     XCTAssert(rUInt.value == fUInt-1)
 
     let fInt32 = Int32(nzRandom())
-    var rInt32 = fInt32
+    var rInt32 = AtomicInt32(fInt32)
     XCTAssert(rInt32.decrement() == fInt32)
-    XCTAssert(rInt32 == fInt32-1)
+    XCTAssert(rInt32.value == fInt32-1)
 
     let fUInt32 = UInt32(nzRandom())
-    var rUInt32 = fUInt32
+    var rUInt32 = AtomicUInt32(fUInt32)
     XCTAssert(rUInt32.decrement() == fUInt32)
-    XCTAssert(rUInt32 == fUInt32-1)
+    XCTAssert(rUInt32.value == fUInt32-1)
 
     let fInt64 = Int64(nzRandom())
-    var rInt64 = fInt64
+    var rInt64 = AtomicInt64(fInt64)
     XCTAssert(rInt64.decrement() == fInt64)
-    XCTAssert(rInt64 == fInt64-1)
+    XCTAssert(rInt64.value == fInt64-1)
 
     let fUInt64 = UInt64(nzRandom())
-    var rUInt64 = fUInt64
+    var rUInt64 = AtomicUInt64(fUInt64)
     XCTAssert(rUInt64.decrement() == fUInt64)
-    XCTAssert(rUInt64 == fUInt64-1)
+    XCTAssert(rUInt64.value == fUInt64-1)
   }
   
   func testCAS()

    let readUInt = randUInt.load()
    XCTAssert(randUInt.value == readUInt)

    var randInt32 = Int32(nzRandom())
    let readInt32 = randInt32.atomicRead(synchronized: false)
    XCTAssert(randInt32 == readInt32)

    var randUInt32 = UInt32(nzRandom())
    let readUInt32 = randUInt32.atomicRead(synchronized: false)
    XCTAssert(randUInt32 == readUInt32)

    var randInt64 = Int64(nzRandom())
    let readInt64 = randInt64.atomicRead(synchronized: false)
    XCTAssert(randInt64 == readInt64)

    var randUInt64 = UInt64(nzRandom())
    let readUInt64 = randUInt64.atomicRead(synchronized: false)
    XCTAssert(randUInt64 == readUInt64)

    var randPtr = UnsafePointer<CGPoint>(bitPattern: nzRandom())
    let readPtr = randPtr.atomicRead(synchronized: false)
    XCTAssert(randPtr == readPtr)

    var randMutPtr = UnsafeMutablePointer<CGPoint>(bitPattern: nzRandom())
    let readMutPtr = randMutPtr.atomicRead(synchronized: false)
    XCTAssert(randMutPtr == readMutPtr)

    var randOPtr = COpaquePointer(bitPattern: nzRandom())
    let readOPtr = randOPtr.atomicRead(synchronized: false)
    XCTAssert(randOPtr == readOPtr)
  }

    

    XCTAssert(rUInt.value == fUInt-1)

    let fInt32 = Int32(nzRandom())
    var rInt32 = AtomicInt32(fInt32)
    XCTAssert(rInt32.subtract(1) == fInt32)
    XCTAssert(rInt32.value == fInt32-1)

    let fUInt32 = UInt32(nzRandom())
    var rUInt32 = AtomicUInt32(fUInt32)
    XCTAssert(rUInt32.subtract(1) == fUInt32)
    XCTAssert(rUInt32.value == fUInt32-1)

    let fInt64 = Int64(nzRandom())
    var rInt64 = AtomicInt64(fInt64)
    XCTAssert(rInt64.subtract(1) == fInt64)
    XCTAssert(rInt64.value == fInt64-1)

    let fUInt64 = UInt64(nzRandom())
    var rUInt64 = AtomicUInt64(fUInt64)
    XCTAssert(rUInt64.subtract(1) == fUInt64)
    XCTAssert(rUInt64.value == fUInt64-1)
  }

  func testIncrement()
