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