Add missing compile checks for XCTExpectFailure in Linux

p4checo · p4checo · commit 44c977714ee7 · 2022-12-13T00:07:34.000Z
diff --git a/Tests/ComposableArchitectureTests/EffectFailureTests.swift b/Tests/ComposableArchitectureTests/EffectFailureTests.swift
@@ -3,51 +3,54 @@ import XCTest
 
 @testable import ComposableArchitecture
 
-@MainActor
-final class EffectFailureTests: XCTestCase {
-  func testTaskUnexpectedThrows() {
-    XCTExpectFailure {
-      Effect<Void, Never>.task {
-        struct Unexpected: Error {}
-        throw Unexpected()
+// `XCTExpectFailure` is not supported on Linux
+#if !os(Linux)
+  @MainActor
+  final class EffectFailureTests: XCTestCase {
+    func testTaskUnexpectedThrows() {
+      XCTExpectFailure {
+        Effect<Void, Never>.task {
+          struct Unexpected: Error {}
+          throw Unexpected()
+        }
+        .producer
+        .start()
+
+        _ = XCTWaiter.wait(for: [.init()], timeout: 0.1)
+      } issueMatcher: {
+        $0.compactDescription == """
+          An 'Effect.task' returned from "ComposableArchitectureTests/EffectFailureTests.swift:10" \
+          threw an unhandled error. …
+
+              EffectFailureTests.Unexpected()
+
+          All non-cancellation errors must be explicitly handled via the 'catch' parameter on \
+          'Effect.task', or via a 'do' block.
+          """
       }
-      .producer
-      .start()
-
-      _ = XCTWaiter.wait(for: [.init()], timeout: 0.1)
-    } issueMatcher: {
-      $0.compactDescription == """
-        An 'Effect.task' returned from "ComposableArchitectureTests/EffectFailureTests.swift:10" \
-        threw an unhandled error. …
-
-            EffectFailureTests.Unexpected()
-
-        All non-cancellation errors must be explicitly handled via the 'catch' parameter on \
-        'Effect.task', or via a 'do' block.
-        """
     }
-  }
 
-  func testRunUnexpectedThrows() {
-    XCTExpectFailure {
-      Effect<Void, Never>.run { _ in
-        struct Unexpected: Error {}
-        throw Unexpected()
+    func testRunUnexpectedThrows() {
+      XCTExpectFailure {
+        Effect<Void, Never>.run { _ in
+          struct Unexpected: Error {}
+          throw Unexpected()
+        }
+        .producer
+        .start()
+
+        _ = XCTWaiter.wait(for: [.init()], timeout: 0.1)
+      } issueMatcher: {
+        $0.compactDescription == """
+          An 'Effect.run' returned from "ComposableArchitectureTests/EffectFailureTests.swift:33" \
+          threw an unhandled error. …
+
+              EffectFailureTests.Unexpected()
+
+          All non-cancellation errors must be explicitly handled via the 'catch' parameter on \
+          'Effect.run', or via a 'do' block.
+          """
       }
-      .producer
-      .start()
-
-      _ = XCTWaiter.wait(for: [.init()], timeout: 0.1)
-    } issueMatcher: {
-      $0.compactDescription == """
-        An 'Effect.run' returned from "ComposableArchitectureTests/EffectFailureTests.swift:33" \
-        threw an unhandled error. …
-
-            EffectFailureTests.Unexpected()
-
-        All non-cancellation errors must be explicitly handled via the 'catch' parameter on \
-        'Effect.run', or via a 'do' block.
-        """
     }
   }
-}
+#endif
diff --git a/Tests/ComposableArchitectureTests/EffectRunTests.swift b/Tests/ComposableArchitectureTests/EffectRunTests.swift
@@ -45,35 +45,38 @@ final class EffectRunTests: XCTestCase {
     await store.receive(.response)
   }
 
-  func testRunUnhandledFailure() async {
-    XCTExpectFailure(nil, enabled: nil, strict: nil) {
-      $0.compactDescription == """
-        An 'Effect.run' returned from "ComposableArchitectureTests/EffectRunTests.swift:62" threw \
-        an unhandled error. …
+  // `XCTExpectFailure` is not supported on Linux
+  #if !os(Linux)
+    func testRunUnhandledFailure() async {
+      XCTExpectFailure(nil, enabled: nil, strict: nil) {
+        $0.compactDescription == """
+          An 'Effect.run' returned from "ComposableArchitectureTests/EffectRunTests.swift:62" threw \
+          an unhandled error. …
 
-            EffectRunTests.Failure()
+              EffectRunTests.Failure()
 
-        All non-cancellation errors must be explicitly handled via the 'catch' parameter on \
-        'Effect.run', or via a 'do' block.
-        """
-    }
-    struct State: Equatable {}
-    enum Action: Equatable { case tapped, response }
-    let reducer = Reducer<State, Action, Void> { state, action, _ in
-      switch action {
-      case .tapped:
-        return .run { send in
-          struct Failure: Error {}
-          throw Failure()
+          All non-cancellation errors must be explicitly handled via the 'catch' parameter on \
+          'Effect.run', or via a 'do' block.
+          """
+      }
+      struct State: Equatable {}
+      enum Action: Equatable { case tapped, response }
+      let reducer = Reducer<State, Action, Void> { state, action, _ in
+        switch action {
+        case .tapped:
+          return .run { send in
+            struct Failure: Error {}
+            throw Failure()
+          }
+        case .response:
+          return .none
         }
-      case .response:
-        return .none
       }
+      let store = TestStore(initialState: State(), reducer: reducer, environment: ())
+      // NB: We wait a long time here because XCTest failures take a long time to generate
+      await store.send(.tapped).finish(timeout: 5 * NSEC_PER_SEC)
     }
-    let store = TestStore(initialState: State(), reducer: reducer, environment: ())
-    // NB: We wait a long time here because XCTest failures take a long time to generate
-    await store.send(.tapped).finish(timeout: 5 * NSEC_PER_SEC)
-  }
+  #endif
 
   func testRunCancellation() async {
     enum CancelID {}
diff --git a/Tests/ComposableArchitectureTests/EffectTaskTests.swift b/Tests/ComposableArchitectureTests/EffectTaskTests.swift
@@ -45,35 +45,38 @@ final class EffectTaskTests: XCTestCase {
     await store.receive(.response)
   }
 
-  func testTaskUnhandledFailure() async {
-    XCTExpectFailure(nil, enabled: nil, strict: nil) {
-      $0.compactDescription == """
-        An 'Effect.task' returned from "ComposableArchitectureTests/EffectTaskTests.swift:62" \
-        threw an unhandled error. …
+  // `XCTExpectFailure` is not supported on Linux
+  #if !os(Linux)
+    func testTaskUnhandledFailure() async {
+      XCTExpectFailure(nil, enabled: nil, strict: nil) {
+        $0.compactDescription == """
+          An 'Effect.task' returned from "ComposableArchitectureTests/EffectTaskTests.swift:62" \
+          threw an unhandled error. …
 
-            EffectTaskTests.Failure()
+              EffectTaskTests.Failure()
 
-        All non-cancellation errors must be explicitly handled via the 'catch' parameter on \
-        'Effect.task', or via a 'do' block.
-        """
-    }
-    struct State: Equatable {}
-    enum Action: Equatable { case tapped, response }
-    let reducer = Reducer<State, Action, Void> { state, action, _ in
-      switch action {
-      case .tapped:
-        return .task {
-          struct Failure: Error {}
-          throw Failure()
+          All non-cancellation errors must be explicitly handled via the 'catch' parameter on \
+          'Effect.task', or via a 'do' block.
+          """
+      }
+      struct State: Equatable {}
+      enum Action: Equatable { case tapped, response }
+      let reducer = Reducer<State, Action, Void> { state, action, _ in
+        switch action {
+        case .tapped:
+          return .task {
+            struct Failure: Error {}
+            throw Failure()
+          }
+        case .response:
+          return .none
         }
-      case .response:
-        return .none
       }
+      let store = TestStore(initialState: State(), reducer: reducer, environment: ())
+      // NB: We wait a long time here because XCTest failures take a long time to generate
+      await store.send(.tapped).finish(timeout: 5 * NSEC_PER_SEC)
     }
-    let store = TestStore(initialState: State(), reducer: reducer, environment: ())
-    // NB: We wait a long time here because XCTest failures take a long time to generate
-    await store.send(.tapped).finish(timeout: 5 * NSEC_PER_SEC)
-  }
+  #endif
 
   func testTaskCancellation() async {
     enum CancelID {}
diff --git a/Tests/ComposableArchitectureTests/TaskResultTests.swift b/Tests/ComposableArchitectureTests/TaskResultTests.swift
@@ -2,75 +2,79 @@ import ComposableArchitecture
 import XCTest
 
 class TaskResultTests: XCTestCase {
-  func testEqualityNonEquatableError() {
-    struct Failure: Error {
-      let message: String
-    }
-
-    XCTExpectFailure {
-      XCTAssertNotEqual(
-        TaskResult<Never>.failure(Failure(message: "Something went wrong")),
-        TaskResult<Never>.failure(Failure(message: "Something went wrong"))
-      )
-    } issueMatcher: {
-      $0.compactDescription == """
-        'Failure' is not equatable. …
-
-        To test two values of this type, it must conform to the 'Equatable' protocol. For example:
 
-            extension Failure: Equatable {}
-
-        See the documentation of 'TaskResult' for more information.
-        """
+  // `XCTExpectFailure` is not supported on Linux
+  #if !os(Linux)
+    func testEqualityNonEquatableError() {
+      struct Failure: Error {
+        let message: String
+      }
+
+      XCTExpectFailure {
+        XCTAssertNotEqual(
+          TaskResult<Never>.failure(Failure(message: "Something went wrong")),
+          TaskResult<Never>.failure(Failure(message: "Something went wrong"))
+        )
+      } issueMatcher: {
+        $0.compactDescription == """
+          'Failure' is not equatable. …
+
+          To test two values of this type, it must conform to the 'Equatable' protocol. For example:
+
+              extension Failure: Equatable {}
+
+          See the documentation of 'TaskResult' for more information.
+          """
+      }
     }
-  }
 
-  func testEqualityMismatchingError() {
-    struct Failure1: Error {
-      let message: String
-    }
-    struct Failure2: Error {
-      let message: String
+    func testEqualityMismatchingError() {
+      struct Failure1: Error {
+        let message: String
+      }
+      struct Failure2: Error {
+        let message: String
+      }
+
+      XCTExpectFailure {
+        XCTAssertNoDifference(
+          TaskResult<Never>.failure(Failure1(message: "Something went wrong")),
+          TaskResult<Never>.failure(Failure2(message: "Something went wrong"))
+        )
+      } issueMatcher: {
+        $0.compactDescription == """
+          XCTAssertNoDifference failed: …
+
+              TaskResult.failure(
+            −   TaskResultTests.Failure1(message: "Something went wrong")
+            +   TaskResultTests.Failure2(message: "Something went wrong")
+              )
+
+          (First: −, Second: +)
+          """
+      }
     }
 
-    XCTExpectFailure {
-      XCTAssertNoDifference(
-        TaskResult<Never>.failure(Failure1(message: "Something went wrong")),
-        TaskResult<Never>.failure(Failure2(message: "Something went wrong"))
-      )
-    } issueMatcher: {
-      $0.compactDescription == """
-        XCTAssertNoDifference failed: …
-
-            TaskResult.failure(
-          −   TaskResultTests.Failure1(message: "Something went wrong")
-          +   TaskResultTests.Failure2(message: "Something went wrong")
-            )
-
-        (First: −, Second: +)
-        """
-    }
-  }
+    func testHashabilityNonHashableError() {
+      struct Failure: Error {
+        let message: String
+      }
 
-  func testHashabilityNonHashableError() {
-    struct Failure: Error {
-      let message: String
-    }
+      XCTExpectFailure {
+        _ = TaskResult<Never>.failure(Failure(message: "Something went wrong")).hashValue
+      } issueMatcher: {
+        $0.compactDescription == """
+          'Failure' is not hashable. …
 
-    XCTExpectFailure {
-      _ = TaskResult<Never>.failure(Failure(message: "Something went wrong")).hashValue
-    } issueMatcher: {
-      $0.compactDescription == """
-        'Failure' is not hashable. …
+          To hash a value of this type, it must conform to the 'Hashable' protocol. For example:
 
-        To hash a value of this type, it must conform to the 'Hashable' protocol. For example:
+              extension Failure: Hashable {}
 
-            extension Failure: Hashable {}
-
-        See the documentation of 'TaskResult' for more information.
-        """
+          See the documentation of 'TaskResult' for more information.
+          """
+      }
     }
-  }
+  #endif
 
   func testEquality_EquatableError() {
     enum Failure: Error, Equatable {
diff --git a/Tests/ComposableArchitectureTests/TestStoreTests.swift b/Tests/ComposableArchitectureTests/TestStoreTests.swift
