src/third_party/libc++/trunk/test/atomics/atomics.types.generic/trivially_copyable.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 // <atomic>
  11
  12 // template <class T>
  13 // struct atomic
  14 // {
  15 //     bool is_lock_free() const volatile noexcept;
  16 //     bool is_lock_free() const noexcept;
  17 //     void store(T desr, memory_order m = memory_order_seq_cst) volatile noexcept;
  18 //     void store(T desr, memory_order m = memory_order_seq_cst) noexcept;
  19 //     T load(memory_order m = memory_order_seq_cst) const volatile noexcept;
  20 //     T load(memory_order m = memory_order_seq_cst) const noexcept;
  21 //     operator T() const volatile noexcept;
  22 //     operator T() const noexcept;
  23 //     T exchange(T desr, memory_order m = memory_order_seq_cst) volatile noexcept;
  24 //     T exchange(T desr, memory_order m = memory_order_seq_cst) noexcept;
  25 //     bool compare_exchange_weak(T& expc, T desr,
  26 //                                memory_order s, memory_order f) volatile noexcept;
  27 //     bool compare_exchange_weak(T& expc, T desr, memory_order s, memory_order f) noexcept;
  28 //     bool compare_exchange_strong(T& expc, T desr,
  29 //                                  memory_order s, memory_order f) volatile noexcept;
  30 //     bool compare_exchange_strong(T& expc, T desr,
  31 //                                  memory_order s, memory_order f) noexcept;
  32 //     bool compare_exchange_weak(T& expc, T desr,
  33 //                                memory_order m = memory_order_seq_cst) volatile noexcept;
  34 //     bool compare_exchange_weak(T& expc, T desr,
  35 //                                memory_order m = memory_order_seq_cst) noexcept;
  36 //     bool compare_exchange_strong(T& expc, T desr,
  37 //                                 memory_order m = memory_order_seq_cst) volatile noexcept;
  38 //     bool compare_exchange_strong(T& expc, T desr,
  39 //                                  memory_order m = memory_order_seq_cst) noexcept;
  40 //
  41 //     atomic() noexcept = default;
  42 //     constexpr atomic(T desr) noexcept;
  43 //     atomic(const atomic&) = delete;
  44 //     atomic& operator=(const atomic&) = delete;
  45 //     atomic& operator=(const atomic&) volatile = delete;
  46 //     T operator=(T) volatile noexcept;
  47 //     T operator=(T) noexcept;
  48 // };
  49
  50 #include <atomic>
  51 #include <new>
  52 #include <cassert>
  53 #include <thread> // for thread_id
  54 #include <chrono> // for nanoseconds
  55
  56 struct TriviallyCopyable {
  57         TriviallyCopyable ( int i ) : i_(i) {}
  58         int i_;
  59         };
  60
  61 template <class T>
  62 void test ( T t ) {
  63         std::atomic<T> t0(t);
  64         }
  65
  66 int main()
  67 {
  68         test(TriviallyCopyable(42));
  69         test(std::this_thread::get_id());
  70         test(std::chrono::nanoseconds(2));
  71 }