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