Clean up bitcode munging tests.

lib/Bitcode/NaCl/TestUtils/NaClBitcodeMunge.cpp

 //===--- Bitcode/NaCl/TestUtils/NaClBitcodeMunge.cpp - Bitcode Munger -----===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Bitcode writer/munger implementation for testing.
@@ skipping 11 matching lines @@
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 #include <memory>
 
 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");
   FoundErrors = false;
   DumpResults.clear(); // Throw away any previous results.
   std::string DumpBuffer;
   DumpStream = new raw_string_ostream(DumpResults);
   MungedInputBuffer.clear();
 
   if (TraceTestRuns) {
-    errs() << "*** Run test: " << TestName << "\n";
+    errs() << "*** Run test:\n";
   }
 
   MungedBitcode.munge(Munges, MungesSize, RecordTerminator);
   WriteFlags.setErrStream(getDumpStream());
   NaClMungedBitcode::WriteResults Results =
       MungedBitcode.writeMaybeRepair(MungedInputBuffer, AddHeader, WriteFlags);
   if (Results.NumErrors != 0
       && !(WriteFlags.getTryToRecover()
            && Results.NumRepairs == Results.NumErrors)
       && !(WriteFlags.getWriteBadAbbrevIndex()
            && Results.WroteBadAbbrevIndex && Results.NumErrors == 1)) {
     Error() << "Unable to generate bitcode file due to write errors\n";
     return false;
   }
 
   // Add null terminator, so that we meet the requirements of the
   // MemoryBuffer API.
   MungedInputBuffer.push_back('\0');
 
   MungedInput = MemoryBuffer::getMemBuffer(
-      StringRef(MungedInputBuffer.data(), MungedInputBuffer.size()-1),
-      TestName);
+      StringRef(MungedInputBuffer.data(), MungedInputBuffer.size()-1));
   return true;
 }
 
 bool NaClBitcodeMunger::cleanupTest() {
   RunAsDeathTest = false;
   WriteFlags.reset();
   MungedBitcode.removeEdits();
   MungedInput.reset();
   assert(DumpStream && "Dump stream removed before cleanup!");
   DumpStream->flush();
@@ skipping 29 matching lines @@
     std::string Line = getLine(DumpResults, LastLinePos);
     if (LastLinePos == std::string::npos) break;
     size_t Pos = Line.find(Substring);
     if (Pos != std::string::npos && (!MustBePrefix || Pos == 0)) {
       Messages.append(Line);
     }
   }
   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));
   WrittenBitcode.print(WriteFlags.getErrStream());
   return cleanupTest();
 }
 
 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(),
                   getDumpStream(), NoRecords, NoAssembly))
     FoundErrors = true;
   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();
 
   raw_ostream *VerboseStrm = VerboseErrors ? &getDumpStream() : nullptr;
   ErrorOr<Module *> ModuleOrError =
       NaClParseBitcodeFile(MungedInput->getMemBufferRef(), Context,
                            VerboseStrm);
   if (ModuleOrError) {
     if (VerboseErrors)
       getDumpStream() << "Successful parse!\n";
     delete ModuleOrError.get();
   } else {
     Error() << ModuleOrError.getError().message() << "\n";
   }
   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;
   if (!Compressor.compress(MungedInput.get(), getDumpStream()))
     Error() << "Unable to compress\n";
   return cleanupTest();
 }