unittests/ADT/APFloatTest.cpp

   1 //===- llvm/unittest/ADT/APFloat.cpp - APFloat unit tests ---------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "llvm/ADT/APFloat.h"
  11 #include "llvm/ADT/APSInt.h"
  12 #include "llvm/ADT/SmallString.h"
  13 #include "llvm/ADT/SmallVector.h"
  14 #include "llvm/Support/raw_ostream.h"
  15 #include "gtest/gtest.h"
  16 #include <ostream>
  17 #include <string>
  18
  19 using namespace llvm;
  20
  21 static double convertToDoubleFromString(const char *Str) {
  22   llvm::APFloat F(0.0);
  23   F.convertFromString(Str, llvm::APFloat::rmNearestTiesToEven);
  24   return F.convertToDouble();
  25 }
  26
  27 static std::string convertToString(double d, unsigned Prec, unsigned Pad) {
  28   llvm::SmallVector<char, 100> Buffer;
  29   llvm::APFloat F(d);
  30   F.toString(Buffer, Prec, Pad);
  31   return std::string(Buffer.data(), Buffer.size());
  32 }
  33
  34 namespace {
  35
  36 TEST(APFloatTest, isSignaling) {
  37   // We test qNaN, -qNaN, +sNaN, -sNaN with and without payloads. *NOTE* The
  38   // positive/negative distinction is included only since the getQNaN/getSNaN
  39   // API provides the option.
  40   APInt payload = APInt::getOneBitSet(4, 2);
  41   EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle, false).isSignaling());
  42   EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle, true).isSignaling());
  43   EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle, false, &payload).isSignaling());
  44   EXPECT_FALSE(APFloat::getQNaN(APFloat::IEEEsingle, true, &payload).isSignaling());
  45   EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, false).isSignaling());
  46   EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, true).isSignaling());
  47   EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, false, &payload).isSignaling());
  48   EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, true, &payload).isSignaling());
  49 }
  50
  51 TEST(APFloatTest, next) {
  52
  53   APFloat test(APFloat::IEEEquad, APFloat::uninitialized);
  54   APFloat expected(APFloat::IEEEquad, APFloat::uninitialized);
  55
  56   // 1. Test Special Cases Values.
  57   //
  58   // Test all special values for nextUp and nextDown perscribed by IEEE-754R
  59   // 2008. These are:
  60   //   1.  +inf
  61   //   2.  -inf
  62   //   3.  getLargest()
  63   //   4.  -getLargest()
  64   //   5.  getSmallest()
  65   //   6.  -getSmallest()
  66   //   7.  qNaN
  67   //   8.  sNaN
  68   //   9.  +0
  69   //   10. -0
  70
  71   // nextUp(+inf) = +inf.
  72   test = APFloat::getInf(APFloat::IEEEquad, false);
  73   expected = APFloat::getInf(APFloat::IEEEquad, false);
  74   EXPECT_EQ(test.next(false), APFloat::opOK);
  75   EXPECT_TRUE(test.isInfinity());
  76   EXPECT_TRUE(!test.isNegative());
  77   EXPECT_TRUE(test.bitwiseIsEqual(expected));
  78
  79   // nextDown(+inf) = -nextUp(-inf) = -(-getLargest()) = getLargest()
  80   test = APFloat::getInf(APFloat::IEEEquad, false);
  81   expected = APFloat::getLargest(APFloat::IEEEquad, false);
  82   EXPECT_EQ(test.next(true), APFloat::opOK);
  83   EXPECT_TRUE(!test.isNegative());
  84   EXPECT_TRUE(test.bitwiseIsEqual(expected));
  85
  86   // nextUp(-inf) = -getLargest()
  87   test = APFloat::getInf(APFloat::IEEEquad, true);
  88   expected = APFloat::getLargest(APFloat::IEEEquad, true);
  89   EXPECT_EQ(test.next(false), APFloat::opOK);
  90   EXPECT_TRUE(test.isNegative());
  91   EXPECT_TRUE(test.bitwiseIsEqual(expected));
  92
  93   // nextDown(-inf) = -nextUp(+inf) = -(+inf) = -inf.
  94   test = APFloat::getInf(APFloat::IEEEquad, true);
  95   expected = APFloat::getInf(APFloat::IEEEquad, true);
  96   EXPECT_EQ(test.next(true), APFloat::opOK);
  97   EXPECT_TRUE(test.isInfinity() && test.isNegative());
  98   EXPECT_TRUE(test.bitwiseIsEqual(expected));
  99
 100   // nextUp(getLargest()) = +inf
 101   test = APFloat::getLargest(APFloat::IEEEquad, false);
 102   expected = APFloat::getInf(APFloat::IEEEquad, false);
 103   EXPECT_EQ(test.next(false), APFloat::opOK);
 104   EXPECT_TRUE(test.isInfinity() && !test.isNegative());
 105   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 106
 107   // nextDown(getLargest()) = -nextUp(-getLargest())
 108   //                        = -(-getLargest() + inc)
 109   //                        = getLargest() - inc.
 110   test = APFloat::getLargest(APFloat::IEEEquad, false);
 111   expected = APFloat(APFloat::IEEEquad,
 112                      "0x1.fffffffffffffffffffffffffffep+16383");
 113   EXPECT_EQ(test.next(true), APFloat::opOK);
 114   EXPECT_TRUE(!test.isInfinity() && !test.isNegative());
 115   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 116
 117   // nextUp(-getLargest()) = -getLargest() + inc.
 118   test = APFloat::getLargest(APFloat::IEEEquad, true);
 119   expected = APFloat(APFloat::IEEEquad,
 120                      "-0x1.fffffffffffffffffffffffffffep+16383");
 121   EXPECT_EQ(test.next(false), APFloat::opOK);
 122   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 123
 124   // nextDown(-getLargest()) = -nextUp(getLargest()) = -(inf) = -inf.
 125   test = APFloat::getLargest(APFloat::IEEEquad, true);
 126   expected = APFloat::getInf(APFloat::IEEEquad, true);
 127   EXPECT_EQ(test.next(true), APFloat::opOK);
 128   EXPECT_TRUE(test.isInfinity() && test.isNegative());
 129   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 130
 131   // nextUp(getSmallest()) = getSmallest() + inc.
 132   test = APFloat(APFloat::IEEEquad, "0x0.0000000000000000000000000001p-16382");
 133   expected = APFloat(APFloat::IEEEquad,
 134                      "0x0.0000000000000000000000000002p-16382");
 135   EXPECT_EQ(test.next(false), APFloat::opOK);
 136   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 137
 138   // nextDown(getSmallest()) = -nextUp(-getSmallest()) = -(-0) = +0.
 139   test = APFloat(APFloat::IEEEquad, "0x0.0000000000000000000000000001p-16382");
 140   expected = APFloat::getZero(APFloat::IEEEquad, false);
 141   EXPECT_EQ(test.next(true), APFloat::opOK);
 142   EXPECT_TRUE(test.isZero() && !test.isNegative());
 143   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 144
 145   // nextUp(-getSmallest()) = -0.
 146   test = APFloat(APFloat::IEEEquad, "-0x0.0000000000000000000000000001p-16382");
 147   expected = APFloat::getZero(APFloat::IEEEquad, true);
 148   EXPECT_EQ(test.next(false), APFloat::opOK);
 149   EXPECT_TRUE(test.isZero() && test.isNegative());
 150   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 151
 152   // nextDown(-getSmallest()) = -nextUp(getSmallest()) = -getSmallest() - inc.
 153   test = APFloat(APFloat::IEEEquad, "-0x0.0000000000000000000000000001p-16382");
 154   expected = APFloat(APFloat::IEEEquad,
 155                      "-0x0.0000000000000000000000000002p-16382");
 156   EXPECT_EQ(test.next(true), APFloat::opOK);
 157   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 158
 159   // nextUp(qNaN) = qNaN
 160   test = APFloat::getQNaN(APFloat::IEEEquad, false);
 161   expected = APFloat::getQNaN(APFloat::IEEEquad, false);
 162   EXPECT_EQ(test.next(false), APFloat::opOK);
 163   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 164
 165   // nextDown(qNaN) = qNaN
 166   test = APFloat::getQNaN(APFloat::IEEEquad, false);
 167   expected = APFloat::getQNaN(APFloat::IEEEquad, false);
 168   EXPECT_EQ(test.next(true), APFloat::opOK);
 169   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 170
 171   // nextUp(sNaN) = qNaN
 172   test = APFloat::getSNaN(APFloat::IEEEquad, false);
 173   expected = APFloat::getQNaN(APFloat::IEEEquad, false);
 174   EXPECT_EQ(test.next(false), APFloat::opInvalidOp);
 175   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 176
 177   // nextDown(sNaN) = qNaN
 178   test = APFloat::getSNaN(APFloat::IEEEquad, false);
 179   expected = APFloat::getQNaN(APFloat::IEEEquad, false);
 180   EXPECT_EQ(test.next(true), APFloat::opInvalidOp);
 181   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 182
 183   // nextUp(+0) = +getSmallest()
 184   test = APFloat::getZero(APFloat::IEEEquad, false);
 185   expected = APFloat::getSmallest(APFloat::IEEEquad, false);
 186   EXPECT_EQ(test.next(false), APFloat::opOK);
 187   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 188
 189   // nextDown(+0) = -nextUp(-0) = -getSmallest()
 190   test = APFloat::getZero(APFloat::IEEEquad, false);
 191   expected = APFloat::getSmallest(APFloat::IEEEquad, true);
 192   EXPECT_EQ(test.next(true), APFloat::opOK);
 193   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 194
 195   // nextUp(-0) = +getSmallest()
 196   test = APFloat::getZero(APFloat::IEEEquad, true);
 197   expected = APFloat::getSmallest(APFloat::IEEEquad, false);
 198   EXPECT_EQ(test.next(false), APFloat::opOK);
 199   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 200
 201   // nextDown(-0) = -nextUp(0) = -getSmallest()
 202   test = APFloat::getZero(APFloat::IEEEquad, true);
 203   expected = APFloat::getSmallest(APFloat::IEEEquad, true);
 204   EXPECT_EQ(test.next(true), APFloat::opOK);
 205   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 206
 207   // 2. Binade Boundary Tests.
 208
 209   // 2a. Test denormal <-> normal binade boundaries.
 210   //     * nextUp(+Largest Denormal) -> +Smallest Normal.
 211   //     * nextDown(-Largest Denormal) -> -Smallest Normal.
 212   //     * nextUp(-Smallest Normal) -> -Largest Denormal.
 213   //     * nextDown(+Smallest Normal) -> +Largest Denormal.
 214
 215   // nextUp(+Largest Denormal) -> +Smallest Normal.
 216   test = APFloat(APFloat::IEEEquad, "0x0.ffffffffffffffffffffffffffffp-16382");
 217   expected = APFloat(APFloat::IEEEquad,
 218                      "0x1.0000000000000000000000000000p-16382");
 219   EXPECT_EQ(test.next(false), APFloat::opOK);
 220   EXPECT_FALSE(test.isDenormal());
 221   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 222
 223   // nextDown(-Largest Denormal) -> -Smallest Normal.
 224   test = APFloat(APFloat::IEEEquad,
 225                  "-0x0.ffffffffffffffffffffffffffffp-16382");
 226   expected = APFloat(APFloat::IEEEquad,
 227                      "-0x1.0000000000000000000000000000p-16382");
 228   EXPECT_EQ(test.next(true), APFloat::opOK);
 229   EXPECT_FALSE(test.isDenormal());
 230   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 231
 232   // nextUp(-Smallest Normal) -> -LargestDenormal.
 233   test = APFloat(APFloat::IEEEquad,
 234                  "-0x1.0000000000000000000000000000p-16382");
 235   expected = APFloat(APFloat::IEEEquad,
 236                      "-0x0.ffffffffffffffffffffffffffffp-16382");
 237   EXPECT_EQ(test.next(false), APFloat::opOK);
 238   EXPECT_TRUE(test.isDenormal());
 239   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 240
 241   // nextDown(+Smallest Normal) -> +Largest Denormal.
 242   test = APFloat(APFloat::IEEEquad,
 243                  "+0x1.0000000000000000000000000000p-16382");
 244   expected = APFloat(APFloat::IEEEquad,
 245                      "+0x0.ffffffffffffffffffffffffffffp-16382");
 246   EXPECT_EQ(test.next(true), APFloat::opOK);
 247   EXPECT_TRUE(test.isDenormal());
 248   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 249
 250   // 2b. Test normal <-> normal binade boundaries.
 251   //     * nextUp(-Normal Binade Boundary) -> -Normal Binade Boundary + 1.
 252   //     * nextDown(+Normal Binade Boundary) -> +Normal Binade Boundary - 1.
 253   //     * nextUp(+Normal Binade Boundary - 1) -> +Normal Binade Boundary.
 254   //     * nextDown(-Normal Binade Boundary + 1) -> -Normal Binade Boundary.
 255
 256   // nextUp(-Normal Binade Boundary) -> -Normal Binade Boundary + 1.
 257   test = APFloat(APFloat::IEEEquad, "-0x1p+1");
 258   expected = APFloat(APFloat::IEEEquad,
 259                      "-0x1.ffffffffffffffffffffffffffffp+0");
 260   EXPECT_EQ(test.next(false), APFloat::opOK);
 261   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 262
 263   // nextDown(+Normal Binade Boundary) -> +Normal Binade Boundary - 1.
 264   test = APFloat(APFloat::IEEEquad, "0x1p+1");
 265   expected = APFloat(APFloat::IEEEquad, "0x1.ffffffffffffffffffffffffffffp+0");
 266   EXPECT_EQ(test.next(true), APFloat::opOK);
 267   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 268
 269   // nextUp(+Normal Binade Boundary - 1) -> +Normal Binade Boundary.
 270   test = APFloat(APFloat::IEEEquad, "0x1.ffffffffffffffffffffffffffffp+0");
 271   expected = APFloat(APFloat::IEEEquad, "0x1p+1");
 272   EXPECT_EQ(test.next(false), APFloat::opOK);
 273   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 274
 275   // nextDown(-Normal Binade Boundary + 1) -> -Normal Binade Boundary.
 276   test = APFloat(APFloat::IEEEquad, "-0x1.ffffffffffffffffffffffffffffp+0");
 277   expected = APFloat(APFloat::IEEEquad, "-0x1p+1");
 278   EXPECT_EQ(test.next(true), APFloat::opOK);
 279   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 280
 281   // 2c. Test using next at binade boundaries with a direction away from the
 282   // binade boundary. Away from denormal <-> normal boundaries.
 283   //
 284   // This is to make sure that even though we are at a binade boundary, since
 285   // we are rounding away, we do not trigger the binade boundary code. Thus we
 286   // test:
 287   //   * nextUp(-Largest Denormal) -> -Largest Denormal + inc.
 288   //   * nextDown(+Largest Denormal) -> +Largest Denormal - inc.
 289   //   * nextUp(+Smallest Normal) -> +Smallest Normal + inc.
 290   //   * nextDown(-Smallest Normal) -> -Smallest Normal - inc.
 291
 292   // nextUp(-Largest Denormal) -> -Largest Denormal + inc.
 293   test = APFloat(APFloat::IEEEquad, "-0x0.ffffffffffffffffffffffffffffp-16382");
 294   expected = APFloat(APFloat::IEEEquad,
 295                      "-0x0.fffffffffffffffffffffffffffep-16382");
 296   EXPECT_EQ(test.next(false), APFloat::opOK);
 297   EXPECT_TRUE(test.isDenormal());
 298   EXPECT_TRUE(test.isNegative());
 299   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 300
 301   // nextDown(+Largest Denormal) -> +Largest Denormal - inc.
 302   test = APFloat(APFloat::IEEEquad, "0x0.ffffffffffffffffffffffffffffp-16382");
 303   expected = APFloat(APFloat::IEEEquad,
 304                      "0x0.fffffffffffffffffffffffffffep-16382");
 305   EXPECT_EQ(test.next(true), APFloat::opOK);
 306   EXPECT_TRUE(test.isDenormal());
 307   EXPECT_TRUE(!test.isNegative());
 308   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 309
 310   // nextUp(+Smallest Normal) -> +Smallest Normal + inc.
 311   test = APFloat(APFloat::IEEEquad, "0x1.0000000000000000000000000000p-16382");
 312   expected = APFloat(APFloat::IEEEquad,
 313                      "0x1.0000000000000000000000000001p-16382");
 314   EXPECT_EQ(test.next(false), APFloat::opOK);
 315   EXPECT_TRUE(!test.isDenormal());
 316   EXPECT_TRUE(!test.isNegative());
 317   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 318
 319   // nextDown(-Smallest Normal) -> -Smallest Normal - inc.
 320   test = APFloat(APFloat::IEEEquad, "-0x1.0000000000000000000000000000p-16382");
 321   expected = APFloat(APFloat::IEEEquad,
 322                      "-0x1.0000000000000000000000000001p-16382");
 323   EXPECT_EQ(test.next(true), APFloat::opOK);
 324   EXPECT_TRUE(!test.isDenormal());
 325   EXPECT_TRUE(test.isNegative());
 326   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 327
 328   // 2d. Test values which cause our exponent to go to min exponent. This
 329   // is to ensure that guards in the code to check for min exponent
 330   // trigger properly.
 331   //     * nextUp(-0x1p-16381) -> -0x1.ffffffffffffffffffffffffffffp-16382
 332   //     * nextDown(-0x1.ffffffffffffffffffffffffffffp-16382) ->
 333   //         -0x1p-16381
 334   //     * nextUp(0x1.ffffffffffffffffffffffffffffp-16382) -> 0x1p-16382
 335   //     * nextDown(0x1p-16382) -> 0x1.ffffffffffffffffffffffffffffp-16382
 336
 337   // nextUp(-0x1p-16381) -> -0x1.ffffffffffffffffffffffffffffp-16382
 338   test = APFloat(APFloat::IEEEquad, "-0x1p-16381");
 339   expected = APFloat(APFloat::IEEEquad,
 340                      "-0x1.ffffffffffffffffffffffffffffp-16382");
 341   EXPECT_EQ(test.next(false), APFloat::opOK);
 342   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 343
 344   // nextDown(-0x1.ffffffffffffffffffffffffffffp-16382) ->
 345   //         -0x1p-16381
 346   test = APFloat(APFloat::IEEEquad, "-0x1.ffffffffffffffffffffffffffffp-16382");
 347   expected = APFloat(APFloat::IEEEquad, "-0x1p-16381");
 348   EXPECT_EQ(test.next(true), APFloat::opOK);
 349   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 350
 351   // nextUp(0x1.ffffffffffffffffffffffffffffp-16382) -> 0x1p-16381
 352   test = APFloat(APFloat::IEEEquad, "0x1.ffffffffffffffffffffffffffffp-16382");
 353   expected = APFloat(APFloat::IEEEquad, "0x1p-16381");
 354   EXPECT_EQ(test.next(false), APFloat::opOK);
 355   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 356
 357   // nextDown(0x1p-16381) -> 0x1.ffffffffffffffffffffffffffffp-16382
 358   test = APFloat(APFloat::IEEEquad, "0x1p-16381");
 359   expected = APFloat(APFloat::IEEEquad,
 360                      "0x1.ffffffffffffffffffffffffffffp-16382");
 361   EXPECT_EQ(test.next(true), APFloat::opOK);
 362   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 363
 364   // 3. Now we test both denormal/normal computation which will not cause us
 365   // to go across binade boundaries. Specifically we test:
 366   //   * nextUp(+Denormal) -> +Denormal.
 367   //   * nextDown(+Denormal) -> +Denormal.
 368   //   * nextUp(-Denormal) -> -Denormal.
 369   //   * nextDown(-Denormal) -> -Denormal.
 370   //   * nextUp(+Normal) -> +Normal.
 371   //   * nextDown(+Normal) -> +Normal.
 372   //   * nextUp(-Normal) -> -Normal.
 373   //   * nextDown(-Normal) -> -Normal.
 374
 375   // nextUp(+Denormal) -> +Denormal.
 376   test = APFloat(APFloat::IEEEquad,
 377                  "0x0.ffffffffffffffffffffffff000cp-16382");
 378   expected = APFloat(APFloat::IEEEquad,
 379                  "0x0.ffffffffffffffffffffffff000dp-16382");
 380   EXPECT_EQ(test.next(false), APFloat::opOK);
 381   EXPECT_TRUE(test.isDenormal());
 382   EXPECT_TRUE(!test.isNegative());
 383   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 384
 385   // nextDown(+Denormal) -> +Denormal.
 386   test = APFloat(APFloat::IEEEquad,
 387                  "0x0.ffffffffffffffffffffffff000cp-16382");
 388   expected = APFloat(APFloat::IEEEquad,
 389                  "0x0.ffffffffffffffffffffffff000bp-16382");
 390   EXPECT_EQ(test.next(true), APFloat::opOK);
 391   EXPECT_TRUE(test.isDenormal());
 392   EXPECT_TRUE(!test.isNegative());
 393   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 394
 395   // nextUp(-Denormal) -> -Denormal.
 396   test = APFloat(APFloat::IEEEquad,
 397                  "-0x0.ffffffffffffffffffffffff000cp-16382");
 398   expected = APFloat(APFloat::IEEEquad,
 399                  "-0x0.ffffffffffffffffffffffff000bp-16382");
 400   EXPECT_EQ(test.next(false), APFloat::opOK);
 401   EXPECT_TRUE(test.isDenormal());
 402   EXPECT_TRUE(test.isNegative());
 403   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 404
 405   // nextDown(-Denormal) -> -Denormal
 406   test = APFloat(APFloat::IEEEquad,
 407                  "-0x0.ffffffffffffffffffffffff000cp-16382");
 408   expected = APFloat(APFloat::IEEEquad,
 409                  "-0x0.ffffffffffffffffffffffff000dp-16382");
 410   EXPECT_EQ(test.next(true), APFloat::opOK);
 411   EXPECT_TRUE(test.isDenormal());
 412   EXPECT_TRUE(test.isNegative());
 413   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 414
 415   // nextUp(+Normal) -> +Normal.
 416   test = APFloat(APFloat::IEEEquad,
 417                  "0x1.ffffffffffffffffffffffff000cp-16000");
 418   expected = APFloat(APFloat::IEEEquad,
 419                  "0x1.ffffffffffffffffffffffff000dp-16000");
 420   EXPECT_EQ(test.next(false), APFloat::opOK);
 421   EXPECT_TRUE(!test.isDenormal());
 422   EXPECT_TRUE(!test.isNegative());
 423   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 424
 425   // nextDown(+Normal) -> +Normal.
 426   test = APFloat(APFloat::IEEEquad,
 427                  "0x1.ffffffffffffffffffffffff000cp-16000");
 428   expected = APFloat(APFloat::IEEEquad,
 429                  "0x1.ffffffffffffffffffffffff000bp-16000");
 430   EXPECT_EQ(test.next(true), APFloat::opOK);
 431   EXPECT_TRUE(!test.isDenormal());
 432   EXPECT_TRUE(!test.isNegative());
 433   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 434
 435   // nextUp(-Normal) -> -Normal.
 436   test = APFloat(APFloat::IEEEquad,
 437                  "-0x1.ffffffffffffffffffffffff000cp-16000");
 438   expected = APFloat(APFloat::IEEEquad,
 439                  "-0x1.ffffffffffffffffffffffff000bp-16000");
 440   EXPECT_EQ(test.next(false), APFloat::opOK);
 441   EXPECT_TRUE(!test.isDenormal());
 442   EXPECT_TRUE(test.isNegative());
 443   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 444
 445   // nextDown(-Normal) -> -Normal.
 446   test = APFloat(APFloat::IEEEquad,
 447                  "-0x1.ffffffffffffffffffffffff000cp-16000");
 448   expected = APFloat(APFloat::IEEEquad,
 449                  "-0x1.ffffffffffffffffffffffff000dp-16000");
 450   EXPECT_EQ(test.next(true), APFloat::opOK);
 451   EXPECT_TRUE(!test.isDenormal());
 452   EXPECT_TRUE(test.isNegative());
 453   EXPECT_TRUE(test.bitwiseIsEqual(expected));
 454 }
 455
 456 TEST(APFloatTest, FMA) {
 457   APFloat::roundingMode rdmd = APFloat::rmNearestTiesToEven;
 458
 459   {
 460     APFloat f1(14.5f);
 461     APFloat f2(-14.5f);
 462     APFloat f3(225.0f);
 463     f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
 464     EXPECT_EQ(14.75f, f1.convertToFloat());
 465   }
 466
 467   {
 468     APFloat Val2(2.0f);
 469     APFloat f1((float)1.17549435e-38F);
 470     APFloat f2((float)1.17549435e-38F);
 471     f1.divide(Val2, rdmd);
 472     f2.divide(Val2, rdmd);
 473     APFloat f3(12.0f);
 474     f1.fusedMultiplyAdd(f2, f3, APFloat::rmNearestTiesToEven);
 475     EXPECT_EQ(12.0f, f1.convertToFloat());
 476   }
 477
 478   {
 479     APFloat M1(APFloat::x87DoubleExtended, 1.0);
 480     APFloat M2(APFloat::x87DoubleExtended, 1.0);
 481     APFloat A(APFloat::x87DoubleExtended, 3.0);
 482
 483     bool losesInfo = false;
 484     M1.fusedMultiplyAdd(M1, A, APFloat::rmNearestTiesToEven);
 485     M1.convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven, &losesInfo);
 486     EXPECT_FALSE(losesInfo);
 487     EXPECT_EQ(4.0f, M1.convertToFloat());
 488   }
 489 }
 490
 491 TEST(APFloatTest, MinNum) {
 492   APFloat f1(1.0);
 493   APFloat f2(2.0);
 494   APFloat nan = APFloat::getNaN(APFloat::IEEEdouble);
 495
 496   EXPECT_EQ(1.0, minnum(f1, f2).convertToDouble());
 497   EXPECT_EQ(1.0, minnum(f2, f1).convertToDouble());
 498   EXPECT_EQ(1.0, minnum(f1, nan).convertToDouble());
 499   EXPECT_EQ(1.0, minnum(nan, f1).convertToDouble());
 500 }
 501
 502 TEST(APFloatTest, MaxNum) {
 503   APFloat f1(1.0);
 504   APFloat f2(2.0);
 505   APFloat nan = APFloat::getNaN(APFloat::IEEEdouble);
 506
 507   EXPECT_EQ(2.0, maxnum(f1, f2).convertToDouble());
 508   EXPECT_EQ(2.0, maxnum(f2, f1).convertToDouble());
 509   EXPECT_EQ(1.0, maxnum(f1, nan).convertToDouble());
 510   EXPECT_EQ(1.0, minnum(nan, f1).convertToDouble());
 511 }
 512
 513 TEST(APFloatTest, Denormal) {
 514   APFloat::roundingMode rdmd = APFloat::rmNearestTiesToEven;
 515
 516   // Test single precision
 517   {
 518     const char *MinNormalStr = "1.17549435082228750797e-38";
 519     EXPECT_FALSE(APFloat(APFloat::IEEEsingle, MinNormalStr).isDenormal());
 520     EXPECT_FALSE(APFloat(APFloat::IEEEsingle, 0.0).isDenormal());
 521
 522     APFloat Val2(APFloat::IEEEsingle, 2.0e0);
 523     APFloat T(APFloat::IEEEsingle, MinNormalStr);
 524     T.divide(Val2, rdmd);
 525     EXPECT_TRUE(T.isDenormal());
 526   }
 527
 528   // Test double precision
 529   {
 530     const char *MinNormalStr = "2.22507385850720138309e-308";
 531     EXPECT_FALSE(APFloat(APFloat::IEEEdouble, MinNormalStr).isDenormal());
 532     EXPECT_FALSE(APFloat(APFloat::IEEEdouble, 0.0).isDenormal());
 533
 534     APFloat Val2(APFloat::IEEEdouble, 2.0e0);
 535     APFloat T(APFloat::IEEEdouble, MinNormalStr);
 536     T.divide(Val2, rdmd);
 537     EXPECT_TRUE(T.isDenormal());
 538   }
 539
 540   // Test Intel double-ext
 541   {
 542     const char *MinNormalStr = "3.36210314311209350626e-4932";
 543     EXPECT_FALSE(APFloat(APFloat::x87DoubleExtended, MinNormalStr).isDenormal());
 544     EXPECT_FALSE(APFloat(APFloat::x87DoubleExtended, 0.0).isDenormal());
 545
 546     APFloat Val2(APFloat::x87DoubleExtended, 2.0e0);
 547     APFloat T(APFloat::x87DoubleExtended, MinNormalStr);
 548     T.divide(Val2, rdmd);
 549     EXPECT_TRUE(T.isDenormal());
 550   }
 551
 552   // Test quadruple precision
 553   {
 554     const char *MinNormalStr = "3.36210314311209350626267781732175260e-4932";
 555     EXPECT_FALSE(APFloat(APFloat::IEEEquad, MinNormalStr).isDenormal());
 556     EXPECT_FALSE(APFloat(APFloat::IEEEquad, 0.0).isDenormal());
 557
 558     APFloat Val2(APFloat::IEEEquad, 2.0e0);
 559     APFloat T(APFloat::IEEEquad, MinNormalStr);
 560     T.divide(Val2, rdmd);
 561     EXPECT_TRUE(T.isDenormal());
 562   }
 563 }
 564
 565 TEST(APFloatTest, Zero) {
 566   EXPECT_EQ(0.0f,  APFloat(0.0f).convertToFloat());
 567   EXPECT_EQ(-0.0f, APFloat(-0.0f).convertToFloat());
 568   EXPECT_TRUE(APFloat(-0.0f).isNegative());
 569
 570   EXPECT_EQ(0.0,  APFloat(0.0).convertToDouble());
 571   EXPECT_EQ(-0.0, APFloat(-0.0).convertToDouble());
 572   EXPECT_TRUE(APFloat(-0.0).isNegative());
 573 }
 574
 575 TEST(APFloatTest, DecimalStringsWithoutNullTerminators) {
 576   // Make sure that we can parse strings without null terminators.
 577   // rdar://14323230.
 578   APFloat Val(APFloat::IEEEdouble);
 579   Val.convertFromString(StringRef("0.00", 3),
 580                         llvm::APFloat::rmNearestTiesToEven);
 581   EXPECT_EQ(Val.convertToDouble(), 0.0);
 582   Val.convertFromString(StringRef("0.01", 3),
 583                         llvm::APFloat::rmNearestTiesToEven);
 584   EXPECT_EQ(Val.convertToDouble(), 0.0);
 585   Val.convertFromString(StringRef("0.09", 3),
 586                         llvm::APFloat::rmNearestTiesToEven);
 587   EXPECT_EQ(Val.convertToDouble(), 0.0);
 588   Val.convertFromString(StringRef("0.095", 4),
 589                         llvm::APFloat::rmNearestTiesToEven);
 590   EXPECT_EQ(Val.convertToDouble(), 0.09);
 591   Val.convertFromString(StringRef("0.00e+3", 7),
 592                         llvm::APFloat::rmNearestTiesToEven);
 593   EXPECT_EQ(Val.convertToDouble(), 0.00);
 594   Val.convertFromString(StringRef("0e+3", 4),
 595                         llvm::APFloat::rmNearestTiesToEven);
 596   EXPECT_EQ(Val.convertToDouble(), 0.00);
 597
 598 }
 599
 600 TEST(APFloatTest, fromZeroDecimalString) {
 601   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0").convertToDouble());
 602   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0").convertToDouble());
 603   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0").convertToDouble());
 604
 605   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0.").convertToDouble());
 606   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.").convertToDouble());
 607   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.").convertToDouble());
 608
 609   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  ".0").convertToDouble());
 610   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.0").convertToDouble());
 611   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.0").convertToDouble());
 612
 613   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0.0").convertToDouble());
 614   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.0").convertToDouble());
 615   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.0").convertToDouble());
 616
 617   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "00000.").convertToDouble());
 618   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+00000.").convertToDouble());
 619   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-00000.").convertToDouble());
 620
 621   EXPECT_EQ(0.0,  APFloat(APFloat::IEEEdouble, ".00000").convertToDouble());
 622   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.00000").convertToDouble());
 623   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.00000").convertToDouble());
 624
 625   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0000.00000").convertToDouble());
 626   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0000.00000").convertToDouble());
 627   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0000.00000").convertToDouble());
 628 }
 629
 630 TEST(APFloatTest, fromZeroDecimalSingleExponentString) {
 631   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,   "0e1").convertToDouble());
 632   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble,  "+0e1").convertToDouble());
 633   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble,  "-0e1").convertToDouble());
 634
 635   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0e+1").convertToDouble());
 636   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e+1").convertToDouble());
 637   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e+1").convertToDouble());
 638
 639   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0e-1").convertToDouble());
 640   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e-1").convertToDouble());
 641   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e-1").convertToDouble());
 642
 643
 644   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,   "0.e1").convertToDouble());
 645   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble,  "+0.e1").convertToDouble());
 646   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble,  "-0.e1").convertToDouble());
 647
 648   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0.e+1").convertToDouble());
 649   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.e+1").convertToDouble());
 650   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.e+1").convertToDouble());
 651
 652   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0.e-1").convertToDouble());
 653   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.e-1").convertToDouble());
 654   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.e-1").convertToDouble());
 655
 656   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,   ".0e1").convertToDouble());
 657   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble,  "+.0e1").convertToDouble());
 658   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble,  "-.0e1").convertToDouble());
 659
 660   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  ".0e+1").convertToDouble());
 661   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.0e+1").convertToDouble());
 662   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.0e+1").convertToDouble());
 663
 664   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  ".0e-1").convertToDouble());
 665   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.0e-1").convertToDouble());
 666   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.0e-1").convertToDouble());
 667
 668
 669   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,   "0.0e1").convertToDouble());
 670   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble,  "+0.0e1").convertToDouble());
 671   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble,  "-0.0e1").convertToDouble());
 672
 673   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0.0e+1").convertToDouble());
 674   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.0e+1").convertToDouble());
 675   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.0e+1").convertToDouble());
 676
 677   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0.0e-1").convertToDouble());
 678   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.0e-1").convertToDouble());
 679   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.0e-1").convertToDouble());
 680
 681
 682   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "000.0000e1").convertToDouble());
 683   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+000.0000e+1").convertToDouble());
 684   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-000.0000e+1").convertToDouble());
 685 }
 686
 687 TEST(APFloatTest, fromZeroDecimalLargeExponentString) {
 688   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0e1234").convertToDouble());
 689   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e1234").convertToDouble());
 690   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e1234").convertToDouble());
 691
 692   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0e+1234").convertToDouble());
 693   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e+1234").convertToDouble());
 694   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e+1234").convertToDouble());
 695
 696   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0e-1234").convertToDouble());
 697   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e-1234").convertToDouble());
 698   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e-1234").convertToDouble());
 699
 700   EXPECT_EQ(0.0,  APFloat(APFloat::IEEEdouble, "000.0000e1234").convertToDouble());
 701   EXPECT_EQ(0.0,  APFloat(APFloat::IEEEdouble, "000.0000e-1234").convertToDouble());
 702
 703   EXPECT_EQ(0.0,  APFloat(APFloat::IEEEdouble, StringRef("0e1234\02", 6)).convertToDouble());
 704 }
 705
 706 TEST(APFloatTest, fromZeroHexadecimalString) {
 707   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x0p1").convertToDouble());
 708   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0p1").convertToDouble());
 709   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0p1").convertToDouble());
 710
 711   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x0p+1").convertToDouble());
 712   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0p+1").convertToDouble());
 713   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0p+1").convertToDouble());
 714
 715   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x0p-1").convertToDouble());
 716   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0p-1").convertToDouble());
 717   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0p-1").convertToDouble());
 718
 719
 720   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x0.p1").convertToDouble());
 721   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.p1").convertToDouble());
 722   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.p1").convertToDouble());
 723
 724   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x0.p+1").convertToDouble());
 725   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.p+1").convertToDouble());
 726   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.p+1").convertToDouble());
 727
 728   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x0.p-1").convertToDouble());
 729   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.p-1").convertToDouble());
 730   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.p-1").convertToDouble());
 731
 732
 733   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x.0p1").convertToDouble());
 734   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x.0p1").convertToDouble());
 735   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x.0p1").convertToDouble());
 736
 737   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x.0p+1").convertToDouble());
 738   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x.0p+1").convertToDouble());
 739   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x.0p+1").convertToDouble());
 740
 741   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x.0p-1").convertToDouble());
 742   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x.0p-1").convertToDouble());
 743   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x.0p-1").convertToDouble());
 744
 745
 746   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x0.0p1").convertToDouble());
 747   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.0p1").convertToDouble());
 748   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.0p1").convertToDouble());
 749
 750   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x0.0p+1").convertToDouble());
 751   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.0p+1").convertToDouble());
 752   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.0p+1").convertToDouble());
 753
 754   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x0.0p-1").convertToDouble());
 755   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.0p-1").convertToDouble());
 756   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.0p-1").convertToDouble());
 757
 758
 759   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x00000.p1").convertToDouble());
 760   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0000.00000p1").convertToDouble());
 761   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x.00000p1").convertToDouble());
 762   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.p1").convertToDouble());
 763   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0p1234").convertToDouble());
 764   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0p1234").convertToDouble());
 765   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x00000.p1234").convertToDouble());
 766   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0000.00000p1234").convertToDouble());
 767   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x.00000p1234").convertToDouble());
 768   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.p1234").convertToDouble());
 769 }
 770
 771 TEST(APFloatTest, fromDecimalString) {
 772   EXPECT_EQ(1.0,      APFloat(APFloat::IEEEdouble, "1").convertToDouble());
 773   EXPECT_EQ(2.0,      APFloat(APFloat::IEEEdouble, "2.").convertToDouble());
 774   EXPECT_EQ(0.5,      APFloat(APFloat::IEEEdouble, ".5").convertToDouble());
 775   EXPECT_EQ(1.0,      APFloat(APFloat::IEEEdouble, "1.0").convertToDouble());
 776   EXPECT_EQ(-2.0,     APFloat(APFloat::IEEEdouble, "-2").convertToDouble());
 777   EXPECT_EQ(-4.0,     APFloat(APFloat::IEEEdouble, "-4.").convertToDouble());
 778   EXPECT_EQ(-0.5,     APFloat(APFloat::IEEEdouble, "-.5").convertToDouble());
 779   EXPECT_EQ(-1.5,     APFloat(APFloat::IEEEdouble, "-1.5").convertToDouble());
 780   EXPECT_EQ(1.25e12,  APFloat(APFloat::IEEEdouble, "1.25e12").convertToDouble());
 781   EXPECT_EQ(1.25e+12, APFloat(APFloat::IEEEdouble, "1.25e+12").convertToDouble());
 782   EXPECT_EQ(1.25e-12, APFloat(APFloat::IEEEdouble, "1.25e-12").convertToDouble());
 783   EXPECT_EQ(1024.0,   APFloat(APFloat::IEEEdouble, "1024.").convertToDouble());
 784   EXPECT_EQ(1024.05,  APFloat(APFloat::IEEEdouble, "1024.05000").convertToDouble());
 785   EXPECT_EQ(0.05,     APFloat(APFloat::IEEEdouble, ".05000").convertToDouble());
 786   EXPECT_EQ(2.0,      APFloat(APFloat::IEEEdouble, "2.").convertToDouble());
 787   EXPECT_EQ(2.0e2,    APFloat(APFloat::IEEEdouble, "2.e2").convertToDouble());
 788   EXPECT_EQ(2.0e+2,   APFloat(APFloat::IEEEdouble, "2.e+2").convertToDouble());
 789   EXPECT_EQ(2.0e-2,   APFloat(APFloat::IEEEdouble, "2.e-2").convertToDouble());
 790   EXPECT_EQ(2.05e2,    APFloat(APFloat::IEEEdouble, "002.05000e2").convertToDouble());
 791   EXPECT_EQ(2.05e+2,   APFloat(APFloat::IEEEdouble, "002.05000e+2").convertToDouble());
 792   EXPECT_EQ(2.05e-2,   APFloat(APFloat::IEEEdouble, "002.05000e-2").convertToDouble());
 793   EXPECT_EQ(2.05e12,   APFloat(APFloat::IEEEdouble, "002.05000e12").convertToDouble());
 794   EXPECT_EQ(2.05e+12,  APFloat(APFloat::IEEEdouble, "002.05000e+12").convertToDouble());
 795   EXPECT_EQ(2.05e-12,  APFloat(APFloat::IEEEdouble, "002.05000e-12").convertToDouble());
 796
 797   // These are "carefully selected" to overflow the fast log-base
 798   // calculations in APFloat.cpp
 799   EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "99e99999").isInfinity());
 800   EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "-99e99999").isInfinity());
 801   EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "1e-99999").isPosZero());
 802   EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "-1e-99999").isNegZero());
 803
 804   EXPECT_EQ(2.71828, convertToDoubleFromString("2.71828"));
 805 }
 806
 807 TEST(APFloatTest, fromHexadecimalString) {
 808   EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble,  "0x1p0").convertToDouble());
 809   EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble, "+0x1p0").convertToDouble());
 810   EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble, "-0x1p0").convertToDouble());
 811
 812   EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble,  "0x1p+0").convertToDouble());
 813   EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble, "+0x1p+0").convertToDouble());
 814   EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble, "-0x1p+0").convertToDouble());
 815
 816   EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble,  "0x1p-0").convertToDouble());
 817   EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble, "+0x1p-0").convertToDouble());
 818   EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble, "-0x1p-0").convertToDouble());
 819
 820
 821   EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble,  "0x1p1").convertToDouble());
 822   EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble, "+0x1p1").convertToDouble());
 823   EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble, "-0x1p1").convertToDouble());
 824
 825   EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble,  "0x1p+1").convertToDouble());
 826   EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble, "+0x1p+1").convertToDouble());
 827   EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble, "-0x1p+1").convertToDouble());
 828
 829   EXPECT_EQ( 0.5, APFloat(APFloat::IEEEdouble,  "0x1p-1").convertToDouble());
 830   EXPECT_EQ(+0.5, APFloat(APFloat::IEEEdouble, "+0x1p-1").convertToDouble());
 831   EXPECT_EQ(-0.5, APFloat(APFloat::IEEEdouble, "-0x1p-1").convertToDouble());
 832
 833
 834   EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble,  "0x1.8p1").convertToDouble());
 835   EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble, "+0x1.8p1").convertToDouble());
 836   EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble, "-0x1.8p1").convertToDouble());
 837
 838   EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble,  "0x1.8p+1").convertToDouble());
 839   EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble, "+0x1.8p+1").convertToDouble());
 840   EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble, "-0x1.8p+1").convertToDouble());
 841
 842   EXPECT_EQ( 0.75, APFloat(APFloat::IEEEdouble,  "0x1.8p-1").convertToDouble());
 843   EXPECT_EQ(+0.75, APFloat(APFloat::IEEEdouble, "+0x1.8p-1").convertToDouble());
 844   EXPECT_EQ(-0.75, APFloat(APFloat::IEEEdouble, "-0x1.8p-1").convertToDouble());
 845
 846
 847   EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble,  "0x1000.000p1").convertToDouble());
 848   EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble, "+0x1000.000p1").convertToDouble());
 849   EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble, "-0x1000.000p1").convertToDouble());
 850
 851   EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble,  "0x1000.000p+1").convertToDouble());
 852   EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble, "+0x1000.000p+1").convertToDouble());
 853   EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble, "-0x1000.000p+1").convertToDouble());
 854
 855   EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble,  "0x1000.000p-1").convertToDouble());
 856   EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble, "+0x1000.000p-1").convertToDouble());
 857   EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble, "-0x1000.000p-1").convertToDouble());
 858
 859
 860   EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble,  "0x1000p1").convertToDouble());
 861   EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble, "+0x1000p1").convertToDouble());
 862   EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble, "-0x1000p1").convertToDouble());
 863
 864   EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble,  "0x1000p+1").convertToDouble());
 865   EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble, "+0x1000p+1").convertToDouble());
 866   EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble, "-0x1000p+1").convertToDouble());
 867
 868   EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble,  "0x1000p-1").convertToDouble());
 869   EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble, "+0x1000p-1").convertToDouble());
 870   EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble, "-0x1000p-1").convertToDouble());
 871
 872
 873   EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble,  "0x10p10").convertToDouble());
 874   EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble, "+0x10p10").convertToDouble());
 875   EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble, "-0x10p10").convertToDouble());
 876
 877   EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble,  "0x10p+10").convertToDouble());
 878   EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble, "+0x10p+10").convertToDouble());
 879   EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble, "-0x10p+10").convertToDouble());
 880
 881   EXPECT_EQ( 0.015625, APFloat(APFloat::IEEEdouble,  "0x10p-10").convertToDouble());
 882   EXPECT_EQ(+0.015625, APFloat(APFloat::IEEEdouble, "+0x10p-10").convertToDouble());
 883   EXPECT_EQ(-0.015625, APFloat(APFloat::IEEEdouble, "-0x10p-10").convertToDouble());
 884
 885   EXPECT_EQ(1.0625, APFloat(APFloat::IEEEdouble, "0x1.1p0").convertToDouble());
 886   EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble, "0x1p0").convertToDouble());
 887
 888   EXPECT_EQ(convertToDoubleFromString("0x1p-150"),
 889             convertToDoubleFromString("+0x800000000000000001.p-221"));
 890   EXPECT_EQ(2251799813685248.5,
 891             convertToDoubleFromString("0x80000000000004000000.010p-28"));
 892 }
 893
 894 TEST(APFloatTest, toString) {
 895   ASSERT_EQ("10", convertToString(10.0, 6, 3));
 896   ASSERT_EQ("1.0E+1", convertToString(10.0, 6, 0));
 897   ASSERT_EQ("10100", convertToString(1.01E+4, 5, 2));
 898   ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 4, 2));
 899   ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 5, 1));
 900   ASSERT_EQ("0.0101", convertToString(1.01E-2, 5, 2));
 901   ASSERT_EQ("0.0101", convertToString(1.01E-2, 4, 2));
 902   ASSERT_EQ("1.01E-2", convertToString(1.01E-2, 5, 1));
 903   ASSERT_EQ("0.78539816339744828", convertToString(0.78539816339744830961, 0, 3));
 904   ASSERT_EQ("4.9406564584124654E-324", convertToString(4.9406564584124654e-324, 0, 3));
 905   ASSERT_EQ("873.18340000000001", convertToString(873.1834, 0, 1));
 906   ASSERT_EQ("8.7318340000000001E+2", convertToString(873.1834, 0, 0));
 907   ASSERT_EQ("1.7976931348623157E+308", convertToString(1.7976931348623157E+308, 0, 0));
 908 }
 909
 910 TEST(APFloatTest, toInteger) {
 911   bool isExact = false;
 912   APSInt result(5, /*isUnsigned=*/true);
 913
 914   EXPECT_EQ(APFloat::opOK,
 915             APFloat(APFloat::IEEEdouble, "10")
 916             .convertToInteger(result, APFloat::rmTowardZero, &isExact));
 917   EXPECT_TRUE(isExact);
 918   EXPECT_EQ(APSInt(APInt(5, 10), true), result);
 919
 920   EXPECT_EQ(APFloat::opInvalidOp,
 921             APFloat(APFloat::IEEEdouble, "-10")
 922             .convertToInteger(result, APFloat::rmTowardZero, &isExact));
 923   EXPECT_FALSE(isExact);
 924   EXPECT_EQ(APSInt::getMinValue(5, true), result);
 925
 926   EXPECT_EQ(APFloat::opInvalidOp,
 927             APFloat(APFloat::IEEEdouble, "32")
 928             .convertToInteger(result, APFloat::rmTowardZero, &isExact));
 929   EXPECT_FALSE(isExact);
 930   EXPECT_EQ(APSInt::getMaxValue(5, true), result);
 931
 932   EXPECT_EQ(APFloat::opInexact,
 933             APFloat(APFloat::IEEEdouble, "7.9")
 934             .convertToInteger(result, APFloat::rmTowardZero, &isExact));
 935   EXPECT_FALSE(isExact);
 936   EXPECT_EQ(APSInt(APInt(5, 7), true), result);
 937
 938   result.setIsUnsigned(false);
 939   EXPECT_EQ(APFloat::opOK,
 940             APFloat(APFloat::IEEEdouble, "-10")
 941             .convertToInteger(result, APFloat::rmTowardZero, &isExact));
 942   EXPECT_TRUE(isExact);
 943   EXPECT_EQ(APSInt(APInt(5, -10, true), false), result);
 944
 945   EXPECT_EQ(APFloat::opInvalidOp,
 946             APFloat(APFloat::IEEEdouble, "-17")
 947             .convertToInteger(result, APFloat::rmTowardZero, &isExact));
 948   EXPECT_FALSE(isExact);
 949   EXPECT_EQ(APSInt::getMinValue(5, false), result);
 950
 951   EXPECT_EQ(APFloat::opInvalidOp,
 952             APFloat(APFloat::IEEEdouble, "16")
 953             .convertToInteger(result, APFloat::rmTowardZero, &isExact));
 954   EXPECT_FALSE(isExact);
 955   EXPECT_EQ(APSInt::getMaxValue(5, false), result);
 956 }
 957
 958 static APInt nanbits(const fltSemantics &Sem,
 959                      bool SNaN, bool Negative, uint64_t fill) {
 960   APInt apfill(64, fill);
 961   if (SNaN)
 962     return APFloat::getSNaN(Sem, Negative, &apfill).bitcastToAPInt();
 963   else
 964     return APFloat::getQNaN(Sem, Negative, &apfill).bitcastToAPInt();
 965 }
 966
 967 TEST(APFloatTest, makeNaN) {
 968   ASSERT_EQ(0x7fc00000, nanbits(APFloat::IEEEsingle, false, false, 0));
 969   ASSERT_EQ(0xffc00000, nanbits(APFloat::IEEEsingle, false, true, 0));
 970   ASSERT_EQ(0x7fc0ae72, nanbits(APFloat::IEEEsingle, false, false, 0xae72));
 971   ASSERT_EQ(0x7fffae72, nanbits(APFloat::IEEEsingle, false, false, 0xffffae72));
 972   ASSERT_EQ(0x7fa00000, nanbits(APFloat::IEEEsingle, true, false, 0));
 973   ASSERT_EQ(0xffa00000, nanbits(APFloat::IEEEsingle, true, true, 0));
 974   ASSERT_EQ(0x7f80ae72, nanbits(APFloat::IEEEsingle, true, false, 0xae72));
 975   ASSERT_EQ(0x7fbfae72, nanbits(APFloat::IEEEsingle, true, false, 0xffffae72));
 976
 977   ASSERT_EQ(0x7ff8000000000000ULL, nanbits(APFloat::IEEEdouble, false, false, 0));
 978   ASSERT_EQ(0xfff8000000000000ULL, nanbits(APFloat::IEEEdouble, false, true, 0));
 979   ASSERT_EQ(0x7ff800000000ae72ULL, nanbits(APFloat::IEEEdouble, false, false, 0xae72));
 980   ASSERT_EQ(0x7fffffffffffae72ULL, nanbits(APFloat::IEEEdouble, false, false, 0xffffffffffffae72ULL));
 981   ASSERT_EQ(0x7ff4000000000000ULL, nanbits(APFloat::IEEEdouble, true, false, 0));
 982   ASSERT_EQ(0xfff4000000000000ULL, nanbits(APFloat::IEEEdouble, true, true, 0));
 983   ASSERT_EQ(0x7ff000000000ae72ULL, nanbits(APFloat::IEEEdouble, true, false, 0xae72));
 984   ASSERT_EQ(0x7ff7ffffffffae72ULL, nanbits(APFloat::IEEEdouble, true, false, 0xffffffffffffae72ULL));
 985 }
 986
 987 #ifdef GTEST_HAS_DEATH_TEST
 988 #ifndef NDEBUG
 989 TEST(APFloatTest, SemanticsDeath) {
 990   EXPECT_DEATH(APFloat(APFloat::IEEEsingle, 0.0f).convertToDouble(), "Float semantics are not IEEEdouble");
 991   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, 0.0 ).convertToFloat(),  "Float semantics are not IEEEsingle");
 992 }
 993
 994 TEST(APFloatTest, StringDecimalDeath) {
 995   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  ""), "Invalid string length");
 996   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+"), "String has no digits");
 997   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-"), "String has no digits");
 998
 999   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("\0", 1)), "Invalid character in significand");
1000   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1\0", 2)), "Invalid character in significand");
1001   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1\02", 3)), "Invalid character in significand");
1002   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1\02e1", 5)), "Invalid character in significand");
1003   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1e\0", 3)), "Invalid character in exponent");
1004   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1e1\0", 4)), "Invalid character in exponent");
1005   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1e1\02", 5)), "Invalid character in exponent");
1006
1007   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0f"), "Invalid character in significand");
1008
1009   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".."), "String contains multiple dots");
1010   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "..0"), "String contains multiple dots");
1011   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0.0"), "String contains multiple dots");
1012 }
1013
1014 TEST(APFloatTest, StringDecimalSignificandDeath) {
1015   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "."), "Significand has no digits");
1016   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+."), "Significand has no digits");
1017   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-."), "Significand has no digits");
1018
1019
1020   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "e"), "Significand has no digits");
1021   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+e"), "Significand has no digits");
1022   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-e"), "Significand has no digits");
1023
1024   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "e1"), "Significand has no digits");
1025   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+e1"), "Significand has no digits");
1026   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-e1"), "Significand has no digits");
1027
1028   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  ".e1"), "Significand has no digits");
1029   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+.e1"), "Significand has no digits");
1030   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-.e1"), "Significand has no digits");
1031
1032
1033   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  ".e"), "Significand has no digits");
1034   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+.e"), "Significand has no digits");
1035   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-.e"), "Significand has no digits");
1036 }
1037
1038 TEST(APFloatTest, StringDecimalExponentDeath) {
1039   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,   "1e"), "Exponent has no digits");
1040   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "+1e"), "Exponent has no digits");
1041   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "-1e"), "Exponent has no digits");
1042
1043   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,   "1.e"), "Exponent has no digits");
1044   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "+1.e"), "Exponent has no digits");
1045   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "-1.e"), "Exponent has no digits");
1046
1047   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,   ".1e"), "Exponent has no digits");
1048   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "+.1e"), "Exponent has no digits");
1049   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "-.1e"), "Exponent has no digits");
1050
1051   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,   "1.1e"), "Exponent has no digits");
1052   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "+1.1e"), "Exponent has no digits");
1053   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "-1.1e"), "Exponent has no digits");
1054
1055
1056   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1e+"), "Exponent has no digits");
1057   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1e-"), "Exponent has no digits");
1058
1059   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  ".1e"), "Exponent has no digits");
1060   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".1e+"), "Exponent has no digits");
1061   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".1e-"), "Exponent has no digits");
1062
1063   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "1.0e"), "Exponent has no digits");
1064   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0e+"), "Exponent has no digits");
1065   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0e-"), "Exponent has no digits");
1066 }
1067
1068 TEST(APFloatTest, StringHexadecimalDeath) {
1069   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x"), "Invalid string");
1070   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x"), "Invalid string");
1071   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x"), "Invalid string");
1072
1073   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x0"), "Hex strings require an exponent");
1074   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x0"), "Hex strings require an exponent");
1075   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x0"), "Hex strings require an exponent");
1076
1077   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x0."), "Hex strings require an exponent");
1078   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x0."), "Hex strings require an exponent");
1079   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x0."), "Hex strings require an exponent");
1080
1081   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x.0"), "Hex strings require an exponent");
1082   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.0"), "Hex strings require an exponent");
1083   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.0"), "Hex strings require an exponent");
1084
1085   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x0.0"), "Hex strings require an exponent");
1086   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x0.0"), "Hex strings require an exponent");
1087   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x0.0"), "Hex strings require an exponent");
1088
1089   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x\0", 3)), "Invalid character in significand");
1090   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1\0", 4)), "Invalid character in significand");
1091   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1\02", 5)), "Invalid character in significand");
1092   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1\02p1", 7)), "Invalid character in significand");
1093   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1p\0", 5)), "Invalid character in exponent");
1094   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1p1\0", 6)), "Invalid character in exponent");
1095   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1p1\02", 7)), "Invalid character in exponent");
1096
1097   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1p0f"), "Invalid character in exponent");
1098
1099   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x..p1"), "String contains multiple dots");
1100   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x..0p1"), "String contains multiple dots");
1101   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.0.0p1"), "String contains multiple dots");
1102 }
1103
1104 TEST(APFloatTest, StringHexadecimalSignificandDeath) {
1105   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x."), "Significand has no digits");
1106   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x."), "Significand has no digits");
1107   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x."), "Significand has no digits");
1108
1109   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0xp"), "Significand has no digits");
1110   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0xp"), "Significand has no digits");
1111   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0xp"), "Significand has no digits");
1112
1113   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0xp+"), "Significand has no digits");
1114   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0xp+"), "Significand has no digits");
1115   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0xp+"), "Significand has no digits");
1116
1117   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0xp-"), "Significand has no digits");
1118   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0xp-"), "Significand has no digits");
1119   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0xp-"), "Significand has no digits");
1120
1121
1122   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x.p"), "Significand has no digits");
1123   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.p"), "Significand has no digits");
1124   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.p"), "Significand has no digits");
1125
1126   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x.p+"), "Significand has no digits");
1127   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.p+"), "Significand has no digits");
1128   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.p+"), "Significand has no digits");
1129
1130   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x.p-"), "Significand has no digits");
1131   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.p-"), "Significand has no digits");
1132   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.p-"), "Significand has no digits");
1133 }
1134
1135 TEST(APFloatTest, StringHexadecimalExponentDeath) {
1136   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x1p"), "Exponent has no digits");
1137   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1p"), "Exponent has no digits");
1138   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1p"), "Exponent has no digits");
1139
1140   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x1p+"), "Exponent has no digits");
1141   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1p+"), "Exponent has no digits");
1142   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1p+"), "Exponent has no digits");
1143
1144   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x1p-"), "Exponent has no digits");
1145   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1p-"), "Exponent has no digits");
1146   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1p-"), "Exponent has no digits");
1147
1148
1149   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x1.p"), "Exponent has no digits");
1150   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.p"), "Exponent has no digits");
1151   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.p"), "Exponent has no digits");
1152
1153   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x1.p+"), "Exponent has no digits");
1154   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.p+"), "Exponent has no digits");
1155   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.p+"), "Exponent has no digits");
1156
1157   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x1.p-"), "Exponent has no digits");
1158   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.p-"), "Exponent has no digits");
1159   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.p-"), "Exponent has no digits");
1160
1161
1162   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x.1p"), "Exponent has no digits");
1163   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.1p"), "Exponent has no digits");
1164   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.1p"), "Exponent has no digits");
1165
1166   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x.1p+"), "Exponent has no digits");
1167   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.1p+"), "Exponent has no digits");
1168   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.1p+"), "Exponent has no digits");
1169
1170   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x.1p-"), "Exponent has no digits");
1171   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.1p-"), "Exponent has no digits");
1172   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.1p-"), "Exponent has no digits");
1173
1174
1175   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x1.1p"), "Exponent has no digits");
1176   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.1p"), "Exponent has no digits");
1177   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.1p"), "Exponent has no digits");
1178
1179   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x1.1p+"), "Exponent has no digits");
1180   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.1p+"), "Exponent has no digits");
1181   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.1p+"), "Exponent has no digits");
1182
1183   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x1.1p-"), "Exponent has no digits");
1184   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.1p-"), "Exponent has no digits");
1185   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.1p-"), "Exponent has no digits");
1186 }
1187 #endif
1188 #endif
1189
1190 TEST(APFloatTest, exactInverse) {
1191   APFloat inv(0.0f);
1192
1193   // Trivial operation.
1194   EXPECT_TRUE(APFloat(2.0).getExactInverse(&inv));
1195   EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5)));
1196   EXPECT_TRUE(APFloat(2.0f).getExactInverse(&inv));
1197   EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5f)));
1198   EXPECT_TRUE(APFloat(APFloat::IEEEquad, "2.0").getExactInverse(&inv));
1199   EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::IEEEquad, "0.5")));
1200   EXPECT_TRUE(APFloat(APFloat::PPCDoubleDouble, "2.0").getExactInverse(&inv));
1201   EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::PPCDoubleDouble, "0.5")));
1202   EXPECT_TRUE(APFloat(APFloat::x87DoubleExtended, "2.0").getExactInverse(&inv));
1203   EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::x87DoubleExtended, "0.5")));
1204
1205   // FLT_MIN
1206   EXPECT_TRUE(APFloat(1.17549435e-38f).getExactInverse(&inv));
1207   EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(8.5070592e+37f)));
1208
1209   // Large float, inverse is a denormal.
1210   EXPECT_FALSE(APFloat(1.7014118e38f).getExactInverse(nullptr));
1211   // Zero
1212   EXPECT_FALSE(APFloat(0.0).getExactInverse(nullptr));
1213   // Denormalized float
1214   EXPECT_FALSE(APFloat(1.40129846e-45f).getExactInverse(nullptr));
1215 }
1216
1217 TEST(APFloatTest, roundToIntegral) {
1218   APFloat T(-0.5), S(3.14), R(APFloat::getLargest(APFloat::IEEEdouble)), P(0.0);
1219
1220   P = T;
1221   P.roundToIntegral(APFloat::rmTowardZero);
1222   EXPECT_EQ(-0.0, P.convertToDouble());
1223   P = T;
1224   P.roundToIntegral(APFloat::rmTowardNegative);
1225   EXPECT_EQ(-1.0, P.convertToDouble());
1226   P = T;
1227   P.roundToIntegral(APFloat::rmTowardPositive);
1228   EXPECT_EQ(-0.0, P.convertToDouble());
1229   P = T;
1230   P.roundToIntegral(APFloat::rmNearestTiesToEven);
1231   EXPECT_EQ(-0.0, P.convertToDouble());
1232
1233   P = S;
1234   P.roundToIntegral(APFloat::rmTowardZero);
1235   EXPECT_EQ(3.0, P.convertToDouble());
1236   P = S;
1237   P.roundToIntegral(APFloat::rmTowardNegative);
1238   EXPECT_EQ(3.0, P.convertToDouble());
1239   P = S;
1240   P.roundToIntegral(APFloat::rmTowardPositive);
1241   EXPECT_EQ(4.0, P.convertToDouble());
1242   P = S;
1243   P.roundToIntegral(APFloat::rmNearestTiesToEven);
1244   EXPECT_EQ(3.0, P.convertToDouble());
1245
1246   P = R;
1247   P.roundToIntegral(APFloat::rmTowardZero);
1248   EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1249   P = R;
1250   P.roundToIntegral(APFloat::rmTowardNegative);
1251   EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1252   P = R;
1253   P.roundToIntegral(APFloat::rmTowardPositive);
1254   EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1255   P = R;
1256   P.roundToIntegral(APFloat::rmNearestTiesToEven);
1257   EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1258
1259   P = APFloat::getZero(APFloat::IEEEdouble);
1260   P.roundToIntegral(APFloat::rmTowardZero);
1261   EXPECT_EQ(0.0, P.convertToDouble());
1262   P = APFloat::getZero(APFloat::IEEEdouble, true);
1263   P.roundToIntegral(APFloat::rmTowardZero);
1264   EXPECT_EQ(-0.0, P.convertToDouble());
1265   P = APFloat::getNaN(APFloat::IEEEdouble);
1266   P.roundToIntegral(APFloat::rmTowardZero);
1267   EXPECT_TRUE(IsNAN(P.convertToDouble()));
1268   P = APFloat::getInf(APFloat::IEEEdouble);
1269   P.roundToIntegral(APFloat::rmTowardZero);
1270   EXPECT_TRUE(IsInf(P.convertToDouble()) && P.convertToDouble() > 0.0);
1271   P = APFloat::getInf(APFloat::IEEEdouble, true);
1272   P.roundToIntegral(APFloat::rmTowardZero);
1273   EXPECT_TRUE(IsInf(P.convertToDouble()) && P.convertToDouble() < 0.0);
1274
1275 }
1276
1277 TEST(APFloatTest, getLargest) {
1278   EXPECT_EQ(3.402823466e+38f, APFloat::getLargest(APFloat::IEEEsingle).convertToFloat());
1279   EXPECT_EQ(1.7976931348623158e+308, APFloat::getLargest(APFloat::IEEEdouble).convertToDouble());
1280 }
1281
1282 TEST(APFloatTest, getSmallest) {
1283   APFloat test = APFloat::getSmallest(APFloat::IEEEsingle, false);
1284   APFloat expected = APFloat(APFloat::IEEEsingle, "0x0.000002p-126");
1285   EXPECT_FALSE(test.isNegative());
1286   EXPECT_TRUE(test.isFiniteNonZero());
1287   EXPECT_TRUE(test.isDenormal());
1288   EXPECT_TRUE(test.bitwiseIsEqual(expected));
1289
1290   test = APFloat::getSmallest(APFloat::IEEEsingle, true);
1291   expected = APFloat(APFloat::IEEEsingle, "-0x0.000002p-126");
1292   EXPECT_TRUE(test.isNegative());
1293   EXPECT_TRUE(test.isFiniteNonZero());
1294   EXPECT_TRUE(test.isDenormal());
1295   EXPECT_TRUE(test.bitwiseIsEqual(expected));
1296
1297   test = APFloat::getSmallest(APFloat::IEEEquad, false);
1298   expected = APFloat(APFloat::IEEEquad, "0x0.0000000000000000000000000001p-16382");
1299   EXPECT_FALSE(test.isNegative());
1300   EXPECT_TRUE(test.isFiniteNonZero());
1301   EXPECT_TRUE(test.isDenormal());
1302   EXPECT_TRUE(test.bitwiseIsEqual(expected));
1303
1304   test = APFloat::getSmallest(APFloat::IEEEquad, true);
1305   expected = APFloat(APFloat::IEEEquad, "-0x0.0000000000000000000000000001p-16382");
1306   EXPECT_TRUE(test.isNegative());
1307   EXPECT_TRUE(test.isFiniteNonZero());
1308   EXPECT_TRUE(test.isDenormal());
1309   EXPECT_TRUE(test.bitwiseIsEqual(expected));
1310 }
1311
1312 TEST(APFloatTest, getSmallestNormalized) {
1313   APFloat test = APFloat::getSmallestNormalized(APFloat::IEEEsingle, false);
1314   APFloat expected = APFloat(APFloat::IEEEsingle, "0x1p-126");
1315   EXPECT_FALSE(test.isNegative());
1316   EXPECT_TRUE(test.isFiniteNonZero());
1317   EXPECT_FALSE(test.isDenormal());
1318   EXPECT_TRUE(test.bitwiseIsEqual(expected));
1319
1320   test = APFloat::getSmallestNormalized(APFloat::IEEEsingle, true);
1321   expected = APFloat(APFloat::IEEEsingle, "-0x1p-126");
1322   EXPECT_TRUE(test.isNegative());
1323   EXPECT_TRUE(test.isFiniteNonZero());
1324   EXPECT_FALSE(test.isDenormal());
1325   EXPECT_TRUE(test.bitwiseIsEqual(expected));
1326
1327   test = APFloat::getSmallestNormalized(APFloat::IEEEquad, false);
1328   expected = APFloat(APFloat::IEEEquad, "0x1p-16382");
1329   EXPECT_FALSE(test.isNegative());
1330   EXPECT_TRUE(test.isFiniteNonZero());
1331   EXPECT_FALSE(test.isDenormal());
1332   EXPECT_TRUE(test.bitwiseIsEqual(expected));
1333
1334   test = APFloat::getSmallestNormalized(APFloat::IEEEquad, true);
1335   expected = APFloat(APFloat::IEEEquad, "-0x1p-16382");
1336   EXPECT_TRUE(test.isNegative());
1337   EXPECT_TRUE(test.isFiniteNonZero());
1338   EXPECT_FALSE(test.isDenormal());
1339   EXPECT_TRUE(test.bitwiseIsEqual(expected));
1340 }
1341
1342 TEST(APFloatTest, getZero) {
1343   struct {
1344     const fltSemantics *semantics;
1345     const bool sign;
1346     const unsigned long long bitPattern[2];
1347     const unsigned bitPatternLength;
1348   } const GetZeroTest[] = {
1349     { &APFloat::IEEEhalf, false, {0, 0}, 1},
1350     { &APFloat::IEEEhalf, true, {0x8000ULL, 0}, 1},
1351     { &APFloat::IEEEsingle, false, {0, 0}, 1},
1352     { &APFloat::IEEEsingle, true, {0x80000000ULL, 0}, 1},
1353     { &APFloat::IEEEdouble, false, {0, 0}, 1},
1354     { &APFloat::IEEEdouble, true, {0x8000000000000000ULL, 0}, 1},
1355     { &APFloat::IEEEquad, false, {0, 0}, 2},
1356     { &APFloat::IEEEquad, true, {0, 0x8000000000000000ULL}, 2},
1357     { &APFloat::PPCDoubleDouble, false, {0, 0}, 2},
1358     { &APFloat::PPCDoubleDouble, true, {0x8000000000000000ULL, 0}, 2},
1359     { &APFloat::x87DoubleExtended, false, {0, 0}, 2},
1360     { &APFloat::x87DoubleExtended, true, {0, 0x8000ULL}, 2},
1361   };
1362   const unsigned NumGetZeroTests = 12;
1363   for (unsigned i = 0; i < NumGetZeroTests; ++i) {
1364     APFloat test = APFloat::getZero(*GetZeroTest[i].semantics,
1365                                     GetZeroTest[i].sign);
1366     const char *pattern = GetZeroTest[i].sign? "-0x0p+0" : "0x0p+0";
1367     APFloat expected = APFloat(*GetZeroTest[i].semantics,
1368                                pattern);
1369     EXPECT_TRUE(test.isZero());
1370     EXPECT_TRUE(GetZeroTest[i].sign? test.isNegative() : !test.isNegative());
1371     EXPECT_TRUE(test.bitwiseIsEqual(expected));
1372     for (unsigned j = 0, je = GetZeroTest[i].bitPatternLength; j < je; ++j) {
1373       EXPECT_EQ(GetZeroTest[i].bitPattern[j],
1374                 test.bitcastToAPInt().getRawData()[j]);
1375     }
1376   }
1377 }
1378
1379 TEST(APFloatTest, copySign) {
1380   EXPECT_TRUE(APFloat(-42.0).bitwiseIsEqual(
1381       APFloat::copySign(APFloat(42.0), APFloat(-1.0))));
1382   EXPECT_TRUE(APFloat(42.0).bitwiseIsEqual(
1383       APFloat::copySign(APFloat(-42.0), APFloat(1.0))));
1384   EXPECT_TRUE(APFloat(-42.0).bitwiseIsEqual(
1385       APFloat::copySign(APFloat(-42.0), APFloat(-1.0))));
1386   EXPECT_TRUE(APFloat(42.0).bitwiseIsEqual(
1387       APFloat::copySign(APFloat(42.0), APFloat(1.0))));
1388 }
1389
1390 TEST(APFloatTest, convert) {
1391   bool losesInfo;
1392   APFloat test(APFloat::IEEEdouble, "1.0");
1393   test.convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven, &losesInfo);
1394   EXPECT_EQ(1.0f, test.convertToFloat());
1395   EXPECT_FALSE(losesInfo);
1396
1397   test = APFloat(APFloat::x87DoubleExtended, "0x1p-53");
1398   test.add(APFloat(APFloat::x87DoubleExtended, "1.0"), APFloat::rmNearestTiesToEven);
1399   test.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, &losesInfo);
1400   EXPECT_EQ(1.0, test.convertToDouble());
1401   EXPECT_TRUE(losesInfo);
1402
1403   test = APFloat(APFloat::IEEEquad, "0x1p-53");
1404   test.add(APFloat(APFloat::IEEEquad, "1.0"), APFloat::rmNearestTiesToEven);
1405   test.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, &losesInfo);
1406   EXPECT_EQ(1.0, test.convertToDouble());
1407   EXPECT_TRUE(losesInfo);
1408
1409   test = APFloat(APFloat::x87DoubleExtended, "0xf.fffffffp+28");
1410   test.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, &losesInfo);
1411   EXPECT_EQ(4294967295.0, test.convertToDouble());
1412   EXPECT_FALSE(losesInfo);
1413
1414   test = APFloat::getSNaN(APFloat::IEEEsingle);
1415   APFloat X87SNaN = APFloat::getSNaN(APFloat::x87DoubleExtended);
1416   test.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven,
1417                &losesInfo);
1418   EXPECT_TRUE(test.bitwiseIsEqual(X87SNaN));
1419   EXPECT_FALSE(losesInfo);
1420
1421   test = APFloat::getQNaN(APFloat::IEEEsingle);
1422   APFloat X87QNaN = APFloat::getQNaN(APFloat::x87DoubleExtended);
1423   test.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven,
1424                &losesInfo);
1425   EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN));
1426   EXPECT_FALSE(losesInfo);
1427
1428   test = APFloat::getSNaN(APFloat::x87DoubleExtended);
1429   test.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven,
1430                &losesInfo);
1431   EXPECT_TRUE(test.bitwiseIsEqual(X87SNaN));
1432   EXPECT_FALSE(losesInfo);
1433
1434   test = APFloat::getQNaN(APFloat::x87DoubleExtended);
1435   test.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven,
1436                &losesInfo);
1437   EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN));
1438   EXPECT_FALSE(losesInfo);
1439 }
1440
1441 TEST(APFloatTest, PPCDoubleDouble) {
1442   APFloat test(APFloat::PPCDoubleDouble, "1.0");
1443   EXPECT_EQ(0x3ff0000000000000ull, test.bitcastToAPInt().getRawData()[0]);
1444   EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1445
1446   test.divide(APFloat(APFloat::PPCDoubleDouble, "3.0"), APFloat::rmNearestTiesToEven);
1447   EXPECT_EQ(0x3fd5555555555555ull, test.bitcastToAPInt().getRawData()[0]);
1448   EXPECT_EQ(0x3c75555555555556ull, test.bitcastToAPInt().getRawData()[1]);
1449
1450   // LDBL_MAX
1451   test = APFloat(APFloat::PPCDoubleDouble, "1.79769313486231580793728971405301e+308");
1452   EXPECT_EQ(0x7fefffffffffffffull, test.bitcastToAPInt().getRawData()[0]);
1453   EXPECT_EQ(0x7c8ffffffffffffeull, test.bitcastToAPInt().getRawData()[1]);
1454
1455   // LDBL_MIN
1456   test = APFloat(APFloat::PPCDoubleDouble, "2.00416836000897277799610805135016e-292");
1457   EXPECT_EQ(0x0360000000000000ull, test.bitcastToAPInt().getRawData()[0]);
1458   EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1459
1460   test = APFloat(APFloat::PPCDoubleDouble, "1.0");
1461   test.add(APFloat(APFloat::PPCDoubleDouble, "0x1p-105"), APFloat::rmNearestTiesToEven);
1462   EXPECT_EQ(0x3ff0000000000000ull, test.bitcastToAPInt().getRawData()[0]);
1463   EXPECT_EQ(0x3960000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1464
1465   test = APFloat(APFloat::PPCDoubleDouble, "1.0");
1466   test.add(APFloat(APFloat::PPCDoubleDouble, "0x1p-106"), APFloat::rmNearestTiesToEven);
1467   EXPECT_EQ(0x3ff0000000000000ull, test.bitcastToAPInt().getRawData()[0]);
1468 #if 0 // XFAIL
1469   // This is what we would expect with a true double-double implementation
1470   EXPECT_EQ(0x3950000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1471 #else
1472   // This is what we get with our 106-bit mantissa approximation
1473   EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1474 #endif
1475 }
1476
1477 TEST(APFloatTest, isNegative) {
1478   APFloat t(APFloat::IEEEsingle, "0x1p+0");
1479   EXPECT_FALSE(t.isNegative());
1480   t = APFloat(APFloat::IEEEsingle, "-0x1p+0");
1481   EXPECT_TRUE(t.isNegative());
1482
1483   EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isNegative());
1484   EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle, true).isNegative());
1485
1486   EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isNegative());
1487   EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle, true).isNegative());
1488
1489   EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isNegative());
1490   EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle, true).isNegative());
1491
1492   EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isNegative());
1493   EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, true).isNegative());
1494 }
1495
1496 TEST(APFloatTest, isNormal) {
1497   APFloat t(APFloat::IEEEsingle, "0x1p+0");
1498   EXPECT_TRUE(t.isNormal());
1499
1500   EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isNormal());
1501   EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isNormal());
1502   EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isNormal());
1503   EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isNormal());
1504   EXPECT_FALSE(APFloat(APFloat::IEEEsingle, "0x1p-149").isNormal());
1505 }
1506
1507 TEST(APFloatTest, isFinite) {
1508   APFloat t(APFloat::IEEEsingle, "0x1p+0");
1509   EXPECT_TRUE(t.isFinite());
1510   EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isFinite());
1511   EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle, false).isFinite());
1512   EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isFinite());
1513   EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isFinite());
1514   EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "0x1p-149").isFinite());
1515 }
1516
1517 TEST(APFloatTest, isInfinity) {
1518   APFloat t(APFloat::IEEEsingle, "0x1p+0");
1519   EXPECT_FALSE(t.isInfinity());
1520   EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle, false).isInfinity());
1521   EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isInfinity());
1522   EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isInfinity());
1523   EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isInfinity());
1524   EXPECT_FALSE(APFloat(APFloat::IEEEsingle, "0x1p-149").isInfinity());
1525 }
1526
1527 TEST(APFloatTest, isNaN) {
1528   APFloat t(APFloat::IEEEsingle, "0x1p+0");
1529   EXPECT_FALSE(t.isNaN());
1530   EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isNaN());
1531   EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isNaN());
1532   EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle, false).isNaN());
1533   EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, false).isNaN());
1534   EXPECT_FALSE(APFloat(APFloat::IEEEsingle, "0x1p-149").isNaN());
1535 }
1536
1537 TEST(APFloatTest, isFiniteNonZero) {
1538   // Test positive/negative normal value.
1539   EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "0x1p+0").isFiniteNonZero());
1540   EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "-0x1p+0").isFiniteNonZero());
1541
1542   // Test positive/negative denormal value.
1543   EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "0x1p-149").isFiniteNonZero());
1544   EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "-0x1p-149").isFiniteNonZero());
1545
1546   // Test +/- Infinity.
1547   EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isFiniteNonZero());
1548   EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, true).isFiniteNonZero());
1549
1550   // Test +/- Zero.
1551   EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isFiniteNonZero());
1552   EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, true).isFiniteNonZero());
1553
1554   // Test +/- qNaN. +/- dont mean anything with qNaN but paranoia can't hurt in
1555   // this instance.
1556   EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isFiniteNonZero());
1557   EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, true).isFiniteNonZero());
1558
1559   // Test +/- sNaN. +/- dont mean anything with sNaN but paranoia can't hurt in
1560   // this instance.
1561   EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isFiniteNonZero());
1562   EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, true).isFiniteNonZero());
1563 }
1564
1565 TEST(APFloatTest, add) {
1566   // Test Special Cases against each other and normal values.
1567
1568   // TODOS/NOTES:
1569   // 1. Since we perform only default exception handling all operations with
1570   // signaling NaNs should have a result that is a quiet NaN. Currently they
1571   // return sNaN.
1572
1573   APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false);
1574   APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true);
1575   APFloat PZero = APFloat::getZero(APFloat::IEEEsingle, false);
1576   APFloat MZero = APFloat::getZero(APFloat::IEEEsingle, true);
1577   APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle, false);
1578   APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle, false);
1579   APFloat PNormalValue = APFloat(APFloat::IEEEsingle, "0x1p+0");
1580   APFloat MNormalValue = APFloat(APFloat::IEEEsingle, "-0x1p+0");
1581   APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle, false);
1582   APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle, true);
1583   APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, false);
1584   APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, true);
1585   APFloat PSmallestNormalized =
1586     APFloat::getSmallestNormalized(APFloat::IEEEsingle, false);
1587   APFloat MSmallestNormalized =
1588     APFloat::getSmallestNormalized(APFloat::IEEEsingle, true);
1589
1590   const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
1591
1592   const unsigned NumTests = 169;
1593   struct {
1594     APFloat x;
1595     APFloat y;
1596     const char *result;
1597     int status;
1598     int category;
1599   } SpecialCaseTests[NumTests] = {
1600     { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1601     { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1602     { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
1603     { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
1604     { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1605 #if 0
1606     // See Note 1.
1607     { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1608 #endif
1609     { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1610     { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1611     { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1612     { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1613     { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1614     { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1615     { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
1616     { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
1617     { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1618     { MInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1619     { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
1620     { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
1621     { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1622 #if 0
1623     // See Note 1.
1624     { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1625 #endif
1626     { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1627     { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1628     { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1629     { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1630     { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1631     { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1632     { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
1633     { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
1634     { PZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1635     { PZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1636     { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1637     { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1638     { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1639 #if 0
1640     // See Note 1.
1641     { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1642 #endif
1643     { PZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1644     { PZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1645     { PZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1646     { PZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1647     { PZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1648     { PZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1649     { PZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1650     { PZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1651     { MZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1652     { MZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1653     { MZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1654     { MZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
1655     { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1656 #if 0
1657     // See Note 1.
1658     { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1659 #endif
1660     { MZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1661     { MZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1662     { MZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1663     { MZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1664     { MZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1665     { MZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1666     { MZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1667     { MZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1668     { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
1669     { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
1670     { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
1671     { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
1672     { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1673 #if 0
1674     // See Note 1.
1675     { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1676 #endif
1677     { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
1678     { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
1679     { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1680     { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1681     { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1682     { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1683     { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
1684     { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
1685 #if 0
1686     // See Note 1.
1687     { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1688     { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1689     { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1690     { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1691     { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1692     { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1693     { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1694     { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1695     { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1696     { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1697     { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1698     { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1699     { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1700     { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1701 #endif
1702     { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1703     { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1704     { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1705     { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1706     { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1707 #if 0
1708     // See Note 1.
1709     { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1710 #endif
1711     { PNormalValue, PNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal },
1712     { PNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1713     { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1714     { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1715     { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1716     { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1717     { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1718     { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1719     { MNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1720     { MNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1721     { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1722     { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1723     { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1724 #if 0
1725     // See Note 1.
1726     { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1727 #endif
1728     { MNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1729     { MNormalValue, MNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal },
1730     { MNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1731     { MNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1732     { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1733     { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1734     { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1735     { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1736     { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1737     { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1738     { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1739     { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1740     { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1741 #if 0
1742     // See Note 1.
1743     { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1744 #endif
1745     { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1746     { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1747     { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
1748     { PLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1749     { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1750     { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1751     { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1752     { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1753     { MLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1754     { MLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1755     { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1756     { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1757     { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1758 #if 0
1759     // See Note 1.
1760     { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1761 #endif
1762     { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1763     { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1764     { MLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1765     { MLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
1766     { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1767     { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1768     { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1769     { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1770     { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1771     { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1772     { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1773     { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1774     { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1775 #if 0
1776     // See Note 1.
1777     { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1778 #endif
1779     { PSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1780     { PSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1781     { PSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1782     { PSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1783     { PSmallestValue, PSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal },
1784     { PSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1785     { PSmallestValue, PSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1786     { PSmallestValue, MSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1787     { MSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1788     { MSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1789     { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1790     { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1791     { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1792 #if 0
1793     // See Note 1.
1794     { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1795 #endif
1796     { MSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1797     { MSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1798     { MSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1799     { MSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1800     { MSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1801     { MSmallestValue, MSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal },
1802     { MSmallestValue, PSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1803     { MSmallestValue, MSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1804     { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1805     { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1806     { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1807     { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1808     { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1809 #if 0
1810 // See Note 1.
1811     { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1812 #endif
1813     { PSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1814     { PSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1815     { PSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1816     { PSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1817     { PSmallestNormalized, PSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1818     { PSmallestNormalized, MSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1819     { PSmallestNormalized, PSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
1820     { PSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1821     { MSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1822     { MSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1823     { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1824     { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1825     { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1826 #if 0
1827     // See Note 1.
1828     { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1829 #endif
1830     { MSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1831     { MSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1832     { MSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1833     { MSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1834     { MSmallestNormalized, PSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1835     { MSmallestNormalized, MSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1836     { MSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1837     { MSmallestNormalized, MSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal }
1838   };
1839
1840   for (size_t i = 0; i < NumTests; ++i) {
1841     APFloat x(SpecialCaseTests[i].x);
1842     APFloat y(SpecialCaseTests[i].y);
1843     APFloat::opStatus status = x.add(y, APFloat::rmNearestTiesToEven);
1844
1845     APFloat result(APFloat::IEEEsingle, SpecialCaseTests[i].result);
1846
1847     EXPECT_TRUE(result.bitwiseIsEqual(x));
1848     EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
1849     EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
1850   }
1851 }
1852
1853 TEST(APFloatTest, subtract) {
1854   // Test Special Cases against each other and normal values.
1855
1856   // TODOS/NOTES:
1857   // 1. Since we perform only default exception handling all operations with
1858   // signaling NaNs should have a result that is a quiet NaN. Currently they
1859   // return sNaN.
1860
1861   APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false);
1862   APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true);
1863   APFloat PZero = APFloat::getZero(APFloat::IEEEsingle, false);
1864   APFloat MZero = APFloat::getZero(APFloat::IEEEsingle, true);
1865   APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle, false);
1866   APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle, false);
1867   APFloat PNormalValue = APFloat(APFloat::IEEEsingle, "0x1p+0");
1868   APFloat MNormalValue = APFloat(APFloat::IEEEsingle, "-0x1p+0");
1869   APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle, false);
1870   APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle, true);
1871   APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, false);
1872   APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, true);
1873   APFloat PSmallestNormalized =
1874     APFloat::getSmallestNormalized(APFloat::IEEEsingle, false);
1875   APFloat MSmallestNormalized =
1876     APFloat::getSmallestNormalized(APFloat::IEEEsingle, true);
1877
1878   const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
1879
1880   const unsigned NumTests = 169;
1881   struct {
1882     APFloat x;
1883     APFloat y;
1884     const char *result;
1885     int status;
1886     int category;
1887   } SpecialCaseTests[NumTests] = {
1888     { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1889     { PInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1890     { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
1891     { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
1892     { PInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1893 #if 0
1894 // See Note 1.
1895     { PInf, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
1896 #endif
1897     { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1898     { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1899     { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1900     { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1901     { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1902     { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1903     { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
1904     { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
1905     { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1906     { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1907     { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
1908     { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
1909     { MInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1910 #if 0
1911 // See Note 1.
1912     { MInf, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
1913 #endif
1914     { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1915     { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1916     { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1917     { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1918     { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1919     { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1920     { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
1921     { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
1922     { PZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1923     { PZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1924     { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1925     { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1926     { PZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1927 #if 0
1928 // See Note 1.
1929     { PZero, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
1930 #endif
1931     { PZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1932     { PZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1933     { PZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1934     { PZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1935     { PZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1936     { PZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1937     { PZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1938     { PZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1939     { MZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1940     { MZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1941     { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
1942     { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1943     { MZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1944 #if 0
1945 // See Note 1.
1946     { MZero, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
1947 #endif
1948     { MZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1949     { MZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1950     { MZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1951     { MZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1952     { MZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1953     { MZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1954     { MZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1955     { MZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1956     { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
1957     { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
1958     { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
1959     { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
1960     { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1961 #if 0
1962 // See Note 1.
1963     { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1964 #endif
1965     { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
1966     { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
1967     { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1968     { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1969     { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1970     { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1971     { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
1972     { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
1973 #if 0
1974 // See Note 1.
1975     { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1976     { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1977     { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1978     { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1979     { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1980     { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1981     { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1982     { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1983     { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1984     { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1985     { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1986     { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1987     { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1988     { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1989 #endif
1990     { PNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1991     { PNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1992     { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1993     { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1994     { PNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1995 #if 0
1996 // See Note 1.
1997     { PNormalValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
1998 #endif
1999     { PNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2000     { PNormalValue, MNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal },
2001     { PNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2002     { PNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2003     { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2004     { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2005     { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2006     { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2007     { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2008     { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2009     { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2010     { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2011     { MNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2012 #if 0
2013 // See Note 1.
2014     { MNormalValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2015 #endif
2016     { MNormalValue, PNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal },
2017     { MNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2018     { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2019     { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2020     { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2021     { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2022     { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2023     { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2024     { PLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2025     { PLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2026     { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2027     { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2028     { PLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2029 #if 0
2030 // See Note 1.
2031     { PLargestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2032 #endif
2033     { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2034     { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2035     { PLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2036     { PLargestValue, MLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2037     { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2038     { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2039     { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2040     { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2041     { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2042     { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2043     { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2044     { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2045     { MLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2046 #if 0
2047 // See Note 1.
2048     { MLargestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2049 #endif
2050     { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2051     { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2052     { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2053     { MLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2054     { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2055     { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2056     { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2057     { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2058     { PSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2059     { PSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2060     { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2061     { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2062     { PSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2063 #if 0
2064 // See Note 1.
2065     { PSmallestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2066 #endif
2067     { PSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2068     { PSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2069     { PSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2070     { PSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2071     { PSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2072     { PSmallestValue, MSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal },
2073     { PSmallestValue, PSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2074     { PSmallestValue, MSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2075     { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2076     { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2077     { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2078     { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2079     { MSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2080 #if 0
2081 // See Note 1.
2082     { MSmallestValue, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2083 #endif
2084     { MSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2085     { MSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2086     { MSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2087     { MSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2088     { MSmallestValue, PSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal },
2089     { MSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2090     { MSmallestValue, PSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2091     { MSmallestValue, MSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2092     { PSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2093     { PSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2094     { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2095     { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2096     { PSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2097 #if 0
2098 // See Note 1.
2099     { PSmallestNormalized, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2100 #endif
2101     { PSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2102     { PSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2103     { PSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2104     { PSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2105     { PSmallestNormalized, PSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2106     { PSmallestNormalized, MSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2107     { PSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2108     { PSmallestNormalized, MSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
2109     { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2110     { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2111     { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2112     { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2113     { MSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2114 #if 0
2115 // See Note 1.
2116     { MSmallestNormalized, SNaN, "-nan", APFloat::opInvalidOp, APFloat::fcNaN },
2117 #endif
2118     { MSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2119     { MSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2120     { MSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2121     { MSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2122     { MSmallestNormalized, PSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2123     { MSmallestNormalized, MSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2124     { MSmallestNormalized, PSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
2125     { MSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }
2126   };
2127
2128   for (size_t i = 0; i < NumTests; ++i) {
2129     APFloat x(SpecialCaseTests[i].x);
2130     APFloat y(SpecialCaseTests[i].y);
2131     APFloat::opStatus status = x.subtract(y, APFloat::rmNearestTiesToEven);
2132
2133     APFloat result(APFloat::IEEEsingle, SpecialCaseTests[i].result);
2134
2135     EXPECT_TRUE(result.bitwiseIsEqual(x));
2136     EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
2137     EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
2138   }
2139 }
2140
2141 TEST(APFloatTest, multiply) {
2142   // Test Special Cases against each other and normal values.
2143
2144   // TODOS/NOTES:
2145   // 1. Since we perform only default exception handling all operations with
2146   // signaling NaNs should have a result that is a quiet NaN. Currently they
2147   // return sNaN.
2148
2149   APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false);
2150   APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true);
2151   APFloat PZero = APFloat::getZero(APFloat::IEEEsingle, false);
2152   APFloat MZero = APFloat::getZero(APFloat::IEEEsingle, true);
2153   APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle, false);
2154   APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle, false);
2155   APFloat PNormalValue = APFloat(APFloat::IEEEsingle, "0x1p+0");
2156   APFloat MNormalValue = APFloat(APFloat::IEEEsingle, "-0x1p+0");
2157   APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle, false);
2158   APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle, true);
2159   APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, false);
2160   APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, true);
2161   APFloat PSmallestNormalized =
2162     APFloat::getSmallestNormalized(APFloat::IEEEsingle, false);
2163   APFloat MSmallestNormalized =
2164     APFloat::getSmallestNormalized(APFloat::IEEEsingle, true);
2165
2166   const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
2167   const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact;
2168
2169   const unsigned NumTests = 169;
2170   struct {
2171     APFloat x;
2172     APFloat y;
2173     const char *result;
2174     int status;
2175     int category;
2176   } SpecialCaseTests[NumTests] = {
2177     { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2178     { PInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2179     { PInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2180     { PInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2181     { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2182 #if 0
2183 // See Note 1.
2184     { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2185 #endif
2186     { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2187     { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2188     { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2189     { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2190     { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2191     { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2192     { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2193     { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2194     { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2195     { MInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2196     { MInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2197     { MInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2198     { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2199 #if 0
2200 // See Note 1.
2201     { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2202 #endif
2203     { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2204     { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2205     { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2206     { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2207     { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2208     { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2209     { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2210     { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2211     { PZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2212     { PZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2213     { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2214     { PZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2215     { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2216 #if 0
2217 // See Note 1.
2218     { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2219 #endif
2220     { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2221     { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2222     { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2223     { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2224     { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2225     { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2226     { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2227     { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2228     { MZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2229     { MZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2230     { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2231     { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2232     { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2233 #if 0
2234 // See Note 1.
2235     { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2236 #endif
2237     { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2238     { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2239     { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2240     { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2241     { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2242     { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2243     { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2244     { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2245     { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2246     { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
2247     { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2248     { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
2249     { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2250 #if 0
2251 // See Note 1.
2252     { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2253 #endif
2254     { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2255     { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2256     { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2257     { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2258     { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2259     { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2260     { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2261     { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2262 #if 0
2263 // See Note 1.
2264     { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2265     { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2266     { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2267     { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2268     { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2269     { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2270     { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2271     { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2272     { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2273     { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2274     { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2275     { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2276     { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2277     { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2278 #endif
2279     { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2280     { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2281     { PNormalValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2282     { PNormalValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2283     { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2284 #if 0
2285 // See Note 1.
2286     { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2287 #endif
2288     { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2289     { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2290     { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2291     { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2292     { PNormalValue, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2293     { PNormalValue, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2294     { PNormalValue, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2295     { PNormalValue, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2296     { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2297     { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2298     { MNormalValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2299     { MNormalValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2300     { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2301 #if 0
2302 // See Note 1.
2303     { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2304 #endif
2305     { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2306     { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2307     { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2308     { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2309     { MNormalValue, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2310     { MNormalValue, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2311     { MNormalValue, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2312     { MNormalValue, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2313     { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2314     { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2315     { PLargestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2316     { PLargestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2317     { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2318 #if 0
2319 // See Note 1.
2320     { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2321 #endif
2322     { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2323     { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2324     { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2325     { PLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2326     { PLargestValue, PSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2327     { PLargestValue, MSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2328     { PLargestValue, PSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2329     { PLargestValue, MSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2330     { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2331     { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2332     { MLargestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2333     { MLargestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2334     { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2335 #if 0
2336 // See Note 1.
2337     { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2338 #endif
2339     { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2340     { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2341     { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2342     { MLargestValue, MLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2343     { MLargestValue, PSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2344     { MLargestValue, MSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2345     { MLargestValue, PSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2346     { MLargestValue, MSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2347     { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2348     { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2349     { PSmallestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2350     { PSmallestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2351     { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2352 #if 0
2353 // See Note 1.
2354     { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2355 #endif
2356     { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2357     { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2358     { PSmallestValue, PLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2359     { PSmallestValue, MLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2360     { PSmallestValue, PSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2361     { PSmallestValue, MSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2362     { PSmallestValue, PSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2363     { PSmallestValue, MSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2364     { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2365     { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2366     { MSmallestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2367     { MSmallestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2368     { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2369 #if 0
2370 // See Note 1.
2371     { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2372 #endif
2373     { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2374     { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2375     { MSmallestValue, PLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2376     { MSmallestValue, MLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2377     { MSmallestValue, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2378     { MSmallestValue, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2379     { MSmallestValue, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2380     { MSmallestValue, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2381     { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2382     { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2383     { PSmallestNormalized, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2384     { PSmallestNormalized, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2385     { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2386 #if 0
2387 // See Note 1.
2388     { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2389 #endif
2390     { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2391     { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2392     { PSmallestNormalized, PLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2393     { PSmallestNormalized, MLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2394     { PSmallestNormalized, PSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2395     { PSmallestNormalized, MSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2396     { PSmallestNormalized, PSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2397     { PSmallestNormalized, MSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2398     { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2399     { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2400     { MSmallestNormalized, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2401     { MSmallestNormalized, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2402     { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2403 #if 0
2404 // See Note 1.
2405     { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2406 #endif
2407     { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2408     { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2409     { MSmallestNormalized, PLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2410     { MSmallestNormalized, MLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2411     { MSmallestNormalized, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2412     { MSmallestNormalized, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2413     { MSmallestNormalized, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2414     { MSmallestNormalized, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero }
2415   };
2416
2417   for (size_t i = 0; i < NumTests; ++i) {
2418     APFloat x(SpecialCaseTests[i].x);
2419     APFloat y(SpecialCaseTests[i].y);
2420     APFloat::opStatus status = x.multiply(y, APFloat::rmNearestTiesToEven);
2421
2422     APFloat result(APFloat::IEEEsingle, SpecialCaseTests[i].result);
2423
2424     EXPECT_TRUE(result.bitwiseIsEqual(x));
2425     EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
2426     EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
2427   }
2428 }
2429
2430 TEST(APFloatTest, divide) {
2431   // Test Special Cases against each other and normal values.
2432
2433   // TODOS/NOTES:
2434   // 1. Since we perform only default exception handling all operations with
2435   // signaling NaNs should have a result that is a quiet NaN. Currently they
2436   // return sNaN.
2437
2438   APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false);
2439   APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true);
2440   APFloat PZero = APFloat::getZero(APFloat::IEEEsingle, false);
2441   APFloat MZero = APFloat::getZero(APFloat::IEEEsingle, true);
2442   APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle, false);
2443   APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle, false);
2444   APFloat PNormalValue = APFloat(APFloat::IEEEsingle, "0x1p+0");
2445   APFloat MNormalValue = APFloat(APFloat::IEEEsingle, "-0x1p+0");
2446   APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle, false);
2447   APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle, true);
2448   APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, false);
2449   APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, true);
2450   APFloat PSmallestNormalized =
2451     APFloat::getSmallestNormalized(APFloat::IEEEsingle, false);
2452   APFloat MSmallestNormalized =
2453     APFloat::getSmallestNormalized(APFloat::IEEEsingle, true);
2454
2455   const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
2456   const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact;
2457
2458   const unsigned NumTests = 169;
2459   struct {
2460     APFloat x;
2461     APFloat y;
2462     const char *result;
2463     int status;
2464     int category;
2465   } SpecialCaseTests[NumTests] = {
2466     { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2467     { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2468     { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2469     { PInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2470     { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2471 #if 0
2472 // See Note 1.
2473     { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2474 #endif
2475     { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2476     { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2477     { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2478     { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2479     { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2480     { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2481     { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2482     { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2483     { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2484     { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2485     { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2486     { MInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2487     { MInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2488 #if 0
2489 // See Note 1.
2490     { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2491 #endif
2492     { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2493     { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2494     { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2495     { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2496     { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2497     { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2498     { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2499     { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2500     { PZero, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2501     { PZero, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2502     { PZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2503     { PZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2504     { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2505 #if 0
2506 // See Note 1.
2507     { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2508 #endif
2509     { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2510     { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2511     { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2512     { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2513     { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2514     { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2515     { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2516     { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2517     { MZero, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2518     { MZero, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2519     { MZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2520     { MZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2521     { MZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2522 #if 0
2523 // See Note 1.
2524     { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2525 #endif
2526     { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2527     { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2528     { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2529     { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2530     { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2531     { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2532     { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2533     { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2534     { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2535     { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
2536     { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2537     { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
2538     { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2539 #if 0
2540 // See Note 1.
2541     { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2542 #endif
2543     { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2544     { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2545     { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2546     { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2547     { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2548     { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2549     { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2550     { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2551 #if 0
2552 // See Note 1.
2553     { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2554     { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2555     { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2556     { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2557     { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2558     { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2559     { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2560     { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2561     { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2562     { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2563     { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2564     { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2565     { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2566     { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2567 #endif
2568     { PNormalValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2569     { PNormalValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2570     { PNormalValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2571     { PNormalValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2572     { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2573 #if 0
2574 // See Note 1.
2575     { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2576 #endif
2577     { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2578     { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2579     { PNormalValue, PLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal },
2580     { PNormalValue, MLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal },
2581     { PNormalValue, PSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2582     { PNormalValue, MSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2583     { PNormalValue, PSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal },
2584     { PNormalValue, MSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal },
2585     { MNormalValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2586     { MNormalValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2587     { MNormalValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2588     { MNormalValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2589     { MNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2590 #if 0
2591 // See Note 1.
2592     { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2593 #endif
2594     { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2595     { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2596     { MNormalValue, PLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal },
2597     { MNormalValue, MLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal },
2598     { MNormalValue, PSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2599     { MNormalValue, MSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2600     { MNormalValue, PSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal },
2601     { MNormalValue, MSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal },
2602     { PLargestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2603     { PLargestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2604     { PLargestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2605     { PLargestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2606     { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2607 #if 0
2608 // See Note 1.
2609     { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2610 #endif
2611     { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2612     { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2613     { PLargestValue, PLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2614     { PLargestValue, MLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2615     { PLargestValue, PSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2616     { PLargestValue, MSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2617     { PLargestValue, PSmallestNormalized, "inf", OverflowStatus, APFloat::fcInfinity },
2618     { PLargestValue, MSmallestNormalized, "-inf", OverflowStatus, APFloat::fcInfinity },
2619     { MLargestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2620     { MLargestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2621     { MLargestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2622     { MLargestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2623     { MLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2624 #if 0
2625 // See Note 1.
2626     { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2627 #endif
2628     { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2629     { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2630     { MLargestValue, PLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2631     { MLargestValue, MLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2632     { MLargestValue, PSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2633     { MLargestValue, MSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2634     { MLargestValue, PSmallestNormalized, "-inf", OverflowStatus, APFloat::fcInfinity },
2635     { MLargestValue, MSmallestNormalized, "inf", OverflowStatus, APFloat::fcInfinity },
2636     { PSmallestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2637     { PSmallestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2638     { PSmallestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2639     { PSmallestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2640     { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2641 #if 0
2642 // See Note 1.
2643     { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2644 #endif
2645     { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2646     { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2647     { PSmallestValue, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2648     { PSmallestValue, MLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2649     { PSmallestValue, PSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2650     { PSmallestValue, MSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2651     { PSmallestValue, PSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal },
2652     { PSmallestValue, MSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal },
2653     { MSmallestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2654     { MSmallestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2655     { MSmallestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2656     { MSmallestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2657     { MSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2658 #if 0
2659 // See Note 1.
2660     { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2661 #endif
2662     { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2663     { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2664     { MSmallestValue, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2665     { MSmallestValue, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2666     { MSmallestValue, PSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2667     { MSmallestValue, MSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2668     { MSmallestValue, PSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal },
2669     { MSmallestValue, MSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal },
2670     { PSmallestNormalized, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2671     { PSmallestNormalized, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2672     { PSmallestNormalized, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2673     { PSmallestNormalized, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2674     { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2675 #if 0
2676 // See Note 1.
2677     { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2678 #endif
2679     { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2680     { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2681     { PSmallestNormalized, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2682     { PSmallestNormalized, MLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2683     { PSmallestNormalized, PSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal },
2684     { PSmallestNormalized, MSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal },
2685     { PSmallestNormalized, PSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2686     { PSmallestNormalized, MSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2687     { MSmallestNormalized, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2688     { MSmallestNormalized, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2689     { MSmallestNormalized, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2690     { MSmallestNormalized, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2691     { MSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2692 #if 0
2693 // See Note 1.
2694     { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2695 #endif
2696     { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2697     { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2698     { MSmallestNormalized, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2699     { MSmallestNormalized, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2700     { MSmallestNormalized, PSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal },
2701     { MSmallestNormalized, MSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal },
2702     { MSmallestNormalized, PSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2703     { MSmallestNormalized, MSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2704   };
2705
2706   for (size_t i = 0; i < NumTests; ++i) {
2707     APFloat x(SpecialCaseTests[i].x);
2708     APFloat y(SpecialCaseTests[i].y);
2709     APFloat::opStatus status = x.divide(y, APFloat::rmNearestTiesToEven);
2710
2711     APFloat result(APFloat::IEEEsingle, SpecialCaseTests[i].result);
2712
2713     EXPECT_TRUE(result.bitwiseIsEqual(x));
2714     EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
2715     EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
2716   }
2717 }
2718
2719 TEST(APFloatTest, operatorOverloads) {
2720   // This is mostly testing that these operator overloads compile.
2721   APFloat One = APFloat(APFloat::IEEEsingle, "0x1p+0");
2722   APFloat Two = APFloat(APFloat::IEEEsingle, "0x2p+0");
2723   EXPECT_TRUE(Two.bitwiseIsEqual(One + One));
2724   EXPECT_TRUE(One.bitwiseIsEqual(Two - One));
2725   EXPECT_TRUE(Two.bitwiseIsEqual(One * Two));
2726   EXPECT_TRUE(One.bitwiseIsEqual(Two / Two));
2727 }
2728
2729 TEST(APFloatTest, abs) {
2730   APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false);
2731   APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true);
2732   APFloat PZero = APFloat::getZero(APFloat::IEEEsingle, false);
2733   APFloat MZero = APFloat::getZero(APFloat::IEEEsingle, true);
2734   APFloat PQNaN = APFloat::getNaN(APFloat::IEEEsingle, false);
2735   APFloat MQNaN = APFloat::getNaN(APFloat::IEEEsingle, true);
2736   APFloat PSNaN = APFloat::getSNaN(APFloat::IEEEsingle, false);
2737   APFloat MSNaN = APFloat::getSNaN(APFloat::IEEEsingle, true);
2738   APFloat PNormalValue = APFloat(APFloat::IEEEsingle, "0x1p+0");
2739   APFloat MNormalValue = APFloat(APFloat::IEEEsingle, "-0x1p+0");
2740   APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle, false);
2741   APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle, true);
2742   APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, false);
2743   APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, true);
2744   APFloat PSmallestNormalized =
2745     APFloat::getSmallestNormalized(APFloat::IEEEsingle, false);
2746   APFloat MSmallestNormalized =
2747     APFloat::getSmallestNormalized(APFloat::IEEEsingle, true);
2748
2749   EXPECT_TRUE(PInf.bitwiseIsEqual(abs(PInf)));
2750   EXPECT_TRUE(PInf.bitwiseIsEqual(abs(MInf)));
2751   EXPECT_TRUE(PZero.bitwiseIsEqual(abs(PZero)));
2752   EXPECT_TRUE(PZero.bitwiseIsEqual(abs(MZero)));
2753   EXPECT_TRUE(PQNaN.bitwiseIsEqual(abs(PQNaN)));
2754   EXPECT_TRUE(PQNaN.bitwiseIsEqual(abs(MQNaN)));
2755   EXPECT_TRUE(PSNaN.bitwiseIsEqual(abs(PSNaN)));
2756   EXPECT_TRUE(PSNaN.bitwiseIsEqual(abs(MSNaN)));
2757   EXPECT_TRUE(PNormalValue.bitwiseIsEqual(abs(PNormalValue)));
2758   EXPECT_TRUE(PNormalValue.bitwiseIsEqual(abs(MNormalValue)));
2759   EXPECT_TRUE(PLargestValue.bitwiseIsEqual(abs(PLargestValue)));
2760   EXPECT_TRUE(PLargestValue.bitwiseIsEqual(abs(MLargestValue)));
2761   EXPECT_TRUE(PSmallestValue.bitwiseIsEqual(abs(PSmallestValue)));
2762   EXPECT_TRUE(PSmallestValue.bitwiseIsEqual(abs(MSmallestValue)));
2763   EXPECT_TRUE(PSmallestNormalized.bitwiseIsEqual(abs(PSmallestNormalized)));
2764   EXPECT_TRUE(PSmallestNormalized.bitwiseIsEqual(abs(MSmallestNormalized)));
2765 }
2766
2767 TEST(APFloatTest, ilogb) {
2768   EXPECT_EQ(0, ilogb(APFloat(APFloat::IEEEsingle, "0x1p+0")));
2769   EXPECT_EQ(0, ilogb(APFloat(APFloat::IEEEsingle, "-0x1p+0")));
2770   EXPECT_EQ(42, ilogb(APFloat(APFloat::IEEEsingle, "0x1p+42")));
2771   EXPECT_EQ(-42, ilogb(APFloat(APFloat::IEEEsingle, "0x1p-42")));
2772
2773   EXPECT_EQ(APFloat::IEK_Inf,
2774             ilogb(APFloat::getInf(APFloat::IEEEsingle, false)));
2775   EXPECT_EQ(APFloat::IEK_Inf,
2776             ilogb(APFloat::getInf(APFloat::IEEEsingle, true)));
2777   EXPECT_EQ(APFloat::IEK_Zero,
2778             ilogb(APFloat::getZero(APFloat::IEEEsingle, false)));
2779   EXPECT_EQ(APFloat::IEK_Zero,
2780             ilogb(APFloat::getZero(APFloat::IEEEsingle, true)));
2781   EXPECT_EQ(APFloat::IEK_NaN,
2782             ilogb(APFloat::getNaN(APFloat::IEEEsingle, false)));
2783   EXPECT_EQ(APFloat::IEK_NaN,
2784             ilogb(APFloat::getSNaN(APFloat::IEEEsingle, false)));
2785
2786   EXPECT_EQ(127, ilogb(APFloat::getLargest(APFloat::IEEEsingle, false)));
2787   EXPECT_EQ(127, ilogb(APFloat::getLargest(APFloat::IEEEsingle, true)));
2788   EXPECT_EQ(-126, ilogb(APFloat::getSmallest(APFloat::IEEEsingle, false)));
2789   EXPECT_EQ(-126, ilogb(APFloat::getSmallest(APFloat::IEEEsingle, true)));
2790   EXPECT_EQ(-126,
2791             ilogb(APFloat::getSmallestNormalized(APFloat::IEEEsingle, false)));
2792   EXPECT_EQ(-126,
2793             ilogb(APFloat::getSmallestNormalized(APFloat::IEEEsingle, true)));
2794 }
2795
2796 TEST(APFloatTest, scalbn) {
2797   EXPECT_TRUE(
2798       APFloat(APFloat::IEEEsingle, "0x1p+0")
2799           .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle, "0x1p+0"), 0)));
2800   EXPECT_TRUE(
2801       APFloat(APFloat::IEEEsingle, "0x1p+42")
2802           .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle, "0x1p+0"), 42)));
2803   EXPECT_TRUE(
2804       APFloat(APFloat::IEEEsingle, "0x1p-42")
2805           .bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle, "0x1p+0"), -42)));
2806
2807   APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false);
2808   APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true);
2809   APFloat PZero = APFloat::getZero(APFloat::IEEEsingle, false);
2810   APFloat MZero = APFloat::getZero(APFloat::IEEEsingle, true);
2811   APFloat QPNaN = APFloat::getNaN(APFloat::IEEEsingle, false);
2812   APFloat QMNaN = APFloat::getNaN(APFloat::IEEEsingle, true);
2813   APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle, false);
2814
2815   EXPECT_TRUE(PInf.bitwiseIsEqual(scalbn(PInf, 0)));
2816   EXPECT_TRUE(MInf.bitwiseIsEqual(scalbn(MInf, 0)));
2817   EXPECT_TRUE(PZero.bitwiseIsEqual(scalbn(PZero, 0)));
2818   EXPECT_TRUE(MZero.bitwiseIsEqual(scalbn(MZero, 0)));
2819   EXPECT_TRUE(QPNaN.bitwiseIsEqual(scalbn(QPNaN, 0)));
2820   EXPECT_TRUE(QMNaN.bitwiseIsEqual(scalbn(QMNaN, 0)));
2821   EXPECT_TRUE(SNaN.bitwiseIsEqual(scalbn(SNaN, 0)));
2822
2823   EXPECT_TRUE(
2824       PInf.bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle, "0x1p+0"), 128)));
2825   EXPECT_TRUE(MInf.bitwiseIsEqual(
2826       scalbn(APFloat(APFloat::IEEEsingle, "-0x1p+0"), 128)));
2827   EXPECT_TRUE(
2828       PInf.bitwiseIsEqual(scalbn(APFloat(APFloat::IEEEsingle, "0x1p+127"), 1)));
2829   EXPECT_TRUE(PZero.bitwiseIsEqual(
2830       scalbn(APFloat(APFloat::IEEEsingle, "0x1p+0"), -127)));
2831   EXPECT_TRUE(MZero.bitwiseIsEqual(
2832       scalbn(APFloat(APFloat::IEEEsingle, "-0x1p+0"), -127)));
2833   EXPECT_TRUE(PZero.bitwiseIsEqual(
2834       scalbn(APFloat(APFloat::IEEEsingle, "0x1p-126"), -1)));
2835   EXPECT_TRUE(PZero.bitwiseIsEqual(
2836       scalbn(APFloat(APFloat::IEEEsingle, "0x1p-126"), -1)));
2837 }
2838 }