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 TEST(APFloatTest, Denormal) {
 480   APFloat::roundingMode rdmd = APFloat::rmNearestTiesToEven;
 481
 482   // Test single precision
 483   {
 484     const char *MinNormalStr = "1.17549435082228750797e-38";
 485     EXPECT_FALSE(APFloat(APFloat::IEEEsingle, MinNormalStr).isDenormal());
 486     EXPECT_FALSE(APFloat(APFloat::IEEEsingle, 0.0).isDenormal());
 487
 488     APFloat Val2(APFloat::IEEEsingle, 2.0e0);
 489     APFloat T(APFloat::IEEEsingle, MinNormalStr);
 490     T.divide(Val2, rdmd);
 491     EXPECT_TRUE(T.isDenormal());
 492   }
 493
 494   // Test double precision
 495   {
 496     const char *MinNormalStr = "2.22507385850720138309e-308";
 497     EXPECT_FALSE(APFloat(APFloat::IEEEdouble, MinNormalStr).isDenormal());
 498     EXPECT_FALSE(APFloat(APFloat::IEEEdouble, 0.0).isDenormal());
 499
 500     APFloat Val2(APFloat::IEEEdouble, 2.0e0);
 501     APFloat T(APFloat::IEEEdouble, MinNormalStr);
 502     T.divide(Val2, rdmd);
 503     EXPECT_TRUE(T.isDenormal());
 504   }
 505
 506   // Test Intel double-ext
 507   {
 508     const char *MinNormalStr = "3.36210314311209350626e-4932";
 509     EXPECT_FALSE(APFloat(APFloat::x87DoubleExtended, MinNormalStr).isDenormal());
 510     EXPECT_FALSE(APFloat(APFloat::x87DoubleExtended, 0.0).isDenormal());
 511
 512     APFloat Val2(APFloat::x87DoubleExtended, 2.0e0);
 513     APFloat T(APFloat::x87DoubleExtended, MinNormalStr);
 514     T.divide(Val2, rdmd);
 515     EXPECT_TRUE(T.isDenormal());
 516   }
 517
 518   // Test quadruple precision
 519   {
 520     const char *MinNormalStr = "3.36210314311209350626267781732175260e-4932";
 521     EXPECT_FALSE(APFloat(APFloat::IEEEquad, MinNormalStr).isDenormal());
 522     EXPECT_FALSE(APFloat(APFloat::IEEEquad, 0.0).isDenormal());
 523
 524     APFloat Val2(APFloat::IEEEquad, 2.0e0);
 525     APFloat T(APFloat::IEEEquad, MinNormalStr);
 526     T.divide(Val2, rdmd);
 527     EXPECT_TRUE(T.isDenormal());
 528   }
 529 }
 530
 531 TEST(APFloatTest, Zero) {
 532   EXPECT_EQ(0.0f,  APFloat(0.0f).convertToFloat());
 533   EXPECT_EQ(-0.0f, APFloat(-0.0f).convertToFloat());
 534   EXPECT_TRUE(APFloat(-0.0f).isNegative());
 535
 536   EXPECT_EQ(0.0,  APFloat(0.0).convertToDouble());
 537   EXPECT_EQ(-0.0, APFloat(-0.0).convertToDouble());
 538   EXPECT_TRUE(APFloat(-0.0).isNegative());
 539 }
 540
 541 TEST(APFloatTest, DecimalStringsWithoutNullTerminators) {
 542   // Make sure that we can parse strings without null terminators.
 543   // rdar://14323230.
 544   APFloat Val(APFloat::IEEEdouble);
 545   Val.convertFromString(StringRef("0.00", 3),
 546                         llvm::APFloat::rmNearestTiesToEven);
 547   EXPECT_EQ(Val.convertToDouble(), 0.0);
 548   Val.convertFromString(StringRef("0.01", 3),
 549                         llvm::APFloat::rmNearestTiesToEven);
 550   EXPECT_EQ(Val.convertToDouble(), 0.0);
 551   Val.convertFromString(StringRef("0.09", 3),
 552                         llvm::APFloat::rmNearestTiesToEven);
 553   EXPECT_EQ(Val.convertToDouble(), 0.0);
 554   Val.convertFromString(StringRef("0.095", 4),
 555                         llvm::APFloat::rmNearestTiesToEven);
 556   EXPECT_EQ(Val.convertToDouble(), 0.09);
 557   Val.convertFromString(StringRef("0.00e+3", 7),
 558                         llvm::APFloat::rmNearestTiesToEven);
 559   EXPECT_EQ(Val.convertToDouble(), 0.00);
 560   Val.convertFromString(StringRef("0e+3", 4),
 561                         llvm::APFloat::rmNearestTiesToEven);
 562   EXPECT_EQ(Val.convertToDouble(), 0.00);
 563
 564 }
 565
 566 TEST(APFloatTest, fromZeroDecimalString) {
 567   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0").convertToDouble());
 568   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0").convertToDouble());
 569   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0").convertToDouble());
 570
 571   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0.").convertToDouble());
 572   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.").convertToDouble());
 573   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.").convertToDouble());
 574
 575   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  ".0").convertToDouble());
 576   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.0").convertToDouble());
 577   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.0").convertToDouble());
 578
 579   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0.0").convertToDouble());
 580   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.0").convertToDouble());
 581   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.0").convertToDouble());
 582
 583   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "00000.").convertToDouble());
 584   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+00000.").convertToDouble());
 585   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-00000.").convertToDouble());
 586
 587   EXPECT_EQ(0.0,  APFloat(APFloat::IEEEdouble, ".00000").convertToDouble());
 588   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.00000").convertToDouble());
 589   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.00000").convertToDouble());
 590
 591   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0000.00000").convertToDouble());
 592   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0000.00000").convertToDouble());
 593   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0000.00000").convertToDouble());
 594 }
 595
 596 TEST(APFloatTest, fromZeroDecimalSingleExponentString) {
 597   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,   "0e1").convertToDouble());
 598   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble,  "+0e1").convertToDouble());
 599   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble,  "-0e1").convertToDouble());
 600
 601   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0e+1").convertToDouble());
 602   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e+1").convertToDouble());
 603   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e+1").convertToDouble());
 604
 605   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0e-1").convertToDouble());
 606   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e-1").convertToDouble());
 607   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e-1").convertToDouble());
 608
 609
 610   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,   "0.e1").convertToDouble());
 611   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble,  "+0.e1").convertToDouble());
 612   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble,  "-0.e1").convertToDouble());
 613
 614   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0.e+1").convertToDouble());
 615   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.e+1").convertToDouble());
 616   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.e+1").convertToDouble());
 617
 618   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0.e-1").convertToDouble());
 619   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.e-1").convertToDouble());
 620   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.e-1").convertToDouble());
 621
 622   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,   ".0e1").convertToDouble());
 623   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble,  "+.0e1").convertToDouble());
 624   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble,  "-.0e1").convertToDouble());
 625
 626   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  ".0e+1").convertToDouble());
 627   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.0e+1").convertToDouble());
 628   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.0e+1").convertToDouble());
 629
 630   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  ".0e-1").convertToDouble());
 631   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.0e-1").convertToDouble());
 632   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.0e-1").convertToDouble());
 633
 634
 635   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,   "0.0e1").convertToDouble());
 636   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble,  "+0.0e1").convertToDouble());
 637   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble,  "-0.0e1").convertToDouble());
 638
 639   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0.0e+1").convertToDouble());
 640   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.0e+1").convertToDouble());
 641   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.0e+1").convertToDouble());
 642
 643   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0.0e-1").convertToDouble());
 644   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.0e-1").convertToDouble());
 645   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.0e-1").convertToDouble());
 646
 647
 648   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "000.0000e1").convertToDouble());
 649   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+000.0000e+1").convertToDouble());
 650   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-000.0000e+1").convertToDouble());
 651 }
 652
 653 TEST(APFloatTest, fromZeroDecimalLargeExponentString) {
 654   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0e1234").convertToDouble());
 655   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e1234").convertToDouble());
 656   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e1234").convertToDouble());
 657
 658   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0e+1234").convertToDouble());
 659   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e+1234").convertToDouble());
 660   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e+1234").convertToDouble());
 661
 662   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0e-1234").convertToDouble());
 663   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e-1234").convertToDouble());
 664   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e-1234").convertToDouble());
 665
 666   EXPECT_EQ(0.0,  APFloat(APFloat::IEEEdouble, "000.0000e1234").convertToDouble());
 667   EXPECT_EQ(0.0,  APFloat(APFloat::IEEEdouble, "000.0000e-1234").convertToDouble());
 668
 669   EXPECT_EQ(0.0,  APFloat(APFloat::IEEEdouble, StringRef("0e1234\02", 6)).convertToDouble());
 670 }
 671
 672 TEST(APFloatTest, fromZeroHexadecimalString) {
 673   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x0p1").convertToDouble());
 674   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0p1").convertToDouble());
 675   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0p1").convertToDouble());
 676
 677   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x0p+1").convertToDouble());
 678   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0p+1").convertToDouble());
 679   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0p+1").convertToDouble());
 680
 681   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x0p-1").convertToDouble());
 682   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0p-1").convertToDouble());
 683   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0p-1").convertToDouble());
 684
 685
 686   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x0.p1").convertToDouble());
 687   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.p1").convertToDouble());
 688   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.p1").convertToDouble());
 689
 690   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x0.p+1").convertToDouble());
 691   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.p+1").convertToDouble());
 692   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.p+1").convertToDouble());
 693
 694   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x0.p-1").convertToDouble());
 695   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.p-1").convertToDouble());
 696   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.p-1").convertToDouble());
 697
 698
 699   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x.0p1").convertToDouble());
 700   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x.0p1").convertToDouble());
 701   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x.0p1").convertToDouble());
 702
 703   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x.0p+1").convertToDouble());
 704   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x.0p+1").convertToDouble());
 705   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x.0p+1").convertToDouble());
 706
 707   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x.0p-1").convertToDouble());
 708   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x.0p-1").convertToDouble());
 709   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x.0p-1").convertToDouble());
 710
 711
 712   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x0.0p1").convertToDouble());
 713   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.0p1").convertToDouble());
 714   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.0p1").convertToDouble());
 715
 716   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x0.0p+1").convertToDouble());
 717   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.0p+1").convertToDouble());
 718   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.0p+1").convertToDouble());
 719
 720   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x0.0p-1").convertToDouble());
 721   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.0p-1").convertToDouble());
 722   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.0p-1").convertToDouble());
 723
 724
 725   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x00000.p1").convertToDouble());
 726   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0000.00000p1").convertToDouble());
 727   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x.00000p1").convertToDouble());
 728   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.p1").convertToDouble());
 729   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0p1234").convertToDouble());
 730   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0p1234").convertToDouble());
 731   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x00000.p1234").convertToDouble());
 732   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0000.00000p1234").convertToDouble());
 733   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x.00000p1234").convertToDouble());
 734   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.p1234").convertToDouble());
 735 }
 736
 737 TEST(APFloatTest, fromDecimalString) {
 738   EXPECT_EQ(1.0,      APFloat(APFloat::IEEEdouble, "1").convertToDouble());
 739   EXPECT_EQ(2.0,      APFloat(APFloat::IEEEdouble, "2.").convertToDouble());
 740   EXPECT_EQ(0.5,      APFloat(APFloat::IEEEdouble, ".5").convertToDouble());
 741   EXPECT_EQ(1.0,      APFloat(APFloat::IEEEdouble, "1.0").convertToDouble());
 742   EXPECT_EQ(-2.0,     APFloat(APFloat::IEEEdouble, "-2").convertToDouble());
 743   EXPECT_EQ(-4.0,     APFloat(APFloat::IEEEdouble, "-4.").convertToDouble());
 744   EXPECT_EQ(-0.5,     APFloat(APFloat::IEEEdouble, "-.5").convertToDouble());
 745   EXPECT_EQ(-1.5,     APFloat(APFloat::IEEEdouble, "-1.5").convertToDouble());
 746   EXPECT_EQ(1.25e12,  APFloat(APFloat::IEEEdouble, "1.25e12").convertToDouble());
 747   EXPECT_EQ(1.25e+12, APFloat(APFloat::IEEEdouble, "1.25e+12").convertToDouble());
 748   EXPECT_EQ(1.25e-12, APFloat(APFloat::IEEEdouble, "1.25e-12").convertToDouble());
 749   EXPECT_EQ(1024.0,   APFloat(APFloat::IEEEdouble, "1024.").convertToDouble());
 750   EXPECT_EQ(1024.05,  APFloat(APFloat::IEEEdouble, "1024.05000").convertToDouble());
 751   EXPECT_EQ(0.05,     APFloat(APFloat::IEEEdouble, ".05000").convertToDouble());
 752   EXPECT_EQ(2.0,      APFloat(APFloat::IEEEdouble, "2.").convertToDouble());
 753   EXPECT_EQ(2.0e2,    APFloat(APFloat::IEEEdouble, "2.e2").convertToDouble());
 754   EXPECT_EQ(2.0e+2,   APFloat(APFloat::IEEEdouble, "2.e+2").convertToDouble());
 755   EXPECT_EQ(2.0e-2,   APFloat(APFloat::IEEEdouble, "2.e-2").convertToDouble());
 756   EXPECT_EQ(2.05e2,    APFloat(APFloat::IEEEdouble, "002.05000e2").convertToDouble());
 757   EXPECT_EQ(2.05e+2,   APFloat(APFloat::IEEEdouble, "002.05000e+2").convertToDouble());
 758   EXPECT_EQ(2.05e-2,   APFloat(APFloat::IEEEdouble, "002.05000e-2").convertToDouble());
 759   EXPECT_EQ(2.05e12,   APFloat(APFloat::IEEEdouble, "002.05000e12").convertToDouble());
 760   EXPECT_EQ(2.05e+12,  APFloat(APFloat::IEEEdouble, "002.05000e+12").convertToDouble());
 761   EXPECT_EQ(2.05e-12,  APFloat(APFloat::IEEEdouble, "002.05000e-12").convertToDouble());
 762
 763   // These are "carefully selected" to overflow the fast log-base
 764   // calculations in APFloat.cpp
 765   EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "99e99999").isInfinity());
 766   EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "-99e99999").isInfinity());
 767   EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "1e-99999").isPosZero());
 768   EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "-1e-99999").isNegZero());
 769 }
 770
 771 TEST(APFloatTest, fromHexadecimalString) {
 772   EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble,  "0x1p0").convertToDouble());
 773   EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble, "+0x1p0").convertToDouble());
 774   EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble, "-0x1p0").convertToDouble());
 775
 776   EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble,  "0x1p+0").convertToDouble());
 777   EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble, "+0x1p+0").convertToDouble());
 778   EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble, "-0x1p+0").convertToDouble());
 779
 780   EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble,  "0x1p-0").convertToDouble());
 781   EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble, "+0x1p-0").convertToDouble());
 782   EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble, "-0x1p-0").convertToDouble());
 783
 784
 785   EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble,  "0x1p1").convertToDouble());
 786   EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble, "+0x1p1").convertToDouble());
 787   EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble, "-0x1p1").convertToDouble());
 788
 789   EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble,  "0x1p+1").convertToDouble());
 790   EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble, "+0x1p+1").convertToDouble());
 791   EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble, "-0x1p+1").convertToDouble());
 792
 793   EXPECT_EQ( 0.5, APFloat(APFloat::IEEEdouble,  "0x1p-1").convertToDouble());
 794   EXPECT_EQ(+0.5, APFloat(APFloat::IEEEdouble, "+0x1p-1").convertToDouble());
 795   EXPECT_EQ(-0.5, APFloat(APFloat::IEEEdouble, "-0x1p-1").convertToDouble());
 796
 797
 798   EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble,  "0x1.8p1").convertToDouble());
 799   EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble, "+0x1.8p1").convertToDouble());
 800   EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble, "-0x1.8p1").convertToDouble());
 801
 802   EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble,  "0x1.8p+1").convertToDouble());
 803   EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble, "+0x1.8p+1").convertToDouble());
 804   EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble, "-0x1.8p+1").convertToDouble());
 805
 806   EXPECT_EQ( 0.75, APFloat(APFloat::IEEEdouble,  "0x1.8p-1").convertToDouble());
 807   EXPECT_EQ(+0.75, APFloat(APFloat::IEEEdouble, "+0x1.8p-1").convertToDouble());
 808   EXPECT_EQ(-0.75, APFloat(APFloat::IEEEdouble, "-0x1.8p-1").convertToDouble());
 809
 810
 811   EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble,  "0x1000.000p1").convertToDouble());
 812   EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble, "+0x1000.000p1").convertToDouble());
 813   EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble, "-0x1000.000p1").convertToDouble());
 814
 815   EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble,  "0x1000.000p+1").convertToDouble());
 816   EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble, "+0x1000.000p+1").convertToDouble());
 817   EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble, "-0x1000.000p+1").convertToDouble());
 818
 819   EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble,  "0x1000.000p-1").convertToDouble());
 820   EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble, "+0x1000.000p-1").convertToDouble());
 821   EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble, "-0x1000.000p-1").convertToDouble());
 822
 823
 824   EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble,  "0x1000p1").convertToDouble());
 825   EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble, "+0x1000p1").convertToDouble());
 826   EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble, "-0x1000p1").convertToDouble());
 827
 828   EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble,  "0x1000p+1").convertToDouble());
 829   EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble, "+0x1000p+1").convertToDouble());
 830   EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble, "-0x1000p+1").convertToDouble());
 831
 832   EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble,  "0x1000p-1").convertToDouble());
 833   EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble, "+0x1000p-1").convertToDouble());
 834   EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble, "-0x1000p-1").convertToDouble());
 835
 836
 837   EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble,  "0x10p10").convertToDouble());
 838   EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble, "+0x10p10").convertToDouble());
 839   EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble, "-0x10p10").convertToDouble());
 840
 841   EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble,  "0x10p+10").convertToDouble());
 842   EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble, "+0x10p+10").convertToDouble());
 843   EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble, "-0x10p+10").convertToDouble());
 844
 845   EXPECT_EQ( 0.015625, APFloat(APFloat::IEEEdouble,  "0x10p-10").convertToDouble());
 846   EXPECT_EQ(+0.015625, APFloat(APFloat::IEEEdouble, "+0x10p-10").convertToDouble());
 847   EXPECT_EQ(-0.015625, APFloat(APFloat::IEEEdouble, "-0x10p-10").convertToDouble());
 848
 849   EXPECT_EQ(1.0625, APFloat(APFloat::IEEEdouble, "0x1.1p0").convertToDouble());
 850   EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble, "0x1p0").convertToDouble());
 851
 852   EXPECT_EQ(2.71828, convertToDoubleFromString("2.71828"));
 853 }
 854
 855 TEST(APFloatTest, toString) {
 856   ASSERT_EQ("10", convertToString(10.0, 6, 3));
 857   ASSERT_EQ("1.0E+1", convertToString(10.0, 6, 0));
 858   ASSERT_EQ("10100", convertToString(1.01E+4, 5, 2));
 859   ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 4, 2));
 860   ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 5, 1));
 861   ASSERT_EQ("0.0101", convertToString(1.01E-2, 5, 2));
 862   ASSERT_EQ("0.0101", convertToString(1.01E-2, 4, 2));
 863   ASSERT_EQ("1.01E-2", convertToString(1.01E-2, 5, 1));
 864   ASSERT_EQ("0.7853981633974483", convertToString(0.78539816339744830961, 0, 3));
 865   ASSERT_EQ("4.940656458412465E-324", convertToString(4.9406564584124654e-324, 0, 3));
 866   ASSERT_EQ("873.1834", convertToString(873.1834, 0, 1));
 867   ASSERT_EQ("8.731834E+2", convertToString(873.1834, 0, 0));
 868 }
 869
 870 TEST(APFloatTest, toInteger) {
 871   bool isExact = false;
 872   APSInt result(5, /*isUnsigned=*/true);
 873
 874   EXPECT_EQ(APFloat::opOK,
 875             APFloat(APFloat::IEEEdouble, "10")
 876             .convertToInteger(result, APFloat::rmTowardZero, &isExact));
 877   EXPECT_TRUE(isExact);
 878   EXPECT_EQ(APSInt(APInt(5, 10), true), result);
 879
 880   EXPECT_EQ(APFloat::opInvalidOp,
 881             APFloat(APFloat::IEEEdouble, "-10")
 882             .convertToInteger(result, APFloat::rmTowardZero, &isExact));
 883   EXPECT_FALSE(isExact);
 884   EXPECT_EQ(APSInt::getMinValue(5, true), result);
 885
 886   EXPECT_EQ(APFloat::opInvalidOp,
 887             APFloat(APFloat::IEEEdouble, "32")
 888             .convertToInteger(result, APFloat::rmTowardZero, &isExact));
 889   EXPECT_FALSE(isExact);
 890   EXPECT_EQ(APSInt::getMaxValue(5, true), result);
 891
 892   EXPECT_EQ(APFloat::opInexact,
 893             APFloat(APFloat::IEEEdouble, "7.9")
 894             .convertToInteger(result, APFloat::rmTowardZero, &isExact));
 895   EXPECT_FALSE(isExact);
 896   EXPECT_EQ(APSInt(APInt(5, 7), true), result);
 897
 898   result.setIsUnsigned(false);
 899   EXPECT_EQ(APFloat::opOK,
 900             APFloat(APFloat::IEEEdouble, "-10")
 901             .convertToInteger(result, APFloat::rmTowardZero, &isExact));
 902   EXPECT_TRUE(isExact);
 903   EXPECT_EQ(APSInt(APInt(5, -10, true), false), result);
 904
 905   EXPECT_EQ(APFloat::opInvalidOp,
 906             APFloat(APFloat::IEEEdouble, "-17")
 907             .convertToInteger(result, APFloat::rmTowardZero, &isExact));
 908   EXPECT_FALSE(isExact);
 909   EXPECT_EQ(APSInt::getMinValue(5, false), result);
 910
 911   EXPECT_EQ(APFloat::opInvalidOp,
 912             APFloat(APFloat::IEEEdouble, "16")
 913             .convertToInteger(result, APFloat::rmTowardZero, &isExact));
 914   EXPECT_FALSE(isExact);
 915   EXPECT_EQ(APSInt::getMaxValue(5, false), result);
 916 }
 917
 918 static APInt nanbits(const fltSemantics &Sem,
 919                      bool SNaN, bool Negative, uint64_t fill) {
 920   APInt apfill(64, fill);
 921   if (SNaN)
 922     return APFloat::getSNaN(Sem, Negative, &apfill).bitcastToAPInt();
 923   else
 924     return APFloat::getQNaN(Sem, Negative, &apfill).bitcastToAPInt();
 925 }
 926
 927 TEST(APFloatTest, makeNaN) {
 928   ASSERT_EQ(0x7fc00000, nanbits(APFloat::IEEEsingle, false, false, 0));
 929   ASSERT_EQ(0xffc00000, nanbits(APFloat::IEEEsingle, false, true, 0));
 930   ASSERT_EQ(0x7fc0ae72, nanbits(APFloat::IEEEsingle, false, false, 0xae72));
 931   ASSERT_EQ(0x7fffae72, nanbits(APFloat::IEEEsingle, false, false, 0xffffae72));
 932   ASSERT_EQ(0x7fa00000, nanbits(APFloat::IEEEsingle, true, false, 0));
 933   ASSERT_EQ(0xffa00000, nanbits(APFloat::IEEEsingle, true, true, 0));
 934   ASSERT_EQ(0x7f80ae72, nanbits(APFloat::IEEEsingle, true, false, 0xae72));
 935   ASSERT_EQ(0x7fbfae72, nanbits(APFloat::IEEEsingle, true, false, 0xffffae72));
 936
 937   ASSERT_EQ(0x7ff8000000000000ULL, nanbits(APFloat::IEEEdouble, false, false, 0));
 938   ASSERT_EQ(0xfff8000000000000ULL, nanbits(APFloat::IEEEdouble, false, true, 0));
 939   ASSERT_EQ(0x7ff800000000ae72ULL, nanbits(APFloat::IEEEdouble, false, false, 0xae72));
 940   ASSERT_EQ(0x7fffffffffffae72ULL, nanbits(APFloat::IEEEdouble, false, false, 0xffffffffffffae72ULL));
 941   ASSERT_EQ(0x7ff4000000000000ULL, nanbits(APFloat::IEEEdouble, true, false, 0));
 942   ASSERT_EQ(0xfff4000000000000ULL, nanbits(APFloat::IEEEdouble, true, true, 0));
 943   ASSERT_EQ(0x7ff000000000ae72ULL, nanbits(APFloat::IEEEdouble, true, false, 0xae72));
 944   ASSERT_EQ(0x7ff7ffffffffae72ULL, nanbits(APFloat::IEEEdouble, true, false, 0xffffffffffffae72ULL));
 945 }
 946
 947 #ifdef GTEST_HAS_DEATH_TEST
 948 #ifndef NDEBUG
 949 TEST(APFloatTest, SemanticsDeath) {
 950   EXPECT_DEATH(APFloat(APFloat::IEEEsingle, 0.0f).convertToDouble(), "Float semantics are not IEEEdouble");
 951   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, 0.0 ).convertToFloat(),  "Float semantics are not IEEEsingle");
 952 }
 953
 954 TEST(APFloatTest, StringDecimalDeath) {
 955   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  ""), "Invalid string length");
 956   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+"), "String has no digits");
 957   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-"), "String has no digits");
 958
 959   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("\0", 1)), "Invalid character in significand");
 960   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1\0", 2)), "Invalid character in significand");
 961   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1\02", 3)), "Invalid character in significand");
 962   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1\02e1", 5)), "Invalid character in significand");
 963   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1e\0", 3)), "Invalid character in exponent");
 964   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1e1\0", 4)), "Invalid character in exponent");
 965   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1e1\02", 5)), "Invalid character in exponent");
 966
 967   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0f"), "Invalid character in significand");
 968
 969   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".."), "String contains multiple dots");
 970   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "..0"), "String contains multiple dots");
 971   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0.0"), "String contains multiple dots");
 972 }
 973
 974 TEST(APFloatTest, StringDecimalSignificandDeath) {
 975   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "."), "Significand has no digits");
 976   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+."), "Significand has no digits");
 977   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-."), "Significand has no digits");
 978
 979
 980   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "e"), "Significand has no digits");
 981   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+e"), "Significand has no digits");
 982   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-e"), "Significand has no digits");
 983
 984   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "e1"), "Significand has no digits");
 985   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+e1"), "Significand has no digits");
 986   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-e1"), "Significand has no digits");
 987
 988   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  ".e1"), "Significand has no digits");
 989   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+.e1"), "Significand has no digits");
 990   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-.e1"), "Significand has no digits");
 991
 992
 993   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  ".e"), "Significand has no digits");
 994   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+.e"), "Significand has no digits");
 995   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-.e"), "Significand has no digits");
 996 }
 997
 998 TEST(APFloatTest, StringDecimalExponentDeath) {
 999   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,   "1e"), "Exponent has no digits");
1000   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "+1e"), "Exponent has no digits");
1001   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "-1e"), "Exponent has no digits");
1002
1003   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,   "1.e"), "Exponent has no digits");
1004   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "+1.e"), "Exponent has no digits");
1005   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "-1.e"), "Exponent has no digits");
1006
1007   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,   ".1e"), "Exponent has no digits");
1008   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "+.1e"), "Exponent has no digits");
1009   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "-.1e"), "Exponent has no digits");
1010
1011   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,   "1.1e"), "Exponent has no digits");
1012   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "+1.1e"), "Exponent has no digits");
1013   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "-1.1e"), "Exponent has no digits");
1014
1015
1016   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1e+"), "Exponent has no digits");
1017   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1e-"), "Exponent has no digits");
1018
1019   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  ".1e"), "Exponent has no digits");
1020   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".1e+"), "Exponent has no digits");
1021   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".1e-"), "Exponent has no digits");
1022
1023   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "1.0e"), "Exponent has no digits");
1024   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0e+"), "Exponent has no digits");
1025   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0e-"), "Exponent has no digits");
1026 }
1027
1028 TEST(APFloatTest, StringHexadecimalDeath) {
1029   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x"), "Invalid string");
1030   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x"), "Invalid string");
1031   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x"), "Invalid string");
1032
1033   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x0"), "Hex strings require an exponent");
1034   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x0"), "Hex strings require an exponent");
1035   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x0"), "Hex strings require an exponent");
1036
1037   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x0."), "Hex strings require an exponent");
1038   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x0."), "Hex strings require an exponent");
1039   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x0."), "Hex strings require an exponent");
1040
1041   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x.0"), "Hex strings require an exponent");
1042   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.0"), "Hex strings require an exponent");
1043   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.0"), "Hex strings require an exponent");
1044
1045   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x0.0"), "Hex strings require an exponent");
1046   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x0.0"), "Hex strings require an exponent");
1047   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x0.0"), "Hex strings require an exponent");
1048
1049   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x\0", 3)), "Invalid character in significand");
1050   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1\0", 4)), "Invalid character in significand");
1051   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1\02", 5)), "Invalid character in significand");
1052   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1\02p1", 7)), "Invalid character in significand");
1053   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1p\0", 5)), "Invalid character in exponent");
1054   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1p1\0", 6)), "Invalid character in exponent");
1055   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1p1\02", 7)), "Invalid character in exponent");
1056
1057   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1p0f"), "Invalid character in exponent");
1058
1059   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x..p1"), "String contains multiple dots");
1060   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x..0p1"), "String contains multiple dots");
1061   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.0.0p1"), "String contains multiple dots");
1062 }
1063
1064 TEST(APFloatTest, StringHexadecimalSignificandDeath) {
1065   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x."), "Significand has no digits");
1066   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x."), "Significand has no digits");
1067   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x."), "Significand has no digits");
1068
1069   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0xp"), "Significand has no digits");
1070   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0xp"), "Significand has no digits");
1071   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0xp"), "Significand has no digits");
1072
1073   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0xp+"), "Significand has no digits");
1074   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0xp+"), "Significand has no digits");
1075   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0xp+"), "Significand has no digits");
1076
1077   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0xp-"), "Significand has no digits");
1078   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0xp-"), "Significand has no digits");
1079   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0xp-"), "Significand has no digits");
1080
1081
1082   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x.p"), "Significand has no digits");
1083   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.p"), "Significand has no digits");
1084   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.p"), "Significand has no digits");
1085
1086   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x.p+"), "Significand has no digits");
1087   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.p+"), "Significand has no digits");
1088   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.p+"), "Significand has no digits");
1089
1090   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x.p-"), "Significand has no digits");
1091   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.p-"), "Significand has no digits");
1092   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.p-"), "Significand has no digits");
1093 }
1094
1095 TEST(APFloatTest, StringHexadecimalExponentDeath) {
1096   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x1p"), "Exponent has no digits");
1097   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1p"), "Exponent has no digits");
1098   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1p"), "Exponent has no digits");
1099
1100   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x1p+"), "Exponent has no digits");
1101   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1p+"), "Exponent has no digits");
1102   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1p+"), "Exponent has no digits");
1103
1104   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x1p-"), "Exponent has no digits");
1105   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1p-"), "Exponent has no digits");
1106   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1p-"), "Exponent has no digits");
1107
1108
1109   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x1.p"), "Exponent has no digits");
1110   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.p"), "Exponent has no digits");
1111   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.p"), "Exponent has no digits");
1112
1113   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x1.p+"), "Exponent has no digits");
1114   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.p+"), "Exponent has no digits");
1115   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.p+"), "Exponent has no digits");
1116
1117   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x1.p-"), "Exponent has no digits");
1118   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.p-"), "Exponent has no digits");
1119   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.p-"), "Exponent has no digits");
1120
1121
1122   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x.1p"), "Exponent has no digits");
1123   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.1p"), "Exponent has no digits");
1124   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.1p"), "Exponent has no digits");
1125
1126   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x.1p+"), "Exponent has no digits");
1127   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.1p+"), "Exponent has no digits");
1128   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.1p+"), "Exponent has no digits");
1129
1130   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x.1p-"), "Exponent has no digits");
1131   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.1p-"), "Exponent has no digits");
1132   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.1p-"), "Exponent has no digits");
1133
1134
1135   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x1.1p"), "Exponent has no digits");
1136   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.1p"), "Exponent has no digits");
1137   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.1p"), "Exponent has no digits");
1138
1139   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x1.1p+"), "Exponent has no digits");
1140   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.1p+"), "Exponent has no digits");
1141   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.1p+"), "Exponent has no digits");
1142
1143   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x1.1p-"), "Exponent has no digits");
1144   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.1p-"), "Exponent has no digits");
1145   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.1p-"), "Exponent has no digits");
1146 }
1147 #endif
1148 #endif
1149
1150 TEST(APFloatTest, exactInverse) {
1151   APFloat inv(0.0f);
1152
1153   // Trivial operation.
1154   EXPECT_TRUE(APFloat(2.0).getExactInverse(&inv));
1155   EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5)));
1156   EXPECT_TRUE(APFloat(2.0f).getExactInverse(&inv));
1157   EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5f)));
1158   EXPECT_TRUE(APFloat(APFloat::IEEEquad, "2.0").getExactInverse(&inv));
1159   EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::IEEEquad, "0.5")));
1160   EXPECT_TRUE(APFloat(APFloat::PPCDoubleDouble, "2.0").getExactInverse(&inv));
1161   EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::PPCDoubleDouble, "0.5")));
1162   EXPECT_TRUE(APFloat(APFloat::x87DoubleExtended, "2.0").getExactInverse(&inv));
1163   EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::x87DoubleExtended, "0.5")));
1164
1165   // FLT_MIN
1166   EXPECT_TRUE(APFloat(1.17549435e-38f).getExactInverse(&inv));
1167   EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(8.5070592e+37f)));
1168
1169   // Large float, inverse is a denormal.
1170   EXPECT_FALSE(APFloat(1.7014118e38f).getExactInverse(0));
1171   // Zero
1172   EXPECT_FALSE(APFloat(0.0).getExactInverse(0));
1173   // Denormalized float
1174   EXPECT_FALSE(APFloat(1.40129846e-45f).getExactInverse(0));
1175 }
1176
1177 TEST(APFloatTest, roundToIntegral) {
1178   APFloat T(-0.5), S(3.14), R(APFloat::getLargest(APFloat::IEEEdouble)), P(0.0);
1179
1180   P = T;
1181   P.roundToIntegral(APFloat::rmTowardZero);
1182   EXPECT_EQ(-0.0, P.convertToDouble());
1183   P = T;
1184   P.roundToIntegral(APFloat::rmTowardNegative);
1185   EXPECT_EQ(-1.0, P.convertToDouble());
1186   P = T;
1187   P.roundToIntegral(APFloat::rmTowardPositive);
1188   EXPECT_EQ(-0.0, P.convertToDouble());
1189   P = T;
1190   P.roundToIntegral(APFloat::rmNearestTiesToEven);
1191   EXPECT_EQ(-0.0, P.convertToDouble());
1192
1193   P = S;
1194   P.roundToIntegral(APFloat::rmTowardZero);
1195   EXPECT_EQ(3.0, P.convertToDouble());
1196   P = S;
1197   P.roundToIntegral(APFloat::rmTowardNegative);
1198   EXPECT_EQ(3.0, P.convertToDouble());
1199   P = S;
1200   P.roundToIntegral(APFloat::rmTowardPositive);
1201   EXPECT_EQ(4.0, P.convertToDouble());
1202   P = S;
1203   P.roundToIntegral(APFloat::rmNearestTiesToEven);
1204   EXPECT_EQ(3.0, P.convertToDouble());
1205
1206   P = R;
1207   P.roundToIntegral(APFloat::rmTowardZero);
1208   EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1209   P = R;
1210   P.roundToIntegral(APFloat::rmTowardNegative);
1211   EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1212   P = R;
1213   P.roundToIntegral(APFloat::rmTowardPositive);
1214   EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1215   P = R;
1216   P.roundToIntegral(APFloat::rmNearestTiesToEven);
1217   EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1218
1219   P = APFloat::getZero(APFloat::IEEEdouble);
1220   P.roundToIntegral(APFloat::rmTowardZero);
1221   EXPECT_EQ(0.0, P.convertToDouble());
1222   P = APFloat::getZero(APFloat::IEEEdouble, true);
1223   P.roundToIntegral(APFloat::rmTowardZero);
1224   EXPECT_EQ(-0.0, P.convertToDouble());
1225   P = APFloat::getNaN(APFloat::IEEEdouble);
1226   P.roundToIntegral(APFloat::rmTowardZero);
1227   EXPECT_TRUE(IsNAN(P.convertToDouble()));
1228   P = APFloat::getInf(APFloat::IEEEdouble);
1229   P.roundToIntegral(APFloat::rmTowardZero);
1230   EXPECT_TRUE(IsInf(P.convertToDouble()) && P.convertToDouble() > 0.0);
1231   P = APFloat::getInf(APFloat::IEEEdouble, true);
1232   P.roundToIntegral(APFloat::rmTowardZero);
1233   EXPECT_TRUE(IsInf(P.convertToDouble()) && P.convertToDouble() < 0.0);
1234
1235 }
1236
1237 TEST(APFloatTest, getLargest) {
1238   EXPECT_EQ(3.402823466e+38f, APFloat::getLargest(APFloat::IEEEsingle).convertToFloat());
1239   EXPECT_EQ(1.7976931348623158e+308, APFloat::getLargest(APFloat::IEEEdouble).convertToDouble());
1240 }
1241
1242 TEST(APFloatTest, getSmallest) {
1243   APFloat test = APFloat::getSmallest(APFloat::IEEEsingle, false);
1244   APFloat expected = APFloat(APFloat::IEEEsingle, "0x0.000002p-126");
1245   EXPECT_FALSE(test.isNegative());
1246   EXPECT_TRUE(test.isFiniteNonZero());
1247   EXPECT_TRUE(test.isDenormal());
1248   EXPECT_TRUE(test.bitwiseIsEqual(expected));
1249
1250   test = APFloat::getSmallest(APFloat::IEEEsingle, true);
1251   expected = APFloat(APFloat::IEEEsingle, "-0x0.000002p-126");
1252   EXPECT_TRUE(test.isNegative());
1253   EXPECT_TRUE(test.isFiniteNonZero());
1254   EXPECT_TRUE(test.isDenormal());
1255   EXPECT_TRUE(test.bitwiseIsEqual(expected));
1256
1257   test = APFloat::getSmallest(APFloat::IEEEquad, false);
1258   expected = APFloat(APFloat::IEEEquad, "0x0.0000000000000000000000000001p-16382");
1259   EXPECT_FALSE(test.isNegative());
1260   EXPECT_TRUE(test.isFiniteNonZero());
1261   EXPECT_TRUE(test.isDenormal());
1262   EXPECT_TRUE(test.bitwiseIsEqual(expected));
1263
1264   test = APFloat::getSmallest(APFloat::IEEEquad, true);
1265   expected = APFloat(APFloat::IEEEquad, "-0x0.0000000000000000000000000001p-16382");
1266   EXPECT_TRUE(test.isNegative());
1267   EXPECT_TRUE(test.isFiniteNonZero());
1268   EXPECT_TRUE(test.isDenormal());
1269   EXPECT_TRUE(test.bitwiseIsEqual(expected));
1270 }
1271
1272 TEST(APFloatTest, getSmallestNormalized) {
1273   APFloat test = APFloat::getSmallestNormalized(APFloat::IEEEsingle, false);
1274   APFloat expected = APFloat(APFloat::IEEEsingle, "0x1p-126");
1275   EXPECT_FALSE(test.isNegative());
1276   EXPECT_TRUE(test.isFiniteNonZero());
1277   EXPECT_FALSE(test.isDenormal());
1278   EXPECT_TRUE(test.bitwiseIsEqual(expected));
1279
1280   test = APFloat::getSmallestNormalized(APFloat::IEEEsingle, true);
1281   expected = APFloat(APFloat::IEEEsingle, "-0x1p-126");
1282   EXPECT_TRUE(test.isNegative());
1283   EXPECT_TRUE(test.isFiniteNonZero());
1284   EXPECT_FALSE(test.isDenormal());
1285   EXPECT_TRUE(test.bitwiseIsEqual(expected));
1286
1287   test = APFloat::getSmallestNormalized(APFloat::IEEEquad, false);
1288   expected = APFloat(APFloat::IEEEquad, "0x1p-16382");
1289   EXPECT_FALSE(test.isNegative());
1290   EXPECT_TRUE(test.isFiniteNonZero());
1291   EXPECT_FALSE(test.isDenormal());
1292   EXPECT_TRUE(test.bitwiseIsEqual(expected));
1293
1294   test = APFloat::getSmallestNormalized(APFloat::IEEEquad, true);
1295   expected = APFloat(APFloat::IEEEquad, "-0x1p-16382");
1296   EXPECT_TRUE(test.isNegative());
1297   EXPECT_TRUE(test.isFiniteNonZero());
1298   EXPECT_FALSE(test.isDenormal());
1299   EXPECT_TRUE(test.bitwiseIsEqual(expected));
1300 }
1301
1302 TEST(APFloatTest, getZero) {
1303   struct {
1304     const fltSemantics *semantics;
1305     const bool sign;
1306     const unsigned long long bitPattern[2];
1307     const unsigned bitPatternLength;
1308   } const GetZeroTest[] = {
1309     { &APFloat::IEEEhalf, false, {0, 0}, 1},
1310     { &APFloat::IEEEhalf, true, {0x8000ULL, 0}, 1},
1311     { &APFloat::IEEEsingle, false, {0, 0}, 1},
1312     { &APFloat::IEEEsingle, true, {0x80000000ULL, 0}, 1},
1313     { &APFloat::IEEEdouble, false, {0, 0}, 1},
1314     { &APFloat::IEEEdouble, true, {0x8000000000000000ULL, 0}, 1},
1315     { &APFloat::IEEEquad, false, {0, 0}, 2},
1316     { &APFloat::IEEEquad, true, {0, 0x8000000000000000ULL}, 2},
1317     { &APFloat::PPCDoubleDouble, false, {0, 0}, 2},
1318     { &APFloat::PPCDoubleDouble, true, {0x8000000000000000ULL, 0}, 2},
1319     { &APFloat::x87DoubleExtended, false, {0, 0}, 2},
1320     { &APFloat::x87DoubleExtended, true, {0, 0x8000ULL}, 2},
1321   };
1322   const unsigned NumGetZeroTests = 12;
1323   for (unsigned i = 0; i < NumGetZeroTests; ++i) {
1324     APFloat test = APFloat::getZero(*GetZeroTest[i].semantics,
1325                                     GetZeroTest[i].sign);
1326     const char *pattern = GetZeroTest[i].sign? "-0x0p+0" : "0x0p+0";
1327     APFloat expected = APFloat(*GetZeroTest[i].semantics,
1328                                pattern);
1329     EXPECT_TRUE(test.isZero());
1330     EXPECT_TRUE(GetZeroTest[i].sign? test.isNegative() : !test.isNegative());
1331     EXPECT_TRUE(test.bitwiseIsEqual(expected));
1332     for (unsigned j = 0, je = GetZeroTest[i].bitPatternLength; j < je; ++j) {
1333       EXPECT_EQ(GetZeroTest[i].bitPattern[j],
1334                 test.bitcastToAPInt().getRawData()[j]);
1335     }
1336   }
1337 }
1338
1339 TEST(APFloatTest, convert) {
1340   bool losesInfo;
1341   APFloat test(APFloat::IEEEdouble, "1.0");
1342   test.convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven, &losesInfo);
1343   EXPECT_EQ(1.0f, test.convertToFloat());
1344   EXPECT_FALSE(losesInfo);
1345
1346   test = APFloat(APFloat::x87DoubleExtended, "0x1p-53");
1347   test.add(APFloat(APFloat::x87DoubleExtended, "1.0"), APFloat::rmNearestTiesToEven);
1348   test.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, &losesInfo);
1349   EXPECT_EQ(1.0, test.convertToDouble());
1350   EXPECT_TRUE(losesInfo);
1351
1352   test = APFloat(APFloat::IEEEquad, "0x1p-53");
1353   test.add(APFloat(APFloat::IEEEquad, "1.0"), APFloat::rmNearestTiesToEven);
1354   test.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, &losesInfo);
1355   EXPECT_EQ(1.0, test.convertToDouble());
1356   EXPECT_TRUE(losesInfo);
1357
1358   test = APFloat(APFloat::x87DoubleExtended, "0xf.fffffffp+28");
1359   test.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, &losesInfo);
1360   EXPECT_EQ(4294967295.0, test.convertToDouble());
1361   EXPECT_FALSE(losesInfo);
1362
1363   test = APFloat::getSNaN(APFloat::IEEEsingle);
1364   APFloat X87SNaN = APFloat::getSNaN(APFloat::x87DoubleExtended);
1365   test.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven,
1366                &losesInfo);
1367   EXPECT_TRUE(test.bitwiseIsEqual(X87SNaN));
1368   EXPECT_FALSE(losesInfo);
1369
1370   test = APFloat::getQNaN(APFloat::IEEEsingle);
1371   APFloat X87QNaN = APFloat::getQNaN(APFloat::x87DoubleExtended);
1372   test.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven,
1373                &losesInfo);
1374   EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN));
1375   EXPECT_FALSE(losesInfo);
1376
1377   test = APFloat::getSNaN(APFloat::x87DoubleExtended);
1378   test.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven,
1379                &losesInfo);
1380   EXPECT_TRUE(test.bitwiseIsEqual(X87SNaN));
1381   EXPECT_FALSE(losesInfo);
1382
1383   test = APFloat::getQNaN(APFloat::x87DoubleExtended);
1384   test.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven,
1385                &losesInfo);
1386   EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN));
1387   EXPECT_FALSE(losesInfo);
1388 }
1389
1390 TEST(APFloatTest, PPCDoubleDouble) {
1391   APFloat test(APFloat::PPCDoubleDouble, "1.0");
1392   EXPECT_EQ(0x3ff0000000000000ull, test.bitcastToAPInt().getRawData()[0]);
1393   EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1394
1395   test.divide(APFloat(APFloat::PPCDoubleDouble, "3.0"), APFloat::rmNearestTiesToEven);
1396   EXPECT_EQ(0x3fd5555555555555ull, test.bitcastToAPInt().getRawData()[0]);
1397   EXPECT_EQ(0x3c75555555555556ull, test.bitcastToAPInt().getRawData()[1]);
1398
1399   // LDBL_MAX
1400   test = APFloat(APFloat::PPCDoubleDouble, "1.79769313486231580793728971405301e+308");
1401   EXPECT_EQ(0x7fefffffffffffffull, test.bitcastToAPInt().getRawData()[0]);
1402   EXPECT_EQ(0x7c8ffffffffffffeull, test.bitcastToAPInt().getRawData()[1]);
1403
1404   // LDBL_MIN
1405   test = APFloat(APFloat::PPCDoubleDouble, "2.00416836000897277799610805135016e-292");
1406   EXPECT_EQ(0x0360000000000000ull, test.bitcastToAPInt().getRawData()[0]);
1407   EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1408
1409   test = APFloat(APFloat::PPCDoubleDouble, "1.0");
1410   test.add(APFloat(APFloat::PPCDoubleDouble, "0x1p-105"), APFloat::rmNearestTiesToEven);
1411   EXPECT_EQ(0x3ff0000000000000ull, test.bitcastToAPInt().getRawData()[0]);
1412   EXPECT_EQ(0x3960000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1413
1414   test = APFloat(APFloat::PPCDoubleDouble, "1.0");
1415   test.add(APFloat(APFloat::PPCDoubleDouble, "0x1p-106"), APFloat::rmNearestTiesToEven);
1416   EXPECT_EQ(0x3ff0000000000000ull, test.bitcastToAPInt().getRawData()[0]);
1417 #if 0 // XFAIL
1418   // This is what we would expect with a true double-double implementation
1419   EXPECT_EQ(0x3950000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1420 #else
1421   // This is what we get with our 106-bit mantissa approximation
1422   EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1423 #endif
1424 }
1425
1426 TEST(APFloatTest, isNegative) {
1427   APFloat t(APFloat::IEEEsingle, "0x1p+0");
1428   EXPECT_FALSE(t.isNegative());
1429   t = APFloat(APFloat::IEEEsingle, "-0x1p+0");
1430   EXPECT_TRUE(t.isNegative());
1431
1432   EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isNegative());
1433   EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle, true).isNegative());
1434
1435   EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isNegative());
1436   EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle, true).isNegative());
1437
1438   EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isNegative());
1439   EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle, true).isNegative());
1440
1441   EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isNegative());
1442   EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, true).isNegative());
1443 }
1444
1445 TEST(APFloatTest, isNormal) {
1446   APFloat t(APFloat::IEEEsingle, "0x1p+0");
1447   EXPECT_TRUE(t.isNormal());
1448
1449   EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isNormal());
1450   EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isNormal());
1451   EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isNormal());
1452   EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isNormal());
1453   EXPECT_FALSE(APFloat(APFloat::IEEEsingle, "0x1p-149").isNormal());
1454 }
1455
1456 TEST(APFloatTest, isFinite) {
1457   APFloat t(APFloat::IEEEsingle, "0x1p+0");
1458   EXPECT_TRUE(t.isFinite());
1459   EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isFinite());
1460   EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle, false).isFinite());
1461   EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isFinite());
1462   EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isFinite());
1463   EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "0x1p-149").isFinite());
1464 }
1465
1466 TEST(APFloatTest, isInfinity) {
1467   APFloat t(APFloat::IEEEsingle, "0x1p+0");
1468   EXPECT_FALSE(t.isInfinity());
1469   EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle, false).isInfinity());
1470   EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isInfinity());
1471   EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isInfinity());
1472   EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isInfinity());
1473   EXPECT_FALSE(APFloat(APFloat::IEEEsingle, "0x1p-149").isInfinity());
1474 }
1475
1476 TEST(APFloatTest, isNaN) {
1477   APFloat t(APFloat::IEEEsingle, "0x1p+0");
1478   EXPECT_FALSE(t.isNaN());
1479   EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isNaN());
1480   EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isNaN());
1481   EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle, false).isNaN());
1482   EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, false).isNaN());
1483   EXPECT_FALSE(APFloat(APFloat::IEEEsingle, "0x1p-149").isNaN());
1484 }
1485
1486 TEST(APFloatTest, isFiniteNonZero) {
1487   // Test positive/negative normal value.
1488   EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "0x1p+0").isFiniteNonZero());
1489   EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "-0x1p+0").isFiniteNonZero());
1490
1491   // Test positive/negative denormal value.
1492   EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "0x1p-149").isFiniteNonZero());
1493   EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "-0x1p-149").isFiniteNonZero());
1494
1495   // Test +/- Infinity.
1496   EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isFiniteNonZero());
1497   EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, true).isFiniteNonZero());
1498
1499   // Test +/- Zero.
1500   EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isFiniteNonZero());
1501   EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, true).isFiniteNonZero());
1502
1503   // Test +/- qNaN. +/- dont mean anything with qNaN but paranoia can't hurt in
1504   // this instance.
1505   EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isFiniteNonZero());
1506   EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, true).isFiniteNonZero());
1507
1508   // Test +/- sNaN. +/- dont mean anything with sNaN but paranoia can't hurt in
1509   // this instance.
1510   EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isFiniteNonZero());
1511   EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, true).isFiniteNonZero());
1512 }
1513
1514 TEST(APFloatTest, add) {
1515   // Test Special Cases against each other and normal values.
1516
1517   // TODOS/NOTES:
1518   // 1. Since we perform only default exception handling all operations with
1519   // signaling NaNs should have a result that is a quiet NaN. Currently they
1520   // return sNaN.
1521   // 2. It seems that add(-x, NaN) = -NaN but add(NaN, -x) = NaN. This is an
1522   // inconsistency that should be looked into. IEEE-754R specifies that the
1523   // interpretation of the sign of NaN is unspecified. We should always have NaN
1524   // be positive since that is one less thing for the compiler to deal with.
1525
1526   APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false);
1527   APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true);
1528   APFloat PZero = APFloat::getZero(APFloat::IEEEsingle, false);
1529   APFloat MZero = APFloat::getZero(APFloat::IEEEsingle, true);
1530   APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle, false);
1531   APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle, false);
1532   APFloat PNormalValue = APFloat(APFloat::IEEEsingle, "0x1p+0");
1533   APFloat MNormalValue = APFloat(APFloat::IEEEsingle, "-0x1p+0");
1534   APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle, false);
1535   APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle, true);
1536   APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, false);
1537   APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, true);
1538   APFloat PSmallestNormalized =
1539     APFloat::getSmallestNormalized(APFloat::IEEEsingle, false);
1540   APFloat MSmallestNormalized =
1541     APFloat::getSmallestNormalized(APFloat::IEEEsingle, true);
1542
1543   const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
1544
1545   const unsigned NumTests = 169;
1546   struct {
1547     APFloat x;
1548     APFloat y;
1549     const char *result;
1550     int status;
1551     int category;
1552   } SpecialCaseTests[NumTests] = {
1553     { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1554     { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1555     { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
1556     { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
1557     { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1558 #if 0
1559     // See Note 1.
1560     { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1561 #endif
1562     { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1563     { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1564     { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1565     { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1566     { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1567     { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1568     { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
1569     { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
1570     { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1571     { MInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1572     { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
1573     { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
1574     // See Note 2.
1575     { MInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1576 #if 0
1577     // See Note 1.
1578     { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1579 #endif
1580     { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1581     { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1582     { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1583     { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1584     { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1585     { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1586     { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
1587     { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
1588     { PZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1589     { PZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1590     { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1591     { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1592     { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1593 #if 0
1594     // See Note 1.
1595     { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1596 #endif
1597     { PZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1598     { PZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1599     { PZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1600     { PZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1601     { PZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1602     { PZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1603     { PZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1604     { PZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1605     { MZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1606     { MZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1607     { MZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1608     { MZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
1609     // See Note 2.
1610     { MZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1611 #if 0
1612     // See Note 1.
1613     { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1614 #endif
1615     { MZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1616     { MZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1617     { MZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1618     { MZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1619     { MZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1620     { MZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1621     { MZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1622     { MZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1623     { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
1624     { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
1625     { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
1626     { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
1627     { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1628 #if 0
1629     // See Note 1.
1630     { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1631 #endif
1632     { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
1633     { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
1634     { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1635     { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1636     { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1637     { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1638     { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
1639     { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
1640 #if 0
1641     // See Note 1.
1642     { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1643     { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1644     { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1645     { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1646     { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1647     { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1648     { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1649     { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1650     { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1651     { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1652     { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1653     { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1654     { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1655     { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1656 #endif
1657     { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1658     { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1659     { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1660     { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1661     { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1662 #if 0
1663     // See Note 1.
1664     { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1665 #endif
1666     { PNormalValue, PNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal },
1667     { PNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1668     { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1669     { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1670     { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1671     { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1672     { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1673     { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1674     { MNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1675     { MNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1676     { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1677     { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1678     // See Note 2.
1679     { MNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1680 #if 0
1681     // See Note 1.
1682     { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1683 #endif
1684     { MNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1685     { MNormalValue, MNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal },
1686     { MNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1687     { MNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1688     { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1689     { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1690     { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1691     { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1692     { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1693     { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1694     { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1695     { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1696     { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1697 #if 0
1698     // See Note 1.
1699     { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1700 #endif
1701     { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1702     { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1703     { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
1704     { PLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1705     { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1706     { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1707     { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1708     { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1709     { MLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1710     { MLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1711     { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1712     { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1713     // See Note 2.
1714     { MLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1715 #if 0
1716     // See Note 1.
1717     { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1718 #endif
1719     { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1720     { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1721     { MLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1722     { MLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
1723     { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1724     { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1725     { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1726     { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1727     { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1728     { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1729     { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1730     { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1731     { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1732 #if 0
1733     // See Note 1.
1734     { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1735 #endif
1736     { PSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1737     { PSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1738     { PSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1739     { PSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1740     { PSmallestValue, PSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal },
1741     { PSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1742     { PSmallestValue, PSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1743     { PSmallestValue, MSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1744     { MSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1745     { MSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1746     { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1747     { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1748     // See Note 2.
1749     { MSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1750 #if 0
1751     // See Note 1.
1752     { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1753 #endif
1754     { MSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1755     { MSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1756     { MSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1757     { MSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1758     { MSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1759     { MSmallestValue, MSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal },
1760     { MSmallestValue, PSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1761     { MSmallestValue, MSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1762     { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1763     { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1764     { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1765     { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1766     { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1767 #if 0
1768 // See Note 1.
1769     { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1770 #endif
1771     { PSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1772     { PSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1773     { PSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1774     { PSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1775     { PSmallestNormalized, PSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1776     { PSmallestNormalized, MSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1777     { PSmallestNormalized, PSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
1778     { PSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1779     { MSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1780     { MSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1781     { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1782     { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1783     // See Note 2.
1784     { MSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1785 #if 0
1786     // See Note 1.
1787     { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1788 #endif
1789     { MSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1790     { MSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1791     { MSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1792     { MSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1793     { MSmallestNormalized, PSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1794     { MSmallestNormalized, MSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1795     { MSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1796     { MSmallestNormalized, MSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal }
1797   };
1798
1799   for (size_t i = 0; i < NumTests; ++i) {
1800     APFloat x(SpecialCaseTests[i].x);
1801     APFloat y(SpecialCaseTests[i].y);
1802     APFloat::opStatus status = x.add(y, APFloat::rmNearestTiesToEven);
1803
1804     APFloat result(APFloat::IEEEsingle, SpecialCaseTests[i].result);
1805
1806     EXPECT_TRUE(result.bitwiseIsEqual(x));
1807     EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
1808     EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
1809   }
1810 }
1811
1812 TEST(APFloatTest, subtract) {
1813   // Test Special Cases against each other and normal values.
1814
1815   // TODOS/NOTES:
1816   // 1. Since we perform only default exception handling all operations with
1817   // signaling NaNs should have a result that is a quiet NaN. Currently they
1818   // return sNaN.
1819   // 2. It seems that sub(-x, NaN) = -NaN but sub(NaN, -x) = NaN. This is an
1820   // inconsistency that should be looked into. IEEE-754R specifies that the
1821   // interpretation of the sign of NaN is unspecified. We should always have NaN
1822   // be positive since that is one less thing for the compiler to deal with.
1823
1824   APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false);
1825   APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true);
1826   APFloat PZero = APFloat::getZero(APFloat::IEEEsingle, false);
1827   APFloat MZero = APFloat::getZero(APFloat::IEEEsingle, true);
1828   APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle, false);
1829   APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle, false);
1830   APFloat PNormalValue = APFloat(APFloat::IEEEsingle, "0x1p+0");
1831   APFloat MNormalValue = APFloat(APFloat::IEEEsingle, "-0x1p+0");
1832   APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle, false);
1833   APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle, true);
1834   APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, false);
1835   APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, true);
1836   APFloat PSmallestNormalized =
1837     APFloat::getSmallestNormalized(APFloat::IEEEsingle, false);
1838   APFloat MSmallestNormalized =
1839     APFloat::getSmallestNormalized(APFloat::IEEEsingle, true);
1840
1841   const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
1842
1843   const unsigned NumTests = 169;
1844   struct {
1845     APFloat x;
1846     APFloat y;
1847     const char *result;
1848     int status;
1849     int category;
1850   } SpecialCaseTests[NumTests] = {
1851     { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1852     { PInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1853     { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
1854     { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
1855     { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1856 #if 0
1857 // See Note 1.
1858     { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1859 #endif
1860     { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1861     { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1862     { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1863     { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1864     { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1865     { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1866     { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
1867     { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
1868     { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1869     { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1870     { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
1871     { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
1872     // See Note 2.
1873     { MInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1874 #if 0
1875 // See Note 1.
1876     { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1877 #endif
1878     { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1879     { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1880     { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1881     { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1882     { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1883     { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1884     { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
1885     { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
1886     { PZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1887     { PZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1888     { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1889     { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1890     { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1891 #if 0
1892 // See Note 1.
1893     { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1894 #endif
1895     { PZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1896     { PZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1897     { PZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1898     { PZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1899     { PZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1900     { PZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1901     { PZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1902     { PZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1903     { MZero, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1904     { MZero, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1905     { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
1906     { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1907     // See Note 2.
1908     { MZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1909 #if 0
1910 // See Note 1.
1911     { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1912 #endif
1913     { MZero, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1914     { MZero, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1915     { MZero, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1916     { MZero, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1917     { MZero, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1918     { MZero, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1919     { MZero, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1920     { MZero, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1921     { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
1922     { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
1923     { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
1924     { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
1925     { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1926 #if 0
1927 // See Note 1.
1928     { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1929 #endif
1930     { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
1931     { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
1932     { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1933     { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1934     { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1935     { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1936     { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
1937     { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
1938 #if 0
1939 // See Note 1.
1940     { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1941     { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1942     { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1943     { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1944     { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1945     { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1946     { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1947     { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1948     { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1949     { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1950     { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1951     { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1952     { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1953     { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1954 #endif
1955     { PNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1956     { PNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1957     { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1958     { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1959     { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1960 #if 0
1961 // See Note 1.
1962     { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1963 #endif
1964     { PNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1965     { PNormalValue, MNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal },
1966     { PNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1967     { PNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1968     { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1969     { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1970     { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1971     { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1972     { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1973     { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1974     { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1975     { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1976     // See Note 2.
1977     { MNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1978 #if 0
1979 // See Note 1.
1980     { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1981 #endif
1982     { MNormalValue, PNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal },
1983     { MNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1984     { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1985     { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1986     { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1987     { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1988     { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1989     { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1990     { PLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1991     { PLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1992     { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1993     { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1994     { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1995 #if 0
1996 // See Note 1.
1997     { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1998 #endif
1999     { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2000     { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2001     { PLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2002     { PLargestValue, MLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2003     { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2004     { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2005     { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2006     { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2007     { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2008     { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2009     { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2010     { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2011     // See Note 2.
2012     { MLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2013 #if 0
2014 // See Note 1.
2015     { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2016 #endif
2017     { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2018     { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2019     { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2020     { MLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2021     { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2022     { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2023     { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2024     { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2025     { PSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2026     { PSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2027     { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2028     { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2029     { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2030 #if 0
2031 // See Note 1.
2032     { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2033 #endif
2034     { PSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2035     { PSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2036     { PSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2037     { PSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2038     { PSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2039     { PSmallestValue, MSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal },
2040     { PSmallestValue, PSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2041     { PSmallestValue, MSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2042     { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2043     { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2044     { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2045     { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2046     // See Note 2.
2047     { MSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2048 #if 0
2049 // See Note 1.
2050     { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2051 #endif
2052     { MSmallestValue, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2053     { MSmallestValue, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2054     { MSmallestValue, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2055     { MSmallestValue, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2056     { MSmallestValue, PSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal },
2057     { MSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2058     { MSmallestValue, PSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2059     { MSmallestValue, MSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2060     { PSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2061     { PSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2062     { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2063     { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2064     { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2065 #if 0
2066 // See Note 1.
2067     { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2068 #endif
2069     { PSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2070     { PSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2071     { PSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2072     { PSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2073     { PSmallestNormalized, PSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2074     { PSmallestNormalized, MSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2075     { PSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2076     { PSmallestNormalized, MSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
2077     { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2078     { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2079     { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2080     { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2081     // See Note 2.
2082     { MSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2083 #if 0
2084 // See Note 1.
2085     { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2086 #endif
2087     { MSmallestNormalized, PNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2088     { MSmallestNormalized, MNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
2089     { MSmallestNormalized, PLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2090     { MSmallestNormalized, MLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
2091     { MSmallestNormalized, PSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
2092     { MSmallestNormalized, MSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
2093     { MSmallestNormalized, PSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal },
2094     { MSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero }
2095   };
2096
2097   for (size_t i = 0; i < NumTests; ++i) {
2098     APFloat x(SpecialCaseTests[i].x);
2099     APFloat y(SpecialCaseTests[i].y);
2100     APFloat::opStatus status = x.subtract(y, APFloat::rmNearestTiesToEven);
2101
2102     APFloat result(APFloat::IEEEsingle, SpecialCaseTests[i].result);
2103
2104     EXPECT_TRUE(result.bitwiseIsEqual(x));
2105     EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
2106     EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
2107   }
2108 }
2109
2110 TEST(APFloatTest, multiply) {
2111   // Test Special Cases against each other and normal values.
2112
2113   // TODOS/NOTES:
2114   // 1. Since we perform only default exception handling all operations with
2115   // signaling NaNs should have a result that is a quiet NaN. Currently they
2116   // return sNaN.
2117   // 2. It seems that multiply(-x, NaN) = multiply(NaN, -x) = -NaN. IEEE-754R
2118   // leaves the meaning of the sign of NaNs as unspecified. To simplify things,
2119   // we should just assume that NaN is always positive. I will fix this.
2120
2121   APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false);
2122   APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true);
2123   APFloat PZero = APFloat::getZero(APFloat::IEEEsingle, false);
2124   APFloat MZero = APFloat::getZero(APFloat::IEEEsingle, true);
2125   APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle, false);
2126   APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle, false);
2127   APFloat PNormalValue = APFloat(APFloat::IEEEsingle, "0x1p+0");
2128   APFloat MNormalValue = APFloat(APFloat::IEEEsingle, "-0x1p+0");
2129   APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle, false);
2130   APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle, true);
2131   APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, false);
2132   APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, true);
2133   APFloat PSmallestNormalized =
2134     APFloat::getSmallestNormalized(APFloat::IEEEsingle, false);
2135   APFloat MSmallestNormalized =
2136     APFloat::getSmallestNormalized(APFloat::IEEEsingle, true);
2137
2138   const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
2139   const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact;
2140
2141   const unsigned NumTests = 169;
2142   struct {
2143     APFloat x;
2144     APFloat y;
2145     const char *result;
2146     int status;
2147     int category;
2148   } SpecialCaseTests[NumTests] = {
2149     { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2150     { PInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2151     { PInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2152     { PInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2153     { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2154 #if 0
2155 // See Note 1.
2156     { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2157 #endif
2158     { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2159     { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2160     { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2161     { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2162     { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2163     { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2164     { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2165     { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2166     { MInf, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2167     { MInf, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2168     { MInf, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2169     { MInf, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2170     // See Note 2.
2171     { MInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2172 #if 0
2173 // See Note 1.
2174     { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2175 #endif
2176     { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2177     { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2178     { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2179     { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2180     { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2181     { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2182     { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2183     { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2184     { PZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2185     { PZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2186     { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2187     { PZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2188     { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2189 #if 0
2190 // See Note 1.
2191     { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2192 #endif
2193     { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2194     { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2195     { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2196     { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2197     { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2198     { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2199     { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2200     { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2201     { MZero, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2202     { MZero, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2203     { MZero, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2204     { MZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2205     // See Note 2.
2206     { MZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2207 #if 0
2208 // See Note 1.
2209     { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2210 #endif
2211     { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2212     { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2213     { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2214     { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2215     { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2216     { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2217     { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2218     { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2219     { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2220     // See Note 2.
2221     { QNaN, MInf, "-nan", APFloat::opOK, APFloat::fcNaN },
2222     { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2223     // See Note 2.
2224     { QNaN, MZero, "-nan", APFloat::opOK, APFloat::fcNaN },
2225     { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2226 #if 0
2227 // See Note 1.
2228     { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2229 #endif
2230     { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2231     // See Note 2.
2232     { QNaN, MNormalValue, "-nan", APFloat::opOK, APFloat::fcNaN },
2233     { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2234     // See Note 2.
2235     { QNaN, MLargestValue, "-nan", APFloat::opOK, APFloat::fcNaN },
2236     { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2237     // See Note 2.
2238     { QNaN, MSmallestValue, "-nan", APFloat::opOK, APFloat::fcNaN },
2239     { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2240     // See Note 2.
2241     { QNaN, MSmallestNormalized, "-nan", APFloat::opOK, APFloat::fcNaN },
2242 #if 0
2243 // See Note 1.
2244     { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2245     { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2246     { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2247     { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2248     { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2249     { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2250     { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2251     { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2252     { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2253     { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2254     { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2255     { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2256     { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2257     { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2258 #endif
2259     { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2260     { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2261     { PNormalValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2262     { PNormalValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2263     { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2264 #if 0
2265 // See Note 1.
2266     { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2267 #endif
2268     { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2269     { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2270     { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2271     { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2272     { PNormalValue, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2273     { PNormalValue, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2274     { PNormalValue, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2275     { PNormalValue, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2276     { MNormalValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2277     { MNormalValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2278     { MNormalValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2279     { MNormalValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2280     // See Note 2.
2281     { MNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2282 #if 0
2283 // See Note 1.
2284     { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2285 #endif
2286     { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2287     { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2288     { MNormalValue, PLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2289     { MNormalValue, MLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2290     { MNormalValue, PSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2291     { MNormalValue, MSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2292     { MNormalValue, PSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2293     { MNormalValue, MSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2294     { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2295     { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2296     { PLargestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2297     { PLargestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2298     { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2299 #if 0
2300 // See Note 1.
2301     { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2302 #endif
2303     { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2304     { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2305     { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2306     { PLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2307     { PLargestValue, PSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2308     { PLargestValue, MSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2309     { PLargestValue, PSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2310     { PLargestValue, MSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2311     { MLargestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2312     { MLargestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2313     { MLargestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2314     { MLargestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2315     // See Note 2.
2316     { MLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2317 #if 0
2318 // See Note 1.
2319     { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2320 #endif
2321     { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2322     { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2323     { MLargestValue, PLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2324     { MLargestValue, MLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2325     { MLargestValue, PSmallestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2326     { MLargestValue, MSmallestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2327     { MLargestValue, PSmallestNormalized, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2328     { MLargestValue, MSmallestNormalized, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2329     { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2330     { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2331     { PSmallestValue, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2332     { PSmallestValue, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2333     { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2334 #if 0
2335 // See Note 1.
2336     { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2337 #endif
2338     { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2339     { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2340     { PSmallestValue, PLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2341     { PSmallestValue, MLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2342     { PSmallestValue, PSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2343     { PSmallestValue, MSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2344     { PSmallestValue, PSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2345     { PSmallestValue, MSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2346     { MSmallestValue, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2347     { MSmallestValue, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2348     { MSmallestValue, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2349     { MSmallestValue, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2350     // See Note 2.
2351     { MSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2352 #if 0
2353 // See Note 1.
2354     { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2355 #endif
2356     { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2357     { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2358     { MSmallestValue, PLargestValue, "-0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2359     { MSmallestValue, MLargestValue, "0x1.fffffep-22", APFloat::opOK, APFloat::fcNormal },
2360     { MSmallestValue, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2361     { MSmallestValue, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2362     { MSmallestValue, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2363     { MSmallestValue, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2364     { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2365     { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2366     { PSmallestNormalized, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2367     { PSmallestNormalized, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2368     { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2369 #if 0
2370 // See Note 1.
2371     { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2372 #endif
2373     { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2374     { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2375     { PSmallestNormalized, PLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2376     { PSmallestNormalized, MLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2377     { PSmallestNormalized, PSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2378     { PSmallestNormalized, MSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2379     { PSmallestNormalized, PSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2380     { PSmallestNormalized, MSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2381     { MSmallestNormalized, PInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
2382     { MSmallestNormalized, MInf, "inf", APFloat::opOK, APFloat::fcInfinity },
2383     { MSmallestNormalized, PZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2384     { MSmallestNormalized, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2385     // See Note 2.
2386     { MSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2387 #if 0
2388 // See Note 1.
2389     { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2390 #endif
2391     { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2392     { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2393     { MSmallestNormalized, PLargestValue, "-0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2394     { MSmallestNormalized, MLargestValue, "0x1.fffffep+1", APFloat::opOK, APFloat::fcNormal },
2395     { MSmallestNormalized, PSmallestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2396     { MSmallestNormalized, MSmallestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2397     { MSmallestNormalized, PSmallestNormalized, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2398     { MSmallestNormalized, MSmallestNormalized, "0x0p+0", UnderflowStatus, APFloat::fcZero }
2399   };
2400
2401   for (size_t i = 0; i < NumTests; ++i) {
2402     APFloat x(SpecialCaseTests[i].x);
2403     APFloat y(SpecialCaseTests[i].y);
2404     APFloat::opStatus status = x.multiply(y, APFloat::rmNearestTiesToEven);
2405
2406     APFloat result(APFloat::IEEEsingle, SpecialCaseTests[i].result);
2407
2408     EXPECT_TRUE(result.bitwiseIsEqual(x));
2409     EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
2410     EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
2411   }
2412 }
2413
2414 TEST(APFloatTest, divide) {
2415   // Test Special Cases against each other and normal values.
2416
2417   // TODOS/NOTES:
2418   // 1. Since we perform only default exception handling all operations with
2419   // signaling NaNs should have a result that is a quiet NaN. Currently they
2420   // return sNaN.
2421   // 2. It seems that divide(-x, NaN) = divide(NaN, -x) = -NaN. IEEE-754R
2422   // leaves the meaning of the sign of NaNs as unspecified. To simplify things,
2423   // we should just assume that NaN is always positive. I will fix this.
2424
2425   APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false);
2426   APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true);
2427   APFloat PZero = APFloat::getZero(APFloat::IEEEsingle, false);
2428   APFloat MZero = APFloat::getZero(APFloat::IEEEsingle, true);
2429   APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle, false);
2430   APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle, false);
2431   APFloat PNormalValue = APFloat(APFloat::IEEEsingle, "0x1p+0");
2432   APFloat MNormalValue = APFloat(APFloat::IEEEsingle, "-0x1p+0");
2433   APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle, false);
2434   APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle, true);
2435   APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, false);
2436   APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, true);
2437   APFloat PSmallestNormalized =
2438     APFloat::getSmallestNormalized(APFloat::IEEEsingle, false);
2439   APFloat MSmallestNormalized =
2440     APFloat::getSmallestNormalized(APFloat::IEEEsingle, true);
2441
2442   const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
2443   const int UnderflowStatus = APFloat::opUnderflow | APFloat::opInexact;
2444
2445   const unsigned NumTests = 169;
2446   struct {
2447     APFloat x;
2448     APFloat y;
2449     const char *result;
2450     int status;
2451     int category;
2452   } SpecialCaseTests[NumTests] = {
2453     { PInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2454     { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2455     { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2456     { PInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2457     { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2458 #if 0
2459 // See Note 1.
2460     { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2461 #endif
2462     { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2463     { PInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2464     { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2465     { PInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2466     { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2467     { PInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2468     { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2469     { PInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2470     { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2471     { MInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2472     { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
2473     { MInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
2474     // See Note 2.
2475     { MInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2476 #if 0
2477 // See Note 1.
2478     { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2479 #endif
2480     { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2481     { MInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2482     { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2483     { MInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2484     { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
2485     { MInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
2486     { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
2487     { MInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
2488     { PZero, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2489     { PZero, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2490     { PZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2491     { PZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2492     { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2493 #if 0
2494 // See Note 1.
2495     { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2496 #endif
2497     { PZero, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2498     { PZero, MNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2499     { PZero, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2500     { PZero, MLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2501     { PZero, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2502     { PZero, MSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2503     { PZero, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2504     { PZero, MSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2505     { MZero, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2506     { MZero, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2507     { MZero, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2508     { MZero, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2509     // See Note 2.
2510     { MZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2511 #if 0
2512 // See Note 1.
2513     { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2514 #endif
2515     { MZero, PNormalValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2516     { MZero, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2517     { MZero, PLargestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2518     { MZero, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2519     { MZero, PSmallestValue, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2520     { MZero, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2521     { MZero, PSmallestNormalized, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2522     { MZero, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2523     { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
2524     // See Note 2.
2525     { QNaN, MInf, "-nan", APFloat::opOK, APFloat::fcNaN },
2526     { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
2527     // See Note 2.
2528     { QNaN, MZero, "-nan", APFloat::opOK, APFloat::fcNaN },
2529     { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2530 #if 0
2531 // See Note 1.
2532     { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2533 #endif
2534     { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
2535     // See Note 2.
2536     { QNaN, MNormalValue, "-nan", APFloat::opOK, APFloat::fcNaN },
2537     { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2538     // See Note 2.
2539     { QNaN, MLargestValue, "-nan", APFloat::opOK, APFloat::fcNaN },
2540     { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
2541     // See Note 2.
2542     { QNaN, MSmallestValue, "-nan", APFloat::opOK, APFloat::fcNaN },
2543     { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
2544     // See Note 2.
2545     { QNaN, MSmallestNormalized, "-nan", APFloat::opOK, APFloat::fcNaN },
2546 #if 0
2547 // See Note 1.
2548     { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2549     { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2550     { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2551     { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2552     { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2553     { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2554     { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2555     { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2556     { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2557     { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2558     { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2559     { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2560     { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2561     { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2562 #endif
2563     { PNormalValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2564     { PNormalValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2565     { PNormalValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2566     { PNormalValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2567     { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2568 #if 0
2569 // See Note 1.
2570     { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2571 #endif
2572     { PNormalValue, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2573     { PNormalValue, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2574     { PNormalValue, PLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal },
2575     { PNormalValue, MLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal },
2576     { PNormalValue, PSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2577     { PNormalValue, MSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2578     { PNormalValue, PSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal },
2579     { PNormalValue, MSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal },
2580     { MNormalValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2581     { MNormalValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2582     { MNormalValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2583     { MNormalValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2584     // See Note 2.
2585     { MNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2586 #if 0
2587 // See Note 1.
2588     { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2589 #endif
2590     { MNormalValue, PNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2591     { MNormalValue, MNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2592     { MNormalValue, PLargestValue, "-0x1p-128", UnderflowStatus, APFloat::fcNormal },
2593     { MNormalValue, MLargestValue, "0x1p-128", UnderflowStatus, APFloat::fcNormal },
2594     { MNormalValue, PSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2595     { MNormalValue, MSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2596     { MNormalValue, PSmallestNormalized, "-0x1p+126", APFloat::opOK, APFloat::fcNormal },
2597     { MNormalValue, MSmallestNormalized, "0x1p+126", APFloat::opOK, APFloat::fcNormal },
2598     { PLargestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2599     { PLargestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2600     { PLargestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2601     { PLargestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2602     { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2603 #if 0
2604 // See Note 1.
2605     { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2606 #endif
2607     { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2608     { PLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2609     { PLargestValue, PLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2610     { PLargestValue, MLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2611     { PLargestValue, PSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2612     { PLargestValue, MSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2613     { PLargestValue, PSmallestNormalized, "inf", OverflowStatus, APFloat::fcInfinity },
2614     { PLargestValue, MSmallestNormalized, "-inf", OverflowStatus, APFloat::fcInfinity },
2615     { MLargestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2616     { MLargestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2617     { MLargestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2618     { MLargestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2619     // See Note 2.
2620     { MLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2621 #if 0
2622 // See Note 1.
2623     { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2624 #endif
2625     { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2626     { MLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
2627     { MLargestValue, PLargestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2628     { MLargestValue, MLargestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2629     { MLargestValue, PSmallestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
2630     { MLargestValue, MSmallestValue, "inf", OverflowStatus, APFloat::fcInfinity },
2631     { MLargestValue, PSmallestNormalized, "-inf", OverflowStatus, APFloat::fcInfinity },
2632     { MLargestValue, MSmallestNormalized, "inf", OverflowStatus, APFloat::fcInfinity },
2633     { PSmallestValue, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2634     { PSmallestValue, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2635     { PSmallestValue, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2636     { PSmallestValue, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2637     { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2638 #if 0
2639 // See Note 1.
2640     { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2641 #endif
2642     { PSmallestValue, PNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2643     { PSmallestValue, MNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2644     { PSmallestValue, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2645     { PSmallestValue, MLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2646     { PSmallestValue, PSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2647     { PSmallestValue, MSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2648     { PSmallestValue, PSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal },
2649     { PSmallestValue, MSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal },
2650     { MSmallestValue, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2651     { MSmallestValue, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2652     { MSmallestValue, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2653     { MSmallestValue, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2654     // See Note 2.
2655     { MSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2656 #if 0
2657 // See Note 1.
2658     { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2659 #endif
2660     { MSmallestValue, PNormalValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
2661     { MSmallestValue, MNormalValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
2662     { MSmallestValue, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2663     { MSmallestValue, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2664     { MSmallestValue, PSmallestValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2665     { MSmallestValue, MSmallestValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2666     { MSmallestValue, PSmallestNormalized, "-0x1p-23", APFloat::opOK, APFloat::fcNormal },
2667     { MSmallestValue, MSmallestNormalized, "0x1p-23", APFloat::opOK, APFloat::fcNormal },
2668     { PSmallestNormalized, PInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2669     { PSmallestNormalized, MInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2670     { PSmallestNormalized, PZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2671     { PSmallestNormalized, MZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2672     { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
2673 #if 0
2674 // See Note 1.
2675     { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2676 #endif
2677     { PSmallestNormalized, PNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2678     { PSmallestNormalized, MNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2679     { PSmallestNormalized, PLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2680     { PSmallestNormalized, MLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2681     { PSmallestNormalized, PSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal },
2682     { PSmallestNormalized, MSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal },
2683     { PSmallestNormalized, PSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2684     { PSmallestNormalized, MSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2685     { MSmallestNormalized, PInf, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
2686     { MSmallestNormalized, MInf, "0x0p+0", APFloat::opOK, APFloat::fcZero },
2687     { MSmallestNormalized, PZero, "-inf", APFloat::opDivByZero, APFloat::fcInfinity },
2688     { MSmallestNormalized, MZero, "inf", APFloat::opDivByZero, APFloat::fcInfinity },
2689     // See Note 2.
2690     { MSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
2691 #if 0
2692 // See Note 1.
2693     { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
2694 #endif
2695     { MSmallestNormalized, PNormalValue, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
2696     { MSmallestNormalized, MNormalValue, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
2697     { MSmallestNormalized, PLargestValue, "-0x0p+0", UnderflowStatus, APFloat::fcZero },
2698     { MSmallestNormalized, MLargestValue, "0x0p+0", UnderflowStatus, APFloat::fcZero },
2699     { MSmallestNormalized, PSmallestValue, "-0x1p+23", APFloat::opOK, APFloat::fcNormal },
2700     { MSmallestNormalized, MSmallestValue, "0x1p+23", APFloat::opOK, APFloat::fcNormal },
2701     { MSmallestNormalized, PSmallestNormalized, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
2702     { MSmallestNormalized, MSmallestNormalized, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
2703   };
2704
2705   for (size_t i = 0; i < NumTests; ++i) {
2706     APFloat x(SpecialCaseTests[i].x);
2707     APFloat y(SpecialCaseTests[i].y);
2708     APFloat::opStatus status = x.divide(y, APFloat::rmNearestTiesToEven);
2709
2710     APFloat result(APFloat::IEEEsingle, SpecialCaseTests[i].result);
2711
2712     EXPECT_TRUE(result.bitwiseIsEqual(x));
2713     EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
2714     EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
2715   }
2716 }
2717
2718 }