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

source code of libcxx/test/std/language.support/cstdint/cstdint.syn/cstdint.pass.cpp