1 use core::sync::atomic::Ordering::SeqCst;
2 use core::sync::atomic::*;
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));
10 a.store(false, SeqCst);
11 assert_eq!(a.compare_exchange(false, true, SeqCst, SeqCst), Ok(false));
16 let a = AtomicBool::new(true);
17 assert_eq!(a.fetch_and(false, SeqCst), true);
18 assert_eq!(a.load(SeqCst), false);
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);
36 let x = AtomicUsize::new(0xf731);
37 assert_eq!(x.fetch_and(0x137f, SeqCst), 0xf731);
38 assert_eq!(x.load(SeqCst), 0xf731 & 0x137f);
43 let x = AtomicUsize::new(0xf731);
44 assert_eq!(x.fetch_nand(0x137f, SeqCst), 0xf731);
45 assert_eq!(x.load(SeqCst), !(0xf731 & 0x137f));
50 let x = AtomicUsize::new(0xf731);
51 assert_eq!(x.fetch_or(0x137f, SeqCst), 0xf731);
52 assert_eq!(x.load(SeqCst), 0xf731 | 0x137f);
57 let x = AtomicUsize::new(0xf731);
58 assert_eq!(x.fetch_xor(0x137f, SeqCst), 0xf731);
59 assert_eq!(x.load(SeqCst), 0xf731 ^ 0x137f);
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
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);
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
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);
86 let x = AtomicIsize::new(0xf731);
87 assert_eq!(x.fetch_and(0x137f, SeqCst), 0xf731);
88 assert_eq!(x.load(SeqCst), 0xf731 & 0x137f);
93 let x = AtomicIsize::new(0xf731);
94 assert_eq!(x.fetch_nand(0x137f, SeqCst), 0xf731);
95 assert_eq!(x.load(SeqCst), !(0xf731 & 0x137f));
100 let x = AtomicIsize::new(0xf731);
101 assert_eq!(x.fetch_or(0x137f, SeqCst), 0xf731);
102 assert_eq!(x.load(SeqCst), 0xf731 | 0x137f);
107 let x = AtomicIsize::new(0xf731);
108 assert_eq!(x.fetch_xor(0x137f, SeqCst), 0xf731);
109 assert_eq!(x.load(SeqCst), 0xf731 ^ 0x137f);
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
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);
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
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);
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);
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);
150 fn atomic_access_bool() {
151 static mut ATOMIC: AtomicBool = AtomicBool::new(false);
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);
169 fn atomic_alignment() {
170 use std::mem::{align_of, size_of};
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>());
203 fn atomic_compare_exchange() {
206 static ATOMIC: AtomicIsize = AtomicIsize::new(0);
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();