Unittest fixes.

unittest/BitcodeMunge.cpp

@@ -19,11 +19,6 @@
 
 namespace IceTest {
 
-void IceTest::SubzeroBitcodeMunger::resetFlags() {
-  Ice::ClFlags::resetClFlags(Flags);
-  resetMungeFlags();
-}
-
 void IceTest::SubzeroBitcodeMunger::resetMungeFlags() {
   Flags.setAllowErrorRecovery(true);
   Flags.setGenerateUnitTestMessages(true);
@@ -34,12 +29,14 @@ void IceTest::SubzeroBitcodeMunger::resetMungeFlags() {
 }
 
 bool IceTest::SubzeroBitcodeMunger::runTest(const uint64_t Munges[],
-                                            size_t MungeSize) {
+                                            size_t MungeSize,
+                                            bool DisableTranslation) {
   const bool AddHeader = true;
   setupTest(Munges, MungeSize, AddHeader);
   Ice::GlobalContext Ctx(DumpStream, DumpStream, DumpStream, nullptr, Flags);
   Ice::PNaClTranslator Translator(&Ctx);
   const char *BufferName = "Test";
+  Flags.setDisableTranslation(DisableTranslation);
   Translator.translateBuffer(BufferName, MungedInput.get());
 
   cleanupTest();

unittest/BitcodeMunge.h

@@ -33,20 +33,18 @@ public:
     resetMungeFlags();
   }
 
-  /// Runs PNaClTranslator to translate bitcode records (with defined
-  /// record Munges), and puts output into DumpResults. Returns true
-  /// if parse is successful.
-  bool runTest(const uint64_t Munges[], size_t MungeSize);
+  /// Runs PNaClTranslator to parse and (optionally) translate bitcode records
+  /// (with defined record Munges), and puts output into DumpResults. Returns
+  /// true if parse is successful.
+  bool runTest(const uint64_t Munges[], size_t MungeSize,
+               bool DisableTranslation = false);
 
   /// Same as above, but without any edits.
-  bool runTest() {
+  bool runTest(bool DisableTranslation = false) {
     uint64_t NoMunges[] = {0};
-    return runTest(NoMunges, 0);
+    return runTest(NoMunges, 0, DisableTranslation);
   }
 
-  /// Sets flags back to default assumptions for munging.
-  void resetFlags();
-
   /// Flags to use to run tests. Use to change default assumptions.
   Ice::ClFlags Flags;
 

unittest/IceParseInstsTest.cpp

@@ -7,6 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include <string>
+
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Bitcode/NaCl/NaClBitcodeParser.h"
 #include "llvm/Bitcode/NaCl/NaClLLVMBitCodes.h"
@@ -19,6 +21,10 @@ using namespace naclmungetest;
 
 namespace {
 
+// The ParseError constant is passed to the BitcodeMunger to prevent translation
+// when we expect a Parse error.
+constexpr bool ParseError = true;
+
 // Note: alignment stored as 0 or log2(Alignment)+1.
 uint64_t getEncAlignPower(unsigned Power) {
   return Power + 1;
@@ -56,13 +62,13 @@ TEST(IceParseInstsTest, NonexistentCallArg) {
 
   // Show that we get appropriate error when parsing in Subzero.
   IceTest::SubzeroBitcodeMunger Munger(ARRAY_TERM(BitcodeRecords));
-  EXPECT_FALSE(Munger.runTest());
+  EXPECT_FALSE(Munger.runTest(ParseError));
   EXPECT_EQ("Error(66:4): Invalid function record: <34 0 4 2 100>\n",
             Munger.getTestResults());
 
   // Show that we generate a fatal error when not allowing error recovery.
   Munger.Flags.setAllowErrorRecovery(false);
-  EXPECT_DEATH(Munger.runTest(), ".*ERROR: Unable to continue.*");
+  EXPECT_DEATH(Munger.runTest(ParseError), ".*ERROR: Unable to continue.*");
 }
 
 /// Test how we recognize alignments in alloca instructions.
@@ -112,7 +118,7 @@ TEST(IceParseInstsTests, AllocaAlignment) {
       ReplaceIndex, NaClMungedBitcode::Replace,
       3, naclbitc::FUNC_CODE_INST_ALLOCA, 1, getEncAlignPower(30), Terminator,
   };
-  EXPECT_FALSE(Munger.runTest(ARRAY(Align30)));
+  EXPECT_FALSE(Munger.runTest(ARRAY(Align30), ParseError));
   EXPECT_EQ("Error(62:4): Invalid function record: <19 1 31>\n",
             Munger.getTestResults());
 
@@ -167,7 +173,7 @@ TEST(IceParseInstsTests, LoadI32Alignment) {
       ReplaceIndex, NaClMungedBitcode::Replace,
       3, naclbitc::FUNC_CODE_INST_LOAD, 1, getEncAlignZero(), 0, Terminator,
   };
-  EXPECT_FALSE(Munger.runTest(ARRAY(Align0)));
+  EXPECT_FALSE(Munger.runTest(ARRAY(Align0), ParseError));
   EXPECT_EQ("Error(58:4): Invalid function record: <20 1 0 0>\n",
             Munger.getTestResults());
   EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align0)));
@@ -180,7 +186,7 @@ TEST(IceParseInstsTests, LoadI32Alignment) {
       ReplaceIndex, NaClMungedBitcode::Replace,
       3, naclbitc::FUNC_CODE_INST_LOAD, 1, getEncAlignPower(2), 0, Terminator,
   };
-  EXPECT_FALSE(Munger.runTest(ARRAY(Align4)));
+  EXPECT_FALSE(Munger.runTest(ARRAY(Align4), ParseError));
   EXPECT_EQ("Error(58:4): Invalid function record: <20 1 3 0>\n",
             Munger.getTestResults());
   EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align4)));
@@ -193,7 +199,7 @@ TEST(IceParseInstsTests, LoadI32Alignment) {
       ReplaceIndex, NaClMungedBitcode::Replace,
       3, naclbitc::FUNC_CODE_INST_LOAD, 1, getEncAlignPower(29), 0, Terminator,
   };
-  EXPECT_FALSE(Munger.runTest(ARRAY(Align29)));
+  EXPECT_FALSE(Munger.runTest(ARRAY(Align29), ParseError));
   EXPECT_EQ("Error(58:4): Invalid function record: <20 1 30 0>\n",
             Munger.getTestResults());
   EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align29)));
@@ -206,7 +212,7 @@ TEST(IceParseInstsTests, LoadI32Alignment) {
       ReplaceIndex, NaClMungedBitcode::Replace,
       3, naclbitc::FUNC_CODE_INST_LOAD, 1, getEncAlignPower(30), 0, Terminator,
   };
-  EXPECT_FALSE(Munger.runTest(ARRAY(Align30)));
+  EXPECT_FALSE(Munger.runTest(ARRAY(Align30), ParseError));
   EXPECT_EQ("Error(58:4): Invalid function record: <20 1 31 0>\n",
             Munger.getTestResults());
   EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align30)));
@@ -249,7 +255,7 @@ TEST(IceParseInstsTests, LoadFloatAlignment) {
       ReplaceIndex, NaClMungedBitcode::Replace,
       3, naclbitc::FUNC_CODE_INST_LOAD, 1, getEncAlignZero(), 0, Terminator,
   };
-  EXPECT_FALSE(Munger.runTest(ARRAY(Align0)));
+  EXPECT_FALSE(Munger.runTest(ARRAY(Align0), ParseError));
   EXPECT_EQ("Error(58:4): Invalid function record: <20 1 0 0>\n",
             Munger.getTestResults());
   EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align0)));
@@ -272,7 +278,7 @@ TEST(IceParseInstsTests, LoadFloatAlignment) {
       ReplaceIndex, NaClMungedBitcode::Replace,
       3, naclbitc::FUNC_CODE_INST_LOAD, 1, getEncAlignPower(29), 0, Terminator,
   };
-  EXPECT_FALSE(Munger.runTest(ARRAY(Align29)));
+  EXPECT_FALSE(Munger.runTest(ARRAY(Align29), ParseError));
   EXPECT_EQ("Error(58:4): Invalid function record: <20 1 30 0>\n",
             Munger.getTestResults());
   EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align29)));
@@ -286,7 +292,7 @@ TEST(IceParseInstsTests, LoadFloatAlignment) {
       ReplaceIndex, NaClMungedBitcode::Replace,
       3, naclbitc::FUNC_CODE_INST_LOAD, 1, getEncAlignPower(30), 0, Terminator,
   };
-  EXPECT_FALSE(Munger.runTest(ARRAY(Align30)));
+  EXPECT_FALSE(Munger.runTest(ARRAY(Align30), ParseError));
   EXPECT_EQ("Error(58:4): Invalid function record: <20 1 31 0>\n",
             Munger.getTestResults());
   EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align30)));
@@ -332,7 +338,7 @@ TEST(NaClParseInstsTests, StoreAlignment) {
       ReplaceIndex, NaClMungedBitcode::Replace,
       3, naclbitc::FUNC_CODE_INST_STORE, 2, 1, getEncAlignZero(), Terminator,
   };
-  EXPECT_FALSE(Munger.runTest(ARRAY(Align0)));
+  EXPECT_FALSE(Munger.runTest(ARRAY(Align0), ParseError));
   EXPECT_EQ("Error(62:4): Invalid function record: <24 2 1 0>\n",
             Munger.getTestResults());
   EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align0)));
@@ -354,7 +360,7 @@ TEST(NaClParseInstsTests, StoreAlignment) {
       ReplaceIndex, NaClMungedBitcode::Replace,
       3, naclbitc::FUNC_CODE_INST_STORE, 2, 1, getEncAlignPower(3), Terminator,
   };
-  EXPECT_FALSE(Munger.runTest(ARRAY(Align8)));
+  EXPECT_FALSE(Munger.runTest(ARRAY(Align8), ParseError));
   EXPECT_EQ("Error(62:4): Invalid function record: <24 2 1 4>\n",
             Munger.getTestResults());
   EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align8)));
@@ -368,7 +374,7 @@ TEST(NaClParseInstsTests, StoreAlignment) {
       ReplaceIndex, NaClMungedBitcode::Replace,
       3, naclbitc::FUNC_CODE_INST_STORE, 2, 1, getEncAlignPower(29), Terminator,
   };
-  EXPECT_FALSE(Munger.runTest(ARRAY(Align29)));
+  EXPECT_FALSE(Munger.runTest(ARRAY(Align29), ParseError));
   EXPECT_EQ("Error(62:4): Invalid function record: <24 2 1 30>\n",
             Munger.getTestResults());
   EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align29)));
@@ -382,7 +388,7 @@ TEST(NaClParseInstsTests, StoreAlignment) {
       // Note: alignment stored as 0 or log2(Alignment)+1.
       3, naclbitc::FUNC_CODE_INST_STORE, 2, 1, getEncAlignPower(30), Terminator,
   };
-  EXPECT_FALSE(Munger.runTest(ARRAY(Align30)));
+  EXPECT_FALSE(Munger.runTest(ARRAY(Align30), ParseError));
   EXPECT_EQ("Error(62:4): Invalid function record: <24 2 1 31>\n",
             Munger.getTestResults());
   EXPECT_FALSE(DumpMunger.runTestForAssembly(ARRAY(Align30)));