1 //===----------------------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // UNSUPPORTED: libcpp-has-no-threads
10
11 // NOTE: atomic<> of a TriviallyCopyable class is wrongly rejected by older
12 // clang versions. It was fixed right before the llvm 3.5 release. See PR18097.
13 // XFAIL: apple-clang-6.0, clang-3.4, clang-3.3
14
15 // <atomic>
16
17 // template <class T>
18 // struct atomic
19 // {
20 // bool is_lock_free() const volatile noexcept;
21 // bool is_lock_free() const noexcept;
22 // void store(T desr, memory_order m = memory_order_seq_cst) volatile noexcept;
23 // void store(T desr, memory_order m = memory_order_seq_cst) noexcept;
24 // T load(memory_order m = memory_order_seq_cst) const volatile noexcept;
25 // T load(memory_order m = memory_order_seq_cst) const noexcept;
26 // operator T() const volatile noexcept;
27 // operator T() const noexcept;
28 // T exchange(T desr, memory_order m = memory_order_seq_cst) volatile noexcept;
29 // T exchange(T desr, memory_order m = memory_order_seq_cst) noexcept;
30 // bool compare_exchange_weak(T& expc, T desr,
31 // memory_order s, memory_order f) volatile noexcept;
32 // bool compare_exchange_weak(T& expc, T desr, memory_order s, memory_order f) noexcept;
33 // bool compare_exchange_strong(T& expc, T desr,
34 // memory_order s, memory_order f) volatile noexcept;
35 // bool compare_exchange_strong(T& expc, T desr,
36 // memory_order s, memory_order f) noexcept;
37 // bool compare_exchange_weak(T& expc, T desr,
38 // memory_order m = memory_order_seq_cst) volatile noexcept;
39 // bool compare_exchange_weak(T& expc, T desr,
40 // memory_order m = memory_order_seq_cst) noexcept;
41 // bool compare_exchange_strong(T& expc, T desr,
42 // memory_order m = memory_order_seq_cst) volatile noexcept;
43 // bool compare_exchange_strong(T& expc, T desr,
44 // memory_order m = memory_order_seq_cst) noexcept;
45 //
46 // atomic() noexcept = default;
47 // constexpr atomic(T desr) noexcept;
48 // atomic(const atomic&) = delete;
49 // atomic& operator=(const atomic&) = delete;
50 // atomic& operator=(const atomic&) volatile = delete;
51 // T operator=(T) volatile noexcept;
52 // T operator=(T) noexcept;
53 // };
54
55 #include <atomic>
56 #include <new>
57 #include <cassert>
58 #include <thread> // for thread_id
59 #include <chrono> // for nanoseconds
60
61 #include "test_macros.h"
62
63 struct TriviallyCopyable {
TriviallyCopyableTriviallyCopyable64 TriviallyCopyable ( int i ) : i_(i) {}
65 int i_;
66 };
67
68 template <class T>
test(T t)69 void test ( T t ) {
70 std::atomic<T> t0(t);
71 }
72
main(int,char **)73 int main(int, char**)
74 {
75 test(TriviallyCopyable(42));
76 test(std::this_thread::get_id());
77 test(std::chrono::nanoseconds(2));
78
79 return 0;
80 }
81