libstdc++-v3/testsuite/decimal/comparison.cc

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