Clean up bitcode munging tests.

unittests/Bitcode/NaClMungedBitcodeTest.cpp

 //===- llvm/unittest/Bitcode/NaClMungedBitcodeTest.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.
 //
 //===----------------------------------------------------------------------===//
 
 // Tests munging NaCl bitcode records.
 
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/Bitcode/NaCl/NaClBitcodeMungeUtils.h"
+#include "NaClMungeTest.h"
 
-#include "gtest/gtest.h"
 #include <limits>
 
 using namespace llvm;
 
-namespace {
-
-static const uint64_t Terminator = 0x5768798008978675LL;
-
-std::string stringify(NaClMungedBitcode &MungedBitcode) {
-  std::string Buffer;
-  raw_string_ostream StrBuf(Buffer);
-  MungedBitcode.print(StrBuf);
-  return StrBuf.str();
-}
-
-} // end of anonymous namespace
-
-#define ARRAY_ARGS(name) name, array_lengthof(name), Terminator
-
-namespace NaClMungedBc {
+namespace naclmungetest {
 
 TEST(NaClMungedBitcodeTest, TestInsertBefore) {
   const uint64_t Records[] = {
     1, 2, 3, Terminator,
     4, 5, Terminator,
     6, 7, 8 , 9, Terminator,
     10, 11, Terminator
   };
-  NaClMungedBitcode MungedRecords(ARRAY_ARGS(Records));
+  NaClMungedBitcode MungedRecords(ARRAY_TERM(Records));
   EXPECT_EQ(
       "       1: [2, 3]\n"
       "       4: [5]\n"
       "       6: [7, 8, 9]\n"
       "      10: [11]\n",
       stringify(MungedRecords));
 
   // Add a record before the second record.
   const uint64_t BeforeSecond[] = {
     1, NaClMungedBitcode::AddBefore, 12, 13, 14, Terminator
   };
-  MungedRecords.munge(ARRAY_ARGS(BeforeSecond));
+  MungedRecords.munge(ARRAY_TERM(BeforeSecond));
   EXPECT_EQ(
       "       1: [2, 3]\n"
       "      12: [13, 14]\n"
       "       4: [5]\n"
       "       6: [7, 8, 9]\n"
       "      10: [11]\n",
       stringify(MungedRecords));
 
   // Add two more records before the second record.
   const uint64_t BeforeSecondMore[] = {
     1, NaClMungedBitcode::AddBefore, 15, 16, 17, Terminator,
     1, NaClMungedBitcode::AddBefore, 18, 19, Terminator
   };
-  MungedRecords.munge(ARRAY_ARGS(BeforeSecondMore));
+  MungedRecords.munge(ARRAY_TERM(BeforeSecondMore));
   EXPECT_EQ(
       "       1: [2, 3]\n"
       "      12: [13, 14]\n"
       "      15: [16, 17]\n"
       "      18: [19]\n"
       "       4: [5]\n"
       "       6: [7, 8, 9]\n"
       "      10: [11]\n",
       stringify(MungedRecords));
 
   // Add two records before the last record.
   const uint64_t BeforeLast[] = {
     3, NaClMungedBitcode::AddBefore, 21, 22, 23, Terminator,
     3, NaClMungedBitcode::AddBefore, 24, 25, 26, 27, Terminator
   };
-  MungedRecords.munge(ARRAY_ARGS(BeforeLast));
+  MungedRecords.munge(ARRAY_TERM(BeforeLast));
   EXPECT_EQ(
       "       1: [2, 3]\n"
       "      12: [13, 14]\n"
       "      15: [16, 17]\n"
       "      18: [19]\n"
       "       4: [5]\n"
       "       6: [7, 8, 9]\n"
       "      21: [22, 23]\n"
       "      24: [25, 26, 27]\n"
       "      10: [11]\n",
       stringify(MungedRecords));
 }
 
 TEST(NaClMungedBitcodeTest, TestInsertAfter) {
   const uint64_t Records[] = {
     1, 2, 3, Terminator,
     4, 5, Terminator,
     6, 7, 8 , 9, Terminator,
     10, 11, Terminator
   };
-  NaClMungedBitcode MungedRecords(ARRAY_ARGS(Records));
+  NaClMungedBitcode MungedRecords(ARRAY_TERM(Records));
   EXPECT_EQ(
       "       1: [2, 3]\n"
       "       4: [5]\n"
       "       6: [7, 8, 9]\n"
       "      10: [11]\n",
       stringify(MungedRecords));
 
   // Add a record after the second record.
   const uint64_t AfterSecond[] = {
     1, NaClMungedBitcode::AddAfter, 12, 13, 14, Terminator
   };
-  MungedRecords.munge(ARRAY_ARGS(AfterSecond));
+  MungedRecords.munge(ARRAY_TERM(AfterSecond));
   EXPECT_EQ(
       "       1: [2, 3]\n"
       "       4: [5]\n"
       "      12: [13, 14]\n"
       "       6: [7, 8, 9]\n"
       "      10: [11]\n",
       stringify(MungedRecords));
 
   // Add two more records after the second record.
   const uint64_t AfterSecondMore[] = {
     1, NaClMungedBitcode::AddAfter, 15, 16, 17, Terminator,
     1, NaClMungedBitcode::AddAfter, 18, 19, Terminator
   };
-  MungedRecords.munge(ARRAY_ARGS(AfterSecondMore));
+  MungedRecords.munge(ARRAY_TERM(AfterSecondMore));
   EXPECT_EQ(
       "       1: [2, 3]\n"
       "       4: [5]\n"
       "      12: [13, 14]\n"
       "      15: [16, 17]\n"
       "      18: [19]\n"
       "       6: [7, 8, 9]\n"
       "      10: [11]\n",
       stringify(MungedRecords));
 
   // Add two records after the last record.
   const uint64_t AfterLast[] = {
     3, NaClMungedBitcode::AddAfter, 21, 22, 23, Terminator,
     3, NaClMungedBitcode::AddAfter, 24, 25, 26, 27, Terminator
   };
-  MungedRecords.munge(ARRAY_ARGS(AfterLast));
+  MungedRecords.munge(ARRAY_TERM(AfterLast));
   EXPECT_EQ(
       "       1: [2, 3]\n"
       "       4: [5]\n"
       "      12: [13, 14]\n"
       "      15: [16, 17]\n"
       "      18: [19]\n"
       "       6: [7, 8, 9]\n"
       "      10: [11]\n"
       "      21: [22, 23]\n"
       "      24: [25, 26, 27]\n",
       stringify(MungedRecords));
 }
 
 TEST(NaClMungedBitcodeTest, TestRemove) {
   const uint64_t Records[] = {
     1, 2, 3, Terminator,
     4, 5, Terminator,
     6, 7, 8 , 9, Terminator,
     10, 11, Terminator
   };
-  NaClMungedBitcode MungedRecords(ARRAY_ARGS(Records));
+  NaClMungedBitcode MungedRecords(ARRAY_TERM(Records));
   EXPECT_EQ(
       "       1: [2, 3]\n"
       "       4: [5]\n"
       "       6: [7, 8, 9]\n"
       "      10: [11]\n",
       stringify(MungedRecords));
 
   // Remove the second record.
   const uint64_t RemoveSecond[] = {
     1, NaClMungedBitcode::Remove
   };
-  MungedRecords.munge(ARRAY_ARGS(RemoveSecond));
+  MungedRecords.munge(ARRAY_TERM(RemoveSecond));
   EXPECT_EQ(
       "       1: [2, 3]\n"
       "       6: [7, 8, 9]\n"
       "      10: [11]\n",
       stringify(MungedRecords));
 
   // Remove first and last records.
   const uint64_t RemoveEnds[] = {
     0, NaClMungedBitcode::Remove,
     3, NaClMungedBitcode::Remove
   };
-  MungedRecords.munge(ARRAY_ARGS(RemoveEnds));
+  MungedRecords.munge(ARRAY_TERM(RemoveEnds));
   EXPECT_EQ(
       "       6: [7, 8, 9]\n",
       stringify(MungedRecords));
 
   // Remove remaining record.
   const uint64_t RemoveOther[] = {
     2, NaClMungedBitcode::Remove
   };
-  MungedRecords.munge(ARRAY_ARGS(RemoveOther));
+  MungedRecords.munge(ARRAY_TERM(RemoveOther));
   EXPECT_EQ(
       "",
       stringify(MungedRecords));
 }
 
 TEST(NaClMungedBitcodeTest, TestReplace) {
   const uint64_t Records[] = {
     1, 2, 3, Terminator,
     4, 5, Terminator,
     6, 7, 8 , 9, Terminator,
     10, 11, Terminator
   };
-  NaClMungedBitcode MungedRecords(ARRAY_ARGS(Records));
+  NaClMungedBitcode MungedRecords(ARRAY_TERM(Records));
   EXPECT_EQ(
       "       1: [2, 3]\n"
       "       4: [5]\n"
       "       6: [7, 8, 9]\n"
       "      10: [11]\n",
       stringify(MungedRecords));
 
   // Replace the second record.
   const uint64_t ReplaceSecond[] = {
     1, NaClMungedBitcode::Replace, 12, 13, 14, Terminator
   };
-  MungedRecords.munge(ARRAY_ARGS(ReplaceSecond));
+  MungedRecords.munge(ARRAY_TERM(ReplaceSecond));
   EXPECT_EQ(
       "       1: [2, 3]\n"
       "      12: [13, 14]\n"
       "       6: [7, 8, 9]\n"
       "      10: [11]\n",
       stringify(MungedRecords));
 
   // Replace the first and last record.
   const uint64_t ReplaceEnds[] = {
     0, NaClMungedBitcode::Replace, 15, 16, 17, 18, Terminator,
     3, NaClMungedBitcode::Replace, 19, 20, Terminator
   };
-  MungedRecords.munge(ARRAY_ARGS(ReplaceEnds));
+  MungedRecords.munge(ARRAY_TERM(ReplaceEnds));
   EXPECT_EQ(
       "      15: [16, 17, 18]\n"
       "      12: [13, 14]\n"
       "       6: [7, 8, 9]\n"
       "      19: [20]\n",
       stringify(MungedRecords));
 
   // Replace the first three records, which includes two already replaced
   // records.
   const uint64_t ReplaceFirst3[] = {
     0, NaClMungedBitcode::Replace, 21, 22, 23, Terminator,
     1, NaClMungedBitcode::Replace, 24, 25, Terminator,
     2, NaClMungedBitcode::Replace, 26, 27, 28, 29, Terminator
   };
-  MungedRecords.munge(ARRAY_ARGS(ReplaceFirst3));
+  MungedRecords.munge(ARRAY_TERM(ReplaceFirst3));
   EXPECT_EQ(
       "      21: [22, 23]\n"
       "      24: [25]\n"
       "      26: [27, 28, 29]\n"
       "      19: [20]\n",
       stringify(MungedRecords));
 
   // Show that we can remove replaced records.
   const uint64_t RemoveReplaced[] = {
     1, NaClMungedBitcode::Remove,
     3, NaClMungedBitcode::Remove
   };
-  MungedRecords.munge(ARRAY_ARGS(RemoveReplaced));
+  MungedRecords.munge(ARRAY_TERM(RemoveReplaced));
   EXPECT_EQ(
       "      21: [22, 23]\n"
       "      26: [27, 28, 29]\n",
       stringify(MungedRecords));
 }
 
 TEST(NaClMungedBitcodeTest, TestBlockStructure) {
   const uint64_t Records[] = {
     1, 2, 3, 4, Terminator,
     5, naclbitc::BLK_CODE_ENTER, 6, Terminator,
     7, 8, Terminator,
     9, naclbitc::BLK_CODE_ENTER, 10, Terminator,
     11, 12, 13, Terminator,
     14, naclbitc::BLK_CODE_EXIT, Terminator,
     15, naclbitc::BLK_CODE_ENTER, 16, Terminator,
     17, naclbitc::BLK_CODE_EXIT, 18, Terminator,
     19, 20, 21, Terminator,
     22, naclbitc::BLK_CODE_EXIT, Terminator
   };
-  NaClMungedBitcode MungedRecords(ARRAY_ARGS(Records));
+  NaClMungedBitcode MungedRecords(ARRAY_TERM(Records));
   EXPECT_EQ(
       "       1: [2, 3, 4]\n"
       "       5: [65535, 6]\n"
       "         7: [8]\n"
       "         9: [65535, 10]\n"
       "          11: [12, 13]\n"
       "        14: [65534]\n"
       "        15: [65535, 16]\n"
       "        17: [65534, 18]\n"
       "        19: [20, 21]\n"
       "      22: [65534]\n",
       stringify(MungedRecords));
 
   // Show what happens if you have unbalanced blocks.
   const uint64_t ExitEdits[] = {
     4, NaClMungedBitcode::AddAfter, 0, naclbitc::BLK_CODE_EXIT, Terminator,
     4, NaClMungedBitcode::AddAfter, 0, naclbitc::BLK_CODE_EXIT, Terminator,
     2, NaClMungedBitcode::Replace, 0, naclbitc::BLK_CODE_EXIT, Terminator
   };
-  MungedRecords.munge(ARRAY_ARGS(ExitEdits));
+  MungedRecords.munge(ARRAY_TERM(ExitEdits));
   EXPECT_EQ(
       "       1: [2, 3, 4]\n"
       "       5: [65535, 6]\n"
       "       0: [65534]\n"
       "       9: [65535, 10]\n"
       "        11: [12, 13]\n"
       "       0: [65534]\n"
       "       0: [65534]\n"
       "      14: [65534]\n"
       "      15: [65535, 16]\n"
       "      17: [65534, 18]\n"
       "      19: [20, 21]\n"
       "      22: [65534]\n",
       stringify(MungedRecords));
 }
 
 // Tests that replace/remove superceed other replace/removes at same
 // record index.
 TEST(NaClMungedBitcodeTest, TestReplaceRemoveEffects) {
   const uint64_t Records[] = {
     1, 2, 3, Terminator,
     4, 5, Terminator,
     6, 7, 8 , 9, Terminator,
     10, 11, Terminator
   };
-  NaClMungedBitcode MungedRecords(ARRAY_ARGS(Records));
+  NaClMungedBitcode MungedRecords(ARRAY_TERM(Records));
   EXPECT_EQ(
       "       1: [2, 3]\n"
       "       4: [5]\n"
       "       6: [7, 8, 9]\n"
       "      10: [11]\n",
       stringify(MungedRecords));
 
   // Remove the second record.
   const uint64_t RemoveSecond[] = {
     1, NaClMungedBitcode::Remove
   };
-  MungedRecords.munge(ARRAY_ARGS(RemoveSecond));
+  MungedRecords.munge(ARRAY_TERM(RemoveSecond));
   EXPECT_EQ(
       "       1: [2, 3]\n"
       "       6: [7, 8, 9]\n"
       "      10: [11]\n",
       stringify(MungedRecords));
 
   // Try it again. Should have no effect.
-  MungedRecords.munge(ARRAY_ARGS(RemoveSecond));
+  MungedRecords.munge(ARRAY_TERM(RemoveSecond));
   EXPECT_EQ(
       "       1: [2, 3]\n"
       "       6: [7, 8, 9]\n"
       "      10: [11]\n",
       stringify(MungedRecords));
 
   // Override removed record with a replacement.
   const uint64_t ReplaceSecond[] = {
     1, NaClMungedBitcode::Replace, 12, 12, 14, 15, Terminator
   };
-  MungedRecords.munge(ARRAY_ARGS(ReplaceSecond));
+  MungedRecords.munge(ARRAY_TERM(ReplaceSecond));
   EXPECT_EQ(
       "       1: [2, 3]\n"
       "      12: [12, 14, 15]\n"
       "       6: [7, 8, 9]\n"
       "      10: [11]\n",
       stringify(MungedRecords));
 
   // Override replacement with a different replacement.
   const uint64_t ReplaceSecondAgain[] = {
     1, NaClMungedBitcode::Replace, 16, 17, 18, Terminator
   };
-  MungedRecords.munge(ARRAY_ARGS(ReplaceSecondAgain));
+  MungedRecords.munge(ARRAY_TERM(ReplaceSecondAgain));
   EXPECT_EQ(
       "       1: [2, 3]\n"
       "      16: [17, 18]\n"
       "       6: [7, 8, 9]\n"
       "      10: [11]\n",
       stringify(MungedRecords));
 
   // Override replacement with a remove.
-  MungedRecords.munge(ARRAY_ARGS(RemoveSecond));
+  MungedRecords.munge(ARRAY_TERM(RemoveSecond));
   EXPECT_EQ(
       "       1: [2, 3]\n"
       "       6: [7, 8, 9]\n"
       "      10: [11]\n",
       stringify(MungedRecords));
 }
 
 // Show how before/after interact between neighboring indices
 TEST(NaClMungedBitcodeTest, TestBeforeAfterInteraction) {
   const uint64_t Records[] = {
     1, 2, 3, Terminator,
     4, 5, Terminator,
     6, 7, 8 , 9, Terminator,
     10, 11, Terminator
   };
-  NaClMungedBitcode MungedRecords(ARRAY_ARGS(Records));
+  NaClMungedBitcode MungedRecords(ARRAY_TERM(Records));
   EXPECT_EQ(
       "       1: [2, 3]\n"
       "       4: [5]\n"
       "       6: [7, 8, 9]\n"
       "      10: [11]\n",
       stringify(MungedRecords));
 
   // Add record before the third record.
   const uint64_t AddBeforeThird[] = {
     2, NaClMungedBitcode::AddBefore, 12, 13, 14, Terminator
   };
-  MungedRecords.munge(ARRAY_ARGS(AddBeforeThird));
+  MungedRecords.munge(ARRAY_TERM(AddBeforeThird));
   EXPECT_EQ(
       "       1: [2, 3]\n"
       "       4: [5]\n"
       "      12: [13, 14]\n"
       "       6: [7, 8, 9]\n"
       "      10: [11]\n",
       stringify(MungedRecords));
 
   // Add record after the second record.
   const uint64_t AddAfterSecond[] = {
     1, NaClMungedBitcode::AddAfter, 15, 16, 17, 18, Terminator
   };
-  MungedRecords.munge(ARRAY_ARGS(AddAfterSecond));
+  MungedRecords.munge(ARRAY_TERM(AddAfterSecond));
   EXPECT_EQ(
       "       1: [2, 3]\n"
       "       4: [5]\n"
       "      15: [16, 17, 18]\n"
       "      12: [13, 14]\n"
       "       6: [7, 8, 9]\n"
       "      10: [11]\n",
       stringify(MungedRecords));
 
   // Add more records before the third record.
   const uint64_t AddBeforeThirdMore[] = {
     2, NaClMungedBitcode::AddBefore, 19, 20, Terminator,
     2, NaClMungedBitcode::AddBefore, 21, 22, Terminator
   };
-  MungedRecords.munge(ARRAY_ARGS(AddBeforeThirdMore));
+  MungedRecords.munge(ARRAY_TERM(AddBeforeThirdMore));
   EXPECT_EQ(
       "       1: [2, 3]\n"
       "       4: [5]\n"
       "      15: [16, 17, 18]\n"
       "      12: [13, 14]\n"
       "      19: [20]\n"
       "      21: [22]\n"
       "       6: [7, 8, 9]\n"
       "      10: [11]\n",
       stringify(MungedRecords));
 
   // Add more records after the second record.
   const uint64_t AddAfterSecondMore[] = {
     1, NaClMungedBitcode::AddAfter, 23, 24, 25, Terminator,
     1, NaClMungedBitcode::AddAfter, 26, 27, 28, 29, Terminator
   };
-  MungedRecords.munge(ARRAY_ARGS(AddAfterSecondMore));
+  MungedRecords.munge(ARRAY_TERM(AddAfterSecondMore));
   EXPECT_EQ(
       "       1: [2, 3]\n"
       "       4: [5]\n"
       "      15: [16, 17, 18]\n"
       "      23: [24, 25]\n"
       "      26: [27, 28, 29]\n"
       "      12: [13, 14]\n"
       "      19: [20]\n"
       "      21: [22]\n"
       "       6: [7, 8, 9]\n"
       "      10: [11]\n",
       stringify(MungedRecords));
 }
 
 // Do a sample combination of all possible edits.
 TEST(NaClMungedBitcodeTest, CombinationEdits) {
   const uint64_t Records[] = {
     1, 2, 3, Terminator,
     4, 5, Terminator,
     6, 7, 8 , 9, Terminator,
     10, 11, Terminator
   };
 
-  NaClMungedBitcode MungedRecords(ARRAY_ARGS(Records));
+  NaClMungedBitcode MungedRecords(ARRAY_TERM(Records));
   EXPECT_EQ(
       "       1: [2, 3]\n"
       "       4: [5]\n"
       "       6: [7, 8, 9]\n"
       "      10: [11]\n",
       stringify(MungedRecords));
 
   // Remove First
   const uint64_t RemoveFirst[] = {
     0, NaClMungedBitcode::Remove
   };
-  MungedRecords.munge(ARRAY_ARGS(RemoveFirst));
+  MungedRecords.munge(ARRAY_TERM(RemoveFirst));
   EXPECT_EQ(
       "       4: [5]\n"
       "       6: [7, 8, 9]\n"
       "      10: [11]\n",
       stringify(MungedRecords));
 
   // Add records after the first (base) record, which corresponds to
   // before the first record in the munged result.
   const uint64_t AddAfterFirst[] = {
     0, NaClMungedBitcode::AddAfter, 12, 13, 14, Terminator,
     0, NaClMungedBitcode::AddAfter, 15, 16, Terminator
   };
-  MungedRecords.munge(ARRAY_ARGS(AddAfterFirst));
+  MungedRecords.munge(ARRAY_TERM(AddAfterFirst));
   EXPECT_EQ(
       "      12: [13, 14]\n"
       "      15: [16]\n"
       "       4: [5]\n"
       "       6: [7, 8, 9]\n"
       "      10: [11]\n",
       stringify(MungedRecords));
 
   // Add records before the second (base) record, which corresponds to
   // before the third record in the munged result.
   const uint64_t AddBeforeSecond[] = {
     1, NaClMungedBitcode::AddBefore, 17, 18, 19, 20, Terminator,
     1, NaClMungedBitcode::AddBefore, 21, 22, 23, Terminator
   };
-  MungedRecords.munge(ARRAY_ARGS(AddBeforeSecond));
+  MungedRecords.munge(ARRAY_TERM(AddBeforeSecond));
   EXPECT_EQ(
       "      12: [13, 14]\n"
       "      15: [16]\n"
       "      17: [18, 19, 20]\n"
       "      21: [22, 23]\n"
       "       4: [5]\n"
       "       6: [7, 8, 9]\n"
       "      10: [11]\n",
       stringify(MungedRecords));
 
   // Put the first (base) record back, which will also be the first
   // record in the munged result.
   const uint64_t ReplaceFirst[] = {
     0, NaClMungedBitcode::Replace, 1, 2, 3, Terminator
   };
-  MungedRecords.munge(ARRAY_ARGS(ReplaceFirst));
+  MungedRecords.munge(ARRAY_TERM(ReplaceFirst));
   EXPECT_EQ(
       "       1: [2, 3]\n"
       "      12: [13, 14]\n"
       "      15: [16]\n"
       "      17: [18, 19, 20]\n"
       "      21: [22, 23]\n"
       "       4: [5]\n"
       "       6: [7, 8, 9]\n"
       "      10: [11]\n",
       stringify(MungedRecords));
 
   // Add before the first (base) record, which will also be before all
   // other records in the munged result.
   const uint64_t AddBeforeFirst[] = {
     0, NaClMungedBitcode::AddBefore, 24, 25, 26, 27, Terminator,
     0, NaClMungedBitcode::AddBefore, 28, 29, Terminator,
     0, NaClMungedBitcode::AddBefore, 30, 31, 32, Terminator
   };
-  MungedRecords.munge(ARRAY_ARGS(AddBeforeFirst));
+  MungedRecords.munge(ARRAY_TERM(AddBeforeFirst));
   EXPECT_EQ(
       "      24: [25, 26, 27]\n"
       "      28: [29]\n"
       "      30: [31, 32]\n"
       "       1: [2, 3]\n"
       "      12: [13, 14]\n"
       "      15: [16]\n"
       "      17: [18, 19, 20]\n"
       "      21: [22, 23]\n"
       "       4: [5]\n"
       "       6: [7, 8, 9]\n"
       "      10: [11]\n",
       stringify(MungedRecords));
 }
 
-} // end of namespace NaClMungedBc
+} // end of namespace naclmungetest