Re-enable ValueObservationTests and FailureTestCase with degraded capabilites on non-Dawin platforms missing XCTIssue

Author: marcprux

Tests/GRDBCombineTests/Support.swift

@@ -1,5 +1,6 @@
 #if canImport(Combine)
 import Combine
+#endif
 import Foundation
 import XCTest
 
@@ -99,6 +100,7 @@ final class AsyncTest<Context> {
     }
 }
 
+#if canImport(Combine)
 public func assertNoFailure<Failure>(
     _ completion: Subscribers.Completion<Failure>,
     file: StaticString = #file,

Tests/GRDBTests/FailureTestCase.swift

@@ -1,12 +1,12 @@
 // Inspired by https://github.com/groue/CombineExpectations
 import XCTest
 
-#if canImport(Darwin) // needed for XCTIssue
 /// A XCTestCase subclass that can test its own failures.
 class FailureTestCase: XCTestCase {
     private struct Failure: Hashable {
+        #if canImport(Darwin)
         let issue: XCTIssue
-        
+
         func issue(prefix: String = "") -> XCTIssue {
             if prefix.isEmpty {
                 return issue
@@ -20,24 +20,28 @@ class FailureTestCase: XCTestCase {
                     attachments: issue.attachments)
             }
         }
-        
+
         private var description: String {
             return issue.compactDescription
         }
-        
+
         func hash(into hasher: inout Hasher) {
             hasher.combine(0)
         }
 
         static func == (lhs: Failure, rhs: Failure) -> Bool {
             lhs.description.hasPrefix(rhs.description) || rhs.description.hasPrefix(lhs.description)
         }
+        #endif
     }
 
     private var recordedFailures: [Failure] = []
     private var isRecordingFailures = false
 
-    func assertFailure(_ prefixes: String..., file: StaticString = #file, line: UInt = #line, _ execute: () throws -> Void) rethrows {
+    func assertFailure(_ prefixes: String..., file: StaticString = #file, line: UInt = #line, _ execute: () throws -> Void) throws {
+        #if !canImport(Darwin)
+        throw XCTSkip("XCTIssue unavailable on non-Darwin platforms")
+        #else
         let recordedFailures = try recordingFailures(execute)
         if prefixes.isEmpty {
             if recordedFailures.isEmpty {
@@ -69,22 +73,24 @@ class FailureTestCase: XCTestCase {
                 recordedFailures: recordedFailures,
                 expectedFailures: expectedFailures)
         }
+        #endif
     }
 
     override func setUp() {
         super.setUp()
         isRecordingFailures = false
         recordedFailures = []
     }
-    
+
+    #if canImport(Darwin)
     override func record(_ issue: XCTIssue) {
         if isRecordingFailures {
             recordedFailures.append(Failure(issue: issue))
         } else {
             super.record(issue)
         }
     }
-    
+
     private func recordingFailures(_ execute: () throws -> Void) rethrows -> [Failure] {
         let oldRecordingFailures = isRecordingFailures
         let oldRecordedFailures = recordedFailures
@@ -121,6 +127,7 @@ class FailureTestCase: XCTestCase {
             }
         }
     }
+    #endif
 }
 
 // MARK: - Tests
@@ -129,83 +136,82 @@ class FailureTestCaseTests: FailureTestCase {
     func testEmptyTest() {
     }
 
-    func testExpectedAnyFailure() {
-        assertFailure {
+    func testExpectedAnyFailure() throws {
+        try assertFailure {
             XCTFail("foo")
         }
-        assertFailure {
+        try assertFailure {
             XCTFail("foo")
             XCTFail("bar")
         }
     }
 
-    func testMissingAnyFailure() {
-        assertFailure("No failure did happen") {
-            assertFailure {
+    func testMissingAnyFailure() throws {
+        try assertFailure("No failure did happen") {
+            try assertFailure {
             }
         }
     }
 
-    func testExpectedFailure() {
-        assertFailure("failed - foo") {
+    func testExpectedFailure() throws {
+        try assertFailure("failed - foo") {
             XCTFail("foo")
         }
     }
 
-    func testExpectedFailureMatchesOnPrefix() {
-        assertFailure("failed - foo") {
+    func testExpectedFailureMatchesOnPrefix() throws {
+        try assertFailure("failed - foo") {
             XCTFail("foobarbaz")
         }
     }
 
-    func testOrderOfExpectedFailureIsIgnored() {
-        assertFailure("failed - foo", "failed - bar") {
+    func testOrderOfExpectedFailureIsIgnored() throws {
+        try assertFailure("failed - foo", "failed - bar") {
             XCTFail("foo")
             XCTFail("bar")
         }
-        assertFailure("failed - bar", "failed - foo") {
+        try assertFailure("failed - bar", "failed - foo") {
             XCTFail("foo")
             XCTFail("bar")
         }
     }
 
-    func testExpectedFailureCanBeRepeated() {
-        assertFailure("failed - foo", "failed - foo", "failed - bar") {
+    func testExpectedFailureCanBeRepeated() throws {
+        try assertFailure("failed - foo", "failed - foo", "failed - bar") {
             XCTFail("foo")
             XCTFail("bar")
             XCTFail("foo")
         }
     }
 
-    func testExactNumberOfRepetitionIsRequired() {
-        assertFailure("Failure did not happen: failed - foo") {
-            assertFailure("failed - foo", "failed - foo") {
+    func testExactNumberOfRepetitionIsRequired() throws {
+        try assertFailure("Failure did not happen: failed - foo") {
+            try assertFailure("failed - foo", "failed - foo") {
                 XCTFail("foo")
             }
         }
-        assertFailure("failed - foo") {
-            assertFailure("failed - foo", "failed - foo") {
+        try assertFailure("failed - foo") {
+            try assertFailure("failed - foo", "failed - foo") {
                 XCTFail("foo")
                 XCTFail("foo")
                 XCTFail("foo")
             }
         }
     }
 
-    func testUnexpectedFailure() {
-        assertFailure("Failure did not happen: failed - foo") {
-            assertFailure("failed - foo") {
+    func testUnexpectedFailure() throws {
+        try assertFailure("Failure did not happen: failed - foo") {
+            try assertFailure("failed - foo") {
             }
         }
     }
 
-    func testMissedFailure() {
-        assertFailure("failed - bar") {
-            assertFailure("failed - foo") {
+    func testMissedFailure() throws {
+        try assertFailure("failed - bar") {
+            try assertFailure("failed - foo") {
                 XCTFail("foo")
                 XCTFail("bar")
             }
         }
     }
 }
-#endif

Tests/GRDBTests/FoundationURLTests.swift

@@ -42,7 +42,7 @@ class FoundationURLTests: GRDBTestCase {
         XCTAssertNil(URL.fromDatabaseValue(databaseValue_Null))
         XCTAssertNil(URL.fromDatabaseValue(databaseValue_Int64))
         XCTAssertNil(URL.fromDatabaseValue(databaseValue_Double))
-        XCTAssertEqual(URL.fromDatabaseValue(databaseValue_Blob)!.absoluteString, "bar")
+        XCTAssertEqual(URL.fromDatabaseValue(databaseValue_Blob)?.absoluteString, "bar")
     }
 
 }

Tests/GRDBTests/ValueObservationRecorderTests.swift

@@ -1,7 +1,6 @@
 import Dispatch
 import XCTest
 
-#if canImport(Darwin) // needed for FailureTestCase
 class ValueObservationRecorderTests: FailureTestCase {
     // MARK: - NextOne
 
@@ -782,4 +781,3 @@ class ValueObservationRecorderTests: FailureTestCase {
         }
     }
 }
-#endif

Tests/GRDBTests/ValueObservationTests.swift

@@ -1,11 +1,7 @@
 import XCTest
 import Dispatch
 @testable import GRDB
-#if GRDBCIPHER
-import SQLCipher
-#endif
 
-#if canImport(Darwin)
 class ValueObservationTests: GRDBTestCase {
     // Test passes if it compiles.
     // See <https://github.com/groue/GRDB.swift/issues/1541>
@@ -894,7 +890,8 @@ class ValueObservationTests: GRDBTestCase {
         try test(makeDatabaseQueue())
         try test(makeDatabasePool())
     }
-    
+
+    #if canImport(Darwin) // @MainActor test cases don't compile non-Darwin platforms: "call to main actor-isolated instance method 'test_mainActor_observation()' in a synchronous nonisolated(unsafe) context"
     // MARK: - Main Actor
     @MainActor func test_mainActor_observation() throws {
         let dbQueue = try makeDatabaseQueue()
@@ -928,6 +925,7 @@ class ValueObservationTests: GRDBTestCase {
             wait(for: [expectation], timeout: 2)
         }
     }
+    #endif
 
     // MARK: - Async Await
 
@@ -1357,4 +1355,3 @@ class ValueObservationTests: GRDBTestCase {
                 })
     }
 }
-#endif