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