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// test <cstdint>
11
12#include <cstdint>
13#include <cstddef>
14#include <cwchar>
15#include <csignal>
16#include <cwctype>
17#include <climits>
18#include <type_traits>
19#include <limits>
20#include <cassert>
21
22int main()
23{
24    // typedef std::int8_t
25    static_assert(sizeof(std::int8_t)*CHAR_BIT == 8,
26                 "sizeof(std::int8_t)*CHAR_BIT == 8");
27    static_assert(std::is_signed<std::int8_t>::value,
28                 "std::is_signed<std::int8_t>::value");
29    // typedef std::int16_t
30    static_assert(sizeof(std::int16_t)*CHAR_BIT == 16,
31                 "sizeof(std::int16_t)*CHAR_BIT == 16");
32    static_assert(std::is_signed<std::int16_t>::value,
33                 "std::is_signed<std::int16_t>::value");
34    // typedef std::int32_t
35    static_assert(sizeof(std::int32_t)*CHAR_BIT == 32,
36                 "sizeof(std::int32_t)*CHAR_BIT == 32");
37    static_assert(std::is_signed<std::int32_t>::value,
38                 "std::is_signed<std::int32_t>::value");
39    // typedef std::int64_t
40    static_assert(sizeof(std::int64_t)*CHAR_BIT == 64,
41                 "sizeof(std::int64_t)*CHAR_BIT == 64");
42    static_assert(std::is_signed<std::int64_t>::value,
43                 "std::is_signed<std::int64_t>::value");
44
45    // typedef std::uint8_t
46    static_assert(sizeof(std::uint8_t)*CHAR_BIT == 8,
47                 "sizeof(std::uint8_t)*CHAR_BIT == 8");
48    static_assert(std::is_unsigned<std::uint8_t>::value,
49                 "std::is_unsigned<std::uint8_t>::value");
50    // typedef std::uint16_t
51    static_assert(sizeof(std::uint16_t)*CHAR_BIT == 16,
52                 "sizeof(std::uint16_t)*CHAR_BIT == 16");
53    static_assert(std::is_unsigned<std::uint16_t>::value,
54                 "std::is_unsigned<std::uint16_t>::value");
55    // typedef std::uint32_t
56    static_assert(sizeof(std::uint32_t)*CHAR_BIT == 32,
57                 "sizeof(std::uint32_t)*CHAR_BIT == 32");
58    static_assert(std::is_unsigned<std::uint32_t>::value,
59                 "std::is_unsigned<std::uint32_t>::value");
60    // typedef std::uint64_t
61    static_assert(sizeof(std::uint64_t)*CHAR_BIT == 64,
62                 "sizeof(std::uint64_t)*CHAR_BIT == 64");
63    static_assert(std::is_unsigned<std::uint64_t>::value,
64                 "std::is_unsigned<std::uint64_t>::value");
65
66    // typedef std::int_least8_t
67    static_assert(sizeof(std::int_least8_t)*CHAR_BIT >= 8,
68                 "sizeof(std::int_least8_t)*CHAR_BIT >= 8");
69    static_assert(std::is_signed<std::int_least8_t>::value,
70                 "std::is_signed<std::int_least8_t>::value");
71    // typedef std::int_least16_t
72    static_assert(sizeof(std::int_least16_t)*CHAR_BIT >= 16,
73                 "sizeof(std::int_least16_t)*CHAR_BIT >= 16");
74    static_assert(std::is_signed<std::int_least16_t>::value,
75                 "std::is_signed<std::int_least16_t>::value");
76    // typedef std::int_least32_t
77    static_assert(sizeof(std::int_least32_t)*CHAR_BIT >= 32,
78                 "sizeof(std::int_least32_t)*CHAR_BIT >= 32");
79    static_assert(std::is_signed<std::int_least32_t>::value,
80                 "std::is_signed<std::int_least32_t>::value");
81    // typedef std::int_least64_t
82    static_assert(sizeof(std::int_least64_t)*CHAR_BIT >= 64,
83                 "sizeof(std::int_least64_t)*CHAR_BIT >= 64");
84    static_assert(std::is_signed<std::int_least64_t>::value,
85                 "std::is_signed<std::int_least64_t>::value");
86
87    // typedef std::uint_least8_t
88    static_assert(sizeof(std::uint_least8_t)*CHAR_BIT >= 8,
89                 "sizeof(std::uint_least8_t)*CHAR_BIT >= 8");
90    static_assert(std::is_unsigned<std::uint_least8_t>::value,
91                 "std::is_unsigned<std::uint_least8_t>::value");
92    // typedef std::uint_least16_t
93    static_assert(sizeof(std::uint_least16_t)*CHAR_BIT >= 16,
94                 "sizeof(std::uint_least16_t)*CHAR_BIT >= 16");
95    static_assert(std::is_unsigned<std::uint_least16_t>::value,
96                 "std::is_unsigned<std::uint_least16_t>::value");
97    // typedef std::uint_least32_t
98    static_assert(sizeof(std::uint_least32_t)*CHAR_BIT >= 32,
99                 "sizeof(std::uint_least32_t)*CHAR_BIT >= 32");
100    static_assert(std::is_unsigned<std::uint_least32_t>::value,
101                 "std::is_unsigned<std::uint_least32_t>::value");
102    // typedef std::uint_least64_t
103    static_assert(sizeof(std::uint_least64_t)*CHAR_BIT >= 64,
104                 "sizeof(std::uint_least64_t)*CHAR_BIT >= 64");
105    static_assert(std::is_unsigned<std::uint_least64_t>::value,
106                 "std::is_unsigned<std::uint_least64_t>::value");
107
108    // typedef std::int_fast8_t
109    static_assert(sizeof(std::int_fast8_t)*CHAR_BIT >= 8,
110                 "sizeof(std::int_fast8_t)*CHAR_BIT >= 8");
111    static_assert(std::is_signed<std::int_fast8_t>::value,
112                 "std::is_signed<std::int_fast8_t>::value");
113    // typedef std::int_fast16_t
114    static_assert(sizeof(std::int_fast16_t)*CHAR_BIT >= 16,
115                 "sizeof(std::int_fast16_t)*CHAR_BIT >= 16");
116    static_assert(std::is_signed<std::int_fast16_t>::value,
117                 "std::is_signed<std::int_fast16_t>::value");
118    // typedef std::int_fast32_t
119    static_assert(sizeof(std::int_fast32_t)*CHAR_BIT >= 32,
120                 "sizeof(std::int_fast32_t)*CHAR_BIT >= 32");
121    static_assert(std::is_signed<std::int_fast32_t>::value,
122                 "std::is_signed<std::int_fast32_t>::value");
123    // typedef std::int_fast64_t
124    static_assert(sizeof(std::int_fast64_t)*CHAR_BIT >= 64,
125                 "sizeof(std::int_fast64_t)*CHAR_BIT >= 64");
126    static_assert(std::is_signed<std::int_fast64_t>::value,
127                 "std::is_signed<std::int_fast64_t>::value");
128
129    // typedef std::uint_fast8_t
130    static_assert(sizeof(std::uint_fast8_t)*CHAR_BIT >= 8,
131                 "sizeof(std::uint_fast8_t)*CHAR_BIT >= 8");
132    static_assert(std::is_unsigned<std::uint_fast8_t>::value,
133                 "std::is_unsigned<std::uint_fast8_t>::value");
134    // typedef std::uint_fast16_t
135    static_assert(sizeof(std::uint_fast16_t)*CHAR_BIT >= 16,
136                 "sizeof(std::uint_fast16_t)*CHAR_BIT >= 16");
137    static_assert(std::is_unsigned<std::uint_fast16_t>::value,
138                 "std::is_unsigned<std::uint_fast16_t>::value");
139    // typedef std::uint_fast32_t
140    static_assert(sizeof(std::uint_fast32_t)*CHAR_BIT >= 32,
141                 "sizeof(std::uint_fast32_t)*CHAR_BIT >= 32");
142    static_assert(std::is_unsigned<std::uint_fast32_t>::value,
143                 "std::is_unsigned<std::uint_fast32_t>::value");
144    // typedef std::uint_fast64_t
145    static_assert(sizeof(std::uint_fast64_t)*CHAR_BIT >= 64,
146                 "sizeof(std::uint_fast64_t)*CHAR_BIT >= 64");
147    static_assert(std::is_unsigned<std::uint_fast64_t>::value,
148                 "std::is_unsigned<std::uint_fast64_t>::value");
149
150    // typedef std::intptr_t
151    static_assert(sizeof(std::intptr_t) >= sizeof(void*),
152                 "sizeof(std::intptr_t) >= sizeof(void*)");
153    static_assert(std::is_signed<std::intptr_t>::value,
154                 "std::is_signed<std::intptr_t>::value");
155    // typedef std::uintptr_t
156    static_assert(sizeof(std::uintptr_t) >= sizeof(void*),
157                 "sizeof(std::uintptr_t) >= sizeof(void*)");
158    static_assert(std::is_unsigned<std::uintptr_t>::value,
159                 "std::is_unsigned<std::uintptr_t>::value");
160
161    // typedef std::intmax_t
162    static_assert(sizeof(std::intmax_t) >= sizeof(long long),
163                 "sizeof(std::intmax_t) >= sizeof(long long)");
164    static_assert(std::is_signed<std::intmax_t>::value,
165                 "std::is_signed<std::intmax_t>::value");
166    // typedef std::uintmax_t
167    static_assert(sizeof(std::uintmax_t) >= sizeof(unsigned long long),
168                 "sizeof(std::uintmax_t) >= sizeof(unsigned long long)");
169    static_assert(std::is_unsigned<std::uintmax_t>::value,
170                 "std::is_unsigned<std::uintmax_t>::value");
171
172    // INTN_MIN
173    static_assert(INT8_MIN == -128, "INT8_MIN == -128");
174    static_assert(INT16_MIN == -32768, "INT16_MIN == -32768");
175    static_assert(INT32_MIN == -2147483647 - 1, "INT32_MIN == -2147483648");
176    static_assert(INT64_MIN == -9223372036854775807LL - 1, "INT64_MIN == -9223372036854775808LL");
177
178    // INTN_MAX
179    static_assert(INT8_MAX == 127, "INT8_MAX == 127");
180    static_assert(INT16_MAX == 32767, "INT16_MAX == 32767");
181    static_assert(INT32_MAX == 2147483647, "INT32_MAX == 2147483647");
182    static_assert(INT64_MAX == 9223372036854775807LL, "INT64_MAX == 9223372036854775807LL");
183
184    // UINTN_MAX
185    static_assert(UINT8_MAX == 255, "UINT8_MAX == 255");
186    static_assert(UINT16_MAX == 65535, "UINT16_MAX == 65535");
187    static_assert(UINT32_MAX == 4294967295U, "UINT32_MAX == 4294967295");
188    static_assert(UINT64_MAX == 18446744073709551615ULL, "UINT64_MAX == 18446744073709551615ULL");
189
190    // INT_FASTN_MIN
191    static_assert(INT_FAST8_MIN <= -128, "INT_FAST8_MIN <= -128");
192    static_assert(INT_FAST16_MIN <= -32768, "INT_FAST16_MIN <= -32768");
193    static_assert(INT_FAST32_MIN <= -2147483647 - 1, "INT_FAST32_MIN <= -2147483648");
194    static_assert(INT_FAST64_MIN <= -9223372036854775807LL - 1, "INT_FAST64_MIN <= -9223372036854775808LL");
195
196    // INT_FASTN_MAX
197    static_assert(INT_FAST8_MAX >= 127, "INT_FAST8_MAX >= 127");
198    static_assert(INT_FAST16_MAX >= 32767, "INT_FAST16_MAX >= 32767");
199    static_assert(INT_FAST32_MAX >= 2147483647, "INT_FAST32_MAX >= 2147483647");
200    static_assert(INT_FAST64_MAX >= 9223372036854775807LL, "INT_FAST64_MAX >= 9223372036854775807LL");
201
202    // UINT_FASTN_MAX
203    static_assert(UINT_FAST8_MAX >= 255, "UINT_FAST8_MAX >= 255");
204    static_assert(UINT_FAST16_MAX >= 65535, "UINT_FAST16_MAX >= 65535");
205    static_assert(UINT_FAST32_MAX >= 4294967295U, "UINT_FAST32_MAX >= 4294967295");
206    static_assert(UINT_FAST64_MAX >= 18446744073709551615ULL, "UINT_FAST64_MAX >= 18446744073709551615ULL");
207
208    // INTPTR_MIN
209    assert(INTPTR_MIN == std::numeric_limits<std::intptr_t>::min());
210
211    // INTPTR_MAX
212    assert(INTPTR_MAX == std::numeric_limits<std::intptr_t>::max());
213
214    // UINTPTR_MAX
215    assert(UINTPTR_MAX == std::numeric_limits<std::uintptr_t>::max());
216
217    // INTMAX_MIN
218    assert(INTMAX_MIN == std::numeric_limits<std::intmax_t>::min());
219
220    // INTMAX_MAX
221    assert(INTMAX_MAX == std::numeric_limits<std::intmax_t>::max());
222
223    // UINTMAX_MAX
224    assert(UINTMAX_MAX == std::numeric_limits<std::uintmax_t>::max());
225
226    // PTRDIFF_MIN
227    assert(PTRDIFF_MIN == std::numeric_limits<std::ptrdiff_t>::min());
228
229    // PTRDIFF_MAX
230    assert(PTRDIFF_MAX == std::numeric_limits<std::ptrdiff_t>::max());
231
232    // SIG_ATOMIC_MIN
233    assert(SIG_ATOMIC_MIN == std::numeric_limits<std::sig_atomic_t>::min());
234
235    // SIG_ATOMIC_MAX
236    assert(SIG_ATOMIC_MAX == std::numeric_limits<std::sig_atomic_t>::max());
237
238    // SIZE_MAX
239    assert(SIZE_MAX == std::numeric_limits<std::size_t>::max());
240
241    // WCHAR_MIN
242    assert(WCHAR_MIN == std::numeric_limits<wchar_t>::min());
243
244    // WCHAR_MAX
245    assert(WCHAR_MAX == std::numeric_limits<wchar_t>::max());
246
247    // WINT_MIN
248    assert(WINT_MIN == std::numeric_limits<std::wint_t>::min());
249
250    // WINT_MAX
251    assert(WINT_MAX == std::numeric_limits<std::wint_t>::max());
252
253#ifndef INT8_C
254#error INT8_C not defined
255#endif
256
257#ifndef INT16_C
258#error INT16_C not defined
259#endif
260
261#ifndef INT32_C
262#error INT32_C not defined
263#endif
264
265#ifndef INT64_C
266#error INT64_C not defined
267#endif
268
269#ifndef UINT8_C
270#error UINT8_C not defined
271#endif
272
273#ifndef UINT16_C
274#error UINT16_C not defined
275#endif
276
277#ifndef UINT32_C
278#error UINT32_C not defined
279#endif
280
281#ifndef UINT64_C
282#error UINT64_C not defined
283#endif
284
285#ifndef INTMAX_C
286#error INTMAX_C not defined
287#endif
288
289#ifndef UINTMAX_C
290#error UINTMAX_C not defined
291#endif
292}
293