Merge pull request #76 from lorentey/weakCompareExchange-shortcut

Add a weakCompareExchange variant that only takes a single ordering
This commit is contained in:
Karoy Lorentey authored and GitHub committed 2023-03-24 17:12:48 -07:00
commit 4ff09f2cf3
35 files changed
+5040 -15

No files matched your search

+5 -4
View File
@@ -50,12 +50,13 @@ let package = Package(
dependencies: ["_AtomicsShims"],
exclude: [
"CMakeLists.txt",
"Builtins.swift.gyb",
"HighLevelTypes.swift.gyb",
"PointerConformances.swift.gyb",
"IntegerConformances.swift.gyb",
"AtomicBool.swift.gyb",
"AtomicLazyReference.swift.gyb",
"HighLevelTypes.swift.gyb",
"IntegerConformances.swift.gyb",
"PointerConformances.swift.gyb",
"Primitives.native.swift.gyb",
"Primitives.shims.swift.gyb",
],
cSettings: _cSettings,
swiftSettings: _swiftSettings
@@ -289,6 +289,24 @@ extension AtomicUpdateOrdering: CustomStringConvertible {
}
}
extension AtomicLoadOrdering {
@_semantics("constant_evaluable")
@_semantics("atomics.requires_constant_orderings")
@_transparent @_alwaysEmitIntoClient
static func _failureOrdering(
for ordering: AtomicUpdateOrdering
) -> AtomicLoadOrdering {
switch ordering {
case .relaxed: return .relaxed
case .acquiring: return .acquiring
case .releasing: return .relaxed
case .acquiringAndReleasing: return .acquiring
case .sequentiallyConsistent: return .sequentiallyConsistent
default: fatalError("Unsupported ordering")
}
}
}
/// Establishes a memory ordering without associating it with a
/// particular atomic operation.
///
@@ -12,6 +12,8 @@
#if ATOMICS_NATIVE_BUILTINS
import Swift
#else
import _AtomicsShims
#endif
/// A class type that supports atomic strong references.
+71
View File
@@ -176,6 +176,43 @@ public protocol AtomicStorage {
failureOrdering: AtomicLoadOrdering
) -> (exchanged: Bool, original: Value)
/// Perform an atomic weak compare and exchange operation on the value
/// referenced by `pointer`, applying the specified memory orderings.
/// This compare-exchange variant is allowed to spuriously fail; it
/// is designed to be called in a loop until it indicates a successful
/// exchange has happened.
///
/// This operation performs the following algorithm as a single atomic
/// transaction:
///
/// ```
/// atomic(self) { currentValue in
/// let original = currentValue
/// guard original == expected else { return (false, original) }
/// currentValue = desired
/// return (true, original)
/// }
/// ```
///
/// (In this weak form, transient conditions may cause the `original ==
/// expected` check to sometimes return false when the two values are in fact
/// the same.)
///
/// - Parameter expected: The expected current value.
/// - Parameter desired: The desired new value.
/// - Parameter pointer: A memory location previously initialized with a value
/// returned by `prepareAtomicRepresentation(for:)`.
/// - Parameter ordering: The memory ordering to apply on this operation.
/// - Returns: A tuple `(exchanged, original)`, where `exchanged` is true if
/// the exchange was successful, and `original` is the original value.
@_semantics("atomics.requires_constant_orderings")
static func atomicWeakCompareExchange(
expected: Value,
desired: __owned Value,
at pointer: UnsafeMutablePointer<Self>,
ordering: AtomicUpdateOrdering
) -> (exchanged: Bool, original: Value)
/// Perform an atomic weak compare and exchange operation on the value
/// referenced by `pointer`, applying the specified success/failure memory
/// orderings. This compare-exchange variant is allowed to spuriously fail; it
@@ -221,3 +258,37 @@ public protocol AtomicStorage {
failureOrdering: AtomicLoadOrdering
) -> (exchanged: Bool, original: Value)
}
extension AtomicStorage {
@_semantics("atomics.requires_constant_orderings")
@_transparent @_alwaysEmitIntoClient
public static func atomicCompareExchange(
expected: Value,
desired: __owned Value,
at pointer: UnsafeMutablePointer<Self>,
ordering: AtomicUpdateOrdering
) -> (exchanged: Bool, original: Value) {
atomicCompareExchange(
expected: expected,
desired: desired,
at: pointer,
successOrdering: ordering,
failureOrdering: ._failureOrdering(for: ordering))
}
@_semantics("atomics.requires_constant_orderings")
@_transparent @_alwaysEmitIntoClient
public static func atomicWeakCompareExchange(
expected: Value,
desired: __owned Value,
at pointer: UnsafeMutablePointer<Self>,
ordering: AtomicUpdateOrdering
) -> (exchanged: Bool, original: Value) {
atomicWeakCompareExchange(
expected: expected,
desired: desired,
at: pointer,
successOrdering: ordering,
failureOrdering: ._failureOrdering(for: ordering))
}
}
+5 -3
View File
@@ -13,14 +13,17 @@ add_library(Atomics
autogenerated/HighLevelTypes.swift
autogenerated/IntegerConformances.swift
autogenerated/PointerConformances.swift
autogenerated/Primitives.native.swift
autogenerated/Primitives.shims.swift
AtomicInteger.swift
AtomicMemoryOrderings.swift
AtomicOptional.swift
AtomicRawRepresentable.swift
AtomicOptionalRawRepresentable.swift
AtomicRawRepresentable.swift
AtomicStrongReference.swift
AtomicValue.swift
DoubleWord.swift)
DoubleWord.swift
"Unmanaged extensions.swift")
set_target_properties(Atomics PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES ${CMAKE_Swift_MODULE_DIRECTORY})
if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|AMD64")
@@ -28,7 +31,6 @@ if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|AMD64")
"$<$<COMPILE_LANGUAGE:Swift>:SHELL:-Xcc -mcx16>")
endif()
target_link_libraries(Atomics PUBLIC
_AtomicBuiltins
_AtomicsShims)
_install_target(Atomics)
+40
View File
@@ -247,6 +247,46 @@ extension ${type} {
failureOrdering: failureOrdering)
}
/// Perform an atomic weak compare and exchange operation on the current
/// value, applying the memory ordering. This compare-exchange variant is
/// allowed to spuriously fail; it is designed to be called in a loop until
/// it indicates a successful exchange has happened.
///
/// This operation performs the following algorithm as a single atomic
/// transaction:
///
/// ```
/// atomic(self) { currentValue in
/// let original = currentValue
/// guard original == expected else { return (false, original) }
/// currentValue = desired
/// return (true, original)
/// }
/// ```
///
/// (In this weak form, transient conditions may cause the `original ==
/// expected` check to sometimes return false when the two values are in fact
/// the same.)
///
/// - Parameter expected: The expected current value.
/// - Parameter desired: The desired new value.
/// - Parameter ordering: The memory ordering to apply on this operation.
/// - Returns: A tuple `(exchanged, original)`, where `exchanged` is true if
/// the exchange was successful, and `original` is the original value.
@_semantics("atomics.requires_constant_orderings")
@_transparent @_alwaysEmitIntoClient
public func weakCompareExchange(
expected: Value,
desired: __owned Value,
ordering: AtomicUpdateOrdering
) -> (exchanged: Bool, original: Value) {
_Storage.atomicWeakCompareExchange(
expected: expected,
desired: desired,
at: _ptr,
ordering: ordering)
}
/// Perform an atomic weak compare and exchange operation on the current
/// value, applying the specified success/failure memory orderings. This
/// compare-exchange variant is allowed to spuriously fail; it is designed to
@@ -248,6 +248,46 @@ extension UnsafeAtomic {
failureOrdering: failureOrdering)
}
/// Perform an atomic weak compare and exchange operation on the current
/// value, applying the memory ordering. This compare-exchange variant is
/// allowed to spuriously fail; it is designed to be called in a loop until
/// it indicates a successful exchange has happened.
///
/// This operation performs the following algorithm as a single atomic
/// transaction:
///
/// ```
/// atomic(self) { currentValue in
/// let original = currentValue
/// guard original == expected else { return (false, original) }
/// currentValue = desired
/// return (true, original)
/// }
/// ```
///
/// (In this weak form, transient conditions may cause the `original ==
/// expected` check to sometimes return false when the two values are in fact
/// the same.)
///
/// - Parameter expected: The expected current value.
/// - Parameter desired: The desired new value.
/// - Parameter ordering: The memory ordering to apply on this operation.
/// - Returns: A tuple `(exchanged, original)`, where `exchanged` is true if
/// the exchange was successful, and `original` is the original value.
@_semantics("atomics.requires_constant_orderings")
@_transparent @_alwaysEmitIntoClient
public func weakCompareExchange(
expected: Value,
desired: __owned Value,
ordering: AtomicUpdateOrdering
) -> (exchanged: Bool, original: Value) {
_Storage.atomicWeakCompareExchange(
expected: expected,
desired: desired,
at: _ptr,
ordering: ordering)
}
/// Perform an atomic weak compare and exchange operation on the current
/// value, applying the specified success/failure memory orderings. This
/// compare-exchange variant is allowed to spuriously fail; it is designed to
@@ -654,6 +694,46 @@ extension ManagedAtomic {
failureOrdering: failureOrdering)
}
/// Perform an atomic weak compare and exchange operation on the current
/// value, applying the memory ordering. This compare-exchange variant is
/// allowed to spuriously fail; it is designed to be called in a loop until
/// it indicates a successful exchange has happened.
///
/// This operation performs the following algorithm as a single atomic
/// transaction:
///
/// ```
/// atomic(self) { currentValue in
/// let original = currentValue
/// guard original == expected else { return (false, original) }
/// currentValue = desired
/// return (true, original)
/// }
/// ```
///
/// (In this weak form, transient conditions may cause the `original ==
/// expected` check to sometimes return false when the two values are in fact
/// the same.)
///
/// - Parameter expected: The expected current value.
/// - Parameter desired: The desired new value.
/// - Parameter ordering: The memory ordering to apply on this operation.
/// - Returns: A tuple `(exchanged, original)`, where `exchanged` is true if
/// the exchange was successful, and `original` is the original value.
@_semantics("atomics.requires_constant_orderings")
@_transparent @_alwaysEmitIntoClient
public func weakCompareExchange(
expected: Value,
desired: __owned Value,
ordering: AtomicUpdateOrdering
) -> (exchanged: Bool, original: Value) {
_Storage.atomicWeakCompareExchange(
expected: expected,
desired: desired,
at: _ptr,
ordering: ordering)
}
/// Perform an atomic weak compare and exchange operation on the current
/// value, applying the specified success/failure memory orderings. This
/// compare-exchange variant is allowed to spuriously fail; it is designed to
+1 -2
View File
@@ -1,12 +1,11 @@
#[[
This source file is part of the Swift Atomics Open Source Project
Copyright (c) 2021-2023 Apple Inc. and the Swift project authors
Copyright (c) 2021 - 2023 Apple Inc. and the Swift project authors
Licensed under Apache License v2.0 with Runtime Library Exception
See https://swift.org/LICENSE.txt for license information
#]]
add_subdirectory(_AtomicsShims)
add_subdirectory(_AtomicBuiltins)
add_subdirectory(Atomics)
@@ -125,12 +125,13 @@ class BasicAtomic${label}Tests: XCTestCase {
% end
% for (order, _, _, _, _) in updateOrderings:
func test_compareExchange_${order}() {
% for operation in ["compareExchange", "weakCompareExchange"]:
% for (order, _, _, _, _) in updateOrderings:
func test_${operation}_${order}() {
let v: UnsafeAtomic<${type}> = .create(${a})
defer { v.destroy() }
var (exchanged, original): (Bool, ${type}) = v.compareExchange(
var (exchanged, original): (Bool, ${type}) = v.${operation}(
expected: ${a},
desired: ${b},
ordering: .${order})
@@ -138,7 +139,7 @@ class BasicAtomic${label}Tests: XCTestCase {
XCTAssertEqual(original, ${a})
XCTAssertEqual(v.load(ordering: .relaxed), ${b})
(exchanged, original) = v.compareExchange(
(exchanged, original) = v.${operation}(
expected: ${a},
desired: ${b},
ordering: .${order})
@@ -146,7 +147,7 @@ class BasicAtomic${label}Tests: XCTestCase {
XCTAssertEqual(original, ${b})
XCTAssertEqual(v.load(ordering: .relaxed), ${b})
(exchanged, original) = v.compareExchange(
(exchanged, original) = v.${operation}(
expected: ${b},
desired: ${a},
ordering: .${order})
@@ -154,7 +155,7 @@ class BasicAtomic${label}Tests: XCTestCase {
XCTAssertEqual(original, ${b})
XCTAssertEqual(v.load(ordering: .relaxed), ${a})
(exchanged, original) = v.compareExchange(
(exchanged, original) = v.${operation}(
expected: ${b},
desired: ${a},
ordering: .${order})
@@ -163,6 +164,7 @@ class BasicAtomic${label}Tests: XCTestCase {
XCTAssertEqual(v.load(ordering: .relaxed), ${a})
}
% end
% end
% for operation in ["compareExchange", "weakCompareExchange"]:
@@ -359,6 +359,191 @@ class BasicAtomicBoolTests: XCTestCase {
XCTAssertEqual(v.load(ordering: .relaxed), true)
}
func test_weakCompareExchange_relaxed() {
let v: UnsafeAtomic<Bool> = .create(true)
defer { v.destroy() }
var (exchanged, original): (Bool, Bool) = v.weakCompareExchange(
expected: true,
desired: false,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, true)
XCTAssertEqual(v.load(ordering: .relaxed), false)
(exchanged, original) = v.weakCompareExchange(
expected: true,
desired: false,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, false)
XCTAssertEqual(v.load(ordering: .relaxed), false)
(exchanged, original) = v.weakCompareExchange(
expected: false,
desired: true,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, false)
XCTAssertEqual(v.load(ordering: .relaxed), true)
(exchanged, original) = v.weakCompareExchange(
expected: false,
desired: true,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, true)
XCTAssertEqual(v.load(ordering: .relaxed), true)
}
func test_weakCompareExchange_acquiring() {
let v: UnsafeAtomic<Bool> = .create(true)
defer { v.destroy() }
var (exchanged, original): (Bool, Bool) = v.weakCompareExchange(
expected: true,
desired: false,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, true)
XCTAssertEqual(v.load(ordering: .relaxed), false)
(exchanged, original) = v.weakCompareExchange(
expected: true,
desired: false,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, false)
XCTAssertEqual(v.load(ordering: .relaxed), false)
(exchanged, original) = v.weakCompareExchange(
expected: false,
desired: true,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, false)
XCTAssertEqual(v.load(ordering: .relaxed), true)
(exchanged, original) = v.weakCompareExchange(
expected: false,
desired: true,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, true)
XCTAssertEqual(v.load(ordering: .relaxed), true)
}
func test_weakCompareExchange_releasing() {
let v: UnsafeAtomic<Bool> = .create(true)
defer { v.destroy() }
var (exchanged, original): (Bool, Bool) = v.weakCompareExchange(
expected: true,
desired: false,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, true)
XCTAssertEqual(v.load(ordering: .relaxed), false)
(exchanged, original) = v.weakCompareExchange(
expected: true,
desired: false,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, false)
XCTAssertEqual(v.load(ordering: .relaxed), false)
(exchanged, original) = v.weakCompareExchange(
expected: false,
desired: true,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, false)
XCTAssertEqual(v.load(ordering: .relaxed), true)
(exchanged, original) = v.weakCompareExchange(
expected: false,
desired: true,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, true)
XCTAssertEqual(v.load(ordering: .relaxed), true)
}
func test_weakCompareExchange_acquiringAndReleasing() {
let v: UnsafeAtomic<Bool> = .create(true)
defer { v.destroy() }
var (exchanged, original): (Bool, Bool) = v.weakCompareExchange(
expected: true,
desired: false,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, true)
XCTAssertEqual(v.load(ordering: .relaxed), false)
(exchanged, original) = v.weakCompareExchange(
expected: true,
desired: false,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, false)
XCTAssertEqual(v.load(ordering: .relaxed), false)
(exchanged, original) = v.weakCompareExchange(
expected: false,
desired: true,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, false)
XCTAssertEqual(v.load(ordering: .relaxed), true)
(exchanged, original) = v.weakCompareExchange(
expected: false,
desired: true,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, true)
XCTAssertEqual(v.load(ordering: .relaxed), true)
}
func test_weakCompareExchange_sequentiallyConsistent() {
let v: UnsafeAtomic<Bool> = .create(true)
defer { v.destroy() }
var (exchanged, original): (Bool, Bool) = v.weakCompareExchange(
expected: true,
desired: false,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, true)
XCTAssertEqual(v.load(ordering: .relaxed), false)
(exchanged, original) = v.weakCompareExchange(
expected: true,
desired: false,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, false)
XCTAssertEqual(v.load(ordering: .relaxed), false)
(exchanged, original) = v.weakCompareExchange(
expected: false,
desired: true,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, false)
XCTAssertEqual(v.load(ordering: .relaxed), true)
(exchanged, original) = v.weakCompareExchange(
expected: false,
desired: true,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, true)
XCTAssertEqual(v.load(ordering: .relaxed), true)
}
func test_compareExchange_relaxed_relaxed() {
let v: UnsafeAtomic<Bool> = .create(true)
@@ -359,6 +359,191 @@ class BasicAtomicDoubleWordTests: XCTestCase {
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 100, second: 64))
}
func test_weakCompareExchange_relaxed() {
let v: UnsafeAtomic<DoubleWord> = .create(DoubleWord(first: 100, second: 64))
defer { v.destroy() }
var (exchanged, original): (Bool, DoubleWord) = v.weakCompareExchange(
expected: DoubleWord(first: 100, second: 64),
desired: DoubleWord(first: 50, second: 32),
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, DoubleWord(first: 100, second: 64))
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
(exchanged, original) = v.weakCompareExchange(
expected: DoubleWord(first: 100, second: 64),
desired: DoubleWord(first: 50, second: 32),
ordering: .relaxed)
XCTAssertFalse(exchanged)
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)
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 100, second: 64))
(exchanged, original) = v.weakCompareExchange(
expected: DoubleWord(first: 50, second: 32),
desired: DoubleWord(first: 100, second: 64),
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, DoubleWord(first: 100, second: 64))
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 100, second: 64))
}
func test_weakCompareExchange_acquiring() {
let v: UnsafeAtomic<DoubleWord> = .create(DoubleWord(first: 100, second: 64))
defer { v.destroy() }
var (exchanged, original): (Bool, DoubleWord) = v.weakCompareExchange(
expected: DoubleWord(first: 100, second: 64),
desired: DoubleWord(first: 50, second: 32),
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, DoubleWord(first: 100, second: 64))
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
(exchanged, original) = v.weakCompareExchange(
expected: DoubleWord(first: 100, second: 64),
desired: DoubleWord(first: 50, second: 32),
ordering: .acquiring)
XCTAssertFalse(exchanged)
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)
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 100, second: 64))
(exchanged, original) = v.weakCompareExchange(
expected: DoubleWord(first: 50, second: 32),
desired: DoubleWord(first: 100, second: 64),
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, DoubleWord(first: 100, second: 64))
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 100, second: 64))
}
func test_weakCompareExchange_releasing() {
let v: UnsafeAtomic<DoubleWord> = .create(DoubleWord(first: 100, second: 64))
defer { v.destroy() }
var (exchanged, original): (Bool, DoubleWord) = v.weakCompareExchange(
expected: DoubleWord(first: 100, second: 64),
desired: DoubleWord(first: 50, second: 32),
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, DoubleWord(first: 100, second: 64))
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
(exchanged, original) = v.weakCompareExchange(
expected: DoubleWord(first: 100, second: 64),
desired: DoubleWord(first: 50, second: 32),
ordering: .releasing)
XCTAssertFalse(exchanged)
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)
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 100, second: 64))
(exchanged, original) = v.weakCompareExchange(
expected: DoubleWord(first: 50, second: 32),
desired: DoubleWord(first: 100, second: 64),
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, DoubleWord(first: 100, second: 64))
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 100, second: 64))
}
func test_weakCompareExchange_acquiringAndReleasing() {
let v: UnsafeAtomic<DoubleWord> = .create(DoubleWord(first: 100, second: 64))
defer { v.destroy() }
var (exchanged, original): (Bool, DoubleWord) = v.weakCompareExchange(
expected: DoubleWord(first: 100, second: 64),
desired: DoubleWord(first: 50, second: 32),
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, DoubleWord(first: 100, second: 64))
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
(exchanged, original) = v.weakCompareExchange(
expected: DoubleWord(first: 100, second: 64),
desired: DoubleWord(first: 50, second: 32),
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
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)
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 100, second: 64))
(exchanged, original) = v.weakCompareExchange(
expected: DoubleWord(first: 50, second: 32),
desired: DoubleWord(first: 100, second: 64),
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, DoubleWord(first: 100, second: 64))
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 100, second: 64))
}
func test_weakCompareExchange_sequentiallyConsistent() {
let v: UnsafeAtomic<DoubleWord> = .create(DoubleWord(first: 100, second: 64))
defer { v.destroy() }
var (exchanged, original): (Bool, DoubleWord) = v.weakCompareExchange(
expected: DoubleWord(first: 100, second: 64),
desired: DoubleWord(first: 50, second: 32),
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, DoubleWord(first: 100, second: 64))
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 50, second: 32))
(exchanged, original) = v.weakCompareExchange(
expected: DoubleWord(first: 100, second: 64),
desired: DoubleWord(first: 50, second: 32),
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
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)
XCTAssertEqual(original, DoubleWord(first: 50, second: 32))
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 100, second: 64))
(exchanged, original) = v.weakCompareExchange(
expected: DoubleWord(first: 50, second: 32),
desired: DoubleWord(first: 100, second: 64),
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, DoubleWord(first: 100, second: 64))
XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(first: 100, second: 64))
}
func test_compareExchange_relaxed_relaxed() {
let v: UnsafeAtomic<DoubleWord> = .create(DoubleWord(first: 100, second: 64))
@@ -359,6 +359,191 @@ class BasicAtomicInt16Tests: XCTestCase {
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_relaxed() {
let v: UnsafeAtomic<Int16> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, Int16) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_acquiring() {
let v: UnsafeAtomic<Int16> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, Int16) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_releasing() {
let v: UnsafeAtomic<Int16> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, Int16) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_acquiringAndReleasing() {
let v: UnsafeAtomic<Int16> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, Int16) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_sequentiallyConsistent() {
let v: UnsafeAtomic<Int16> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, Int16) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_compareExchange_relaxed_relaxed() {
let v: UnsafeAtomic<Int16> = .create(12)
@@ -359,6 +359,191 @@ class BasicAtomicInt32Tests: XCTestCase {
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_relaxed() {
let v: UnsafeAtomic<Int32> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, Int32) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_acquiring() {
let v: UnsafeAtomic<Int32> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, Int32) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_releasing() {
let v: UnsafeAtomic<Int32> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, Int32) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_acquiringAndReleasing() {
let v: UnsafeAtomic<Int32> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, Int32) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_sequentiallyConsistent() {
let v: UnsafeAtomic<Int32> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, Int32) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_compareExchange_relaxed_relaxed() {
let v: UnsafeAtomic<Int32> = .create(12)
@@ -359,6 +359,191 @@ class BasicAtomicInt64Tests: XCTestCase {
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_relaxed() {
let v: UnsafeAtomic<Int64> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, Int64) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_acquiring() {
let v: UnsafeAtomic<Int64> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, Int64) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_releasing() {
let v: UnsafeAtomic<Int64> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, Int64) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_acquiringAndReleasing() {
let v: UnsafeAtomic<Int64> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, Int64) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_sequentiallyConsistent() {
let v: UnsafeAtomic<Int64> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, Int64) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_compareExchange_relaxed_relaxed() {
let v: UnsafeAtomic<Int64> = .create(12)
@@ -359,6 +359,191 @@ class BasicAtomicInt8Tests: XCTestCase {
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_relaxed() {
let v: UnsafeAtomic<Int8> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, Int8) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_acquiring() {
let v: UnsafeAtomic<Int8> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, Int8) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_releasing() {
let v: UnsafeAtomic<Int8> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, Int8) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_acquiringAndReleasing() {
let v: UnsafeAtomic<Int8> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, Int8) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_sequentiallyConsistent() {
let v: UnsafeAtomic<Int8> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, Int8) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_compareExchange_relaxed_relaxed() {
let v: UnsafeAtomic<Int8> = .create(12)
@@ -359,6 +359,191 @@ class BasicAtomicIntTests: XCTestCase {
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_relaxed() {
let v: UnsafeAtomic<Int> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, Int) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_acquiring() {
let v: UnsafeAtomic<Int> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, Int) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_releasing() {
let v: UnsafeAtomic<Int> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, Int) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_acquiringAndReleasing() {
let v: UnsafeAtomic<Int> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, Int) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_sequentiallyConsistent() {
let v: UnsafeAtomic<Int> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, Int) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_compareExchange_relaxed_relaxed() {
let v: UnsafeAtomic<Int> = .create(12)
@@ -380,6 +380,191 @@ class BasicAtomicMutablePointerTests: XCTestCase {
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1)
}
func test_weakCompareExchange_relaxed() {
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>> = .create(_mfoo1)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>) = v.weakCompareExchange(
expected: _mfoo1,
desired: _mfoo2,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _mfoo1)
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
(exchanged, original) = v.weakCompareExchange(
expected: _mfoo1,
desired: _mfoo2,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _mfoo2)
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
(exchanged, original) = v.weakCompareExchange(
expected: _mfoo2,
desired: _mfoo1,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _mfoo2)
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1)
(exchanged, original) = v.weakCompareExchange(
expected: _mfoo2,
desired: _mfoo1,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _mfoo1)
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1)
}
func test_weakCompareExchange_acquiring() {
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>> = .create(_mfoo1)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>) = v.weakCompareExchange(
expected: _mfoo1,
desired: _mfoo2,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _mfoo1)
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
(exchanged, original) = v.weakCompareExchange(
expected: _mfoo1,
desired: _mfoo2,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _mfoo2)
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
(exchanged, original) = v.weakCompareExchange(
expected: _mfoo2,
desired: _mfoo1,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _mfoo2)
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1)
(exchanged, original) = v.weakCompareExchange(
expected: _mfoo2,
desired: _mfoo1,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _mfoo1)
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1)
}
func test_weakCompareExchange_releasing() {
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>> = .create(_mfoo1)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>) = v.weakCompareExchange(
expected: _mfoo1,
desired: _mfoo2,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _mfoo1)
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
(exchanged, original) = v.weakCompareExchange(
expected: _mfoo1,
desired: _mfoo2,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _mfoo2)
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
(exchanged, original) = v.weakCompareExchange(
expected: _mfoo2,
desired: _mfoo1,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _mfoo2)
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1)
(exchanged, original) = v.weakCompareExchange(
expected: _mfoo2,
desired: _mfoo1,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _mfoo1)
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1)
}
func test_weakCompareExchange_acquiringAndReleasing() {
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>> = .create(_mfoo1)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>) = v.weakCompareExchange(
expected: _mfoo1,
desired: _mfoo2,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _mfoo1)
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
(exchanged, original) = v.weakCompareExchange(
expected: _mfoo1,
desired: _mfoo2,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _mfoo2)
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
(exchanged, original) = v.weakCompareExchange(
expected: _mfoo2,
desired: _mfoo1,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _mfoo2)
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1)
(exchanged, original) = v.weakCompareExchange(
expected: _mfoo2,
desired: _mfoo1,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _mfoo1)
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1)
}
func test_weakCompareExchange_sequentiallyConsistent() {
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>> = .create(_mfoo1)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>) = v.weakCompareExchange(
expected: _mfoo1,
desired: _mfoo2,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _mfoo1)
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
(exchanged, original) = v.weakCompareExchange(
expected: _mfoo1,
desired: _mfoo2,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _mfoo2)
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
(exchanged, original) = v.weakCompareExchange(
expected: _mfoo2,
desired: _mfoo1,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _mfoo2)
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1)
(exchanged, original) = v.weakCompareExchange(
expected: _mfoo2,
desired: _mfoo1,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _mfoo1)
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1)
}
func test_compareExchange_relaxed_relaxed() {
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>> = .create(_mfoo1)
@@ -369,6 +369,191 @@ class BasicAtomicMutableRawPointerTests: XCTestCase {
XCTAssertEqual(v.load(ordering: .relaxed), _mraw1)
}
func test_weakCompareExchange_relaxed() {
let v: UnsafeAtomic<UnsafeMutableRawPointer> = .create(_mraw1)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafeMutableRawPointer) = v.weakCompareExchange(
expected: _mraw1,
desired: _mraw2,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _mraw1)
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
(exchanged, original) = v.weakCompareExchange(
expected: _mraw1,
desired: _mraw2,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _mraw2)
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
(exchanged, original) = v.weakCompareExchange(
expected: _mraw2,
desired: _mraw1,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _mraw2)
XCTAssertEqual(v.load(ordering: .relaxed), _mraw1)
(exchanged, original) = v.weakCompareExchange(
expected: _mraw2,
desired: _mraw1,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _mraw1)
XCTAssertEqual(v.load(ordering: .relaxed), _mraw1)
}
func test_weakCompareExchange_acquiring() {
let v: UnsafeAtomic<UnsafeMutableRawPointer> = .create(_mraw1)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafeMutableRawPointer) = v.weakCompareExchange(
expected: _mraw1,
desired: _mraw2,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _mraw1)
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
(exchanged, original) = v.weakCompareExchange(
expected: _mraw1,
desired: _mraw2,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _mraw2)
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
(exchanged, original) = v.weakCompareExchange(
expected: _mraw2,
desired: _mraw1,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _mraw2)
XCTAssertEqual(v.load(ordering: .relaxed), _mraw1)
(exchanged, original) = v.weakCompareExchange(
expected: _mraw2,
desired: _mraw1,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _mraw1)
XCTAssertEqual(v.load(ordering: .relaxed), _mraw1)
}
func test_weakCompareExchange_releasing() {
let v: UnsafeAtomic<UnsafeMutableRawPointer> = .create(_mraw1)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafeMutableRawPointer) = v.weakCompareExchange(
expected: _mraw1,
desired: _mraw2,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _mraw1)
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
(exchanged, original) = v.weakCompareExchange(
expected: _mraw1,
desired: _mraw2,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _mraw2)
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
(exchanged, original) = v.weakCompareExchange(
expected: _mraw2,
desired: _mraw1,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _mraw2)
XCTAssertEqual(v.load(ordering: .relaxed), _mraw1)
(exchanged, original) = v.weakCompareExchange(
expected: _mraw2,
desired: _mraw1,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _mraw1)
XCTAssertEqual(v.load(ordering: .relaxed), _mraw1)
}
func test_weakCompareExchange_acquiringAndReleasing() {
let v: UnsafeAtomic<UnsafeMutableRawPointer> = .create(_mraw1)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafeMutableRawPointer) = v.weakCompareExchange(
expected: _mraw1,
desired: _mraw2,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _mraw1)
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
(exchanged, original) = v.weakCompareExchange(
expected: _mraw1,
desired: _mraw2,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _mraw2)
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
(exchanged, original) = v.weakCompareExchange(
expected: _mraw2,
desired: _mraw1,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _mraw2)
XCTAssertEqual(v.load(ordering: .relaxed), _mraw1)
(exchanged, original) = v.weakCompareExchange(
expected: _mraw2,
desired: _mraw1,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _mraw1)
XCTAssertEqual(v.load(ordering: .relaxed), _mraw1)
}
func test_weakCompareExchange_sequentiallyConsistent() {
let v: UnsafeAtomic<UnsafeMutableRawPointer> = .create(_mraw1)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafeMutableRawPointer) = v.weakCompareExchange(
expected: _mraw1,
desired: _mraw2,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _mraw1)
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
(exchanged, original) = v.weakCompareExchange(
expected: _mraw1,
desired: _mraw2,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _mraw2)
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
(exchanged, original) = v.weakCompareExchange(
expected: _mraw2,
desired: _mraw1,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _mraw2)
XCTAssertEqual(v.load(ordering: .relaxed), _mraw1)
(exchanged, original) = v.weakCompareExchange(
expected: _mraw2,
desired: _mraw1,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _mraw1)
XCTAssertEqual(v.load(ordering: .relaxed), _mraw1)
}
func test_compareExchange_relaxed_relaxed() {
let v: UnsafeAtomic<UnsafeMutableRawPointer> = .create(_mraw1)
@@ -380,6 +380,191 @@ class BasicAtomicOptionalMutablePointerTests: XCTestCase {
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_weakCompareExchange_relaxed() {
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>?> = .create(nil)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?) = v.weakCompareExchange(
expected: nil,
desired: _mfoo2,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: _mfoo2,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _mfoo2)
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
(exchanged, original) = v.weakCompareExchange(
expected: _mfoo2,
desired: nil,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _mfoo2)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: _mfoo2,
desired: nil,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_weakCompareExchange_acquiring() {
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>?> = .create(nil)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?) = v.weakCompareExchange(
expected: nil,
desired: _mfoo2,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: _mfoo2,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _mfoo2)
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
(exchanged, original) = v.weakCompareExchange(
expected: _mfoo2,
desired: nil,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _mfoo2)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: _mfoo2,
desired: nil,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_weakCompareExchange_releasing() {
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>?> = .create(nil)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?) = v.weakCompareExchange(
expected: nil,
desired: _mfoo2,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: _mfoo2,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _mfoo2)
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
(exchanged, original) = v.weakCompareExchange(
expected: _mfoo2,
desired: nil,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _mfoo2)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: _mfoo2,
desired: nil,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_weakCompareExchange_acquiringAndReleasing() {
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>?> = .create(nil)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?) = v.weakCompareExchange(
expected: nil,
desired: _mfoo2,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: _mfoo2,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _mfoo2)
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
(exchanged, original) = v.weakCompareExchange(
expected: _mfoo2,
desired: nil,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _mfoo2)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: _mfoo2,
desired: nil,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_weakCompareExchange_sequentiallyConsistent() {
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>?> = .create(nil)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafeMutablePointer<Foo>?) = v.weakCompareExchange(
expected: nil,
desired: _mfoo2,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: _mfoo2,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _mfoo2)
XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2)
(exchanged, original) = v.weakCompareExchange(
expected: _mfoo2,
desired: nil,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _mfoo2)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: _mfoo2,
desired: nil,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_compareExchange_relaxed_relaxed() {
let v: UnsafeAtomic<UnsafeMutablePointer<Foo>?> = .create(nil)
@@ -369,6 +369,191 @@ class BasicAtomicOptionalMutableRawPointerTests: XCTestCase {
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_weakCompareExchange_relaxed() {
let v: UnsafeAtomic<UnsafeMutableRawPointer?> = .create(nil)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafeMutableRawPointer?) = v.weakCompareExchange(
expected: nil,
desired: _mraw2,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: _mraw2,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _mraw2)
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
(exchanged, original) = v.weakCompareExchange(
expected: _mraw2,
desired: nil,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _mraw2)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: _mraw2,
desired: nil,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_weakCompareExchange_acquiring() {
let v: UnsafeAtomic<UnsafeMutableRawPointer?> = .create(nil)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafeMutableRawPointer?) = v.weakCompareExchange(
expected: nil,
desired: _mraw2,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: _mraw2,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _mraw2)
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
(exchanged, original) = v.weakCompareExchange(
expected: _mraw2,
desired: nil,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _mraw2)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: _mraw2,
desired: nil,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_weakCompareExchange_releasing() {
let v: UnsafeAtomic<UnsafeMutableRawPointer?> = .create(nil)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafeMutableRawPointer?) = v.weakCompareExchange(
expected: nil,
desired: _mraw2,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: _mraw2,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _mraw2)
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
(exchanged, original) = v.weakCompareExchange(
expected: _mraw2,
desired: nil,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _mraw2)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: _mraw2,
desired: nil,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_weakCompareExchange_acquiringAndReleasing() {
let v: UnsafeAtomic<UnsafeMutableRawPointer?> = .create(nil)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafeMutableRawPointer?) = v.weakCompareExchange(
expected: nil,
desired: _mraw2,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: _mraw2,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _mraw2)
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
(exchanged, original) = v.weakCompareExchange(
expected: _mraw2,
desired: nil,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _mraw2)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: _mraw2,
desired: nil,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_weakCompareExchange_sequentiallyConsistent() {
let v: UnsafeAtomic<UnsafeMutableRawPointer?> = .create(nil)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafeMutableRawPointer?) = v.weakCompareExchange(
expected: nil,
desired: _mraw2,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: _mraw2,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _mraw2)
XCTAssertEqual(v.load(ordering: .relaxed), _mraw2)
(exchanged, original) = v.weakCompareExchange(
expected: _mraw2,
desired: nil,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _mraw2)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: _mraw2,
desired: nil,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_compareExchange_relaxed_relaxed() {
let v: UnsafeAtomic<UnsafeMutableRawPointer?> = .create(nil)
@@ -380,6 +380,191 @@ class BasicAtomicOptionalPointerTests: XCTestCase {
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_weakCompareExchange_relaxed() {
let v: UnsafeAtomic<UnsafePointer<Foo>?> = .create(nil)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafePointer<Foo>?) = v.weakCompareExchange(
expected: nil,
desired: _foo2,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: _foo2,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _foo2)
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
(exchanged, original) = v.weakCompareExchange(
expected: _foo2,
desired: nil,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _foo2)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: _foo2,
desired: nil,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_weakCompareExchange_acquiring() {
let v: UnsafeAtomic<UnsafePointer<Foo>?> = .create(nil)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafePointer<Foo>?) = v.weakCompareExchange(
expected: nil,
desired: _foo2,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: _foo2,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _foo2)
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
(exchanged, original) = v.weakCompareExchange(
expected: _foo2,
desired: nil,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _foo2)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: _foo2,
desired: nil,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_weakCompareExchange_releasing() {
let v: UnsafeAtomic<UnsafePointer<Foo>?> = .create(nil)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafePointer<Foo>?) = v.weakCompareExchange(
expected: nil,
desired: _foo2,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: _foo2,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _foo2)
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
(exchanged, original) = v.weakCompareExchange(
expected: _foo2,
desired: nil,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _foo2)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: _foo2,
desired: nil,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_weakCompareExchange_acquiringAndReleasing() {
let v: UnsafeAtomic<UnsafePointer<Foo>?> = .create(nil)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafePointer<Foo>?) = v.weakCompareExchange(
expected: nil,
desired: _foo2,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: _foo2,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _foo2)
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
(exchanged, original) = v.weakCompareExchange(
expected: _foo2,
desired: nil,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _foo2)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: _foo2,
desired: nil,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_weakCompareExchange_sequentiallyConsistent() {
let v: UnsafeAtomic<UnsafePointer<Foo>?> = .create(nil)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafePointer<Foo>?) = v.weakCompareExchange(
expected: nil,
desired: _foo2,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: _foo2,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _foo2)
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
(exchanged, original) = v.weakCompareExchange(
expected: _foo2,
desired: nil,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _foo2)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: _foo2,
desired: nil,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_compareExchange_relaxed_relaxed() {
let v: UnsafeAtomic<UnsafePointer<Foo>?> = .create(nil)
@@ -369,6 +369,191 @@ class BasicAtomicOptionalRawPointerTests: XCTestCase {
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_weakCompareExchange_relaxed() {
let v: UnsafeAtomic<UnsafeRawPointer?> = .create(nil)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafeRawPointer?) = v.weakCompareExchange(
expected: nil,
desired: _raw2,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: _raw2,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _raw2)
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
(exchanged, original) = v.weakCompareExchange(
expected: _raw2,
desired: nil,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _raw2)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: _raw2,
desired: nil,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_weakCompareExchange_acquiring() {
let v: UnsafeAtomic<UnsafeRawPointer?> = .create(nil)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafeRawPointer?) = v.weakCompareExchange(
expected: nil,
desired: _raw2,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: _raw2,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _raw2)
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
(exchanged, original) = v.weakCompareExchange(
expected: _raw2,
desired: nil,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _raw2)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: _raw2,
desired: nil,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_weakCompareExchange_releasing() {
let v: UnsafeAtomic<UnsafeRawPointer?> = .create(nil)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafeRawPointer?) = v.weakCompareExchange(
expected: nil,
desired: _raw2,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: _raw2,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _raw2)
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
(exchanged, original) = v.weakCompareExchange(
expected: _raw2,
desired: nil,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _raw2)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: _raw2,
desired: nil,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_weakCompareExchange_acquiringAndReleasing() {
let v: UnsafeAtomic<UnsafeRawPointer?> = .create(nil)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafeRawPointer?) = v.weakCompareExchange(
expected: nil,
desired: _raw2,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: _raw2,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _raw2)
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
(exchanged, original) = v.weakCompareExchange(
expected: _raw2,
desired: nil,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _raw2)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: _raw2,
desired: nil,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_weakCompareExchange_sequentiallyConsistent() {
let v: UnsafeAtomic<UnsafeRawPointer?> = .create(nil)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafeRawPointer?) = v.weakCompareExchange(
expected: nil,
desired: _raw2,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: _raw2,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _raw2)
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
(exchanged, original) = v.weakCompareExchange(
expected: _raw2,
desired: nil,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _raw2)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: _raw2,
desired: nil,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_compareExchange_relaxed_relaxed() {
let v: UnsafeAtomic<UnsafeRawPointer?> = .create(nil)
@@ -359,6 +359,191 @@ class BasicAtomicOptionalRawRepresentableTests: XCTestCase {
XCTAssertEqual(v.load(ordering: .relaxed), Hyacinth.bucket)
}
func test_weakCompareExchange_relaxed() {
let v: UnsafeAtomic<Hyacinth?> = .create(Hyacinth.bucket)
defer { v.destroy() }
var (exchanged, original): (Bool, Hyacinth?) = v.weakCompareExchange(
expected: Hyacinth.bucket,
desired: nil,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, Hyacinth.bucket)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: Hyacinth.bucket,
desired: nil,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: Hyacinth.bucket,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), Hyacinth.bucket)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: Hyacinth.bucket,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, Hyacinth.bucket)
XCTAssertEqual(v.load(ordering: .relaxed), Hyacinth.bucket)
}
func test_weakCompareExchange_acquiring() {
let v: UnsafeAtomic<Hyacinth?> = .create(Hyacinth.bucket)
defer { v.destroy() }
var (exchanged, original): (Bool, Hyacinth?) = v.weakCompareExchange(
expected: Hyacinth.bucket,
desired: nil,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, Hyacinth.bucket)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: Hyacinth.bucket,
desired: nil,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: Hyacinth.bucket,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), Hyacinth.bucket)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: Hyacinth.bucket,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, Hyacinth.bucket)
XCTAssertEqual(v.load(ordering: .relaxed), Hyacinth.bucket)
}
func test_weakCompareExchange_releasing() {
let v: UnsafeAtomic<Hyacinth?> = .create(Hyacinth.bucket)
defer { v.destroy() }
var (exchanged, original): (Bool, Hyacinth?) = v.weakCompareExchange(
expected: Hyacinth.bucket,
desired: nil,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, Hyacinth.bucket)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: Hyacinth.bucket,
desired: nil,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: Hyacinth.bucket,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), Hyacinth.bucket)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: Hyacinth.bucket,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, Hyacinth.bucket)
XCTAssertEqual(v.load(ordering: .relaxed), Hyacinth.bucket)
}
func test_weakCompareExchange_acquiringAndReleasing() {
let v: UnsafeAtomic<Hyacinth?> = .create(Hyacinth.bucket)
defer { v.destroy() }
var (exchanged, original): (Bool, Hyacinth?) = v.weakCompareExchange(
expected: Hyacinth.bucket,
desired: nil,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, Hyacinth.bucket)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: Hyacinth.bucket,
desired: nil,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: Hyacinth.bucket,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), Hyacinth.bucket)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: Hyacinth.bucket,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, Hyacinth.bucket)
XCTAssertEqual(v.load(ordering: .relaxed), Hyacinth.bucket)
}
func test_weakCompareExchange_sequentiallyConsistent() {
let v: UnsafeAtomic<Hyacinth?> = .create(Hyacinth.bucket)
defer { v.destroy() }
var (exchanged, original): (Bool, Hyacinth?) = v.weakCompareExchange(
expected: Hyacinth.bucket,
desired: nil,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, Hyacinth.bucket)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: Hyacinth.bucket,
desired: nil,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: Hyacinth.bucket,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), Hyacinth.bucket)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: Hyacinth.bucket,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, Hyacinth.bucket)
XCTAssertEqual(v.load(ordering: .relaxed), Hyacinth.bucket)
}
func test_compareExchange_relaxed_relaxed() {
let v: UnsafeAtomic<Hyacinth?> = .create(Hyacinth.bucket)
@@ -361,6 +361,191 @@ class BasicAtomicOptionalReferenceTests: XCTestCase {
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_weakCompareExchange_relaxed() {
let v: UnsafeAtomic<Baz?> = .create(nil)
defer { v.destroy() }
var (exchanged, original): (Bool, Baz?) = v.weakCompareExchange(
expected: nil,
desired: _baz2,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: _baz2,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _baz2)
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
(exchanged, original) = v.weakCompareExchange(
expected: _baz2,
desired: nil,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _baz2)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: _baz2,
desired: nil,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_weakCompareExchange_acquiring() {
let v: UnsafeAtomic<Baz?> = .create(nil)
defer { v.destroy() }
var (exchanged, original): (Bool, Baz?) = v.weakCompareExchange(
expected: nil,
desired: _baz2,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: _baz2,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _baz2)
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
(exchanged, original) = v.weakCompareExchange(
expected: _baz2,
desired: nil,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _baz2)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: _baz2,
desired: nil,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_weakCompareExchange_releasing() {
let v: UnsafeAtomic<Baz?> = .create(nil)
defer { v.destroy() }
var (exchanged, original): (Bool, Baz?) = v.weakCompareExchange(
expected: nil,
desired: _baz2,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: _baz2,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _baz2)
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
(exchanged, original) = v.weakCompareExchange(
expected: _baz2,
desired: nil,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _baz2)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: _baz2,
desired: nil,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_weakCompareExchange_acquiringAndReleasing() {
let v: UnsafeAtomic<Baz?> = .create(nil)
defer { v.destroy() }
var (exchanged, original): (Bool, Baz?) = v.weakCompareExchange(
expected: nil,
desired: _baz2,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: _baz2,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _baz2)
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
(exchanged, original) = v.weakCompareExchange(
expected: _baz2,
desired: nil,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _baz2)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: _baz2,
desired: nil,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_weakCompareExchange_sequentiallyConsistent() {
let v: UnsafeAtomic<Baz?> = .create(nil)
defer { v.destroy() }
var (exchanged, original): (Bool, Baz?) = v.weakCompareExchange(
expected: nil,
desired: _baz2,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: _baz2,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _baz2)
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
(exchanged, original) = v.weakCompareExchange(
expected: _baz2,
desired: nil,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _baz2)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: _baz2,
desired: nil,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_compareExchange_relaxed_relaxed() {
let v: UnsafeAtomic<Baz?> = .create(nil)
@@ -366,6 +366,191 @@ class BasicAtomicOptionalUnmanagedTests: XCTestCase {
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_weakCompareExchange_relaxed() {
let v: UnsafeAtomic<Unmanaged<Bar>?> = .create(nil)
defer { v.destroy() }
var (exchanged, original): (Bool, Unmanaged<Bar>?) = v.weakCompareExchange(
expected: nil,
desired: _bar2,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: _bar2,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _bar2)
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
(exchanged, original) = v.weakCompareExchange(
expected: _bar2,
desired: nil,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _bar2)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: _bar2,
desired: nil,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_weakCompareExchange_acquiring() {
let v: UnsafeAtomic<Unmanaged<Bar>?> = .create(nil)
defer { v.destroy() }
var (exchanged, original): (Bool, Unmanaged<Bar>?) = v.weakCompareExchange(
expected: nil,
desired: _bar2,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: _bar2,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _bar2)
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
(exchanged, original) = v.weakCompareExchange(
expected: _bar2,
desired: nil,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _bar2)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: _bar2,
desired: nil,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_weakCompareExchange_releasing() {
let v: UnsafeAtomic<Unmanaged<Bar>?> = .create(nil)
defer { v.destroy() }
var (exchanged, original): (Bool, Unmanaged<Bar>?) = v.weakCompareExchange(
expected: nil,
desired: _bar2,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: _bar2,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _bar2)
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
(exchanged, original) = v.weakCompareExchange(
expected: _bar2,
desired: nil,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _bar2)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: _bar2,
desired: nil,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_weakCompareExchange_acquiringAndReleasing() {
let v: UnsafeAtomic<Unmanaged<Bar>?> = .create(nil)
defer { v.destroy() }
var (exchanged, original): (Bool, Unmanaged<Bar>?) = v.weakCompareExchange(
expected: nil,
desired: _bar2,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: _bar2,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _bar2)
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
(exchanged, original) = v.weakCompareExchange(
expected: _bar2,
desired: nil,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _bar2)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: _bar2,
desired: nil,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_weakCompareExchange_sequentiallyConsistent() {
let v: UnsafeAtomic<Unmanaged<Bar>?> = .create(nil)
defer { v.destroy() }
var (exchanged, original): (Bool, Unmanaged<Bar>?) = v.weakCompareExchange(
expected: nil,
desired: _bar2,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
(exchanged, original) = v.weakCompareExchange(
expected: nil,
desired: _bar2,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _bar2)
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
(exchanged, original) = v.weakCompareExchange(
expected: _bar2,
desired: nil,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _bar2)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
(exchanged, original) = v.weakCompareExchange(
expected: _bar2,
desired: nil,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, nil)
XCTAssertEqual(v.load(ordering: .relaxed), nil)
}
func test_compareExchange_relaxed_relaxed() {
let v: UnsafeAtomic<Unmanaged<Bar>?> = .create(nil)
@@ -380,6 +380,191 @@ class BasicAtomicPointerTests: XCTestCase {
XCTAssertEqual(v.load(ordering: .relaxed), _foo1)
}
func test_weakCompareExchange_relaxed() {
let v: UnsafeAtomic<UnsafePointer<Foo>> = .create(_foo1)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafePointer<Foo>) = v.weakCompareExchange(
expected: _foo1,
desired: _foo2,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _foo1)
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
(exchanged, original) = v.weakCompareExchange(
expected: _foo1,
desired: _foo2,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _foo2)
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
(exchanged, original) = v.weakCompareExchange(
expected: _foo2,
desired: _foo1,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _foo2)
XCTAssertEqual(v.load(ordering: .relaxed), _foo1)
(exchanged, original) = v.weakCompareExchange(
expected: _foo2,
desired: _foo1,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _foo1)
XCTAssertEqual(v.load(ordering: .relaxed), _foo1)
}
func test_weakCompareExchange_acquiring() {
let v: UnsafeAtomic<UnsafePointer<Foo>> = .create(_foo1)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafePointer<Foo>) = v.weakCompareExchange(
expected: _foo1,
desired: _foo2,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _foo1)
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
(exchanged, original) = v.weakCompareExchange(
expected: _foo1,
desired: _foo2,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _foo2)
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
(exchanged, original) = v.weakCompareExchange(
expected: _foo2,
desired: _foo1,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _foo2)
XCTAssertEqual(v.load(ordering: .relaxed), _foo1)
(exchanged, original) = v.weakCompareExchange(
expected: _foo2,
desired: _foo1,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _foo1)
XCTAssertEqual(v.load(ordering: .relaxed), _foo1)
}
func test_weakCompareExchange_releasing() {
let v: UnsafeAtomic<UnsafePointer<Foo>> = .create(_foo1)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafePointer<Foo>) = v.weakCompareExchange(
expected: _foo1,
desired: _foo2,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _foo1)
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
(exchanged, original) = v.weakCompareExchange(
expected: _foo1,
desired: _foo2,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _foo2)
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
(exchanged, original) = v.weakCompareExchange(
expected: _foo2,
desired: _foo1,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _foo2)
XCTAssertEqual(v.load(ordering: .relaxed), _foo1)
(exchanged, original) = v.weakCompareExchange(
expected: _foo2,
desired: _foo1,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _foo1)
XCTAssertEqual(v.load(ordering: .relaxed), _foo1)
}
func test_weakCompareExchange_acquiringAndReleasing() {
let v: UnsafeAtomic<UnsafePointer<Foo>> = .create(_foo1)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafePointer<Foo>) = v.weakCompareExchange(
expected: _foo1,
desired: _foo2,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _foo1)
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
(exchanged, original) = v.weakCompareExchange(
expected: _foo1,
desired: _foo2,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _foo2)
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
(exchanged, original) = v.weakCompareExchange(
expected: _foo2,
desired: _foo1,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _foo2)
XCTAssertEqual(v.load(ordering: .relaxed), _foo1)
(exchanged, original) = v.weakCompareExchange(
expected: _foo2,
desired: _foo1,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _foo1)
XCTAssertEqual(v.load(ordering: .relaxed), _foo1)
}
func test_weakCompareExchange_sequentiallyConsistent() {
let v: UnsafeAtomic<UnsafePointer<Foo>> = .create(_foo1)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafePointer<Foo>) = v.weakCompareExchange(
expected: _foo1,
desired: _foo2,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _foo1)
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
(exchanged, original) = v.weakCompareExchange(
expected: _foo1,
desired: _foo2,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _foo2)
XCTAssertEqual(v.load(ordering: .relaxed), _foo2)
(exchanged, original) = v.weakCompareExchange(
expected: _foo2,
desired: _foo1,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _foo2)
XCTAssertEqual(v.load(ordering: .relaxed), _foo1)
(exchanged, original) = v.weakCompareExchange(
expected: _foo2,
desired: _foo1,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _foo1)
XCTAssertEqual(v.load(ordering: .relaxed), _foo1)
}
func test_compareExchange_relaxed_relaxed() {
let v: UnsafeAtomic<UnsafePointer<Foo>> = .create(_foo1)
@@ -369,6 +369,191 @@ class BasicAtomicRawPointerTests: XCTestCase {
XCTAssertEqual(v.load(ordering: .relaxed), _raw1)
}
func test_weakCompareExchange_relaxed() {
let v: UnsafeAtomic<UnsafeRawPointer> = .create(_raw1)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafeRawPointer) = v.weakCompareExchange(
expected: _raw1,
desired: _raw2,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _raw1)
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
(exchanged, original) = v.weakCompareExchange(
expected: _raw1,
desired: _raw2,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _raw2)
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
(exchanged, original) = v.weakCompareExchange(
expected: _raw2,
desired: _raw1,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _raw2)
XCTAssertEqual(v.load(ordering: .relaxed), _raw1)
(exchanged, original) = v.weakCompareExchange(
expected: _raw2,
desired: _raw1,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _raw1)
XCTAssertEqual(v.load(ordering: .relaxed), _raw1)
}
func test_weakCompareExchange_acquiring() {
let v: UnsafeAtomic<UnsafeRawPointer> = .create(_raw1)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafeRawPointer) = v.weakCompareExchange(
expected: _raw1,
desired: _raw2,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _raw1)
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
(exchanged, original) = v.weakCompareExchange(
expected: _raw1,
desired: _raw2,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _raw2)
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
(exchanged, original) = v.weakCompareExchange(
expected: _raw2,
desired: _raw1,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _raw2)
XCTAssertEqual(v.load(ordering: .relaxed), _raw1)
(exchanged, original) = v.weakCompareExchange(
expected: _raw2,
desired: _raw1,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _raw1)
XCTAssertEqual(v.load(ordering: .relaxed), _raw1)
}
func test_weakCompareExchange_releasing() {
let v: UnsafeAtomic<UnsafeRawPointer> = .create(_raw1)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafeRawPointer) = v.weakCompareExchange(
expected: _raw1,
desired: _raw2,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _raw1)
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
(exchanged, original) = v.weakCompareExchange(
expected: _raw1,
desired: _raw2,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _raw2)
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
(exchanged, original) = v.weakCompareExchange(
expected: _raw2,
desired: _raw1,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _raw2)
XCTAssertEqual(v.load(ordering: .relaxed), _raw1)
(exchanged, original) = v.weakCompareExchange(
expected: _raw2,
desired: _raw1,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _raw1)
XCTAssertEqual(v.load(ordering: .relaxed), _raw1)
}
func test_weakCompareExchange_acquiringAndReleasing() {
let v: UnsafeAtomic<UnsafeRawPointer> = .create(_raw1)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafeRawPointer) = v.weakCompareExchange(
expected: _raw1,
desired: _raw2,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _raw1)
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
(exchanged, original) = v.weakCompareExchange(
expected: _raw1,
desired: _raw2,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _raw2)
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
(exchanged, original) = v.weakCompareExchange(
expected: _raw2,
desired: _raw1,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _raw2)
XCTAssertEqual(v.load(ordering: .relaxed), _raw1)
(exchanged, original) = v.weakCompareExchange(
expected: _raw2,
desired: _raw1,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _raw1)
XCTAssertEqual(v.load(ordering: .relaxed), _raw1)
}
func test_weakCompareExchange_sequentiallyConsistent() {
let v: UnsafeAtomic<UnsafeRawPointer> = .create(_raw1)
defer { v.destroy() }
var (exchanged, original): (Bool, UnsafeRawPointer) = v.weakCompareExchange(
expected: _raw1,
desired: _raw2,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _raw1)
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
(exchanged, original) = v.weakCompareExchange(
expected: _raw1,
desired: _raw2,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _raw2)
XCTAssertEqual(v.load(ordering: .relaxed), _raw2)
(exchanged, original) = v.weakCompareExchange(
expected: _raw2,
desired: _raw1,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _raw2)
XCTAssertEqual(v.load(ordering: .relaxed), _raw1)
(exchanged, original) = v.weakCompareExchange(
expected: _raw2,
desired: _raw1,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _raw1)
XCTAssertEqual(v.load(ordering: .relaxed), _raw1)
}
func test_compareExchange_relaxed_relaxed() {
let v: UnsafeAtomic<UnsafeRawPointer> = .create(_raw1)
@@ -359,6 +359,191 @@ class BasicAtomicRawRepresentableTests: XCTestCase {
XCTAssertEqual(v.load(ordering: .relaxed), Fred.one)
}
func test_weakCompareExchange_relaxed() {
let v: UnsafeAtomic<Fred> = .create(Fred.one)
defer { v.destroy() }
var (exchanged, original): (Bool, Fred) = v.weakCompareExchange(
expected: Fred.one,
desired: Fred.two,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, Fred.one)
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
(exchanged, original) = v.weakCompareExchange(
expected: Fred.one,
desired: Fred.two,
ordering: .relaxed)
XCTAssertFalse(exchanged)
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)
XCTAssertEqual(original, Fred.two)
XCTAssertEqual(v.load(ordering: .relaxed), Fred.one)
(exchanged, original) = v.weakCompareExchange(
expected: Fred.two,
desired: Fred.one,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, Fred.one)
XCTAssertEqual(v.load(ordering: .relaxed), Fred.one)
}
func test_weakCompareExchange_acquiring() {
let v: UnsafeAtomic<Fred> = .create(Fred.one)
defer { v.destroy() }
var (exchanged, original): (Bool, Fred) = v.weakCompareExchange(
expected: Fred.one,
desired: Fred.two,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, Fred.one)
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
(exchanged, original) = v.weakCompareExchange(
expected: Fred.one,
desired: Fred.two,
ordering: .acquiring)
XCTAssertFalse(exchanged)
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)
XCTAssertEqual(original, Fred.two)
XCTAssertEqual(v.load(ordering: .relaxed), Fred.one)
(exchanged, original) = v.weakCompareExchange(
expected: Fred.two,
desired: Fred.one,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, Fred.one)
XCTAssertEqual(v.load(ordering: .relaxed), Fred.one)
}
func test_weakCompareExchange_releasing() {
let v: UnsafeAtomic<Fred> = .create(Fred.one)
defer { v.destroy() }
var (exchanged, original): (Bool, Fred) = v.weakCompareExchange(
expected: Fred.one,
desired: Fred.two,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, Fred.one)
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
(exchanged, original) = v.weakCompareExchange(
expected: Fred.one,
desired: Fred.two,
ordering: .releasing)
XCTAssertFalse(exchanged)
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)
XCTAssertEqual(original, Fred.two)
XCTAssertEqual(v.load(ordering: .relaxed), Fred.one)
(exchanged, original) = v.weakCompareExchange(
expected: Fred.two,
desired: Fred.one,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, Fred.one)
XCTAssertEqual(v.load(ordering: .relaxed), Fred.one)
}
func test_weakCompareExchange_acquiringAndReleasing() {
let v: UnsafeAtomic<Fred> = .create(Fred.one)
defer { v.destroy() }
var (exchanged, original): (Bool, Fred) = v.weakCompareExchange(
expected: Fred.one,
desired: Fred.two,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, Fred.one)
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
(exchanged, original) = v.weakCompareExchange(
expected: Fred.one,
desired: Fred.two,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
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)
XCTAssertEqual(original, Fred.two)
XCTAssertEqual(v.load(ordering: .relaxed), Fred.one)
(exchanged, original) = v.weakCompareExchange(
expected: Fred.two,
desired: Fred.one,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, Fred.one)
XCTAssertEqual(v.load(ordering: .relaxed), Fred.one)
}
func test_weakCompareExchange_sequentiallyConsistent() {
let v: UnsafeAtomic<Fred> = .create(Fred.one)
defer { v.destroy() }
var (exchanged, original): (Bool, Fred) = v.weakCompareExchange(
expected: Fred.one,
desired: Fred.two,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, Fred.one)
XCTAssertEqual(v.load(ordering: .relaxed), Fred.two)
(exchanged, original) = v.weakCompareExchange(
expected: Fred.one,
desired: Fred.two,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
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)
XCTAssertEqual(original, Fred.two)
XCTAssertEqual(v.load(ordering: .relaxed), Fred.one)
(exchanged, original) = v.weakCompareExchange(
expected: Fred.two,
desired: Fred.one,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, Fred.one)
XCTAssertEqual(v.load(ordering: .relaxed), Fred.one)
}
func test_compareExchange_relaxed_relaxed() {
let v: UnsafeAtomic<Fred> = .create(Fred.one)
@@ -361,6 +361,191 @@ class BasicAtomicReferenceTests: XCTestCase {
XCTAssertEqual(v.load(ordering: .relaxed), _baz1)
}
func test_weakCompareExchange_relaxed() {
let v: UnsafeAtomic<Baz> = .create(_baz1)
defer { v.destroy() }
var (exchanged, original): (Bool, Baz) = v.weakCompareExchange(
expected: _baz1,
desired: _baz2,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _baz1)
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
(exchanged, original) = v.weakCompareExchange(
expected: _baz1,
desired: _baz2,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _baz2)
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
(exchanged, original) = v.weakCompareExchange(
expected: _baz2,
desired: _baz1,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _baz2)
XCTAssertEqual(v.load(ordering: .relaxed), _baz1)
(exchanged, original) = v.weakCompareExchange(
expected: _baz2,
desired: _baz1,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _baz1)
XCTAssertEqual(v.load(ordering: .relaxed), _baz1)
}
func test_weakCompareExchange_acquiring() {
let v: UnsafeAtomic<Baz> = .create(_baz1)
defer { v.destroy() }
var (exchanged, original): (Bool, Baz) = v.weakCompareExchange(
expected: _baz1,
desired: _baz2,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _baz1)
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
(exchanged, original) = v.weakCompareExchange(
expected: _baz1,
desired: _baz2,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _baz2)
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
(exchanged, original) = v.weakCompareExchange(
expected: _baz2,
desired: _baz1,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _baz2)
XCTAssertEqual(v.load(ordering: .relaxed), _baz1)
(exchanged, original) = v.weakCompareExchange(
expected: _baz2,
desired: _baz1,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _baz1)
XCTAssertEqual(v.load(ordering: .relaxed), _baz1)
}
func test_weakCompareExchange_releasing() {
let v: UnsafeAtomic<Baz> = .create(_baz1)
defer { v.destroy() }
var (exchanged, original): (Bool, Baz) = v.weakCompareExchange(
expected: _baz1,
desired: _baz2,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _baz1)
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
(exchanged, original) = v.weakCompareExchange(
expected: _baz1,
desired: _baz2,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _baz2)
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
(exchanged, original) = v.weakCompareExchange(
expected: _baz2,
desired: _baz1,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _baz2)
XCTAssertEqual(v.load(ordering: .relaxed), _baz1)
(exchanged, original) = v.weakCompareExchange(
expected: _baz2,
desired: _baz1,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _baz1)
XCTAssertEqual(v.load(ordering: .relaxed), _baz1)
}
func test_weakCompareExchange_acquiringAndReleasing() {
let v: UnsafeAtomic<Baz> = .create(_baz1)
defer { v.destroy() }
var (exchanged, original): (Bool, Baz) = v.weakCompareExchange(
expected: _baz1,
desired: _baz2,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _baz1)
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
(exchanged, original) = v.weakCompareExchange(
expected: _baz1,
desired: _baz2,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _baz2)
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
(exchanged, original) = v.weakCompareExchange(
expected: _baz2,
desired: _baz1,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _baz2)
XCTAssertEqual(v.load(ordering: .relaxed), _baz1)
(exchanged, original) = v.weakCompareExchange(
expected: _baz2,
desired: _baz1,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _baz1)
XCTAssertEqual(v.load(ordering: .relaxed), _baz1)
}
func test_weakCompareExchange_sequentiallyConsistent() {
let v: UnsafeAtomic<Baz> = .create(_baz1)
defer { v.destroy() }
var (exchanged, original): (Bool, Baz) = v.weakCompareExchange(
expected: _baz1,
desired: _baz2,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _baz1)
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
(exchanged, original) = v.weakCompareExchange(
expected: _baz1,
desired: _baz2,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _baz2)
XCTAssertEqual(v.load(ordering: .relaxed), _baz2)
(exchanged, original) = v.weakCompareExchange(
expected: _baz2,
desired: _baz1,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _baz2)
XCTAssertEqual(v.load(ordering: .relaxed), _baz1)
(exchanged, original) = v.weakCompareExchange(
expected: _baz2,
desired: _baz1,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _baz1)
XCTAssertEqual(v.load(ordering: .relaxed), _baz1)
}
func test_compareExchange_relaxed_relaxed() {
let v: UnsafeAtomic<Baz> = .create(_baz1)
@@ -359,6 +359,191 @@ class BasicAtomicUInt16Tests: XCTestCase {
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_relaxed() {
let v: UnsafeAtomic<UInt16> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, UInt16) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_acquiring() {
let v: UnsafeAtomic<UInt16> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, UInt16) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_releasing() {
let v: UnsafeAtomic<UInt16> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, UInt16) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_acquiringAndReleasing() {
let v: UnsafeAtomic<UInt16> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, UInt16) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_sequentiallyConsistent() {
let v: UnsafeAtomic<UInt16> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, UInt16) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_compareExchange_relaxed_relaxed() {
let v: UnsafeAtomic<UInt16> = .create(12)
@@ -359,6 +359,191 @@ class BasicAtomicUInt32Tests: XCTestCase {
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_relaxed() {
let v: UnsafeAtomic<UInt32> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, UInt32) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_acquiring() {
let v: UnsafeAtomic<UInt32> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, UInt32) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_releasing() {
let v: UnsafeAtomic<UInt32> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, UInt32) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_acquiringAndReleasing() {
let v: UnsafeAtomic<UInt32> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, UInt32) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_sequentiallyConsistent() {
let v: UnsafeAtomic<UInt32> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, UInt32) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_compareExchange_relaxed_relaxed() {
let v: UnsafeAtomic<UInt32> = .create(12)
@@ -359,6 +359,191 @@ class BasicAtomicUInt64Tests: XCTestCase {
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_relaxed() {
let v: UnsafeAtomic<UInt64> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, UInt64) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_acquiring() {
let v: UnsafeAtomic<UInt64> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, UInt64) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_releasing() {
let v: UnsafeAtomic<UInt64> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, UInt64) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_acquiringAndReleasing() {
let v: UnsafeAtomic<UInt64> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, UInt64) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_sequentiallyConsistent() {
let v: UnsafeAtomic<UInt64> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, UInt64) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_compareExchange_relaxed_relaxed() {
let v: UnsafeAtomic<UInt64> = .create(12)
@@ -359,6 +359,191 @@ class BasicAtomicUInt8Tests: XCTestCase {
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_relaxed() {
let v: UnsafeAtomic<UInt8> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, UInt8) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_acquiring() {
let v: UnsafeAtomic<UInt8> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, UInt8) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_releasing() {
let v: UnsafeAtomic<UInt8> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, UInt8) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_acquiringAndReleasing() {
let v: UnsafeAtomic<UInt8> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, UInt8) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_sequentiallyConsistent() {
let v: UnsafeAtomic<UInt8> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, UInt8) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_compareExchange_relaxed_relaxed() {
let v: UnsafeAtomic<UInt8> = .create(12)
@@ -359,6 +359,191 @@ class BasicAtomicUIntTests: XCTestCase {
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_relaxed() {
let v: UnsafeAtomic<UInt> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, UInt) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_acquiring() {
let v: UnsafeAtomic<UInt> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, UInt) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_releasing() {
let v: UnsafeAtomic<UInt> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, UInt) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_acquiringAndReleasing() {
let v: UnsafeAtomic<UInt> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, UInt) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_weakCompareExchange_sequentiallyConsistent() {
let v: UnsafeAtomic<UInt> = .create(12)
defer { v.destroy() }
var (exchanged, original): (Bool, UInt) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 12,
desired: 23,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 23)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, 23)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
(exchanged, original) = v.weakCompareExchange(
expected: 23,
desired: 12,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, 12)
XCTAssertEqual(v.load(ordering: .relaxed), 12)
}
func test_compareExchange_relaxed_relaxed() {
let v: UnsafeAtomic<UInt> = .create(12)
@@ -366,6 +366,191 @@ class BasicAtomicUnmanagedTests: XCTestCase {
XCTAssertEqual(v.load(ordering: .relaxed), _bar1)
}
func test_weakCompareExchange_relaxed() {
let v: UnsafeAtomic<Unmanaged<Bar>> = .create(_bar1)
defer { v.destroy() }
var (exchanged, original): (Bool, Unmanaged<Bar>) = v.weakCompareExchange(
expected: _bar1,
desired: _bar2,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _bar1)
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
(exchanged, original) = v.weakCompareExchange(
expected: _bar1,
desired: _bar2,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _bar2)
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
(exchanged, original) = v.weakCompareExchange(
expected: _bar2,
desired: _bar1,
ordering: .relaxed)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _bar2)
XCTAssertEqual(v.load(ordering: .relaxed), _bar1)
(exchanged, original) = v.weakCompareExchange(
expected: _bar2,
desired: _bar1,
ordering: .relaxed)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _bar1)
XCTAssertEqual(v.load(ordering: .relaxed), _bar1)
}
func test_weakCompareExchange_acquiring() {
let v: UnsafeAtomic<Unmanaged<Bar>> = .create(_bar1)
defer { v.destroy() }
var (exchanged, original): (Bool, Unmanaged<Bar>) = v.weakCompareExchange(
expected: _bar1,
desired: _bar2,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _bar1)
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
(exchanged, original) = v.weakCompareExchange(
expected: _bar1,
desired: _bar2,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _bar2)
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
(exchanged, original) = v.weakCompareExchange(
expected: _bar2,
desired: _bar1,
ordering: .acquiring)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _bar2)
XCTAssertEqual(v.load(ordering: .relaxed), _bar1)
(exchanged, original) = v.weakCompareExchange(
expected: _bar2,
desired: _bar1,
ordering: .acquiring)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _bar1)
XCTAssertEqual(v.load(ordering: .relaxed), _bar1)
}
func test_weakCompareExchange_releasing() {
let v: UnsafeAtomic<Unmanaged<Bar>> = .create(_bar1)
defer { v.destroy() }
var (exchanged, original): (Bool, Unmanaged<Bar>) = v.weakCompareExchange(
expected: _bar1,
desired: _bar2,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _bar1)
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
(exchanged, original) = v.weakCompareExchange(
expected: _bar1,
desired: _bar2,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _bar2)
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
(exchanged, original) = v.weakCompareExchange(
expected: _bar2,
desired: _bar1,
ordering: .releasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _bar2)
XCTAssertEqual(v.load(ordering: .relaxed), _bar1)
(exchanged, original) = v.weakCompareExchange(
expected: _bar2,
desired: _bar1,
ordering: .releasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _bar1)
XCTAssertEqual(v.load(ordering: .relaxed), _bar1)
}
func test_weakCompareExchange_acquiringAndReleasing() {
let v: UnsafeAtomic<Unmanaged<Bar>> = .create(_bar1)
defer { v.destroy() }
var (exchanged, original): (Bool, Unmanaged<Bar>) = v.weakCompareExchange(
expected: _bar1,
desired: _bar2,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _bar1)
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
(exchanged, original) = v.weakCompareExchange(
expected: _bar1,
desired: _bar2,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _bar2)
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
(exchanged, original) = v.weakCompareExchange(
expected: _bar2,
desired: _bar1,
ordering: .acquiringAndReleasing)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _bar2)
XCTAssertEqual(v.load(ordering: .relaxed), _bar1)
(exchanged, original) = v.weakCompareExchange(
expected: _bar2,
desired: _bar1,
ordering: .acquiringAndReleasing)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _bar1)
XCTAssertEqual(v.load(ordering: .relaxed), _bar1)
}
func test_weakCompareExchange_sequentiallyConsistent() {
let v: UnsafeAtomic<Unmanaged<Bar>> = .create(_bar1)
defer { v.destroy() }
var (exchanged, original): (Bool, Unmanaged<Bar>) = v.weakCompareExchange(
expected: _bar1,
desired: _bar2,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _bar1)
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
(exchanged, original) = v.weakCompareExchange(
expected: _bar1,
desired: _bar2,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _bar2)
XCTAssertEqual(v.load(ordering: .relaxed), _bar2)
(exchanged, original) = v.weakCompareExchange(
expected: _bar2,
desired: _bar1,
ordering: .sequentiallyConsistent)
XCTAssertTrue(exchanged)
XCTAssertEqual(original, _bar2)
XCTAssertEqual(v.load(ordering: .relaxed), _bar1)
(exchanged, original) = v.weakCompareExchange(
expected: _bar2,
desired: _bar1,
ordering: .sequentiallyConsistent)
XCTAssertFalse(exchanged)
XCTAssertEqual(original, _bar1)
XCTAssertEqual(v.load(ordering: .relaxed), _bar1)
}
func test_compareExchange_relaxed_relaxed() {
let v: UnsafeAtomic<Unmanaged<Bar>> = .create(_bar1)