From 7ccad4492ab7396d28e15c0eee13d18a8ef1712e Mon Sep 17 00:00:00 2001 From: Rachel Brindle Date: Sun, 13 Oct 2024 22:05:29 -0700 Subject: [PATCH] Fix the current set of concurrency warnings in tests --- .../NimbleTests/AsyncAwaitTest+Require.swift | 80 +++++++-------- Tests/NimbleTests/AsyncAwaitTest.swift | 88 ++++++++--------- .../ContainElementSatisfyingTest.swift | 12 ++- Tests/NimbleTests/Matchers/ContainTest.swift | 9 +- Tests/NimbleTests/Matchers/MapTest.swift | 6 +- .../Matchers/PostNotificationTest.swift | 28 +++--- .../Matchers/SatisfyAllOfTest.swift | 12 ++- .../Matchers/SatisfyAnyOfTest.swift | 10 +- .../Matchers/ThrowAssertionTest.swift | 20 ++-- .../NimbleTests/Matchers/ThrowErrorTest.swift | 2 +- Tests/NimbleTests/PollingTest+Require.swift | 98 +++++++++---------- Tests/NimbleTests/PollingTest.swift | 94 +++++++++--------- 12 files changed, 231 insertions(+), 228 deletions(-) diff --git a/Tests/NimbleTests/AsyncAwaitTest+Require.swift b/Tests/NimbleTests/AsyncAwaitTest+Require.swift index f88e986a0..f681557ae 100644 --- a/Tests/NimbleTests/AsyncAwaitTest+Require.swift +++ b/Tests/NimbleTests/AsyncAwaitTest+Require.swift @@ -1,7 +1,7 @@ #if !os(WASI) import XCTest -import Nimble +@testable import Nimble #if SWIFT_PACKAGE import NimbleSharedTestHelpers #endif @@ -24,12 +24,12 @@ final class AsyncAwaitRequireTest: XCTestCase { // swiftlint:disable:this type_b } func testToEventuallyPositiveMatches() async throws { - var value = 0 - deferToMainQueue { value = 1 } - try await require { value }.toEventually(equal(1)) + let value = LockedContainer(0) + deferToMainQueue { value.set(1) } + try await require { value.value }.toEventually(equal(1)) - deferToMainQueue { value = 0 } - try await require { value }.toEventuallyNot(equal(1)) + deferToMainQueue { value.set(0) } + try await require { value.value }.toEventuallyNot(equal(1)) } func testToEventuallyNegativeMatches() async { @@ -194,52 +194,52 @@ final class AsyncAwaitRequireTest: XCTestCase { // swiftlint:disable:this type_b } final class ClassUnderTest { - var deinitCalled: (() -> Void)? - var count = 0 - deinit { deinitCalled?() } + let deinitCalled = LockedContainer<(() -> Void)?>(nil) + let count = LockedContainer(0) + deinit { deinitCalled.value?() } } func testSubjectUnderTestIsReleasedFromMemory() async throws { - var subject: ClassUnderTest? = ClassUnderTest() + let subject = LockedContainer(ClassUnderTest()) - if let sub = subject { - try await require(sub.count).toEventually(equal(0), timeout: .milliseconds(100)) - try await require(sub.count).toEventuallyNot(equal(1), timeout: .milliseconds(100)) + if let sub = subject.value { + try await require(sub.count.value).toEventually(equal(0), timeout: .milliseconds(100)) + try await require(sub.count.value).toEventuallyNot(equal(1), timeout: .milliseconds(100)) } await waitUntil(timeout: .milliseconds(500)) { done in - subject?.deinitCalled = { + subject.value?.deinitCalled.set({ done() - } + }) - deferToMainQueue { subject = nil } + deferToMainQueue { subject.set(nil) } } } func testToNeverPositiveMatches() async throws { - var value = 0 - deferToMainQueue { value = 1 } - try await require { value }.toNever(beGreaterThan(1)) + let value = LockedContainer(0) + deferToMainQueue { value.set(1) } + try await require { value.value }.toNever(beGreaterThan(1)) - deferToMainQueue { value = 0 } - try await require { value }.neverTo(beGreaterThan(1)) + deferToMainQueue { value.set(0) } + try await require { value.value }.neverTo(beGreaterThan(1)) } func testToNeverNegativeMatches() async { - var value = 0 + let value = LockedContainer(0) await failsWithErrorMessage("expected to never equal <0>, got <0>") { - try await require { value }.toNever(equal(0)) + try await require { value.value }.toNever(equal(0)) } await failsWithErrorMessage("expected to never equal <0>, got <0>") { - try await require { value }.neverTo(equal(0)) + try await require { value.value }.neverTo(equal(0)) } await failsWithErrorMessage("expected to never equal <1>, got <1>") { - deferToMainQueue { value = 1 } - try await require { value }.toNever(equal(1)) + deferToMainQueue { value.set(1) } + try await require { value.value }.toNever(equal(1)) } await failsWithErrorMessage("expected to never equal <1>, got <1>") { - deferToMainQueue { value = 1 } - try await require { value }.neverTo(equal(1)) + deferToMainQueue { value.set(1) } + try await require { value.value }.neverTo(equal(1)) } await failsWithErrorMessage("unexpected error thrown: <\(Self.errorToThrow)>") { try await require { try Self.doThrowError() }.toNever(equal(0)) @@ -253,29 +253,29 @@ final class AsyncAwaitRequireTest: XCTestCase { // swiftlint:disable:this type_b } func testToAlwaysPositiveMatches() async throws { - var value = 1 - deferToMainQueue { value = 2 } - try await require { value }.toAlways(beGreaterThan(0)) + let value = LockedContainer(1) + deferToMainQueue { value.set(2) } + try await require { value.value }.toAlways(beGreaterThan(0)) - deferToMainQueue { value = 2 } - try await require { value }.alwaysTo(beGreaterThan(1)) + deferToMainQueue { value.set(2) } + try await require { value.value }.alwaysTo(beGreaterThan(1)) } func testToAlwaysNegativeMatches() async { - var value = 1 + let value = LockedContainer(1) await failsWithErrorMessage("expected to always equal <0>, got <1>") { - try await require { value }.toAlways(equal(0)) + try await require { value.value }.toAlways(equal(0)) } await failsWithErrorMessage("expected to always equal <0>, got <1>") { - try await require { value }.alwaysTo(equal(0)) + try await require { value.value }.alwaysTo(equal(0)) } await failsWithErrorMessage("expected to always equal <1>, got <0>") { - deferToMainQueue { value = 0 } - try await require { value }.toAlways(equal(1)) + deferToMainQueue { value.set(0) } + try await require { value.value }.toAlways(equal(1)) } await failsWithErrorMessage("expected to always equal <1>, got <0>") { - deferToMainQueue { value = 0 } - try await require { value }.alwaysTo(equal(1)) + deferToMainQueue { value.set(0) } + try await require { value.value }.alwaysTo(equal(1)) } await failsWithErrorMessage("unexpected error thrown: <\(Self.errorToThrow)>") { try await require { try Self.doThrowError() }.toAlways(equal(0)) diff --git a/Tests/NimbleTests/AsyncAwaitTest.swift b/Tests/NimbleTests/AsyncAwaitTest.swift index 99cd43720..f833784ae 100644 --- a/Tests/NimbleTests/AsyncAwaitTest.swift +++ b/Tests/NimbleTests/AsyncAwaitTest.swift @@ -1,7 +1,7 @@ #if !os(WASI) import XCTest -import Nimble +@testable import Nimble #if SWIFT_PACKAGE import NimbleSharedTestHelpers #endif @@ -24,12 +24,12 @@ final class AsyncAwaitTest: XCTestCase { // swiftlint:disable:this type_body_len } func testToEventuallyPositiveMatches() async { - var value = 0 - deferToMainQueue { value = 1 } - await expect { value }.toEventually(equal(1)) + let value = LockedContainer(0) + deferToMainQueue { value.set(1) } + await expect { value.value }.toEventually(equal(1)) - deferToMainQueue { value = 0 } - await expect { value }.toEventuallyNot(equal(1)) + deferToMainQueue { value.set(0) } + await expect { value.value }.toEventuallyNot(equal(1)) } func testToEventuallyNegativeMatches() async { @@ -145,23 +145,23 @@ final class AsyncAwaitTest: XCTestCase { // swiftlint:disable:this type_body_len PollingDefaults.timeout = .seconds(1) } - var value = 0 + let value = LockedContainer(0) let sleepThenSetValueTo: (Int) -> Void = { newValue in Thread.sleep(forTimeInterval: 1.1) - value = newValue + value.set(newValue) } let task = Task { sleepThenSetValueTo(1) } - await expect { value }.toEventually(equal(1)) + await expect { value.value }.toEventually(equal(1)) let secondTask = Task { sleepThenSetValueTo(0) } - await expect { value }.toEventuallyNot(equal(1)) + await expect { value.value }.toEventuallyNot(equal(1)) _ = await task.value _ = await secondTask.result @@ -286,52 +286,52 @@ final class AsyncAwaitTest: XCTestCase { // swiftlint:disable:this type_body_len } final class ClassUnderTest { - var deinitCalled: (() -> Void)? - var count = 0 - deinit { deinitCalled?() } + let deinitCalled = LockedContainer<(() -> Void)?>(nil) + let count = LockedContainer(0) + deinit { deinitCalled.value?() } } func testSubjectUnderTestIsReleasedFromMemory() async { - var subject: ClassUnderTest? = ClassUnderTest() + let subject = LockedContainer(ClassUnderTest()) - if let sub = subject { - await expect(sub.count).toEventually(equal(0), timeout: .milliseconds(100)) - await expect(sub.count).toEventuallyNot(equal(1), timeout: .milliseconds(100)) + if let sub = subject.value { + await expect(sub.count.value).toEventually(equal(0), timeout: .milliseconds(100)) + await expect(sub.count.value).toEventuallyNot(equal(1), timeout: .milliseconds(100)) } await waitUntil(timeout: .milliseconds(500)) { done in - subject?.deinitCalled = { + subject.value?.deinitCalled.set({ done() - } + }) - deferToMainQueue { subject = nil } + deferToMainQueue { subject.set(nil) } } } func testToNeverPositiveMatches() async { - var value = 0 - deferToMainQueue { value = 1 } - await expect { value }.toNever(beGreaterThan(1)) + let value = LockedContainer(0) + deferToMainQueue { value.set(1) } + await expect { value.value }.toNever(beGreaterThan(1)) - deferToMainQueue { value = 0 } - await expect { value }.neverTo(beGreaterThan(1)) + deferToMainQueue { value.set(0) } + await expect { value.value }.neverTo(beGreaterThan(1)) } func testToNeverNegativeMatches() async { - var value = 0 + let value = LockedContainer(0) await failsWithErrorMessage("expected to never equal <0>, got <0>") { - await expect { value }.toNever(equal(0)) + await expect { value.value }.toNever(equal(0)) } await failsWithErrorMessage("expected to never equal <0>, got <0>") { - await expect { value }.neverTo(equal(0)) + await expect { value.value }.neverTo(equal(0)) } await failsWithErrorMessage("expected to never equal <1>, got <1>") { - deferToMainQueue { value = 1 } - await expect { value }.toNever(equal(1)) + deferToMainQueue { value.set(1) } + await expect { value.value }.toNever(equal(1)) } await failsWithErrorMessage("expected to never equal <1>, got <1>") { - deferToMainQueue { value = 1 } - await expect { value }.neverTo(equal(1)) + deferToMainQueue { value.set(1) } + await expect { value.value }.neverTo(equal(1)) } await failsWithErrorMessage("unexpected error thrown: <\(errorToThrow)>") { await expect { try self.doThrowError() }.toNever(equal(0)) @@ -342,29 +342,29 @@ final class AsyncAwaitTest: XCTestCase { // swiftlint:disable:this type_body_len } func testToAlwaysPositiveMatches() async { - var value = 1 - deferToMainQueue { value = 2 } - await expect { value }.toAlways(beGreaterThan(0)) + let value = LockedContainer(1) + deferToMainQueue { value.set(2) } + await expect { value.value }.toAlways(beGreaterThan(0)) - deferToMainQueue { value = 2 } - await expect { value }.alwaysTo(beGreaterThan(1)) + deferToMainQueue { value.set(2) } + await expect { value.value }.alwaysTo(beGreaterThan(1)) } func testToAlwaysNegativeMatches() async { - var value = 1 + let value = LockedContainer(1) await failsWithErrorMessage("expected to always equal <0>, got <1>") { - await expect { value }.toAlways(equal(0)) + await expect { value.value }.toAlways(equal(0)) } await failsWithErrorMessage("expected to always equal <0>, got <1>") { - await expect { value }.alwaysTo(equal(0)) + await expect { value.value }.alwaysTo(equal(0)) } await failsWithErrorMessage("expected to always equal <1>, got <0>") { - deferToMainQueue { value = 0 } - await expect { value }.toAlways(equal(1)) + deferToMainQueue { value.set(0) } + await expect { value.value }.toAlways(equal(1)) } await failsWithErrorMessage("expected to always equal <1>, got <0>") { - deferToMainQueue { value = 0 } - await expect { value }.alwaysTo(equal(1)) + deferToMainQueue { value.set(0) } + await expect { value.value }.alwaysTo(equal(1)) } await failsWithErrorMessage("unexpected error thrown: <\(errorToThrow)>") { await expect { try self.doThrowError() }.toAlways(equal(0)) diff --git a/Tests/NimbleTests/Matchers/ContainElementSatisfyingTest.swift b/Tests/NimbleTests/Matchers/ContainElementSatisfyingTest.swift index 38a3eac10..cce362555 100644 --- a/Tests/NimbleTests/Matchers/ContainElementSatisfyingTest.swift +++ b/Tests/NimbleTests/Matchers/ContainElementSatisfyingTest.swift @@ -8,7 +8,7 @@ import NimbleSharedTestHelpers final class ContainElementSatisfyingTest: XCTestCase { // MARK: - Matcher variant func testContainElementSatisfying() { - var orderIndifferentArray = [1, 2, 3] + let orderIndifferentArray = [1, 2, 3] expect(orderIndifferentArray).to(containElementSatisfying({ number in return number == 1 })) @@ -18,8 +18,10 @@ final class ContainElementSatisfyingTest: XCTestCase { expect(orderIndifferentArray).to(containElementSatisfying({ number in return number == 3 })) + } - orderIndifferentArray = [3, 1, 2] + func testContainElementSatisfying2() { + let orderIndifferentArray = [3, 1, 2] expect(orderIndifferentArray).to(containElementSatisfying({ number in return number == 1 })) @@ -76,7 +78,7 @@ final class ContainElementSatisfyingTest: XCTestCase { // MARK: - AsyncMatcher variant func testAsyncContainElementSatisfying() async { - var orderIndifferentArray = [1, 2, 3] + let orderIndifferentArray = [1, 2, 3] await expect(orderIndifferentArray).to(containElementSatisfying({ number in await asyncEqualityCheck(number, 1) })) @@ -86,8 +88,10 @@ final class ContainElementSatisfyingTest: XCTestCase { await expect(orderIndifferentArray).to(containElementSatisfying({ number in await asyncEqualityCheck(number, 3) })) + } - orderIndifferentArray = [3, 1, 2] + func testAsyncContainElementSatisfying2() async { + let orderIndifferentArray = [3, 1, 2] await expect(orderIndifferentArray).to(containElementSatisfying({ number in await asyncEqualityCheck(number, 1) })) diff --git a/Tests/NimbleTests/Matchers/ContainTest.swift b/Tests/NimbleTests/Matchers/ContainTest.swift index 2991405a0..3810a52fe 100644 --- a/Tests/NimbleTests/Matchers/ContainTest.swift +++ b/Tests/NimbleTests/Matchers/ContainTest.swift @@ -89,11 +89,10 @@ final class ContainTest: XCTestCase { } func testContainNSStringSubstring() { - let str = "foo" as NSString - expect(str).to(contain("o" as NSString)) - expect(str).to(contain("oo" as NSString)) - expect(str).toNot(contain("z" as NSString)) - expect(str).toNot(contain("zz" as NSString)) + expect("foo" as NSString).to(contain("o" as NSString)) + expect("foo" as NSString).to(contain("oo" as NSString)) + expect("foo" as NSString).toNot(contain("z" as NSString)) + expect("foo" as NSString).toNot(contain("zz" as NSString)) } func testVariadicArguments() { diff --git a/Tests/NimbleTests/Matchers/MapTest.swift b/Tests/NimbleTests/Matchers/MapTest.swift index 9b13c5f64..d9bf87fd9 100644 --- a/Tests/NimbleTests/Matchers/MapTest.swift +++ b/Tests/NimbleTests/Matchers/MapTest.swift @@ -56,7 +56,7 @@ final class MapTest: XCTestCase { } func testMapWithAsyncFunction() async { - func someOperation(_ value: Int) async -> String { + @Sendable func someOperation(_ value: Int) async -> String { "\(value)" } await expect(1).to(map(someOperation, equal("1"))) @@ -76,8 +76,8 @@ final class MapTest: XCTestCase { let box = Box(int: 3, string: "world") expect(box).to(satisfyAllOf( - map(\.int, equal(3)), - map(\.string, equal("world")) + map( { $0.int }, equal(3)), + map( { $0.string }, equal("world")) )) } } diff --git a/Tests/NimbleTests/Matchers/PostNotificationTest.swift b/Tests/NimbleTests/Matchers/PostNotificationTest.swift index c92e15caa..cde1b9c31 100644 --- a/Tests/NimbleTests/Matchers/PostNotificationTest.swift +++ b/Tests/NimbleTests/Matchers/PostNotificationTest.swift @@ -19,7 +19,7 @@ final class PostNotificationTest: XCTestCase { func testPassesWhenExpectedNotificationIsPosted() { let testNotification = Notification(name: Notification.Name("Foo"), object: nil) expect { - self.notificationCenter.post(testNotification) + self.notificationCenter.post(Notification(name: Notification.Name("Foo"), object: nil)) }.to(postNotifications(equal([testNotification]), from: notificationCenter)) } @@ -29,8 +29,8 @@ final class PostNotificationTest: XCTestCase { let n1 = Notification(name: Notification.Name("Foo"), object: foo) let n2 = Notification(name: Notification.Name("Bar"), object: bar) expect { - self.notificationCenter.post(n1) - self.notificationCenter.post(n2) + self.notificationCenter.post(Notification(name: Notification.Name("Foo"), object: foo)) + self.notificationCenter.post(Notification(name: Notification.Name("Bar"), object: bar)) }.to(postNotifications(equal([n1, n2]), from: notificationCenter)) } @@ -48,17 +48,18 @@ final class PostNotificationTest: XCTestCase { let n2 = Notification(name: Notification.Name(n1.name.rawValue + "a"), object: nil) failsWithErrorMessage("expected to equal <[\(n1)]>, got <[\(n2)]>") { expect { - self.notificationCenter.post(n2) + self.notificationCenter.post(Notification(name: Notification.Name("Fooa"), object: nil)) }.to(postNotifications(equal([n1]), from: self.notificationCenter)) } } func testFailsWhenNotificationWithWrongObjectIsPosted() { let n1 = Notification(name: Notification.Name("Foo"), object: nil) - let n2 = Notification(name: n1.name, object: NSObject()) + let object = NSObject() + let n2 = Notification(name: n1.name, object: object) failsWithErrorMessage("expected to equal <[\(n1)]>, got <[\(n2)]>") { expect { - self.notificationCenter.post(n2) + self.notificationCenter.post(Notification(name: Notification.Name("Foo"), object: object)) }.to(postNotifications(equal([n1]), from: self.notificationCenter)) } } @@ -67,7 +68,7 @@ final class PostNotificationTest: XCTestCase { let testNotification = Notification(name: Notification.Name("Foo"), object: nil) expect { deferToMainQueue { - self.notificationCenter.post(testNotification) + self.notificationCenter.post(Notification(name: Notification.Name("Foo"), object: nil)) } }.toEventually(postNotifications(equal([testNotification]), from: notificationCenter)) } @@ -76,16 +77,15 @@ final class PostNotificationTest: XCTestCase { let n1 = Notification(name: Notification.Name("Foo"), object: nil) failsWithErrorMessage("expected to not equal <[\(n1)]>, got <[\(n1)]>") { expect { - self.notificationCenter.post(n1) + self.notificationCenter.post(Notification(name: Notification.Name("Foo"), object: nil)) }.toNot(postNotifications(equal([n1]), from: self.notificationCenter)) } } func testPassesWhenNotificationIsNotPosted() { let n1 = Notification(name: Notification.Name("Foo"), object: nil) - let n2 = Notification(name: Notification.Name(n1.name.rawValue + "a"), object: nil) expect { - self.notificationCenter.post(n2) + self.notificationCenter.post(Notification(name: Notification.Name("Fooa"), object: nil)) }.toNever(postNotifications(equal([n1]), from: self.notificationCenter)) } @@ -99,7 +99,7 @@ final class PostNotificationTest: XCTestCase { self.notificationCenter.post(n2) }, ], waitUntilFinished: true) - self.notificationCenter.post(n1) + self.notificationCenter.post(Notification(name: Notification.Name("Foo"), object: nil)) }.to(postNotifications(contain([n1]), from: notificationCenter)) } @@ -109,7 +109,7 @@ final class PostNotificationTest: XCTestCase { OperationQueue().addOperations([ BlockOperation { let backgroundThreadObject = BackgroundThreadObject() - let n2 = Notification(name: Notification.Name(n1.name.rawValue + "a"), object: backgroundThreadObject) + let n2 = Notification(name: Notification.Name("Fooa"), object: backgroundThreadObject) self.notificationCenter.post(n2) }, ], waitUntilFinished: true) @@ -122,8 +122,8 @@ final class PostNotificationTest: XCTestCase { let n1 = Notification(name: Notification.Name("Foo"), object: "1") let n2 = Notification(name: Notification.Name("Bar"), object: "2") expect { - center.post(n1) - center.post(n2) + center.post(Notification(name: Notification.Name("Foo"), object: "1")) + center.post(Notification(name: Notification.Name("Bar"), object: "2")) }.toEventually(postDistributedNotifications(equal([n1, n2]), from: center, names: [n1.name, n2.name])) } #endif diff --git a/Tests/NimbleTests/Matchers/SatisfyAllOfTest.swift b/Tests/NimbleTests/Matchers/SatisfyAllOfTest.swift index e2563581a..429695864 100644 --- a/Tests/NimbleTests/Matchers/SatisfyAllOfTest.swift +++ b/Tests/NimbleTests/Matchers/SatisfyAllOfTest.swift @@ -1,5 +1,5 @@ import XCTest -import Nimble +@testable import Nimble import Foundation #if SWIFT_PACKAGE import NimbleSharedTestHelpers @@ -57,10 +57,12 @@ final class SatisfyAllOfTest: XCTestCase { func testSatisfyAllOfCachesExpressionBeforePassingToMatchers() { // This is not a great example of assertion writing - functions being asserted on in Expressions should not have side effects. // But we should still handle those cases anyway. - var value: Int = 0 - func testFunction() -> Int { - value += 1 - return value + let value = LockedContainer(0) + @Sendable func testFunction() -> Int { + value.operate { + $0 + 1 + } + return value.value } expect(testFunction()).toEventually(satisfyAllOf(equal(1), equal(1))) diff --git a/Tests/NimbleTests/Matchers/SatisfyAnyOfTest.swift b/Tests/NimbleTests/Matchers/SatisfyAnyOfTest.swift index f02c35206..d8afc25e4 100644 --- a/Tests/NimbleTests/Matchers/SatisfyAnyOfTest.swift +++ b/Tests/NimbleTests/Matchers/SatisfyAnyOfTest.swift @@ -1,5 +1,5 @@ import XCTest -import Nimble +@testable import Nimble import Foundation #if SWIFT_PACKAGE import NimbleSharedTestHelpers @@ -55,10 +55,10 @@ final class SatisfyAnyOfTest: XCTestCase { func testSatisfyAllOfCachesExpressionBeforePassingToMatchers() { // This is not a great example of assertion writing - functions being asserted on in Expressions should not have side effects. // But we should still handle those cases anyway. - var value: Int = 0 - func testFunction() -> Int { - value += 1 - return value + let value = LockedContainer(0) + @Sendable func testFunction() -> Int { + value.operate { $0 + 1 } + return value.value } // This demonstrates caching because the first time this is evaluated, the function should return 1, which doesn't pass the `equal(0)`. diff --git a/Tests/NimbleTests/Matchers/ThrowAssertionTest.swift b/Tests/NimbleTests/Matchers/ThrowAssertionTest.swift index 8d547d128..8bffc575e 100644 --- a/Tests/NimbleTests/Matchers/ThrowAssertionTest.swift +++ b/Tests/NimbleTests/Matchers/ThrowAssertionTest.swift @@ -1,6 +1,6 @@ import Foundation import XCTest -import Nimble +@testable import Nimble #if SWIFT_PACKAGE import NimbleSharedTestHelpers #endif @@ -22,27 +22,27 @@ final class ThrowAssertionTest: XCTestCase { func testPostAssertionCodeNotRun() { #if (arch(x86_64) || arch(arm64)) && !os(Windows) - var reachedPoint1 = false - var reachedPoint2 = false + let reachedPoint1 = LockedContainer(false) + let reachedPoint2 = LockedContainer(false) expect { - reachedPoint1 = true + reachedPoint1.set(true) precondition(false, "condition message") - reachedPoint2 = true + reachedPoint2.set(true) }.to(throwAssertion()) - expect(reachedPoint1) == true - expect(reachedPoint2) == false + expect(reachedPoint1.value) == true + expect(reachedPoint2.value) == false #endif } func testNegativeMatch() { #if (arch(x86_64) || arch(arm64)) && !os(Windows) - var reachedPoint1 = false + let reachedPoint1 = LockedContainer(false) - expect { reachedPoint1 = true }.toNot(throwAssertion()) + expect { reachedPoint1.set(true) }.toNot(throwAssertion()) - expect(reachedPoint1) == true + expect(reachedPoint1.value) == true #endif } diff --git a/Tests/NimbleTests/Matchers/ThrowErrorTest.swift b/Tests/NimbleTests/Matchers/ThrowErrorTest.swift index f2523d86d..bbdbb4d4f 100644 --- a/Tests/NimbleTests/Matchers/ThrowErrorTest.swift +++ b/Tests/NimbleTests/Matchers/ThrowErrorTest.swift @@ -128,7 +128,7 @@ final class ThrowErrorTest: XCTestCase { func testNegativeMatchesWithClosure() { let moduleName = "NimbleTests" let innerFailureMessage = "expected to equal , got <\(moduleName).NimbleError>" - let closure = { (error: Error) -> Void in + let closure = { @Sendable (error: Error) -> Void in expect(error._domain).to(equal("foo")) } diff --git a/Tests/NimbleTests/PollingTest+Require.swift b/Tests/NimbleTests/PollingTest+Require.swift index 7bdc48464..ac3edcfc7 100644 --- a/Tests/NimbleTests/PollingTest+Require.swift +++ b/Tests/NimbleTests/PollingTest+Require.swift @@ -6,7 +6,7 @@ import CoreFoundation #endif import Foundation import XCTest -import Nimble +@testable import Nimble #if SWIFT_PACKAGE import NimbleSharedTestHelpers #endif @@ -21,15 +21,15 @@ final class PollingRequireTest: XCTestCase { } func testToEventuallyPositiveMatches() { - var value = 0 - deferToMainQueue { value = 1 } + let value = LockedContainer(0) + deferToMainQueue { value.set(1) } expect { - try require { value }.toEventually(equal(1)) + try require { value.value }.toEventually(equal(1)) }.to(equal(1)) - deferToMainQueue { value = 0 } + deferToMainQueue { value.set(0) } expect { - try require { value }.toEventuallyNot(equal(1)) + try require { value.value }.toEventuallyNot(equal(1)) }.to(equal(0)) } @@ -50,12 +50,10 @@ final class PollingRequireTest: XCTestCase { } func testPollUnwrapPositiveCase() { - var value: Int? = nil - deferToMainQueue { - value = 1 - } + let value = LockedContainer(nil) + deferToMainQueue { value.set(1) } expect { - try pollUnwrap(value) + try pollUnwrap(value.value) }.to(equal(1)) } @@ -83,22 +81,22 @@ final class PollingRequireTest: XCTestCase { PollingDefaults.timeout = .seconds(1) } - var value = 0 + let value = LockedContainer(0) let sleepThenSetValueTo: (Int) -> Void = { newValue in Thread.sleep(forTimeInterval: 1.1) - value = newValue + value.set(newValue) } var asyncOperation: () -> Void = { sleepThenSetValueTo(1) } DispatchQueue.global().async(execute: asyncOperation) - try require { value }.toEventually(equal(1)) + try require { value.value }.toEventually(equal(1)) asyncOperation = { sleepThenSetValueTo(0) } DispatchQueue.global().async(execute: asyncOperation) - try require { value }.toEventuallyNot(equal(1)) + try require { value.value }.toEventuallyNot(equal(1)) } func testToEventuallyAllowsInBackgroundThread() { @@ -120,53 +118,53 @@ final class PollingRequireTest: XCTestCase { #endif } - final class ClassUnderTest { - var deinitCalled: (() -> Void)? - var count = 0 - deinit { deinitCalled?() } + final class ClassUnderTest: Sendable { + let deinitCalled = LockedContainer<(@Sendable () -> Void)?>(nil) + let count = LockedContainer(0) + deinit { deinitCalled.value?() } } func testSubjectUnderTestIsReleasedFromMemory() throws { - var subject: ClassUnderTest? = ClassUnderTest() + let subject = LockedContainer(ClassUnderTest()) - if let sub = subject { - try require(sub.count).toEventually(equal(0), timeout: .milliseconds(100)) - try require(sub.count).toEventuallyNot(equal(1), timeout: .milliseconds(100)) + if let sub = subject.value { + try require(sub.count.value).toEventually(equal(0), timeout: .milliseconds(100)) + try require(sub.count.value).toEventuallyNot(equal(1), timeout: .milliseconds(100)) } waitUntil(timeout: .milliseconds(500)) { done in - subject?.deinitCalled = { + subject.value?.deinitCalled.set({ done() - } + }) - deferToMainQueue { subject = nil } + deferToMainQueue { subject.set(nil) } } } func testToNeverPositiveMatches() throws { - var value = 0 - deferToMainQueue { value = 1 } - try require { value }.toNever(beGreaterThan(1)) + let value = LockedContainer(0) + deferToMainQueue { value.set(1) } + try require { value.value }.toNever(beGreaterThan(1)) - deferToMainQueue { value = 0 } - try require { value }.neverTo(beGreaterThan(1)) + deferToMainQueue { value.set(0) } + try require { value.value }.neverTo(beGreaterThan(1)) } func testToNeverNegativeMatches() { - var value = 0 + let value = LockedContainer(0) failsWithErrorMessage("expected to never equal <0>, got <0>") { - try require { value }.toNever(equal(0)) + try require { value.value }.toNever(equal(0)) } failsWithErrorMessage("expected to never equal <0>, got <0>") { - try require { value }.neverTo(equal(0)) + try require { value.value }.neverTo(equal(0)) } failsWithErrorMessage("expected to never equal <1>, got <1>") { - deferToMainQueue { value = 1 } - try require { value }.toNever(equal(1)) + deferToMainQueue { value.set(1) } + try require { value.value }.toNever(equal(1)) } failsWithErrorMessage("expected to never equal <1>, got <1>") { - deferToMainQueue { value = 1 } - try require { value }.neverTo(equal(1)) + deferToMainQueue { value.set(1) } + try require { value.value }.neverTo(equal(1)) } failsWithErrorMessage("unexpected error thrown: <\(errorToThrow)>") { try require { try self.doThrowError() }.toNever(equal(0)) @@ -180,29 +178,29 @@ final class PollingRequireTest: XCTestCase { } func testToAlwaysPositiveMatches() throws { - var value = 1 - deferToMainQueue { value = 2 } - try require { value }.toAlways(beGreaterThan(0)) + let value = LockedContainer(1) + deferToMainQueue { value.set(2) } + try require { value.value }.toAlways(beGreaterThan(0)) - deferToMainQueue { value = 2 } - try require { value }.alwaysTo(beGreaterThan(1)) + deferToMainQueue { value.set(2) } + try require { value.value }.alwaysTo(beGreaterThan(1)) } func testToAlwaysNegativeMatches() { - var value = 1 + let value = LockedContainer(1) failsWithErrorMessage("expected to always equal <0>, got <1>") { - try require { value }.toAlways(equal(0)) + try require { value.value }.toAlways(equal(0)) } failsWithErrorMessage("expected to always equal <0>, got <1>") { - try require { value }.alwaysTo(equal(0)) + try require { value.value }.alwaysTo(equal(0)) } failsWithErrorMessage("expected to always equal <1>, got <0>") { - deferToMainQueue { value = 0 } - try require { value }.toAlways(equal(1)) + deferToMainQueue { value.set(0) } + try require { value.value }.toAlways(equal(1)) } failsWithErrorMessage("expected to always equal <1>, got <0>") { - deferToMainQueue { value = 0 } - try require { value }.alwaysTo(equal(1)) + deferToMainQueue { value.set(0) } + try require { value.value }.alwaysTo(equal(1)) } failsWithErrorMessage("unexpected error thrown: <\(errorToThrow)>") { try require { try self.doThrowError() }.toAlways(equal(0)) diff --git a/Tests/NimbleTests/PollingTest.swift b/Tests/NimbleTests/PollingTest.swift index e414b7b34..616e411ae 100644 --- a/Tests/NimbleTests/PollingTest.swift +++ b/Tests/NimbleTests/PollingTest.swift @@ -6,7 +6,7 @@ import CoreFoundation #endif import Foundation import XCTest -import Nimble +@testable import Nimble #if SWIFT_PACKAGE import NimbleSharedTestHelpers #endif @@ -21,12 +21,12 @@ final class PollingTest: XCTestCase { } func testToEventuallyPositiveMatches() { - var value = 0 - deferToMainQueue { value = 1 } - expect { value }.toEventually(equal(1)) + let value = LockedContainer(0) + deferToMainQueue { value.set(1) } + expect { value.value }.toEventually(equal(1)) - deferToMainQueue { value = 0 } - expect { value }.toEventuallyNot(equal(1)) + deferToMainQueue { value.set(0) } + expect { value.value }.toEventuallyNot(equal(1)) } func testToEventuallyNegativeMatches() { @@ -55,22 +55,22 @@ final class PollingTest: XCTestCase { PollingDefaults.timeout = .seconds(1) } - var value = 0 + let value = LockedContainer(0) let sleepThenSetValueTo: (Int) -> Void = { newValue in Thread.sleep(forTimeInterval: 1.1) - value = newValue + value.set(newValue) } var asyncOperation: () -> Void = { sleepThenSetValueTo(1) } DispatchQueue.global().async(execute: asyncOperation) - expect { value }.toEventually(equal(1)) + expect { value.value }.toEventually(equal(1)) asyncOperation = { sleepThenSetValueTo(0) } DispatchQueue.global().async(execute: asyncOperation) - expect { value }.toEventuallyNot(equal(1)) + expect { value.value }.toEventuallyNot(equal(1)) } func testWaitUntilWithCustomDefaultsTimeout() { @@ -102,13 +102,13 @@ final class PollingTest: XCTestCase { } func testWaitUntilTimesOutWhenExceedingItsTime() { - var waiting = true + let waiting = LockedContainer(true) failsWithErrorMessage("Waited more than 0.01 seconds") { waitUntil(timeout: .milliseconds(10)) { done in - let asyncOperation: () -> Void = { + let asyncOperation: @Sendable () -> Void = { Thread.sleep(forTimeInterval: 0.1) done() - waiting = false + waiting.set(false) } DispatchQueue.global().async(execute: asyncOperation) } @@ -117,7 +117,7 @@ final class PollingTest: XCTestCase { // "clear" runloop to ensure this test doesn't poison other tests repeat { RunLoop.main.run(until: Date().addingTimeInterval(0.2)) - } while(waiting) + } while(waiting.value) } func testWaitUntilNegativeMatches() { @@ -241,53 +241,53 @@ final class PollingTest: XCTestCase { #endif } - final class ClassUnderTest { - var deinitCalled: (() -> Void)? - var count = 0 - deinit { deinitCalled?() } + final class ClassUnderTest: Sendable { + let deinitCalled = LockedContainer<(@Sendable () -> Void)?>(nil) + let count = 0 + deinit { deinitCalled.value?() } } func testSubjectUnderTestIsReleasedFromMemory() { - var subject: ClassUnderTest? = ClassUnderTest() + let subject = LockedContainer(ClassUnderTest()) - if let sub = subject { + if let sub = subject.value { expect(sub.count).toEventually(equal(0), timeout: .milliseconds(100)) expect(sub.count).toEventuallyNot(equal(1), timeout: .milliseconds(100)) } waitUntil(timeout: .milliseconds(500)) { done in - subject?.deinitCalled = { + subject.value?.deinitCalled.set({ done() - } + }) - deferToMainQueue { subject = nil } + deferToMainQueue { subject.set(nil) } } } func testToNeverPositiveMatches() { - var value = 0 - deferToMainQueue { value = 1 } - expect { value }.toNever(beGreaterThan(1)) + let value = LockedContainer(0) + deferToMainQueue { value.set(1) } + expect { value.value }.toNever(beGreaterThan(1)) - deferToMainQueue { value = 0 } - expect { value }.neverTo(beGreaterThan(1)) + deferToMainQueue { value.set(0) } + expect { value.value }.neverTo(beGreaterThan(1)) } func testToNeverNegativeMatches() { - var value = 0 + let value = LockedContainer(0) failsWithErrorMessage("expected to never equal <0>, got <0>") { - expect { value }.toNever(equal(0)) + expect { value.value }.toNever(equal(0)) } failsWithErrorMessage("expected to never equal <0>, got <0>") { - expect { value }.neverTo(equal(0)) + expect { value.value }.neverTo(equal(0)) } failsWithErrorMessage("expected to never equal <1>, got <1>") { - deferToMainQueue { value = 1 } - expect { value }.toNever(equal(1)) + deferToMainQueue { value.set(1) } + expect { value.value }.toNever(equal(1)) } failsWithErrorMessage("expected to never equal <1>, got <1>") { - deferToMainQueue { value = 1 } - expect { value }.neverTo(equal(1)) + deferToMainQueue { value.set(1) } + expect { value.value }.neverTo(equal(1)) } failsWithErrorMessage("unexpected error thrown: <\(errorToThrow)>") { expect { try self.doThrowError() }.toNever(equal(0)) @@ -301,29 +301,29 @@ final class PollingTest: XCTestCase { } func testToAlwaysPositiveMatches() { - var value = 1 - deferToMainQueue { value = 2 } - expect { value }.toAlways(beGreaterThan(0)) + let value = LockedContainer(1) + deferToMainQueue { value.set(2) } + expect { value.value }.toAlways(beGreaterThan(0)) - deferToMainQueue { value = 2 } - expect { value }.alwaysTo(beGreaterThan(1)) + deferToMainQueue { value.set(2) } + expect { value.value }.alwaysTo(beGreaterThan(1)) } func testToAlwaysNegativeMatches() { - var value = 1 + let value = LockedContainer(1) failsWithErrorMessage("expected to always equal <0>, got <1>") { - expect { value }.toAlways(equal(0)) + expect { value.value }.toAlways(equal(0)) } failsWithErrorMessage("expected to always equal <0>, got <1>") { - expect { value }.alwaysTo(equal(0)) + expect { value.value }.alwaysTo(equal(0)) } failsWithErrorMessage("expected to always equal <1>, got <0>") { - deferToMainQueue { value = 0 } - expect { value }.toAlways(equal(1)) + deferToMainQueue { value.set(0) } + expect { value.value }.toAlways(equal(1)) } failsWithErrorMessage("expected to always equal <1>, got <0>") { - deferToMainQueue { value = 0 } - expect { value }.alwaysTo(equal(1)) + deferToMainQueue { value.set(0) } + expect { value.value }.alwaysTo(equal(1)) } failsWithErrorMessage("unexpected error thrown: <\(errorToThrow)>") { expect { try self.doThrowError() }.toAlways(equal(0))