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// <atomic>
10
11// Test nested types
12
13// template <class T>
14// class atomic
15// {
16// public:
17// typedef T value_type;
18// };
19
20// atomic still has a difference_type in the C++03 frozen headers
21// XFAIL: FROZEN-CXX03-HEADERS-FIXME
22
23#include <atomic>
24#include <chrono>
25#include <cstdint>
26#include <memory>
27#include <type_traits>
28
29#include "test_macros.h"
30
31#ifndef TEST_HAS_NO_THREADS
32# include <thread>
33#endif
34
35// detect existence of the difference_type member type
36template <class...>
37using myvoid_t = void;
38template <typename T, typename = void>
39struct has_difference_type : std::false_type {};
40template <typename T>
41struct has_difference_type<T, myvoid_t<typename T::difference_type> > : std::true_type {};
42
43template <class T,
44 bool Integral = (std::is_integral<T>::value && !std::is_same<T, bool>::value),
45 bool Floating = std::is_floating_point<T>::value,
46 bool Pointer = std::is_pointer<T>::value>
47struct test_atomic {
48 test_atomic() {
49 static_assert(!Integral && !Floating && !Pointer, "");
50 using A = std::atomic<T>;
51 A a;
52 (void)a;
53 static_assert(std::is_same<typename A::value_type, T>::value, "");
54 static_assert(!has_difference_type<A>::value, "");
55 }
56};
57
58template <class T>
59struct test_atomic<T, /*Integral=*/true, false, false> {
60 test_atomic() {
61 static_assert(!std::is_same<T, bool>::value, "");
62 using A = std::atomic<T>;
63 A a;
64 (void)a;
65 static_assert(std::is_same<typename A::value_type, T>::value, "");
66 static_assert(std::is_same<typename A::difference_type, T>::value, "");
67 }
68};
69
70template <class T>
71struct test_atomic<T, false, /*Foating=*/true, false> {
72 test_atomic() {
73 using A = std::atomic<T>;
74 A a;
75 (void)a;
76 static_assert(std::is_same<typename A::value_type, T>::value, "");
77#if TEST_STD_VER >= 20
78 static_assert(std::is_same<typename A::difference_type, T>::value, "");
79#else
80 static_assert(!has_difference_type<A>::value, "");
81#endif
82 }
83};
84
85template <class T>
86struct test_atomic<T, false, false, /*Pointer=*/true> {
87 test_atomic() {
88 using A = std::atomic<T>;
89 A a;
90 (void)a;
91 static_assert(std::is_same<typename A::value_type, T>::value, "");
92 static_assert(std::is_same<typename A::difference_type, std::ptrdiff_t>::value, "");
93 }
94};
95
96template <class T>
97void test() {
98 using A = std::atomic<T>;
99 static_assert(std::is_same<typename A::value_type, T>::value, "");
100 test_atomic<T>();
101}
102
103struct TriviallyCopyable {
104 int i_;
105};
106
107struct WeirdTriviallyCopyable {
108 char i, j, k; /* the 3 chars of doom */
109};
110
111struct PaddedTriviallyCopyable {
112 char i;
113 int j; /* probably lock-free? */
114};
115
116struct LargeTriviallyCopyable {
117 int i, j[127]; /* decidedly not lock-free */
118};
119
120int main(int, char**) {
121 test<bool>();
122 test<char>();
123 test<signed char>();
124 test<unsigned char>();
125 test<short>();
126 test<unsigned short>();
127 test<int>();
128 test<unsigned int>();
129 test<long>();
130 test<unsigned long>();
131 test<long long>();
132 test<unsigned long long>();
133#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
134 test<char8_t>();
135#endif
136 test<char16_t>();
137 test<char32_t>();
138#ifndef TEST_HAS_NO_WIDE_CHARACTERS
139 test<wchar_t>();
140#endif
141
142 test<std::int_least8_t>();
143 test<std::uint_least8_t>();
144 test<std::int_least16_t>();
145 test<std::uint_least16_t>();
146 test<std::int_least32_t>();
147 test<std::uint_least32_t>();
148 test<std::int_least64_t>();
149 test<std::uint_least64_t>();
150
151 test<std::int_fast8_t>();
152 test<std::uint_fast8_t>();
153 test<std::int_fast16_t>();
154 test<std::uint_fast16_t>();
155 test<std::int_fast32_t>();
156 test<std::uint_fast32_t>();
157 test<std::int_fast64_t>();
158 test<std::uint_fast64_t>();
159
160 test< std::int8_t>();
161 test<std::uint8_t>();
162 test< std::int16_t>();
163 test<std::uint16_t>();
164 test< std::int32_t>();
165 test<std::uint32_t>();
166 test< std::int64_t>();
167 test<std::uint64_t>();
168
169 test<std::intptr_t>();
170 test<std::uintptr_t>();
171 test<std::size_t>();
172 test<std::ptrdiff_t>();
173 test<std::intmax_t>();
174 test<std::uintmax_t>();
175
176 test<std::uintmax_t>();
177 test<std::uintmax_t>();
178
179 test<void (*)(int)>();
180 test<void*>();
181 test<const void*>();
182 test<int*>();
183 test<const int*>();
184
185 test<TriviallyCopyable>();
186 test<PaddedTriviallyCopyable>();
187#ifndef __APPLE__ // Apple doesn't ship libatomic
188 /*
189 These aren't going to be lock-free,
190 so some libatomic.a is necessary.
191 */
192 test<WeirdTriviallyCopyable>();
193 test<LargeTriviallyCopyable>();
194#endif
195
196#ifndef TEST_HAS_NO_THREADS
197 test<std::thread::id>();
198#endif
199 test<std::chrono::nanoseconds>();
200 test<float>();
201
202#if TEST_STD_VER >= 20
203 test<std::atomic_signed_lock_free::value_type>();
204 static_assert(std::is_signed_v<std::atomic_signed_lock_free::value_type>);
205 static_assert(std::is_integral_v<std::atomic_signed_lock_free::value_type>);
206
207 test<std::atomic_unsigned_lock_free::value_type>();
208 static_assert(std::is_unsigned_v<std::atomic_unsigned_lock_free::value_type>);
209 static_assert(std::is_integral_v<std::atomic_unsigned_lock_free::value_type>);
210/*
211 test<std::shared_ptr<int>>();
212*/
213#endif
214
215 return 0;
216}
217

source code of libcxx/test/std/atomics/types.pass.cpp