Skip to content

Commit 7ccad44

Browse files
younatayounata
committed
Fix the current set of concurrency warnings in tests
1 parent b4b2dad commit 7ccad44

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
@@ -286,52 +286,52 @@ final class AsyncAwaitTest: XCTestCase { // swiftlint:disable:this type_body_len
286286
}
287287

288288
final class ClassUnderTest {
289-
var deinitCalled: (() -> Void)?
290-
var count = 0
291-
deinit { deinitCalled?() }
289+
let deinitCalled = LockedContainer<(() -> Void)?>(nil)
290+
let count = LockedContainer(0)
291+
deinit { deinitCalled.value?() }
292292
}
293293

294294
func testSubjectUnderTestIsReleasedFromMemory() async {
295-
var subject: ClassUnderTest? = ClassUnderTest()
295+
let subject = LockedContainer<ClassUnderTest?>(ClassUnderTest())
296296

297-
if let sub = subject {
298-
await expect(sub.count).toEventually(equal(0), timeout: .milliseconds(100))
299-
await expect(sub.count).toEventuallyNot(equal(1), timeout: .milliseconds(100))
297+
if let sub = subject.value {
298+
await expect(sub.count.value).toEventually(equal(0), timeout: .milliseconds(100))
299+
await expect(sub.count.value).toEventuallyNot(equal(1), timeout: .milliseconds(100))
300300
}
301301

302302
await waitUntil(timeout: .milliseconds(500)) { done in
303-
subject?.deinitCalled = {
303+
subject.value?.deinitCalled.set({
304304
done()
305-
}
305+
})
306306

307-
deferToMainQueue { subject = nil }
307+
deferToMainQueue { subject.set(nil) }
308308
}
309309
}
310310

311311
func testToNeverPositiveMatches() async {
312-
var value = 0
313-
deferToMainQueue { value = 1 }
314-
await expect { value }.toNever(beGreaterThan(1))
312+
let value = LockedContainer(0)
313+
deferToMainQueue { value.set(1) }
314+
await expect { value.value }.toNever(beGreaterThan(1))
315315

316-
deferToMainQueue { value = 0 }
317-
await expect { value }.neverTo(beGreaterThan(1))
316+
deferToMainQueue { value.set(0) }
317+
await expect { value.value }.neverTo(beGreaterThan(1))
318318
}
319319

320320
func testToNeverNegativeMatches() async {
321-
var value = 0
321+
let value = LockedContainer(0)
322322
await failsWithErrorMessage("expected to never equal <0>, got <0>") {
323-
await expect { value }.toNever(equal(0))
323+
await expect { value.value }.toNever(equal(0))
324324
}
325325
await failsWithErrorMessage("expected to never equal <0>, got <0>") {
326-
await expect { value }.neverTo(equal(0))
326+
await expect { value.value }.neverTo(equal(0))
327327
}
328328
await failsWithErrorMessage("expected to never equal <1>, got <1>") {
329-
deferToMainQueue { value = 1 }
330-
await expect { value }.toNever(equal(1))
329+
deferToMainQueue { value.set(1) }
330+
await expect { value.value }.toNever(equal(1))
331331
}
332332
await failsWithErrorMessage("expected to never equal <1>, got <1>") {
333-
deferToMainQueue { value = 1 }
334-
await expect { value }.neverTo(equal(1))
333+
deferToMainQueue { value.set(1) }
334+
await expect { value.value }.neverTo(equal(1))
335335
}
336336
await failsWithErrorMessage("unexpected error thrown: <\(errorToThrow)>") {
337337
await expect { try self.doThrowError() }.toNever(equal(0))
@@ -342,29 +342,29 @@ final class AsyncAwaitTest: XCTestCase { // swiftlint:disable:this type_body_len
342342
}
343343

344344
func testToAlwaysPositiveMatches() async {
345-
var value = 1
346-
deferToMainQueue { value = 2 }
347-
await expect { value }.toAlways(beGreaterThan(0))
345+
let value = LockedContainer(1)
346+
deferToMainQueue { value.set(2) }
347+
await expect { value.value }.toAlways(beGreaterThan(0))
348348

349-
deferToMainQueue { value = 2 }
350-
await expect { value }.alwaysTo(beGreaterThan(1))
349+
deferToMainQueue { value.set(2) }
350+
await expect { value.value }.alwaysTo(beGreaterThan(1))
351351
}
352352

353353
func testToAlwaysNegativeMatches() async {
354-
var value = 1
354+
let value = LockedContainer(1)
355355
await failsWithErrorMessage("expected to always equal <0>, got <1>") {
356-
await expect { value }.toAlways(equal(0))
356+
await expect { value.value }.toAlways(equal(0))
357357
}
358358
await failsWithErrorMessage("expected to always equal <0>, got <1>") {
359-
await expect { value }.alwaysTo(equal(0))
359+
await expect { value.value }.alwaysTo(equal(0))
360360
}
361361
await failsWithErrorMessage("expected to always equal <1>, got <0>") {
362-
deferToMainQueue { value = 0 }
363-
await expect { value }.toAlways(equal(1))
362+
deferToMainQueue { value.set(0) }
363+
await expect { value.value }.toAlways(equal(1))
364364
}
365365
await failsWithErrorMessage("expected to always equal <1>, got <0>") {
366-
deferToMainQueue { value = 0 }
367-
await expect { value }.alwaysTo(equal(1))
366+
deferToMainQueue { value.set(0) }
367+
await expect { value.value }.alwaysTo(equal(1))
368368
}
369369
await failsWithErrorMessage("unexpected error thrown: <\(errorToThrow)>") {
370370
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
@@ -56,7 +56,7 @@ final class MapTest: XCTestCase {
5656
}
5757

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

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

0 commit comments

Comments
 (0)