|
14741
|
1 /* Test intprops.h. |
|
|
2 Copyright (C) 2011 Free Software Foundation, Inc. |
|
|
3 |
|
|
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. |
|
|
8 |
|
|
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. |
|
|
13 |
|
|
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/>. */ |
|
|
16 |
|
|
17 /* Written by Paul Eggert. */ |
|
|
18 |
|
|
19 #include <config.h> |
|
|
20 |
|
|
21 #include "intprops.h" |
|
|
22 #include "verify.h" |
|
|
23 |
|
|
24 #include <stdbool.h> |
|
|
25 #include <inttypes.h> |
|
|
26 |
|
|
27 /* TYPE_IS_INTEGER. */ |
|
|
28 verify (TYPE_IS_INTEGER (bool)); |
|
|
29 verify (TYPE_IS_INTEGER (char)); |
|
|
30 verify (TYPE_IS_INTEGER (signed char)); |
|
|
31 verify (TYPE_IS_INTEGER (unsigned char)); |
|
|
32 verify (TYPE_IS_INTEGER (short int)); |
|
|
33 verify (TYPE_IS_INTEGER (unsigned short int)); |
|
|
34 verify (TYPE_IS_INTEGER (int)); |
|
|
35 verify (TYPE_IS_INTEGER (unsigned int)); |
|
|
36 verify (TYPE_IS_INTEGER (long int)); |
|
|
37 verify (TYPE_IS_INTEGER (unsigned long int)); |
|
|
38 verify (TYPE_IS_INTEGER (intmax_t)); |
|
|
39 verify (TYPE_IS_INTEGER (uintmax_t)); |
|
|
40 verify (! TYPE_IS_INTEGER (float)); |
|
|
41 verify (! TYPE_IS_INTEGER (double)); |
|
|
42 verify (! TYPE_IS_INTEGER (long double)); |
|
|
43 |
|
|
44 /* Integer representation. */ |
|
|
45 verify (INT_MIN + INT_MAX < 0 |
|
|
46 ? (TYPE_TWOS_COMPLEMENT (int) |
|
|
47 && ! TYPE_ONES_COMPLEMENT (int) && ! TYPE_SIGNED_MAGNITUDE (int)) |
|
|
48 : (! TYPE_TWOS_COMPLEMENT (int) |
|
|
49 && (TYPE_ONES_COMPLEMENT (int) || TYPE_SIGNED_MAGNITUDE (int)))); |
|
|
50 |
|
|
51 /* TYPE_SIGNED. */ |
|
|
52 /* verify (! TYPE_SIGNED (bool)); */ /* not guaranteed by gnulib substitute */ |
|
|
53 verify (TYPE_SIGNED (signed char)); |
|
|
54 verify (! TYPE_SIGNED (unsigned char)); |
|
|
55 verify (TYPE_SIGNED (short int)); |
|
|
56 verify (! TYPE_SIGNED (unsigned short int)); |
|
|
57 verify (TYPE_SIGNED (int)); |
|
|
58 verify (! TYPE_SIGNED (unsigned int)); |
|
|
59 verify (TYPE_SIGNED (long int)); |
|
|
60 verify (! TYPE_SIGNED (unsigned long int)); |
|
|
61 verify (TYPE_SIGNED (intmax_t)); |
|
|
62 verify (! TYPE_SIGNED (uintmax_t)); |
|
|
63 verify (TYPE_SIGNED (float)); |
|
|
64 verify (TYPE_SIGNED (double)); |
|
|
65 verify (TYPE_SIGNED (long double)); |
|
|
66 |
|
|
67 /* TYPE_MINIMUM, TYPE_MAXIMUM. */ |
|
|
68 verify (TYPE_MINIMUM (char) == CHAR_MIN); |
|
|
69 verify (TYPE_MAXIMUM (char) == CHAR_MAX); |
|
|
70 verify (TYPE_MINIMUM (unsigned char) == 0); |
|
|
71 verify (TYPE_MAXIMUM (unsigned char) == UCHAR_MAX); |
|
|
72 verify (TYPE_MINIMUM (signed char) == SCHAR_MIN); |
|
|
73 verify (TYPE_MAXIMUM (signed char) == SCHAR_MAX); |
|
|
74 verify (TYPE_MINIMUM (short int) == SHRT_MIN); |
|
|
75 verify (TYPE_MAXIMUM (short int) == SHRT_MAX); |
|
|
76 verify (TYPE_MINIMUM (unsigned short int) == 0); |
|
|
77 verify (TYPE_MAXIMUM (unsigned short int) == USHRT_MAX); |
|
|
78 verify (TYPE_MINIMUM (int) == INT_MIN); |
|
|
79 verify (TYPE_MAXIMUM (int) == INT_MAX); |
|
|
80 verify (TYPE_MINIMUM (unsigned int) == 0); |
|
|
81 verify (TYPE_MAXIMUM (unsigned int) == UINT_MAX); |
|
|
82 verify (TYPE_MINIMUM (long int) == LONG_MIN); |
|
|
83 verify (TYPE_MAXIMUM (long int) == LONG_MAX); |
|
|
84 verify (TYPE_MINIMUM (unsigned long int) == 0); |
|
|
85 verify (TYPE_MAXIMUM (unsigned long int) == ULONG_MAX); |
|
|
86 verify (TYPE_MINIMUM (intmax_t) == INTMAX_MIN); |
|
|
87 verify (TYPE_MAXIMUM (intmax_t) == INTMAX_MAX); |
|
|
88 verify (TYPE_MINIMUM (uintmax_t) == 0); |
|
|
89 verify (TYPE_MAXIMUM (uintmax_t) == UINTMAX_MAX); |
|
|
90 |
|
|
91 /* INT_BITS_STRLEN_BOUND. */ |
|
|
92 verify (INT_BITS_STRLEN_BOUND (1) == 1); |
|
|
93 verify (INT_BITS_STRLEN_BOUND (2620) == 789); |
|
|
94 |
|
|
95 /* INT_STRLEN_BOUND, INT_BUFSIZE_BOUND. */ |
|
|
96 #ifdef INT32_MAX /* POSIX guarantees int32_t; this ports to non-POSIX hosts */ |
|
|
97 verify (INT_STRLEN_BOUND (int32_t) == sizeof ("-2147483648") - 1); |
|
|
98 verify (INT_BUFSIZE_BOUND (int32_t) == sizeof ("-2147483648")); |
|
|
99 #endif |
|
|
100 #ifdef INT64_MAX |
|
|
101 verify (INT_STRLEN_BOUND (int64_t) == sizeof ("-9223372036854775808") - 1); |
|
|
102 verify (INT_BUFSIZE_BOUND (int64_t) == sizeof ("-9223372036854775808")); |
|
|
103 #endif |
|
|
104 |
|
|
105 /* All the INT_<op>_RANGE_OVERFLOW tests are equally valid as |
|
|
106 INT_<op>_OVERFLOW tests, so define a single macro to do both. */ |
|
|
107 #define check_binop(op, a, b, min, max, overflow) \ |
|
|
108 (INT_##op##_RANGE_OVERFLOW (a, b, min, max) == (overflow) \ |
|
|
109 && INT_##op##_OVERFLOW (a, b) == (overflow)) |
|
|
110 #define check_unop(op, a, min, max, overflow) \ |
|
|
111 (INT_##op##_RANGE_OVERFLOW (a, min, max) == (overflow) \ |
|
|
112 && INT_##op##_OVERFLOW (a) == (overflow)) |
|
|
113 |
|
|
114 /* INT_<op>_RANGE_OVERFLOW, INT_<op>_OVERFLOW. */ |
|
|
115 verify (INT_ADD_RANGE_OVERFLOW (INT_MAX, 1, INT_MIN, INT_MAX)); |
|
|
116 verify (INT_ADD_OVERFLOW (INT_MAX, 1)); |
|
|
117 verify (check_binop (ADD, INT_MAX, 1, INT_MIN, INT_MAX, true)); |
|
|
118 verify (check_binop (ADD, INT_MAX, -1, INT_MIN, INT_MAX, false)); |
|
|
119 verify (check_binop (ADD, INT_MIN, 1, INT_MIN, INT_MAX, false)); |
|
|
120 verify (check_binop (ADD, INT_MIN, -1, INT_MIN, INT_MAX, true)); |
|
|
121 verify (check_binop (ADD, UINT_MAX, 1u, 0u, UINT_MAX, true)); |
|
|
122 verify (check_binop (ADD, 0u, 1u, 0u, UINT_MAX, false)); |
|
|
123 |
|
|
124 verify (check_binop (SUBTRACT, INT_MAX, 1, INT_MIN, INT_MAX, false)); |
|
|
125 verify (check_binop (SUBTRACT, INT_MAX, -1, INT_MIN, INT_MAX, true)); |
|
|
126 verify (check_binop (SUBTRACT, INT_MIN, 1, INT_MIN, INT_MAX, true)); |
|
|
127 verify (check_binop (SUBTRACT, INT_MIN, -1, INT_MIN, INT_MAX, false)); |
|
|
128 verify (check_binop (SUBTRACT, UINT_MAX, 1u, 0u, UINT_MAX, false)); |
|
|
129 verify (check_binop (SUBTRACT, 0u, 1u, 0u, UINT_MAX, true)); |
|
|
130 |
|
|
131 verify (check_unop (NEGATE, INT_MIN, INT_MIN, INT_MAX, |
|
|
132 TYPE_TWOS_COMPLEMENT (int))); |
|
|
133 verify (check_unop (NEGATE, 0, INT_MIN, INT_MAX, false)); |
|
|
134 verify (check_unop (NEGATE, INT_MAX, INT_MIN, INT_MAX, false)); |
|
|
135 verify (check_unop (NEGATE, 0u, 0u, UINT_MAX, false)); |
|
|
136 verify (check_unop (NEGATE, 1u, 0u, UINT_MAX, true)); |
|
|
137 verify (check_unop (NEGATE, UINT_MAX, 0u, UINT_MAX, true)); |
|
|
138 |
|
|
139 verify (check_binop (MULTIPLY, INT_MAX, INT_MAX, INT_MIN, INT_MAX, true)); |
|
|
140 verify (check_binop (MULTIPLY, INT_MAX, INT_MIN, INT_MIN, INT_MAX, true)); |
|
|
141 verify (check_binop (MULTIPLY, INT_MIN, INT_MAX, INT_MIN, INT_MAX, true)); |
|
|
142 verify (check_binop (MULTIPLY, INT_MIN, INT_MIN, INT_MIN, INT_MAX, true)); |
|
|
143 verify (check_binop (MULTIPLY, -1, INT_MIN, INT_MIN, INT_MAX, |
|
|
144 INT_NEGATE_OVERFLOW (INT_MIN))); |
|
|
145 verify (check_binop (MULTIPLY, LONG_MIN / INT_MAX, (long int) INT_MAX, |
|
|
146 LONG_MIN, LONG_MIN, false)); |
|
|
147 |
|
|
148 verify (check_binop (DIVIDE, INT_MIN, -1, INT_MIN, INT_MAX, |
|
|
149 INT_NEGATE_OVERFLOW (INT_MIN))); |
|
|
150 verify (check_binop (DIVIDE, INT_MAX, 1, INT_MIN, INT_MAX, false)); |
|
|
151 verify (check_binop (DIVIDE, (unsigned int) INT_MIN, |
|
|
152 -1u, 0u, UINT_MAX, false)); |
|
|
153 |
|
|
154 verify (check_binop (REMAINDER, INT_MIN, -1, INT_MIN, INT_MAX, |
|
|
155 INT_NEGATE_OVERFLOW (INT_MIN))); |
|
|
156 verify (check_binop (REMAINDER, INT_MAX, 1, INT_MIN, INT_MAX, false)); |
|
|
157 verify (check_binop (REMAINDER, (unsigned int) INT_MIN, |
|
|
158 -1u, 0u, UINT_MAX, false)); |
|
|
159 |
|
|
160 verify (check_binop (LEFT_SHIFT, UINT_MAX, 1, 0u, UINT_MAX, true)); |
|
|
161 verify (check_binop (LEFT_SHIFT, UINT_MAX / 2 + 1, 1, 0u, UINT_MAX, true)); |
|
|
162 verify (check_binop (LEFT_SHIFT, UINT_MAX / 2, 1, 0u, UINT_MAX, false)); |
|
|
163 |
|
|
164 /* INT_<op>_OVERFLOW with mixed types. */ |
|
|
165 #define check_sum(a, b, overflow) \ |
|
|
166 verify (INT_ADD_OVERFLOW (a, b) == (overflow)); \ |
|
|
167 verify (INT_ADD_OVERFLOW (b, a) == (overflow)) |
|
|
168 check_sum (-1, LONG_MIN, true); |
|
|
169 check_sum (-1, UINT_MAX, false); |
|
|
170 check_sum (-1L, INT_MIN, INT_MIN == LONG_MIN); |
|
|
171 check_sum (0u, -1, true); |
|
|
172 check_sum (0u, 0, false); |
|
|
173 check_sum (0u, 1, false); |
|
|
174 check_sum (1, LONG_MAX, true); |
|
|
175 check_sum (1, UINT_MAX, true); |
|
|
176 check_sum (1L, INT_MAX, INT_MAX == LONG_MAX); |
|
|
177 check_sum (1u, INT_MAX, INT_MAX == UINT_MAX); |
|
|
178 check_sum (1u, INT_MIN, true); |
|
|
179 |
|
|
180 verify (! INT_SUBTRACT_OVERFLOW (INT_MAX, 1u)); |
|
|
181 verify (! INT_SUBTRACT_OVERFLOW (UINT_MAX, 1)); |
|
|
182 verify (! INT_SUBTRACT_OVERFLOW (0u, -1)); |
|
|
183 verify (INT_SUBTRACT_OVERFLOW (UINT_MAX, -1)); |
|
|
184 verify (INT_SUBTRACT_OVERFLOW (INT_MIN, 1u)); |
|
|
185 verify (INT_SUBTRACT_OVERFLOW (-1, 0u)); |
|
|
186 |
|
|
187 #define check_product(a, b, overflow) \ |
|
|
188 verify (INT_MULTIPLY_OVERFLOW (a, b) == (overflow)); \ |
|
|
189 verify (INT_MULTIPLY_OVERFLOW (b, a) == (overflow)) |
|
|
190 |
|
|
191 check_product (-1, 1u, true); |
|
|
192 check_product (-1, INT_MIN, INT_NEGATE_OVERFLOW (INT_MIN)); |
|
|
193 check_product (-1, UINT_MAX, true); |
|
|
194 check_product (-12345, LONG_MAX / -12345 - 1, true); |
|
|
195 check_product (-12345, LONG_MAX / -12345, false); |
|
|
196 check_product (0, -1, false); |
|
|
197 check_product (0, 0, false); |
|
|
198 check_product (0, 0u, false); |
|
|
199 check_product (0, 1, false); |
|
|
200 check_product (0, INT_MAX, false); |
|
|
201 check_product (0, INT_MIN, false); |
|
|
202 check_product (0, UINT_MAX, false); |
|
|
203 check_product (0u, -1, false); |
|
|
204 check_product (0u, 0, false); |
|
|
205 check_product (0u, 0u, false); |
|
|
206 check_product (0u, 1, false); |
|
|
207 check_product (0u, INT_MAX, false); |
|
|
208 check_product (0u, INT_MIN, false); |
|
|
209 check_product (0u, UINT_MAX, false); |
|
|
210 check_product (1, INT_MAX, false); |
|
|
211 check_product (1, INT_MIN, false); |
|
|
212 check_product (1, UINT_MAX, false); |
|
|
213 check_product (1u, INT_MIN, true); |
|
|
214 check_product (1u, INT_MAX, UINT_MAX < INT_MAX); |
|
|
215 check_product (INT_MAX, UINT_MAX, true); |
|
|
216 check_product (INT_MAX, ULONG_MAX, true); |
|
|
217 check_product (INT_MIN, LONG_MAX / INT_MIN - 1, true); |
|
|
218 check_product (INT_MIN, LONG_MAX / INT_MIN, false); |
|
|
219 check_product (INT_MIN, UINT_MAX, true); |
|
|
220 check_product (INT_MIN, ULONG_MAX, true); |
|
|
221 |
|
|
222 verify (INT_DIVIDE_OVERFLOW (INT_MIN, -1L) |
|
|
223 == (TYPE_TWOS_COMPLEMENT (long int) && INT_MIN == LONG_MIN)); |
|
|
224 verify (! INT_DIVIDE_OVERFLOW (INT_MIN, UINT_MAX)); |
|
|
225 verify (! INT_DIVIDE_OVERFLOW (INTMAX_MIN, UINTMAX_MAX)); |
|
|
226 verify (! INT_DIVIDE_OVERFLOW (INTMAX_MIN, UINT_MAX)); |
|
|
227 verify (INT_DIVIDE_OVERFLOW (-11, 10u)); |
|
|
228 verify (INT_DIVIDE_OVERFLOW (-10, 10u)); |
|
|
229 verify (! INT_DIVIDE_OVERFLOW (-9, 10u)); |
|
|
230 verify (INT_DIVIDE_OVERFLOW (11u, -10)); |
|
|
231 verify (INT_DIVIDE_OVERFLOW (10u, -10)); |
|
|
232 verify (! INT_DIVIDE_OVERFLOW (9u, -10)); |
|
|
233 |
|
|
234 verify (INT_REMAINDER_OVERFLOW (INT_MIN, -1L) |
|
|
235 == (TYPE_TWOS_COMPLEMENT (long int) && INT_MIN == LONG_MIN)); |
|
|
236 verify (INT_REMAINDER_OVERFLOW (-1, UINT_MAX)); |
|
|
237 verify (INT_REMAINDER_OVERFLOW ((intmax_t) -1, UINTMAX_MAX)); |
|
|
238 verify (INT_REMAINDER_OVERFLOW (INTMAX_MIN, UINT_MAX) |
|
|
239 == (INTMAX_MAX < UINT_MAX |
|
|
240 && - (unsigned int) INTMAX_MIN % UINT_MAX != 0)); |
|
|
241 verify (INT_REMAINDER_OVERFLOW (INT_MIN, ULONG_MAX) |
|
|
242 == (INT_MIN % ULONG_MAX != 1)); |
|
|
243 verify (! INT_REMAINDER_OVERFLOW (1u, -1)); |
|
|
244 verify (! INT_REMAINDER_OVERFLOW (37*39u, -39)); |
|
|
245 verify (INT_REMAINDER_OVERFLOW (37*39u + 1, -39)); |
|
|
246 verify (INT_REMAINDER_OVERFLOW (37*39u - 1, -39)); |
|
|
247 verify (! INT_REMAINDER_OVERFLOW (LONG_MAX, -INT_MAX)); |
|
|
248 |
|
|
249 int |
|
|
250 main (void) |
|
|
251 { |
|
|
252 return 0; |
|
|
253 } |
