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

   1 // Copyright (C) 2009-2020 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 }