Run swift-format

Author: stephencelis

Tests/ComposableArchitectureTests/EffectTests.swift

@@ -50,7 +50,7 @@ final class EffectTests: XCTestCase {
       .store(in: &self.cancellables)
   }
 
-#if canImport(RoomPlan) || (!canImport(Darwin) && swift(>=5.7))
+  #if canImport(RoomPlan) || (!canImport(Darwin) && swift(>=5.7))
     func testConcatenate() async {
       if #available(iOS 16, macOS 13, tvOS 16, watchOS 9, *) {
         let clock = TestClock()
@@ -102,35 +102,35 @@ final class EffectTests: XCTestCase {
     XCTAssertEqual(values, [1])
   }
 
-#if canImport(RoomPlan) || (!canImport(Darwin) && swift(>=5.7))
-  func testMerge() async {
-    if #available(iOS 16, macOS 13, tvOS 16, watchOS 9, *) {
-      let clock = TestClock()
+  #if canImport(RoomPlan) || (!canImport(Darwin) && swift(>=5.7))
+    func testMerge() async {
+      if #available(iOS 16, macOS 13, tvOS 16, watchOS 9, *) {
+        let clock = TestClock()
 
-      let effect = Effect<Int, Never>.merge(
-        (1...3).map { count in
-          .task {
-            try await clock.sleep(for: .seconds(count))
-            return count
+        let effect = Effect<Int, Never>.merge(
+          (1...3).map { count in
+            .task {
+              try await clock.sleep(for: .seconds(count))
+              return count
+            }
           }
-        }
-      )
+        )
 
-      var values: [Int] = []
-      effect.sink(receiveValue: { values.append($0) }).store(in: &self.cancellables)
+        var values: [Int] = []
+        effect.sink(receiveValue: { values.append($0) }).store(in: &self.cancellables)
 
-      XCTAssertEqual(values, [])
+        XCTAssertEqual(values, [])
 
-      await clock.advance(by: .seconds(1))
-      XCTAssertEqual(values, [1])
+        await clock.advance(by: .seconds(1))
+        XCTAssertEqual(values, [1])
 
-      await clock.advance(by: .seconds(1))
-      XCTAssertEqual(values, [1, 2])
+        await clock.advance(by: .seconds(1))
+        XCTAssertEqual(values, [1, 2])
 
-      await clock.advance(by: .seconds(1))
-      XCTAssertEqual(values, [1, 2, 3])
+        await clock.advance(by: .seconds(1))
+        XCTAssertEqual(values, [1, 2, 3])
+      }
     }
-  }
   #endif
 
   func testEffectSubscriberInitializer() {

Tests/ComposableArchitectureTests/ReducerTests.swift

@@ -19,60 +19,60 @@ final class ReducerTests: XCTestCase {
     XCTAssertEqual(state, 1)
   }
 
-#if canImport(RoomPlan) || (!canImport(Darwin) && swift(>=5.7))
-  func testCombine_EffectsAreMerged() async throws {
-    if #available(iOS 16, macOS 13, tvOS 16, watchOS 9, *) {
-      enum Action: Equatable {
-        case increment
-      }
+  #if canImport(RoomPlan) || (!canImport(Darwin) && swift(>=5.7))
+    func testCombine_EffectsAreMerged() async throws {
+      if #available(iOS 16, macOS 13, tvOS 16, watchOS 9, *) {
+        enum Action: Equatable {
+          case increment
+        }
 
-      struct Delayed: ReducerProtocol {
-        typealias State = Int
+        struct Delayed: ReducerProtocol {
+          typealias State = Int
 
-        @Dependency(\.continuousClock) var clock
+          @Dependency(\.continuousClock) var clock
 
-        let delay: Duration
-        let setValue: @Sendable () async -> Void
+          let delay: Duration
+          let setValue: @Sendable () async -> Void
 
-        func reduce(into state: inout State, action: Action) -> EffectTask<Action> {
-          state += 1
-          return .fireAndForget {
-            try await self.clock.sleep(for: self.delay)
-            await self.setValue()
+          func reduce(into state: inout State, action: Action) -> EffectTask<Action> {
+            state += 1
+            return .fireAndForget {
+              try await self.clock.sleep(for: self.delay)
+              await self.setValue()
+            }
           }
         }
-      }
 
-      var fastValue: Int? = nil
-      var slowValue: Int? = nil
+        var fastValue: Int? = nil
+        var slowValue: Int? = nil
 
-      let store = TestStore(
-        initialState: 0,
-        reducer: CombineReducers {
-          Delayed(delay: .seconds(1), setValue: { @MainActor in fastValue = 42 })
-          Delayed(delay: .seconds(2), setValue: { @MainActor in slowValue = 1729 })
-        }
-      )
+        let store = TestStore(
+          initialState: 0,
+          reducer: CombineReducers {
+            Delayed(delay: .seconds(1), setValue: { @MainActor in fastValue = 42 })
+            Delayed(delay: .seconds(2), setValue: { @MainActor in slowValue = 1729 })
+          }
+        )
 
-      let clock = TestClock()
-      store.dependencies.continuousClock = clock
+        let clock = TestClock()
+        store.dependencies.continuousClock = clock
 
-      await store.send(.increment) {
-        $0 = 2
+        await store.send(.increment) {
+          $0 = 2
+        }
+        // Waiting a second causes the fast effect to fire.
+        await clock.advance(by: .seconds(1))
+        try await Task.sleep(nanoseconds: NSEC_PER_SEC / 3)
+        XCTAssertEqual(fastValue, 42)
+        XCTAssertEqual(slowValue, nil)
+        // Waiting one more second causes the slow effect to fire. This proves that the effects
+        // are merged together, as opposed to concatenated.
+        await clock.advance(by: .seconds(1))
+        await store.finish()
+        XCTAssertEqual(fastValue, 42)
+        XCTAssertEqual(slowValue, 1729)
       }
-      // Waiting a second causes the fast effect to fire.
-      await clock.advance(by: .seconds(1))
-      try await Task.sleep(nanoseconds: NSEC_PER_SEC / 3)
-      XCTAssertEqual(fastValue, 42)
-      XCTAssertEqual(slowValue, nil)
-      // Waiting one more second causes the slow effect to fire. This proves that the effects
-      // are merged together, as opposed to concatenated.
-      await clock.advance(by: .seconds(1))
-      await store.finish()
-      XCTAssertEqual(fastValue, 42)
-      XCTAssertEqual(slowValue, 1729)
     }
-  }
   #endif
 
   func testCombine() async {