[test] Don’t report failures when weakCompareExchange to spuriously fails

Author: lorentey

Tests/AtomicsTests/Basics/BasicTests.gyb-template

@@ -125,37 +125,36 @@ 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})
     XCTAssertTrue(exchanged)
     XCTAssertEqual(original, ${a})
     XCTAssertEqual(v.load(ordering: .relaxed), ${b})
 
-    (exchanged, original) = v.${operation}(
+    (exchanged, original) = v.compareExchange(
       expected: ${a},
       desired: ${b},
       ordering: .${order})
     XCTAssertFalse(exchanged)
     XCTAssertEqual(original, ${b})
     XCTAssertEqual(v.load(ordering: .relaxed), ${b})
 
-    (exchanged, original) = v.${operation}(
+    (exchanged, original) = v.compareExchange(
       expected: ${b},
       desired: ${a},
       ordering: .${order})
     XCTAssertTrue(exchanged)
     XCTAssertEqual(original, ${b})
     XCTAssertEqual(v.load(ordering: .relaxed), ${a})
 
-    (exchanged, original) = v.${operation}(
+    (exchanged, original) = v.compareExchange(
       expected: ${b},
       desired: ${a},
       ordering: .${order})
@@ -164,17 +163,59 @@ class BasicAtomic${label}Tests: XCTestCase {
     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 (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.${operation}(
+    var (exchanged, original): (Bool, ${type}) = v.compareExchange(
       expected: ${a},
       desired: ${b},
       successOrdering: .${successorder},
@@ -183,7 +224,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},
       successOrdering: .${successorder},
@@ -192,7 +233,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},
       successOrdering: .${successorder},
@@ -201,7 +242,56 @@ 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},
+      successOrdering: .${successorder},
+      failureOrdering: .${failorder})
+    XCTAssertFalse(exchanged)
+    XCTAssertEqual(original, ${a})
+    XCTAssertEqual(v.load(ordering: .relaxed), ${a})
+  }
+
+%   end
+% end
+
+% 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})
+    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.weakCompareExchange(
+      expected: ${a},
+      desired: ${b},
+      successOrdering: .${successorder},
+      failureOrdering: .${failorder})
+    XCTAssertFalse(exchanged)
+    XCTAssertEqual(original, ${b})
+    XCTAssertEqual(v.load(ordering: .relaxed), ${b})
+
+    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.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