[llvm-exegesis][NFC] Refactor Mips tests fixtures into a base class

[atanasyan]

llvm/unittests/tools/llvm-exegesis/Mips/BenchmarkResultTest.cpp

58

This comment looks orphaned.

llvm/unittests/tools/llvm-exegesis/Mips/CMakeLists.txt

18

This change comes from the D72004

[mstojanovic]

Removed leftover lines.

llvm/unittests/tools/llvm-exegesis/Mips/BenchmarkResultTest.cpp

 //===-- BenchmarkResultTest.cpp ---------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "BenchmarkResult.h"
 #include "MipsInstrInfo.h"
+#include "TestBase.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/Support/raw_ostream.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 using ::testing::AllOf;
 using ::testing::Eq;
 using ::testing::get;
 using ::testing::Pointwise;
 using ::testing::Property;
 
 namespace llvm {
 namespace exegesis {
 
-void InitializeMipsExegesisTarget();
-
 bool operator==(const BenchmarkMeasure &A, const BenchmarkMeasure &B) {
   return std::tie(A.Key, A.PerInstructionValue, A.PerSnippetValue) ==
          std::tie(B.Key, B.PerInstructionValue, B.PerSnippetValue);
 }
 
 static std::string Dump(const MCInst &McInst) {
   std::string Buffer;
   raw_string_ostream OS(Buffer);
   McInst.print(OS);
   return Buffer;
 }
 
 MATCHER(EqMCInst, "") {
   const std::string Lhs = Dump(get<0>(arg));
   const std::string Rhs = Dump(get<1>(arg));
   if (Lhs != Rhs) {
     *result_listener << Lhs << " <=> " << Rhs;
     return false;
   }
   return true;
 }
 
 namespace {
 
-TEST(BenchmarkResultTest, WriteToAndReadFromDisk) {
-  LLVMInitializeMipsTargetInfo();
-  LLVMInitializeMipsTarget();
-  LLVMInitializeMipsTargetMC();
-  InitializeMipsExegesisTarget();
+class BenchmarkResultTest : public MipsTestBase {};
 
+TEST_F(BenchmarkResultTest, WriteToAndReadFromDisk) {
   // Read benchmarks.
-  const LLVMState State("mips-unknown-linux", "mips32");
-
   ExitOnError ExitOnErr;
 
   InstructionBenchmark ToDisk;
 
   ToDisk.Key.Instructions.push_back(MCInstBuilder(Mips::XOR)
                                         .addReg(Mips::T0)
                                         .addReg(Mips::T1)
                                         .addReg(Mips::T2));
ExitOnErr(ToDisk.writeYaml(State, Filename));
     EXPECT_EQ(FromDisk.LLVMTriple, ToDisk.LLVMTriple);
     EXPECT_EQ(FromDisk.NumRepetitions, ToDisk.NumRepetitions);
     EXPECT_THAT(FromDisk.Measurements, ToDisk.Measurements);
     EXPECT_THAT(FromDisk.Error, ToDisk.Error);
     EXPECT_EQ(FromDisk.Info, ToDisk.Info);
   }
 }
 
-TEST(BenchmarkResultTest, PerInstructionStats) {
+TEST_F(BenchmarkResultTest, PerInstructionStats) {
   PerInstructionStats Stats;
   Stats.push(BenchmarkMeasure{"a", 0.5, 0.0});
   Stats.push(BenchmarkMeasure{"a", 1.5, 0.0});
   Stats.push(BenchmarkMeasure{"a", -1.0, 0.0});
   Stats.push(BenchmarkMeasure{"a", 0.0, 0.0});
   EXPECT_EQ(Stats.min(), -1.0);
   EXPECT_EQ(Stats.max(), 1.5);
   EXPECT_EQ(Stats.avg(), 0.25); // (0.5+1.5-1.0+0.0) / 4
 }
 } // namespace
 } // namespace exegesis
 } // namespace llvm

llvm/unittests/tools/llvm-exegesis/Mips/CMakeLists.txt

set(LLVM_LINK_COMPONENTS
   Object
   Support
   Symbolize
   Mips
   )
 
 add_llvm_unittest(LLVMExegesisMipsTests
   BenchmarkResultTest.cpp
+  RegisterAliasingTest.cpp
   SnippetGeneratorTest.cpp
   TargetTest.cpp
   )
 target_link_libraries(LLVMExegesisMipsTests PRIVATE
   LLVMExegesis
   LLVMExegesisMips)

llvm/unittests/tools/llvm-exegesis/Mips/SnippetGeneratorTest.cpp

 //===-- SnippetGeneratorTest.cpp --------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "../Common/AssemblerUtils.h"
 #include "Latency.h"
 #include "LlvmState.h"
 #include "MCInstrDescView.h"
-#include "RegisterAliasing.h"
 #include "MipsInstrInfo.h"
+#include "RegisterAliasing.h"
+#include "TestBase.h"
 
 #include <unordered_set>
 
 namespace llvm {
 namespace exegesis {
-
-void InitializeMipsExegesisTarget();
-
 namespace {
 
 using testing::AnyOf;
 using testing::ElementsAre;
 using testing::SizeIs;
 
 MATCHER(IsInvalid, "") { return !arg.isValid(); }
 MATCHER(IsReg, "") { return arg.isReg(); }
 
-class MipsSnippetGeneratorTest : public ::testing::Test {
-protected:
-  MipsSnippetGeneratorTest() : State("mips-unknown-linux", "mips32"),
-  InstrInfo(State.getInstrInfo()) {}
-
-  static void SetUpTestCase() {
-    LLVMInitializeMipsTargetInfo();
-    LLVMInitializeMipsTarget();
-    LLVMInitializeMipsTargetMC();
-    InitializeMipsExegesisTarget();
-  }
-
-  LLVMState State;
-  const MCInstrInfo &InstrInfo;
-};
+class MipsSnippetGeneratorTest : public MipsTestBase {};
 
 template <typename SnippetGeneratorT>
 class SnippetGeneratorTest : public MipsSnippetGeneratorTest {
 protected:
   SnippetGeneratorTest() : Generator(State, SnippetGenerator::Options()) {}
 
   std::vector<CodeTemplate> checkAndGetCodeTemplates(unsigned Opcode) {
     randomGenerator().seed(0); // Initialize seed.

llvm/unittests/tools/llvm-exegesis/Mips/TargetTest.cpp

 //===-- TargetTest.cpp ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Target.h"
 
 #include <cassert>
 #include <memory>
 
 #include "MCTargetDesc/MipsMCTargetDesc.h"
+#include "TestBase.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 namespace llvm {
 namespace exegesis {
-
-void InitializeMipsExegesisTarget();
-
 namespace {
 
 using testing::AllOf;
 using testing::ElementsAre;
 using testing::Eq;
 using testing::Matcher;
 using testing::Property;
 
Matcher<MCInst> OpcodeIs(unsigned Opcode) {
   return Property(&MCInst::getOpcode, Eq(Opcode));
 }
 
 Matcher<MCInst> IsLoadLowImm(int64_t Reg, int64_t Value) {
   return AllOf(OpcodeIs(Mips::ORi),
                ElementsAre(IsReg(Reg), IsReg(Mips::ZERO), IsImm(Value)));
 }
 
-constexpr const char kTriple[] = "mips-unknown-linux";
-
-class MipsTargetTest : public ::testing::Test {
+class MipsTargetTest : public MipsTestBase {
 protected:
-  MipsTargetTest() : State(kTriple, "mips32", "") {}
-
-  static void SetUpTestCase() {
-    LLVMInitializeMipsTargetInfo();
-    LLVMInitializeMipsTarget();
-    LLVMInitializeMipsTargetMC();
-    InitializeMipsExegesisTarget();
-  }
-
   std::vector<MCInst> setRegTo(unsigned Reg, const APInt &Value) {
     return State.getExegesisTarget().setRegTo(State.getSubtargetInfo(), Reg,
                                               Value);
   }
-
-  LLVMState State;
 };
 
 TEST_F(MipsTargetTest, SetRegToConstant) {
   const uint16_t Value = 0xFFFFU;
   const unsigned Reg = Mips::T0;
   EXPECT_THAT(setRegTo(Reg, APInt(16, Value)),
               ElementsAre(IsLoadLowImm(Reg, Value)));
 }

llvm/unittests/tools/llvm-exegesis/Mips/TestBase.h

+//===-- TestBase.h ----------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+// Test fixture common to all Mips tests.
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_UNITTESTS_TOOLS_LLVMEXEGESIS_MIPS_TESTBASE_H
+#define LLVM_UNITTESTS_TOOLS_LLVMEXEGESIS_MIPS_TESTBASE_H
+
+#include "LlvmState.h"
+#include "llvm/Support/TargetRegistry.h"
+#include "llvm/Support/TargetSelect.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+namespace llvm {
+namespace exegesis {
+
+void InitializeMipsExegesisTarget();
+
+class MipsTestBase : public ::testing::Test {
+protected:
+  MipsTestBase() : State("mips-unknown-linux", "mips32") {}
+
+  static void SetUpTestCase() {
+    LLVMInitializeMipsTargetInfo();
+    LLVMInitializeMipsTargetMC();
+    LLVMInitializeMipsTarget();
+    InitializeMipsExegesisTarget();
+  }
+
+  const LLVMState State;
+};
+
+} // namespace exegesis
+} // namespace llvm
+
+#endif