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 // type_traits
11 
12 // aligned_storage
13 //
14 //  Issue 3034 added:
15 //  The member typedef type shall be a trivial standard-layout type.
16 
17 #include <type_traits>
18 #include <cstddef>       // for std::max_align_t
19 #include "test_macros.h"
20 
main()21 int main()
22 {
23     {
24     typedef std::aligned_storage<10, 1 >::type T1;
25 #if TEST_STD_VER > 11
26     static_assert(std::is_same<std::aligned_storage_t<10, 1>, T1>::value, "");
27 #endif
28 #if TEST_STD_VER <= 17
29     static_assert(std::is_pod<T1>::value, "");
30 #endif
31     static_assert(std::is_trivial<T1>::value, "");
32     static_assert(std::is_standard_layout<T1>::value, "");
33     static_assert(std::alignment_of<T1>::value == 1, "");
34     static_assert(sizeof(T1) == 10, "");
35     }
36     {
37     typedef std::aligned_storage<10, 2 >::type T1;
38 #if TEST_STD_VER > 11
39     static_assert(std::is_same<std::aligned_storage_t<10, 2>, T1>::value, "");
40 #endif
41 #if TEST_STD_VER <= 17
42     static_assert(std::is_pod<T1>::value, "");
43 #endif
44     static_assert(std::is_trivial<T1>::value, "");
45     static_assert(std::is_standard_layout<T1>::value, "");
46     static_assert(std::alignment_of<T1>::value == 2, "");
47     static_assert(sizeof(T1) == 10, "");
48     }
49     {
50     typedef std::aligned_storage<10, 4 >::type T1;
51 #if TEST_STD_VER > 11
52     static_assert(std::is_same<std::aligned_storage_t<10, 4>, T1>::value, "");
53 #endif
54 #if TEST_STD_VER <= 17
55     static_assert(std::is_pod<T1>::value, "");
56 #endif
57     static_assert(std::is_trivial<T1>::value, "");
58     static_assert(std::is_standard_layout<T1>::value, "");
59     static_assert(std::alignment_of<T1>::value == 4, "");
60     static_assert(sizeof(T1) == 12, "");
61     }
62     {
63     typedef std::aligned_storage<10, 8 >::type T1;
64 #if TEST_STD_VER > 11
65     static_assert(std::is_same<std::aligned_storage_t<10, 8>, T1>::value, "");
66 #endif
67 #if TEST_STD_VER <= 17
68     static_assert(std::is_pod<T1>::value, "");
69 #endif
70     static_assert(std::is_trivial<T1>::value, "");
71     static_assert(std::is_standard_layout<T1>::value, "");
72     static_assert(std::alignment_of<T1>::value == 8, "");
73     static_assert(sizeof(T1) == 16, "");
74     }
75     {
76     typedef std::aligned_storage<10, 16 >::type T1;
77 #if TEST_STD_VER > 11
78     static_assert(std::is_same<std::aligned_storage_t<10, 16>, T1>::value, "");
79 #endif
80 #if TEST_STD_VER <= 17
81     static_assert(std::is_pod<T1>::value, "");
82 #endif
83     static_assert(std::is_trivial<T1>::value, "");
84     static_assert(std::is_standard_layout<T1>::value, "");
85     static_assert(std::alignment_of<T1>::value == 16, "");
86     static_assert(sizeof(T1) == 16, "");
87     }
88     {
89     typedef std::aligned_storage<10, 32 >::type T1;
90 #if TEST_STD_VER > 11
91     static_assert(std::is_same<std::aligned_storage_t<10, 32>, T1>::value, "");
92 #endif
93 #if TEST_STD_VER <= 17
94     static_assert(std::is_pod<T1>::value, "");
95 #endif
96     static_assert(std::is_trivial<T1>::value, "");
97     static_assert(std::is_standard_layout<T1>::value, "");
98     static_assert(std::alignment_of<T1>::value == 32, "");
99     static_assert(sizeof(T1) == 32, "");
100     }
101     {
102     typedef std::aligned_storage<20, 32 >::type T1;
103 #if TEST_STD_VER > 11
104     static_assert(std::is_same<std::aligned_storage_t<20, 32>, T1>::value, "");
105 #endif
106 #if TEST_STD_VER <= 17
107     static_assert(std::is_pod<T1>::value, "");
108 #endif
109     static_assert(std::is_trivial<T1>::value, "");
110     static_assert(std::is_standard_layout<T1>::value, "");
111     static_assert(std::alignment_of<T1>::value == 32, "");
112     static_assert(sizeof(T1) == 32, "");
113     }
114     {
115     typedef std::aligned_storage<40, 32 >::type T1;
116 #if TEST_STD_VER > 11
117     static_assert(std::is_same<std::aligned_storage_t<40, 32>, T1>::value, "");
118 #endif
119 #if TEST_STD_VER <= 17
120     static_assert(std::is_pod<T1>::value, "");
121 #endif
122     static_assert(std::is_trivial<T1>::value, "");
123     static_assert(std::is_standard_layout<T1>::value, "");
124     static_assert(std::alignment_of<T1>::value == 32, "");
125     static_assert(sizeof(T1) == 64, "");
126     }
127     {
128     typedef std::aligned_storage<12, 16 >::type T1;
129 #if TEST_STD_VER > 11
130     static_assert(std::is_same<std::aligned_storage_t<12, 16>, T1>::value, "");
131 #endif
132 #if TEST_STD_VER <= 17
133     static_assert(std::is_pod<T1>::value, "");
134 #endif
135     static_assert(std::is_trivial<T1>::value, "");
136     static_assert(std::is_standard_layout<T1>::value, "");
137     static_assert(std::alignment_of<T1>::value == 16, "");
138     static_assert(sizeof(T1) == 16, "");
139     }
140     {
141     typedef std::aligned_storage<1>::type T1;
142 #if TEST_STD_VER > 11
143     static_assert(std::is_same<std::aligned_storage_t<1>, T1>::value, "");
144 #endif
145 #if TEST_STD_VER <= 17
146     static_assert(std::is_pod<T1>::value, "");
147 #endif
148     static_assert(std::is_trivial<T1>::value, "");
149     static_assert(std::is_standard_layout<T1>::value, "");
150     static_assert(std::alignment_of<T1>::value == 1, "");
151     static_assert(sizeof(T1) == 1, "");
152     }
153     {
154     typedef std::aligned_storage<2>::type T1;
155 #if TEST_STD_VER > 11
156     static_assert(std::is_same<std::aligned_storage_t<2>, T1>::value, "");
157 #endif
158 #if TEST_STD_VER <= 17
159     static_assert(std::is_pod<T1>::value, "");
160 #endif
161     static_assert(std::is_trivial<T1>::value, "");
162     static_assert(std::is_standard_layout<T1>::value, "");
163     static_assert(std::alignment_of<T1>::value == 2, "");
164     static_assert(sizeof(T1) == 2, "");
165     }
166     {
167     typedef std::aligned_storage<3>::type T1;
168 #if TEST_STD_VER > 11
169     static_assert(std::is_same<std::aligned_storage_t<3>, T1>::value, "");
170 #endif
171 #if TEST_STD_VER <= 17
172     static_assert(std::is_pod<T1>::value, "");
173 #endif
174     static_assert(std::is_trivial<T1>::value, "");
175     static_assert(std::is_standard_layout<T1>::value, "");
176     static_assert(std::alignment_of<T1>::value == 2, "");
177     static_assert(sizeof(T1) == 4, "");
178     }
179     {
180     typedef std::aligned_storage<4>::type T1;
181 #if TEST_STD_VER > 11
182     static_assert(std::is_same<std::aligned_storage_t<4>, T1>::value, "");
183 #endif
184 #if TEST_STD_VER <= 17
185     static_assert(std::is_pod<T1>::value, "");
186 #endif
187     static_assert(std::is_trivial<T1>::value, "");
188     static_assert(std::is_standard_layout<T1>::value, "");
189     static_assert(std::alignment_of<T1>::value == 4, "");
190     static_assert(sizeof(T1) == 4, "");
191     }
192     {
193     typedef std::aligned_storage<5>::type T1;
194 #if TEST_STD_VER > 11
195     static_assert(std::is_same<std::aligned_storage_t<5>, T1>::value, "");
196 #endif
197 #if TEST_STD_VER <= 17
198     static_assert(std::is_pod<T1>::value, "");
199 #endif
200     static_assert(std::is_trivial<T1>::value, "");
201     static_assert(std::is_standard_layout<T1>::value, "");
202     static_assert(std::alignment_of<T1>::value == 4, "");
203     static_assert(sizeof(T1) == 8, "");
204     }
205     {
206     typedef std::aligned_storage<7>::type T1;
207 #if TEST_STD_VER > 11
208     static_assert(std::is_same<std::aligned_storage_t<7>, T1>::value, "");
209 #endif
210     static_assert(std::is_trivial<T1>::value, "");
211     static_assert(std::is_standard_layout<T1>::value, "");
212     static_assert(std::alignment_of<T1>::value == 4, "");
213     static_assert(sizeof(T1) == 8, "");
214     }
215     {
216     typedef std::aligned_storage<8>::type T1;
217 #if TEST_STD_VER > 11
218     static_assert(std::is_same<std::aligned_storage_t<8>, T1>::value, "");
219 #endif
220 #if TEST_STD_VER <= 17
221     static_assert(std::is_pod<T1>::value, "");
222 #endif
223     static_assert(std::is_trivial<T1>::value, "");
224     static_assert(std::is_standard_layout<T1>::value, "");
225     static_assert(std::alignment_of<T1>::value == 8, "");
226     static_assert(sizeof(T1) == 8, "");
227     }
228     {
229     typedef std::aligned_storage<9>::type T1;
230 #if TEST_STD_VER > 11
231     static_assert(std::is_same<std::aligned_storage_t<9>, T1>::value, "");
232 #endif
233 #if TEST_STD_VER <= 17
234     static_assert(std::is_pod<T1>::value, "");
235 #endif
236     static_assert(std::is_trivial<T1>::value, "");
237     static_assert(std::is_standard_layout<T1>::value, "");
238     static_assert(std::alignment_of<T1>::value == 8, "");
239     static_assert(sizeof(T1) == 16, "");
240     }
241     {
242     typedef std::aligned_storage<15>::type T1;
243 #if TEST_STD_VER > 11
244     static_assert(std::is_same<std::aligned_storage_t<15>, T1>::value, "");
245 #endif
246 #if TEST_STD_VER <= 17
247     static_assert(std::is_pod<T1>::value, "");
248 #endif
249     static_assert(std::is_trivial<T1>::value, "");
250     static_assert(std::is_standard_layout<T1>::value, "");
251     static_assert(std::alignment_of<T1>::value == 8, "");
252     static_assert(sizeof(T1) == 16, "");
253     }
254     // Use alignof(std::max_align_t) below to find the max alignment instead of
255     // hardcoding it, because it's different on different platforms.
256     // (For example 8 on arm and 16 on x86.)
257 #if TEST_STD_VER < 11
258 #define alignof __alignof__
259 #endif
260     {
261     typedef std::aligned_storage<16>::type T1;
262 #if TEST_STD_VER > 11
263     static_assert(std::is_same<std::aligned_storage_t<16>, T1>::value, "");
264 #endif
265     static_assert(std::is_trivial<T1>::value, "");
266     static_assert(std::is_standard_layout<T1>::value, "");
267     static_assert(std::alignment_of<T1>::value == alignof(std::max_align_t),
268                   "");
269     static_assert(sizeof(T1) == 16, "");
270     }
271     {
272     typedef std::aligned_storage<17>::type T1;
273 #if TEST_STD_VER > 11
274     static_assert(std::is_same<std::aligned_storage_t<17>, T1>::value, "");
275 #endif
276     static_assert(std::is_trivial<T1>::value, "");
277     static_assert(std::is_standard_layout<T1>::value, "");
278     static_assert(std::alignment_of<T1>::value == alignof(std::max_align_t),
279                   "");
280     static_assert(sizeof(T1) == 16 + alignof(std::max_align_t), "");
281     }
282     {
283     typedef std::aligned_storage<10>::type T1;
284 #if TEST_STD_VER > 11
285     static_assert(std::is_same<std::aligned_storage_t<10>, T1>::value, "");
286 #endif
287     static_assert(std::is_trivial<T1>::value, "");
288     static_assert(std::is_standard_layout<T1>::value, "");
289     static_assert(std::alignment_of<T1>::value == 8, "");
290     static_assert(sizeof(T1) == 16, "");
291     }
292 }
293