mirror of
https://github.com/apple/swift-atomics
synced 2026-11-22 04:20:39 +00:00
[test] Don’t report failures when weakCompareExchange to spuriously fails
This commit is contained in:
27 files changed
+7837
-6006
No files matched your search
@@ -125,13 +125,12 @@ class BasicAtomic${label}Tests: XCTestCase {
|
||||
|
||||
% end
|
||||
|
||||
% for operation in ["compareExchange", "weakCompareExchange"]:
|
||||
% for (order, _, _, _, _) in updateOrderings:
|
||||
func test_${operation}_${order}() {
|
||||
% for (order, _, _, _, _) in updateOrderings:
|
||||
func test_compareExchange_${order}() {
|
||||
let v: UnsafeAtomic<${type}> = .create(${a})
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, ${type}) = v.${operation}(
|
||||
var (exchanged, original): (Bool, ${type}) = v.compareExchange(
|
||||
expected: ${a},
|
||||
desired: ${b},
|
||||
ordering: .${order})
|
||||
@@ -139,7 +138,7 @@ class BasicAtomic${label}Tests: XCTestCase {
|
||||
XCTAssertEqual(original, ${a})
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), ${b})
|
||||
|
||||
(exchanged, original) = v.${operation}(
|
||||
(exchanged, original) = v.compareExchange(
|
||||
expected: ${a},
|
||||
desired: ${b},
|
||||
ordering: .${order})
|
||||
@@ -147,7 +146,7 @@ class BasicAtomic${label}Tests: XCTestCase {
|
||||
XCTAssertEqual(original, ${b})
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), ${b})
|
||||
|
||||
(exchanged, original) = v.${operation}(
|
||||
(exchanged, original) = v.compareExchange(
|
||||
expected: ${b},
|
||||
desired: ${a},
|
||||
ordering: .${order})
|
||||
@@ -155,7 +154,7 @@ class BasicAtomic${label}Tests: XCTestCase {
|
||||
XCTAssertEqual(original, ${b})
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), ${a})
|
||||
|
||||
(exchanged, original) = v.${operation}(
|
||||
(exchanged, original) = v.compareExchange(
|
||||
expected: ${b},
|
||||
desired: ${a},
|
||||
ordering: .${order})
|
||||
@@ -164,26 +163,116 @@ class BasicAtomic${label}Tests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), ${a})
|
||||
}
|
||||
|
||||
% end
|
||||
|
||||
% for (order, _, _, _, _) in updateOrderings:
|
||||
func test_weakCompareExchange_${order}() {
|
||||
let v: UnsafeAtomic<${type}> = .create(${a})
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, ${type})
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: ${a},
|
||||
desired: ${b},
|
||||
ordering: .${order})
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, ${a})
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), ${b})
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: ${a},
|
||||
desired: ${b},
|
||||
ordering: .${order})
|
||||
XCTAssertFalse(exchanged)
|
||||
XCTAssertEqual(original, ${b})
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), ${b})
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: ${b},
|
||||
desired: ${a},
|
||||
ordering: .${order})
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, ${b})
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), ${a})
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: ${b},
|
||||
desired: ${a},
|
||||
ordering: .${order})
|
||||
XCTAssertFalse(exchanged)
|
||||
XCTAssertEqual(original, ${a})
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), ${a})
|
||||
}
|
||||
|
||||
% end
|
||||
|
||||
% for (successorder, _, _, _, _) in updateOrderings:
|
||||
% for (failorder, _, _, _) in loadOrderings:
|
||||
func test_compareExchange_${successorder}_${failorder}() {
|
||||
let v: UnsafeAtomic<${type}> = .create(${a})
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, ${type}) = v.compareExchange(
|
||||
expected: ${a},
|
||||
desired: ${b},
|
||||
successOrdering: .${successorder},
|
||||
failureOrdering: .${failorder})
|
||||
XCTAssertTrue(exchanged)
|
||||
XCTAssertEqual(original, ${a})
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), ${b})
|
||||
|
||||
(exchanged, original) = v.compareExchange(
|
||||
expected: ${a},
|
||||
desired: ${b},
|
||||
successOrdering: .${successorder},
|
||||
failureOrdering: .${failorder})
|
||||
XCTAssertFalse(exchanged)
|
||||
XCTAssertEqual(original, ${b})
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), ${b})
|
||||
|
||||
(exchanged, original) = v.compareExchange(
|
||||
expected: ${b},
|
||||
desired: ${a},
|
||||
successOrdering: .${successorder},
|
||||
failureOrdering: .${failorder})
|
||||
XCTAssertTrue(exchanged)
|
||||
XCTAssertEqual(original, ${b})
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), ${a})
|
||||
|
||||
(exchanged, original) = v.compareExchange(
|
||||
expected: ${b},
|
||||
desired: ${a},
|
||||
successOrdering: .${successorder},
|
||||
failureOrdering: .${failorder})
|
||||
XCTAssertFalse(exchanged)
|
||||
XCTAssertEqual(original, ${a})
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), ${a})
|
||||
}
|
||||
|
||||
% end
|
||||
% end
|
||||
|
||||
% for operation in ["compareExchange", "weakCompareExchange"]:
|
||||
% for (successorder, _, _, _, _) in updateOrderings:
|
||||
% for (failorder, _, _, _) in loadOrderings:
|
||||
func test_${operation}_${successorder}_${failorder}() {
|
||||
% for (successorder, _, _, _, _) in updateOrderings:
|
||||
% for (failorder, _, _, _) in loadOrderings:
|
||||
func test_weakCompareExchange_${successorder}_${failorder}() {
|
||||
let v: UnsafeAtomic<${type}> = .create(${a})
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, ${type}) = v.${operation}(
|
||||
expected: ${a},
|
||||
desired: ${b},
|
||||
successOrdering: .${successorder},
|
||||
failureOrdering: .${failorder})
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, ${type})
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: ${a},
|
||||
desired: ${b},
|
||||
successOrdering: .${successorder},
|
||||
failureOrdering: .${failorder})
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, ${a})
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), ${b})
|
||||
|
||||
(exchanged, original) = v.${operation}(
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: ${a},
|
||||
desired: ${b},
|
||||
successOrdering: .${successorder},
|
||||
@@ -192,16 +281,17 @@ class BasicAtomic${label}Tests: XCTestCase {
|
||||
XCTAssertEqual(original, ${b})
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), ${b})
|
||||
|
||||
(exchanged, original) = v.${operation}(
|
||||
expected: ${b},
|
||||
desired: ${a},
|
||||
successOrdering: .${successorder},
|
||||
failureOrdering: .${failorder})
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: ${b},
|
||||
desired: ${a},
|
||||
successOrdering: .${successorder},
|
||||
failureOrdering: .${failorder})
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, ${b})
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), ${a})
|
||||
|
||||
(exchanged, original) = v.${operation}(
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: ${b},
|
||||
desired: ${a},
|
||||
successOrdering: .${successorder},
|
||||
@@ -211,7 +301,6 @@ class BasicAtomic${label}Tests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), ${a})
|
||||
}
|
||||
|
||||
% end
|
||||
% end
|
||||
% end
|
||||
|
||||
|
||||
@@ -359,15 +359,19 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), true)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed() {
|
||||
let v: UnsafeAtomic<Bool> = .create(true)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Bool) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Bool)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, true)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
@@ -379,11 +383,12 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), true)
|
||||
|
||||
@@ -400,11 +405,14 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Bool> = .create(true)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Bool) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Bool)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, true)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
@@ -416,11 +424,12 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), true)
|
||||
|
||||
@@ -437,11 +446,14 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Bool> = .create(true)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Bool) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Bool)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, true)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
@@ -453,11 +465,12 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), true)
|
||||
|
||||
@@ -474,11 +487,14 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Bool> = .create(true)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Bool) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Bool)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, true)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
@@ -490,11 +506,12 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), true)
|
||||
|
||||
@@ -511,11 +528,14 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Bool> = .create(true)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Bool) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Bool)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, true)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
@@ -527,11 +547,12 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), true)
|
||||
|
||||
@@ -1160,16 +1181,19 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), true)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed_relaxed() {
|
||||
let v: UnsafeAtomic<Bool> = .create(true)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Bool) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Bool)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, true)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
@@ -1182,12 +1206,13 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), true)
|
||||
|
||||
@@ -1205,12 +1230,14 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Bool> = .create(true)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Bool) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Bool)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, true)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
@@ -1223,12 +1250,13 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), true)
|
||||
|
||||
@@ -1246,12 +1274,14 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Bool> = .create(true)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Bool) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Bool)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, true)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
@@ -1264,12 +1294,13 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), true)
|
||||
|
||||
@@ -1287,12 +1318,14 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Bool> = .create(true)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Bool) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Bool)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, true)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
@@ -1305,12 +1338,13 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), true)
|
||||
|
||||
@@ -1328,12 +1362,14 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Bool> = .create(true)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Bool) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Bool)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, true)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
@@ -1346,12 +1382,13 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), true)
|
||||
|
||||
@@ -1369,12 +1406,14 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Bool> = .create(true)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Bool) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Bool)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, true)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
@@ -1387,12 +1426,13 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), true)
|
||||
|
||||
@@ -1410,12 +1450,14 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Bool> = .create(true)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Bool) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Bool)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, true)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
@@ -1428,12 +1470,13 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), true)
|
||||
|
||||
@@ -1451,12 +1494,14 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Bool> = .create(true)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Bool) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Bool)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, true)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
@@ -1469,12 +1514,13 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), true)
|
||||
|
||||
@@ -1492,12 +1538,14 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Bool> = .create(true)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Bool) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Bool)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, true)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
@@ -1510,12 +1558,13 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), true)
|
||||
|
||||
@@ -1533,12 +1582,14 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Bool> = .create(true)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Bool) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Bool)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, true)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
@@ -1551,12 +1602,13 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), true)
|
||||
|
||||
@@ -1574,12 +1626,14 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Bool> = .create(true)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Bool) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Bool)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, true)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
@@ -1592,12 +1646,13 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), true)
|
||||
|
||||
@@ -1615,12 +1670,14 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Bool> = .create(true)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Bool) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Bool)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, true)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
@@ -1633,12 +1690,13 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), true)
|
||||
|
||||
@@ -1656,12 +1714,14 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Bool> = .create(true)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Bool) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Bool)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, true)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
@@ -1674,12 +1734,13 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), true)
|
||||
|
||||
@@ -1697,12 +1758,14 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Bool> = .create(true)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Bool) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Bool)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, true)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
@@ -1715,12 +1778,13 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), true)
|
||||
|
||||
@@ -1738,12 +1802,14 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Bool> = .create(true)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Bool) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Bool)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: true,
|
||||
desired: false,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, true)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
@@ -1756,12 +1822,13 @@ class BasicAtomicBoolTests: XCTestCase {
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), false)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: false,
|
||||
desired: true,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, false)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), true)
|
||||
|
||||
|
||||
@@ -359,15 +359,19 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 100, second: 64))
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed() {
|
||||
let v: UnsafeAtomic<DoubleWord> = .create(DoubleWord(first: 100, second: 64))
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, DoubleWord) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, DoubleWord)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 100, second: 64))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
@@ -379,11 +383,12 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 100, second: 64))
|
||||
|
||||
@@ -400,11 +405,14 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
let v: UnsafeAtomic<DoubleWord> = .create(DoubleWord(first: 100, second: 64))
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, DoubleWord) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, DoubleWord)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 100, second: 64))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
@@ -416,11 +424,12 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 100, second: 64))
|
||||
|
||||
@@ -437,11 +446,14 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
let v: UnsafeAtomic<DoubleWord> = .create(DoubleWord(first: 100, second: 64))
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, DoubleWord) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, DoubleWord)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 100, second: 64))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
@@ -453,11 +465,12 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 100, second: 64))
|
||||
|
||||
@@ -474,11 +487,14 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
let v: UnsafeAtomic<DoubleWord> = .create(DoubleWord(first: 100, second: 64))
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, DoubleWord) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, DoubleWord)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 100, second: 64))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
@@ -490,11 +506,12 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 100, second: 64))
|
||||
|
||||
@@ -511,11 +528,14 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
let v: UnsafeAtomic<DoubleWord> = .create(DoubleWord(first: 100, second: 64))
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, DoubleWord) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, DoubleWord)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 100, second: 64))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
@@ -527,11 +547,12 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 100, second: 64))
|
||||
|
||||
@@ -1160,16 +1181,19 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 100, second: 64))
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed_relaxed() {
|
||||
let v: UnsafeAtomic<DoubleWord> = .create(DoubleWord(first: 100, second: 64))
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, DoubleWord) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, DoubleWord)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 100, second: 64))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
@@ -1182,12 +1206,13 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 100, second: 64))
|
||||
|
||||
@@ -1205,12 +1230,14 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
let v: UnsafeAtomic<DoubleWord> = .create(DoubleWord(first: 100, second: 64))
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, DoubleWord) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, DoubleWord)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 100, second: 64))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
@@ -1223,12 +1250,13 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 100, second: 64))
|
||||
|
||||
@@ -1246,12 +1274,14 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
let v: UnsafeAtomic<DoubleWord> = .create(DoubleWord(first: 100, second: 64))
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, DoubleWord) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, DoubleWord)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 100, second: 64))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
@@ -1264,12 +1294,13 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 100, second: 64))
|
||||
|
||||
@@ -1287,12 +1318,14 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
let v: UnsafeAtomic<DoubleWord> = .create(DoubleWord(first: 100, second: 64))
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, DoubleWord) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, DoubleWord)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 100, second: 64))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
@@ -1305,12 +1338,13 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 100, second: 64))
|
||||
|
||||
@@ -1328,12 +1362,14 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
let v: UnsafeAtomic<DoubleWord> = .create(DoubleWord(first: 100, second: 64))
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, DoubleWord) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, DoubleWord)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 100, second: 64))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
@@ -1346,12 +1382,13 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 100, second: 64))
|
||||
|
||||
@@ -1369,12 +1406,14 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
let v: UnsafeAtomic<DoubleWord> = .create(DoubleWord(first: 100, second: 64))
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, DoubleWord) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, DoubleWord)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 100, second: 64))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
@@ -1387,12 +1426,13 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 100, second: 64))
|
||||
|
||||
@@ -1410,12 +1450,14 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
let v: UnsafeAtomic<DoubleWord> = .create(DoubleWord(first: 100, second: 64))
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, DoubleWord) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, DoubleWord)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 100, second: 64))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
@@ -1428,12 +1470,13 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 100, second: 64))
|
||||
|
||||
@@ -1451,12 +1494,14 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
let v: UnsafeAtomic<DoubleWord> = .create(DoubleWord(first: 100, second: 64))
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, DoubleWord) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, DoubleWord)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 100, second: 64))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
@@ -1469,12 +1514,13 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 100, second: 64))
|
||||
|
||||
@@ -1492,12 +1538,14 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
let v: UnsafeAtomic<DoubleWord> = .create(DoubleWord(first: 100, second: 64))
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, DoubleWord) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, DoubleWord)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 100, second: 64))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
@@ -1510,12 +1558,13 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 100, second: 64))
|
||||
|
||||
@@ -1533,12 +1582,14 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
let v: UnsafeAtomic<DoubleWord> = .create(DoubleWord(first: 100, second: 64))
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, DoubleWord) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, DoubleWord)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 100, second: 64))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
@@ -1551,12 +1602,13 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 100, second: 64))
|
||||
|
||||
@@ -1574,12 +1626,14 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
let v: UnsafeAtomic<DoubleWord> = .create(DoubleWord(first: 100, second: 64))
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, DoubleWord) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, DoubleWord)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 100, second: 64))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
@@ -1592,12 +1646,13 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 100, second: 64))
|
||||
|
||||
@@ -1615,12 +1670,14 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
let v: UnsafeAtomic<DoubleWord> = .create(DoubleWord(first: 100, second: 64))
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, DoubleWord) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, DoubleWord)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 100, second: 64))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
@@ -1633,12 +1690,13 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 100, second: 64))
|
||||
|
||||
@@ -1656,12 +1714,14 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
let v: UnsafeAtomic<DoubleWord> = .create(DoubleWord(first: 100, second: 64))
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, DoubleWord) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, DoubleWord)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 100, second: 64))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
@@ -1674,12 +1734,13 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 100, second: 64))
|
||||
|
||||
@@ -1697,12 +1758,14 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
let v: UnsafeAtomic<DoubleWord> = .create(DoubleWord(first: 100, second: 64))
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, DoubleWord) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, DoubleWord)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 100, second: 64))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
@@ -1715,12 +1778,13 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 100, second: 64))
|
||||
|
||||
@@ -1738,12 +1802,14 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
let v: UnsafeAtomic<DoubleWord> = .create(DoubleWord(first: 100, second: 64))
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, DoubleWord) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, DoubleWord)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 100, second: 64),
|
||||
desired: DoubleWord(first: 50, second: 32),
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 100, second: 64))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
@@ -1756,12 +1822,13 @@ class BasicAtomicDoubleWordTests: XCTestCase {
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: DoubleWord(first: 50, second: 32),
|
||||
desired: DoubleWord(first: 100, second: 64),
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 100, second: 64))
|
||||
|
||||
|
||||
@@ -359,15 +359,19 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed() {
|
||||
let v: UnsafeAtomic<Int16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int16)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -379,11 +383,12 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -400,11 +405,14 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int16)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -416,11 +424,12 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -437,11 +446,14 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int16)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -453,11 +465,12 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -474,11 +487,14 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int16)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -490,11 +506,12 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -511,11 +528,14 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int16)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -527,11 +547,12 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1160,16 +1181,19 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed_relaxed() {
|
||||
let v: UnsafeAtomic<Int16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int16)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1182,12 +1206,13 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1205,12 +1230,14 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int16)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1223,12 +1250,13 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1246,12 +1274,14 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int16)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1264,12 +1294,13 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1287,12 +1318,14 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int16)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1305,12 +1338,13 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1328,12 +1362,14 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int16)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1346,12 +1382,13 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1369,12 +1406,14 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int16)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1387,12 +1426,13 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1410,12 +1450,14 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int16)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1428,12 +1470,13 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1451,12 +1494,14 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int16)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1469,12 +1514,13 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1492,12 +1538,14 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int16)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1510,12 +1558,13 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1533,12 +1582,14 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int16)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1551,12 +1602,13 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1574,12 +1626,14 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int16)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1592,12 +1646,13 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1615,12 +1670,14 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int16)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1633,12 +1690,13 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1656,12 +1714,14 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int16)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1674,12 +1734,13 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1697,12 +1758,14 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int16)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1715,12 +1778,13 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1738,12 +1802,14 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int16)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1756,12 +1822,13 @@ class BasicAtomicInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
|
||||
@@ -359,15 +359,19 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed() {
|
||||
let v: UnsafeAtomic<Int32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int32)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -379,11 +383,12 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -400,11 +405,14 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int32)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -416,11 +424,12 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -437,11 +446,14 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int32)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -453,11 +465,12 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -474,11 +487,14 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int32)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -490,11 +506,12 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -511,11 +528,14 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int32)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -527,11 +547,12 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1160,16 +1181,19 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed_relaxed() {
|
||||
let v: UnsafeAtomic<Int32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int32)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1182,12 +1206,13 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1205,12 +1230,14 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int32)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1223,12 +1250,13 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1246,12 +1274,14 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int32)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1264,12 +1294,13 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1287,12 +1318,14 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int32)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1305,12 +1338,13 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1328,12 +1362,14 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int32)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1346,12 +1382,13 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1369,12 +1406,14 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int32)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1387,12 +1426,13 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1410,12 +1450,14 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int32)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1428,12 +1470,13 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1451,12 +1494,14 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int32)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1469,12 +1514,13 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1492,12 +1538,14 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int32)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1510,12 +1558,13 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1533,12 +1582,14 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int32)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1551,12 +1602,13 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1574,12 +1626,14 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int32)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1592,12 +1646,13 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1615,12 +1670,14 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int32)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1633,12 +1690,13 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1656,12 +1714,14 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int32)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1674,12 +1734,13 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1697,12 +1758,14 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int32)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1715,12 +1778,13 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1738,12 +1802,14 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int32)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1756,12 +1822,13 @@ class BasicAtomicInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
|
||||
@@ -359,15 +359,19 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed() {
|
||||
let v: UnsafeAtomic<Int64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int64)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -379,11 +383,12 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -400,11 +405,14 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int64)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -416,11 +424,12 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -437,11 +446,14 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int64)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -453,11 +465,12 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -474,11 +487,14 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int64)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -490,11 +506,12 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -511,11 +528,14 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int64)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -527,11 +547,12 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1160,16 +1181,19 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed_relaxed() {
|
||||
let v: UnsafeAtomic<Int64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int64)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1182,12 +1206,13 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1205,12 +1230,14 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int64)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1223,12 +1250,13 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1246,12 +1274,14 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int64)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1264,12 +1294,13 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1287,12 +1318,14 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int64)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1305,12 +1338,13 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1328,12 +1362,14 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int64)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1346,12 +1382,13 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1369,12 +1406,14 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int64)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1387,12 +1426,13 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1410,12 +1450,14 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int64)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1428,12 +1470,13 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1451,12 +1494,14 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int64)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1469,12 +1514,13 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1492,12 +1538,14 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int64)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1510,12 +1558,13 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1533,12 +1582,14 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int64)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1551,12 +1602,13 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1574,12 +1626,14 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int64)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1592,12 +1646,13 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1615,12 +1670,14 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int64)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1633,12 +1690,13 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1656,12 +1714,14 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int64)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1674,12 +1734,13 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1697,12 +1758,14 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int64)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1715,12 +1778,13 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1738,12 +1802,14 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int64)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1756,12 +1822,13 @@ class BasicAtomicInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
|
||||
@@ -359,15 +359,19 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed() {
|
||||
let v: UnsafeAtomic<Int8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int8)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -379,11 +383,12 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -400,11 +405,14 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int8)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -416,11 +424,12 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -437,11 +446,14 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int8)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -453,11 +465,12 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -474,11 +487,14 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int8)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -490,11 +506,12 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -511,11 +528,14 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int8)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -527,11 +547,12 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1160,16 +1181,19 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed_relaxed() {
|
||||
let v: UnsafeAtomic<Int8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int8)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1182,12 +1206,13 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1205,12 +1230,14 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int8)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1223,12 +1250,13 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1246,12 +1274,14 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int8)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1264,12 +1294,13 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1287,12 +1318,14 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int8)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1305,12 +1338,13 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1328,12 +1362,14 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int8)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1346,12 +1382,13 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1369,12 +1406,14 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int8)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1387,12 +1426,13 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1410,12 +1450,14 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int8)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1428,12 +1470,13 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1451,12 +1494,14 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int8)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1469,12 +1514,13 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1492,12 +1538,14 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int8)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1510,12 +1558,13 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1533,12 +1582,14 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int8)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1551,12 +1602,13 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1574,12 +1626,14 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int8)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1592,12 +1646,13 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1615,12 +1670,14 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int8)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1633,12 +1690,13 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1656,12 +1714,14 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int8)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1674,12 +1734,13 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1697,12 +1758,14 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int8)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1715,12 +1778,13 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1738,12 +1802,14 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int8)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1756,12 +1822,13 @@ class BasicAtomicInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
|
||||
@@ -359,15 +359,19 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed() {
|
||||
let v: UnsafeAtomic<Int> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -379,11 +383,12 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -400,11 +405,14 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -416,11 +424,12 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -437,11 +446,14 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -453,11 +465,12 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -474,11 +487,14 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -490,11 +506,12 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -511,11 +528,14 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -527,11 +547,12 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1160,16 +1181,19 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed_relaxed() {
|
||||
let v: UnsafeAtomic<Int> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1182,12 +1206,13 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1205,12 +1230,14 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1223,12 +1250,13 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1246,12 +1274,14 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1264,12 +1294,13 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1287,12 +1318,14 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1305,12 +1338,13 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1328,12 +1362,14 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1346,12 +1382,13 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1369,12 +1406,14 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1387,12 +1426,13 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1410,12 +1450,14 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1428,12 +1470,13 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1451,12 +1494,14 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1469,12 +1514,13 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1492,12 +1538,14 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1510,12 +1558,13 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1533,12 +1582,14 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1551,12 +1602,13 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1574,12 +1626,14 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1592,12 +1646,13 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1615,12 +1670,14 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1633,12 +1690,13 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1656,12 +1714,14 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1674,12 +1734,13 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1697,12 +1758,14 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1715,12 +1778,13 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1738,12 +1802,14 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Int> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Int) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Int)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1756,12 +1822,13 @@ class BasicAtomicIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
|
||||
@@ -380,15 +380,19 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed() {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>> = .create(_mfoo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -400,11 +404,12 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1)
|
||||
|
||||
@@ -421,11 +426,14 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>> = .create(_mfoo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -437,11 +445,12 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1)
|
||||
|
||||
@@ -458,11 +467,14 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>> = .create(_mfoo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -474,11 +486,12 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1)
|
||||
|
||||
@@ -495,11 +508,14 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>> = .create(_mfoo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -511,11 +527,12 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1)
|
||||
|
||||
@@ -532,11 +549,14 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>> = .create(_mfoo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -548,11 +568,12 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1)
|
||||
|
||||
@@ -1181,16 +1202,19 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed_relaxed() {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>> = .create(_mfoo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -1203,12 +1227,13 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1)
|
||||
|
||||
@@ -1226,12 +1251,14 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>> = .create(_mfoo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -1244,12 +1271,13 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1)
|
||||
|
||||
@@ -1267,12 +1295,14 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>> = .create(_mfoo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -1285,12 +1315,13 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1)
|
||||
|
||||
@@ -1308,12 +1339,14 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>> = .create(_mfoo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -1326,12 +1359,13 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1)
|
||||
|
||||
@@ -1349,12 +1383,14 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>> = .create(_mfoo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -1367,12 +1403,13 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1)
|
||||
|
||||
@@ -1390,12 +1427,14 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>> = .create(_mfoo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -1408,12 +1447,13 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1)
|
||||
|
||||
@@ -1431,12 +1471,14 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>> = .create(_mfoo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -1449,12 +1491,13 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1)
|
||||
|
||||
@@ -1472,12 +1515,14 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>> = .create(_mfoo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -1490,12 +1535,13 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1)
|
||||
|
||||
@@ -1513,12 +1559,14 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>> = .create(_mfoo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -1531,12 +1579,13 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1)
|
||||
|
||||
@@ -1554,12 +1603,14 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>> = .create(_mfoo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -1572,12 +1623,13 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1)
|
||||
|
||||
@@ -1595,12 +1647,14 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>> = .create(_mfoo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -1613,12 +1667,13 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1)
|
||||
|
||||
@@ -1636,12 +1691,14 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>> = .create(_mfoo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -1654,12 +1711,13 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1)
|
||||
|
||||
@@ -1677,12 +1735,14 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>> = .create(_mfoo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -1695,12 +1755,13 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1)
|
||||
|
||||
@@ -1718,12 +1779,14 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>> = .create(_mfoo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -1736,12 +1799,13 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1)
|
||||
|
||||
@@ -1759,12 +1823,14 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>> = .create(_mfoo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo1,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -1777,12 +1843,13 @@ class BasicAtomicMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: _mfoo1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1)
|
||||
|
||||
|
||||
@@ -369,15 +369,19 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw1)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed() {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer> = .create(_mraw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -389,11 +393,12 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw1)
|
||||
|
||||
@@ -410,11 +415,14 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer> = .create(_mraw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -426,11 +434,12 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw1)
|
||||
|
||||
@@ -447,11 +456,14 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer> = .create(_mraw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -463,11 +475,12 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw1)
|
||||
|
||||
@@ -484,11 +497,14 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer> = .create(_mraw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -500,11 +516,12 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw1)
|
||||
|
||||
@@ -521,11 +538,14 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer> = .create(_mraw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -537,11 +557,12 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw1)
|
||||
|
||||
@@ -1170,16 +1191,19 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw1)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed_relaxed() {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer> = .create(_mraw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -1192,12 +1216,13 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw1)
|
||||
|
||||
@@ -1215,12 +1240,14 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer> = .create(_mraw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -1233,12 +1260,13 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw1)
|
||||
|
||||
@@ -1256,12 +1284,14 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer> = .create(_mraw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -1274,12 +1304,13 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw1)
|
||||
|
||||
@@ -1297,12 +1328,14 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer> = .create(_mraw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -1315,12 +1348,13 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw1)
|
||||
|
||||
@@ -1338,12 +1372,14 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer> = .create(_mraw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -1356,12 +1392,13 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw1)
|
||||
|
||||
@@ -1379,12 +1416,14 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer> = .create(_mraw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -1397,12 +1436,13 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw1)
|
||||
|
||||
@@ -1420,12 +1460,14 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer> = .create(_mraw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -1438,12 +1480,13 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw1)
|
||||
|
||||
@@ -1461,12 +1504,14 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer> = .create(_mraw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -1479,12 +1524,13 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw1)
|
||||
|
||||
@@ -1502,12 +1548,14 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer> = .create(_mraw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -1520,12 +1568,13 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw1)
|
||||
|
||||
@@ -1543,12 +1592,14 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer> = .create(_mraw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -1561,12 +1612,13 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw1)
|
||||
|
||||
@@ -1584,12 +1636,14 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer> = .create(_mraw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -1602,12 +1656,13 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw1)
|
||||
|
||||
@@ -1625,12 +1680,14 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer> = .create(_mraw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -1643,12 +1700,13 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw1)
|
||||
|
||||
@@ -1666,12 +1724,14 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer> = .create(_mraw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -1684,12 +1744,13 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw1)
|
||||
|
||||
@@ -1707,12 +1768,14 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer> = .create(_mraw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -1725,12 +1788,13 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw1)
|
||||
|
||||
@@ -1748,12 +1812,14 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer> = .create(_mraw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw1,
|
||||
desired: _mraw2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -1766,12 +1832,13 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: _mraw1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw1)
|
||||
|
||||
|
||||
+297
-230
@@ -380,15 +380,19 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed() {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -400,11 +404,12 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -421,11 +426,14 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -437,11 +445,12 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -458,11 +467,14 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -474,11 +486,12 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -495,11 +508,14 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -511,11 +527,12 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -532,11 +549,14 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -548,11 +568,12 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1181,16 +1202,19 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed_relaxed() {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -1203,12 +1227,13 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1226,12 +1251,14 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -1244,12 +1271,13 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1267,12 +1295,14 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -1285,12 +1315,13 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1308,12 +1339,14 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -1326,12 +1359,13 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1349,12 +1383,14 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -1367,12 +1403,13 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1390,12 +1427,14 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -1408,12 +1447,13 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1431,12 +1471,14 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -1449,12 +1491,13 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1472,12 +1515,14 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -1490,12 +1535,13 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1513,12 +1559,14 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -1531,12 +1579,13 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1554,12 +1603,14 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -1572,12 +1623,13 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1595,12 +1647,14 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -1613,12 +1667,13 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1636,12 +1691,14 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -1654,12 +1711,13 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1677,12 +1735,14 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -1695,12 +1755,13 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1718,12 +1779,14 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -1736,12 +1799,13 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1759,12 +1823,14 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mfoo2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
@@ -1777,12 +1843,13 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mfoo2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mfoo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
|
||||
+297
-230
@@ -369,15 +369,19 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed() {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -389,11 +393,12 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -410,11 +415,14 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -426,11 +434,12 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -447,11 +456,14 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -463,11 +475,12 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -484,11 +497,14 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -500,11 +516,12 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -521,11 +538,14 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -537,11 +557,12 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1170,16 +1191,19 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed_relaxed() {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -1192,12 +1216,13 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1215,12 +1240,14 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -1233,12 +1260,13 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1256,12 +1284,14 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -1274,12 +1304,13 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1297,12 +1328,14 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -1315,12 +1348,13 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1338,12 +1372,14 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -1356,12 +1392,13 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1379,12 +1416,14 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -1397,12 +1436,13 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1420,12 +1460,14 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -1438,12 +1480,13 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1461,12 +1504,14 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -1479,12 +1524,13 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1502,12 +1548,14 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -1520,12 +1568,13 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1543,12 +1592,14 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -1561,12 +1612,13 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1584,12 +1636,14 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -1602,12 +1656,13 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1625,12 +1680,14 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -1643,12 +1700,13 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1666,12 +1724,14 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -1684,12 +1744,13 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1707,12 +1768,14 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -1725,12 +1788,13 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1748,12 +1812,14 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeMutableRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeMutableRawPointer?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _mraw2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
@@ -1766,12 +1832,13 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _mraw2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _mraw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
|
||||
@@ -380,15 +380,19 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed() {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -400,11 +404,12 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -421,11 +426,14 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -437,11 +445,12 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -458,11 +467,14 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -474,11 +486,12 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -495,11 +508,14 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -511,11 +527,12 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -532,11 +549,14 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -548,11 +568,12 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1181,16 +1202,19 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed_relaxed() {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -1203,12 +1227,13 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1226,12 +1251,14 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -1244,12 +1271,13 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1267,12 +1295,14 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -1285,12 +1315,13 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1308,12 +1339,14 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -1326,12 +1359,13 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1349,12 +1383,14 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -1367,12 +1403,13 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1390,12 +1427,14 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -1408,12 +1447,13 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1431,12 +1471,14 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -1449,12 +1491,13 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1472,12 +1515,14 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -1490,12 +1535,13 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1513,12 +1559,14 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -1531,12 +1579,13 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1554,12 +1603,14 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -1572,12 +1623,13 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1595,12 +1647,14 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -1613,12 +1667,13 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1636,12 +1691,14 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -1654,12 +1711,13 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1677,12 +1735,14 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -1695,12 +1755,13 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1718,12 +1779,14 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -1736,12 +1799,13 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1759,12 +1823,14 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _foo2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -1777,12 +1843,13 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
|
||||
+297
-230
@@ -369,15 +369,19 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed() {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -389,11 +393,12 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -410,11 +415,14 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -426,11 +434,12 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -447,11 +456,14 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -463,11 +475,12 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -484,11 +497,14 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -500,11 +516,12 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -521,11 +538,14 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -537,11 +557,12 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1170,16 +1191,19 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed_relaxed() {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -1192,12 +1216,13 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1215,12 +1240,14 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -1233,12 +1260,13 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1256,12 +1284,14 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -1274,12 +1304,13 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1297,12 +1328,14 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -1315,12 +1348,13 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1338,12 +1372,14 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -1356,12 +1392,13 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1379,12 +1416,14 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -1397,12 +1436,13 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1420,12 +1460,14 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -1438,12 +1480,13 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1461,12 +1504,14 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -1479,12 +1524,13 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1502,12 +1548,14 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -1520,12 +1568,13 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1543,12 +1592,14 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -1561,12 +1612,13 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1584,12 +1636,14 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -1602,12 +1656,13 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1625,12 +1680,14 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -1643,12 +1700,13 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1666,12 +1724,14 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -1684,12 +1744,13 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1707,12 +1768,14 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -1725,12 +1788,13 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1748,12 +1812,14 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _raw2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -1766,12 +1832,13 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
|
||||
+297
-230
@@ -359,15 +359,19 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Hyacinth.bucket)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed() {
|
||||
let v: UnsafeAtomic<Hyacinth?> = .create(Hyacinth.bucket)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Hyacinth?) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Hyacinth?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Hyacinth.bucket)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -379,11 +383,12 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Hyacinth.bucket)
|
||||
|
||||
@@ -400,11 +405,14 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Hyacinth?> = .create(Hyacinth.bucket)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Hyacinth?) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Hyacinth?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Hyacinth.bucket)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -416,11 +424,12 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Hyacinth.bucket)
|
||||
|
||||
@@ -437,11 +446,14 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Hyacinth?> = .create(Hyacinth.bucket)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Hyacinth?) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Hyacinth?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Hyacinth.bucket)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -453,11 +465,12 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Hyacinth.bucket)
|
||||
|
||||
@@ -474,11 +487,14 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Hyacinth?> = .create(Hyacinth.bucket)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Hyacinth?) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Hyacinth?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Hyacinth.bucket)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -490,11 +506,12 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Hyacinth.bucket)
|
||||
|
||||
@@ -511,11 +528,14 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Hyacinth?> = .create(Hyacinth.bucket)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Hyacinth?) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Hyacinth?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Hyacinth.bucket)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -527,11 +547,12 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Hyacinth.bucket)
|
||||
|
||||
@@ -1160,16 +1181,19 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Hyacinth.bucket)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed_relaxed() {
|
||||
let v: UnsafeAtomic<Hyacinth?> = .create(Hyacinth.bucket)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Hyacinth?) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Hyacinth?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Hyacinth.bucket)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1182,12 +1206,13 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Hyacinth.bucket)
|
||||
|
||||
@@ -1205,12 +1230,14 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Hyacinth?> = .create(Hyacinth.bucket)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Hyacinth?) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Hyacinth?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Hyacinth.bucket)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1223,12 +1250,13 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Hyacinth.bucket)
|
||||
|
||||
@@ -1246,12 +1274,14 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Hyacinth?> = .create(Hyacinth.bucket)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Hyacinth?) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Hyacinth?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Hyacinth.bucket)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1264,12 +1294,13 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Hyacinth.bucket)
|
||||
|
||||
@@ -1287,12 +1318,14 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Hyacinth?> = .create(Hyacinth.bucket)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Hyacinth?) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Hyacinth?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Hyacinth.bucket)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1305,12 +1338,13 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Hyacinth.bucket)
|
||||
|
||||
@@ -1328,12 +1362,14 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Hyacinth?> = .create(Hyacinth.bucket)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Hyacinth?) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Hyacinth?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Hyacinth.bucket)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1346,12 +1382,13 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Hyacinth.bucket)
|
||||
|
||||
@@ -1369,12 +1406,14 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Hyacinth?> = .create(Hyacinth.bucket)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Hyacinth?) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Hyacinth?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Hyacinth.bucket)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1387,12 +1426,13 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Hyacinth.bucket)
|
||||
|
||||
@@ -1410,12 +1450,14 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Hyacinth?> = .create(Hyacinth.bucket)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Hyacinth?) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Hyacinth?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Hyacinth.bucket)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1428,12 +1470,13 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Hyacinth.bucket)
|
||||
|
||||
@@ -1451,12 +1494,14 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Hyacinth?> = .create(Hyacinth.bucket)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Hyacinth?) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Hyacinth?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Hyacinth.bucket)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1469,12 +1514,13 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Hyacinth.bucket)
|
||||
|
||||
@@ -1492,12 +1538,14 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Hyacinth?> = .create(Hyacinth.bucket)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Hyacinth?) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Hyacinth?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Hyacinth.bucket)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1510,12 +1558,13 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Hyacinth.bucket)
|
||||
|
||||
@@ -1533,12 +1582,14 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Hyacinth?> = .create(Hyacinth.bucket)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Hyacinth?) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Hyacinth?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Hyacinth.bucket)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1551,12 +1602,13 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Hyacinth.bucket)
|
||||
|
||||
@@ -1574,12 +1626,14 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Hyacinth?> = .create(Hyacinth.bucket)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Hyacinth?) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Hyacinth?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Hyacinth.bucket)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1592,12 +1646,13 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Hyacinth.bucket)
|
||||
|
||||
@@ -1615,12 +1670,14 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Hyacinth?> = .create(Hyacinth.bucket)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Hyacinth?) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Hyacinth?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Hyacinth.bucket)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1633,12 +1690,13 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Hyacinth.bucket)
|
||||
|
||||
@@ -1656,12 +1714,14 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Hyacinth?> = .create(Hyacinth.bucket)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Hyacinth?) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Hyacinth?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Hyacinth.bucket)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1674,12 +1734,13 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Hyacinth.bucket)
|
||||
|
||||
@@ -1697,12 +1758,14 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Hyacinth?> = .create(Hyacinth.bucket)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Hyacinth?) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Hyacinth?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Hyacinth.bucket)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1715,12 +1778,13 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Hyacinth.bucket)
|
||||
|
||||
@@ -1738,12 +1802,14 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Hyacinth?> = .create(Hyacinth.bucket)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Hyacinth?) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Hyacinth?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Hyacinth.bucket,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Hyacinth.bucket)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1756,12 +1822,13 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: Hyacinth.bucket,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Hyacinth.bucket)
|
||||
|
||||
|
||||
@@ -361,15 +361,19 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed() {
|
||||
let v: UnsafeAtomic<Baz?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -381,11 +385,12 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -402,11 +407,14 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -418,11 +426,12 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -439,11 +448,14 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -455,11 +467,12 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -476,11 +489,14 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -492,11 +508,12 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -513,11 +530,14 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -529,11 +549,12 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1162,16 +1183,19 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed_relaxed() {
|
||||
let v: UnsafeAtomic<Baz?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -1184,12 +1208,13 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1207,12 +1232,14 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -1225,12 +1252,13 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1248,12 +1276,14 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -1266,12 +1296,13 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1289,12 +1320,14 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -1307,12 +1340,13 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1330,12 +1364,14 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -1348,12 +1384,13 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1371,12 +1408,14 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -1389,12 +1428,13 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1412,12 +1452,14 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -1430,12 +1472,13 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1453,12 +1496,14 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -1471,12 +1516,13 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1494,12 +1540,14 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -1512,12 +1560,13 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1535,12 +1584,14 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -1553,12 +1604,13 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1576,12 +1628,14 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -1594,12 +1648,13 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1617,12 +1672,14 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -1635,12 +1692,13 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1658,12 +1716,14 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -1676,12 +1736,13 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1699,12 +1760,14 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -1717,12 +1780,13 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1740,12 +1804,14 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _baz2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -1758,12 +1824,13 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
|
||||
@@ -366,15 +366,19 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed() {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -386,11 +390,12 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -407,11 +412,14 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -423,11 +431,12 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -444,11 +453,14 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -460,11 +472,12 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -481,11 +494,14 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -497,11 +513,12 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -518,11 +535,14 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -534,11 +554,12 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1167,16 +1188,19 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed_relaxed() {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -1189,12 +1213,13 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1212,12 +1237,14 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -1230,12 +1257,13 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1253,12 +1281,14 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -1271,12 +1301,13 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1294,12 +1325,14 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -1312,12 +1345,13 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1335,12 +1369,14 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -1353,12 +1389,13 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1376,12 +1413,14 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -1394,12 +1433,13 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1417,12 +1457,14 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -1435,12 +1477,13 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1458,12 +1501,14 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -1476,12 +1521,13 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1499,12 +1545,14 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -1517,12 +1565,13 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1540,12 +1589,14 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -1558,12 +1609,13 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1581,12 +1633,14 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -1599,12 +1653,13 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1622,12 +1677,14 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -1640,12 +1697,13 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1663,12 +1721,14 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -1681,12 +1741,13 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1704,12 +1765,14 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -1722,12 +1785,13 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
@@ -1745,12 +1809,14 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>?> = .create(nil)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>?)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: nil,
|
||||
desired: _bar2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, nil)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -1763,12 +1829,13 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: nil,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), nil)
|
||||
|
||||
|
||||
@@ -380,15 +380,19 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo1)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed() {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>> = .create(_foo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -400,11 +404,12 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo1)
|
||||
|
||||
@@ -421,11 +426,14 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>> = .create(_foo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -437,11 +445,12 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo1)
|
||||
|
||||
@@ -458,11 +467,14 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>> = .create(_foo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -474,11 +486,12 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo1)
|
||||
|
||||
@@ -495,11 +508,14 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>> = .create(_foo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -511,11 +527,12 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo1)
|
||||
|
||||
@@ -532,11 +549,14 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>> = .create(_foo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -548,11 +568,12 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo1)
|
||||
|
||||
@@ -1181,16 +1202,19 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo1)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed_relaxed() {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>> = .create(_foo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -1203,12 +1227,13 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo1)
|
||||
|
||||
@@ -1226,12 +1251,14 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>> = .create(_foo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -1244,12 +1271,13 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo1)
|
||||
|
||||
@@ -1267,12 +1295,14 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>> = .create(_foo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -1285,12 +1315,13 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo1)
|
||||
|
||||
@@ -1308,12 +1339,14 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>> = .create(_foo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -1326,12 +1359,13 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo1)
|
||||
|
||||
@@ -1349,12 +1383,14 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>> = .create(_foo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -1367,12 +1403,13 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo1)
|
||||
|
||||
@@ -1390,12 +1427,14 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>> = .create(_foo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -1408,12 +1447,13 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo1)
|
||||
|
||||
@@ -1431,12 +1471,14 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>> = .create(_foo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -1449,12 +1491,13 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo1)
|
||||
|
||||
@@ -1472,12 +1515,14 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>> = .create(_foo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -1490,12 +1535,13 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo1)
|
||||
|
||||
@@ -1513,12 +1559,14 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>> = .create(_foo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -1531,12 +1579,13 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo1)
|
||||
|
||||
@@ -1554,12 +1603,14 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>> = .create(_foo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -1572,12 +1623,13 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo1)
|
||||
|
||||
@@ -1595,12 +1647,14 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>> = .create(_foo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -1613,12 +1667,13 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo1)
|
||||
|
||||
@@ -1636,12 +1691,14 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>> = .create(_foo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -1654,12 +1711,13 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo1)
|
||||
|
||||
@@ -1677,12 +1735,14 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>> = .create(_foo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -1695,12 +1755,13 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo1)
|
||||
|
||||
@@ -1718,12 +1779,14 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>> = .create(_foo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -1736,12 +1799,13 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo1)
|
||||
|
||||
@@ -1759,12 +1823,14 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafePointer<Foo>> = .create(_foo1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafePointer<Foo>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo1,
|
||||
desired: _foo2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
@@ -1777,12 +1843,13 @@ class BasicAtomicPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _foo2,
|
||||
desired: _foo1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _foo2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _foo1)
|
||||
|
||||
|
||||
@@ -369,15 +369,19 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw1)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed() {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer> = .create(_raw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -389,11 +393,12 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw1)
|
||||
|
||||
@@ -410,11 +415,14 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer> = .create(_raw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -426,11 +434,12 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw1)
|
||||
|
||||
@@ -447,11 +456,14 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer> = .create(_raw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -463,11 +475,12 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw1)
|
||||
|
||||
@@ -484,11 +497,14 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer> = .create(_raw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -500,11 +516,12 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw1)
|
||||
|
||||
@@ -521,11 +538,14 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer> = .create(_raw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -537,11 +557,12 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw1)
|
||||
|
||||
@@ -1170,16 +1191,19 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw1)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed_relaxed() {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer> = .create(_raw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -1192,12 +1216,13 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw1)
|
||||
|
||||
@@ -1215,12 +1240,14 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer> = .create(_raw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -1233,12 +1260,13 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw1)
|
||||
|
||||
@@ -1256,12 +1284,14 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer> = .create(_raw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -1274,12 +1304,13 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw1)
|
||||
|
||||
@@ -1297,12 +1328,14 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer> = .create(_raw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -1315,12 +1348,13 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw1)
|
||||
|
||||
@@ -1338,12 +1372,14 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer> = .create(_raw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -1356,12 +1392,13 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw1)
|
||||
|
||||
@@ -1379,12 +1416,14 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer> = .create(_raw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -1397,12 +1436,13 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw1)
|
||||
|
||||
@@ -1420,12 +1460,14 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer> = .create(_raw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -1438,12 +1480,13 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw1)
|
||||
|
||||
@@ -1461,12 +1504,14 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer> = .create(_raw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -1479,12 +1524,13 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw1)
|
||||
|
||||
@@ -1502,12 +1548,14 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer> = .create(_raw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -1520,12 +1568,13 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw1)
|
||||
|
||||
@@ -1543,12 +1592,14 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer> = .create(_raw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -1561,12 +1612,13 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw1)
|
||||
|
||||
@@ -1584,12 +1636,14 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer> = .create(_raw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -1602,12 +1656,13 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw1)
|
||||
|
||||
@@ -1625,12 +1680,14 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer> = .create(_raw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -1643,12 +1700,13 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw1)
|
||||
|
||||
@@ -1666,12 +1724,14 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer> = .create(_raw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -1684,12 +1744,13 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw1)
|
||||
|
||||
@@ -1707,12 +1768,14 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer> = .create(_raw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -1725,12 +1788,13 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw1)
|
||||
|
||||
@@ -1748,12 +1812,14 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UnsafeRawPointer> = .create(_raw1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UnsafeRawPointer)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw1,
|
||||
desired: _raw2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
@@ -1766,12 +1832,13 @@ class BasicAtomicRawPointerTests: XCTestCase {
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _raw2,
|
||||
desired: _raw1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _raw2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _raw1)
|
||||
|
||||
|
||||
@@ -359,15 +359,19 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.one)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed() {
|
||||
let v: UnsafeAtomic<Fred> = .create(Fred.one)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Fred) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Fred)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.one)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
@@ -379,11 +383,12 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.one)
|
||||
|
||||
@@ -400,11 +405,14 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Fred> = .create(Fred.one)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Fred) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Fred)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.one)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
@@ -416,11 +424,12 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.one)
|
||||
|
||||
@@ -437,11 +446,14 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Fred> = .create(Fred.one)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Fred) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Fred)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.one)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
@@ -453,11 +465,12 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.one)
|
||||
|
||||
@@ -474,11 +487,14 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Fred> = .create(Fred.one)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Fred) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Fred)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.one)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
@@ -490,11 +506,12 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.one)
|
||||
|
||||
@@ -511,11 +528,14 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Fred> = .create(Fred.one)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Fred) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Fred)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.one)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
@@ -527,11 +547,12 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.one)
|
||||
|
||||
@@ -1160,16 +1181,19 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.one)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed_relaxed() {
|
||||
let v: UnsafeAtomic<Fred> = .create(Fred.one)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Fred) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Fred)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.one)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
@@ -1182,12 +1206,13 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.one)
|
||||
|
||||
@@ -1205,12 +1230,14 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Fred> = .create(Fred.one)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Fred) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Fred)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.one)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
@@ -1223,12 +1250,13 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.one)
|
||||
|
||||
@@ -1246,12 +1274,14 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Fred> = .create(Fred.one)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Fred) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Fred)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.one)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
@@ -1264,12 +1294,13 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.one)
|
||||
|
||||
@@ -1287,12 +1318,14 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Fred> = .create(Fred.one)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Fred) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Fred)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.one)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
@@ -1305,12 +1338,13 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.one)
|
||||
|
||||
@@ -1328,12 +1362,14 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Fred> = .create(Fred.one)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Fred) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Fred)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.one)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
@@ -1346,12 +1382,13 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.one)
|
||||
|
||||
@@ -1369,12 +1406,14 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Fred> = .create(Fred.one)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Fred) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Fred)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.one)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
@@ -1387,12 +1426,13 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.one)
|
||||
|
||||
@@ -1410,12 +1450,14 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Fred> = .create(Fred.one)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Fred) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Fred)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.one)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
@@ -1428,12 +1470,13 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.one)
|
||||
|
||||
@@ -1451,12 +1494,14 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Fred> = .create(Fred.one)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Fred) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Fred)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.one)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
@@ -1469,12 +1514,13 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.one)
|
||||
|
||||
@@ -1492,12 +1538,14 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Fred> = .create(Fred.one)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Fred) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Fred)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.one)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
@@ -1510,12 +1558,13 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.one)
|
||||
|
||||
@@ -1533,12 +1582,14 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Fred> = .create(Fred.one)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Fred) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Fred)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.one)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
@@ -1551,12 +1602,13 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.one)
|
||||
|
||||
@@ -1574,12 +1626,14 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Fred> = .create(Fred.one)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Fred) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Fred)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.one)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
@@ -1592,12 +1646,13 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.one)
|
||||
|
||||
@@ -1615,12 +1670,14 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Fred> = .create(Fred.one)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Fred) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Fred)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.one)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
@@ -1633,12 +1690,13 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.one)
|
||||
|
||||
@@ -1656,12 +1714,14 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Fred> = .create(Fred.one)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Fred) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Fred)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.one)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
@@ -1674,12 +1734,13 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.one)
|
||||
|
||||
@@ -1697,12 +1758,14 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Fred> = .create(Fred.one)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Fred) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Fred)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.one)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
@@ -1715,12 +1778,13 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.one)
|
||||
|
||||
@@ -1738,12 +1802,14 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Fred> = .create(Fred.one)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Fred) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Fred)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.one,
|
||||
desired: Fred.two,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.one)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
@@ -1756,12 +1822,13 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: Fred.two,
|
||||
desired: Fred.one,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, Fred.two)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), Fred.one)
|
||||
|
||||
|
||||
@@ -361,15 +361,19 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz1)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed() {
|
||||
let v: UnsafeAtomic<Baz> = .create(_baz1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -381,11 +385,12 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz1)
|
||||
|
||||
@@ -402,11 +407,14 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz> = .create(_baz1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -418,11 +426,12 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz1)
|
||||
|
||||
@@ -439,11 +448,14 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz> = .create(_baz1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -455,11 +467,12 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz1)
|
||||
|
||||
@@ -476,11 +489,14 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz> = .create(_baz1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -492,11 +508,12 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz1)
|
||||
|
||||
@@ -513,11 +530,14 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz> = .create(_baz1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -529,11 +549,12 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz1)
|
||||
|
||||
@@ -1162,16 +1183,19 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz1)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed_relaxed() {
|
||||
let v: UnsafeAtomic<Baz> = .create(_baz1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -1184,12 +1208,13 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz1)
|
||||
|
||||
@@ -1207,12 +1232,14 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz> = .create(_baz1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -1225,12 +1252,13 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz1)
|
||||
|
||||
@@ -1248,12 +1276,14 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz> = .create(_baz1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -1266,12 +1296,13 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz1)
|
||||
|
||||
@@ -1289,12 +1320,14 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz> = .create(_baz1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -1307,12 +1340,13 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz1)
|
||||
|
||||
@@ -1330,12 +1364,14 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz> = .create(_baz1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -1348,12 +1384,13 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz1)
|
||||
|
||||
@@ -1371,12 +1408,14 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz> = .create(_baz1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -1389,12 +1428,13 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz1)
|
||||
|
||||
@@ -1412,12 +1452,14 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz> = .create(_baz1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -1430,12 +1472,13 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz1)
|
||||
|
||||
@@ -1453,12 +1496,14 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz> = .create(_baz1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -1471,12 +1516,13 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz1)
|
||||
|
||||
@@ -1494,12 +1540,14 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz> = .create(_baz1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -1512,12 +1560,13 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz1)
|
||||
|
||||
@@ -1535,12 +1584,14 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz> = .create(_baz1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -1553,12 +1604,13 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz1)
|
||||
|
||||
@@ -1576,12 +1628,14 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz> = .create(_baz1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -1594,12 +1648,13 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz1)
|
||||
|
||||
@@ -1617,12 +1672,14 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz> = .create(_baz1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -1635,12 +1692,13 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz1)
|
||||
|
||||
@@ -1658,12 +1716,14 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz> = .create(_baz1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -1676,12 +1736,13 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz1)
|
||||
|
||||
@@ -1699,12 +1760,14 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz> = .create(_baz1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -1717,12 +1780,13 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz1)
|
||||
|
||||
@@ -1740,12 +1804,14 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Baz> = .create(_baz1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Baz) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Baz)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz1,
|
||||
desired: _baz2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
@@ -1758,12 +1824,13 @@ class BasicAtomicReferenceTests: XCTestCase {
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _baz2,
|
||||
desired: _baz1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _baz2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _baz1)
|
||||
|
||||
|
||||
@@ -359,15 +359,19 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed() {
|
||||
let v: UnsafeAtomic<UInt16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt16)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -379,11 +383,12 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -400,11 +405,14 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt16)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -416,11 +424,12 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -437,11 +446,14 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt16)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -453,11 +465,12 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -474,11 +487,14 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt16)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -490,11 +506,12 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -511,11 +528,14 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt16)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -527,11 +547,12 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1160,16 +1181,19 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed_relaxed() {
|
||||
let v: UnsafeAtomic<UInt16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt16)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1182,12 +1206,13 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1205,12 +1230,14 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt16)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1223,12 +1250,13 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1246,12 +1274,14 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt16)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1264,12 +1294,13 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1287,12 +1318,14 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt16)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1305,12 +1338,13 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1328,12 +1362,14 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt16)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1346,12 +1382,13 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1369,12 +1406,14 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt16)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1387,12 +1426,13 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1410,12 +1450,14 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt16)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1428,12 +1470,13 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1451,12 +1494,14 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt16)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1469,12 +1514,13 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1492,12 +1538,14 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt16)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1510,12 +1558,13 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1533,12 +1582,14 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt16)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1551,12 +1602,13 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1574,12 +1626,14 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt16)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1592,12 +1646,13 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1615,12 +1670,14 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt16)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1633,12 +1690,13 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1656,12 +1714,14 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt16)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1674,12 +1734,13 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1697,12 +1758,14 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt16)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1715,12 +1778,13 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1738,12 +1802,14 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt16> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt16) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt16)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1756,12 +1822,13 @@ class BasicAtomicUInt16Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
|
||||
@@ -359,15 +359,19 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed() {
|
||||
let v: UnsafeAtomic<UInt32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt32)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -379,11 +383,12 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -400,11 +405,14 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt32)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -416,11 +424,12 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -437,11 +446,14 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt32)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -453,11 +465,12 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -474,11 +487,14 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt32)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -490,11 +506,12 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -511,11 +528,14 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt32)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -527,11 +547,12 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1160,16 +1181,19 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed_relaxed() {
|
||||
let v: UnsafeAtomic<UInt32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt32)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1182,12 +1206,13 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1205,12 +1230,14 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt32)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1223,12 +1250,13 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1246,12 +1274,14 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt32)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1264,12 +1294,13 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1287,12 +1318,14 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt32)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1305,12 +1338,13 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1328,12 +1362,14 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt32)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1346,12 +1382,13 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1369,12 +1406,14 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt32)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1387,12 +1426,13 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1410,12 +1450,14 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt32)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1428,12 +1470,13 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1451,12 +1494,14 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt32)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1469,12 +1514,13 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1492,12 +1538,14 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt32)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1510,12 +1558,13 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1533,12 +1582,14 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt32)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1551,12 +1602,13 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1574,12 +1626,14 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt32)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1592,12 +1646,13 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1615,12 +1670,14 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt32)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1633,12 +1690,13 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1656,12 +1714,14 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt32)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1674,12 +1734,13 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1697,12 +1758,14 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt32)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1715,12 +1778,13 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1738,12 +1802,14 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt32> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt32) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt32)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1756,12 +1822,13 @@ class BasicAtomicUInt32Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
|
||||
@@ -359,15 +359,19 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed() {
|
||||
let v: UnsafeAtomic<UInt64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt64)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -379,11 +383,12 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -400,11 +405,14 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt64)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -416,11 +424,12 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -437,11 +446,14 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt64)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -453,11 +465,12 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -474,11 +487,14 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt64)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -490,11 +506,12 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -511,11 +528,14 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt64)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -527,11 +547,12 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1160,16 +1181,19 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed_relaxed() {
|
||||
let v: UnsafeAtomic<UInt64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt64)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1182,12 +1206,13 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1205,12 +1230,14 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt64)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1223,12 +1250,13 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1246,12 +1274,14 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt64)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1264,12 +1294,13 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1287,12 +1318,14 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt64)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1305,12 +1338,13 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1328,12 +1362,14 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt64)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1346,12 +1382,13 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1369,12 +1406,14 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt64)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1387,12 +1426,13 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1410,12 +1450,14 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt64)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1428,12 +1470,13 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1451,12 +1494,14 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt64)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1469,12 +1514,13 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1492,12 +1538,14 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt64)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1510,12 +1558,13 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1533,12 +1582,14 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt64)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1551,12 +1602,13 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1574,12 +1626,14 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt64)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1592,12 +1646,13 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1615,12 +1670,14 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt64)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1633,12 +1690,13 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1656,12 +1714,14 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt64)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1674,12 +1734,13 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1697,12 +1758,14 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt64)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1715,12 +1778,13 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1738,12 +1802,14 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt64> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt64) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt64)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1756,12 +1822,13 @@ class BasicAtomicUInt64Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
|
||||
@@ -359,15 +359,19 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed() {
|
||||
let v: UnsafeAtomic<UInt8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt8)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -379,11 +383,12 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -400,11 +405,14 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt8)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -416,11 +424,12 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -437,11 +446,14 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt8)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -453,11 +465,12 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -474,11 +487,14 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt8)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -490,11 +506,12 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -511,11 +528,14 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt8)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -527,11 +547,12 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1160,16 +1181,19 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed_relaxed() {
|
||||
let v: UnsafeAtomic<UInt8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt8)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1182,12 +1206,13 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1205,12 +1230,14 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt8)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1223,12 +1250,13 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1246,12 +1274,14 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt8)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1264,12 +1294,13 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1287,12 +1318,14 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt8)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1305,12 +1338,13 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1328,12 +1362,14 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt8)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1346,12 +1382,13 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1369,12 +1406,14 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt8)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1387,12 +1426,13 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1410,12 +1450,14 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt8)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1428,12 +1470,13 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1451,12 +1494,14 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt8)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1469,12 +1514,13 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1492,12 +1538,14 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt8)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1510,12 +1558,13 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1533,12 +1582,14 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt8)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1551,12 +1602,13 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1574,12 +1626,14 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt8)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1592,12 +1646,13 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1615,12 +1670,14 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt8)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1633,12 +1690,13 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1656,12 +1714,14 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt8)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1674,12 +1734,13 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1697,12 +1758,14 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt8)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1715,12 +1778,13 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1738,12 +1802,14 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt8> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt8) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt8)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1756,12 +1822,13 @@ class BasicAtomicUInt8Tests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
|
||||
@@ -359,15 +359,19 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed() {
|
||||
let v: UnsafeAtomic<UInt> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -379,11 +383,12 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -400,11 +405,14 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -416,11 +424,12 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -437,11 +446,14 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -453,11 +465,12 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -474,11 +487,14 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -490,11 +506,12 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -511,11 +528,14 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -527,11 +547,12 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1160,16 +1181,19 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed_relaxed() {
|
||||
let v: UnsafeAtomic<UInt> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1182,12 +1206,13 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1205,12 +1230,14 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1223,12 +1250,13 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1246,12 +1274,14 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1264,12 +1294,13 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1287,12 +1318,14 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1305,12 +1338,13 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1328,12 +1362,14 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1346,12 +1382,13 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1369,12 +1406,14 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1387,12 +1426,13 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1410,12 +1450,14 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1428,12 +1470,13 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1451,12 +1494,14 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1469,12 +1514,13 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1492,12 +1538,14 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1510,12 +1558,13 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1533,12 +1582,14 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1551,12 +1602,13 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1574,12 +1626,14 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1592,12 +1646,13 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1615,12 +1670,14 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1633,12 +1690,13 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1656,12 +1714,14 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1674,12 +1734,13 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1697,12 +1758,14 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1715,12 +1778,13 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
@@ -1738,12 +1802,14 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
let v: UnsafeAtomic<UInt> = .create(12)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, UInt) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, UInt)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 12,
|
||||
desired: 23,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 12)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
@@ -1756,12 +1822,13 @@ class BasicAtomicUIntTests: XCTestCase {
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 23)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: 23,
|
||||
desired: 12,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, 23)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), 12)
|
||||
|
||||
|
||||
@@ -366,15 +366,19 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar1)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed() {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>> = .create(_bar1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -386,11 +390,12 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
ordering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
ordering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar1)
|
||||
|
||||
@@ -407,11 +412,14 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>> = .create(_bar1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -423,11 +431,12 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
ordering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
ordering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar1)
|
||||
|
||||
@@ -444,11 +453,14 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>> = .create(_bar1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -460,11 +472,12 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
ordering: .releasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
ordering: .releasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar1)
|
||||
|
||||
@@ -481,11 +494,14 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>> = .create(_bar1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -497,11 +513,12 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
ordering: .acquiringAndReleasing)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
ordering: .acquiringAndReleasing)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar1)
|
||||
|
||||
@@ -518,11 +535,14 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>> = .create(_bar1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>)
|
||||
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -534,11 +554,12 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
ordering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
ordering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar1)
|
||||
|
||||
@@ -1167,16 +1188,19 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar1)
|
||||
}
|
||||
|
||||
|
||||
func test_weakCompareExchange_relaxed_relaxed() {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>> = .create(_bar1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -1189,12 +1213,13 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar1)
|
||||
|
||||
@@ -1212,12 +1237,14 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>> = .create(_bar1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -1230,12 +1257,13 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar1)
|
||||
|
||||
@@ -1253,12 +1281,14 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>> = .create(_bar1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -1271,12 +1301,13 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
successOrdering: .relaxed,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar1)
|
||||
|
||||
@@ -1294,12 +1325,14 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>> = .create(_bar1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -1312,12 +1345,13 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar1)
|
||||
|
||||
@@ -1335,12 +1369,14 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>> = .create(_bar1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -1353,12 +1389,13 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar1)
|
||||
|
||||
@@ -1376,12 +1413,14 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>> = .create(_bar1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -1394,12 +1433,13 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
successOrdering: .acquiring,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar1)
|
||||
|
||||
@@ -1417,12 +1457,14 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>> = .create(_bar1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -1435,12 +1477,13 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar1)
|
||||
|
||||
@@ -1458,12 +1501,14 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>> = .create(_bar1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -1476,12 +1521,13 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar1)
|
||||
|
||||
@@ -1499,12 +1545,14 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>> = .create(_bar1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -1517,12 +1565,13 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
successOrdering: .releasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar1)
|
||||
|
||||
@@ -1540,12 +1589,14 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>> = .create(_bar1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -1558,12 +1609,13 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar1)
|
||||
|
||||
@@ -1581,12 +1633,14 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>> = .create(_bar1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -1599,12 +1653,13 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar1)
|
||||
|
||||
@@ -1622,12 +1677,14 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>> = .create(_bar1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -1640,12 +1697,13 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
successOrdering: .acquiringAndReleasing,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar1)
|
||||
|
||||
@@ -1663,12 +1721,14 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>> = .create(_bar1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -1681,12 +1741,13 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .relaxed)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar1)
|
||||
|
||||
@@ -1704,12 +1765,14 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>> = .create(_bar1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -1722,12 +1785,13 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .acquiring)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar1)
|
||||
|
||||
@@ -1745,12 +1809,14 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
let v: UnsafeAtomic<Unmanaged<Bar>> = .create(_bar1)
|
||||
defer { v.destroy() }
|
||||
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
var (exchanged, original): (Bool, Unmanaged<Bar>)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar1,
|
||||
desired: _bar2,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar1)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
@@ -1763,12 +1829,13 @@ class BasicAtomicUnmanagedTests: XCTestCase {
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
|
||||
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
XCTAssertTrue(exchanged)
|
||||
repeat {
|
||||
(exchanged, original) = v.weakCompareExchange(
|
||||
expected: _bar2,
|
||||
desired: _bar1,
|
||||
successOrdering: .sequentiallyConsistent,
|
||||
failureOrdering: .sequentiallyConsistent)
|
||||
} while !exchanged
|
||||
XCTAssertEqual(original, _bar2)
|
||||
XCTAssertEqual(v.load(ordering: .relaxed), _bar1)
|
||||
|
||||
|
||||
Reference in new issue
Block a user