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 fn uint_min() {
  64     let x = AtomicUsize::new(0xf731);
  65     assert_eq!(x.fetch_min(0x137f, SeqCst), 0xf731);
  66     assert_eq!(x.load(SeqCst), 0x137f);
  67     assert_eq!(x.fetch_min(0xf731, SeqCst), 0x137f);
  68     assert_eq!(x.load(SeqCst), 0x137f);
  69 }
  70
  71 #[test]
  72 fn uint_max() {
  73     let x = AtomicUsize::new(0x137f);
  74     assert_eq!(x.fetch_max(0xf731, SeqCst), 0x137f);
  75     assert_eq!(x.load(SeqCst), 0xf731);
  76     assert_eq!(x.fetch_max(0x137f, SeqCst), 0xf731);
  77     assert_eq!(x.load(SeqCst), 0xf731);
  78 }
  79
  80 #[test]
  81 fn int_and() {
  82     let x = AtomicIsize::new(0xf731);
  83     assert_eq!(x.fetch_and(0x137f, SeqCst), 0xf731);
  84     assert_eq!(x.load(SeqCst), 0xf731 & 0x137f);
  85 }
  86
  87 #[test]
  88 fn int_nand() {
  89     let x = AtomicIsize::new(0xf731);
  90     assert_eq!(x.fetch_nand(0x137f, SeqCst), 0xf731);
  91     assert_eq!(x.load(SeqCst), !(0xf731 & 0x137f));
  92 }
  93
  94 #[test]
  95 fn int_or() {
  96     let x = AtomicIsize::new(0xf731);
  97     assert_eq!(x.fetch_or(0x137f, SeqCst), 0xf731);
  98     assert_eq!(x.load(SeqCst), 0xf731 | 0x137f);
  99 }
 100
 101 #[test]
 102 fn int_xor() {
 103     let x = AtomicIsize::new(0xf731);
 104     assert_eq!(x.fetch_xor(0x137f, SeqCst), 0xf731);
 105     assert_eq!(x.load(SeqCst), 0xf731 ^ 0x137f);
 106 }
 107
 108 #[test]
 109 fn int_min() {
 110     let x = AtomicIsize::new(0xf731);
 111     assert_eq!(x.fetch_min(0x137f, SeqCst), 0xf731);
 112     assert_eq!(x.load(SeqCst), 0x137f);
 113     assert_eq!(x.fetch_min(0xf731, SeqCst), 0x137f);
 114     assert_eq!(x.load(SeqCst), 0x137f);
 115 }
 116
 117 #[test]
 118 fn int_max() {
 119     let x = AtomicIsize::new(0x137f);
 120     assert_eq!(x.fetch_max(0xf731, SeqCst), 0x137f);
 121     assert_eq!(x.load(SeqCst), 0xf731);
 122     assert_eq!(x.fetch_max(0x137f, SeqCst), 0xf731);
 123     assert_eq!(x.load(SeqCst), 0xf731);
 124 }
 125
 126 static S_FALSE: AtomicBool = AtomicBool::new(false);
 127 static S_TRUE: AtomicBool = AtomicBool::new(true);
 128 static S_INT: AtomicIsize = AtomicIsize::new(0);
 129 static S_UINT: AtomicUsize = AtomicUsize::new(0);
 130
 131 #[test]
 132 fn static_init() {
 133     // Note that we're not really testing the mutability here but it's important
 134     // on Android at the moment (#49775)
 135     assert!(!S_FALSE.swap(true, SeqCst));
 136     assert!(S_TRUE.swap(false, SeqCst));
 137     assert!(S_INT.fetch_add(1, SeqCst) == 0);
 138     assert!(S_UINT.fetch_add(1, SeqCst) == 0);
 139 }
 140
 141 #[test]
 142 fn atomic_access_bool() {
 143     static mut ATOMIC: AtomicBool = AtomicBool::new(false);
 144
 145     unsafe {
 146         assert_eq!(*ATOMIC.get_mut(), false);
 147         ATOMIC.store(true, SeqCst);
 148         assert_eq!(*ATOMIC.get_mut(), true);
 149         ATOMIC.fetch_or(false, SeqCst);
 150         assert_eq!(*ATOMIC.get_mut(), true);
 151         ATOMIC.fetch_and(false, SeqCst);
 152         assert_eq!(*ATOMIC.get_mut(), false);
 153         ATOMIC.fetch_nand(true, SeqCst);
 154         assert_eq!(*ATOMIC.get_mut(), true);
 155         ATOMIC.fetch_xor(true, SeqCst);
 156         assert_eq!(*ATOMIC.get_mut(), false);
 157     }
 158 }
 159
 160 #[test]
 161 fn atomic_alignment() {
 162     use std::mem::{align_of, size_of};
 163
 164     #[cfg(target_has_atomic = "8")]
 165     assert_eq!(align_of::<AtomicBool>(), size_of::<AtomicBool>());
 166     #[cfg(target_has_atomic = "ptr")]
 167     assert_eq!(align_of::<AtomicPtr<u8>>(), size_of::<AtomicPtr<u8>>());
 168     #[cfg(target_has_atomic = "8")]
 169     assert_eq!(align_of::<AtomicU8>(), size_of::<AtomicU8>());
 170     #[cfg(target_has_atomic = "8")]
 171     assert_eq!(align_of::<AtomicI8>(), size_of::<AtomicI8>());
 172     #[cfg(target_has_atomic = "16")]
 173     assert_eq!(align_of::<AtomicU16>(), size_of::<AtomicU16>());
 174     #[cfg(target_has_atomic = "16")]
 175     assert_eq!(align_of::<AtomicI16>(), size_of::<AtomicI16>());
 176     #[cfg(target_has_atomic = "32")]
 177     assert_eq!(align_of::<AtomicU32>(), size_of::<AtomicU32>());
 178     #[cfg(target_has_atomic = "32")]
 179     assert_eq!(align_of::<AtomicI32>(), size_of::<AtomicI32>());
 180     #[cfg(target_has_atomic = "64")]
 181     assert_eq!(align_of::<AtomicU64>(), size_of::<AtomicU64>());
 182     #[cfg(target_has_atomic = "64")]
 183     assert_eq!(align_of::<AtomicI64>(), size_of::<AtomicI64>());
 184     #[cfg(target_has_atomic = "128")]
 185     assert_eq!(align_of::<AtomicU128>(), size_of::<AtomicU128>());
 186     #[cfg(target_has_atomic = "128")]
 187     assert_eq!(align_of::<AtomicI128>(), size_of::<AtomicI128>());
 188     #[cfg(target_has_atomic = "ptr")]
 189     assert_eq!(align_of::<AtomicUsize>(), size_of::<AtomicUsize>());
 190     #[cfg(target_has_atomic = "ptr")]
 191     assert_eq!(align_of::<AtomicIsize>(), size_of::<AtomicIsize>());
 192 }
 193
 194 #[test]
 195 fn atomic_compare_exchange() {
 196     use Ordering::*;
 197
 198     static ATOMIC: AtomicIsize = AtomicIsize::new(0);
 199
 200     ATOMIC.compare_exchange(0, 1, Relaxed, Relaxed).ok();
 201     ATOMIC.compare_exchange(0, 1, Acquire, Relaxed).ok();
 202     ATOMIC.compare_exchange(0, 1, Release, Relaxed).ok();
 203     ATOMIC.compare_exchange(0, 1, AcqRel, Relaxed).ok();
 204     ATOMIC.compare_exchange(0, 1, SeqCst, Relaxed).ok();
 205     ATOMIC.compare_exchange(0, 1, Acquire, Acquire).ok();
 206     ATOMIC.compare_exchange(0, 1, AcqRel, Acquire).ok();
 207     ATOMIC.compare_exchange(0, 1, SeqCst, Acquire).ok();
 208     ATOMIC.compare_exchange(0, 1, SeqCst, SeqCst).ok();
 209     ATOMIC.compare_exchange_weak(0, 1, Relaxed, Relaxed).ok();
 210     ATOMIC.compare_exchange_weak(0, 1, Acquire, Relaxed).ok();
 211     ATOMIC.compare_exchange_weak(0, 1, Release, Relaxed).ok();
 212     ATOMIC.compare_exchange_weak(0, 1, AcqRel, Relaxed).ok();
 213     ATOMIC.compare_exchange_weak(0, 1, SeqCst, Relaxed).ok();
 214     ATOMIC.compare_exchange_weak(0, 1, Acquire, Acquire).ok();
 215     ATOMIC.compare_exchange_weak(0, 1, AcqRel, Acquire).ok();
 216     ATOMIC.compare_exchange_weak(0, 1, SeqCst, Acquire).ok();
 217     ATOMIC.compare_exchange_weak(0, 1, SeqCst, SeqCst).ok();
 218 }