[APFloatTest] Log when test fails. NFC

llvm/trunk/unittests/ADT/APFloatTest.cpp

 //===- llvm/unittest/ADT/APFloat.cpp - APFloat unit tests ---------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/raw_ostream.h"
 #include "gtest/gtest.h"
 #include <cmath>
 #include <ostream>
 #include <string>
 #include <tuple>
 
 using namespace llvm;
for (auto Tp : Data) {
     APFloat::fltCategory Expected;
     APFloat::roundingMode RM;
     std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected, RM) = Tp;
 
     APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
     APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
     A1.add(A2, RM);
 
-    EXPECT_EQ(Expected, A1.getCategory());
+    EXPECT_EQ(Expected, A1.getCategory())
+        << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
+                   Op2[1])
+               .str();
   }
 }
 
 TEST(APFloatTest, PPCDoubleDoubleAdd) {
   using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
                               uint64_t, APFloat::roundingMode>;
   DataType Data[] = {
       // (1 + 0) + (1e-105 + 0) = (1 + 1e-105)
for (auto Tp : Data) {
     uint64_t Op1[2], Op2[2], Expected[2];
     APFloat::roundingMode RM;
     std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
 
     APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
     APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
     A1.add(A2, RM);
 
-    EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0]);
-    EXPECT_EQ(Expected[1],
-              A1.getSecondFloat().bitcastToAPInt().getRawData()[0]);
+    EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
+        << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
+                   Op2[1])
+               .str();
+    EXPECT_EQ(Expected[1], A1.getSecondFloat().bitcastToAPInt().getRawData()[0])
+        << formatv("({0:x} + {1:x}) + ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
+                   Op2[1])
+               .str();
   }
 }
 
 TEST(APFloatTest, PPCDoubleDoubleSubtract) {
   using DataType = std::tuple<uint64_t, uint64_t, uint64_t, uint64_t, uint64_t,
                               uint64_t, APFloat::roundingMode>;
   DataType Data[] = {
       // (1 + 0) - (-1e-105 + 0) = (1 + 1e-105)
for (auto Tp : Data) {
     uint64_t Op1[2], Op2[2], Expected[2];
     APFloat::roundingMode RM;
     std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
 
     APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
     APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
     A1.subtract(A2, RM);
 
-    EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0]);
-    EXPECT_EQ(Expected[1],
-              A1.getSecondFloat().bitcastToAPInt().getRawData()[0]);
+    EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
+        << formatv("({0:x} + {1:x}) - ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
+                   Op2[1])
+               .str();
+    EXPECT_EQ(Expected[1], A1.getSecondFloat().bitcastToAPInt().getRawData()[0])
+        << formatv("({0:x} + {1:x}) - ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
+                   Op2[1])
+               .str();
   }
 }
 }