Clean up bitcode munging tests.

unittests/Bitcode/NaClMungedIoTest.cpp

 //===- llvm/unittest/Bitcode/NaClMungedIoTest.cpp -------------------------===//
 //     Tests munging NaCl bitcode records.
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // For class NaClMungedBitcode, tests reading initial sequence of records and
 // writing out munged set of bitcode records.
 
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/Bitcode/NaCl/NaClBitcodeMungeUtils.h"
-#include "llvm/Bitcode/NaCl/NaClBitcodeMunge.h"
+#include "NaClMungeTest.h"
 
-#include "gtest/gtest.h"
+namespace naclmungetest {
 
 using namespace llvm;
 
-namespace {
-
-static const uint64_t Terminator = 0x5768798008978675LL;
-
-#define ARRAY_ARGS(name) name, array_lengthof(name), Terminator
-
-std::string stringify(NaClMungedBitcode &MungedBitcode) {
-  std::string Buffer;
-  raw_string_ostream StrBuf(Buffer);
-  MungedBitcode.print(StrBuf);
-  return StrBuf.str();
-}
-
 typedef SmallVector<char, 1024> TextBuffer;
 
 // Writes out a sequence of munged bitcode records, and writes them into
 // the text buffer. Returns a corresponding memory buffer containing
 // the munged bitcode records.
 std::unique_ptr<MemoryBuffer> writeMungedBitcode(
     NaClMungedBitcode &Bitcode, TextBuffer &Buffer,
     NaClMungedBitcode::WriteFlags &Flags) {
   Bitcode.write(Buffer, /* AddHeader = */ true, Flags);
   StringRef Input(Buffer.data(), Buffer.size());
@@ skipping 32 matching lines @@
   3, naclbitc::MODULE_CODE_FUNCTION, 1, 0, 0, 3, Terminator,
   1, naclbitc::BLK_CODE_ENTER, 12, 3, Terminator,
   3, naclbitc::FUNC_CODE_DECLAREBLOCKS, 1, Terminator,
   4, naclbitc::FUNC_CODE_INST_RET, Terminator,
   0, naclbitc::BLK_CODE_EXIT, Terminator,
   0, naclbitc::BLK_CODE_EXIT, Terminator,
 };
 
 // Show a more readable form of what the program is.
 TEST(NaClMungedIoTest, TestDumpingBitcode) {
-  NaClObjDumpMunger DumpMunger(ARRAY_ARGS(Records));
-  EXPECT_TRUE(DumpMunger.runTest("Display assembly"));
+  NaClObjDumpMunger DumpMunger(ARRAY_TERM(Records));
+  EXPECT_TRUE(DumpMunger.runTest());
   EXPECT_EQ(
       "       0:0|<65532, 80, 69, 88, 69, 1, 0,|Magic Number: 'PEXE' (80, 69, "
       "88, 69)\n"
       "          | 8, 0, 17, 0, 4, 0, 2, 0, 0, |PNaCl Version: 2\n"
       "          | 0>                          |\n"
       "      16:0|1: <65535, 8, 2>             |module {  // BlockID = 8\n"
       "      24:0|  3: <1, 1>                  |  version 1;\n"
       "      26:4|  1: <65535, 0, 2>           |  abbreviations {  // BlockID "
       "= 0\n"
       "      36:0|    3: <1, 12>               |    function:\n"
@@ skipping 16 matching lines @@
       "          |                             |  %b0:\n"
       "      78:5|    4: <10>                  |    ret void; <@a0>\n"
       "      79:0|  0: <65534>                 |  }\n"
       "      80:0|0: <65534>                   |}\n",
       DumpMunger.getTestResults());
 }
 
 // Test that we can write out bitcode, and then read it back in.
 TEST(NaClMungedIoTest, TestWriteThenRead) {
   // Create munged bitcode for the given records.
-  NaClMungedBitcode Bitcode(ARRAY_ARGS(Records));
+  NaClMungedBitcode Bitcode(ARRAY_TERM(Records));
 
   // The expected output when stringifying this input.
   const std::string ExpectedRecords(
       "       1: [65535, 8, 2]\n"
       "         3: [1, 1]\n"
       "         1: [65535, 0, 2]\n"
       "           3: [1, 12]\n"
       "           2: [65533, 1, 1, 10]\n"
       "         0: [65534]\n"
       "         1: [65535, 17, 3]\n"
@@ skipping 13 matching lines @@
   // Write and read the bitcode back into a sequence of records.
   EXPECT_EQ(ExpectedRecords, parseWrittenMungedBitcode(Bitcode));
 }
 
 
 // Test that writing truncated bitcode is difficult, due to word
 // alignment requirements for bitcode files. Note: Bitcode files must
 // be divisible by 4.
 TEST(NaClMungedIoTest, TestTruncatedNonalignedBitcode) {
   // Created an example of a truncated bitcode file.
-  NaClMungedBitcode Bitcode(ARRAY_ARGS(Records));
+  NaClMungedBitcode Bitcode(ARRAY_TERM(Records));
   for (size_t i = 2, e = Bitcode.getBaseRecords().size(); i < e; ++i)
     Bitcode.remove(i);
 
   // The expected output when stringifying this input.
   EXPECT_EQ(
       "       1: [65535, 8, 2]\n"
       "         3: [1, 1]\n",
       stringify(Bitcode));
 
   // Show that we can't write the bitcode correctly.
   TextBuffer WriteBuffer;
   std::string LogBuffer;
   raw_string_ostream StrBuf(LogBuffer);
   NaClMungedBitcode::WriteFlags Flags;
   Flags.setErrStream(StrBuf);
   writeMungedBitcode(Bitcode, WriteBuffer, Flags);
   EXPECT_EQ(
       "Error (Block 8): Missing close block.\n",
       StrBuf.str());
 }
 
-} // end of anonymous namespace
+} // end of namespace naclmungetest