Skip to content

Commit fc7bb4c

Browse files
younatayounata
committed
Fix the current set of concurrency warnings in tests (#1166)
1 parent 24fd17a commit fc7bb4c

12 files changed

+231
-228
lines changed

‎Tests/NimbleTests/AsyncAwaitTest+Require.swift‎

Lines changed: 40 additions & 40 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
#if !os(WASI)
22

33
import XCTest
4-
import Nimble
4+
@testable import Nimble
55
#if SWIFT_PACKAGE
66
import NimbleSharedTestHelpers
77
#endif
@@ -24,12 +24,12 @@ final class AsyncAwaitRequireTest: XCTestCase { // swiftlint:disable:this type_b
2424
}
2525

2626
func testToEventuallyPositiveMatches() async throws {
27-
var value = 0
28-
deferToMainQueue { value = 1 }
29-
try await require { value }.toEventually(equal(1))
27+
let value = LockedContainer(0)
28+
deferToMainQueue { value.set(1) }
29+
try await require { value.value }.toEventually(equal(1))
3030

31-
deferToMainQueue { value = 0 }
32-
try await require { value }.toEventuallyNot(equal(1))
31+
deferToMainQueue { value.set(0) }
32+
try await require { value.value }.toEventuallyNot(equal(1))
3333
}
3434

3535
func testToEventuallyNegativeMatches() async {
@@ -194,52 +194,52 @@ final class AsyncAwaitRequireTest: XCTestCase { // swiftlint:disable:this type_b
194194
}
195195

196196
final class ClassUnderTest {
197-
var deinitCalled: (() -> Void)?
198-
var count = 0
199-
deinit { deinitCalled?() }
197+
let deinitCalled = LockedContainer<(() -> Void)?>(nil)
198+
let count = LockedContainer(0)
199+
deinit { deinitCalled.value?() }
200200
}
201201

202202
func testSubjectUnderTestIsReleasedFromMemory() async throws {
203-
var subject: ClassUnderTest? = ClassUnderTest()
203+
let subject = LockedContainer<ClassUnderTest?>(ClassUnderTest())
204204

205-
if let sub = subject {
206-
try await require(sub.count).toEventually(equal(0), timeout: .milliseconds(100))
207-
try await require(sub.count).toEventuallyNot(equal(1), timeout: .milliseconds(100))
205+
if let sub = subject.value {
206+
try await require(sub.count.value).toEventually(equal(0), timeout: .milliseconds(100))
207+
try await require(sub.count.value).toEventuallyNot(equal(1), timeout: .milliseconds(100))
208208
}
209209

210210
await waitUntil(timeout: .milliseconds(500)) { done in
211-
subject?.deinitCalled = {
211+
subject.value?.deinitCalled.set({
212212
done()
213-
}
213+
})
214214

215-
deferToMainQueue { subject = nil }
215+
deferToMainQueue { subject.set(nil) }
216216
}
217217
}
218218

219219
func testToNeverPositiveMatches() async throws {
220-
var value = 0
221-
deferToMainQueue { value = 1 }
222-
try await require { value }.toNever(beGreaterThan(1))
220+
let value = LockedContainer(0)
221+
deferToMainQueue { value.set(1) }
222+
try await require { value.value }.toNever(beGreaterThan(1))
223223

224-
deferToMainQueue { value = 0 }
225-
try await require { value }.neverTo(beGreaterThan(1))
224+
deferToMainQueue { value.set(0) }
225+
try await require { value.value }.neverTo(beGreaterThan(1))
226226
}
227227

228228
func testToNeverNegativeMatches() async {
229-
var value = 0
229+
let value = LockedContainer(0)
230230
await failsWithErrorMessage("expected to never equal <0>, got <0>") {
231-
try await require { value }.toNever(equal(0))
231+
try await require { value.value }.toNever(equal(0))
232232
}
233233
await failsWithErrorMessage("expected to never equal <0>, got <0>") {
234-
try await require { value }.neverTo(equal(0))
234+
try await require { value.value }.neverTo(equal(0))
235235
}
236236
await failsWithErrorMessage("expected to never equal <1>, got <1>") {
237-
deferToMainQueue { value = 1 }
238-
try await require { value }.toNever(equal(1))
237+
deferToMainQueue { value.set(1) }
238+
try await require { value.value }.toNever(equal(1))
239239
}
240240
await failsWithErrorMessage("expected to never equal <1>, got <1>") {
241-
deferToMainQueue { value = 1 }
242-
try await require { value }.neverTo(equal(1))
241+
deferToMainQueue { value.set(1) }
242+
try await require { value.value }.neverTo(equal(1))
243243
}
244244
await failsWithErrorMessage("unexpected error thrown: <\(Self.errorToThrow)>") {
245245
try await require { try Self.doThrowError() }.toNever(equal(0))
@@ -253,29 +253,29 @@ final class AsyncAwaitRequireTest: XCTestCase { // swiftlint:disable:this type_b
253253
}
254254

255255
func testToAlwaysPositiveMatches() async throws {
256-
var value = 1
257-
deferToMainQueue { value = 2 }
258-
try await require { value }.toAlways(beGreaterThan(0))
256+
let value = LockedContainer(1)
257+
deferToMainQueue { value.set(2) }
258+
try await require { value.value }.toAlways(beGreaterThan(0))
259259

260-
deferToMainQueue { value = 2 }
261-
try await require { value }.alwaysTo(beGreaterThan(1))
260+
deferToMainQueue { value.set(2) }
261+
try await require { value.value }.alwaysTo(beGreaterThan(1))
262262
}
263263

264264
func testToAlwaysNegativeMatches() async {
265-
var value = 1
265+
let value = LockedContainer(1)
266266
await failsWithErrorMessage("expected to always equal <0>, got <1>") {
267-
try await require { value }.toAlways(equal(0))
267+
try await require { value.value }.toAlways(equal(0))
268268
}
269269
await failsWithErrorMessage("expected to always equal <0>, got <1>") {
270-
try await require { value }.alwaysTo(equal(0))
270+
try await require { value.value }.alwaysTo(equal(0))
271271
}
272272
await failsWithErrorMessage("expected to always equal <1>, got <0>") {
273-
deferToMainQueue { value = 0 }
274-
try await require { value }.toAlways(equal(1))
273+
deferToMainQueue { value.set(0) }
274+
try await require { value.value }.toAlways(equal(1))
275275
}
276276
await failsWithErrorMessage("expected to always equal <1>, got <0>") {
277-
deferToMainQueue { value = 0 }
278-
try await require { value }.alwaysTo(equal(1))
277+
deferToMainQueue { value.set(0) }
278+
try await require { value.value }.alwaysTo(equal(1))
279279
}
280280
await failsWithErrorMessage("unexpected error thrown: <\(Self.errorToThrow)>") {
281281
try await require { try Self.doThrowError() }.toAlways(equal(0))

‎Tests/NimbleTests/AsyncAwaitTest.swift‎

Lines changed: 44 additions & 44 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
#if !os(WASI)
22

33
import XCTest
4-
import Nimble
4+
@testable import Nimble
55
#if SWIFT_PACKAGE
66
import NimbleSharedTestHelpers
77
#endif
@@ -24,12 +24,12 @@ final class AsyncAwaitTest: XCTestCase { // swiftlint:disable:this type_body_len
2424
}
2525

2626
func testToEventuallyPositiveMatches() async {
27-
var value = 0
28-
deferToMainQueue { value = 1 }
29-
await expect { value }.toEventually(equal(1))
27+
let value = LockedContainer(0)
28+
deferToMainQueue { value.set(1) }
29+
await expect { value.value }.toEventually(equal(1))
3030

31-
deferToMainQueue { value = 0 }
32-
await expect { value }.toEventuallyNot(equal(1))
31+
deferToMainQueue { value.set(0) }
32+
await expect { value.value }.toEventuallyNot(equal(1))
3333
}
3434

3535
func testToEventuallyNegativeMatches() async {
@@ -145,23 +145,23 @@ final class AsyncAwaitTest: XCTestCase { // swiftlint:disable:this type_body_len
145145
PollingDefaults.timeout = .seconds(1)
146146
}
147147

148-
var value = 0
148+
let value = LockedContainer(0)
149149

150150
let sleepThenSetValueTo: (Int) -> Void = { newValue in
151151
Thread.sleep(forTimeInterval: 1.1)
152-
value = newValue
152+
value.set(newValue)
153153
}
154154

155155
let task = Task {
156156
sleepThenSetValueTo(1)
157157
}
158-
await expect { value }.toEventually(equal(1))
158+
await expect { value.value }.toEventually(equal(1))
159159

160160
let secondTask = Task {
161161
sleepThenSetValueTo(0)
162162
}
163163

164-
await expect { value }.toEventuallyNot(equal(1))
164+
await expect { value.value }.toEventuallyNot(equal(1))
165165

166166
_ = await task.value
167167
_ = await secondTask.result
@@ -295,52 +295,52 @@ final class AsyncAwaitTest: XCTestCase { // swiftlint:disable:this type_body_len
295295
}
296296

297297
final class ClassUnderTest {
298-
var deinitCalled: (() -> Void)?
299-
var count = 0
300-
deinit { deinitCalled?() }
298+
let deinitCalled = LockedContainer<(() -> Void)?>(nil)
299+
let count = LockedContainer(0)
300+
deinit { deinitCalled.value?() }
301301
}
302302

303303
func testSubjectUnderTestIsReleasedFromMemory() async {
304-
var subject: ClassUnderTest? = ClassUnderTest()
304+
let subject = LockedContainer<ClassUnderTest?>(ClassUnderTest())
305305

306-
if let sub = subject {
307-
await expect(sub.count).toEventually(equal(0), timeout: .milliseconds(100))
308-
await expect(sub.count).toEventuallyNot(equal(1), timeout: .milliseconds(100))
306+
if let sub = subject.value {
307+
await expect(sub.count.value).toEventually(equal(0), timeout: .milliseconds(100))
308+
await expect(sub.count.value).toEventuallyNot(equal(1), timeout: .milliseconds(100))
309309
}
310310

311311
await waitUntil(timeout: .milliseconds(500)) { done in
312-
subject?.deinitCalled = {
312+
subject.value?.deinitCalled.set({
313313
done()
314-
}
314+
})
315315

316-
deferToMainQueue { subject = nil }
316+
deferToMainQueue { subject.set(nil) }
317317
}
318318
}
319319

320320
func testToNeverPositiveMatches() async {
321-
var value = 0
322-
deferToMainQueue { value = 1 }
323-
await expect { value }.toNever(beGreaterThan(1))
321+
let value = LockedContainer(0)
322+
deferToMainQueue { value.set(1) }
323+
await expect { value.value }.toNever(beGreaterThan(1))
324324

325-
deferToMainQueue { value = 0 }
326-
await expect { value }.neverTo(beGreaterThan(1))
325+
deferToMainQueue { value.set(0) }
326+
await expect { value.value }.neverTo(beGreaterThan(1))
327327
}
328328

329329
func testToNeverNegativeMatches() async {
330-
var value = 0
330+
let value = LockedContainer(0)
331331
await failsWithErrorMessage("expected to never equal <0>, got <0>") {
332-
await expect { value }.toNever(equal(0))
332+
await expect { value.value }.toNever(equal(0))
333333
}
334334
await failsWithErrorMessage("expected to never equal <0>, got <0>") {
335-
await expect { value }.neverTo(equal(0))
335+
await expect { value.value }.neverTo(equal(0))
336336
}
337337
await failsWithErrorMessage("expected to never equal <1>, got <1>") {
338-
deferToMainQueue { value = 1 }
339-
await expect { value }.toNever(equal(1))
338+
deferToMainQueue { value.set(1) }
339+
await expect { value.value }.toNever(equal(1))
340340
}
341341
await failsWithErrorMessage("expected to never equal <1>, got <1>") {
342-
deferToMainQueue { value = 1 }
343-
await expect { value }.neverTo(equal(1))
342+
deferToMainQueue { value.set(1) }
343+
await expect { value.value }.neverTo(equal(1))
344344
}
345345
await failsWithErrorMessage("unexpected error thrown: <\(errorToThrow)>") {
346346
await expect { try self.doThrowError() }.toNever(equal(0))
@@ -351,29 +351,29 @@ final class AsyncAwaitTest: XCTestCase { // swiftlint:disable:this type_body_len
351351
}
352352

353353
func testToAlwaysPositiveMatches() async {
354-
var value = 1
355-
deferToMainQueue { value = 2 }
356-
await expect { value }.toAlways(beGreaterThan(0))
354+
let value = LockedContainer(1)
355+
deferToMainQueue { value.set(2) }
356+
await expect { value.value }.toAlways(beGreaterThan(0))
357357

358-
deferToMainQueue { value = 2 }
359-
await expect { value }.alwaysTo(beGreaterThan(1))
358+
deferToMainQueue { value.set(2) }
359+
await expect { value.value }.alwaysTo(beGreaterThan(1))
360360
}
361361

362362
func testToAlwaysNegativeMatches() async {
363-
var value = 1
363+
let value = LockedContainer(1)
364364
await failsWithErrorMessage("expected to always equal <0>, got <1>") {
365-
await expect { value }.toAlways(equal(0))
365+
await expect { value.value }.toAlways(equal(0))
366366
}
367367
await failsWithErrorMessage("expected to always equal <0>, got <1>") {
368-
await expect { value }.alwaysTo(equal(0))
368+
await expect { value.value }.alwaysTo(equal(0))
369369
}
370370
await failsWithErrorMessage("expected to always equal <1>, got <0>") {
371-
deferToMainQueue { value = 0 }
372-
await expect { value }.toAlways(equal(1))
371+
deferToMainQueue { value.set(0) }
372+
await expect { value.value }.toAlways(equal(1))
373373
}
374374
await failsWithErrorMessage("expected to always equal <1>, got <0>") {
375-
deferToMainQueue { value = 0 }
376-
await expect { value }.alwaysTo(equal(1))
375+
deferToMainQueue { value.set(0) }
376+
await expect { value.value }.alwaysTo(equal(1))
377377
}
378378
await failsWithErrorMessage("unexpected error thrown: <\(errorToThrow)>") {
379379
await expect { try self.doThrowError() }.toAlways(equal(0))

‎Tests/NimbleTests/Matchers/ContainElementSatisfyingTest.swift‎

Lines changed: 8 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@ import NimbleSharedTestHelpers
88
final class ContainElementSatisfyingTest: XCTestCase {
99
// MARK: - Matcher variant
1010
func testContainElementSatisfying() {
11-
var orderIndifferentArray = [1, 2, 3]
11+
let orderIndifferentArray = [1, 2, 3]
1212
expect(orderIndifferentArray).to(containElementSatisfying({ number in
1313
return number == 1
1414
}))
@@ -18,8 +18,10 @@ final class ContainElementSatisfyingTest: XCTestCase {
1818
expect(orderIndifferentArray).to(containElementSatisfying({ number in
1919
return number == 3
2020
}))
21+
}
2122

22-
orderIndifferentArray = [3, 1, 2]
23+
func testContainElementSatisfying2() {
24+
let orderIndifferentArray = [3, 1, 2]
2325
expect(orderIndifferentArray).to(containElementSatisfying({ number in
2426
return number == 1
2527
}))
@@ -76,7 +78,7 @@ final class ContainElementSatisfyingTest: XCTestCase {
7678

7779
// MARK: - AsyncMatcher variant
7880
func testAsyncContainElementSatisfying() async {
79-
var orderIndifferentArray = [1, 2, 3]
81+
let orderIndifferentArray = [1, 2, 3]
8082
await expect(orderIndifferentArray).to(containElementSatisfying({ number in
8183
await asyncEqualityCheck(number, 1)
8284
}))
@@ -86,8 +88,10 @@ final class ContainElementSatisfyingTest: XCTestCase {
8688
await expect(orderIndifferentArray).to(containElementSatisfying({ number in
8789
await asyncEqualityCheck(number, 3)
8890
}))
91+
}
8992

90-
orderIndifferentArray = [3, 1, 2]
93+
func testAsyncContainElementSatisfying2() async {
94+
let orderIndifferentArray = [3, 1, 2]
9195
await expect(orderIndifferentArray).to(containElementSatisfying({ number in
9296
await asyncEqualityCheck(number, 1)
9397
}))

‎Tests/NimbleTests/Matchers/ContainTest.swift‎

Lines changed: 4 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -89,11 +89,10 @@ final class ContainTest: XCTestCase {
8989
}
9090

9191
func testContainNSStringSubstring() {
92-
let str = "foo" as NSString
93-
expect(str).to(contain("o" as NSString))
94-
expect(str).to(contain("oo" as NSString))
95-
expect(str).toNot(contain("z" as NSString))
96-
expect(str).toNot(contain("zz" as NSString))
92+
expect("foo" as NSString).to(contain("o" as NSString))
93+
expect("foo" as NSString).to(contain("oo" as NSString))
94+
expect("foo" as NSString).toNot(contain("z" as NSString))
95+
expect("foo" as NSString).toNot(contain("zz" as NSString))
9796
}
9897

9998
func testVariadicArguments() {

‎Tests/NimbleTests/Matchers/MapTest.swift‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -57,7 +57,7 @@ final class MapTest: XCTestCase {
5757
}
5858

5959
func testMapWithAsyncFunction() async {
60-
func someOperation(_ value: Int) async -> String {
60+
@Sendable func someOperation(_ value: Int) async -> String {
6161
"\(value)"
6262
}
6363
await expect(1).to(map(someOperation, equal("1")))
@@ -77,8 +77,8 @@ final class MapTest: XCTestCase {
7777
let box = Box(int: 3, string: "world")
7878

7979
expect(box).to(satisfyAllOf(
80-
map(\.int, equal(3)),
81-
map(\.string, equal("world"))
80+
map( { $0.int }, equal(3)),
81+
map( { $0.string }, equal("world"))
8282
))
8383
}
8484

0 commit comments

Comments
 (0)