Home | History | Annotate | Download | only in atomics.types.operations.req
      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 //  ... assertion fails line 38
     12 
     13 // <atomic>
     14 
     15 // template <class T>
     16 //     bool
     17 //     atomic_compare_exchange_strong_explicit(volatile atomic<T>* obj, T* expc,
     18 //                                           T desr,
     19 //                                           memory_order s, memory_order f);
     20 //
     21 // template <class T>
     22 //     bool
     23 //     atomic_compare_exchange_strong_explicit(atomic<T>* obj, T* expc, T desr,
     24 //                                           memory_order s, memory_order f);
     25 
     26 #include <atomic>
     27 #include <type_traits>
     28 #include <cassert>
     29 
     30 #include "atomic_helpers.h"
     31 
     32 template <class T>
     33 struct TestFn {
     34   void operator()() const {
     35     {
     36         typedef std::atomic<T> A;
     37         A a;
     38         T t(T(1));
     39         std::atomic_init(&a, t);
     40         assert(std::atomic_compare_exchange_strong_explicit(&a, &t, T(2),
     41                std::memory_order_seq_cst, std::memory_order_seq_cst) == true);
     42         assert(a == T(2));
     43         assert(t == T(1));
     44         assert(std::atomic_compare_exchange_strong_explicit(&a, &t, T(3),
     45                std::memory_order_seq_cst, std::memory_order_seq_cst) == false);
     46         assert(a == T(2));
     47         assert(t == T(2));
     48     }
     49     {
     50         typedef std::atomic<T> A;
     51         volatile A a;
     52         T t(T(1));
     53         std::atomic_init(&a, t);
     54         assert(std::atomic_compare_exchange_strong_explicit(&a, &t, T(2),
     55                std::memory_order_seq_cst, std::memory_order_seq_cst) == true);
     56         assert(a == T(2));
     57         assert(t == T(1));
     58         assert(std::atomic_compare_exchange_strong_explicit(&a, &t, T(3),
     59                std::memory_order_seq_cst, std::memory_order_seq_cst) == false);
     60         assert(a == T(2));
     61         assert(t == T(2));
     62     }
     63   }
     64 };
     65 
     66 int main()
     67 {
     68     TestEachAtomicType<TestFn>()();
     69 }
     70