1 /* test cases for integer comparison transformations
2 * compile with -DINT_TYPE="signed char"
3 * or -DINT_TYPE="short"
4 * or -DINT_TYPE="int"
5 * or -DINT_TYPE="long"
6 * or -DINT_TYPE="long long"
7 */
8
9 #include <assert.h>
10
main()11 int main() {
12
13 volatile INT_TYPE a, b;
14 /* different values */
15 a = -21;
16 b = -2; /* signs equal */
17 assert((a < b));
18 assert((a <= b));
19 assert(!(a > b));
20 assert(!(a >= b));
21 assert((a != b));
22 assert(!(a == b));
23
24 a = 1;
25 b = 8; /* signs equal */
26 assert((a < b));
27 assert((a <= b));
28 assert(!(a > b));
29 assert(!(a >= b));
30 assert((a != b));
31 assert(!(a == b));
32
33 if ((unsigned)(INT_TYPE)(~0) > 255) { /* short or bigger */
34 volatile short a, b;
35 a = 2;
36 b = 256 + 1; /* signs equal */
37 assert((a < b));
38 assert((a <= b));
39 assert(!(a > b));
40 assert(!(a >= b));
41 assert((a != b));
42 assert(!(a == b));
43
44 a = -1 - 256;
45 b = -8; /* signs equal */
46 assert((a < b));
47 assert((a <= b));
48 assert(!(a > b));
49 assert(!(a >= b));
50 assert((a != b));
51 assert(!(a == b));
52
53 if ((unsigned)(INT_TYPE)(~0) > 65535) { /* int or bigger */
54 volatile int a, b;
55 a = 2;
56 b = 65536 + 1; /* signs equal */
57 assert((a < b));
58 assert((a <= b));
59 assert(!(a > b));
60 assert(!(a >= b));
61 assert((a != b));
62 assert(!(a == b));
63
64 a = -1 - 65536;
65 b = -8; /* signs equal */
66 assert((a < b));
67 assert((a <= b));
68 assert(!(a > b));
69 assert(!(a >= b));
70 assert((a != b));
71 assert(!(a == b));
72
73 if ((unsigned)(INT_TYPE)(~0) > 4294967295) { /* long or bigger */
74 volatile long a, b;
75 a = 2;
76 b = 4294967296 + 1; /* signs equal */
77 assert((a < b));
78 assert((a <= b));
79 assert(!(a > b));
80 assert(!(a >= b));
81 assert((a != b));
82 assert(!(a == b));
83
84 a = -1 - 4294967296;
85 b = -8; /* signs equal */
86 assert((a < b));
87 assert((a <= b));
88 assert(!(a > b));
89 assert(!(a >= b));
90 assert((a != b));
91 assert(!(a == b));
92
93 }
94
95 }
96
97 }
98
99 a = -1;
100 b = 1; /* signs differ */
101 assert((a < b));
102 assert((a <= b));
103 assert(!(a > b));
104 assert(!(a >= b));
105 assert((a != b));
106 assert(!(a == b));
107
108 a = -1;
109 b = 0; /* signs differ */
110 assert((a < b));
111 assert((a <= b));
112 assert(!(a > b));
113 assert(!(a >= b));
114 assert((a != b));
115 assert(!(a == b));
116
117 a = -2;
118 b = 8; /* signs differ */
119 assert((a < b));
120 assert((a <= b));
121 assert(!(a > b));
122 assert(!(a >= b));
123 assert((a != b));
124 assert(!(a == b));
125
126 a = -1;
127 b = -2; /* signs equal */
128 assert((a > b));
129 assert((a >= b));
130 assert(!(a < b));
131 assert(!(a <= b));
132 assert((a != b));
133 assert(!(a == b));
134
135 a = 8;
136 b = 1; /* signs equal */
137 assert((a > b));
138 assert((a >= b));
139 assert(!(a < b));
140 assert(!(a <= b));
141 assert((a != b));
142 assert(!(a == b));
143
144 if ((unsigned)(INT_TYPE)(~0) > 255) {
145
146 volatile short a, b;
147 a = 1 + 256;
148 b = 3; /* signs equal */
149 assert((a > b));
150 assert((a >= b));
151 assert(!(a < b));
152 assert(!(a <= b));
153 assert((a != b));
154 assert(!(a == b));
155
156 a = -1;
157 b = -256; /* signs equal */
158 assert((a > b));
159 assert((a >= b));
160 assert(!(a < b));
161 assert(!(a <= b));
162 assert((a != b));
163 assert(!(a == b));
164
165 if ((unsigned)(INT_TYPE)(~0) > 65535) {
166
167 volatile int a, b;
168 a = 1 + 65536;
169 b = 3; /* signs equal */
170 assert((a > b));
171 assert((a >= b));
172 assert(!(a < b));
173 assert(!(a <= b));
174 assert((a != b));
175 assert(!(a == b));
176
177 a = -1;
178 b = -65536; /* signs equal */
179 assert((a > b));
180 assert((a >= b));
181 assert(!(a < b));
182 assert(!(a <= b));
183 assert((a != b));
184 assert(!(a == b));
185
186 if ((unsigned)(INT_TYPE)(~0) > 4294967295) {
187
188 volatile long a, b;
189 a = 1 + 4294967296;
190 b = 3; /* signs equal */
191 assert((a > b));
192 assert((a >= b));
193 assert(!(a < b));
194 assert(!(a <= b));
195 assert((a != b));
196 assert(!(a == b));
197
198 a = -1;
199 b = -4294967296; /* signs equal */
200 assert((a > b));
201 assert((a >= b));
202 assert(!(a < b));
203 assert(!(a <= b));
204 assert((a != b));
205 assert(!(a == b));
206
207 }
208
209 }
210
211 }
212
213 a = 1;
214 b = -1; /* signs differ */
215 assert((a > b));
216 assert((a >= b));
217 assert(!(a < b));
218 assert(!(a <= b));
219 assert((a != b));
220 assert(!(a == b));
221
222 a = 0;
223 b = -1; /* signs differ */
224 assert((a > b));
225 assert((a >= b));
226 assert(!(a < b));
227 assert(!(a <= b));
228 assert((a != b));
229 assert(!(a == b));
230
231 a = 8;
232 b = -2; /* signs differ */
233 assert((a > b));
234 assert((a >= b));
235 assert(!(a < b));
236 assert(!(a <= b));
237 assert((a != b));
238 assert(!(a == b));
239
240 a = 1;
241 b = -2; /* signs differ */
242 assert((a > b));
243 assert((a >= b));
244 assert(!(a < b));
245 assert(!(a <= b));
246 assert((a != b));
247 assert(!(a == b));
248
249 if ((unsigned)(INT_TYPE)(~0) > 255) {
250
251 volatile short a, b;
252 a = 1 + 256;
253 b = -2; /* signs differ */
254 assert((a > b));
255 assert((a >= b));
256 assert(!(a < b));
257 assert(!(a <= b));
258 assert((a != b));
259 assert(!(a == b));
260
261 a = -1;
262 b = -2 - 256; /* signs differ */
263 assert((a > b));
264 assert((a >= b));
265 assert(!(a < b));
266 assert(!(a <= b));
267 assert((a != b));
268 assert(!(a == b));
269
270 if ((unsigned)(INT_TYPE)(~0) > 65535) {
271
272 volatile int a, b;
273 a = 1 + 65536;
274 b = -2; /* signs differ */
275 assert((a > b));
276 assert((a >= b));
277 assert(!(a < b));
278 assert(!(a <= b));
279 assert((a != b));
280 assert(!(a == b));
281
282 a = -1;
283 b = -2 - 65536; /* signs differ */
284 assert((a > b));
285 assert((a >= b));
286 assert(!(a < b));
287 assert(!(a <= b));
288 assert((a != b));
289 assert(!(a == b));
290
291 if ((unsigned)(INT_TYPE)(~0) > 4294967295) {
292
293 volatile long a, b;
294 a = 1 + 4294967296;
295 b = -2; /* signs differ */
296 assert((a > b));
297 assert((a >= b));
298 assert(!(a < b));
299 assert(!(a <= b));
300 assert((a != b));
301 assert(!(a == b));
302
303 a = -1;
304 b = -2 - 4294967296; /* signs differ */
305 assert((a > b));
306 assert((a >= b));
307 assert(!(a < b));
308 assert(!(a <= b));
309 assert((a != b));
310 assert(!(a == b));
311
312 }
313
314 }
315
316 }
317
318 /* equal values */
319 a = 0;
320 b = 0;
321 assert(!(a < b));
322 assert((a <= b));
323 assert(!(a > b));
324 assert((a >= b));
325 assert(!(a != b));
326 assert((a == b));
327
328 a = -0;
329 b = 0;
330 assert(!(a < b));
331 assert((a <= b));
332 assert(!(a > b));
333 assert((a >= b));
334 assert(!(a != b));
335 assert((a == b));
336
337 a = 1;
338 b = 1;
339 assert(!(a < b));
340 assert((a <= b));
341 assert(!(a > b));
342 assert((a >= b));
343 assert(!(a != b));
344 assert((a == b));
345
346 a = 5;
347 b = 5;
348 assert(!(a < b));
349 assert((a <= b));
350 assert(!(a > b));
351 assert((a >= b));
352 assert(!(a != b));
353 assert((a == b));
354
355 a = -1;
356 b = -1;
357 assert(!(a < b));
358 assert((a <= b));
359 assert(!(a > b));
360 assert((a >= b));
361 assert(!(a != b));
362 assert((a == b));
363
364 a = -5;
365 b = -5;
366 assert(!(a < b));
367 assert((a <= b));
368 assert(!(a > b));
369 assert((a >= b));
370 assert(!(a != b));
371 assert((a == b));
372
373 if ((unsigned)(INT_TYPE)(~0) > 255) {
374
375 volatile short a, b;
376 a = 1 + 256;
377 b = 1 + 256;
378 assert(!(a < b));
379 assert((a <= b));
380 assert(!(a > b));
381 assert((a >= b));
382 assert(!(a != b));
383 assert((a == b));
384
385 a = -2 - 256;
386 b = -2 - 256;
387 assert(!(a < b));
388 assert((a <= b));
389 assert(!(a > b));
390 assert((a >= b));
391 assert(!(a != b));
392 assert((a == b));
393
394 if ((unsigned)(INT_TYPE)(~0) > 65535) {
395
396 volatile int a, b;
397 a = 1 + 65536;
398 b = 1 + 65536;
399 assert(!(a < b));
400 assert((a <= b));
401 assert(!(a > b));
402 assert((a >= b));
403 assert(!(a != b));
404 assert((a == b));
405
406 a = -2 - 65536;
407 b = -2 - 65536;
408 assert(!(a < b));
409 assert((a <= b));
410 assert(!(a > b));
411 assert((a >= b));
412 assert(!(a != b));
413 assert((a == b));
414
415 if ((unsigned)(INT_TYPE)(~0) > 4294967295) {
416
417 volatile long a, b;
418 a = 1 + 4294967296;
419 b = 1 + 4294967296;
420 assert(!(a < b));
421 assert((a <= b));
422 assert(!(a > b));
423 assert((a >= b));
424 assert(!(a != b));
425 assert((a == b));
426
427 a = -2 - 4294967296;
428 b = -2 - 4294967296;
429 assert(!(a < b));
430 assert((a <= b));
431 assert(!(a > b));
432 assert((a >= b));
433 assert(!(a != b));
434 assert((a == b));
435
436 }
437
438 }
439
440 }
441
442 }
443
444