Clean up bitcode munging tests.

Cleans up bitcode munging tests in several ways:

1) Extracts out common definitions into a single header file.
2) Puts all test/code for munging in same namespace.
3) Removes test name argument from calls to runTest.
4) Uses ARRAY and ARRAY_TERM macros to pass array arguments to
bitcode munger constructors and runTest calls.

BUG=None
[email protected]

Review URL: https://codereview.chromium.org/1140153004

Author: KarlSchimpf

include/llvm/Bitcode/NaCl/NaClBitcodeMunge.h

@@ -74,9 +74,15 @@ class NaClBitcodeMunger {
 
   /// Creates MungedInput and DumpStream for running tests, based on
   /// given Munges. Returns true if able to set up test.
-  bool setupTest(
-      const char *TestName, const uint64_t Munges[], size_t MungesSize,
-      bool AddHeader);
+  bool setupTest(const uint64_t Munges[], size_t MungesSize, bool AddHeader);
+
+  // TODO(kschimpf): The following function is deprecated and only
+  // provided until subzero is updated to use the new API that no
+  // longer uses test names.
+  bool setupTest(const char *, const uint64_t Munges[], size_t MungesSize,
+                 bool AddHeader) {
+    return setupTest(Munges, MungesSize, AddHeader);
+  }
 
   /// Cleans up state after a test. Returns true if no errors found.
   bool cleanupTest();
@@ -170,23 +176,12 @@ class NaClWriteMunger : public NaClBitcodeMunger {
 
   /// Writes munged bitcode and puts error messages into DumpResults.
   /// Returns true if successful.
-  bool runTest(const char* TestName, const uint64_t Munges[],
-               size_t MungesSize);
-
-  /// Same as above, but without test name.
-  bool runTest(const uint64_t Munges[], size_t MungesSize) {
-    return runTest("Test", Munges, MungesSize);
-  }
+  bool runTest(const uint64_t Munges[], size_t MungesSize);
 
   /// Same as above, but without any edits.
-  bool runTest(const char* TestName) {
-    uint64_t NoMunges[] = {0};
-    return runTest(TestName, NoMunges, 0);
-  }
-
-  /// Same as above, but without test name.
   bool runTest() {
-    return runTest("Test");
+    uint64_t NoMunges[] = {0};
+    return runTest(NoMunges, 0);
   }
 };
 
@@ -202,38 +197,36 @@ class NaClObjDumpMunger : public NaClBitcodeMunger {
   /// Runs function NaClObjDump on the sequence of records associated
   /// with the instance. The memory buffer containing the bitsequence
   /// associated with the record is automatically generated, and
-  /// passed to NaClObjDump.  TestName is the name associated with the
-  /// memory buffer.  If AddHeader is true, test assumes that the
+  /// passed to NaClObjDump. If AddHeader is true, test assumes that the
   /// sequence of records doesn't contain a header record, and the
   /// test should add one. Arguments NoRecords and NoAssembly are
   /// passed to NaClObjDump. Returns true if test succeeds without
   /// errors.
-  bool runTestWithFlags(const char *TestName, bool AddHeader,
-                        bool NoRecords, bool NoAssembly) {
+  bool runTestWithFlags(bool AddHeader, bool NoRecords, bool NoAssembly) {
     uint64_t NoMunges[] = {0};
-    return runTestWithFlags(TestName, NoMunges, 0, AddHeader, NoRecords,
-                            NoAssembly);
+    return runTestWithFlags(NoMunges, 0, AddHeader, NoRecords, NoAssembly);
   }
 
   /// Same as above except it runs function NaClObjDump with flags
   /// NoRecords and NoAssembly set to false, and AddHeader set to true.
-  bool runTest(const char *TestName) {
-    return runTestWithFlags(TestName, true, false, false);
+  bool runTest() {
+    return runTestWithFlags(true, false, false);
   }
 
-  /// Same as above but without test name.
-  bool runTest() {
-    return runTest("Test");
+  // TODO(kschimpf): The following function is deprecated and only
+  // provided until subzero is updated to use the new API that no
+  // longer uses test names.
+  bool runTest(const char *) {
+    return runTest();
   }
 
   /// Same as above, but only print out assembly and errors.
-  bool runTestForAssembly(const char *TestName) {
-    return runTestWithFlags(TestName, true, true, false);
+  bool runTestForAssembly() {
+    return runTestWithFlags(true, true, false);
   }
-
   /// Same as above, but only generate error messages.
-  bool runTestForErrors(const char *TestName) {
-    return runTestWithFlags(TestName, true, true, true);
+  bool runTestForErrors() {
+    return runTestWithFlags(true, true, true);
   }
 
   /// Runs function llvm::NaClObjDump on the sequence of records
@@ -244,30 +237,31 @@ class NaClObjDumpMunger : public NaClBitcodeMunger {
   /// with the memory buffer.  Arguments NoRecords and NoAssembly are
   /// passed to NaClObjDump. Returns true if test succeeds without
   /// errors.
-  bool runTestWithFlags(const char* TestName, const uint64_t Munges[],
-                        size_t MungesSize, bool AddHeader,
-                        bool NoRecords, bool NoAssembly);
+  bool runTestWithFlags(const uint64_t Munges[], size_t MungesSize,
+                        bool AddHeader, bool NoRecords, bool NoAssembly);
 
   /// Same as above except it runs function NaClObjDump with flags
   /// NoRecords and NoAssembly set to false, and AddHeader set to
   /// true.
-  bool runTest(const char* TestName, const uint64_t Munges[],
-                      size_t MungesSize) {
-    return runTestWithFlags(TestName, Munges, MungesSize, true, false, false);
+  bool runTest(const uint64_t Munges[], size_t MungesSize) {
+    return runTestWithFlags(Munges, MungesSize, true, false, false);
   }
 
-  bool runTest(const uint64_t Munges[], size_t MungesSize) {
-    return runTest("Test", Munges, MungesSize);
+  bool runTestForAssembly(const uint64_t Munges[], size_t MungesSize) {
+    return runTestWithFlags(Munges, MungesSize, true, true, false);
   }
 
-  bool runTestForAssembly(const char* TestName, const uint64_t Munges[],
+  // TODO(kschimpf): The following function is deprecated and only
+  // provided until subzero is updated to use the new API that no
+  // longer uses test names.
+  bool runTestForAssembly(const char *, const uint64_t Munges[],
                           size_t MungesSize) {
-    return runTestWithFlags(TestName, Munges, MungesSize, true, true, false);
+    return runTestForAssembly(Munges, MungesSize);
   }
 
-  bool runTestForErrors(const char* TestName, const uint64_t Munges[],
-                        size_t MungesSize) {
-    return runTestWithFlags(TestName, Munges, MungesSize, true, true, true);
+
+  bool runTestForErrors(const uint64_t Munges[], size_t MungesSize) {
+    return runTestWithFlags(Munges, MungesSize, true, true, true);
   }
 };
 
@@ -280,18 +274,12 @@ class NaClParseBitcodeMunger : public NaClBitcodeMunger {
 
   /// Runs function llvm::NaClParseBitcodeFile, and puts error messages
   /// into DumpResults. Returns true if parse is successful.
-  bool runTest(const char* TestName, const uint64_t Munges[],
-               size_t MungesSize, bool VerboseErrors);
-
-  /// Same as above, but without test name.
-  bool runTest(const uint64_t Munges[], size_t MungesSize, bool VerboseErrors) {
-    return runTest("Test", Munges, MungesSize, VerboseErrors);
-  }
+  bool runTest(const uint64_t Munges[], size_t MungesSize, bool VerboseErrors);
 
   // Same as above, but without any edits.
-  bool runTest(const char* TestName, bool VerboseErrors) {
+  bool runTest(bool VerboseErrors) {
     uint64_t NoMunges[] = {0};
-    return runTest(TestName, NoMunges, 0, VerboseErrors);
+    return runTest(NoMunges, 0, VerboseErrors);
   }
 };
 
@@ -302,12 +290,11 @@ class NaClCompressMunger : public NaClBitcodeMunger {
                      uint64_t RecordTerminator)
       : NaClBitcodeMunger(Records, RecordsSize, RecordTerminator) {}
 
-  bool runTest(const char* TestName, const uint64_t Munges[],
-               size_t MungesSize);
+  bool runTest(const uint64_t Munges[], size_t MungesSize);
 
-  bool runTest(const char* TestName) {
+  bool runTest() {
     uint64_t NoMunges[] = {0};
-    return runTest(TestName, NoMunges, 0);
+    return runTest(NoMunges, 0);
   }
 };
 

lib/Bitcode/NaCl/TestUtils/NaClBitcodeMunge.cpp

@@ -29,9 +29,8 @@ using namespace llvm;
 // For debugging. When true, shows each test being run.
 static bool TraceTestRuns = false;
 
-bool NaClBitcodeMunger::setupTest(
-    const char *TestName, const uint64_t Munges[], size_t MungesSize,
-    bool AddHeader) {
+bool NaClBitcodeMunger::setupTest(const uint64_t Munges[], size_t MungesSize,
+                                  bool AddHeader) {
   assert(DumpStream == nullptr && "Test run with DumpStream already defined");
   assert(MungedInput.get() == nullptr
          && "Test run with MungedInput already defined");
@@ -42,7 +41,7 @@ bool NaClBitcodeMunger::setupTest(
   MungedInputBuffer.clear();
 
   if (TraceTestRuns) {
-    errs() << "*** Run test: " << TestName << "\n";
+    errs() << "*** Run test:\n";
   }
 
   MungedBitcode.munge(Munges, MungesSize, RecordTerminator);
@@ -63,8 +62,7 @@ bool NaClBitcodeMunger::setupTest(
   MungedInputBuffer.push_back('\0');
 
   MungedInput = MemoryBuffer::getMemBuffer(
-      StringRef(MungedInputBuffer.data(), MungedInputBuffer.size()-1),
-      TestName);
+      StringRef(MungedInputBuffer.data(), MungedInputBuffer.size()-1));
   return true;
 }
 
@@ -114,10 +112,9 @@ getLinesWithTextMatch(const std::string &Substring, bool MustBePrefix) const {
   return Messages;
 }
 
-bool NaClWriteMunger::runTest(const char* Name, const uint64_t Munges[],
-                              size_t MungesSize) {
+bool NaClWriteMunger::runTest(const uint64_t Munges[], size_t MungesSize) {
   bool AddHeader = true;
-  if (!setupTest(Name, Munges, MungesSize, AddHeader))
+  if (!setupTest(Munges, MungesSize, AddHeader))
     return cleanupTest();
   MemoryBufferRef InputRef(MungedInput->getMemBufferRef());
   NaClMungedBitcode WrittenBitcode(MemoryBuffer::getMemBuffer(InputRef));
@@ -126,9 +123,9 @@ bool NaClWriteMunger::runTest(const char* Name, const uint64_t Munges[],
 }
 
 bool NaClObjDumpMunger::runTestWithFlags(
-    const char *Name, const uint64_t Munges[], size_t MungesSize,
-    bool AddHeader, bool NoRecords, bool NoAssembly) {
-  if (!setupTest(Name, Munges, MungesSize, AddHeader))
+    const uint64_t Munges[], size_t MungesSize, bool AddHeader,
+    bool NoRecords, bool NoAssembly) {
+  if (!setupTest(Munges, MungesSize, AddHeader))
     return cleanupTest();
 
   if (NaClObjDump(MungedInput.get()->getMemBufferRef(),
@@ -137,11 +134,10 @@ bool NaClObjDumpMunger::runTestWithFlags(
   return cleanupTest();
 }
 
-bool NaClParseBitcodeMunger::runTest(
-    const char *Name, const uint64_t Munges[], size_t MungesSize,
-    bool VerboseErrors) {
+bool NaClParseBitcodeMunger::runTest(const uint64_t Munges[], size_t MungesSize,
+                                     bool VerboseErrors) {
   bool AddHeader = true;
-  if (!setupTest(Name, Munges, MungesSize, AddHeader))
+  if (!setupTest(Munges, MungesSize, AddHeader))
     return cleanupTest();
 
   LLVMContext &Context = getGlobalContext();
@@ -160,10 +156,9 @@ bool NaClParseBitcodeMunger::runTest(
   return cleanupTest();
 }
 
-bool NaClCompressMunger::runTest(const char* Name, const uint64_t Munges[],
-                                 size_t MungesSize) {
+bool NaClCompressMunger::runTest(const uint64_t Munges[], size_t MungesSize) {
   bool AddHeader = true;
-  if (!setupTest(Name, Munges, MungesSize, AddHeader))
+  if (!setupTest(Munges, MungesSize, AddHeader))
     return cleanupTest();
 
   NaClBitcodeCompressor Compressor;

unittests/Bitcode/NaClCompressTests.cpp

@@ -8,18 +8,13 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/Bitcode/NaCl/NaClBitcodeMunge.h"
-#include "llvm/Bitcode/NaCl/NaClBitcodeParser.h"
-#include "llvm/Bitcode/NaCl/NaClLLVMBitCodes.h"
+#include "NaClMungeTest.h"
 
-#include "gtest/gtest.h"
+#include "llvm/Bitcode/NaCl/NaClLLVMBitCodes.h"
 
 using namespace llvm;
 
-namespace {
-
-static const uint64_t Terminator = 0x5768798008978675LL;
+namespace naclmungetest {
 
 // Note: Tests fix for bug in
 // https://code.google.com/p/nativeclient/issues/detail?id=4104
@@ -41,9 +36,8 @@ TEST(NaClCompressTests, FixedModuleAbbrevIdBug) {
   };
 
   // Show textual version of sample input.
-  NaClObjDumpMunger DumpMunger(BitcodeRecords,
-                               array_lengthof(BitcodeRecords), Terminator);
-  EXPECT_TRUE(DumpMunger.runTest("Test fixed module abbreviation ID bug"));
+  NaClObjDumpMunger DumpMunger(ARRAY_TERM(BitcodeRecords));
+  EXPECT_TRUE(DumpMunger.runTest());
   EXPECT_EQ(
       "       0:0|<65532, 80, 69, 88, 69, 1, 0,|Magic Number: 'PEXE' (80, 69, 8"
       "8, 69)\n"
@@ -63,7 +57,7 @@ TEST(NaClCompressTests, FixedModuleAbbrevIdBug) {
   // Show that we can compress as well.
   NaClCompressMunger CompressMunger(BitcodeRecords,
                                     array_lengthof(BitcodeRecords), Terminator);
-  EXPECT_TRUE(CompressMunger.runTest("Test fixed module abbreviation ID bug"));
+  EXPECT_TRUE(CompressMunger.runTest());
 }
 
-}
+} // end of namespace naclmungetest

unittests/Bitcode/NaClMungeTest.h

@@ -0,0 +1,41 @@
+//===- llvm/unittest/Bitcode/NaClMungeTest.h - Test munging utils ---------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// Contains common utilities used in bitcode munge tests.
+
+#ifndef LLVM_UNITTEST_BITCODE_NACLMUNGETEST_H
+#define LLVM_UNITTEST_BITCODE_NACLMUNGETEST_H
+
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Bitcode/NaCl/NaClBitcodeMunge.h"
+
+#include "gtest/gtest.h"
+
+namespace naclmungetest {
+
+const uint64_t Terminator = 0x5768798008978675LL;
+
+#define ARRAY(name) name, array_lengthof(name)
+
+#define ARRAY_TERM(name) ARRAY(name), Terminator
+
+inline std::string stringify(llvm::NaClMungedBitcode &MungedBitcode) {
+  std::string Buffer;
+  llvm::raw_string_ostream StrBuf(Buffer);
+  MungedBitcode.print(StrBuf);
+  return StrBuf.str();
+}
+
+inline std::string stringify(llvm::NaClBitcodeMunger &Munger) {
+  return stringify(Munger.getMungedBitcode());
+}
+
+} // end of namespace naclmungetest
+
+#endif // end LLVM_UNITTEST_BITCODE_NACLMUNGETEST_H