1 #include "test.h"
2 #include <stdio.h>
3 #include <stdlib.h>
4
5
test_rshift16_var(void)6 void test_rshift16_var(void)
7 {
8 int val = 0x8000;
9 int v = 0;
10
11 // RHS is folded by compiler
12 Assert( val >> v == 0x8000 >> 0, ">>0");
13 ++v;
14 Assert( val >> v == 0x8000 >> 1, ">>1");
15 ++v;
16 Assert( val >> v == 0x8000 >> 2, ">>2");
17 ++v;
18 Assert( val >> v == 0x8000 >> 3, ">>3");
19 ++v;
20 Assert( val >> v == 0x8000 >> 4, ">>4");
21 ++v;
22 Assert( val >> v == 0x8000 >> 5, ">>5");
23 ++v;
24 Assert( val >> v == 0x8000 >> 6, ">>6");
25 ++v;
26 Assert( val >> v == 0x8000 >> 7, ">>7");
27 ++v;
28 Assert( val >> v == 0x8000 >> 8, ">>8");
29 ++v;
30 Assert( val >> v == 0x8000 >> 9, ">>9");
31 ++v;
32 Assert( val >> v == 0x8000 >> 10, ">>10");
33 ++v;
34 Assert( val >> v == 0x8000 >> 11, ">>11");
35 ++v;
36 Assert( val >> v == 0x8000 >> 12, ">>12");
37 ++v;
38 Assert( val >> v == 0x8000 >> 13, ">>13");
39 ++v;
40 Assert( val >> v == 0x8000 >> 14, ">>14");
41 ++v;
42 Assert( val >> v == 0x8000 >> 15, ">>15");
43 ++v;
44 // Assert( val >> v == 0x8000 >> 16, ">>16"); // Undefined
45 ++v;
46 // Assert( val >> v == 0x8000 >> 17, ">>17"); // Undefined
47 }
48
test_rshift32_var(void)49 void test_rshift32_var(void)
50 {
51 long val = 0x80000000L;
52 int v = 0;
53
54 // RHS is folded by compiler
55 Assert( val >> v == 0x80000000L >> 0, ">>0");
56 ++v;
57 Assert( val >> v == 0x80000000L >> 1, ">>1");
58 ++v;
59 Assert( val >> v == 0x80000000L >> 2, ">>2");
60 ++v;
61 Assert( val >> v == 0x80000000L >> 3, ">>3");
62 ++v;
63 Assert( val >> v == 0x80000000L >> 4, ">>4");
64 ++v;
65 Assert( val >> v == 0x80000000L >> 5, ">>5");
66 ++v;
67 Assert( val >> v == 0x80000000L >> 6, ">>6");
68 ++v;
69 Assert( val >> v == 0x80000000L >> 7, ">>7");
70 ++v;
71 Assert( val >> v == 0x80000000L >> 8, ">>8");
72 ++v;
73 Assert( val >> v == 0x80000000L >> 9, ">>9");
74 ++v;
75 Assert( val >> v == 0x80000000L >> 10, ">>10");
76 ++v;
77 Assert( val >> v == 0x80000000L >> 11, ">>11");
78 ++v;
79 Assert( val >> v == 0x80000000L >> 12, ">>12");
80 ++v;
81 Assert( val >> v == 0x80000000L >> 13, ">>13");
82 ++v;
83 Assert( val >> v == 0x80000000L >> 14, ">>14");
84 ++v;
85 Assert( val >> v == 0x80000000L >> 15, ">>15");
86 ++v;
87 Assert( val >> v == 0x80000000L >> 16, ">>16");
88 ++v;
89 Assert( val >> v == 0x80000000L >> 17, ">>17");
90 ++v;
91 Assert( val >> v == 0x80000000L >> 18, ">>18");
92 ++v;
93 Assert( val >> v == 0x80000000L >> 19, ">>19");
94 ++v;
95 Assert( val >> v == 0x80000000L >> 20, ">>20");
96 ++v;
97 Assert( val >> v == 0x80000000L >> 21, ">>21");
98 ++v;
99 Assert( val >> v == 0x80000000L >> 22, ">>22");
100 ++v;
101 Assert( val >> v == 0x80000000L >> 23, ">>23");
102 ++v;
103 Assert( val >> v == 0x80000000L >> 24, ">>24");
104 ++v;
105 Assert( val >> v == 0x80000000L >> 25, ">>25");
106 ++v;
107 Assert( val >> v == 0x80000000L >> 26, ">>26");
108 ++v;
109 Assert( val >> v == 0x80000000L >> 27, ">>27");
110 ++v;
111 Assert( val >> v == 0x80000000L >> 28, ">>28");
112 ++v;
113 Assert( val >> v == 0x80000000L >> 29, ">>29");
114 ++v;
115 Assert( val >> v == 0x80000000L >> 30, ">>30");
116 ++v;
117 Assert( val >> v == 0x80000000L >> 31, ">>31");
118 ++v;
119 // Assert( val >> v == 0x80000000L >> 32, ">>32"); // Undefined behaviour
120 ++v;
121 // Assert( val >> v == 0x80000000L >> 33, ">>33"); // Undefined, but it should match
122 }
123
test_rshift8_const(void)124 void test_rshift8_const(void)
125 {
126 unsigned char val = 0x80;
127
128 // RHS is folded by compiler
129 Assert( val >> 0 == 0x80 >> 0, ">>0");
130 Assert( val >> 1 == 0x80 >> 1, ">>1");
131 Assert( val >> 2 == 0x80 >> 2, ">>2");
132 Assert( val >> 3 == 0x80 >> 3, ">>3");
133 Assert( val >> 4 == 0x80 >> 4, ">>4");
134 Assert( val >> 5 == 0x80 >> 5, ">>5");
135 Assert( val >> 6 == 0x80 >> 6, ">>6");
136 Assert( val >> 7 == 0x80 >> 7, ">>7");
137 Assert( val >> 8 == 0x80 >> 8, ">>8");
138 }
139
test_rshift16_const(void)140 void test_rshift16_const(void)
141 {
142 int val = 0x8000;
143
144 // RHS is folded by compiler
145 Assert( val >> 0 == 0x8000 >> 0, ">>0");
146 Assert( val >> 1 == 0x8000 >> 1, ">>1");
147 Assert( val >> 2 == 0x8000 >> 2, ">>2");
148 Assert( val >> 3 == 0x8000 >> 3, ">>3");
149 Assert( val >> 4 == 0x8000 >> 4, ">>4");
150 Assert( val >> 5 == 0x8000 >> 5, ">>5");
151 Assert( val >> 6 == 0x8000 >> 6, ">>6");
152 Assert( val >> 7 == 0x8000 >> 7, ">>7");
153 Assert( val >> 8 == 0x8000 >> 8, ">>8");
154 Assert( val >> 9 == 0x8000 >> 9, ">>9");
155 Assert( val >> 10 == 0x8000 >> 10, ">>10");
156 Assert( val >> 11 == 0x8000 >> 11, ">>11");
157 Assert( val >> 12 == 0x8000 >> 12, ">>12");
158 Assert( val >> 13 == 0x8000 >> 13, ">>13");
159 Assert( val >> 14 == 0x8000 >> 14, ">>14");
160 Assert( val >> 15 == 0x8000 >> 15, ">>15");
161 // Assert( val >> 16 == 0x8000 >> 16, ">>16"); // Undefined
162 // Assert( val >> 17 == 0x8000 >> 17, ">>17"); // Undefined
163 }
164
test_rshift32_const(void)165 void test_rshift32_const(void)
166 {
167 long val = 0x80000000;
168
169 // RHS is folded by compiler
170 Assert( val >> 0 == 0x80000000L >> 0, ">>0");
171 Assert( val >> 1 == 0x80000000L >> 1, ">>1");
172 Assert( val >> 2 == 0x80000000L >> 2, ">>2");
173 Assert( val >> 3 == 0x80000000L >> 3, ">>3");
174 Assert( val >> 4 == 0x80000000L >> 4, ">>4");
175 Assert( val >> 5 == 0x80000000L >> 5, ">>5");
176 Assert( val >> 6 == 0x80000000L >> 6, ">>6");
177 Assert( val >> 7 == 0x80000000L >> 7, ">>7");
178 Assert( val >> 8 == 0x80000000L >> 8, ">>8");
179 Assert( val >> 9 == 0x80000000L >> 9, ">>9");
180 Assert( val >> 10 == 0x80000000L >> 10, ">>10");
181 Assert( val >> 11 == 0x80000000L >> 11, ">>11");
182 Assert( val >> 12 == 0x80000000L >> 12, ">>12");
183 Assert( val >> 13 == 0x80000000L >> 13, ">>13");
184 Assert( val >> 14 == 0x80000000L >> 14, ">>14");
185 Assert( val >> 15 == 0x80000000L >> 15, ">>15");
186 Assert( val >> 16 == 0x80000000L >> 16, ">>16");
187 Assert( val >> 17 == 0x80000000L >> 17, ">>17");
188 Assert( val >> 18 == 0x80000000L >> 18, ">>18");
189 Assert( val >> 19 == 0x80000000L >> 19, ">>19");
190 Assert( val >> 20 == 0x80000000L >> 20, ">>20");
191 Assert( val >> 21 == 0x80000000L >> 21, ">>21");
192 Assert( val >> 22 == 0x80000000L >> 22, ">>22");
193 Assert( val >> 23 == 0x80000000L >> 23, ">>23");
194 Assert( val >> 24 == 0x80000000L >> 24, ">>24");
195 Assert( val >> 25 == 0x80000000L >> 25, ">>25");
196 Assert( val >> 26 == 0x80000000L >> 26, ">>26");
197 Assert( val >> 27 == 0x80000000L >> 27, ">>27");
198 Assert( val >> 28 == 0x80000000L >> 28, ">>28");
199 Assert( val >> 29 == 0x80000000L >> 29, ">>29");
200 Assert( val >> 30 == 0x80000000L >> 30, ">>30");
201 Assert( val >> 31 == 0x80000000L >> 31, ">>31");
202 // Assert( val >> 32 == 0x80000000L >> 32, ">>32"); // Undefined behaviour
203 // Assert( val >> 33 == 0x80000000L >> 33, ">>33"); // Undefined, but it should match
204 }
205
test_rshift32_const_unsigned(void)206 void test_rshift32_const_unsigned(void)
207 {
208 unsigned long val = 0x80000000;
209
210 // RHS is folded by compiler
211 Assert( val >> 0 == 0x80000000UL >> 0, ">>0");
212 Assert( val >> 1 == 0x80000000UL >> 1, ">>1");
213 Assert( val >> 2 == 0x80000000UL >> 2, ">>2");
214 Assert( val >> 3 == 0x80000000UL >> 3, ">>3");
215 Assert( val >> 4 == 0x80000000UL >> 4, ">>4");
216 Assert( val >> 5 == 0x80000000UL >> 5, ">>5");
217 Assert( val >> 6 == 0x80000000UL >> 6, ">>6");
218 Assert( val >> 7 == 0x80000000UL >> 7, ">>7");
219 Assert( val >> 8 == 0x80000000UL >> 8, ">>8");
220 Assert( val >> 9 == 0x80000000UL >> 9, ">>9");
221 Assert( val >> 10 == 0x80000000UL >> 10, ">>10");
222 Assert( val >> 11 == 0x80000000UL >> 11, ">>11");
223 Assert( val >> 12 == 0x80000000UL >> 12, ">>12");
224 Assert( val >> 13 == 0x80000000UL >> 13, ">>13");
225 Assert( val >> 14 == 0x80000000UL >> 14, ">>14");
226 Assert( val >> 15 == 0x80000000UL >> 15, ">>15");
227 Assert( val >> 16 == 0x80000000UL >> 16, ">>16");
228 Assert( val >> 17 == 0x80000000UL >> 17, ">>17");
229 Assert( val >> 18 == 0x80000000UL >> 18, ">>18");
230 Assert( val >> 19 == 0x80000000UL >> 19, ">>19");
231 Assert( val >> 20 == 0x80000000UL >> 20, ">>20");
232 Assert( val >> 21 == 0x80000000UL >> 21, ">>21");
233 Assert( val >> 22 == 0x80000000UL >> 22, ">>22");
234 Assert( val >> 23 == 0x80000000UL >> 23, ">>23");
235 Assert( val >> 24 == 0x80000000UL >> 24, ">>24");
236 Assert( val >> 25 == 0x80000000UL >> 25, ">>25");
237 Assert( val >> 26 == 0x80000000UL >> 26, ">>26");
238 Assert( val >> 27 == 0x80000000UL >> 27, ">>27");
239 Assert( val >> 28 == 0x80000000UL >> 28, ">>28");
240 Assert( val >> 29 == 0x80000000UL >> 29, ">>29");
241 Assert( val >> 30 == 0x80000000UL >> 30, ">>30");
242 Assert( val >> 31 == 0x80000000UL >> 31, ">>31");
243 // Assert( val >> 32 == 0x80000000UL >> 32, ">>32"); // Undefined behaviour
244 // Assert( val >> 33 == 0x80000000UL >> 33, ">>33"); // Undefined, but it should match
245 }
246
247
248 #ifndef __8080__
249 #ifndef __GBZ80__
test_rshift64_var(void)250 void test_rshift64_var(void)
251 {
252 long long val = 0x8000000000000000LL;
253 int v = 0;
254
255 // RHS is folded by compiler
256 Assert( val >> v == 0x8000000000000000LL >> 0, ">>0");
257 ++v;
258 Assert( val >> v == 0x8000000000000000LL >> 1, ">>1");
259 ++v;
260 Assert( val >> v == 0x8000000000000000LL >> 2, ">>2");
261 ++v;
262 Assert( val >> v == 0x8000000000000000LL >> 3, ">>3");
263 ++v;
264 Assert( val >> v == 0x8000000000000000LL >> 4, ">>4");
265 ++v;
266 Assert( val >> v == 0x8000000000000000LL >> 5, ">>5");
267 ++v;
268 Assert( val >> v == 0x8000000000000000LL >> 6, ">>6");
269 ++v;
270 Assert( val >> v == 0x8000000000000000LL >> 7, ">>7");
271 ++v;
272 Assert( val >> v == 0x8000000000000000LL >> 8, ">>8");
273 ++v;
274 Assert( val >> v == 0x8000000000000000LL >> 9, ">>9");
275 ++v;
276 Assert( val >> v == 0x8000000000000000LL >> 10, ">>10");
277 ++v;
278 Assert( val >> v == 0x8000000000000000LL >> 11, ">>11");
279 ++v;
280 Assert( val >> v == 0x8000000000000000LL >> 12, ">>12");
281 ++v;
282 Assert( val >> v == 0x8000000000000000LL >> 13, ">>13");
283 ++v;
284 Assert( val >> v == 0x8000000000000000LL >> 14, ">>14");
285 ++v;
286 Assert( val >> v == 0x8000000000000000LL >> 15, ">>15");
287 ++v;
288 Assert( val >> v == 0x8000000000000000LL >> 16, ">>16");
289 ++v;
290 Assert( val >> v == 0x8000000000000000LL >> 17, ">>17");
291 ++v;
292 Assert( val >> v == 0x8000000000000000LL >> 18, ">>18");
293 ++v;
294 Assert( val >> v == 0x8000000000000000LL >> 19, ">>19");
295 ++v;
296 Assert( val >> v == 0x8000000000000000LL >> 20, ">>20");
297 ++v;
298 Assert( val >> v == 0x8000000000000000LL >> 21, ">>21");
299 ++v;
300 Assert( val >> v == 0x8000000000000000LL >> 22, ">>22");
301 ++v;
302 Assert( val >> v == 0x8000000000000000LL >> 23, ">>23");
303 ++v;
304 Assert( val >> v == 0x8000000000000000LL >> 24, ">>24");
305 ++v;
306 Assert( val >> v == 0x8000000000000000LL >> 25, ">>25");
307 ++v;
308 Assert( val >> v == 0x8000000000000000LL >> 26, ">>26");
309 ++v;
310 Assert( val >> v == 0x8000000000000000LL >> 27, ">>27");
311 ++v;
312 Assert( val >> v == 0x8000000000000000LL >> 28, ">>28");
313 ++v;
314 Assert( val >> v == 0x8000000000000000LL >> 29, ">>29");
315 ++v;
316 Assert( val >> v == 0x8000000000000000LL >> 30, ">>30");
317 ++v;
318 Assert( val >> v == 0x8000000000000000LL >> 31, ">>31");
319 ++v;
320 Assert( val >> v == 0x8000000000000000LL >> 32, ">>32");
321 ++v;
322 Assert( val >> v == 0x8000000000000000LL >> 33, ">>33");
323 ++v;
324 Assert( val >> v == 0x8000000000000000LL >> 34, ">>34");
325 ++v;
326 Assert( val >> v == 0x8000000000000000LL >> 35, ">>35");
327 ++v;
328 Assert( val >> v == 0x8000000000000000LL >> 36, ">>36");
329 ++v;
330 Assert( val >> v == 0x8000000000000000LL >> 37, ">>37");
331 ++v;
332 Assert( val >> v == 0x8000000000000000LL >> 38, ">>38");
333 ++v;
334 Assert( val >> v == 0x8000000000000000LL >> 39, ">>39");
335 ++v;
336 Assert( val >> v == 0x8000000000000000LL >> 40, ">>40");
337 ++v;
338 Assert( val >> v == 0x8000000000000000LL >> 41, ">>41");
339 ++v;
340 Assert( val >> v == 0x8000000000000000LL >> 42, ">>42");
341 ++v;
342 Assert( val >> v == 0x8000000000000000LL >> 43, ">>43");
343 ++v;
344 Assert( val >> v == 0x8000000000000000LL >> 44, ">>44");
345 ++v;
346 Assert( val >> v == 0x8000000000000000LL >> 45, ">>45");
347 ++v;
348 Assert( val >> v == 0x8000000000000000LL >> 46, ">>46");
349 ++v;
350 Assert( val >> v == 0x8000000000000000LL >> 47, ">>47");
351 ++v;
352 Assert( val >> v == 0x8000000000000000LL >> 48, ">>48");
353 ++v;
354 Assert( val >> v == 0x8000000000000000LL >> 49, ">>49");
355 ++v;
356 Assert( val >> v == 0x8000000000000000LL >> 50, ">>50");
357 ++v;
358 Assert( val >> v == 0x8000000000000000LL >> 51, ">>51");
359 ++v;
360 Assert( val >> v == 0x8000000000000000LL >> 52, ">>52");
361 ++v;
362 Assert( val >> v == 0x8000000000000000LL >> 53, ">>53");
363 ++v;
364 Assert( val >> v == 0x8000000000000000LL >> 54, ">>54");
365 ++v;
366 Assert( val >> v == 0x8000000000000000LL >> 55, ">>55");
367 ++v;
368 Assert( val >> v == 0x8000000000000000LL >> 56, ">>56");
369 ++v;
370 Assert( val >> v == 0x8000000000000000LL >> 57, ">>57");
371 ++v;
372 Assert( val >> v == 0x8000000000000000LL >> 58, ">>58");
373 ++v;
374 Assert( val >> v == 0x8000000000000000LL >> 59, ">>59");
375 ++v;
376 Assert( val >> v == 0x8000000000000000LL >> 60, ">>60");
377 ++v;
378 Assert( val >> v == 0x8000000000000000LL >> 61, ">>61");
379 ++v;
380 Assert( val >> v == 0x8000000000000000LL >> 62, ">>62");
381 ++v;
382 Assert( val >> v == 0x8000000000000000LL >> 63, ">>63");
383 }
384
385
test_rshift64_const(void)386 void test_rshift64_const(void)
387 {
388 long long val = 0x8000000000000000LL;
389
390 // RHS is folded by compiler
391 Assert( val >> 0 == 0x8000000000000000LL >> 0, ">>0");
392 Assert( val >> 1 == 0x8000000000000000LL >> 1, ">>1");
393 Assert( val >> 2 == 0x8000000000000000LL >> 2, ">>2");
394 Assert( val >> 3 == 0x8000000000000000LL >> 3, ">>3");
395 Assert( val >> 4 == 0x8000000000000000LL >> 4, ">>4");
396 Assert( val >> 5 == 0x8000000000000000LL >> 5, ">>5");
397 Assert( val >> 6 == 0x8000000000000000LL >> 6, ">>6");
398 Assert( val >> 7 == 0x8000000000000000LL >> 7, ">>7");
399 Assert( val >> 8 == 0x8000000000000000LL >> 8, ">>8");
400 Assert( val >> 9 == 0x8000000000000000LL >> 9, ">>9");
401 Assert( val >> 10 == 0x8000000000000000LL >> 10, ">>10");
402 Assert( val >> 11 == 0x8000000000000000LL >> 11, ">>11");
403 Assert( val >> 12 == 0x8000000000000000LL >> 12, ">>12");
404 Assert( val >> 13 == 0x8000000000000000LL >> 13, ">>13");
405 Assert( val >> 14 == 0x8000000000000000LL >> 14, ">>14");
406 Assert( val >> 15 == 0x8000000000000000LL >> 15, ">>15");
407 Assert( val >> 16 == 0x8000000000000000LL >> 16, ">>16");
408 Assert( val >> 17 == 0x8000000000000000LL >> 17, ">>17");
409 Assert( val >> 18 == 0x8000000000000000LL >> 18, ">>18");
410 Assert( val >> 19 == 0x8000000000000000LL >> 19, ">>19");
411 Assert( val >> 20 == 0x8000000000000000LL >> 20, ">>20");
412 Assert( val >> 21 == 0x8000000000000000LL >> 21, ">>21");
413 Assert( val >> 22 == 0x8000000000000000LL >> 22, ">>22");
414 Assert( val >> 23 == 0x8000000000000000LL >> 23, ">>23");
415 Assert( val >> 24 == 0x8000000000000000LL >> 24, ">>24");
416 Assert( val >> 25 == 0x8000000000000000LL >> 25, ">>25");
417 Assert( val >> 26 == 0x8000000000000000LL >> 26, ">>26");
418 Assert( val >> 27 == 0x8000000000000000LL >> 27, ">>27");
419 Assert( val >> 28 == 0x8000000000000000LL >> 28, ">>28");
420 Assert( val >> 29 == 0x8000000000000000LL >> 29, ">>29");
421 Assert( val >> 30 == 0x8000000000000000LL >> 30, ">>30");
422 Assert( val >> 31 == 0x8000000000000000LL >> 31, ">>31");
423 Assert( val >> 32 == 0x8000000000000000LL >> 32, ">>32");
424 Assert( val >> 33 == 0x8000000000000000LL >> 33, ">>33");
425 Assert( val >> 34 == 0x8000000000000000LL >> 34, ">>34");
426 Assert( val >> 35 == 0x8000000000000000LL >> 35, ">>35");
427 Assert( val >> 36 == 0x8000000000000000LL >> 36, ">>36");
428 Assert( val >> 37 == 0x8000000000000000LL >> 37, ">>37");
429 Assert( val >> 38 == 0x8000000000000000LL >> 38, ">>38");
430 Assert( val >> 39 == 0x8000000000000000LL >> 39, ">>39");
431 Assert( val >> 40 == 0x8000000000000000LL >> 40, ">>40");
432 Assert( val >> 41 == 0x8000000000000000LL >> 41, ">>41");
433 Assert( val >> 42 == 0x8000000000000000LL >> 42, ">>42");
434 Assert( val >> 43 == 0x8000000000000000LL >> 43, ">>43");
435 Assert( val >> 44 == 0x8000000000000000LL >> 44, ">>44");
436 Assert( val >> 45 == 0x8000000000000000LL >> 45, ">>45");
437 Assert( val >> 46 == 0x8000000000000000LL >> 46, ">>46");
438 Assert( val >> 47 == 0x8000000000000000LL >> 47, ">>47");
439 Assert( val >> 48 == 0x8000000000000000LL >> 48, ">>48");
440 Assert( val >> 49 == 0x8000000000000000LL >> 49, ">>49");
441 Assert( val >> 50 == 0x8000000000000000LL >> 50, ">>50");
442 Assert( val >> 51 == 0x8000000000000000LL >> 51, ">>51");
443 Assert( val >> 52 == 0x8000000000000000LL >> 52, ">>52");
444 Assert( val >> 53 == 0x8000000000000000LL >> 53, ">>53");
445 Assert( val >> 54 == 0x8000000000000000LL >> 54, ">>54");
446 Assert( val >> 55 == 0x8000000000000000LL >> 55, ">>55");
447 Assert( val >> 56 == 0x8000000000000000LL >> 56, ">>56");
448 Assert( val >> 57 == 0x8000000000000000LL >> 57, ">>57");
449 Assert( val >> 58 == 0x8000000000000000LL >> 58, ">>58");
450 Assert( val >> 59 == 0x8000000000000000LL >> 59, ">>59");
451 Assert( val >> 60 == 0x8000000000000000LL >> 60, ">>60");
452 Assert( val >> 61 == 0x8000000000000000LL >> 61, ">>61");
453 Assert( val >> 62 == 0x8000000000000000LL >> 62, ">>62");
454 Assert( val >> 63 == 0x8000000000000000LL >> 63, ">>63");
455 }
456
test_rshift64_const_unsigned(void)457 void test_rshift64_const_unsigned(void)
458 {
459 unsigned long long val = 0x8000000000000000ULL;
460
461 // RHS is folded by compiler
462 Assert( val >> 0 == 0x8000000000000000ULL >> 0, ">>0");
463 Assert( val >> 1 == 0x8000000000000000ULL >> 1, ">>1");
464 Assert( val >> 2 == 0x8000000000000000ULL >> 2, ">>2");
465 Assert( val >> 3 == 0x8000000000000000ULL >> 3, ">>3");
466 Assert( val >> 4 == 0x8000000000000000ULL >> 4, ">>4");
467 Assert( val >> 5 == 0x8000000000000000ULL >> 5, ">>5");
468 Assert( val >> 6 == 0x8000000000000000ULL >> 6, ">>6");
469 Assert( val >> 7 == 0x8000000000000000ULL >> 7, ">>7");
470 Assert( val >> 8 == 0x8000000000000000ULL >> 8, ">>8");
471 Assert( val >> 9 == 0x8000000000000000ULL >> 9, ">>9");
472 Assert( val >> 10 == 0x8000000000000000ULL >> 10, ">>10");
473 Assert( val >> 11 == 0x8000000000000000ULL >> 11, ">>11");
474 Assert( val >> 12 == 0x8000000000000000ULL >> 12, ">>12");
475 Assert( val >> 13 == 0x8000000000000000ULL >> 13, ">>13");
476 Assert( val >> 14 == 0x8000000000000000ULL >> 14, ">>14");
477 Assert( val >> 15 == 0x8000000000000000ULL >> 15, ">>15");
478 Assert( val >> 16 == 0x8000000000000000ULL >> 16, ">>16");
479 Assert( val >> 17 == 0x8000000000000000ULL >> 17, ">>17");
480 Assert( val >> 18 == 0x8000000000000000ULL >> 18, ">>18");
481 Assert( val >> 19 == 0x8000000000000000ULL >> 19, ">>19");
482 Assert( val >> 20 == 0x8000000000000000ULL >> 20, ">>20");
483 Assert( val >> 21 == 0x8000000000000000ULL >> 21, ">>21");
484 Assert( val >> 22 == 0x8000000000000000ULL >> 22, ">>22");
485 Assert( val >> 23 == 0x8000000000000000ULL >> 23, ">>23");
486 Assert( val >> 24 == 0x8000000000000000ULL >> 24, ">>24");
487 Assert( val >> 25 == 0x8000000000000000ULL >> 25, ">>25");
488 Assert( val >> 26 == 0x8000000000000000ULL >> 26, ">>26");
489 Assert( val >> 27 == 0x8000000000000000ULL >> 27, ">>27");
490 Assert( val >> 28 == 0x8000000000000000ULL >> 28, ">>28");
491 Assert( val >> 29 == 0x8000000000000000ULL >> 29, ">>29");
492 Assert( val >> 30 == 0x8000000000000000ULL >> 30, ">>30");
493 Assert( val >> 31 == 0x8000000000000000ULL >> 31, ">>31");
494 Assert( val >> 32 == 0x8000000000000000ULL >> 32, ">>32");
495 Assert( val >> 33 == 0x8000000000000000ULL >> 33, ">>33");
496 Assert( val >> 34 == 0x8000000000000000ULL >> 34, ">>34");
497 Assert( val >> 35 == 0x8000000000000000ULL >> 35, ">>35");
498 Assert( val >> 36 == 0x8000000000000000ULL >> 36, ">>36");
499 Assert( val >> 37 == 0x8000000000000000ULL >> 37, ">>37");
500 Assert( val >> 38 == 0x8000000000000000ULL >> 38, ">>38");
501 Assert( val >> 39 == 0x8000000000000000ULL >> 39, ">>39");
502 Assert( val >> 40 == 0x8000000000000000ULL >> 40, ">>40");
503 Assert( val >> 41 == 0x8000000000000000ULL >> 41, ">>41");
504 Assert( val >> 42 == 0x8000000000000000ULL >> 42, ">>42");
505 Assert( val >> 43 == 0x8000000000000000ULL >> 43, ">>43");
506 Assert( val >> 44 == 0x8000000000000000ULL >> 44, ">>44");
507 Assert( val >> 45 == 0x8000000000000000ULL >> 45, ">>45");
508 Assert( val >> 46 == 0x8000000000000000ULL >> 46, ">>46");
509 Assert( val >> 47 == 0x8000000000000000ULL >> 47, ">>47");
510 Assert( val >> 48 == 0x8000000000000000ULL >> 48, ">>48");
511 Assert( val >> 49 == 0x8000000000000000ULL >> 49, ">>49");
512 Assert( val >> 50 == 0x8000000000000000ULL >> 50, ">>50");
513 Assert( val >> 51 == 0x8000000000000000ULL >> 51, ">>51");
514 Assert( val >> 52 == 0x8000000000000000ULL >> 52, ">>52");
515 Assert( val >> 53 == 0x8000000000000000ULL >> 53, ">>53");
516 Assert( val >> 54 == 0x8000000000000000ULL >> 54, ">>54");
517 Assert( val >> 55 == 0x8000000000000000ULL >> 55, ">>55");
518 Assert( val >> 56 == 0x8000000000000000ULL >> 56, ">>56");
519 Assert( val >> 57 == 0x8000000000000000ULL >> 57, ">>57");
520 Assert( val >> 58 == 0x8000000000000000ULL >> 58, ">>58");
521 Assert( val >> 59 == 0x8000000000000000ULL >> 59, ">>59");
522 Assert( val >> 60 == 0x8000000000000000ULL >> 60, ">>60");
523 Assert( val >> 61 == 0x8000000000000000ULL >> 61, ">>61");
524 Assert( val >> 62 == 0x8000000000000000ULL >> 62, ">>62");
525 Assert( val >> 63 == 0x8000000000000000ULL >> 63, ">>63");
526 }
527 #endif
528 #endif
529
suite_rshift()530 int suite_rshift()
531 {
532 suite_setup("Right shift Tests");
533
534 #ifndef __8080__
535 #ifndef __GBZ80__
536 suite_add_test(test_rshift64_const);
537 suite_add_test(test_rshift64_const_unsigned);
538 suite_add_test(test_rshift64_var);
539 #endif
540 #endif
541
542 suite_add_test(test_rshift32_const);
543 suite_add_test(test_rshift32_const_unsigned);
544 suite_add_test(test_rshift32_var);
545 suite_add_test(test_rshift16_const);
546 suite_add_test(test_rshift16_var);
547 suite_add_test(test_rshift8_const);
548
549 return suite_run();
550 }
551
552
main(int argc,char * argv[])553 int main(int argc, char *argv[])
554 {
555 int res = 0;
556
557 res += suite_rshift();
558
559 exit(res);
560 }
561