library/core/tests/atomic.rs

   1 use core::sync::atomic::Ordering::SeqCst;
   2 use core::sync::atomic::*;
   3
   4 #[test]
   5 fn bool_() {
   6     let a = AtomicBool::new(false);
   7     assert_eq!(a.compare_exchange(false, true, SeqCst, SeqCst), Ok(false));
   8     assert_eq!(a.compare_exchange(false, true, SeqCst, SeqCst), Err(true));
   9
  10     a.store(false, SeqCst);
  11     assert_eq!(a.compare_exchange(false, true, SeqCst, SeqCst), Ok(false));
  12 }
  13
  14 #[test]
  15 fn bool_and() {
  16     let a = AtomicBool::new(true);
  17     assert_eq!(a.fetch_and(false, SeqCst), true);
  18     assert_eq!(a.load(SeqCst), false);
  19 }
  20
  21 #[test]
  22 fn bool_nand() {
  23     let a = AtomicBool::new(false);
  24     assert_eq!(a.fetch_nand(false, SeqCst), false);
  25     assert_eq!(a.load(SeqCst), true);
  26     assert_eq!(a.fetch_nand(false, SeqCst), true);
  27     assert_eq!(a.load(SeqCst), true);
  28     assert_eq!(a.fetch_nand(true, SeqCst), true);
  29     assert_eq!(a.load(SeqCst), false);
  30     assert_eq!(a.fetch_nand(true, SeqCst), false);
  31     assert_eq!(a.load(SeqCst), true);
  32 }
  33
  34 #[test]
  35 fn uint_and() {
  36     let x = AtomicUsize::new(0xf731);
  37     assert_eq!(x.fetch_and(0x137f, SeqCst), 0xf731);
  38     assert_eq!(x.load(SeqCst), 0xf731 & 0x137f);
  39 }
  40
  41 #[test]
  42 fn uint_nand() {
  43     let x = AtomicUsize::new(0xf731);
  44     assert_eq!(x.fetch_nand(0x137f, SeqCst), 0xf731);
  45     assert_eq!(x.load(SeqCst), !(0xf731 & 0x137f));
  46 }
  47
  48 #[test]
  49 fn uint_or() {
  50     let x = AtomicUsize::new(0xf731);
  51     assert_eq!(x.fetch_or(0x137f, SeqCst), 0xf731);
  52     assert_eq!(x.load(SeqCst), 0xf731 | 0x137f);
  53 }
  54
  55 #[test]
  56 fn uint_xor() {
  57     let x = AtomicUsize::new(0xf731);
  58     assert_eq!(x.fetch_xor(0x137f, SeqCst), 0xf731);
  59     assert_eq!(x.load(SeqCst), 0xf731 ^ 0x137f);
  60 }
  61
  62 #[test]
  63 #[cfg(any(not(target_arch = "arm"), target_os = "linux"))] // Missing intrinsic in compiler-builtins
  64 #[cfg_attr(miri, ignore)] // FIXME: Miri does not support atomic_min
  65 fn uint_min() {
  66     let x = AtomicUsize::new(0xf731);
  67     assert_eq!(x.fetch_min(0x137f, SeqCst), 0xf731);
  68     assert_eq!(x.load(SeqCst), 0x137f);
  69     assert_eq!(x.fetch_min(0xf731, SeqCst), 0x137f);
  70     assert_eq!(x.load(SeqCst), 0x137f);
  71 }
  72
  73 #[test]
  74 #[cfg(any(not(target_arch = "arm"), target_os = "linux"))] // Missing intrinsic in compiler-builtins
  75 #[cfg_attr(miri, ignore)] // FIXME: Miri does not support atomic_max
  76 fn uint_max() {
  77     let x = AtomicUsize::new(0x137f);
  78     assert_eq!(x.fetch_max(0xf731, SeqCst), 0x137f);
  79     assert_eq!(x.load(SeqCst), 0xf731);
  80     assert_eq!(x.fetch_max(0x137f, SeqCst), 0xf731);
  81     assert_eq!(x.load(SeqCst), 0xf731);
  82 }
  83
  84 #[test]
  85 fn int_and() {
  86     let x = AtomicIsize::new(0xf731);
  87     assert_eq!(x.fetch_and(0x137f, SeqCst), 0xf731);
  88     assert_eq!(x.load(SeqCst), 0xf731 & 0x137f);
  89 }
  90
  91 #[test]
  92 fn int_nand() {
  93     let x = AtomicIsize::new(0xf731);
  94     assert_eq!(x.fetch_nand(0x137f, SeqCst), 0xf731);
  95     assert_eq!(x.load(SeqCst), !(0xf731 & 0x137f));
  96 }
  97
  98 #[test]
  99 fn int_or() {
 100     let x = AtomicIsize::new(0xf731);
 101     assert_eq!(x.fetch_or(0x137f, SeqCst), 0xf731);
 102     assert_eq!(x.load(SeqCst), 0xf731 | 0x137f);
 103 }
 104
 105 #[test]
 106 fn int_xor() {
 107     let x = AtomicIsize::new(0xf731);
 108     assert_eq!(x.fetch_xor(0x137f, SeqCst), 0xf731);
 109     assert_eq!(x.load(SeqCst), 0xf731 ^ 0x137f);
 110 }
 111
 112 #[test]
 113 #[cfg(any(not(target_arch = "arm"), target_os = "linux"))] // Missing intrinsic in compiler-builtins
 114 #[cfg_attr(miri, ignore)] // FIXME: Miri does not support atomic_min
 115 fn int_min() {
 116     let x = AtomicIsize::new(0xf731);
 117     assert_eq!(x.fetch_min(0x137f, SeqCst), 0xf731);
 118     assert_eq!(x.load(SeqCst), 0x137f);
 119     assert_eq!(x.fetch_min(0xf731, SeqCst), 0x137f);
 120     assert_eq!(x.load(SeqCst), 0x137f);
 121 }
 122
 123 #[test]
 124 #[cfg(any(not(target_arch = "arm"), target_os = "linux"))] // Missing intrinsic in compiler-builtins
 125 #[cfg_attr(miri, ignore)] // FIXME: Miri does not support atomic_max
 126 fn int_max() {
 127     let x = AtomicIsize::new(0x137f);
 128     assert_eq!(x.fetch_max(0xf731, SeqCst), 0x137f);
 129     assert_eq!(x.load(SeqCst), 0xf731);
 130     assert_eq!(x.fetch_max(0x137f, SeqCst), 0xf731);
 131     assert_eq!(x.load(SeqCst), 0xf731);
 132 }
 133
 134 static S_FALSE: AtomicBool = AtomicBool::new(false);
 135 static S_TRUE: AtomicBool = AtomicBool::new(true);
 136 static S_INT: AtomicIsize = AtomicIsize::new(0);
 137 static S_UINT: AtomicUsize = AtomicUsize::new(0);
 138
 139 #[test]
 140 fn static_init() {
 141     // Note that we're not really testing the mutability here but it's important
 142     // on Android at the moment (#49775)
 143     assert!(!S_FALSE.swap(true, SeqCst));
 144     assert!(S_TRUE.swap(false, SeqCst));
 145     assert!(S_INT.fetch_add(1, SeqCst) == 0);
 146     assert!(S_UINT.fetch_add(1, SeqCst) == 0);
 147 }
 148
 149 #[test]
 150 fn atomic_access_bool() {
 151     static mut ATOMIC: AtomicBool = AtomicBool::new(false);
 152
 153     unsafe {
 154         assert_eq!(*ATOMIC.get_mut(), false);
 155         ATOMIC.store(true, SeqCst);
 156         assert_eq!(*ATOMIC.get_mut(), true);
 157         ATOMIC.fetch_or(false, SeqCst);
 158         assert_eq!(*ATOMIC.get_mut(), true);
 159         ATOMIC.fetch_and(false, SeqCst);
 160         assert_eq!(*ATOMIC.get_mut(), false);
 161         ATOMIC.fetch_nand(true, SeqCst);
 162         assert_eq!(*ATOMIC.get_mut(), true);
 163         ATOMIC.fetch_xor(true, SeqCst);
 164         assert_eq!(*ATOMIC.get_mut(), false);
 165     }
 166 }
 167
 168 #[test]
 169 fn atomic_alignment() {
 170     use std::mem::{align_of, size_of};
 171
 172     #[cfg(target_has_atomic = "8")]
 173     assert_eq!(align_of::<AtomicBool>(), size_of::<AtomicBool>());
 174     #[cfg(target_has_atomic = "ptr")]
 175     assert_eq!(align_of::<AtomicPtr<u8>>(), size_of::<AtomicPtr<u8>>());
 176     #[cfg(target_has_atomic = "8")]
 177     assert_eq!(align_of::<AtomicU8>(), size_of::<AtomicU8>());
 178     #[cfg(target_has_atomic = "8")]
 179     assert_eq!(align_of::<AtomicI8>(), size_of::<AtomicI8>());
 180     #[cfg(target_has_atomic = "16")]
 181     assert_eq!(align_of::<AtomicU16>(), size_of::<AtomicU16>());
 182     #[cfg(target_has_atomic = "16")]
 183     assert_eq!(align_of::<AtomicI16>(), size_of::<AtomicI16>());
 184     #[cfg(target_has_atomic = "32")]
 185     assert_eq!(align_of::<AtomicU32>(), size_of::<AtomicU32>());
 186     #[cfg(target_has_atomic = "32")]
 187     assert_eq!(align_of::<AtomicI32>(), size_of::<AtomicI32>());
 188     #[cfg(target_has_atomic = "64")]
 189     assert_eq!(align_of::<AtomicU64>(), size_of::<AtomicU64>());
 190     #[cfg(target_has_atomic = "64")]
 191     assert_eq!(align_of::<AtomicI64>(), size_of::<AtomicI64>());
 192     #[cfg(target_has_atomic = "128")]
 193     assert_eq!(align_of::<AtomicU128>(), size_of::<AtomicU128>());
 194     #[cfg(target_has_atomic = "128")]
 195     assert_eq!(align_of::<AtomicI128>(), size_of::<AtomicI128>());
 196     #[cfg(target_has_atomic = "ptr")]
 197     assert_eq!(align_of::<AtomicUsize>(), size_of::<AtomicUsize>());
 198     #[cfg(target_has_atomic = "ptr")]
 199     assert_eq!(align_of::<AtomicIsize>(), size_of::<AtomicIsize>());
 200 }
 201
 202 #[test]
 203 fn atomic_compare_exchange() {
 204     use Ordering::*;
 205
 206     static ATOMIC: AtomicIsize = AtomicIsize::new(0);
 207
 208     ATOMIC.compare_exchange(0, 1, Relaxed, Relaxed).ok();
 209     ATOMIC.compare_exchange(0, 1, Acquire, Relaxed).ok();
 210     ATOMIC.compare_exchange(0, 1, Release, Relaxed).ok();
 211     ATOMIC.compare_exchange(0, 1, AcqRel, Relaxed).ok();
 212     ATOMIC.compare_exchange(0, 1, SeqCst, Relaxed).ok();
 213     ATOMIC.compare_exchange(0, 1, Acquire, Acquire).ok();
 214     ATOMIC.compare_exchange(0, 1, AcqRel, Acquire).ok();
 215     ATOMIC.compare_exchange(0, 1, SeqCst, Acquire).ok();
 216     ATOMIC.compare_exchange(0, 1, SeqCst, SeqCst).ok();
 217     ATOMIC.compare_exchange_weak(0, 1, Relaxed, Relaxed).ok();
 218     ATOMIC.compare_exchange_weak(0, 1, Acquire, Relaxed).ok();
 219     ATOMIC.compare_exchange_weak(0, 1, Release, Relaxed).ok();
 220     ATOMIC.compare_exchange_weak(0, 1, AcqRel, Relaxed).ok();
 221     ATOMIC.compare_exchange_weak(0, 1, SeqCst, Relaxed).ok();
 222     ATOMIC.compare_exchange_weak(0, 1, Acquire, Acquire).ok();
 223     ATOMIC.compare_exchange_weak(0, 1, AcqRel, Acquire).ok();
 224     ATOMIC.compare_exchange_weak(0, 1, SeqCst, Acquire).ok();
 225     ATOMIC.compare_exchange_weak(0, 1, SeqCst, SeqCst).ok();
 226 }