diff --git a/concepts/for-loops/.meta/config.json b/concepts/for-loops/.meta/config.json
index d5cb6a257..1d255acef 100644
--- a/concepts/for-loops/.meta/config.json
+++ b/concepts/for-loops/.meta/config.json
@@ -1,7 +1,8 @@
 {
   "blurb": "For loops can be used to iterate over a sequence of values.",
   "authors": [
-    "wneumann"
+    "wneumann",
+    "meatball133"
   ],
   "contributors": []
 }
diff --git a/concepts/for-loops/about.md b/concepts/for-loops/about.md
index 32c347589..7a3685622 100644
--- a/concepts/for-loops/about.md
+++ b/concepts/for-loops/about.md
@@ -1,84 +1,121 @@
-# About
+# For loops
 
-[For-in loops][for-in-loops] are used to iterate over a sequence of values, taking each element in turn, binding it to a variable or constant name of the developer's choosing, then executes a block of code that may refer to the element. When every element of the sequence has been iterated over, the loop exits and execution begins with the first line following the body of the loop.
+Looping is a fundamental concept in programming that allows you to execute a block of code multiple times.
+In Swift, there are two types of loops: [`for-in` loops][for-loops] and `while` loops. 
+In this chapter, you'll learn about `for-in` loops.
+
+For loops allows you to iterate over a sequence of values, taking each element in turn, and binding it to a variable of your choosing.
+Swift allows you to iterate over a variety of sequences, such as ranges, arrays, and strings (and more types which will be covered later).
+When every element of the sequence has been iterated over, the loop exits.
+
+For loops are declared by using the `for` keyword, followed by a variable name, the `in` keyword, and a sequence of values to iterate over.
+The variable given in the `for-in` loop is inmutable, meaning you can't change its value inside the loop.
+Here's an example of a `for-in` loop that iterates over an array of numbers:
 
 ```swift
 let numbers = [3, 10, 7, 11]
-let word = "Supercalifragilisticexpialidocious"
 
 for number in numbers {
-  print("\(number) / 2 = \(number / 2)")
+  print(number)
 }
 print("Done with numbers")
 
 // prints:
-// 3 / 2 = 1
-// 10 / 2 = 5
-// 7 / 2 = 3
-// 11 / 2 = 5
+// 3
+// 10
+// 7
+// 11
 // Done with numbers
+```
 
+~~~~exercism/note
+The `number` variable is declared in the `for-in` loop and is only available within the loop's scope.
 
-for char in word {
-  if "aeiou".contains(char) {
-    print(char, terminator: "")
-  }
-}
-print(" - those are all the vowels")
-
-// prints:
-// ueaiaiiieiaioiou - those are all the vowels
+```swift
+let numbers = [3, 10, 7, 11]
 
+for number in numbers {
+    number + 1
+}
+number + 1
+// Error: Use of unresolved identifier 'number'
 ```
+~~~~
+
+## Iterating over a range
 
-If one needs to mutate the current element of the iteration, it can be declared as a variable in the for-in loop:
+You can also iterate over a range of numbers using a `for-in` loop.
+This allows you to execute a block of code a specific number of times, for example, the range `1...5` will iterate over the numbers 1, 2, 3, 4, and 5, so the loop will execute 5 times.
+Sometimes you might want to iterate over indexes, in a datastructure like an array, then you can use a `0..<array.count` range.
 
 ```swift
-for var x in [123, 900, 7] {
-  while x > 0 {
-    print(x % 10)
-    x /= 10
-  }
-  print()
+let numbers = [3, 10, 7, 11]
+
+for i in 0..<numbers.count {
+  print(numbers[i])
 }
 
 // prints:
 // 3
-// 2
-// 1
-//
-// 0
-// 0
-// 9
-//
+// 10
 // 7
+// 11
 ```
 
-If one wants to execute a loop a specified number of times, a for-in loop can be used with a range supplied for the sequence to iterate over:
+## Iterating over a string
+
+You can also iterate over a string using a `for-in` loop.
+This allows you to iterate over each character in the string, and note specifically that the type given in the loop is a `Character`.
 
 ```swift
-for i in 1...3 {
-  print("i: \(i)")
+let message = "Hello!"
+
+for character in message {
+  print(character)
 }
 
 // prints:
-// i: 1
-// i: 2
-// i: 3
+// H
+// e
+// l
+// l
+// o
+// !
 ```
 
-If the body of the loop doesn't refer to the current element of the sequence, an underscore (`_`) can be supplied for the name:
+## Unusued variables
+
+If you don't need the value of the variable in the loop, you can use an underscore `_` to ignore it.
 
 ```swift
-for _ in 1...3 {
-	  print("Perhaps.")
+let numbers = [3, 10, 7, 11]
+
+for _ in numbers {
+  print("Hello!")
 }
+```
 
-// prints:
-// Perhaps.
-// Perhaps.
-// Perhaps.
+## stride
 
+Swift also provides a `stride` function that allows you to create a sequence over a range with a specific step.
+Which can be then iterated over using a `for-in` loop.
+`stride` is defined as [`stride(from:to:by:)`][stride-to] or [`stride(from:through:by:)`][stride-through], the first one is exclusive and the second one is inclusive.
+
+```swift
+for i in stride(from: 0, to: 10, by: 2) {
+  print(i)
+}
+
+// prints:
+// 0
+// 2
+// 4
+// 6
+// 8
 ```
 
-[for-in-loops]: https://docs.swift.org/swift-book/LanguageGuide/ControlFlow.html#ID121
+Note that the `to` parameter is exclusive, so the loop will iterate until the number before the `to` parameter, while the `through` parameter is inclusive, so in this case it would also include the `10`.
+
+[stride-to]: https://developer.apple.com/documentation/swift/stride(from:to:by:)
+[stride-through]: https://developer.apple.com/documentation/swift/stride(from:through:by:)
+[for-loops]: https://docs.swift.org/swift-book/documentation/the-swift-programming-language/controlflow/#For-In-Loops
diff --git a/concepts/for-loops/introduction.md b/concepts/for-loops/introduction.md
index ae5ec52b9..7038a6730 100644
--- a/concepts/for-loops/introduction.md
+++ b/concepts/for-loops/introduction.md
@@ -1,19 +1,109 @@
-# Introduction
+# For loops
 
-For-in loops are used to iterate over a sequence of values, taking each element in turn, binding it to a variable or constant name of the developer's choosing, then executes a block of code that may refer to the element. When every element of the sequence has been iterated over, the loop exits and execution begins with the first line following the body of the loop.
+Looping is a fundamental concept in programming that allows you to execute a block of code multiple times.
+In Swift, there are two types of loops: [`for-in` loops][for-loops] and `while` loops. 
+In this chapter, you'll learn about `for-in` loops.
+
+For loops allows you to iterate over a sequence of values, taking each element in turn, binding it to a variable of your choosing.
+Swift allows you to iterate over a variety of sequences, such as ranges, arrays, and strings (and more types which will be covered later).
+When every element of the sequence has been iterated over, the loop exits.
+
+For loops are declared by using the `for` keyword, followed by a variable name, the `in` keyword, and a sequence of values to iterate over.
+The variable given in the `for-in` loop is inmutable, meaning you can't change its value inside the loop.
+Here's an example of a `for-in` loop that iterates over an array of numbers:
 
 ```swift
 let numbers = [3, 10, 7, 11]
 
 for number in numbers {
-  print("\(number) / 2 = \(number / 2)")
+  print(number)
 }
 print("Done with numbers")
 
 // prints:
-// 3 / 2 = 1
-// 10 / 2 = 5
-// 7 / 2 = 3
-// 11 / 2 = 5
+// 3
+// 10
+// 7
+// 11
 // Done with numbers
 ```
+
+~~~~exercism/note
+The `number` variable is declared in the `for-in` loop and is only available within the loop's scope.
+
+```swift
+let numbers = [3, 10, 7, 11]
+
+for number in numbers {
+    number + 1
+}
+number + 1
+// Error: Use of unresolved identifier 'number'
+```
+~~~~
+
+## Iterating over a range
+
+You can also iterate over a range of numbers using a `for-in` loop.
+This allows you to execute a block of code a specific number of times, for example, the range `1...5` will iterate over the numbers 1, 2, 3, 4, and 5, so the loop will execute 5 times.
+Sometimes you might want to iterate over indexes, in a datastructure like an array, then you can use a `0..<array.count` range.
+
+```swift
+let numbers = [3, 10, 7, 11]
+
+for i in 0..<numbers.count {
+  print(numbers[i])
+}
+
+// prints:
+// 3
+// 10
+// 7
+// 11
+```
+
+## Iterating over a string
+
+You can also iterate over a string using a `for-in` loop.
+This allows you to iterate over each character in the string, and note specifically that the type given in the loop is a `Character`.
+
+```swift
+let message = "Hello!"
+
+for character in message {
+  print(character)
+}
+
+// prints:
+// H
+// e
+// l
+// l
+// o
+// !
+```
+
+## stride
+
+Swift also provides a `stride` function that allows you to create a sequence over a range with a specific step.
+Which can be then iterated over using a `for-in` loop.
+`stride` is defined as [`stride(from:to:by:)`][stride-to] or [`stride(from:through:by:)`][stride-through], the first one is exclusive and the second one is inclusive.
+
+```swift
+for i in stride(from: 0, to: 10, by: 2) {
+  print(i)
+}
+
+// prints:
+// 0
+// 2
+// 4
+// 6
+// 8
+```
+
+Note that the `to` parameter is exclusive, so the loop will iterate until the number before the `to` parameter, while the `through` parameter is inclusive, so in this case it would also include the `10`.
+
+[stride-to]: https://developer.apple.com/documentation/swift/stride(from:to:by:)
+[stride-through]: https://developer.apple.com/documentation/swift/stride(from:through:by:)
+[for-loops]: https://docs.swift.org/swift-book/documentation/the-swift-programming-language/controlflow/#For-In-Loops
diff --git a/concepts/for-loops/links.json b/concepts/for-loops/links.json
index fe51488c7..72ab65f1d 100644
--- a/concepts/for-loops/links.json
+++ b/concepts/for-loops/links.json
@@ -1 +1,11 @@
-[]
+[
+    {
+      "url": "https://docs.swift.org/swift-book/documentation/the-swift-programming-language/controlflow/#For-In-Loops",
+      "description": "Swift Book: For-In Loops"
+    },
+    {
+      "url": "https://developer.apple.com/documentation/swift/stride(from:through:by:)",
+      "description": "Swift docs: stride"
+    }
+  ]
+  
\ No newline at end of file
diff --git a/config.json b/config.json
index ec20ac8b0..404a99369 100644
--- a/config.json
+++ b/config.json
@@ -131,6 +131,18 @@
         ],
         "status": "active"
       },
+      {
+        "slug": "bird-watcher",
+        "name": "Bird Watcher",
+        "uuid": "a5efd630-8e6f-49f7-bed5-1576138d2f8a",
+        "concepts": [
+          "for-loops"
+        ],
+        "prerequisites": [
+          "ranges"
+        ],
+        "status": "active"
+      },
       {
         "slug": "santas-helper",
         "name": "Santa's Swifty Helper",
@@ -139,7 +151,8 @@
           "tuples"
         ],
         "prerequisites": [
-          "arrays"
+          "arrays",
+          "for-loops"
         ],
         "status": "active"
       },
@@ -168,7 +181,8 @@
         "prerequisites": [
           "arrays",
           "optionals",
-          "tuples"
+          "tuples",
+          "for-loops"
         ],
         "status": "active"
       },
diff --git a/exercises/concept/bird-watcher/.docs/hints.md b/exercises/concept/bird-watcher/.docs/hints.md
new file mode 100644
index 000000000..dcde6ddc3
--- /dev/null
+++ b/exercises/concept/bird-watcher/.docs/hints.md
@@ -0,0 +1,21 @@
+# Hints
+
+## 1. Determine the total number of birds that you counted so far
+
+- Refer to the exercise introduction for an example how to use a for loop to iterate over a slice.
+- Use a helper variable to store the total count and increase that variable as you go through the slice.
+- Think about the correct initial value for that helper variable.
+
+## 2. Calculate the number of visiting birds in a specific week
+
+- This task is similar to the first one, you can copy your code as a starting point.
+- Think about which indexes in the slice you would need to take into account for week number 1 and 2, respectively.
+- Now find a general way to calculate the first and the last index that should be considered.
+- With that you can set up the for loop to only iterate over the relevant section of the slice.
+
+## 3. Fix a counting mistake
+
+- Again you need to set up a for loop to iterate over the whole bird count slice.
+- This time you only need to visit every second entry in the slice.
+- Change the step so the counter variable is increased accordingly after each iteration.
+- In the body of the for loop you can use the increment operator to change the value of an element in a slice in-place.
diff --git a/exercises/concept/bird-watcher/.docs/instructions.md b/exercises/concept/bird-watcher/.docs/instructions.md
new file mode 100644
index 000000000..f2f754a5b
--- /dev/null
+++ b/exercises/concept/bird-watcher/.docs/instructions.md
@@ -0,0 +1,51 @@
+# Instructions
+
+You are an avid bird watcher that keeps track of how many birds have visited your garden.
+Usually you use a tally in a notebook to count the birds, but to better work with your data, you've digitalized the bird counts for the past weeks.
+
+## 1. Determine the total number of birds that you counted so far
+
+Let us start analyzing the data by getting a high level view.
+Find out how many birds you counted in total since you started your logs.
+
+Implement a function `totalBirdCount` that accepts an array of `Int`s that contains the bird count per day.
+It should return the total number of birds that you counted.
+
+```swift
+let birdsPerDay = [2, 5, 0, 7, 4, 1, 3, 0, 2, 5, 0, 1, 3, 1]
+totalBirdCount(birdsPerDay)
+// Returns 34
+```
+
+## 2. Calculate the number of visiting birds in a specific week
+
+Now that you got a general feel for your bird count numbers, you want to make a more fine-grained analysis.
+
+Implement a function `birdsInWeek` that accepts an array of bird counts per day and a week number.
+
+It returns the total number of birds that you counted in that specific week.
+You can assume weeks are always tracked completely.
+
+```swift
+let birdsPerDay = [2, 5, 0, 7, 4, 1, 3, 0, 2, 5, 0, 1, 3, 1]
+birdsInWeek(birdsPerDay, weekNumber: 2)
+// Returns 12
+```
+
+## 3. Fix a counting mistake
+
+You realized that all the time you were trying to keep track of the birds, there was one bird that was hiding in a far corner of the garden.
+
+You figured out that this bird always spent every second day in your garden.
+
+You do not know exactly where it was in between those days but definitely not in your garden.
+
+Your bird watcher intuition also tells you that the bird was in your garden on the first day that you tracked in your list.
+
+Given this new information, write a function `fixBirdCountLog` that takes an array of birds counted per day as an argument and returns the array after correcting the counting mistake.
+
+```swift
+var birdsPerDay = [2, 5, 0, 7, 4, 1]
+fixBirdCountLog(birdsPerDay)
+// Returns [3, 5, 1, 7, 5, 1]
+```
diff --git a/exercises/concept/bird-watcher/.docs/introduction.md b/exercises/concept/bird-watcher/.docs/introduction.md
new file mode 100644
index 000000000..7038a6730
--- /dev/null
+++ b/exercises/concept/bird-watcher/.docs/introduction.md
@@ -0,0 +1,109 @@
+# For loops
+
+Looping is a fundamental concept in programming that allows you to execute a block of code multiple times.
+In Swift, there are two types of loops: [`for-in` loops][for-loops] and `while` loops. 
+In this chapter, you'll learn about `for-in` loops.
+
+For loops allows you to iterate over a sequence of values, taking each element in turn, binding it to a variable of your choosing.
+Swift allows you to iterate over a variety of sequences, such as ranges, arrays, and strings (and more types which will be covered later).
+When every element of the sequence has been iterated over, the loop exits.
+
+For loops are declared by using the `for` keyword, followed by a variable name, the `in` keyword, and a sequence of values to iterate over.
+The variable given in the `for-in` loop is inmutable, meaning you can't change its value inside the loop.
+Here's an example of a `for-in` loop that iterates over an array of numbers:
+
+```swift
+let numbers = [3, 10, 7, 11]
+
+for number in numbers {
+  print(number)
+}
+print("Done with numbers")
+
+// prints:
+// 3
+// 10
+// 7
+// 11
+// Done with numbers
+```
+
+~~~~exercism/note
+The `number` variable is declared in the `for-in` loop and is only available within the loop's scope.
+
+```swift
+let numbers = [3, 10, 7, 11]
+
+for number in numbers {
+    number + 1
+}
+number + 1
+// Error: Use of unresolved identifier 'number'
+```
+~~~~
+
+## Iterating over a range
+
+You can also iterate over a range of numbers using a `for-in` loop.
+This allows you to execute a block of code a specific number of times, for example, the range `1...5` will iterate over the numbers 1, 2, 3, 4, and 5, so the loop will execute 5 times.
+Sometimes you might want to iterate over indexes, in a datastructure like an array, then you can use a `0..<array.count` range.
+
+```swift
+let numbers = [3, 10, 7, 11]
+
+for i in 0..<numbers.count {
+  print(numbers[i])
+}
+
+// prints:
+// 3
+// 10
+// 7
+// 11
+```
+
+## Iterating over a string
+
+You can also iterate over a string using a `for-in` loop.
+This allows you to iterate over each character in the string, and note specifically that the type given in the loop is a `Character`.
+
+```swift
+let message = "Hello!"
+
+for character in message {
+  print(character)
+}
+
+// prints:
+// H
+// e
+// l
+// l
+// o
+// !
+```
+
+## stride
+
+Swift also provides a `stride` function that allows you to create a sequence over a range with a specific step.
+Which can be then iterated over using a `for-in` loop.
+`stride` is defined as [`stride(from:to:by:)`][stride-to] or [`stride(from:through:by:)`][stride-through], the first one is exclusive and the second one is inclusive.
+
+```swift
+for i in stride(from: 0, to: 10, by: 2) {
+  print(i)
+}
+
+// prints:
+// 0
+// 2
+// 4
+// 6
+// 8
+```
+
+Note that the `to` parameter is exclusive, so the loop will iterate until the number before the `to` parameter, while the `through` parameter is inclusive, so in this case it would also include the `10`.
+
+[stride-to]: https://developer.apple.com/documentation/swift/stride(from:to:by:)
+[stride-through]: https://developer.apple.com/documentation/swift/stride(from:through:by:)
+[for-loops]: https://docs.swift.org/swift-book/documentation/the-swift-programming-language/controlflow/#For-In-Loops
diff --git a/exercises/concept/bird-watcher/.gitignore b/exercises/concept/bird-watcher/.gitignore
new file mode 100644
index 000000000..95c432091
--- /dev/null
+++ b/exercises/concept/bird-watcher/.gitignore
@@ -0,0 +1,5 @@
+.DS_Store
+/.build
+/Packages
+/*.xcodeproj
+xcuserdata/
diff --git a/exercises/concept/bird-watcher/.meta/Sources/BirdWatcher/BirdWatcherExemplar.swift b/exercises/concept/bird-watcher/.meta/Sources/BirdWatcher/BirdWatcherExemplar.swift
new file mode 100644
index 000000000..9b1f4ca9c
--- /dev/null
+++ b/exercises/concept/bird-watcher/.meta/Sources/BirdWatcher/BirdWatcherExemplar.swift
@@ -0,0 +1,25 @@
+func totalBirdCount(_ birdsPerDay: [Int]) -> Int {
+  var count = 0
+  for day in birdsPerDay {
+    count += day
+  }
+  return count
+}
+
+func birdsInWeek(_ birdsPerDay: [Int], weekNumber: Int) -> Int {
+  var count = 0
+  let startOfWeek = (weekNumber - 1) * 7
+  let endOfWeek = startOfWeek + 7
+  for i in startOfWeek..<endOfWeek {
+    count += birdsPerDay[i]
+  }
+  return count
+}
+
+func fixBirdCountLog(_ birdsPerDay: [Int]) -> [Int] {
+  var result = [Int](birdsPerDay)
+  for i in stride(from: 0, through: birdsPerDay.count - 1, by: 2) {
+    result[i] += 1
+  }
+  return result
+}
\ No newline at end of file
diff --git a/exercises/concept/bird-watcher/.meta/config.json b/exercises/concept/bird-watcher/.meta/config.json
new file mode 100644
index 000000000..bcf1eff1b
--- /dev/null
+++ b/exercises/concept/bird-watcher/.meta/config.json
@@ -0,0 +1,20 @@
+{
+  "authors": [
+    "meatball133"
+  ],
+  "files": {
+    "solution": [
+      "Sources/BirdWatcher/BirdWatcher.swift"
+    ],
+    "test": [
+      "Tests/BirdWatcherTests/BirdWatcherTests.swift"
+    ],
+    "exemplar": [
+      ".meta/Sources/BirdWatcher/BirdWatcherExemplar.swift"
+    ]
+  },
+  "forked_from": [
+    "go/bird-watcher"
+  ],
+  "blurb": "Count the birds in your garden with for loops."
+}
diff --git a/exercises/concept/bird-watcher/.meta/design.md b/exercises/concept/bird-watcher/.meta/design.md
new file mode 100644
index 000000000..07f490d2f
--- /dev/null
+++ b/exercises/concept/bird-watcher/.meta/design.md
@@ -0,0 +1,31 @@
+# Design
+
+This concept exercise should convey a basic understanding of how to work with closures in Swift.
+
+## Learning objectives
+
+- Defining closures
+- Assigning closures to names
+- Capturing the environment
+- Shorthand argument names
+- Trailing closure syntax
+
+## Out of scope
+
+- Capture lists
+- Weak/Unowned
+- Escaping closures
+- Autoclosures
+
+## Concepts
+
+- `closures`: Know how to define closures; know how to assign closures to names
+- `capturing`: know about environment capture
+- `trailing-closures`: know about trailing closure syntax
+- `shorthand-arguments`: know about shorthand closure syntax
+
+## Prerequisites
+
+- `functions`
+- `higher-order-functions`
+- `loops`
diff --git a/exercises/concept/bird-watcher/Package.swift b/exercises/concept/bird-watcher/Package.swift
new file mode 100644
index 000000000..25472ce29
--- /dev/null
+++ b/exercises/concept/bird-watcher/Package.swift
@@ -0,0 +1,28 @@
+// swift-tools-version:6.0
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+  name: "BirdWatcher",
+  products: [
+    // Products define the executables and libraries a package produces, and make them visible to other packages.
+    .library(
+      name: "BirdWatcher",
+      targets: ["BirdWatcher"])
+  ],
+  dependencies: [
+    // Dependencies declare other packages that this package depends on.
+    // .package(url: /* package url */, from: "1.0.0"),
+  ],
+  targets: [
+    // Targets are the basic building blocks of a package. A target can define a module or a test suite.
+    // Targets can depend on other targets in this package, and on products in packages this package depends on.
+    .target(
+      name: "BirdWatcher",
+      dependencies: []),
+    .testTarget(
+      name: "BirdWatcherTests",
+      dependencies: ["BirdWatcher"]),
+  ]
+)
diff --git a/exercises/concept/bird-watcher/Sources/BirdWatcher/BirdWatcher.swift b/exercises/concept/bird-watcher/Sources/BirdWatcher/BirdWatcher.swift
new file mode 100644
index 000000000..e84c68d84
--- /dev/null
+++ b/exercises/concept/bird-watcher/Sources/BirdWatcher/BirdWatcher.swift
@@ -0,0 +1,11 @@
+func totalBirdCount(_ birdsPerDay: [Int]) -> Int {
+  fatalError("Please implement the totalBirdCount(_:) function")
+}
+
+func birdsInWeek(_ birdsPerDay: [Int], weekNumber: Int) -> Int {
+  fatalError("Please implement the birdsInWeek(_:weekNumber:) function")
+}
+
+func fixBirdCountLog(_ birdsPerDay: [Int]) -> [Int] {
+  fatalError("Please implement the birdsInWeek(_:) function")
+}
diff --git a/exercises/concept/bird-watcher/Tests/BirdWatcherTests/BirdWatcherTests.swift b/exercises/concept/bird-watcher/Tests/BirdWatcherTests/BirdWatcherTests.swift
new file mode 100644
index 000000000..aa2b68f08
--- /dev/null
+++ b/exercises/concept/bird-watcher/Tests/BirdWatcherTests/BirdWatcherTests.swift
@@ -0,0 +1,82 @@
+import Foundation
+import Testing
+
+@testable import BirdWatcher
+
+let RUNALL = Bool(ProcessInfo.processInfo.environment["RUNALL", default: "false"]) ?? false
+
+@Suite struct BirdWatcherTests {
+  @Test("calculates the correct total number of birds")
+  func testTotalBirdCount() {
+    let birdCount = [9, 0, 8, 4, 5, 1, 3]
+    let expected = 30
+    #expect(totalBirdCount(birdCount) == expected)
+  }
+
+  @Test("works for a short bird count list", .enabled(if: RUNALL))
+  func testTotalBirdCountShort() {
+    let birdCount = [2]
+    let expected = 2
+    #expect(totalBirdCount(birdCount) == expected)
+  }
+
+  @Test("works for a long bird count list", .enabled(if: RUNALL))
+  func testTotalBirdCountLong() {
+    let birdCount = [2, 8, 4, 1, 3, 5, 0, 4, 1, 6, 0, 3, 0, 1, 5, 4, 1, 1, 2, 6]
+    let expected = 57
+    #expect(totalBirdCount(birdCount) == expected)
+  }
+
+  @Test("calculates the number of birds in the first week", .enabled(if: RUNALL))
+  func testBirdsInFirstWeek() {
+    let birdCount = [3, 0, 5, 1, 0, 4, 1, 0, 3, 4, 3, 0, 8, 0]
+    let weekNumber = 1
+    let expected = 14
+    #expect(birdsInWeek(birdCount, weekNumber: weekNumber) == expected)
+  }
+
+  @Test("calculates the number of birds for a week in the middle of the log", .enabled(if: RUNALL))
+  func testBirdsInMiddleWeek() {
+    let birdCount = [4, 7, 3, 2, 1, 1, 2, 0, 2, 3, 2, 7, 1, 3, 0, 6, 5, 3, 7, 2, 3]
+    let weekNumber = 2
+    let expected = 18
+    #expect(birdsInWeek(birdCount, weekNumber: weekNumber) == expected)
+  }
+
+  @Test("calculates the number of birds for a week in the end of the log", .enabled(if: RUNALL))
+  func testBirdsInLastWeek() {
+    let birdCount = [4, 7, 3, 2, 1, 1, 2, 0, 2, 3, 2, 7, 1, 3, 0, 6, 5, 3, 7, 2, 3]
+    let weekNumber = 3
+    let expected = 26
+    #expect(birdsInWeek(birdCount, weekNumber: weekNumber) == expected)
+  }
+
+  @Test("works when there is only one week", .enabled(if: RUNALL))
+  func testBirdsInOneWeek() {
+    let birdCount = [3, 0, 3, 3, 2, 1, 0]
+    let weekNumber = 1
+    let expected = 12
+    #expect(birdsInWeek(birdCount, weekNumber: weekNumber) == expected)
+  }
+
+  @Test("returns a bird count list with the corrected values", .enabled(if: RUNALL))
+  func testFixBirdCountLog() {
+    var birdCount = [3, 0, 5, 1, 0, 4, 1, 0, 3, 4, 3, 0]
+    let expected = [4, 0, 6, 1, 1, 4, 2, 0, 4, 4, 4, 0]
+    #expect(fixBirdCountLog(birdCount) == expected)
+  }
+
+  @Test("works for a short bird count list", .enabled(if: RUNALL))
+  func testFixBirdCountLogShort() {
+    var birdCount = [4, 2]
+    let expected = [5, 2]
+    #expect(fixBirdCountLog(birdCount) == expected)
+  }
+
+  @Test("works for a long bird count list", .enabled(if: RUNALL))
+  func testFixBirdCountLogLong() {
+    var birdCount = [2, 8, 4, 1, 3, 5, 0, 4, 1, 6, 0, 3, 0, 1, 5, 4, 1, 1, 2, 6]
+    let expected = [3, 8, 5, 1, 4, 5, 1, 4, 2, 6, 1, 3, 1, 1, 6, 4, 2, 1, 3, 6]
+    #expect(fixBirdCountLog(birdCount) == expected)
+  }
+}