[test] More Atomic<T> adoption

Author: lorentey

Tests/AtomicsTests/StrongReferenceShuffle.swift

@@ -31,12 +31,12 @@ private let nodeCount = ManagedAtomic<Int>(0)
 
 private class List<Value: Equatable> {
   final class Node: AtomicReference {
-    private let _next: UnsafeAtomic<Node?>
-    private let _value: UnsafeAtomic<UnsafeMutablePointer<Value>?>
+    private let _next: Atomic<Node?>
+    private let _value: Atomic<UnsafeMutablePointer<Value>?>
 
     init(pointer: UnsafeMutablePointer<Value>?, next: Node? = nil) {
-      self._next = .create(next)
-      self._value = .create(pointer)
+      self._next = .init(next)
+      self._value = .init(pointer)
       nodeCount.wrappingIncrement(ordering: .relaxed)
     }
 
@@ -52,14 +52,14 @@ private class List<Value: Equatable> {
 
     deinit {
       // Prevent stack overflow when deinitializing a long chain
-      var node = self._next.destroy()
+      var node = self.clearNext()
       while node != nil && isKnownUniquelyReferenced(&node) {
-        let next = node!._next.exchange(nil, ordering: .relaxed)
+        let next = node!.clearNext()
         withExtendedLifetime(node) {}
         node = next
       }
 
-      if let p = self._value.destroy() {
+      if let p = self.clearValue() {
         p.deinitialize(count: 1)
         p.deallocate()
       }

Tests/AtomicsTests/StrongReferenceSubclass.swift

@@ -25,6 +25,19 @@ private class Child: Base {}
 private class Grandchild: Child {}
 
 class StrongReferenceSubclass: XCTestCase {
+  func test_base_noncopyable() {
+    let object = Child(42)
+    let v = Atomic<Base>(object)
+
+    XCTAssertTrue(v.load(ordering: .relaxed) === object)
+
+    let object2 = Grandchild(23)
+    let o = v.exchange(object2, ordering: .relaxed)
+    XCTAssertTrue(o === object)
+
+    XCTAssertTrue(v.load(ordering: .relaxed) === object2)
+  }
+
   func test_base_unsafe() {
     let object = Child(42)
     let v = UnsafeAtomic<Base>.create(object)
@@ -54,6 +67,18 @@ class StrongReferenceSubclass: XCTestCase {
     XCTAssertTrue(v.load(ordering: .relaxed) === object2)
   }
 
+  func test_optional_base() {
+    let v = Atomic<Base?>(nil)
+
+    XCTAssertTrue(v.load(ordering: .relaxed) == nil)
+
+    let object = Grandchild(23)
+    let o = v.exchange(object, ordering: .relaxed)
+    XCTAssertTrue(o == nil)
+
+    XCTAssertTrue(v.load(ordering: .relaxed) === object)
+  }
+
   func test_optional_base_unsafe() {
     let v = UnsafeAtomic<Base?>.create(nil)