OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libstdc++-v3/] [testsuite/] [decimal/] [comparison.cc] - Blame information for rev 818

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 742 jeremybenn 
// Copyright (C) 2009 Free Software Foundation, Inc.
2 
//
3 
// This file is part of the GNU ISO C++ Library.  This library is free
4 
// software; you can redistribute it and/or modify it under the
5 
// terms of the GNU General Public License as published by the
6 
// Free Software Foundation; either version 3, or (at your option)
7 
// any later version.
8 
 
9 
// This library 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 along
15 
// with this library; see the file COPYING3.  If not see
16 
// <http://www.gnu.org/licenses/>.
17 
 
18 
// { dg-require-effective-target dfp }
19 
 
20 
// ISO/IEC TR 24733  3.2.9  Comparison operators.
21 
 
22 
#include <decimal/decimal>
23 
#include <testsuite_hooks.h>
24 
 
25 
using namespace std::decimal;
26 
 
27 
decimal32 d32 (5);
28 
decimal64 d64 (-10);
29 
decimal128 d128 (25);
30 
int si = -20;
31 
unsigned int ui = 50;
32 
long sl = -10;
33 
unsigned long ul = 20;
34 
long long sll = -25;
35 
unsigned long long ull = 50;
36 
 
37 
void
38 
compare_eq_32 (void)
39 
{
40 
  decimal32 a;
41 
 
42 
  a = si;   VERIFY (a == si);   VERIFY (si == a);
43 
  a = ui;   VERIFY (a == ui);   VERIFY (ui == a);
44 
  a = sl;   VERIFY (a == sl);   VERIFY (sl == a);
45 
  a = ul;   VERIFY (a == ul);   VERIFY (ul == a);
46 
  a = sll;  VERIFY (a == sll);  VERIFY (sll == a);
47 
  a = ull;  VERIFY (a == ull);  VERIFY (ull == a);
48 
  a = d32;  VERIFY (a == d32);  VERIFY (d32 == a);
49 
  a = (decimal32)d64;  VERIFY (a == d64);  VERIFY (d64 == a);
50 
  a = (decimal32)d128; VERIFY (a == d128); VERIFY (d128 == a);
51 
}
52 
 
53 
void
54 
compare_ne_32 (void)
55 
{
56 
  decimal32 a = 100;
57 
 
58 
  VERIFY (a != si);   VERIFY (si != a);
59 
  VERIFY (a != ui);   VERIFY (ui != a);
60 
  VERIFY (a != sl);   VERIFY (sl != a);
61 
  VERIFY (a != ul);   VERIFY (ul != a);
62 
  VERIFY (a != sll);  VERIFY (sll != a);
63 
  VERIFY (a != ull);  VERIFY (ull != a);
64 
  VERIFY (a != d32);  VERIFY (d32 != a);
65 
  VERIFY (a != d64);  VERIFY (d64 != a);
66 
  VERIFY (a != d128); VERIFY (d128 != a);
67 
}
68 
 
69 
void
70 
compare_lt_32 (void)
71 
{
72 
  decimal32 a = -100;
73 
 
74 
  VERIFY (a < si);
75 
  VERIFY (a < ui);
76 
  VERIFY (a < sl);
77 
  VERIFY (a < ul);
78 
  VERIFY (a < sll);
79 
  VERIFY (a < ull);
80 
  VERIFY (a < d32);
81 
  VERIFY (a < d64);
82 
  VERIFY (a < d128);
83 
 
84 
  a = 100;
85 
  VERIFY (si < a);
86 
  VERIFY (ui < a);
87 
  VERIFY (sl < a);
88 
  VERIFY (ul < a);
89 
  VERIFY (sll < a);
90 
  VERIFY (ull < a);
91 
  VERIFY (d32 < a);
92 
  VERIFY (d64 < a);
93 
  VERIFY (d128 < a);
94 
}
95 
 
96 
void
97 
compare_le_32 (void)
98 
{
99 
  decimal32 a;
100 
 
101 
  a = si;   VERIFY (a <= si);   VERIFY (si <= a);
102 
  a = ui;   VERIFY (a <= ui);   VERIFY (ui <= a);
103 
  a = sl;   VERIFY (a <= sl);   VERIFY (sl <= a);
104 
  a = ul;   VERIFY (a <= ul);   VERIFY (ul <= a);
105 
  a = sll;  VERIFY (a <= sll);  VERIFY (sll <= a);
106 
  a = ull;  VERIFY (a <= ull);  VERIFY (ull <= a);
107 
  a = d32;  VERIFY (a <= d32);  VERIFY (d32 <= a);
108 
  a = (decimal32)d64;  VERIFY (a <= d64);  VERIFY (d64 <= a);
109 
  a = (decimal32)d128; VERIFY (a <= d128); VERIFY (d128 <= a);
110 
 
111 
  a = -100;
112 
  VERIFY (a <= si);
113 
  VERIFY (a <= ui);
114 
  VERIFY (a <= sl);
115 
  VERIFY (a <= ul);
116 
  VERIFY (a <= sll);
117 
  VERIFY (a <= ull);
118 
  VERIFY (a <= d32);
119 
  VERIFY (a <= d64);
120 
  VERIFY (a <= d128);
121 
 
122 
  a = 100;
123 
  VERIFY (si <= a);
124 
  VERIFY (ui <= a);
125 
  VERIFY (sl <= a);
126 
  VERIFY (ul <= a);
127 
  VERIFY (sll <= a);
128 
  VERIFY (ull <= a);
129 
  VERIFY (d32 <= a);
130 
  VERIFY (d64 <= a);
131 
  VERIFY (d128 <= a);
132 
}
133 
 
134 
void
135 
compare_gt_32 (void)
136 
{
137 
  decimal32 a = 100;
138 
 
139 
  VERIFY (a > si);
140 
  VERIFY (a > ui);
141 
  VERIFY (a > sl);
142 
  VERIFY (a > ul);
143 
  VERIFY (a > sll);
144 
  VERIFY (a > ull);
145 
  VERIFY (a > d32);
146 
  VERIFY (a > d64);
147 
  VERIFY (a > d128);
148 
 
149 
  a = -100;
150 
  VERIFY (si > a);
151 
  VERIFY (ui > a);
152 
  VERIFY (sl > a);
153 
  VERIFY (ul > a);
154 
  VERIFY (sll > a);
155 
  VERIFY (ull > a);
156 
  VERIFY (d32 > a);
157 
  VERIFY (d64 > a);
158 
  VERIFY (d128 > a);
159 
}
160 
 
161 
void
162 
compare_ge_32 (void)
163 
{
164 
  decimal32 a;
165 
 
166 
  a = si;   VERIFY (a >= si);   VERIFY (si <= a);
167 
  a = ui;   VERIFY (a >= ui);   VERIFY (ui <= a);
168 
  a = sl;   VERIFY (a >= sl);   VERIFY (sl <= a);
169 
  a = ul;   VERIFY (a >= ul);   VERIFY (ul <= a);
170 
  a = sll;  VERIFY (a >= sll);  VERIFY (sll <= a);
171 
  a = ull;  VERIFY (a >= ull);  VERIFY (ull <= a);
172 
  a = d32;  VERIFY (a >= d32);  VERIFY (d32 <= a);
173 
  a = (decimal32)d64;  VERIFY (a >= d64);  VERIFY (d64 <= a);
174 
  a = (decimal32)d128; VERIFY (a >= d128); VERIFY (d128 <= a);
175 
 
176 
  a = 100;
177 
  VERIFY (a >= si);
178 
  VERIFY (a >= ui);
179 
  VERIFY (a >= sl);
180 
  VERIFY (a >= ul);
181 
  VERIFY (a >= sll);
182 
  VERIFY (a >= ull);
183 
  VERIFY (a >= d32);
184 
  VERIFY (a >= d64);
185 
  VERIFY (a >= d128);
186 
 
187 
  a = -100;
188 
  VERIFY (si >= a);
189 
  VERIFY (ui >= a);
190 
  VERIFY (sl >= a);
191 
  VERIFY (ul >= a);
192 
  VERIFY (sll >= a);
193 
  VERIFY (ull >= a);
194 
  VERIFY (d32 >= a);
195 
  VERIFY (d64 >= a);
196 
  VERIFY (d128 >= a);
197 
}
198 
 
199 
void
200 
compare_eq_64 (void)
201 
{
202 
  decimal64 a;
203 
 
204 
  a = si;   VERIFY (a == si);   VERIFY (si == a);
205 
  a = ui;   VERIFY (a == ui);   VERIFY (ui == a);
206 
  a = sl;   VERIFY (a == sl);   VERIFY (sl == a);
207 
  a = ul;   VERIFY (a == ul);   VERIFY (ul == a);
208 
  a = sll;  VERIFY (a == sll);  VERIFY (sll == a);
209 
  a = ull;  VERIFY (a == ull);  VERIFY (ull == a);
210 
  a = d32;  VERIFY (a == d32);  VERIFY (d32 == a);
211 
  a = d64;  VERIFY (a == d64);  VERIFY (d64 == a);
212 
  a = (decimal64)d128; VERIFY (a == d128); VERIFY (d128 == a);
213 
}
214 
 
215 
void
216 
compare_ne_64 (void)
217 
{
218 
  decimal64 a = 100;
219 
 
220 
  VERIFY (a != si);   VERIFY (si != a);
221 
  VERIFY (a != ui);   VERIFY (ui != a);
222 
  VERIFY (a != sl);   VERIFY (sl != a);
223 
  VERIFY (a != ul);   VERIFY (ul != a);
224 
  VERIFY (a != sll);  VERIFY (sll != a);
225 
  VERIFY (a != ull);  VERIFY (ull != a);
226 
  VERIFY (a != d32);  VERIFY (d32 != a);
227 
  VERIFY (a != d64);  VERIFY (d64 != a);
228 
  VERIFY (a != d128); VERIFY (d128 != a);
229 
}
230 
 
231 
void
232 
compare_lt_64 (void)
233 
{
234 
  decimal64 a = -100;
235 
 
236 
  VERIFY (a < si);
237 
  VERIFY (a < ui);
238 
  VERIFY (a < sl);
239 
  VERIFY (a < ul);
240 
  VERIFY (a < sll);
241 
  VERIFY (a < ull);
242 
  VERIFY (a < d32);
243 
  VERIFY (a < d64);
244 
  VERIFY (a < d128);
245 
 
246 
  a = 100;
247 
  VERIFY (si < a);
248 
  VERIFY (ui < a);
249 
  VERIFY (sl < a);
250 
  VERIFY (ul < a);
251 
  VERIFY (sll < a);
252 
  VERIFY (ull < a);
253 
  VERIFY (d32 < a);
254 
  VERIFY (d64 < a);
255 
  VERIFY (d128 < a);
256 
}
257 
 
258 
void
259 
compare_le_64 (void)
260 
{
261 
  decimal64 a;
262 
 
263 
  a = si;   VERIFY (a <= si);   VERIFY (si <= a);
264 
  a = ui;   VERIFY (a <= ui);   VERIFY (ui <= a);
265 
  a = sl;   VERIFY (a <= sl);   VERIFY (sl <= a);
266 
  a = ul;   VERIFY (a <= ul);   VERIFY (ul <= a);
267 
  a = sll;  VERIFY (a <= sll);  VERIFY (sll <= a);
268 
  a = ull;  VERIFY (a <= ull);  VERIFY (ull <= a);
269 
  a = d32;  VERIFY (a <= d32);  VERIFY (d32 <= a);
270 
  a = (decimal32)d64;  VERIFY (a <= d64);  VERIFY (d64 <= a);
271 
  a = (decimal32)d128; VERIFY (a <= d128); VERIFY (d128 <= a);
272 
 
273 
  a = -100;
274 
  VERIFY (a <= si);
275 
  VERIFY (a <= ui);
276 
  VERIFY (a <= sl);
277 
  VERIFY (a <= ul);
278 
  VERIFY (a <= sll);
279 
  VERIFY (a <= ull);
280 
  VERIFY (a <= d32);
281 
  VERIFY (a <= d64);
282 
  VERIFY (a <= d128);
283 
 
284 
  a = 100;
285 
  VERIFY (si <= a);
286 
  VERIFY (ui <= a);
287 
  VERIFY (sl <= a);
288 
  VERIFY (ul <= a);
289 
  VERIFY (sll <= a);
290 
  VERIFY (ull <= a);
291 
  VERIFY (d32 <= a);
292 
  VERIFY (d64 <= a);
293 
  VERIFY (d128 <= a);
294 
}
295 
 
296 
void
297 
compare_gt_64 (void)
298 
{
299 
  decimal64 a = 100;
300 
 
301 
  VERIFY (a > si);
302 
  VERIFY (a > ui);
303 
  VERIFY (a > sl);
304 
  VERIFY (a > ul);
305 
  VERIFY (a > sll);
306 
  VERIFY (a > ull);
307 
  VERIFY (a > d32);
308 
  VERIFY (a > d64);
309 
  VERIFY (a > d128);
310 
 
311 
  a = -100;
312 
  VERIFY (si > a);
313 
  VERIFY (ui > a);
314 
  VERIFY (sl > a);
315 
  VERIFY (ul > a);
316 
  VERIFY (sll > a);
317 
  VERIFY (ull > a);
318 
  VERIFY (d32 > a);
319 
  VERIFY (d64 > a);
320 
  VERIFY (d128 > a);
321 
}
322 
 
323 
void
324 
compare_ge_64 (void)
325 
{
326 
  decimal64 a;
327 
 
328 
  a = si;   VERIFY (a >= si);   VERIFY (si <= a);
329 
  a = ui;   VERIFY (a >= ui);   VERIFY (ui <= a);
330 
  a = sl;   VERIFY (a >= sl);   VERIFY (sl <= a);
331 
  a = ul;   VERIFY (a >= ul);   VERIFY (ul <= a);
332 
  a = sll;  VERIFY (a >= sll);  VERIFY (sll <= a);
333 
  a = ull;  VERIFY (a >= ull);  VERIFY (ull <= a);
334 
  a = d32;  VERIFY (a >= d32);  VERIFY (d32 <= a);
335 
  a = (decimal32)d64;  VERIFY (a >= d64);  VERIFY (d64 <= a);
336 
  a = (decimal32)d128; VERIFY (a >= d128); VERIFY (d128 <= a);
337 
 
338 
  a = 100;
339 
  VERIFY (a >= si);
340 
  VERIFY (a >= ui);
341 
  VERIFY (a >= sl);
342 
  VERIFY (a >= ul);
343 
  VERIFY (a >= sll);
344 
  VERIFY (a >= ull);
345 
  VERIFY (a >= d32);
346 
  VERIFY (a >= d64);
347 
  VERIFY (a >= d128);
348 
 
349 
  a = -100;
350 
  VERIFY (si >= a);
351 
  VERIFY (ui >= a);
352 
  VERIFY (sl >= a);
353 
  VERIFY (ul >= a);
354 
  VERIFY (sll >= a);
355 
  VERIFY (ull >= a);
356 
  VERIFY (d32 >= a);
357 
  VERIFY (d64 >= a);
358 
  VERIFY (d128 >= a);
359 
}
360 
 
361 
void
362 
compare_eq_128 (void)
363 
{
364 
  decimal128 a;
365 
 
366 
  a = si;   VERIFY (a == si);   VERIFY (si == a);
367 
  a = ui;   VERIFY (a == ui);   VERIFY (ui == a);
368 
  a = sl;   VERIFY (a == sl);   VERIFY (sl == a);
369 
  a = ul;   VERIFY (a == ul);   VERIFY (ul == a);
370 
  a = sll;  VERIFY (a == sll);  VERIFY (sll == a);
371 
  a = ull;  VERIFY (a == ull);  VERIFY (ull == a);
372 
  a = d32;  VERIFY (a == d32);  VERIFY (d32 == a);
373 
  a = d64;  VERIFY (a == d64);  VERIFY (d64 == a);
374 
  a = d128; VERIFY (a == d128); VERIFY (d128 == a);
375 
}
376 
 
377 
void
378 
compare_ne_128 (void)
379 
{
380 
  decimal128 a = 100;
381 
 
382 
  VERIFY (a != si);   VERIFY (si != a);
383 
  VERIFY (a != ui);   VERIFY (ui != a);
384 
  VERIFY (a != sl);   VERIFY (sl != a);
385 
  VERIFY (a != ul);   VERIFY (ul != a);
386 
  VERIFY (a != sll);  VERIFY (sll != a);
387 
  VERIFY (a != ull);  VERIFY (ull != a);
388 
  VERIFY (a != d32);  VERIFY (d32 != a);
389 
  VERIFY (a != d64);  VERIFY (d64 != a);
390 
  VERIFY (a != d128); VERIFY (d128 != a);
391 
}
392 
 
393 
void
394 
compare_lt_128 (void)
395 
{
396 
  decimal128 a = -100;
397 
 
398 
  VERIFY (a < si);
399 
  VERIFY (a < ui);
400 
  VERIFY (a < sl);
401 
  VERIFY (a < ul);
402 
  VERIFY (a < sll);
403 
  VERIFY (a < ull);
404 
  VERIFY (a < d32);
405 
  VERIFY (a < d64);
406 
  VERIFY (a < d128);
407 
 
408 
  a = 100;
409 
  VERIFY (si < a);
410 
  VERIFY (ui < a);
411 
  VERIFY (sl < a);
412 
  VERIFY (ul < a);
413 
  VERIFY (sll < a);
414 
  VERIFY (ull < a);
415 
  VERIFY (d32 < a);
416 
  VERIFY (d64 < a);
417 
  VERIFY (d128 < a);
418 
}
419 
 
420 
void
421 
compare_le_128 (void)
422 
{
423 
  decimal128 a;
424 
 
425 
  a = si;   VERIFY (a <= si);   VERIFY (si <= a);
426 
  a = ui;   VERIFY (a <= ui);   VERIFY (ui <= a);
427 
  a = sl;   VERIFY (a <= sl);   VERIFY (sl <= a);
428 
  a = ul;   VERIFY (a <= ul);   VERIFY (ul <= a);
429 
  a = sll;  VERIFY (a <= sll);  VERIFY (sll <= a);
430 
  a = ull;  VERIFY (a <= ull);  VERIFY (ull <= a);
431 
  a = d32;  VERIFY (a <= d32);  VERIFY (d32 <= a);
432 
  a = (decimal32)d64;  VERIFY (a <= d64);  VERIFY (d64 <= a);
433 
  a = (decimal32)d128; VERIFY (a <= d128); VERIFY (d128 <= a);
434 
 
435 
  a = -100;
436 
  VERIFY (a <= si);
437 
  VERIFY (a <= ui);
438 
  VERIFY (a <= sl);
439 
  VERIFY (a <= ul);
440 
  VERIFY (a <= sll);
441 
  VERIFY (a <= ull);
442 
  VERIFY (a <= d32);
443 
  VERIFY (a <= d64);
444 
  VERIFY (a <= d128);
445 
 
446 
  a = 100;
447 
  VERIFY (si <= a);
448 
  VERIFY (ui <= a);
449 
  VERIFY (sl <= a);
450 
  VERIFY (ul <= a);
451 
  VERIFY (sll <= a);
452 
  VERIFY (ull <= a);
453 
  VERIFY (d32 <= a);
454 
  VERIFY (d64 <= a);
455 
  VERIFY (d128 <= a);
456 
}
457 
 
458 
void
459 
compare_gt_128 (void)
460 
{
461 
  decimal128 a = 100;
462 
 
463 
  VERIFY (a > si);
464 
  VERIFY (a > ui);
465 
  VERIFY (a > sl);
466 
  VERIFY (a > ul);
467 
  VERIFY (a > sll);
468 
  VERIFY (a > ull);
469 
  VERIFY (a > d32);
470 
  VERIFY (a > d64);
471 
  VERIFY (a > d128);
472 
 
473 
  a = -100;
474 
  VERIFY (si > a);
475 
  VERIFY (ui > a);
476 
  VERIFY (sl > a);
477 
  VERIFY (ul > a);
478 
  VERIFY (sll > a);
479 
  VERIFY (ull > a);
480 
  VERIFY (d32 > a);
481 
  VERIFY (d64 > a);
482 
  VERIFY (d128 > a);
483 
}
484 
 
485 
void
486 
compare_ge_128 (void)
487 
{
488 
  decimal128 a;
489 
 
490 
  a = si;   VERIFY (a >= si);   VERIFY (si <= a);
491 
  a = ui;   VERIFY (a >= ui);   VERIFY (ui <= a);
492 
  a = sl;   VERIFY (a >= sl);   VERIFY (sl <= a);
493 
  a = ul;   VERIFY (a >= ul);   VERIFY (ul <= a);
494 
  a = sll;  VERIFY (a >= sll);  VERIFY (sll <= a);
495 
  a = ull;  VERIFY (a >= ull);  VERIFY (ull <= a);
496 
  a = d32;  VERIFY (a >= d32);  VERIFY (d32 <= a);
497 
  a = (decimal32)d64;  VERIFY (a >= d64);  VERIFY (d64 <= a);
498 
  a = (decimal32)d128; VERIFY (a >= d128); VERIFY (d128 <= a);
499 
 
500 
  a = 100;
501 
  VERIFY (a >= si);
502 
  VERIFY (a >= ui);
503 
  VERIFY (a >= sl);
504 
  VERIFY (a >= ul);
505 
  VERIFY (a >= sll);
506 
  VERIFY (a >= ull);
507 
  VERIFY (a >= d32);
508 
  VERIFY (a >= d64);
509 
  VERIFY (a >= d128);
510 
 
511 
  a = -100;
512 
  VERIFY (si >= a);
513 
  VERIFY (ui >= a);
514 
  VERIFY (sl >= a);
515 
  VERIFY (ul >= a);
516 
  VERIFY (sll >= a);
517 
  VERIFY (ull >= a);
518 
  VERIFY (d32 >= a);
519 
  VERIFY (d64 >= a);
520 
  VERIFY (d128 >= a);
521 
}
522 
 
523 
int
524 
main ()
525 
{
526 
  compare_eq_32 ();
527 
  compare_ne_32 ();
528 
  compare_lt_32 ();
529 
  compare_le_32 ();
530 
  compare_gt_32 ();
531 
  compare_ge_32 ();
532 
 
533 
  compare_eq_64 ();
534 
  compare_ne_64 ();
535 
  compare_lt_64 ();
536 
  compare_le_64 ();
537 
  compare_gt_64 ();
538 
  compare_ge_64 ();
539 
 
540 
  compare_eq_128 ();
541 
  compare_ne_128 ();
542 
  compare_lt_128 ();
543 
  compare_le_128 ();
544 
  compare_gt_128 ();
545 
  compare_ge_128 ();
546 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.