1
/* Test of <stdint.h> substitute.
2
Copyright (C) 2006-2010 Free Software Foundation, Inc.
4
This program is free software: you can redistribute it and/or modify
5
it under the terms of the GNU General Public License as published by
6
the Free Software Foundation; either version 3 of the License, or
7
(at your option) any later version.
9
This program is distributed in the hope that it will be useful,
10
but WITHOUT ANY WARRANTY; without even the implied warranty of
11
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12
GNU General Public License for more details.
14
You should have received a copy of the GNU General Public License
15
along with this program. If not, see <http://www.gnu.org/licenses/>. */
17
/* Written by Bruno Haible <bruno@clisp.org>, 2006. */
21
/* Whether to enable pedantic checks. */
24
#define __STDC_LIMIT_MACROS 1 /* to make it work also in C++ mode */
30
#if __GNUC__ >= 2 && DO_PEDANTIC
31
# define verify_same_types(expr1,expr2) \
32
extern void _verify_func(__LINE__) (__typeof__ (expr1) *); \
33
extern void _verify_func(__LINE__) (__typeof__ (expr2) *);
34
# define _verify_func(line) _verify_func2(line)
35
# define _verify_func2(line) verify_func_ ## line
37
# define verify_same_types(expr1,expr2) extern void verify_func (int)
40
/* 7.18.1.1. Exact-width integer types */
41
/* 7.18.2.1. Limits of exact-width integer types */
43
int8_t a1[3] = { INT8_C (17), INT8_MIN, INT8_MAX };
44
verify (TYPE_MINIMUM (int8_t) == INT8_MIN);
45
verify (TYPE_MAXIMUM (int8_t) == INT8_MAX);
46
verify_same_types (INT8_MIN, (int8_t) 0 + 0);
47
verify_same_types (INT8_MAX, (int8_t) 0 + 0);
49
int16_t a2[3] = { INT16_C (17), INT16_MIN, INT16_MAX };
50
verify (TYPE_MINIMUM (int16_t) == INT16_MIN);
51
verify (TYPE_MAXIMUM (int16_t) == INT16_MAX);
52
verify_same_types (INT16_MIN, (int16_t) 0 + 0);
53
verify_same_types (INT16_MAX, (int16_t) 0 + 0);
55
int32_t a3[3] = { INT32_C (17), INT32_MIN, INT32_MAX };
56
verify (TYPE_MINIMUM (int32_t) == INT32_MIN);
57
verify (TYPE_MAXIMUM (int32_t) == INT32_MAX);
58
verify_same_types (INT32_MIN, (int32_t) 0 + 0);
59
verify_same_types (INT32_MAX, (int32_t) 0 + 0);
62
int64_t a4[3] = { INT64_C (17), INT64_MIN, INT64_MAX };
63
verify (TYPE_MINIMUM (int64_t) == INT64_MIN);
64
verify (TYPE_MAXIMUM (int64_t) == INT64_MAX);
65
verify_same_types (INT64_MIN, (int64_t) 0 + 0);
66
verify_same_types (INT64_MAX, (int64_t) 0 + 0);
69
uint8_t b1[2] = { UINT8_C (17), UINT8_MAX };
70
verify (TYPE_MAXIMUM (uint8_t) == UINT8_MAX);
71
verify_same_types (UINT8_MAX, (uint8_t) 0 + 0);
73
uint16_t b2[2] = { UINT16_C (17), UINT16_MAX };
74
verify (TYPE_MAXIMUM (uint16_t) == UINT16_MAX);
75
verify_same_types (UINT16_MAX, (uint16_t) 0 + 0);
77
uint32_t b3[2] = { UINT32_C (17), UINT32_MAX };
78
verify (TYPE_MAXIMUM (uint32_t) == UINT32_MAX);
79
verify_same_types (UINT32_MAX, (uint32_t) 0 + 0);
82
uint64_t b4[2] = { UINT64_C (17), UINT64_MAX };
83
verify (TYPE_MAXIMUM (uint64_t) == UINT64_MAX);
84
verify_same_types (UINT64_MAX, (uint64_t) 0 + 0);
87
#if INT8_MIN && INT8_MAX && INT16_MIN && INT16_MAX && INT32_MIN && INT32_MAX
93
#if UINT8_MAX && UINT16_MAX && UINT32_MAX
99
/* 7.18.1.2. Minimum-width integer types */
100
/* 7.18.2.2. Limits of minimum-width integer types */
102
int_least8_t c1[3] = { 17, INT_LEAST8_MIN, INT_LEAST8_MAX };
103
verify (TYPE_MINIMUM (int_least8_t) == INT_LEAST8_MIN);
104
verify (TYPE_MAXIMUM (int_least8_t) == INT_LEAST8_MAX);
105
verify_same_types (INT_LEAST8_MIN, (int_least8_t) 0 + 0);
106
verify_same_types (INT_LEAST8_MAX, (int_least8_t) 0 + 0);
108
int_least16_t c2[3] = { 17, INT_LEAST16_MIN, INT_LEAST16_MAX };
109
verify (TYPE_MINIMUM (int_least16_t) == INT_LEAST16_MIN);
110
verify (TYPE_MAXIMUM (int_least16_t) == INT_LEAST16_MAX);
111
verify_same_types (INT_LEAST16_MIN, (int_least16_t) 0 + 0);
112
verify_same_types (INT_LEAST16_MAX, (int_least16_t) 0 + 0);
114
int_least32_t c3[3] = { 17, INT_LEAST32_MIN, INT_LEAST32_MAX };
115
verify (TYPE_MINIMUM (int_least32_t) == INT_LEAST32_MIN);
116
verify (TYPE_MAXIMUM (int_least32_t) == INT_LEAST32_MAX);
117
verify_same_types (INT_LEAST32_MIN, (int_least32_t) 0 + 0);
118
verify_same_types (INT_LEAST32_MAX, (int_least32_t) 0 + 0);
120
#ifdef INT_LEAST64_MAX
121
int_least64_t c4[3] = { 17, INT_LEAST64_MIN, INT_LEAST64_MAX };
122
verify (TYPE_MINIMUM (int_least64_t) == INT_LEAST64_MIN);
123
verify (TYPE_MAXIMUM (int_least64_t) == INT_LEAST64_MAX);
124
verify_same_types (INT_LEAST64_MIN, (int_least64_t) 0 + 0);
125
verify_same_types (INT_LEAST64_MAX, (int_least64_t) 0 + 0);
128
uint_least8_t d1[2] = { 17, UINT_LEAST8_MAX };
129
verify (TYPE_MAXIMUM (uint_least8_t) == UINT_LEAST8_MAX);
130
verify_same_types (UINT_LEAST8_MAX, (uint_least8_t) 0 + 0);
132
uint_least16_t d2[2] = { 17, UINT_LEAST16_MAX };
133
verify (TYPE_MAXIMUM (uint_least16_t) == UINT_LEAST16_MAX);
134
verify_same_types (UINT_LEAST16_MAX, (uint_least16_t) 0 + 0);
136
uint_least32_t d3[2] = { 17, UINT_LEAST32_MAX };
137
verify (TYPE_MAXIMUM (uint_least32_t) == UINT_LEAST32_MAX);
138
verify_same_types (UINT_LEAST32_MAX, (uint_least32_t) 0 + 0);
140
#ifdef UINT_LEAST64_MAX
141
uint_least64_t d4[2] = { 17, UINT_LEAST64_MAX };
142
verify (TYPE_MAXIMUM (uint_least64_t) == UINT_LEAST64_MAX);
143
verify_same_types (UINT_LEAST64_MAX, (uint_least64_t) 0 + 0);
146
#if INT_LEAST8_MIN && INT_LEAST8_MAX && INT_LEAST16_MIN && INT_LEAST16_MAX && INT_LEAST32_MIN && INT_LEAST32_MAX
152
#if UINT_LEAST8_MAX && UINT_LEAST16_MAX && UINT_LEAST32_MAX
158
/* 7.18.1.3. Fastest minimum-width integer types */
159
/* 7.18.2.3. Limits of fastest minimum-width integer types */
161
int_fast8_t e1[3] = { 17, INT_FAST8_MIN, INT_FAST8_MAX };
162
verify (TYPE_MINIMUM (int_fast8_t) == INT_FAST8_MIN);
163
verify (TYPE_MAXIMUM (int_fast8_t) == INT_FAST8_MAX);
164
verify_same_types (INT_FAST8_MIN, (int_fast8_t) 0 + 0);
165
verify_same_types (INT_FAST8_MAX, (int_fast8_t) 0 + 0);
167
int_fast16_t e2[3] = { 17, INT_FAST16_MIN, INT_FAST16_MAX };
168
verify (TYPE_MINIMUM (int_fast16_t) == INT_FAST16_MIN);
169
verify (TYPE_MAXIMUM (int_fast16_t) == INT_FAST16_MAX);
170
verify_same_types (INT_FAST16_MIN, (int_fast16_t) 0 + 0);
171
verify_same_types (INT_FAST16_MAX, (int_fast16_t) 0 + 0);
173
int_fast32_t e3[3] = { 17, INT_FAST32_MIN, INT_FAST32_MAX };
174
verify (TYPE_MINIMUM (int_fast32_t) == INT_FAST32_MIN);
175
verify (TYPE_MAXIMUM (int_fast32_t) == INT_FAST32_MAX);
176
verify_same_types (INT_FAST32_MIN, (int_fast32_t) 0 + 0);
177
verify_same_types (INT_FAST32_MAX, (int_fast32_t) 0 + 0);
179
#ifdef INT_FAST64_MAX
180
int_fast64_t e4[3] = { 17, INT_FAST64_MIN, INT_FAST64_MAX };
181
verify (TYPE_MINIMUM (int_fast64_t) == INT_FAST64_MIN);
182
verify (TYPE_MAXIMUM (int_fast64_t) == INT_FAST64_MAX);
183
verify_same_types (INT_FAST64_MIN, (int_fast64_t) 0 + 0);
184
verify_same_types (INT_FAST64_MAX, (int_fast64_t) 0 + 0);
187
uint_fast8_t f1[2] = { 17, UINT_FAST8_MAX };
188
verify (TYPE_MAXIMUM (uint_fast8_t) == UINT_FAST8_MAX);
189
verify_same_types (UINT_FAST8_MAX, (uint_fast8_t) 0 + 0);
191
uint_fast16_t f2[2] = { 17, UINT_FAST16_MAX };
192
verify (TYPE_MAXIMUM (uint_fast16_t) == UINT_FAST16_MAX);
193
verify_same_types (UINT_FAST16_MAX, (uint_fast16_t) 0 + 0);
195
uint_fast32_t f3[2] = { 17, UINT_FAST32_MAX };
196
verify (TYPE_MAXIMUM (uint_fast32_t) == UINT_FAST32_MAX);
197
verify_same_types (UINT_FAST32_MAX, (uint_fast32_t) 0 + 0);
199
#ifdef UINT_FAST64_MAX
200
uint_fast64_t f4[2] = { 17, UINT_FAST64_MAX };
201
verify (TYPE_MAXIMUM (uint_fast64_t) == UINT_FAST64_MAX);
202
verify_same_types (UINT_FAST64_MAX, (uint_fast64_t) 0 + 0);
205
#if INT_FAST8_MIN && INT_FAST8_MAX && INT_FAST16_MIN && INT_FAST16_MAX && INT_FAST32_MIN && INT_FAST32_MAX
211
#if UINT_FAST8_MAX && UINT_FAST16_MAX && UINT_FAST32_MAX
217
/* 7.18.1.4. Integer types capable of holding object pointers */
218
/* 7.18.2.4. Limits of integer types capable of holding object pointers */
220
intptr_t g[3] = { 17, INTPTR_MIN, INTPTR_MAX };
221
verify (TYPE_MINIMUM (intptr_t) == INTPTR_MIN);
222
verify (TYPE_MAXIMUM (intptr_t) == INTPTR_MAX);
223
verify_same_types (INTPTR_MIN, (intptr_t) 0 + 0);
224
verify_same_types (INTPTR_MAX, (intptr_t) 0 + 0);
226
uintptr_t h[2] = { 17, UINTPTR_MAX };
227
verify (TYPE_MAXIMUM (uintptr_t) == UINTPTR_MAX);
228
verify_same_types (UINTPTR_MAX, (uintptr_t) 0 + 0);
230
#if INTPTR_MIN && INTPTR_MAX && UINTPTR_MAX
236
/* 7.18.1.5. Greatest-width integer types */
237
/* 7.18.2.5. Limits of greatest-width integer types */
239
intmax_t i[3] = { INTMAX_C (17), INTMAX_MIN, INTMAX_MAX };
240
verify (TYPE_MINIMUM (intmax_t) == INTMAX_MIN);
241
verify (TYPE_MAXIMUM (intmax_t) == INTMAX_MAX);
242
verify_same_types (INTMAX_MIN, (intmax_t) 0 + 0);
243
verify_same_types (INTMAX_MAX, (intmax_t) 0 + 0);
245
uintmax_t j[2] = { UINTMAX_C (17), UINTMAX_MAX };
246
verify (TYPE_MAXIMUM (uintmax_t) == UINTMAX_MAX);
247
verify_same_types (UINTMAX_MAX, (uintmax_t) 0 + 0);
249
/* As of 2007, Sun C and HP-UX 10.20 cc don't support 'long long' constants in
251
#if !(defined __SUNPRO_C || (defined __hpux && !defined __GNUC__))
252
#if INTMAX_MIN && INTMAX_MAX && UINTMAX_MAX
259
/* 7.18.3. Limits of other integer types */
263
verify (TYPE_MINIMUM (ptrdiff_t) == PTRDIFF_MIN);
264
verify (TYPE_MAXIMUM (ptrdiff_t) == PTRDIFF_MAX);
265
verify_same_types (PTRDIFF_MIN, (ptrdiff_t) 0 + 0);
266
verify_same_types (PTRDIFF_MAX, (ptrdiff_t) 0 + 0);
268
#if PTRDIFF_MIN && PTRDIFF_MAX
276
verify (TYPE_MINIMUM (sig_atomic_t) == SIG_ATOMIC_MIN);
277
verify (TYPE_MAXIMUM (sig_atomic_t) == SIG_ATOMIC_MAX);
278
verify_same_types (SIG_ATOMIC_MIN, (sig_atomic_t) 0 + 0);
279
verify_same_types (SIG_ATOMIC_MAX, (sig_atomic_t) 0 + 0);
281
#if SIG_ATOMIC_MIN != 17 && SIG_ATOMIC_MAX
287
verify (TYPE_MAXIMUM (size_t) == SIZE_MAX);
288
verify_same_types (SIZE_MAX, (size_t) 0 + 0);
297
verify (TYPE_MINIMUM (wchar_t) == WCHAR_MIN);
298
verify (TYPE_MAXIMUM (wchar_t) == WCHAR_MAX);
299
verify_same_types (WCHAR_MIN, (wchar_t) 0 + 0);
300
verify_same_types (WCHAR_MAX, (wchar_t) 0 + 0);
302
# if WCHAR_MIN != 17 && WCHAR_MAX
312
verify (TYPE_MINIMUM (wint_t) == WINT_MIN);
313
verify (TYPE_MAXIMUM (wint_t) == WINT_MAX);
314
verify_same_types (WINT_MIN, (wint_t) 0 + 0);
315
verify_same_types (WINT_MAX, (wint_t) 0 + 0);
317
# if WINT_MIN != 17 && WINT_MAX
324
/* 7.18.4. Macros for integer constants */
326
verify (INT8_C (17) == 17);
327
verify_same_types (INT8_C (17), (int_least8_t)0 + 0);
328
verify (UINT8_C (17) == 17);
329
verify_same_types (UINT8_C (17), (uint_least8_t)0 + 0);
331
verify (INT16_C (17) == 17);
332
verify_same_types (INT16_C (17), (int_least16_t)0 + 0);
333
verify (UINT16_C (17) == 17);
334
verify_same_types (UINT16_C (17), (uint_least16_t)0 + 0);
336
verify (INT32_C (17) == 17);
337
verify_same_types (INT32_C (17), (int_least32_t)0 + 0);
338
verify (UINT32_C (17) == 17);
339
verify_same_types (UINT32_C (17), (uint_least32_t)0 + 0);
342
verify (INT64_C (17) == 17);
343
verify_same_types (INT64_C (17), (int_least64_t)0 + 0);
346
verify (UINT64_C (17) == 17);
347
verify_same_types (UINT64_C (17), (uint_least64_t)0 + 0);
350
verify (INTMAX_C (17) == 17);
351
verify_same_types (INTMAX_C (17), (intmax_t)0 + 0);
352
verify (UINTMAX_C (17) == 17);
353
verify_same_types (UINTMAX_C (17), (uintmax_t)0 + 0);
added
removed
gltests/test-stdint.c
