Revert name changes of PelotonTest and PelotonCodeGenTest

Author: tcm-marcel

Diff for: test/binder/binder_test.cpp

@@ -37,17 +37,17 @@ using std::vector;
 namespace peloton {
 namespace test {
 
-class BinderCorrectnessTests : public PelotonTests {
+class BinderCorrectnessTests : public PelotonTest {
   virtual void SetUp() override {
-    PelotonTests::SetUp();
+    PelotonTest::SetUp();
     catalog::Catalog::GetInstance();
     // NOTE: Catalog::GetInstance()->Bootstrap(), you can only call it once!
     TestingExecutorUtil::InitializeDatabase(DEFAULT_DB_NAME);
   }
 
   virtual void TearDown() override {
     TestingExecutorUtil::DeleteDatabase(DEFAULT_DB_NAME);
-    PelotonTests::TearDown();
+    PelotonTest::TearDown();
   }
 };
 

Diff for: test/brain/query_clusterer_test.cpp

@@ -52,7 +52,7 @@ bool ClusterCorrectness(std::set<brain::Cluster *> clusters,
   return check;
 }
 
-class QueryClustererTests : public PelotonTests {};
+class QueryClustererTests : public PelotonTest {};
 
 TEST_F(QueryClustererTests, ClusterTest) {
   int num_features = 5;

Diff for: test/brain/query_logger_test.cpp

@@ -19,7 +19,7 @@
 namespace peloton {
 namespace test {
 
-class QueryLoggerTests : public PelotonTests {
+class QueryLoggerTests : public PelotonTest {
  protected:
   void SetUp() override {
     settings::SettingsManager::SetBool(settings::SettingId::brain, true);

Diff for: test/brain/tensorflow_test.cpp

@@ -26,7 +26,7 @@ namespace test {
 // Tensorflow Tests
 //===--------------------------------------------------------------------===//
 
-class TensorflowTests : public PelotonTests {};
+class TensorflowTests : public PelotonTest {};
 
 TEST_F(TensorflowTests, BasicTFTest) {
   // Check that the tensorflow library imports and prints version info correctly

Diff for: test/catalog/catalog_test.cpp

@@ -33,7 +33,7 @@ namespace test {
 // Catalog Tests
 //===--------------------------------------------------------------------===//
 
-class CatalogTests : public PelotonTests {};
+class CatalogTests : public PelotonTest {};
 
 TEST_F(CatalogTests, BootstrappingCatalogTest) {
   auto catalog = catalog::Catalog::GetInstance();

Diff for: test/catalog/constraints_test.cpp

@@ -38,7 +38,7 @@ namespace test {
 // Constraints Tests
 //===--------------------------------------------------------------------===//
 
-class ConstraintsTests : public PelotonTests {};
+class ConstraintsTests : public PelotonTest {};
 
 #ifdef CONSTRAINT_NOTNULL_TEST
 TEST_F(ConstraintsTests, NOTNULLTest) {

Diff for: test/catalog/manager_test.cpp

@@ -26,7 +26,7 @@ namespace test {
 // Manager Tests
 //===--------------------------------------------------------------------===//
 
-class ManagerTests : public PelotonTests {};
+class ManagerTests : public PelotonTest {};
 
 void AddTileGroup(UNUSED_ATTRIBUTE uint64_t thread_id) {
   // TILES

Diff for: test/catalog/tuple_schema_test.cpp

@@ -21,7 +21,7 @@ namespace test {
 // Tuple Schema Tests
 //===--------------------------------------------------------------------===//
 
-class TupleSchemaTests : public PelotonTests {};
+class TupleSchemaTests : public PelotonTest {};
 
 TEST_F(TupleSchemaTests, ColumnInfoTest) {
   std::vector<catalog::Column> columns;

Diff for: test/codegen/bloom_filter_test.cpp

@@ -36,7 +36,7 @@
 namespace peloton {
 namespace test {
 
-class BloomFilterCodegenTests : public PelotonTests {
+class BloomFilterCodegenTests : public PelotonTest {
  public:
   BloomFilterCodegenTests() {
     // Create test db

Diff for: test/codegen/function_builder_test.cpp

@@ -18,7 +18,7 @@
 namespace peloton {
 namespace test {
 
-class FunctionBuilderTests : public PelotonTests {};
+class FunctionBuilderTests : public PelotonTest {};
 
 TEST_F(FunctionBuilderTests, ConstructSingleFunctionTest) {
   // Generate a function like so:

Diff for: test/codegen/if_test.cpp

@@ -23,7 +23,7 @@
 namespace peloton {
 namespace test {
 
-class IfTests : public PelotonTests {};
+class IfTests : public PelotonTest {};
 
 TEST_F(IfTests, IfOnlyTest) {
   const std::string func_name = "TestIfOnly";

Diff for: test/codegen/oa_hash_table_test.cpp

@@ -22,7 +22,7 @@
 namespace peloton {
 namespace test {
 
-class OAHashTableTests : public PelotonTests {
+class OAHashTableTests : public PelotonTest {
  public:
   // The key and value object we store in the hash table
   struct Key {

Diff for: test/codegen/sorter_test.cpp

@@ -34,7 +34,7 @@ static int CompareTuplesForAscending(const char *a, const char *b) {
   return at->col_b - bt->col_b;
 }
 
-class SorterTests : public PelotonTests {
+class SorterTests : public PelotonTest {
  public:
   SorterTests() {
     // Init

Diff for: test/common/cache_test.cpp

@@ -26,7 +26,7 @@ namespace test {
 // Cache Test
 //===--------------------------------------------------------------------===//
 
-class CacheTests : public PelotonTests {};
+class CacheTests : public PelotonTest {};
 
 #define CACHE_SIZE 5
 

Diff for: test/common/container_tuple_test.cpp

@@ -23,7 +23,7 @@
 namespace peloton {
 namespace test {
 
-class ContainerTupleTests : public PelotonTests {};
+class ContainerTupleTests : public PelotonTest {};
 
 TEST_F(ContainerTupleTests, VectorValueTest) {
   std::vector<type::Value> values;

Diff for: test/common/cuckoo_map_test.cpp

@@ -21,7 +21,7 @@ namespace test {
 // Cuckoo Map Test
 //===--------------------------------------------------------------------===//
 
-class CuckooMapTests : public PelotonTests {};
+class CuckooMapTests : public PelotonTest {};
 
 // Test basic functionality
 TEST_F(CuckooMapTests, BasicTest) {

Diff for: test/common/internal_types_test.cpp

@@ -24,7 +24,7 @@ namespace test {
 // Internal Types Test
 //===--------------------------------------------------------------------===//
 
-class InternalTypesTests : public PelotonTests {};
+class InternalTypesTests : public PelotonTest {};
 
 TEST_F(InternalTypesTests, DatePartTypeTest) {
   std::vector<DatePartType> list = {

Diff for: test/common/lock_free_array_test.cpp

@@ -21,7 +21,7 @@ namespace test {
 // LockFreeArray Test
 //===--------------------------------------------------------------------===//
 
-class LockFreeArrayTests : public PelotonTests {};
+class LockFreeArrayTests : public PelotonTest {};
 
 // Test basic functionality
 TEST_F(LockFreeArrayTests, BasicTest) {

Diff for: test/common/logger_test.cpp

@@ -20,7 +20,7 @@ namespace test {
 // Logger Tests
 //===--------------------------------------------------------------------===//
 
-class LoggerTests : public PelotonTests {};
+class LoggerTests : public PelotonTest {};
 
 TEST_F(LoggerTests, BasicTest) {
   LOG_TRACE("trace message");

Diff for: test/common/statement_cache_manager_test.cpp

@@ -19,7 +19,7 @@
 namespace peloton {
 namespace test {
 // Tests for both statement cache
-class StatementCacheTests : public PelotonTests {};
+class StatementCacheTests : public PelotonTest {};
 
 TEST_F(StatementCacheTests, InvalidateOneTest) {
   // Register the statement cache to the statement cache manager

Diff for: test/common/statement_cache_test.cpp

@@ -18,7 +18,7 @@
 namespace peloton {
 namespace test {
 // Tests for both statement cache
-class StatementCacheTests : public PelotonTests {};
+class StatementCacheTests : public PelotonTest {};
 
 // Test statementCache add and get statement
 TEST_F(StatementCacheTests, AddGetTest) {

Diff for: test/common/thread_pool_test.cpp

@@ -20,7 +20,7 @@ namespace test {
 // Thread Pool Test
 //===--------------------------------------------------------------------===//
 
-class ThreadPoolTests : public PelotonTests {};
+class ThreadPoolTests : public PelotonTest {};
 
 TEST_F(ThreadPoolTests, BasicTest) {
   ThreadPool thread_pool;

Diff for: test/concurrency/anomaly_test.cpp

@@ -22,7 +22,7 @@ namespace test {
 // These test cases are based on the paper:
 // -- "A Critique of ANSI SQL Isolation Levels"
 
-class AnomalyTests : public PelotonTests {};
+class AnomalyTests : public PelotonTest {};
 
 static std::vector<ProtocolType> PROTOCOL_TYPES = {
     ProtocolType::TIMESTAMP_ORDERING};

Diff for: test/concurrency/decentralized_epoch_manager_test.cpp

@@ -21,7 +21,7 @@ namespace test {
 // TransactionContext Tests
 //===--------------------------------------------------------------------===//
 
-class DecentralizedEpochManagerTests : public PelotonTests {};
+class DecentralizedEpochManagerTests : public PelotonTest {};
 
 TEST_F(DecentralizedEpochManagerTests, Test) {
   concurrency::EpochManagerFactory::Configure(EpochType::DECENTRALIZED_EPOCH);

Diff for: test/concurrency/local_epoch_test.cpp

@@ -20,7 +20,7 @@ namespace test {
 // TransactionContext Tests
 //===--------------------------------------------------------------------===//
 
-class LocalEpochTests : public PelotonTests {};
+class LocalEpochTests : public PelotonTest {};
 
 TEST_F(LocalEpochTests, EpochCompareTest) {
   concurrency::EpochCompare comp;

Diff for: test/concurrency/multi_granularity_access_test.cpp

@@ -20,7 +20,7 @@ namespace test {
 // Multi-Granularity Access Tests
 //===--------------------------------------------------------------------===//
 
-class MultiGranularityAccessTests : public PelotonTests {};
+class MultiGranularityAccessTests : public PelotonTest {};
 
 static std::vector<ProtocolType> PROTOCOL_TYPES = {
     ProtocolType::TIMESTAMP_ORDERING};

Diff for: test/concurrency/mvcc_test.cpp

@@ -23,7 +23,7 @@ namespace test {
 // TransactionContext Tests
 //===--------------------------------------------------------------------===//
 
-class MVCCTests : public PelotonTests {};
+class MVCCTests : public PelotonTest {};
 
 static std::vector<ProtocolType> PROTOCOL_TYPES = {
     ProtocolType::TIMESTAMP_ORDERING};

Diff for: test/concurrency/serializable_transaction_test.cpp

@@ -20,7 +20,7 @@ namespace test {
 // Serializable TransactionContext Tests
 //===--------------------------------------------------------------------===//
 
-class SerializableTransactionTests : public PelotonTests {};
+class SerializableTransactionTests : public PelotonTest {};
 
 static std::vector<ProtocolType> PROTOCOL_TYPES = {
     ProtocolType::TIMESTAMP_ORDERING};

Diff for: test/concurrency/timestamp_ordering_transaction_manager_test.cpp

@@ -22,7 +22,7 @@ namespace test {
 // TransactionContext Tests
 //===--------------------------------------------------------------------===//
 
-class TimestampOrderingTransactionManagerTests : public PelotonTests {};
+class TimestampOrderingTransactionManagerTests : public PelotonTest {};
 
 TEST_F(TimestampOrderingTransactionManagerTests, Test) {
   concurrency::TransactionManagerFactory::Configure(

Diff for: test/executor/aggregate_test.cpp

@@ -38,7 +38,7 @@ using ::testing::Return;
 namespace peloton {
 namespace test {
 
-class AggregateTests : public PelotonTests {};
+class AggregateTests : public PelotonTest {};
 
 TEST_F(AggregateTests, SortedDistinctTest) {
   // SELECT d, a, b, c FROM table GROUP BY a, b, c, d;

Diff for: test/executor/append_test.cpp

@@ -34,7 +34,7 @@ namespace test {
 
 namespace {
 
-class AppendTests : public PelotonTests {};
+class AppendTests : public PelotonTest {};
 
 void RunTest(executor::AppendExecutor &executor, size_t expected_num_tuples) {
   EXPECT_TRUE(executor.Init());

Diff for: test/executor/copy_test.cpp

@@ -36,7 +36,7 @@ namespace test {
 // Copy Tests
 //===--------------------------------------------------------------------===//
 
-class CopyTests : public PelotonTests {};
+class CopyTests : public PelotonTest {};
 
 TEST_F(CopyTests, CopyingTest) {
   auto catalog = catalog::Catalog::GetInstance();

Diff for: test/executor/create_index_test.cpp

@@ -43,7 +43,7 @@ namespace test {
 // Catalog Tests
 //===--------------------------------------------------------------------===//
 
-class CreateIndexTests : public PelotonTests {};
+class CreateIndexTests : public PelotonTest {};
 
 TEST_F(CreateIndexTests, CreatingIndexTest) {
   LOG_INFO("Bootstrapping...");

Diff for: test/executor/create_test.cpp

@@ -39,7 +39,7 @@ namespace test {
 // Catalog Tests
 //===--------------------------------------------------------------------===//
 
-class CreateTests : public PelotonTests {};
+class CreateTests : public PelotonTest {};
 
 TEST_F(CreateTests, CreatingDBTest) {
   // Bootstrap

Diff for: test/executor/delete_test.cpp

@@ -42,7 +42,7 @@ namespace test {
 // Catalog Tests
 //===--------------------------------------------------------------------===//
 
-class DeleteTests : public PelotonTests {};
+class DeleteTests : public PelotonTest {};
 
 void ShowTable(std::string database_name, std::string table_name) {
   // auto table =

Diff for: test/executor/drop_test.cpp

@@ -35,7 +35,7 @@ namespace test {
 // Catalog Tests
 //===--------------------------------------------------------------------===//
 
-class DropTests : public PelotonTests {};
+class DropTests : public PelotonTest {};
 
 TEST_F(DropTests, DroppingDatabaseTest) {
   auto catalog = catalog::Catalog::GetInstance();

Diff for: test/executor/hash_set_op_test.cpp

@@ -32,7 +32,7 @@ using ::testing::Return;
 namespace peloton {
 namespace test {
 
-class HashSetOptTests : public PelotonTests {};
+class HashSetOptTests : public PelotonTest {};
 
 namespace {
 

Diff for: test/executor/index_scan_test.cpp

@@ -41,7 +41,7 @@ using ::testing::Return;
 namespace peloton {
 namespace test {
 
-class IndexScanTests : public PelotonTests {};
+class IndexScanTests : public PelotonTest {};
 
 // Index scan of table with index predicate.
 TEST_F(IndexScanTests, IndexPredicateTest) {

Diff for: test/executor/insert_test.cpp

@@ -31,7 +31,7 @@ namespace test {
 // Catalog Tests
 //===--------------------------------------------------------------------===//
 
-class InsertTests : public PelotonTests {};
+class InsertTests : public PelotonTest {};
 
 TEST_F(InsertTests, InsertRecordTest) {
   catalog::Catalog::GetInstance();

Diff for: test/executor/join_test.cpp

@@ -52,7 +52,7 @@ using ::testing::InSequence;
 namespace peloton {
 namespace test {
 
-class JoinTests : public PelotonTests {};
+class JoinTests : public PelotonTest {};
 
 std::vector<planner::MergeJoinPlan::JoinClause> CreateJoinClauses() {
   std::vector<planner::MergeJoinPlan::JoinClause> join_clauses;

Diff for: test/executor/limit_test.cpp

@@ -36,7 +36,7 @@ using ::testing::Return;
 namespace peloton {
 namespace test {
 
-class LimitTests : public PelotonTests {};
+class LimitTests : public PelotonTest {};
 
 namespace {
 

Diff for: test/executor/loader_test.cpp

@@ -48,7 +48,7 @@ namespace test {
 // Loader Tests
 //===--------------------------------------------------------------------===//
 
-class LoaderTests : public PelotonTests {};
+class LoaderTests : public PelotonTest {};
 
 std::atomic<int> loader_tuple_id;
 

Diff for: test/executor/logical_tile_test.cpp

@@ -38,7 +38,7 @@ namespace test {
 // Logical Tile Tests
 //===--------------------------------------------------------------------===//
 
-class LogicalTileTests : public PelotonTests {};
+class LogicalTileTests : public PelotonTest {};
 
 TEST_F(LogicalTileTests, TempTableTest) {
   const int tuple_count = TESTS_TUPLES_PER_TILEGROUP;