[APFloat] Removed debugging cruft that snuck in.
[oota-llvm.git] / 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, fromZeroDecimalString) {
542   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0").convertToDouble());
543   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0").convertToDouble());
544   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0").convertToDouble());
545
546   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0.").convertToDouble());
547   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.").convertToDouble());
548   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.").convertToDouble());
549
550   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  ".0").convertToDouble());
551   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.0").convertToDouble());
552   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.0").convertToDouble());
553
554   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0.0").convertToDouble());
555   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.0").convertToDouble());
556   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.0").convertToDouble());
557
558   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "00000.").convertToDouble());
559   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+00000.").convertToDouble());
560   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-00000.").convertToDouble());
561
562   EXPECT_EQ(0.0,  APFloat(APFloat::IEEEdouble, ".00000").convertToDouble());
563   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.00000").convertToDouble());
564   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.00000").convertToDouble());
565
566   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0000.00000").convertToDouble());
567   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0000.00000").convertToDouble());
568   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0000.00000").convertToDouble());
569 }
570
571 TEST(APFloatTest, fromZeroDecimalSingleExponentString) {
572   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,   "0e1").convertToDouble());
573   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble,  "+0e1").convertToDouble());
574   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble,  "-0e1").convertToDouble());
575
576   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0e+1").convertToDouble());
577   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e+1").convertToDouble());
578   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e+1").convertToDouble());
579
580   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0e-1").convertToDouble());
581   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e-1").convertToDouble());
582   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e-1").convertToDouble());
583
584
585   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,   "0.e1").convertToDouble());
586   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble,  "+0.e1").convertToDouble());
587   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble,  "-0.e1").convertToDouble());
588
589   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0.e+1").convertToDouble());
590   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.e+1").convertToDouble());
591   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.e+1").convertToDouble());
592
593   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0.e-1").convertToDouble());
594   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.e-1").convertToDouble());
595   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.e-1").convertToDouble());
596
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.0e1").convertToDouble());
611   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble,  "+0.0e1").convertToDouble());
612   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble,  "-0.0e1").convertToDouble());
613
614   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0.0e+1").convertToDouble());
615   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.0e+1").convertToDouble());
616   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.0e+1").convertToDouble());
617
618   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0.0e-1").convertToDouble());
619   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.0e-1").convertToDouble());
620   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.0e-1").convertToDouble());
621
622
623   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "000.0000e1").convertToDouble());
624   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+000.0000e+1").convertToDouble());
625   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-000.0000e+1").convertToDouble());
626 }
627
628 TEST(APFloatTest, fromZeroDecimalLargeExponentString) {
629   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0e1234").convertToDouble());
630   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e1234").convertToDouble());
631   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e1234").convertToDouble());
632
633   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0e+1234").convertToDouble());
634   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e+1234").convertToDouble());
635   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e+1234").convertToDouble());
636
637   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0e-1234").convertToDouble());
638   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e-1234").convertToDouble());
639   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e-1234").convertToDouble());
640
641   EXPECT_EQ(0.0,  APFloat(APFloat::IEEEdouble, "000.0000e1234").convertToDouble());
642   EXPECT_EQ(0.0,  APFloat(APFloat::IEEEdouble, "000.0000e-1234").convertToDouble());
643
644   EXPECT_EQ(0.0,  APFloat(APFloat::IEEEdouble, StringRef("0e1234\02", 6)).convertToDouble());
645 }
646
647 TEST(APFloatTest, fromZeroHexadecimalString) {
648   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x0p1").convertToDouble());
649   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0p1").convertToDouble());
650   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0p1").convertToDouble());
651
652   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x0p+1").convertToDouble());
653   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0p+1").convertToDouble());
654   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0p+1").convertToDouble());
655
656   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x0p-1").convertToDouble());
657   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0p-1").convertToDouble());
658   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0p-1").convertToDouble());
659
660
661   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x0.p1").convertToDouble());
662   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.p1").convertToDouble());
663   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.p1").convertToDouble());
664
665   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x0.p+1").convertToDouble());
666   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.p+1").convertToDouble());
667   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.p+1").convertToDouble());
668
669   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x0.p-1").convertToDouble());
670   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.p-1").convertToDouble());
671   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.p-1").convertToDouble());
672
673
674   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x.0p1").convertToDouble());
675   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x.0p1").convertToDouble());
676   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x.0p1").convertToDouble());
677
678   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x.0p+1").convertToDouble());
679   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x.0p+1").convertToDouble());
680   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x.0p+1").convertToDouble());
681
682   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x.0p-1").convertToDouble());
683   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x.0p-1").convertToDouble());
684   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x.0p-1").convertToDouble());
685
686
687   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x0.0p1").convertToDouble());
688   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.0p1").convertToDouble());
689   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.0p1").convertToDouble());
690
691   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x0.0p+1").convertToDouble());
692   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.0p+1").convertToDouble());
693   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.0p+1").convertToDouble());
694
695   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble,  "0x0.0p-1").convertToDouble());
696   EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.0p-1").convertToDouble());
697   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.0p-1").convertToDouble());
698
699
700   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x00000.p1").convertToDouble());
701   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0000.00000p1").convertToDouble());
702   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x.00000p1").convertToDouble());
703   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.p1").convertToDouble());
704   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0p1234").convertToDouble());
705   EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0p1234").convertToDouble());
706   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x00000.p1234").convertToDouble());
707   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0000.00000p1234").convertToDouble());
708   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x.00000p1234").convertToDouble());
709   EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.p1234").convertToDouble());
710 }
711
712 TEST(APFloatTest, fromDecimalString) {
713   EXPECT_EQ(1.0,      APFloat(APFloat::IEEEdouble, "1").convertToDouble());
714   EXPECT_EQ(2.0,      APFloat(APFloat::IEEEdouble, "2.").convertToDouble());
715   EXPECT_EQ(0.5,      APFloat(APFloat::IEEEdouble, ".5").convertToDouble());
716   EXPECT_EQ(1.0,      APFloat(APFloat::IEEEdouble, "1.0").convertToDouble());
717   EXPECT_EQ(-2.0,     APFloat(APFloat::IEEEdouble, "-2").convertToDouble());
718   EXPECT_EQ(-4.0,     APFloat(APFloat::IEEEdouble, "-4.").convertToDouble());
719   EXPECT_EQ(-0.5,     APFloat(APFloat::IEEEdouble, "-.5").convertToDouble());
720   EXPECT_EQ(-1.5,     APFloat(APFloat::IEEEdouble, "-1.5").convertToDouble());
721   EXPECT_EQ(1.25e12,  APFloat(APFloat::IEEEdouble, "1.25e12").convertToDouble());
722   EXPECT_EQ(1.25e+12, APFloat(APFloat::IEEEdouble, "1.25e+12").convertToDouble());
723   EXPECT_EQ(1.25e-12, APFloat(APFloat::IEEEdouble, "1.25e-12").convertToDouble());
724   EXPECT_EQ(1024.0,   APFloat(APFloat::IEEEdouble, "1024.").convertToDouble());
725   EXPECT_EQ(1024.05,  APFloat(APFloat::IEEEdouble, "1024.05000").convertToDouble());
726   EXPECT_EQ(0.05,     APFloat(APFloat::IEEEdouble, ".05000").convertToDouble());
727   EXPECT_EQ(2.0,      APFloat(APFloat::IEEEdouble, "2.").convertToDouble());
728   EXPECT_EQ(2.0e2,    APFloat(APFloat::IEEEdouble, "2.e2").convertToDouble());
729   EXPECT_EQ(2.0e+2,   APFloat(APFloat::IEEEdouble, "2.e+2").convertToDouble());
730   EXPECT_EQ(2.0e-2,   APFloat(APFloat::IEEEdouble, "2.e-2").convertToDouble());
731   EXPECT_EQ(2.05e2,    APFloat(APFloat::IEEEdouble, "002.05000e2").convertToDouble());
732   EXPECT_EQ(2.05e+2,   APFloat(APFloat::IEEEdouble, "002.05000e+2").convertToDouble());
733   EXPECT_EQ(2.05e-2,   APFloat(APFloat::IEEEdouble, "002.05000e-2").convertToDouble());
734   EXPECT_EQ(2.05e12,   APFloat(APFloat::IEEEdouble, "002.05000e12").convertToDouble());
735   EXPECT_EQ(2.05e+12,  APFloat(APFloat::IEEEdouble, "002.05000e+12").convertToDouble());
736   EXPECT_EQ(2.05e-12,  APFloat(APFloat::IEEEdouble, "002.05000e-12").convertToDouble());
737
738   // These are "carefully selected" to overflow the fast log-base
739   // calculations in APFloat.cpp
740   EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "99e99999").isInfinity());
741   EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "-99e99999").isInfinity());
742   EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "1e-99999").isPosZero());
743   EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "-1e-99999").isNegZero());
744 }
745
746 TEST(APFloatTest, fromHexadecimalString) {
747   EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble,  "0x1p0").convertToDouble());
748   EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble, "+0x1p0").convertToDouble());
749   EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble, "-0x1p0").convertToDouble());
750
751   EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble,  "0x1p+0").convertToDouble());
752   EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble, "+0x1p+0").convertToDouble());
753   EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble, "-0x1p+0").convertToDouble());
754
755   EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble,  "0x1p-0").convertToDouble());
756   EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble, "+0x1p-0").convertToDouble());
757   EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble, "-0x1p-0").convertToDouble());
758
759
760   EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble,  "0x1p1").convertToDouble());
761   EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble, "+0x1p1").convertToDouble());
762   EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble, "-0x1p1").convertToDouble());
763
764   EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble,  "0x1p+1").convertToDouble());
765   EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble, "+0x1p+1").convertToDouble());
766   EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble, "-0x1p+1").convertToDouble());
767
768   EXPECT_EQ( 0.5, APFloat(APFloat::IEEEdouble,  "0x1p-1").convertToDouble());
769   EXPECT_EQ(+0.5, APFloat(APFloat::IEEEdouble, "+0x1p-1").convertToDouble());
770   EXPECT_EQ(-0.5, APFloat(APFloat::IEEEdouble, "-0x1p-1").convertToDouble());
771
772
773   EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble,  "0x1.8p1").convertToDouble());
774   EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble, "+0x1.8p1").convertToDouble());
775   EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble, "-0x1.8p1").convertToDouble());
776
777   EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble,  "0x1.8p+1").convertToDouble());
778   EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble, "+0x1.8p+1").convertToDouble());
779   EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble, "-0x1.8p+1").convertToDouble());
780
781   EXPECT_EQ( 0.75, APFloat(APFloat::IEEEdouble,  "0x1.8p-1").convertToDouble());
782   EXPECT_EQ(+0.75, APFloat(APFloat::IEEEdouble, "+0x1.8p-1").convertToDouble());
783   EXPECT_EQ(-0.75, APFloat(APFloat::IEEEdouble, "-0x1.8p-1").convertToDouble());
784
785
786   EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble,  "0x1000.000p1").convertToDouble());
787   EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble, "+0x1000.000p1").convertToDouble());
788   EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble, "-0x1000.000p1").convertToDouble());
789
790   EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble,  "0x1000.000p+1").convertToDouble());
791   EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble, "+0x1000.000p+1").convertToDouble());
792   EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble, "-0x1000.000p+1").convertToDouble());
793
794   EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble,  "0x1000.000p-1").convertToDouble());
795   EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble, "+0x1000.000p-1").convertToDouble());
796   EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble, "-0x1000.000p-1").convertToDouble());
797
798
799   EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble,  "0x1000p1").convertToDouble());
800   EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble, "+0x1000p1").convertToDouble());
801   EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble, "-0x1000p1").convertToDouble());
802
803   EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble,  "0x1000p+1").convertToDouble());
804   EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble, "+0x1000p+1").convertToDouble());
805   EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble, "-0x1000p+1").convertToDouble());
806
807   EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble,  "0x1000p-1").convertToDouble());
808   EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble, "+0x1000p-1").convertToDouble());
809   EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble, "-0x1000p-1").convertToDouble());
810
811
812   EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble,  "0x10p10").convertToDouble());
813   EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble, "+0x10p10").convertToDouble());
814   EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble, "-0x10p10").convertToDouble());
815
816   EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble,  "0x10p+10").convertToDouble());
817   EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble, "+0x10p+10").convertToDouble());
818   EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble, "-0x10p+10").convertToDouble());
819
820   EXPECT_EQ( 0.015625, APFloat(APFloat::IEEEdouble,  "0x10p-10").convertToDouble());
821   EXPECT_EQ(+0.015625, APFloat(APFloat::IEEEdouble, "+0x10p-10").convertToDouble());
822   EXPECT_EQ(-0.015625, APFloat(APFloat::IEEEdouble, "-0x10p-10").convertToDouble());
823
824   EXPECT_EQ(1.0625, APFloat(APFloat::IEEEdouble, "0x1.1p0").convertToDouble());
825   EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble, "0x1p0").convertToDouble());
826
827   EXPECT_EQ(2.71828, convertToDoubleFromString("2.71828"));
828 }
829
830 TEST(APFloatTest, toString) {
831   ASSERT_EQ("10", convertToString(10.0, 6, 3));
832   ASSERT_EQ("1.0E+1", convertToString(10.0, 6, 0));
833   ASSERT_EQ("10100", convertToString(1.01E+4, 5, 2));
834   ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 4, 2));
835   ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 5, 1));
836   ASSERT_EQ("0.0101", convertToString(1.01E-2, 5, 2));
837   ASSERT_EQ("0.0101", convertToString(1.01E-2, 4, 2));
838   ASSERT_EQ("1.01E-2", convertToString(1.01E-2, 5, 1));
839   ASSERT_EQ("0.7853981633974483", convertToString(0.78539816339744830961, 0, 3));
840   ASSERT_EQ("4.940656458412465E-324", convertToString(4.9406564584124654e-324, 0, 3));
841   ASSERT_EQ("873.1834", convertToString(873.1834, 0, 1));
842   ASSERT_EQ("8.731834E+2", convertToString(873.1834, 0, 0));
843 }
844
845 TEST(APFloatTest, toInteger) {
846   bool isExact = false;
847   APSInt result(5, /*isUnsigned=*/true);
848
849   EXPECT_EQ(APFloat::opOK,
850             APFloat(APFloat::IEEEdouble, "10")
851             .convertToInteger(result, APFloat::rmTowardZero, &isExact));
852   EXPECT_TRUE(isExact);
853   EXPECT_EQ(APSInt(APInt(5, 10), true), result);
854
855   EXPECT_EQ(APFloat::opInvalidOp,
856             APFloat(APFloat::IEEEdouble, "-10")
857             .convertToInteger(result, APFloat::rmTowardZero, &isExact));
858   EXPECT_FALSE(isExact);
859   EXPECT_EQ(APSInt::getMinValue(5, true), result);
860
861   EXPECT_EQ(APFloat::opInvalidOp,
862             APFloat(APFloat::IEEEdouble, "32")
863             .convertToInteger(result, APFloat::rmTowardZero, &isExact));
864   EXPECT_FALSE(isExact);
865   EXPECT_EQ(APSInt::getMaxValue(5, true), result);
866
867   EXPECT_EQ(APFloat::opInexact,
868             APFloat(APFloat::IEEEdouble, "7.9")
869             .convertToInteger(result, APFloat::rmTowardZero, &isExact));
870   EXPECT_FALSE(isExact);
871   EXPECT_EQ(APSInt(APInt(5, 7), true), result);
872
873   result.setIsUnsigned(false);
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), false), result);
879
880   EXPECT_EQ(APFloat::opInvalidOp,
881             APFloat(APFloat::IEEEdouble, "-17")
882             .convertToInteger(result, APFloat::rmTowardZero, &isExact));
883   EXPECT_FALSE(isExact);
884   EXPECT_EQ(APSInt::getMinValue(5, false), result);
885
886   EXPECT_EQ(APFloat::opInvalidOp,
887             APFloat(APFloat::IEEEdouble, "16")
888             .convertToInteger(result, APFloat::rmTowardZero, &isExact));
889   EXPECT_FALSE(isExact);
890   EXPECT_EQ(APSInt::getMaxValue(5, false), result);
891 }
892
893 static APInt nanbits(const fltSemantics &Sem,
894                      bool SNaN, bool Negative, uint64_t fill) {
895   APInt apfill(64, fill);
896   if (SNaN)
897     return APFloat::getSNaN(Sem, Negative, &apfill).bitcastToAPInt();
898   else
899     return APFloat::getQNaN(Sem, Negative, &apfill).bitcastToAPInt();
900 }
901
902 TEST(APFloatTest, makeNaN) {
903   ASSERT_EQ(0x7fc00000, nanbits(APFloat::IEEEsingle, false, false, 0));
904   ASSERT_EQ(0xffc00000, nanbits(APFloat::IEEEsingle, false, true, 0));
905   ASSERT_EQ(0x7fc0ae72, nanbits(APFloat::IEEEsingle, false, false, 0xae72));
906   ASSERT_EQ(0x7fffae72, nanbits(APFloat::IEEEsingle, false, false, 0xffffae72));
907   ASSERT_EQ(0x7fa00000, nanbits(APFloat::IEEEsingle, true, false, 0));
908   ASSERT_EQ(0xffa00000, nanbits(APFloat::IEEEsingle, true, true, 0));
909   ASSERT_EQ(0x7f80ae72, nanbits(APFloat::IEEEsingle, true, false, 0xae72));
910   ASSERT_EQ(0x7fbfae72, nanbits(APFloat::IEEEsingle, true, false, 0xffffae72));
911
912   ASSERT_EQ(0x7ff8000000000000ULL, nanbits(APFloat::IEEEdouble, false, false, 0));
913   ASSERT_EQ(0xfff8000000000000ULL, nanbits(APFloat::IEEEdouble, false, true, 0));
914   ASSERT_EQ(0x7ff800000000ae72ULL, nanbits(APFloat::IEEEdouble, false, false, 0xae72));
915   ASSERT_EQ(0x7fffffffffffae72ULL, nanbits(APFloat::IEEEdouble, false, false, 0xffffffffffffae72ULL));
916   ASSERT_EQ(0x7ff4000000000000ULL, nanbits(APFloat::IEEEdouble, true, false, 0));
917   ASSERT_EQ(0xfff4000000000000ULL, nanbits(APFloat::IEEEdouble, true, true, 0));
918   ASSERT_EQ(0x7ff000000000ae72ULL, nanbits(APFloat::IEEEdouble, true, false, 0xae72));
919   ASSERT_EQ(0x7ff7ffffffffae72ULL, nanbits(APFloat::IEEEdouble, true, false, 0xffffffffffffae72ULL));
920 }
921
922 #ifdef GTEST_HAS_DEATH_TEST
923 #ifndef NDEBUG
924 TEST(APFloatTest, SemanticsDeath) {
925   EXPECT_DEATH(APFloat(APFloat::IEEEsingle, 0.0f).convertToDouble(), "Float semantics are not IEEEdouble");
926   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, 0.0 ).convertToFloat(),  "Float semantics are not IEEEsingle");
927 }
928
929 TEST(APFloatTest, StringDecimalDeath) {
930   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  ""), "Invalid string length");
931   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+"), "String has no digits");
932   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-"), "String has no digits");
933
934   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("\0", 1)), "Invalid character in significand");
935   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1\0", 2)), "Invalid character in significand");
936   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1\02", 3)), "Invalid character in significand");
937   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1\02e1", 5)), "Invalid character in significand");
938   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1e\0", 3)), "Invalid character in exponent");
939   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1e1\0", 4)), "Invalid character in exponent");
940   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1e1\02", 5)), "Invalid character in exponent");
941
942   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0f"), "Invalid character in significand");
943
944   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".."), "String contains multiple dots");
945   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "..0"), "String contains multiple dots");
946   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0.0"), "String contains multiple dots");
947 }
948
949 TEST(APFloatTest, StringDecimalSignificandDeath) {
950   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "."), "Significand has no digits");
951   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+."), "Significand has no digits");
952   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-."), "Significand has no digits");
953
954
955   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "e"), "Significand has no digits");
956   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+e"), "Significand has no digits");
957   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-e"), "Significand has no digits");
958
959   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "e1"), "Significand has no digits");
960   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+e1"), "Significand has no digits");
961   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-e1"), "Significand has no digits");
962
963   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  ".e1"), "Significand has no digits");
964   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+.e1"), "Significand has no digits");
965   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-.e1"), "Significand has no digits");
966
967
968   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  ".e"), "Significand has no digits");
969   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+.e"), "Significand has no digits");
970   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-.e"), "Significand has no digits");
971 }
972
973 TEST(APFloatTest, StringDecimalExponentDeath) {
974   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,   "1e"), "Exponent has no digits");
975   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "+1e"), "Exponent has no digits");
976   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "-1e"), "Exponent has no digits");
977
978   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,   "1.e"), "Exponent has no digits");
979   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "+1.e"), "Exponent has no digits");
980   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "-1.e"), "Exponent has no digits");
981
982   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,   ".1e"), "Exponent has no digits");
983   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "+.1e"), "Exponent has no digits");
984   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "-.1e"), "Exponent has no digits");
985
986   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,   "1.1e"), "Exponent has no digits");
987   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "+1.1e"), "Exponent has no digits");
988   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "-1.1e"), "Exponent has no digits");
989
990
991   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1e+"), "Exponent has no digits");
992   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1e-"), "Exponent has no digits");
993
994   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  ".1e"), "Exponent has no digits");
995   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".1e+"), "Exponent has no digits");
996   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".1e-"), "Exponent has no digits");
997
998   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "1.0e"), "Exponent has no digits");
999   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0e+"), "Exponent has no digits");
1000   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0e-"), "Exponent has no digits");
1001 }
1002
1003 TEST(APFloatTest, StringHexadecimalDeath) {
1004   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x"), "Invalid string");
1005   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x"), "Invalid string");
1006   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x"), "Invalid string");
1007
1008   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x0"), "Hex strings require an exponent");
1009   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x0"), "Hex strings require an exponent");
1010   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x0"), "Hex strings require an exponent");
1011
1012   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x0."), "Hex strings require an exponent");
1013   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x0."), "Hex strings require an exponent");
1014   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x0."), "Hex strings require an exponent");
1015
1016   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x.0"), "Hex strings require an exponent");
1017   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.0"), "Hex strings require an exponent");
1018   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.0"), "Hex strings require an exponent");
1019
1020   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x0.0"), "Hex strings require an exponent");
1021   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x0.0"), "Hex strings require an exponent");
1022   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x0.0"), "Hex strings require an exponent");
1023
1024   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x\0", 3)), "Invalid character in significand");
1025   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1\0", 4)), "Invalid character in significand");
1026   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1\02", 5)), "Invalid character in significand");
1027   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1\02p1", 7)), "Invalid character in significand");
1028   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1p\0", 5)), "Invalid character in exponent");
1029   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1p1\0", 6)), "Invalid character in exponent");
1030   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1p1\02", 7)), "Invalid character in exponent");
1031
1032   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1p0f"), "Invalid character in exponent");
1033
1034   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x..p1"), "String contains multiple dots");
1035   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x..0p1"), "String contains multiple dots");
1036   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.0.0p1"), "String contains multiple dots");
1037 }
1038
1039 TEST(APFloatTest, StringHexadecimalSignificandDeath) {
1040   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x."), "Significand has no digits");
1041   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x."), "Significand has no digits");
1042   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x."), "Significand has no digits");
1043
1044   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0xp"), "Significand has no digits");
1045   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0xp"), "Significand has no digits");
1046   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0xp"), "Significand has no digits");
1047
1048   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0xp+"), "Significand has no digits");
1049   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0xp+"), "Significand has no digits");
1050   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0xp+"), "Significand has no digits");
1051
1052   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0xp-"), "Significand has no digits");
1053   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0xp-"), "Significand has no digits");
1054   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0xp-"), "Significand has no digits");
1055
1056
1057   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x.p"), "Significand has no digits");
1058   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.p"), "Significand has no digits");
1059   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.p"), "Significand has no digits");
1060
1061   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x.p+"), "Significand has no digits");
1062   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.p+"), "Significand has no digits");
1063   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.p+"), "Significand has no digits");
1064
1065   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x.p-"), "Significand has no digits");
1066   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.p-"), "Significand has no digits");
1067   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.p-"), "Significand has no digits");
1068 }
1069
1070 TEST(APFloatTest, StringHexadecimalExponentDeath) {
1071   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x1p"), "Exponent has no digits");
1072   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1p"), "Exponent has no digits");
1073   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1p"), "Exponent has no digits");
1074
1075   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x1p+"), "Exponent has no digits");
1076   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1p+"), "Exponent has no digits");
1077   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1p+"), "Exponent has no digits");
1078
1079   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x1p-"), "Exponent has no digits");
1080   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1p-"), "Exponent has no digits");
1081   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1p-"), "Exponent has no digits");
1082
1083
1084   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x1.p"), "Exponent has no digits");
1085   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.p"), "Exponent has no digits");
1086   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.p"), "Exponent has no digits");
1087
1088   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x1.p+"), "Exponent has no digits");
1089   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.p+"), "Exponent has no digits");
1090   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.p+"), "Exponent has no digits");
1091
1092   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x1.p-"), "Exponent has no digits");
1093   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.p-"), "Exponent has no digits");
1094   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.p-"), "Exponent has no digits");
1095
1096
1097   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x.1p"), "Exponent has no digits");
1098   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.1p"), "Exponent has no digits");
1099   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.1p"), "Exponent has no digits");
1100
1101   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x.1p+"), "Exponent has no digits");
1102   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.1p+"), "Exponent has no digits");
1103   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.1p+"), "Exponent has no digits");
1104
1105   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x.1p-"), "Exponent has no digits");
1106   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.1p-"), "Exponent has no digits");
1107   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.1p-"), "Exponent has no digits");
1108
1109
1110   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x1.1p"), "Exponent has no digits");
1111   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.1p"), "Exponent has no digits");
1112   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.1p"), "Exponent has no digits");
1113
1114   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x1.1p+"), "Exponent has no digits");
1115   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.1p+"), "Exponent has no digits");
1116   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.1p+"), "Exponent has no digits");
1117
1118   EXPECT_DEATH(APFloat(APFloat::IEEEdouble,  "0x1.1p-"), "Exponent has no digits");
1119   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.1p-"), "Exponent has no digits");
1120   EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.1p-"), "Exponent has no digits");
1121 }
1122 #endif
1123 #endif
1124
1125 TEST(APFloatTest, exactInverse) {
1126   APFloat inv(0.0f);
1127
1128   // Trivial operation.
1129   EXPECT_TRUE(APFloat(2.0).getExactInverse(&inv));
1130   EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5)));
1131   EXPECT_TRUE(APFloat(2.0f).getExactInverse(&inv));
1132   EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(0.5f)));
1133   EXPECT_TRUE(APFloat(APFloat::IEEEquad, "2.0").getExactInverse(&inv));
1134   EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::IEEEquad, "0.5")));
1135   EXPECT_TRUE(APFloat(APFloat::PPCDoubleDouble, "2.0").getExactInverse(&inv));
1136   EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::PPCDoubleDouble, "0.5")));
1137   EXPECT_TRUE(APFloat(APFloat::x87DoubleExtended, "2.0").getExactInverse(&inv));
1138   EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(APFloat::x87DoubleExtended, "0.5")));
1139
1140   // FLT_MIN
1141   EXPECT_TRUE(APFloat(1.17549435e-38f).getExactInverse(&inv));
1142   EXPECT_TRUE(inv.bitwiseIsEqual(APFloat(8.5070592e+37f)));
1143
1144   // Large float, inverse is a denormal.
1145   EXPECT_FALSE(APFloat(1.7014118e38f).getExactInverse(0));
1146   // Zero
1147   EXPECT_FALSE(APFloat(0.0).getExactInverse(0));
1148   // Denormalized float
1149   EXPECT_FALSE(APFloat(1.40129846e-45f).getExactInverse(0));
1150 }
1151
1152 TEST(APFloatTest, roundToIntegral) {
1153   APFloat T(-0.5), S(3.14), R(APFloat::getLargest(APFloat::IEEEdouble)), P(0.0);
1154
1155   P = T;
1156   P.roundToIntegral(APFloat::rmTowardZero);
1157   EXPECT_EQ(-0.0, P.convertToDouble());
1158   P = T;
1159   P.roundToIntegral(APFloat::rmTowardNegative);
1160   EXPECT_EQ(-1.0, P.convertToDouble());
1161   P = T;
1162   P.roundToIntegral(APFloat::rmTowardPositive);
1163   EXPECT_EQ(-0.0, P.convertToDouble());
1164   P = T;
1165   P.roundToIntegral(APFloat::rmNearestTiesToEven);
1166   EXPECT_EQ(-0.0, P.convertToDouble());
1167
1168   P = S;
1169   P.roundToIntegral(APFloat::rmTowardZero);
1170   EXPECT_EQ(3.0, P.convertToDouble());
1171   P = S;
1172   P.roundToIntegral(APFloat::rmTowardNegative);
1173   EXPECT_EQ(3.0, P.convertToDouble());
1174   P = S;
1175   P.roundToIntegral(APFloat::rmTowardPositive);
1176   EXPECT_EQ(4.0, P.convertToDouble());
1177   P = S;
1178   P.roundToIntegral(APFloat::rmNearestTiesToEven);
1179   EXPECT_EQ(3.0, P.convertToDouble());
1180
1181   P = R;
1182   P.roundToIntegral(APFloat::rmTowardZero);
1183   EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1184   P = R;
1185   P.roundToIntegral(APFloat::rmTowardNegative);
1186   EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1187   P = R;
1188   P.roundToIntegral(APFloat::rmTowardPositive);
1189   EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1190   P = R;
1191   P.roundToIntegral(APFloat::rmNearestTiesToEven);
1192   EXPECT_EQ(R.convertToDouble(), P.convertToDouble());
1193
1194   P = APFloat::getZero(APFloat::IEEEdouble);
1195   P.roundToIntegral(APFloat::rmTowardZero);
1196   EXPECT_EQ(0.0, P.convertToDouble());
1197   P = APFloat::getZero(APFloat::IEEEdouble, true);
1198   P.roundToIntegral(APFloat::rmTowardZero);
1199   EXPECT_EQ(-0.0, P.convertToDouble());
1200   P = APFloat::getNaN(APFloat::IEEEdouble);
1201   P.roundToIntegral(APFloat::rmTowardZero);
1202   EXPECT_TRUE(IsNAN(P.convertToDouble()));
1203   P = APFloat::getInf(APFloat::IEEEdouble);
1204   P.roundToIntegral(APFloat::rmTowardZero);
1205   EXPECT_TRUE(IsInf(P.convertToDouble()) && P.convertToDouble() > 0.0);
1206   P = APFloat::getInf(APFloat::IEEEdouble, true);
1207   P.roundToIntegral(APFloat::rmTowardZero);
1208   EXPECT_TRUE(IsInf(P.convertToDouble()) && P.convertToDouble() < 0.0);
1209
1210 }
1211
1212 TEST(APFloatTest, getLargest) {
1213   EXPECT_EQ(3.402823466e+38f, APFloat::getLargest(APFloat::IEEEsingle).convertToFloat());
1214   EXPECT_EQ(1.7976931348623158e+308, APFloat::getLargest(APFloat::IEEEdouble).convertToDouble());
1215 }
1216
1217 TEST(APFloatTest, getSmallest) {
1218   APFloat test = APFloat::getSmallest(APFloat::IEEEsingle, false);
1219   APFloat expected = APFloat(APFloat::IEEEsingle, "0x0.000002p-126");
1220   EXPECT_FALSE(test.isNegative());
1221   EXPECT_TRUE(test.isFiniteNonZero());
1222   EXPECT_TRUE(test.isDenormal());
1223   EXPECT_TRUE(test.bitwiseIsEqual(expected));
1224
1225   test = APFloat::getSmallest(APFloat::IEEEsingle, true);
1226   expected = APFloat(APFloat::IEEEsingle, "-0x0.000002p-126");
1227   EXPECT_TRUE(test.isNegative());
1228   EXPECT_TRUE(test.isFiniteNonZero());
1229   EXPECT_TRUE(test.isDenormal());
1230   EXPECT_TRUE(test.bitwiseIsEqual(expected));
1231
1232   test = APFloat::getSmallest(APFloat::IEEEquad, false);
1233   expected = APFloat(APFloat::IEEEquad, "0x0.0000000000000000000000000001p-16382");
1234   EXPECT_FALSE(test.isNegative());
1235   EXPECT_TRUE(test.isFiniteNonZero());
1236   EXPECT_TRUE(test.isDenormal());
1237   EXPECT_TRUE(test.bitwiseIsEqual(expected));
1238
1239   test = APFloat::getSmallest(APFloat::IEEEquad, true);
1240   expected = APFloat(APFloat::IEEEquad, "-0x0.0000000000000000000000000001p-16382");
1241   EXPECT_TRUE(test.isNegative());
1242   EXPECT_TRUE(test.isFiniteNonZero());
1243   EXPECT_TRUE(test.isDenormal());
1244   EXPECT_TRUE(test.bitwiseIsEqual(expected));
1245 }
1246
1247 TEST(APFloatTest, getSmallestNormalized) {
1248   APFloat test = APFloat::getSmallestNormalized(APFloat::IEEEsingle, false);
1249   APFloat expected = APFloat(APFloat::IEEEsingle, "0x1p-126");
1250   EXPECT_FALSE(test.isNegative());
1251   EXPECT_TRUE(test.isFiniteNonZero());
1252   EXPECT_FALSE(test.isDenormal());
1253   EXPECT_TRUE(test.bitwiseIsEqual(expected));
1254
1255   test = APFloat::getSmallestNormalized(APFloat::IEEEsingle, true);
1256   expected = APFloat(APFloat::IEEEsingle, "-0x1p-126");
1257   EXPECT_TRUE(test.isNegative());
1258   EXPECT_TRUE(test.isFiniteNonZero());
1259   EXPECT_FALSE(test.isDenormal());
1260   EXPECT_TRUE(test.bitwiseIsEqual(expected));
1261
1262   test = APFloat::getSmallestNormalized(APFloat::IEEEquad, false);
1263   expected = APFloat(APFloat::IEEEquad, "0x1p-16382");
1264   EXPECT_FALSE(test.isNegative());
1265   EXPECT_TRUE(test.isFiniteNonZero());
1266   EXPECT_FALSE(test.isDenormal());
1267   EXPECT_TRUE(test.bitwiseIsEqual(expected));
1268
1269   test = APFloat::getSmallestNormalized(APFloat::IEEEquad, true);
1270   expected = APFloat(APFloat::IEEEquad, "-0x1p-16382");
1271   EXPECT_TRUE(test.isNegative());
1272   EXPECT_TRUE(test.isFiniteNonZero());
1273   EXPECT_FALSE(test.isDenormal());
1274   EXPECT_TRUE(test.bitwiseIsEqual(expected));
1275 }
1276
1277 TEST(APFloatTest, getZero) {
1278   struct {
1279     const fltSemantics *semantics;
1280     const bool sign;
1281     const unsigned long long bitPattern[2];
1282     const unsigned bitPatternLength;
1283   } const GetZeroTest[] = {
1284     { &APFloat::IEEEhalf, false, {0, 0}, 1},
1285     { &APFloat::IEEEhalf, true, {0x8000ULL, 0}, 1},
1286     { &APFloat::IEEEsingle, false, {0, 0}, 1},
1287     { &APFloat::IEEEsingle, true, {0x80000000ULL, 0}, 1},
1288     { &APFloat::IEEEdouble, false, {0, 0}, 1},
1289     { &APFloat::IEEEdouble, true, {0x8000000000000000ULL, 0}, 1},
1290     { &APFloat::IEEEquad, false, {0, 0}, 2},
1291     { &APFloat::IEEEquad, true, {0, 0x8000000000000000ULL}, 2},
1292     { &APFloat::PPCDoubleDouble, false, {0, 0}, 2},
1293     { &APFloat::PPCDoubleDouble, true, {0x8000000000000000ULL, 0}, 2},
1294     { &APFloat::x87DoubleExtended, false, {0, 0}, 2},
1295     { &APFloat::x87DoubleExtended, true, {0, 0x8000ULL}, 2},
1296   };
1297   const unsigned NumGetZeroTests = 12;
1298   for (unsigned i = 0; i < NumGetZeroTests; ++i) {
1299     APFloat test = APFloat::getZero(*GetZeroTest[i].semantics,
1300                                     GetZeroTest[i].sign);
1301     const char *pattern = GetZeroTest[i].sign? "-0x0p+0" : "0x0p+0";
1302     APFloat expected = APFloat(*GetZeroTest[i].semantics,
1303                                pattern);
1304     EXPECT_TRUE(test.isZero());
1305     EXPECT_TRUE(GetZeroTest[i].sign? test.isNegative() : !test.isNegative());
1306     EXPECT_TRUE(test.bitwiseIsEqual(expected));
1307     for (unsigned j = 0, je = GetZeroTest[i].bitPatternLength; j < je; ++j) {
1308       EXPECT_EQ(GetZeroTest[i].bitPattern[j],
1309                 test.bitcastToAPInt().getRawData()[j]);
1310     }
1311   }
1312 }
1313
1314 TEST(APFloatTest, convert) {
1315   bool losesInfo;
1316   APFloat test(APFloat::IEEEdouble, "1.0");
1317   test.convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven, &losesInfo);
1318   EXPECT_EQ(1.0f, test.convertToFloat());
1319   EXPECT_FALSE(losesInfo);
1320
1321   test = APFloat(APFloat::x87DoubleExtended, "0x1p-53");
1322   test.add(APFloat(APFloat::x87DoubleExtended, "1.0"), APFloat::rmNearestTiesToEven);
1323   test.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, &losesInfo);
1324   EXPECT_EQ(1.0, test.convertToDouble());
1325   EXPECT_TRUE(losesInfo);
1326
1327   test = APFloat(APFloat::IEEEquad, "0x1p-53");
1328   test.add(APFloat(APFloat::IEEEquad, "1.0"), APFloat::rmNearestTiesToEven);
1329   test.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, &losesInfo);
1330   EXPECT_EQ(1.0, test.convertToDouble());
1331   EXPECT_TRUE(losesInfo);
1332
1333   test = APFloat(APFloat::x87DoubleExtended, "0xf.fffffffp+28");
1334   test.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, &losesInfo);
1335   EXPECT_EQ(4294967295.0, test.convertToDouble());
1336   EXPECT_FALSE(losesInfo);
1337
1338   test = APFloat::getSNaN(APFloat::IEEEsingle);
1339   APFloat X87SNaN = APFloat::getSNaN(APFloat::x87DoubleExtended);
1340   test.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven,
1341                &losesInfo);
1342   EXPECT_TRUE(test.bitwiseIsEqual(X87SNaN));
1343   EXPECT_FALSE(losesInfo);
1344
1345   test = APFloat::getQNaN(APFloat::IEEEsingle);
1346   APFloat X87QNaN = APFloat::getQNaN(APFloat::x87DoubleExtended);
1347   test.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven,
1348                &losesInfo);
1349   EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN));
1350   EXPECT_FALSE(losesInfo);
1351
1352   test = APFloat::getSNaN(APFloat::x87DoubleExtended);
1353   test.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven,
1354                &losesInfo);
1355   EXPECT_TRUE(test.bitwiseIsEqual(X87SNaN));
1356   EXPECT_FALSE(losesInfo);
1357
1358   test = APFloat::getQNaN(APFloat::x87DoubleExtended);
1359   test.convert(APFloat::x87DoubleExtended, APFloat::rmNearestTiesToEven,
1360                &losesInfo);
1361   EXPECT_TRUE(test.bitwiseIsEqual(X87QNaN));
1362   EXPECT_FALSE(losesInfo);
1363 }
1364
1365 TEST(APFloatTest, PPCDoubleDouble) {
1366   APFloat test(APFloat::PPCDoubleDouble, "1.0");
1367   EXPECT_EQ(0x3ff0000000000000ull, test.bitcastToAPInt().getRawData()[0]);
1368   EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1369
1370   test.divide(APFloat(APFloat::PPCDoubleDouble, "3.0"), APFloat::rmNearestTiesToEven);
1371   EXPECT_EQ(0x3fd5555555555555ull, test.bitcastToAPInt().getRawData()[0]);
1372   EXPECT_EQ(0x3c75555555555556ull, test.bitcastToAPInt().getRawData()[1]);
1373
1374   // LDBL_MAX
1375   test = APFloat(APFloat::PPCDoubleDouble, "1.79769313486231580793728971405301e+308");
1376   EXPECT_EQ(0x7fefffffffffffffull, test.bitcastToAPInt().getRawData()[0]);
1377   EXPECT_EQ(0x7c8ffffffffffffeull, test.bitcastToAPInt().getRawData()[1]);
1378
1379   // LDBL_MIN
1380   test = APFloat(APFloat::PPCDoubleDouble, "2.00416836000897277799610805135016e-292");
1381   EXPECT_EQ(0x0360000000000000ull, test.bitcastToAPInt().getRawData()[0]);
1382   EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1383
1384   test = APFloat(APFloat::PPCDoubleDouble, "1.0");
1385   test.add(APFloat(APFloat::PPCDoubleDouble, "0x1p-105"), APFloat::rmNearestTiesToEven);
1386   EXPECT_EQ(0x3ff0000000000000ull, test.bitcastToAPInt().getRawData()[0]);
1387   EXPECT_EQ(0x3960000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1388
1389   test = APFloat(APFloat::PPCDoubleDouble, "1.0");
1390   test.add(APFloat(APFloat::PPCDoubleDouble, "0x1p-106"), APFloat::rmNearestTiesToEven);
1391   EXPECT_EQ(0x3ff0000000000000ull, test.bitcastToAPInt().getRawData()[0]);
1392 #if 0 // XFAIL
1393   // This is what we would expect with a true double-double implementation
1394   EXPECT_EQ(0x3950000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1395 #else
1396   // This is what we get with our 106-bit mantissa approximation
1397   EXPECT_EQ(0x0000000000000000ull, test.bitcastToAPInt().getRawData()[1]);
1398 #endif
1399 }
1400
1401 TEST(APFloatTest, isNegative) {
1402   APFloat t(APFloat::IEEEsingle, "0x1p+0");
1403   EXPECT_FALSE(t.isNegative());
1404   t = APFloat(APFloat::IEEEsingle, "-0x1p+0");
1405   EXPECT_TRUE(t.isNegative());
1406
1407   EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isNegative());
1408   EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle, true).isNegative());
1409
1410   EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isNegative());
1411   EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle, true).isNegative());
1412
1413   EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isNegative());
1414   EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle, true).isNegative());
1415
1416   EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isNegative());
1417   EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, true).isNegative());
1418 }
1419
1420 TEST(APFloatTest, isNormal) {
1421   APFloat t(APFloat::IEEEsingle, "0x1p+0");
1422   EXPECT_TRUE(t.isNormal());
1423
1424   EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isNormal());
1425   EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isNormal());
1426   EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isNormal());
1427   EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isNormal());
1428   EXPECT_FALSE(APFloat(APFloat::IEEEsingle, "0x1p-149").isNormal());
1429 }
1430
1431 TEST(APFloatTest, isFinite) {
1432   APFloat t(APFloat::IEEEsingle, "0x1p+0");
1433   EXPECT_TRUE(t.isFinite());
1434   EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isFinite());
1435   EXPECT_TRUE(APFloat::getZero(APFloat::IEEEsingle, false).isFinite());
1436   EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isFinite());
1437   EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isFinite());
1438   EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "0x1p-149").isFinite());
1439 }
1440
1441 TEST(APFloatTest, isInfinity) {
1442   APFloat t(APFloat::IEEEsingle, "0x1p+0");
1443   EXPECT_FALSE(t.isInfinity());
1444   EXPECT_TRUE(APFloat::getInf(APFloat::IEEEsingle, false).isInfinity());
1445   EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isInfinity());
1446   EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isInfinity());
1447   EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isInfinity());
1448   EXPECT_FALSE(APFloat(APFloat::IEEEsingle, "0x1p-149").isInfinity());
1449 }
1450
1451 TEST(APFloatTest, isNaN) {
1452   APFloat t(APFloat::IEEEsingle, "0x1p+0");
1453   EXPECT_FALSE(t.isNaN());
1454   EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isNaN());
1455   EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isNaN());
1456   EXPECT_TRUE(APFloat::getNaN(APFloat::IEEEsingle, false).isNaN());
1457   EXPECT_TRUE(APFloat::getSNaN(APFloat::IEEEsingle, false).isNaN());
1458   EXPECT_FALSE(APFloat(APFloat::IEEEsingle, "0x1p-149").isNaN());
1459 }
1460
1461 TEST(APFloatTest, isFiniteNonZero) {
1462   // Test positive/negative normal value.
1463   EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "0x1p+0").isFiniteNonZero());
1464   EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "-0x1p+0").isFiniteNonZero());
1465
1466   // Test positive/negative denormal value.
1467   EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "0x1p-149").isFiniteNonZero());
1468   EXPECT_TRUE(APFloat(APFloat::IEEEsingle, "-0x1p-149").isFiniteNonZero());
1469
1470   // Test +/- Infinity.
1471   EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, false).isFiniteNonZero());
1472   EXPECT_FALSE(APFloat::getInf(APFloat::IEEEsingle, true).isFiniteNonZero());
1473
1474   // Test +/- Zero.
1475   EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, false).isFiniteNonZero());
1476   EXPECT_FALSE(APFloat::getZero(APFloat::IEEEsingle, true).isFiniteNonZero());
1477
1478   // Test +/- qNaN. +/- dont mean anything with qNaN but paranoia can't hurt in
1479   // this instance.
1480   EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, false).isFiniteNonZero());
1481   EXPECT_FALSE(APFloat::getNaN(APFloat::IEEEsingle, true).isFiniteNonZero());
1482
1483   // Test +/- sNaN. +/- dont mean anything with sNaN but paranoia can't hurt in
1484   // this instance.
1485   EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, false).isFiniteNonZero());
1486   EXPECT_FALSE(APFloat::getSNaN(APFloat::IEEEsingle, true).isFiniteNonZero());
1487 }
1488
1489 TEST(APFloatTest, add) {
1490   // Test Special Cases against each other and normal values.
1491
1492   // TODOS/NOTES:
1493   // 1. Since we perform only default exception handling all operations with
1494   // signaling NaNs should have a result that is a quiet NaN. Currently they
1495   // return sNaN.
1496   // 2. It seems that add(-x, NaN) = -NaN but add(NaN, -x) = NaN. This is an
1497   // inconsistency that should be looked into. IEEE-754R specifies that the
1498   // interpretation of the sign of NaN is unspecified. We should always have NaN
1499   // be positive since that is one less thing for the compiler to deal with.
1500
1501   APFloat PInf = APFloat::getInf(APFloat::IEEEsingle, false);
1502   APFloat MInf = APFloat::getInf(APFloat::IEEEsingle, true);
1503   APFloat PZero = APFloat::getZero(APFloat::IEEEsingle, false);
1504   APFloat MZero = APFloat::getZero(APFloat::IEEEsingle, true);
1505   APFloat QNaN = APFloat::getNaN(APFloat::IEEEsingle, false);
1506   APFloat SNaN = APFloat::getSNaN(APFloat::IEEEsingle, false);
1507   APFloat PNormalValue = APFloat(APFloat::IEEEsingle, "0x1p+0");
1508   APFloat MNormalValue = APFloat(APFloat::IEEEsingle, "-0x1p+0");
1509   APFloat PLargestValue = APFloat::getLargest(APFloat::IEEEsingle, false);
1510   APFloat MLargestValue = APFloat::getLargest(APFloat::IEEEsingle, true);
1511   APFloat PSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, false);
1512   APFloat MSmallestValue = APFloat::getSmallest(APFloat::IEEEsingle, true);
1513   APFloat PSmallestNormalized =
1514     APFloat::getSmallestNormalized(APFloat::IEEEsingle, false);
1515   APFloat MSmallestNormalized =
1516     APFloat::getSmallestNormalized(APFloat::IEEEsingle, true);
1517
1518   const int OverflowStatus = APFloat::opOverflow | APFloat::opInexact;
1519
1520   const unsigned NumTests = 169;
1521   struct {
1522     APFloat x;
1523     APFloat y;
1524     const char *result;
1525     int status;
1526     int category;
1527   } SpecialCaseTests[NumTests] = {
1528     { PInf, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1529     { PInf, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1530     { PInf, PZero, "inf", APFloat::opOK, APFloat::fcInfinity },
1531     { PInf, MZero, "inf", APFloat::opOK, APFloat::fcInfinity },
1532     { PInf, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1533 #if 0
1534     // See Note 1.
1535     { PInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1536 #endif
1537     { PInf, PNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1538     { PInf, MNormalValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1539     { PInf, PLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1540     { PInf, MLargestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1541     { PInf, PSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1542     { PInf, MSmallestValue, "inf", APFloat::opOK, APFloat::fcInfinity },
1543     { PInf, PSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
1544     { PInf, MSmallestNormalized, "inf", APFloat::opOK, APFloat::fcInfinity },
1545     { MInf, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1546     { MInf, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1547     { MInf, PZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
1548     { MInf, MZero, "-inf", APFloat::opOK, APFloat::fcInfinity },
1549     // See Note 2.
1550     { MInf, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1551 #if 0
1552     // See Note 1.
1553     { MInf, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1554 #endif
1555     { MInf, PNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1556     { MInf, MNormalValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1557     { MInf, PLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1558     { MInf, MLargestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1559     { MInf, PSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1560     { MInf, MSmallestValue, "-inf", APFloat::opOK, APFloat::fcInfinity },
1561     { MInf, PSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
1562     { MInf, MSmallestNormalized, "-inf", APFloat::opOK, APFloat::fcInfinity },
1563     { PZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1564     { PZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1565     { PZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1566     { PZero, MZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1567     { PZero, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1568 #if 0
1569     // See Note 1.
1570     { PZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1571 #endif
1572     { PZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1573     { PZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1574     { PZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1575     { PZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1576     { PZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1577     { PZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1578     { PZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1579     { PZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1580     { MZero, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1581     { MZero, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1582     { MZero, PZero, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1583     { MZero, MZero, "-0x0p+0", APFloat::opOK, APFloat::fcZero },
1584     // See Note 2.
1585     { MZero, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1586 #if 0
1587     // See Note 1.
1588     { MZero, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1589 #endif
1590     { MZero, PNormalValue, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1591     { MZero, MNormalValue, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1592     { MZero, PLargestValue, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1593     { MZero, MLargestValue, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1594     { MZero, PSmallestValue, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1595     { MZero, MSmallestValue, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1596     { MZero, PSmallestNormalized, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1597     { MZero, MSmallestNormalized, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1598     { QNaN, PInf, "nan", APFloat::opOK, APFloat::fcNaN },
1599     { QNaN, MInf, "nan", APFloat::opOK, APFloat::fcNaN },
1600     { QNaN, PZero, "nan", APFloat::opOK, APFloat::fcNaN },
1601     { QNaN, MZero, "nan", APFloat::opOK, APFloat::fcNaN },
1602     { QNaN, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1603 #if 0
1604     // See Note 1.
1605     { QNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1606 #endif
1607     { QNaN, PNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
1608     { QNaN, MNormalValue, "nan", APFloat::opOK, APFloat::fcNaN },
1609     { QNaN, PLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1610     { QNaN, MLargestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1611     { QNaN, PSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1612     { QNaN, MSmallestValue, "nan", APFloat::opOK, APFloat::fcNaN },
1613     { QNaN, PSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
1614     { QNaN, MSmallestNormalized, "nan", APFloat::opOK, APFloat::fcNaN },
1615 #if 0
1616     // See Note 1.
1617     { SNaN, PInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1618     { SNaN, MInf, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1619     { SNaN, PZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1620     { SNaN, MZero, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1621     { SNaN, QNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1622     { SNaN, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1623     { SNaN, PNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1624     { SNaN, MNormalValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1625     { SNaN, PLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1626     { SNaN, MLargestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1627     { SNaN, PSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1628     { SNaN, MSmallestValue, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1629     { SNaN, PSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1630     { SNaN, MSmallestNormalized, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1631 #endif
1632     { PNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1633     { PNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1634     { PNormalValue, PZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1635     { PNormalValue, MZero, "0x1p+0", APFloat::opOK, APFloat::fcNormal },
1636     { PNormalValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1637 #if 0
1638     // See Note 1.
1639     { PNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1640 #endif
1641     { PNormalValue, PNormalValue, "0x1p+1", APFloat::opOK, APFloat::fcNormal },
1642     { PNormalValue, MNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1643     { PNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1644     { PNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1645     { PNormalValue, PSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1646     { PNormalValue, MSmallestValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1647     { PNormalValue, PSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1648     { PNormalValue, MSmallestNormalized, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1649     { MNormalValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1650     { MNormalValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1651     { MNormalValue, PZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1652     { MNormalValue, MZero, "-0x1p+0", APFloat::opOK, APFloat::fcNormal },
1653     // See Note 2.
1654     { MNormalValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1655 #if 0
1656     // See Note 1.
1657     { MNormalValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1658 #endif
1659     { MNormalValue, PNormalValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1660     { MNormalValue, MNormalValue, "-0x1p+1", APFloat::opOK, APFloat::fcNormal },
1661     { MNormalValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1662     { MNormalValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1663     { MNormalValue, PSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1664     { MNormalValue, MSmallestValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1665     { MNormalValue, PSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1666     { MNormalValue, MSmallestNormalized, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1667     { PLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1668     { PLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1669     { PLargestValue, PZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1670     { PLargestValue, MZero, "0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1671     { PLargestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1672 #if 0
1673     // See Note 1.
1674     { PLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1675 #endif
1676     { PLargestValue, PNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1677     { PLargestValue, MNormalValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1678     { PLargestValue, PLargestValue, "inf", OverflowStatus, APFloat::fcInfinity },
1679     { PLargestValue, MLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1680     { PLargestValue, PSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1681     { PLargestValue, MSmallestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1682     { PLargestValue, PSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1683     { PLargestValue, MSmallestNormalized, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1684     { MLargestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1685     { MLargestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1686     { MLargestValue, PZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1687     { MLargestValue, MZero, "-0x1.fffffep+127", APFloat::opOK, APFloat::fcNormal },
1688     // See Note 2.
1689     { MLargestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1690 #if 0
1691     // See Note 1.
1692     { MLargestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1693 #endif
1694     { MLargestValue, PNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1695     { MLargestValue, MNormalValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1696     { MLargestValue, PLargestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1697     { MLargestValue, MLargestValue, "-inf", OverflowStatus, APFloat::fcInfinity },
1698     { MLargestValue, PSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1699     { MLargestValue, MSmallestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1700     { MLargestValue, PSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1701     { MLargestValue, MSmallestNormalized, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1702     { PSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1703     { PSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1704     { PSmallestValue, PZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1705     { PSmallestValue, MZero, "0x1p-149", APFloat::opOK, APFloat::fcNormal },
1706     { PSmallestValue, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1707 #if 0
1708     // See Note 1.
1709     { PSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1710 #endif
1711     { PSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1712     { PSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1713     { PSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1714     { PSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1715     { PSmallestValue, PSmallestValue, "0x1p-148", APFloat::opOK, APFloat::fcNormal },
1716     { PSmallestValue, MSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1717     { PSmallestValue, PSmallestNormalized, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1718     { PSmallestValue, MSmallestNormalized, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1719     { MSmallestValue, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1720     { MSmallestValue, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1721     { MSmallestValue, PZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1722     { MSmallestValue, MZero, "-0x1p-149", APFloat::opOK, APFloat::fcNormal },
1723     // See Note 2.
1724     { MSmallestValue, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1725 #if 0
1726     // See Note 1.
1727     { MSmallestValue, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1728 #endif
1729     { MSmallestValue, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1730     { MSmallestValue, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1731     { MSmallestValue, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1732     { MSmallestValue, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1733     { MSmallestValue, PSmallestValue, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1734     { MSmallestValue, MSmallestValue, "-0x1p-148", APFloat::opOK, APFloat::fcNormal },
1735     { MSmallestValue, PSmallestNormalized, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1736     { MSmallestValue, MSmallestNormalized, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1737     { PSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1738     { PSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1739     { PSmallestNormalized, PZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1740     { PSmallestNormalized, MZero, "0x1p-126", APFloat::opOK, APFloat::fcNormal },
1741     { PSmallestNormalized, QNaN, "nan", APFloat::opOK, APFloat::fcNaN },
1742 #if 0
1743 // See Note 1.
1744     { PSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1745 #endif
1746     { PSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1747     { PSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1748     { PSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1749     { PSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1750     { PSmallestNormalized, PSmallestValue, "0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1751     { PSmallestNormalized, MSmallestValue, "0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1752     { PSmallestNormalized, PSmallestNormalized, "0x1p-125", APFloat::opOK, APFloat::fcNormal },
1753     { PSmallestNormalized, MSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1754     { MSmallestNormalized, PInf, "inf", APFloat::opOK, APFloat::fcInfinity },
1755     { MSmallestNormalized, MInf, "-inf", APFloat::opOK, APFloat::fcInfinity },
1756     { MSmallestNormalized, PZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1757     { MSmallestNormalized, MZero, "-0x1p-126", APFloat::opOK, APFloat::fcNormal },
1758     // See Note 2.
1759     { MSmallestNormalized, QNaN, "-nan", APFloat::opOK, APFloat::fcNaN },
1760 #if 0
1761     // See Note 1.
1762     { MSmallestNormalized, SNaN, "nan", APFloat::opInvalidOp, APFloat::fcNaN },
1763 #endif
1764     { MSmallestNormalized, PNormalValue, "0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1765     { MSmallestNormalized, MNormalValue, "-0x1p+0", APFloat::opInexact, APFloat::fcNormal },
1766     { MSmallestNormalized, PLargestValue, "0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1767     { MSmallestNormalized, MLargestValue, "-0x1.fffffep+127", APFloat::opInexact, APFloat::fcNormal },
1768     { MSmallestNormalized, PSmallestValue, "-0x1.fffffcp-127", APFloat::opOK, APFloat::fcNormal },
1769     { MSmallestNormalized, MSmallestValue, "-0x1.000002p-126", APFloat::opOK, APFloat::fcNormal },
1770     { MSmallestNormalized, PSmallestNormalized, "0x0p+0", APFloat::opOK, APFloat::fcZero },
1771     { MSmallestNormalized, MSmallestNormalized, "-0x1p-125", APFloat::opOK, APFloat::fcNormal }
1772   };
1773
1774   for (size_t i = 0; i < NumTests; ++i) {
1775     APFloat x(SpecialCaseTests[i].x);
1776     APFloat y(SpecialCaseTests[i].y);
1777     APFloat::opStatus status = x.add(y, APFloat::rmNearestTiesToEven);
1778
1779     APFloat result(APFloat::IEEEsingle, SpecialCaseTests[i].result);
1780
1781     EXPECT_TRUE(result.bitwiseIsEqual(x));
1782     EXPECT_TRUE((int)status == SpecialCaseTests[i].status);
1783     EXPECT_TRUE((int)x.getCategory() == SpecialCaseTests[i].category);
1784   }
1785 }
1786
1787 }