diff --git a/Tests/AtomicsTests/Basics/BasicTests.gyb-template b/Tests/AtomicsTests/Basics/BasicTests.gyb-template index 32251f1..5bdb294 100644 --- a/Tests/AtomicsTests/Basics/BasicTests.gyb-template +++ b/Tests/AtomicsTests/Basics/BasicTests.gyb-template @@ -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 diff --git a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicBoolTests.swift b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicBoolTests.swift index c4079d1..a553bb3 100644 --- a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicBoolTests.swift +++ b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicBoolTests.swift @@ -359,15 +359,19 @@ class BasicAtomicBoolTests: XCTestCase { XCTAssertEqual(v.load(ordering: .relaxed), true) } + func test_weakCompareExchange_relaxed() { let v: UnsafeAtomic = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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) diff --git a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicDoubleWordTests.swift b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicDoubleWordTests.swift index 8d9adfa..cce1947 100644 --- a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicDoubleWordTests.swift +++ b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicDoubleWordTests.swift @@ -359,15 +359,19 @@ class BasicAtomicDoubleWordTests: XCTestCase { XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 100, second: 64)) } + func test_weakCompareExchange_relaxed() { let v: UnsafeAtomic = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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)) diff --git a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicInt16Tests.swift b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicInt16Tests.swift index 48c48b2..1b0ebda 100644 --- a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicInt16Tests.swift +++ b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicInt16Tests.swift @@ -359,15 +359,19 @@ class BasicAtomicInt16Tests: XCTestCase { XCTAssertEqual(v.load(ordering: .relaxed), 12) } + func test_weakCompareExchange_relaxed() { let v: UnsafeAtomic = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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) diff --git a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicInt32Tests.swift b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicInt32Tests.swift index b755452..cd444a2 100644 --- a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicInt32Tests.swift +++ b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicInt32Tests.swift @@ -359,15 +359,19 @@ class BasicAtomicInt32Tests: XCTestCase { XCTAssertEqual(v.load(ordering: .relaxed), 12) } + func test_weakCompareExchange_relaxed() { let v: UnsafeAtomic = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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) diff --git a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicInt64Tests.swift b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicInt64Tests.swift index bda8b1c..dda74f6 100644 --- a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicInt64Tests.swift +++ b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicInt64Tests.swift @@ -359,15 +359,19 @@ class BasicAtomicInt64Tests: XCTestCase { XCTAssertEqual(v.load(ordering: .relaxed), 12) } + func test_weakCompareExchange_relaxed() { let v: UnsafeAtomic = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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) diff --git a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicInt8Tests.swift b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicInt8Tests.swift index b5c33e2..8b49885 100644 --- a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicInt8Tests.swift +++ b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicInt8Tests.swift @@ -359,15 +359,19 @@ class BasicAtomicInt8Tests: XCTestCase { XCTAssertEqual(v.load(ordering: .relaxed), 12) } + func test_weakCompareExchange_relaxed() { let v: UnsafeAtomic = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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) diff --git a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicIntTests.swift b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicIntTests.swift index d24f881..39ab68e 100644 --- a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicIntTests.swift +++ b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicIntTests.swift @@ -359,15 +359,19 @@ class BasicAtomicIntTests: XCTestCase { XCTAssertEqual(v.load(ordering: .relaxed), 12) } + func test_weakCompareExchange_relaxed() { let v: UnsafeAtomic = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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) diff --git a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicMutablePointerTests.swift b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicMutablePointerTests.swift index 2240630..45dd4dd 100644 --- a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicMutablePointerTests.swift +++ b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicMutablePointerTests.swift @@ -380,15 +380,19 @@ class BasicAtomicMutablePointerTests: XCTestCase { XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) } + func test_weakCompareExchange_relaxed() { let v: UnsafeAtomic> = .create(_mfoo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer) = v.weakCompareExchange( - expected: _mfoo1, - desired: _mfoo2, - ordering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer) + + 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> = .create(_mfoo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer) = v.weakCompareExchange( - expected: _mfoo1, - desired: _mfoo2, - ordering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer) + + 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> = .create(_mfoo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer) = v.weakCompareExchange( - expected: _mfoo1, - desired: _mfoo2, - ordering: .releasing) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer) + + 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> = .create(_mfoo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer) = v.weakCompareExchange( - expected: _mfoo1, - desired: _mfoo2, - ordering: .acquiringAndReleasing) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer) + + 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> = .create(_mfoo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer) = v.weakCompareExchange( - expected: _mfoo1, - desired: _mfoo2, - ordering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer) + + 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> = .create(_mfoo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer) = v.weakCompareExchange( - expected: _mfoo1, - desired: _mfoo2, - successOrdering: .relaxed, - failureOrdering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer) + 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> = .create(_mfoo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer) = v.weakCompareExchange( - expected: _mfoo1, - desired: _mfoo2, - successOrdering: .relaxed, - failureOrdering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer) + 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> = .create(_mfoo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer) = v.weakCompareExchange( - expected: _mfoo1, - desired: _mfoo2, - successOrdering: .relaxed, - failureOrdering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer) + 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> = .create(_mfoo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer) = v.weakCompareExchange( - expected: _mfoo1, - desired: _mfoo2, - successOrdering: .acquiring, - failureOrdering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer) + 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> = .create(_mfoo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer) = v.weakCompareExchange( - expected: _mfoo1, - desired: _mfoo2, - successOrdering: .acquiring, - failureOrdering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer) + 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> = .create(_mfoo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer) = v.weakCompareExchange( - expected: _mfoo1, - desired: _mfoo2, - successOrdering: .acquiring, - failureOrdering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer) + 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> = .create(_mfoo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer) = v.weakCompareExchange( - expected: _mfoo1, - desired: _mfoo2, - successOrdering: .releasing, - failureOrdering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer) + 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> = .create(_mfoo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer) = v.weakCompareExchange( - expected: _mfoo1, - desired: _mfoo2, - successOrdering: .releasing, - failureOrdering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer) + 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> = .create(_mfoo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer) = v.weakCompareExchange( - expected: _mfoo1, - desired: _mfoo2, - successOrdering: .releasing, - failureOrdering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer) + 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> = .create(_mfoo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer) = v.weakCompareExchange( - expected: _mfoo1, - desired: _mfoo2, - successOrdering: .acquiringAndReleasing, - failureOrdering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer) + 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> = .create(_mfoo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer) = v.weakCompareExchange( - expected: _mfoo1, - desired: _mfoo2, - successOrdering: .acquiringAndReleasing, - failureOrdering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer) + 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> = .create(_mfoo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer) = v.weakCompareExchange( - expected: _mfoo1, - desired: _mfoo2, - successOrdering: .acquiringAndReleasing, - failureOrdering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer) + 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> = .create(_mfoo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer) = v.weakCompareExchange( - expected: _mfoo1, - desired: _mfoo2, - successOrdering: .sequentiallyConsistent, - failureOrdering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer) + 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> = .create(_mfoo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer) = v.weakCompareExchange( - expected: _mfoo1, - desired: _mfoo2, - successOrdering: .sequentiallyConsistent, - failureOrdering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer) + 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> = .create(_mfoo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer) = v.weakCompareExchange( - expected: _mfoo1, - desired: _mfoo2, - successOrdering: .sequentiallyConsistent, - failureOrdering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer) + 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) diff --git a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicMutableRawPointerTests.swift b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicMutableRawPointerTests.swift index 0056e52..dbad2fc 100644 --- a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicMutableRawPointerTests.swift +++ b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicMutableRawPointerTests.swift @@ -369,15 +369,19 @@ class BasicAtomicMutableRawPointerTests: XCTestCase { XCTAssertEqual(v.load(ordering: .relaxed), _mraw1) } + func test_weakCompareExchange_relaxed() { let v: UnsafeAtomic = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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) diff --git a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicOptionalMutablePointerTests.swift b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicOptionalMutablePointerTests.swift index f61687d..9ccb6e8 100644 --- a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicOptionalMutablePointerTests.swift +++ b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicOptionalMutablePointerTests.swift @@ -380,15 +380,19 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase { XCTAssertEqual(v.load(ordering: .relaxed), nil) } + func test_weakCompareExchange_relaxed() { let v: UnsafeAtomic?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer?) = v.weakCompareExchange( - expected: nil, - desired: _mfoo2, - ordering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer?) + + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer?) = v.weakCompareExchange( - expected: nil, - desired: _mfoo2, - ordering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer?) + + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer?) = v.weakCompareExchange( - expected: nil, - desired: _mfoo2, - ordering: .releasing) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer?) + + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer?) = v.weakCompareExchange( - expected: nil, - desired: _mfoo2, - ordering: .acquiringAndReleasing) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer?) + + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer?) = v.weakCompareExchange( - expected: nil, - desired: _mfoo2, - ordering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer?) + + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer?) = v.weakCompareExchange( - expected: nil, - desired: _mfoo2, - successOrdering: .relaxed, - failureOrdering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer?) = v.weakCompareExchange( - expected: nil, - desired: _mfoo2, - successOrdering: .relaxed, - failureOrdering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer?) = v.weakCompareExchange( - expected: nil, - desired: _mfoo2, - successOrdering: .relaxed, - failureOrdering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer?) = v.weakCompareExchange( - expected: nil, - desired: _mfoo2, - successOrdering: .acquiring, - failureOrdering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer?) = v.weakCompareExchange( - expected: nil, - desired: _mfoo2, - successOrdering: .acquiring, - failureOrdering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer?) = v.weakCompareExchange( - expected: nil, - desired: _mfoo2, - successOrdering: .acquiring, - failureOrdering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer?) = v.weakCompareExchange( - expected: nil, - desired: _mfoo2, - successOrdering: .releasing, - failureOrdering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer?) = v.weakCompareExchange( - expected: nil, - desired: _mfoo2, - successOrdering: .releasing, - failureOrdering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer?) = v.weakCompareExchange( - expected: nil, - desired: _mfoo2, - successOrdering: .releasing, - failureOrdering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer?) = v.weakCompareExchange( - expected: nil, - desired: _mfoo2, - successOrdering: .acquiringAndReleasing, - failureOrdering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer?) = v.weakCompareExchange( - expected: nil, - desired: _mfoo2, - successOrdering: .acquiringAndReleasing, - failureOrdering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer?) = v.weakCompareExchange( - expected: nil, - desired: _mfoo2, - successOrdering: .acquiringAndReleasing, - failureOrdering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer?) = v.weakCompareExchange( - expected: nil, - desired: _mfoo2, - successOrdering: .sequentiallyConsistent, - failureOrdering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer?) = v.weakCompareExchange( - expected: nil, - desired: _mfoo2, - successOrdering: .sequentiallyConsistent, - failureOrdering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafeMutablePointer?) = v.weakCompareExchange( - expected: nil, - desired: _mfoo2, - successOrdering: .sequentiallyConsistent, - failureOrdering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafeMutablePointer?) + 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) diff --git a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicOptionalMutableRawPointerTests.swift b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicOptionalMutableRawPointerTests.swift index 9eb8929..29dc3f2 100644 --- a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicOptionalMutableRawPointerTests.swift +++ b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicOptionalMutableRawPointerTests.swift @@ -369,15 +369,19 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase { XCTAssertEqual(v.load(ordering: .relaxed), nil) } + func test_weakCompareExchange_relaxed() { let v: UnsafeAtomic = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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) diff --git a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicOptionalPointerTests.swift b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicOptionalPointerTests.swift index 7e5a58e..5c40656 100644 --- a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicOptionalPointerTests.swift +++ b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicOptionalPointerTests.swift @@ -380,15 +380,19 @@ class BasicAtomicOptionalPointerTests: XCTestCase { XCTAssertEqual(v.load(ordering: .relaxed), nil) } + func test_weakCompareExchange_relaxed() { let v: UnsafeAtomic?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer?) = v.weakCompareExchange( - expected: nil, - desired: _foo2, - ordering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer?) + + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer?) = v.weakCompareExchange( - expected: nil, - desired: _foo2, - ordering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer?) + + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer?) = v.weakCompareExchange( - expected: nil, - desired: _foo2, - ordering: .releasing) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer?) + + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer?) = v.weakCompareExchange( - expected: nil, - desired: _foo2, - ordering: .acquiringAndReleasing) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer?) + + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer?) = v.weakCompareExchange( - expected: nil, - desired: _foo2, - ordering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer?) + + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer?) = v.weakCompareExchange( - expected: nil, - desired: _foo2, - successOrdering: .relaxed, - failureOrdering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer?) = v.weakCompareExchange( - expected: nil, - desired: _foo2, - successOrdering: .relaxed, - failureOrdering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer?) = v.weakCompareExchange( - expected: nil, - desired: _foo2, - successOrdering: .relaxed, - failureOrdering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer?) = v.weakCompareExchange( - expected: nil, - desired: _foo2, - successOrdering: .acquiring, - failureOrdering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer?) = v.weakCompareExchange( - expected: nil, - desired: _foo2, - successOrdering: .acquiring, - failureOrdering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer?) = v.weakCompareExchange( - expected: nil, - desired: _foo2, - successOrdering: .acquiring, - failureOrdering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer?) = v.weakCompareExchange( - expected: nil, - desired: _foo2, - successOrdering: .releasing, - failureOrdering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer?) = v.weakCompareExchange( - expected: nil, - desired: _foo2, - successOrdering: .releasing, - failureOrdering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer?) = v.weakCompareExchange( - expected: nil, - desired: _foo2, - successOrdering: .releasing, - failureOrdering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer?) = v.weakCompareExchange( - expected: nil, - desired: _foo2, - successOrdering: .acquiringAndReleasing, - failureOrdering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer?) = v.weakCompareExchange( - expected: nil, - desired: _foo2, - successOrdering: .acquiringAndReleasing, - failureOrdering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer?) = v.weakCompareExchange( - expected: nil, - desired: _foo2, - successOrdering: .acquiringAndReleasing, - failureOrdering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer?) = v.weakCompareExchange( - expected: nil, - desired: _foo2, - successOrdering: .sequentiallyConsistent, - failureOrdering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer?) = v.weakCompareExchange( - expected: nil, - desired: _foo2, - successOrdering: .sequentiallyConsistent, - failureOrdering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer?) = v.weakCompareExchange( - expected: nil, - desired: _foo2, - successOrdering: .sequentiallyConsistent, - failureOrdering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer?) + 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) diff --git a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicOptionalRawPointerTests.swift b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicOptionalRawPointerTests.swift index 4a36fe0..f3c47ef 100644 --- a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicOptionalRawPointerTests.swift +++ b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicOptionalRawPointerTests.swift @@ -369,15 +369,19 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase { XCTAssertEqual(v.load(ordering: .relaxed), nil) } + func test_weakCompareExchange_relaxed() { let v: UnsafeAtomic = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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) diff --git a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicOptionalRawRepresentableTests.swift b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicOptionalRawRepresentableTests.swift index 4ba56a6..9ad2995 100644 --- a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicOptionalRawRepresentableTests.swift +++ b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicOptionalRawRepresentableTests.swift @@ -359,15 +359,19 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase { XCTAssertEqual(v.load(ordering: .relaxed), Hyacinth.bucket) } + func test_weakCompareExchange_relaxed() { let v: UnsafeAtomic = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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) diff --git a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicOptionalReferenceTests.swift b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicOptionalReferenceTests.swift index 0df9852..ac83607 100644 --- a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicOptionalReferenceTests.swift +++ b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicOptionalReferenceTests.swift @@ -361,15 +361,19 @@ class BasicAtomicOptionalReferenceTests: XCTestCase { XCTAssertEqual(v.load(ordering: .relaxed), nil) } + func test_weakCompareExchange_relaxed() { let v: UnsafeAtomic = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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) diff --git a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicOptionalUnmanagedTests.swift b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicOptionalUnmanagedTests.swift index 17bb682..2e697e8 100644 --- a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicOptionalUnmanagedTests.swift +++ b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicOptionalUnmanagedTests.swift @@ -366,15 +366,19 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase { XCTAssertEqual(v.load(ordering: .relaxed), nil) } + func test_weakCompareExchange_relaxed() { let v: UnsafeAtomic?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged?) = v.weakCompareExchange( - expected: nil, - desired: _bar2, - ordering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged?) + + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged?) = v.weakCompareExchange( - expected: nil, - desired: _bar2, - ordering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged?) + + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged?) = v.weakCompareExchange( - expected: nil, - desired: _bar2, - ordering: .releasing) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged?) + + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged?) = v.weakCompareExchange( - expected: nil, - desired: _bar2, - ordering: .acquiringAndReleasing) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged?) + + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged?) = v.weakCompareExchange( - expected: nil, - desired: _bar2, - ordering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged?) + + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged?) = v.weakCompareExchange( - expected: nil, - desired: _bar2, - successOrdering: .relaxed, - failureOrdering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged?) = v.weakCompareExchange( - expected: nil, - desired: _bar2, - successOrdering: .relaxed, - failureOrdering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged?) = v.weakCompareExchange( - expected: nil, - desired: _bar2, - successOrdering: .relaxed, - failureOrdering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged?) = v.weakCompareExchange( - expected: nil, - desired: _bar2, - successOrdering: .acquiring, - failureOrdering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged?) = v.weakCompareExchange( - expected: nil, - desired: _bar2, - successOrdering: .acquiring, - failureOrdering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged?) = v.weakCompareExchange( - expected: nil, - desired: _bar2, - successOrdering: .acquiring, - failureOrdering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged?) = v.weakCompareExchange( - expected: nil, - desired: _bar2, - successOrdering: .releasing, - failureOrdering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged?) = v.weakCompareExchange( - expected: nil, - desired: _bar2, - successOrdering: .releasing, - failureOrdering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged?) = v.weakCompareExchange( - expected: nil, - desired: _bar2, - successOrdering: .releasing, - failureOrdering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged?) = v.weakCompareExchange( - expected: nil, - desired: _bar2, - successOrdering: .acquiringAndReleasing, - failureOrdering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged?) = v.weakCompareExchange( - expected: nil, - desired: _bar2, - successOrdering: .acquiringAndReleasing, - failureOrdering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged?) = v.weakCompareExchange( - expected: nil, - desired: _bar2, - successOrdering: .acquiringAndReleasing, - failureOrdering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged?) = v.weakCompareExchange( - expected: nil, - desired: _bar2, - successOrdering: .sequentiallyConsistent, - failureOrdering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged?) = v.weakCompareExchange( - expected: nil, - desired: _bar2, - successOrdering: .sequentiallyConsistent, - failureOrdering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged?) + 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?> = .create(nil) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged?) = v.weakCompareExchange( - expected: nil, - desired: _bar2, - successOrdering: .sequentiallyConsistent, - failureOrdering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged?) + 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) diff --git a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicPointerTests.swift b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicPointerTests.swift index b1cb328..8fcc1f2 100644 --- a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicPointerTests.swift +++ b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicPointerTests.swift @@ -380,15 +380,19 @@ class BasicAtomicPointerTests: XCTestCase { XCTAssertEqual(v.load(ordering: .relaxed), _foo1) } + func test_weakCompareExchange_relaxed() { let v: UnsafeAtomic> = .create(_foo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer) = v.weakCompareExchange( - expected: _foo1, - desired: _foo2, - ordering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer) + + 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> = .create(_foo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer) = v.weakCompareExchange( - expected: _foo1, - desired: _foo2, - ordering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer) + + 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> = .create(_foo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer) = v.weakCompareExchange( - expected: _foo1, - desired: _foo2, - ordering: .releasing) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer) + + 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> = .create(_foo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer) = v.weakCompareExchange( - expected: _foo1, - desired: _foo2, - ordering: .acquiringAndReleasing) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer) + + 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> = .create(_foo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer) = v.weakCompareExchange( - expected: _foo1, - desired: _foo2, - ordering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer) + + 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> = .create(_foo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer) = v.weakCompareExchange( - expected: _foo1, - desired: _foo2, - successOrdering: .relaxed, - failureOrdering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer) + 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> = .create(_foo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer) = v.weakCompareExchange( - expected: _foo1, - desired: _foo2, - successOrdering: .relaxed, - failureOrdering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer) + 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> = .create(_foo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer) = v.weakCompareExchange( - expected: _foo1, - desired: _foo2, - successOrdering: .relaxed, - failureOrdering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer) + 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> = .create(_foo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer) = v.weakCompareExchange( - expected: _foo1, - desired: _foo2, - successOrdering: .acquiring, - failureOrdering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer) + 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> = .create(_foo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer) = v.weakCompareExchange( - expected: _foo1, - desired: _foo2, - successOrdering: .acquiring, - failureOrdering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer) + 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> = .create(_foo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer) = v.weakCompareExchange( - expected: _foo1, - desired: _foo2, - successOrdering: .acquiring, - failureOrdering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer) + 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> = .create(_foo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer) = v.weakCompareExchange( - expected: _foo1, - desired: _foo2, - successOrdering: .releasing, - failureOrdering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer) + 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> = .create(_foo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer) = v.weakCompareExchange( - expected: _foo1, - desired: _foo2, - successOrdering: .releasing, - failureOrdering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer) + 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> = .create(_foo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer) = v.weakCompareExchange( - expected: _foo1, - desired: _foo2, - successOrdering: .releasing, - failureOrdering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer) + 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> = .create(_foo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer) = v.weakCompareExchange( - expected: _foo1, - desired: _foo2, - successOrdering: .acquiringAndReleasing, - failureOrdering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer) + 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> = .create(_foo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer) = v.weakCompareExchange( - expected: _foo1, - desired: _foo2, - successOrdering: .acquiringAndReleasing, - failureOrdering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer) + 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> = .create(_foo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer) = v.weakCompareExchange( - expected: _foo1, - desired: _foo2, - successOrdering: .acquiringAndReleasing, - failureOrdering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer) + 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> = .create(_foo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer) = v.weakCompareExchange( - expected: _foo1, - desired: _foo2, - successOrdering: .sequentiallyConsistent, - failureOrdering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer) + 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> = .create(_foo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer) = v.weakCompareExchange( - expected: _foo1, - desired: _foo2, - successOrdering: .sequentiallyConsistent, - failureOrdering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer) + 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> = .create(_foo1) defer { v.destroy() } - var (exchanged, original): (Bool, UnsafePointer) = v.weakCompareExchange( - expected: _foo1, - desired: _foo2, - successOrdering: .sequentiallyConsistent, - failureOrdering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, UnsafePointer) + 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) diff --git a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicRawPointerTests.swift b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicRawPointerTests.swift index 157ea7e..87ca1df 100644 --- a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicRawPointerTests.swift +++ b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicRawPointerTests.swift @@ -369,15 +369,19 @@ class BasicAtomicRawPointerTests: XCTestCase { XCTAssertEqual(v.load(ordering: .relaxed), _raw1) } + func test_weakCompareExchange_relaxed() { let v: UnsafeAtomic = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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) diff --git a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicRawRepresentableTests.swift b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicRawRepresentableTests.swift index fc0dcd6..2677efa 100644 --- a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicRawRepresentableTests.swift +++ b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicRawRepresentableTests.swift @@ -359,15 +359,19 @@ class BasicAtomicRawRepresentableTests: XCTestCase { XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) } + func test_weakCompareExchange_relaxed() { let v: UnsafeAtomic = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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) diff --git a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicReferenceTests.swift b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicReferenceTests.swift index 65883e0..0ce7900 100644 --- a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicReferenceTests.swift +++ b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicReferenceTests.swift @@ -361,15 +361,19 @@ class BasicAtomicReferenceTests: XCTestCase { XCTAssertEqual(v.load(ordering: .relaxed), _baz1) } + func test_weakCompareExchange_relaxed() { let v: UnsafeAtomic = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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) diff --git a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicUInt16Tests.swift b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicUInt16Tests.swift index cf233db..0a04807 100644 --- a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicUInt16Tests.swift +++ b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicUInt16Tests.swift @@ -359,15 +359,19 @@ class BasicAtomicUInt16Tests: XCTestCase { XCTAssertEqual(v.load(ordering: .relaxed), 12) } + func test_weakCompareExchange_relaxed() { let v: UnsafeAtomic = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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) diff --git a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicUInt32Tests.swift b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicUInt32Tests.swift index a62d823..dd7bac3 100644 --- a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicUInt32Tests.swift +++ b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicUInt32Tests.swift @@ -359,15 +359,19 @@ class BasicAtomicUInt32Tests: XCTestCase { XCTAssertEqual(v.load(ordering: .relaxed), 12) } + func test_weakCompareExchange_relaxed() { let v: UnsafeAtomic = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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) diff --git a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicUInt64Tests.swift b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicUInt64Tests.swift index 4dfd806..ed88c36 100644 --- a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicUInt64Tests.swift +++ b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicUInt64Tests.swift @@ -359,15 +359,19 @@ class BasicAtomicUInt64Tests: XCTestCase { XCTAssertEqual(v.load(ordering: .relaxed), 12) } + func test_weakCompareExchange_relaxed() { let v: UnsafeAtomic = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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) diff --git a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicUInt8Tests.swift b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicUInt8Tests.swift index ca8ecc9..af7bf01 100644 --- a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicUInt8Tests.swift +++ b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicUInt8Tests.swift @@ -359,15 +359,19 @@ class BasicAtomicUInt8Tests: XCTestCase { XCTAssertEqual(v.load(ordering: .relaxed), 12) } + func test_weakCompareExchange_relaxed() { let v: UnsafeAtomic = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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) diff --git a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicUIntTests.swift b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicUIntTests.swift index 067adcb..58eaf90 100644 --- a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicUIntTests.swift +++ b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicUIntTests.swift @@ -359,15 +359,19 @@ class BasicAtomicUIntTests: XCTestCase { XCTAssertEqual(v.load(ordering: .relaxed), 12) } + func test_weakCompareExchange_relaxed() { let v: UnsafeAtomic = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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 = .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) diff --git a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicUnmanagedTests.swift b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicUnmanagedTests.swift index 35d846b..eb8e76d 100644 --- a/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicUnmanagedTests.swift +++ b/Tests/AtomicsTests/Basics/autogenerated/BasicAtomicUnmanagedTests.swift @@ -366,15 +366,19 @@ class BasicAtomicUnmanagedTests: XCTestCase { XCTAssertEqual(v.load(ordering: .relaxed), _bar1) } + func test_weakCompareExchange_relaxed() { let v: UnsafeAtomic> = .create(_bar1) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged) = v.weakCompareExchange( - expected: _bar1, - desired: _bar2, - ordering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged) + + 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> = .create(_bar1) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged) = v.weakCompareExchange( - expected: _bar1, - desired: _bar2, - ordering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged) + + 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> = .create(_bar1) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged) = v.weakCompareExchange( - expected: _bar1, - desired: _bar2, - ordering: .releasing) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged) + + 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> = .create(_bar1) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged) = v.weakCompareExchange( - expected: _bar1, - desired: _bar2, - ordering: .acquiringAndReleasing) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged) + + 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> = .create(_bar1) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged) = v.weakCompareExchange( - expected: _bar1, - desired: _bar2, - ordering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged) + + 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> = .create(_bar1) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged) = v.weakCompareExchange( - expected: _bar1, - desired: _bar2, - successOrdering: .relaxed, - failureOrdering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged) + 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> = .create(_bar1) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged) = v.weakCompareExchange( - expected: _bar1, - desired: _bar2, - successOrdering: .relaxed, - failureOrdering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged) + 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> = .create(_bar1) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged) = v.weakCompareExchange( - expected: _bar1, - desired: _bar2, - successOrdering: .relaxed, - failureOrdering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged) + 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> = .create(_bar1) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged) = v.weakCompareExchange( - expected: _bar1, - desired: _bar2, - successOrdering: .acquiring, - failureOrdering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged) + 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> = .create(_bar1) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged) = v.weakCompareExchange( - expected: _bar1, - desired: _bar2, - successOrdering: .acquiring, - failureOrdering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged) + 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> = .create(_bar1) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged) = v.weakCompareExchange( - expected: _bar1, - desired: _bar2, - successOrdering: .acquiring, - failureOrdering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged) + 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> = .create(_bar1) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged) = v.weakCompareExchange( - expected: _bar1, - desired: _bar2, - successOrdering: .releasing, - failureOrdering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged) + 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> = .create(_bar1) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged) = v.weakCompareExchange( - expected: _bar1, - desired: _bar2, - successOrdering: .releasing, - failureOrdering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged) + 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> = .create(_bar1) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged) = v.weakCompareExchange( - expected: _bar1, - desired: _bar2, - successOrdering: .releasing, - failureOrdering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged) + 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> = .create(_bar1) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged) = v.weakCompareExchange( - expected: _bar1, - desired: _bar2, - successOrdering: .acquiringAndReleasing, - failureOrdering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged) + 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> = .create(_bar1) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged) = v.weakCompareExchange( - expected: _bar1, - desired: _bar2, - successOrdering: .acquiringAndReleasing, - failureOrdering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged) + 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> = .create(_bar1) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged) = v.weakCompareExchange( - expected: _bar1, - desired: _bar2, - successOrdering: .acquiringAndReleasing, - failureOrdering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged) + 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> = .create(_bar1) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged) = v.weakCompareExchange( - expected: _bar1, - desired: _bar2, - successOrdering: .sequentiallyConsistent, - failureOrdering: .relaxed) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged) + 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> = .create(_bar1) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged) = v.weakCompareExchange( - expected: _bar1, - desired: _bar2, - successOrdering: .sequentiallyConsistent, - failureOrdering: .acquiring) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged) + 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> = .create(_bar1) defer { v.destroy() } - var (exchanged, original): (Bool, Unmanaged) = v.weakCompareExchange( - expected: _bar1, - desired: _bar2, - successOrdering: .sequentiallyConsistent, - failureOrdering: .sequentiallyConsistent) - XCTAssertTrue(exchanged) + var (exchanged, original): (Bool, Unmanaged) + 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)