use core::sync::atomic::Ordering::SeqCst; use core::sync::atomic::*; #[test] fn bool_() { let a = AtomicBool::new(false); assert_eq!(a.compare_exchange(false, true, SeqCst, SeqCst), Ok(false)); assert_eq!(a.compare_exchange(false, true, SeqCst, SeqCst), Err(true)); a.store(false, SeqCst); assert_eq!(a.compare_exchange(false, true, SeqCst, SeqCst), Ok(false)); } #[test] fn bool_and() { let a = AtomicBool::new(true); assert_eq!(a.fetch_and(false, SeqCst), true); assert_eq!(a.load(SeqCst), false); } #[test] fn bool_nand() { let a = AtomicBool::new(false); assert_eq!(a.fetch_nand(false, SeqCst), false); assert_eq!(a.load(SeqCst), true); assert_eq!(a.fetch_nand(false, SeqCst), true); assert_eq!(a.load(SeqCst), true); assert_eq!(a.fetch_nand(true, SeqCst), true); assert_eq!(a.load(SeqCst), false); assert_eq!(a.fetch_nand(true, SeqCst), false); assert_eq!(a.load(SeqCst), true); } #[test] fn uint_and() { let x = AtomicUsize::new(0xf731); assert_eq!(x.fetch_and(0x137f, SeqCst), 0xf731); assert_eq!(x.load(SeqCst), 0xf731 & 0x137f); } #[test] fn uint_nand() { let x = AtomicUsize::new(0xf731); assert_eq!(x.fetch_nand(0x137f, SeqCst), 0xf731); assert_eq!(x.load(SeqCst), !(0xf731 & 0x137f)); } #[test] fn uint_or() { let x = AtomicUsize::new(0xf731); assert_eq!(x.fetch_or(0x137f, SeqCst), 0xf731); assert_eq!(x.load(SeqCst), 0xf731 | 0x137f); } #[test] fn uint_xor() { let x = AtomicUsize::new(0xf731); assert_eq!(x.fetch_xor(0x137f, SeqCst), 0xf731); assert_eq!(x.load(SeqCst), 0xf731 ^ 0x137f); } #[test] #[cfg(any(not(target_arch = "arm"), target_os = "linux"))] // Missing intrinsic in compiler-builtins fn uint_min() { let x = AtomicUsize::new(0xf731); assert_eq!(x.fetch_min(0x137f, SeqCst), 0xf731); assert_eq!(x.load(SeqCst), 0x137f); assert_eq!(x.fetch_min(0xf731, SeqCst), 0x137f); assert_eq!(x.load(SeqCst), 0x137f); } #[test] #[cfg(any(not(target_arch = "arm"), target_os = "linux"))] // Missing intrinsic in compiler-builtins fn uint_max() { let x = AtomicUsize::new(0x137f); assert_eq!(x.fetch_max(0xf731, SeqCst), 0x137f); assert_eq!(x.load(SeqCst), 0xf731); assert_eq!(x.fetch_max(0x137f, SeqCst), 0xf731); assert_eq!(x.load(SeqCst), 0xf731); } #[test] fn int_and() { let x = AtomicIsize::new(0xf731); assert_eq!(x.fetch_and(0x137f, SeqCst), 0xf731); assert_eq!(x.load(SeqCst), 0xf731 & 0x137f); } #[test] fn int_nand() { let x = AtomicIsize::new(0xf731); assert_eq!(x.fetch_nand(0x137f, SeqCst), 0xf731); assert_eq!(x.load(SeqCst), !(0xf731 & 0x137f)); } #[test] fn int_or() { let x = AtomicIsize::new(0xf731); assert_eq!(x.fetch_or(0x137f, SeqCst), 0xf731); assert_eq!(x.load(SeqCst), 0xf731 | 0x137f); } #[test] fn int_xor() { let x = AtomicIsize::new(0xf731); assert_eq!(x.fetch_xor(0x137f, SeqCst), 0xf731); assert_eq!(x.load(SeqCst), 0xf731 ^ 0x137f); } #[test] #[cfg(any(not(target_arch = "arm"), target_os = "linux"))] // Missing intrinsic in compiler-builtins fn int_min() { let x = AtomicIsize::new(0xf731); assert_eq!(x.fetch_min(0x137f, SeqCst), 0xf731); assert_eq!(x.load(SeqCst), 0x137f); assert_eq!(x.fetch_min(0xf731, SeqCst), 0x137f); assert_eq!(x.load(SeqCst), 0x137f); } #[test] #[cfg(any(not(target_arch = "arm"), target_os = "linux"))] // Missing intrinsic in compiler-builtins fn int_max() { let x = AtomicIsize::new(0x137f); assert_eq!(x.fetch_max(0xf731, SeqCst), 0x137f); assert_eq!(x.load(SeqCst), 0xf731); assert_eq!(x.fetch_max(0x137f, SeqCst), 0xf731); assert_eq!(x.load(SeqCst), 0xf731); } static S_FALSE: AtomicBool = AtomicBool::new(false); static S_TRUE: AtomicBool = AtomicBool::new(true); static S_INT: AtomicIsize = AtomicIsize::new(0); static S_UINT: AtomicUsize = AtomicUsize::new(0); #[test] fn static_init() { // Note that we're not really testing the mutability here but it's important // on Android at the moment (#49775) assert!(!S_FALSE.swap(true, SeqCst)); assert!(S_TRUE.swap(false, SeqCst)); assert!(S_INT.fetch_add(1, SeqCst) == 0); assert!(S_UINT.fetch_add(1, SeqCst) == 0); } #[test] fn atomic_access_bool() { static mut ATOMIC: AtomicBool = AtomicBool::new(false); unsafe { assert_eq!(*ATOMIC.get_mut(), false); ATOMIC.store(true, SeqCst); assert_eq!(*ATOMIC.get_mut(), true); ATOMIC.fetch_or(false, SeqCst); assert_eq!(*ATOMIC.get_mut(), true); ATOMIC.fetch_and(false, SeqCst); assert_eq!(*ATOMIC.get_mut(), false); ATOMIC.fetch_nand(true, SeqCst); assert_eq!(*ATOMIC.get_mut(), true); ATOMIC.fetch_xor(true, SeqCst); assert_eq!(*ATOMIC.get_mut(), false); } } #[test] fn atomic_alignment() { use std::mem::{align_of, size_of}; #[cfg(target_has_atomic = "8")] assert_eq!(align_of::(), size_of::()); #[cfg(target_has_atomic = "ptr")] assert_eq!(align_of::>(), size_of::>()); #[cfg(target_has_atomic = "8")] assert_eq!(align_of::(), size_of::()); #[cfg(target_has_atomic = "8")] assert_eq!(align_of::(), size_of::()); #[cfg(target_has_atomic = "16")] assert_eq!(align_of::(), size_of::()); #[cfg(target_has_atomic = "16")] assert_eq!(align_of::(), size_of::()); #[cfg(target_has_atomic = "32")] assert_eq!(align_of::(), size_of::()); #[cfg(target_has_atomic = "32")] assert_eq!(align_of::(), size_of::()); #[cfg(target_has_atomic = "64")] assert_eq!(align_of::(), size_of::()); #[cfg(target_has_atomic = "64")] assert_eq!(align_of::(), size_of::()); #[cfg(target_has_atomic = "128")] assert_eq!(align_of::(), size_of::()); #[cfg(target_has_atomic = "128")] assert_eq!(align_of::(), size_of::()); #[cfg(target_has_atomic = "ptr")] assert_eq!(align_of::(), size_of::()); #[cfg(target_has_atomic = "ptr")] assert_eq!(align_of::(), size_of::()); } #[test] fn atomic_compare_exchange() { use Ordering::*; static ATOMIC: AtomicIsize = AtomicIsize::new(0); ATOMIC.compare_exchange(0, 1, Relaxed, Relaxed).ok(); ATOMIC.compare_exchange(0, 1, Acquire, Relaxed).ok(); ATOMIC.compare_exchange(0, 1, Release, Relaxed).ok(); ATOMIC.compare_exchange(0, 1, AcqRel, Relaxed).ok(); ATOMIC.compare_exchange(0, 1, SeqCst, Relaxed).ok(); ATOMIC.compare_exchange(0, 1, Acquire, Acquire).ok(); ATOMIC.compare_exchange(0, 1, AcqRel, Acquire).ok(); ATOMIC.compare_exchange(0, 1, SeqCst, Acquire).ok(); ATOMIC.compare_exchange(0, 1, SeqCst, SeqCst).ok(); ATOMIC.compare_exchange_weak(0, 1, Relaxed, Relaxed).ok(); ATOMIC.compare_exchange_weak(0, 1, Acquire, Relaxed).ok(); ATOMIC.compare_exchange_weak(0, 1, Release, Relaxed).ok(); ATOMIC.compare_exchange_weak(0, 1, AcqRel, Relaxed).ok(); ATOMIC.compare_exchange_weak(0, 1, SeqCst, Relaxed).ok(); ATOMIC.compare_exchange_weak(0, 1, Acquire, Acquire).ok(); ATOMIC.compare_exchange_weak(0, 1, AcqRel, Acquire).ok(); ATOMIC.compare_exchange_weak(0, 1, SeqCst, Acquire).ok(); ATOMIC.compare_exchange_weak(0, 1, SeqCst, SeqCst).ok(); }