bool.pass.cpp (8931B)
1 //===----------------------------------------------------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is dual licensed under the MIT and the University of Illinois Open 6 // Source Licenses. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // UNSUPPORTED: libcpp-has-no-threads 11 12 // <atomic> 13 14 // template <class T> 15 // struct atomic 16 // { 17 // bool is_lock_free() const volatile; 18 // bool is_lock_free() const; 19 // void store(T desr, memory_order m = memory_order_seq_cst) volatile; 20 // void store(T desr, memory_order m = memory_order_seq_cst); 21 // T load(memory_order m = memory_order_seq_cst) const volatile; 22 // T load(memory_order m = memory_order_seq_cst) const; 23 // operator T() const volatile; 24 // operator T() const; 25 // T exchange(T desr, memory_order m = memory_order_seq_cst) volatile; 26 // T exchange(T desr, memory_order m = memory_order_seq_cst); 27 // bool compare_exchange_weak(T& expc, T desr, 28 // memory_order s, memory_order f) volatile; 29 // bool compare_exchange_weak(T& expc, T desr, memory_order s, memory_order f); 30 // bool compare_exchange_strong(T& expc, T desr, 31 // memory_order s, memory_order f) volatile; 32 // bool compare_exchange_strong(T& expc, T desr, 33 // memory_order s, memory_order f); 34 // bool compare_exchange_weak(T& expc, T desr, 35 // memory_order m = memory_order_seq_cst) volatile; 36 // bool compare_exchange_weak(T& expc, T desr, 37 // memory_order m = memory_order_seq_cst); 38 // bool compare_exchange_strong(T& expc, T desr, 39 // memory_order m = memory_order_seq_cst) volatile; 40 // bool compare_exchange_strong(T& expc, T desr, 41 // memory_order m = memory_order_seq_cst); 42 // 43 // atomic() = default; 44 // constexpr atomic(T desr); 45 // atomic(const atomic&) = delete; 46 // atomic& operator=(const atomic&) = delete; 47 // atomic& operator=(const atomic&) volatile = delete; 48 // T operator=(T) volatile; 49 // T operator=(T); 50 // }; 51 // 52 // typedef atomic<bool> atomic_bool; 53 54 #include <atomic> 55 #include <new> 56 #include <cassert> 57 58 #include <cmpxchg_loop.h> 59 60 #include "test_macros.h" 61 62 int main() 63 { 64 { 65 volatile std::atomic<bool> obj(true); 66 assert(obj == true); 67 std::atomic_init(&obj, false); 68 assert(obj == false); 69 std::atomic_init(&obj, true); 70 assert(obj == true); 71 bool b0 = obj.is_lock_free(); 72 (void)b0; // to placate scan-build 73 obj.store(false); 74 assert(obj == false); 75 obj.store(true, std::memory_order_release); 76 assert(obj == true); 77 assert(obj.load() == true); 78 assert(obj.load(std::memory_order_acquire) == true); 79 assert(obj.exchange(false) == true); 80 assert(obj == false); 81 assert(obj.exchange(true, std::memory_order_relaxed) == false); 82 assert(obj == true); 83 bool x = obj; 84 assert(cmpxchg_weak_loop(obj, x, false) == true); 85 assert(obj == false); 86 assert(x == true); 87 assert(obj.compare_exchange_weak(x, true, 88 std::memory_order_seq_cst) == false); 89 assert(obj == false); 90 assert(x == false); 91 obj.store(true); 92 x = true; 93 assert(cmpxchg_weak_loop(obj, x, false, 94 std::memory_order_seq_cst, 95 std::memory_order_seq_cst) == true); 96 assert(obj == false); 97 assert(x == true); 98 x = true; 99 obj.store(true); 100 assert(obj.compare_exchange_strong(x, false) == true); 101 assert(obj == false); 102 assert(x == true); 103 assert(obj.compare_exchange_strong(x, true, 104 std::memory_order_seq_cst) == false); 105 assert(obj == false); 106 assert(x == false); 107 x = true; 108 obj.store(true); 109 assert(obj.compare_exchange_strong(x, false, 110 std::memory_order_seq_cst, 111 std::memory_order_seq_cst) == true); 112 assert(obj == false); 113 assert(x == true); 114 assert((obj = false) == false); 115 assert(obj == false); 116 assert((obj = true) == true); 117 assert(obj == true); 118 } 119 { 120 std::atomic<bool> obj(true); 121 assert(obj == true); 122 std::atomic_init(&obj, false); 123 assert(obj == false); 124 std::atomic_init(&obj, true); 125 assert(obj == true); 126 bool b0 = obj.is_lock_free(); 127 (void)b0; // to placate scan-build 128 obj.store(false); 129 assert(obj == false); 130 obj.store(true, std::memory_order_release); 131 assert(obj == true); 132 assert(obj.load() == true); 133 assert(obj.load(std::memory_order_acquire) == true); 134 assert(obj.exchange(false) == true); 135 assert(obj == false); 136 assert(obj.exchange(true, std::memory_order_relaxed) == false); 137 assert(obj == true); 138 bool x = obj; 139 assert(cmpxchg_weak_loop(obj, x, false) == true); 140 assert(obj == false); 141 assert(x == true); 142 assert(obj.compare_exchange_weak(x, true, 143 std::memory_order_seq_cst) == false); 144 assert(obj == false); 145 assert(x == false); 146 obj.store(true); 147 x = true; 148 assert(cmpxchg_weak_loop(obj, x, false, 149 std::memory_order_seq_cst, 150 std::memory_order_seq_cst) == true); 151 assert(obj == false); 152 assert(x == true); 153 x = true; 154 obj.store(true); 155 assert(obj.compare_exchange_strong(x, false) == true); 156 assert(obj == false); 157 assert(x == true); 158 assert(obj.compare_exchange_strong(x, true, 159 std::memory_order_seq_cst) == false); 160 assert(obj == false); 161 assert(x == false); 162 x = true; 163 obj.store(true); 164 assert(obj.compare_exchange_strong(x, false, 165 std::memory_order_seq_cst, 166 std::memory_order_seq_cst) == true); 167 assert(obj == false); 168 assert(x == true); 169 assert((obj = false) == false); 170 assert(obj == false); 171 assert((obj = true) == true); 172 assert(obj == true); 173 } 174 { 175 std::atomic_bool obj(true); 176 assert(obj == true); 177 std::atomic_init(&obj, false); 178 assert(obj == false); 179 std::atomic_init(&obj, true); 180 assert(obj == true); 181 bool b0 = obj.is_lock_free(); 182 (void)b0; // to placate scan-build 183 obj.store(false); 184 assert(obj == false); 185 obj.store(true, std::memory_order_release); 186 assert(obj == true); 187 assert(obj.load() == true); 188 assert(obj.load(std::memory_order_acquire) == true); 189 assert(obj.exchange(false) == true); 190 assert(obj == false); 191 assert(obj.exchange(true, std::memory_order_relaxed) == false); 192 assert(obj == true); 193 bool x = obj; 194 assert(cmpxchg_weak_loop(obj, x, false) == true); 195 assert(obj == false); 196 assert(x == true); 197 assert(obj.compare_exchange_weak(x, true, 198 std::memory_order_seq_cst) == false); 199 assert(obj == false); 200 assert(x == false); 201 obj.store(true); 202 x = true; 203 assert(cmpxchg_weak_loop(obj, x, false, 204 std::memory_order_seq_cst, 205 std::memory_order_seq_cst) == true); 206 assert(obj == false); 207 assert(x == true); 208 x = true; 209 obj.store(true); 210 assert(obj.compare_exchange_strong(x, false) == true); 211 assert(obj == false); 212 assert(x == true); 213 assert(obj.compare_exchange_strong(x, true, 214 std::memory_order_seq_cst) == false); 215 assert(obj == false); 216 assert(x == false); 217 x = true; 218 obj.store(true); 219 assert(obj.compare_exchange_strong(x, false, 220 std::memory_order_seq_cst, 221 std::memory_order_seq_cst) == true); 222 assert(obj == false); 223 assert(x == true); 224 assert((obj = false) == false); 225 assert(obj == false); 226 assert((obj = true) == true); 227 assert(obj == true); 228 } 229 { 230 typedef std::atomic<bool> A; 231 TEST_ALIGNAS_TYPE(A) char storage[sizeof(A)] = {1}; 232 A& zero = *new (storage) A(); 233 assert(zero == false); 234 zero.~A(); 235 } 236 }