test/std/atomics/atomics.types.generic/bool.pass.cpp

   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 }