1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
|
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2023 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
#if canImport(TestSupport)
import TestSupport
#endif
#if canImport(FoundationEssentials)
@testable import FoundationEssentials
#endif
final class LockedStateTests : XCTestCase {
final class TestObject {
var deinitBlock: () -> Void = {}
deinit {
deinitBlock()
}
}
struct TestError: Error {}
func testWithLockDoesNotExtendLifetimeOfState() {
weak var state: TestObject?
let lockedState: LockedState<TestObject>
(state, lockedState) = {
let state = TestObject()
return (state, LockedState(initialState: state))
}()
lockedState.withLock { state in
weak var oldState = state
state = TestObject()
XCTAssertNil(oldState, "State object lifetime was extended after reassignment within body")
}
XCTAssertNil(state, "State object lifetime was extended beyond end of call")
}
func testWithLockExtendingLifetimeExtendsLifetimeOfStatePastReassignment() {
let lockedState = LockedState(initialState: TestObject())
lockedState.withLockExtendingLifetimeOfState { state in
weak var oldState = state
state = TestObject()
XCTAssertNotNil(oldState, "State object lifetime was not extended after reassignment within body")
}
}
func testWithLockExtendingLifetimeExtendsLifetimeOfStatePastEndOfLockedScope() {
let lockedState: LockedState<TestObject> = {
let state = TestObject()
let lockedState = LockedState(initialState: state)
// `withLockExtendingLifetimeOfState()` should extend the lifetime of the state until after the lock is
// released. By asserting that the lock is not held when the state object is deinit-ed, we can confirm
// that the lifetime was extended past the end of the locked scope.
state.deinitBlock = {
assertLockNotHeld(lockedState, "State object lifetime was not extended to end of locked scope")
}
return lockedState
}()
lockedState.withLockExtendingLifetimeOfState { state in
state = TestObject()
}
}
func testWithLockExtendingLifetimeDoesNotExtendLifetimeOfStatePastEndOfCall() {
weak var state: TestObject?
let lockedState: LockedState<TestObject>
(state, lockedState) = {
let state = TestObject()
return (state, LockedState(initialState: state))
}()
lockedState.withLockExtendingLifetimeOfState { state in
state = TestObject()
}
XCTAssertNil(state, "State object lifetime was extended beyond end of call")
}
func testWithLockExtendingLifetimeReleasesLockWhenBodyThrows() {
let lockedState = LockedState(initialState: TestObject())
XCTAssertThrowsError(
try lockedState.withLockExtendingLifetimeOfState { _ in
throw TestError()
},
"The body was expected to throw an error, but it did not."
)
assertLockNotHeld(lockedState, "Lock was not properly released by withLockExtendingLifetimeOfState()")
}
}
/// Assert that the locked state is not currently locked.
///
/// ⚠️ This assertion fails by crashing. If the lock is currently held, the `withLock()` call will abort the program.
private func assertLockNotHeld<Value>(_ lockedState: LockedState<Value>, _ message: @autoclosure () -> String) {
// Note: Since the assertion fails by crashing, `message` is never logged.
lockedState.withLock { _ in
// PASS
}
}
|
