Fix scattered discrepencies

Author: schedutron

test/binder/binder_test.cpp

@@ -39,15 +39,15 @@ namespace test {
 
 class BinderCorrectnessTests : public PelotonTests {
   virtual void SetUp() override {
-    PelotonTest::SetUp();
+    PelotonTests::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);
-    PelotonTest::TearDown();
+    PelotonTests::TearDown();
   }
 };
 

test/catalog/tuple_schema_test.cpp

@@ -45,7 +45,7 @@ TEST_F(TupleSchemaTests, ColumnInfoTest) {
 }
 
 /*
- * TupleSchemaFilteringTest() - Tests FilterSchema() which uses a set
+ * TupleSchemaFilteringTests() - Tests FilterSchema() which uses a set
  */
 TEST_F(TupleSchemaTests, TupleSchemaFilteringTest) {
   std::vector<catalog::Column> columns;
@@ -115,7 +115,7 @@ TEST_F(TupleSchemaTests, TupleSchemaFilteringTest) {
 }
 
 /*
- * TupleSchemaCopyTest() - Tests CopySchema() which uses a list of indices
+ * TupleSchemaCopyTests() - Tests CopySchema() which uses a list of indices
  */
 TEST_F(TupleSchemaTests, TupleSchemaCopyTest) {
   std::vector<catalog::Column> columns;

test/codegen/block_nested_loop_join_translator_test.cpp

@@ -23,7 +23,7 @@ namespace test {
 
 class BlockNestedLoopJoinTranslatorTests : public PelotonCodeGenTests {
  public:
-  BlockNestedLoopJoinTranslatorTest() : PelotonCodeGenTest() {
+  BlockNestedLoopJoinTranslatorTests() : PelotonCodeGenTests() {
     // Load the test table
     uint32_t num_rows = 10;
     LoadTestTable(LeftTableId(), 2 * num_rows);
@@ -59,7 +59,7 @@ class BlockNestedLoopJoinTranslatorTests : public PelotonCodeGenTests {
   type::Value GetCol(const AbstractTuple &t, JoinOutputColPos p);
 };
 
-void BlockNestedLoopJoinTranslatorTest::PerformTest(
+void BlockNestedLoopJoinTranslatorTests::PerformTest(
     ExpressionPtr &&predicate, const std::vector<oid_t> &left_join_cols,
     const std::vector<oid_t> &right_join_cols,
     std::vector<codegen::WrappedTuple> &results) {
@@ -102,8 +102,8 @@ void BlockNestedLoopJoinTranslatorTest::PerformTest(
   results = buffer.GetOutputTuples();
 }
 
-type::Value BlockNestedLoopJoinTranslatorTest::GetCol(const AbstractTuple &t,
-                                                      JoinOutputColPos p) {
+type::Value BlockNestedLoopJoinTranslatorTests::GetCol(const AbstractTuple &t,
+                                                       JoinOutputColPos p) {
   return t.GetValue(static_cast<oid_t>(p));
 }
 

test/codegen/bloom_filter_test.cpp

@@ -38,15 +38,15 @@ namespace test {
 
 class BloomFilterCodegenTests : public PelotonTests {
  public:
-  BloomFilterCodegenTest() {
+  BloomFilterCodegenTests() {
     // Create test db
     auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance();
     auto txn = txn_manager.BeginTransaction();
     catalog::Catalog::GetInstance()->CreateDatabase(DEFAULT_DB_NAME, txn);
     txn_manager.CommitTransaction(txn);
   }
 
-  ~BloomFilterCodegenTest() {
+  ~BloomFilterCodegenTests() {
     // Drop test db
     auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance();
     auto txn = txn_manager.BeginTransaction();
@@ -276,11 +276,9 @@ TEST_F(BloomFilterCodegenTests, PerformanceTest) {
   txn_manager.CommitTransaction(txn);
 }
 
-double BloomFilterCodegenTest::ExecuteJoin(std::string query,
-                                           concurrency::TransactionContext *txn,
-                                           int num_iter,
-                                           unsigned inner_table_cardinality,
-                                           bool enable_bloom_filter) {
+double BloomFilterCodegenTests::ExecuteJoin(
+    std::string query, concurrency::TransactionContext *txn, int num_iter,
+    unsigned inner_table_cardinality, bool enable_bloom_filter) {
   std::unique_ptr<optimizer::AbstractOptimizer> optimizer(
       new optimizer::Optimizer());
   double total_runtime = 0;
@@ -310,8 +308,8 @@ double BloomFilterCodegenTest::ExecuteJoin(std::string query,
         *plan, executor_context->GetParams().GetQueryParametersMap(), consumer);
 
     // Run
-    PelotonCodeGenTest::ExecuteSync(*compiled_query,
-                                    std::move(executor_context), consumer);
+    PelotonCodeGenTests::ExecuteSync(*compiled_query,
+                                     std::move(executor_context), consumer);
 
     LOG_INFO("Execution Time: %0.0f ms", stats.plan_ms);
     total_runtime += stats.plan_ms;
@@ -321,8 +319,9 @@ double BloomFilterCodegenTest::ExecuteJoin(std::string query,
 
 // Create a table where all the columns are BIGINT and each tuple has desired
 // tuple size
-void BloomFilterCodegenTest::CreateTable(std::string table_name, int tuple_size,
-                                         concurrency::TransactionContext *txn) {
+void BloomFilterCodegenTests::CreateTable(
+    std::string table_name, int tuple_size,
+    concurrency::TransactionContext *txn) {
   int curr_size = 0;
   size_t bigint_size = type::Type::GetTypeSize(type::TypeId::BIGINT);
   std::vector<catalog::Column> cols;
@@ -339,9 +338,9 @@ void BloomFilterCodegenTest::CreateTable(std::string table_name, int tuple_size,
 }
 
 // Insert a tuple to specific table
-void BloomFilterCodegenTest::InsertTuple(const std::vector<int> &vals,
-                                         storage::DataTable *table,
-                                         concurrency::TransactionContext *txn) {
+void BloomFilterCodegenTests::InsertTuple(
+    const std::vector<int> &vals, storage::DataTable *table,
+    concurrency::TransactionContext *txn) {
   auto &txn_manager = concurrency::TransactionManagerFactory::GetInstance();
   storage::Tuple tuple{table->GetSchema(), true};
   for (unsigned i = 0; i < vals.size(); i++) {

test/codegen/case_translator_test.cpp

@@ -27,7 +27,7 @@ namespace test {
 
 class CaseTranslatorTests : public PelotonCodeGenTests {
  public:
-  CaseTranslatorTest() : PelotonCodeGenTest(), num_rows_to_insert(64) {
+  CaseTranslatorTests() : PelotonCodeGenTests(), num_rows_to_insert(64) {
     // Load test table
     LoadTestTable(TestTableId(), num_rows_to_insert);
   }

test/codegen/delete_translator_test.cpp

@@ -25,7 +25,7 @@ namespace test {
 
 class DeleteTranslatorTests : public PelotonCodeGenTests {
  public:
-  DeleteTranslatorTest() : PelotonCodeGenTest() {}
+  DeleteTranslatorTests() : PelotonCodeGenTests() {}
 
   size_t GetCurrentTableSize(oid_t table_id) {
     planner::SeqScanPlan scan{&GetTestTable(table_id), nullptr, {0, 1}};

test/codegen/group_by_translator_test.cpp

@@ -27,7 +27,7 @@ namespace test {
 
 class GroupByTranslatorTests : public PelotonCodeGenTests {
  public:
-  GroupByTranslatorTest() : PelotonCodeGenTest() {
+  GroupByTranslatorTests() : PelotonCodeGenTests() {
     uint32_t num_rows = 10;
     LoadTestTable(TestTableId(), num_rows);
   }

test/codegen/hash_join_translator_test.cpp

@@ -27,7 +27,7 @@ namespace test {
 
 class HashJoinTranslatorTests : public PelotonCodeGenTests {
  public:
-  HashJoinTranslatorTest() : PelotonCodeGenTest() {
+  HashJoinTranslatorTests() : PelotonCodeGenTests() {
     // Load the test table
     uint32_t num_rows = 10;
     LoadTestTable(LeftTableId(), 2 * num_rows);

test/codegen/insert_translator_test.cpp

@@ -24,7 +24,7 @@ namespace test {
 
 class InsertTranslatorTests : public PelotonCodeGenTests {
  public:
-  InsertTranslatorTest() : PelotonCodeGenTest() {}
+  InsertTranslatorTests() : PelotonCodeGenTests() {}
   oid_t TestTableId1() { return test_table_oids[0]; }
   oid_t TestTableId2() { return test_table_oids[1]; }
 };

test/codegen/oa_hash_table_test.cpp

@@ -42,12 +42,12 @@ class OAHashTableTests : public PelotonTests {
     bool operator!=(const Value &rhs) const { return !(rhs == *this); }
   };
 
-  OAHashTableTest() {
+  OAHashTableTests() {
     PELOTON_MEMSET(raw_hash_table, 1, sizeof(raw_hash_table));
     GetHashTable().Init(sizeof(Key), sizeof(Value));
   }
 
-  ~OAHashTableTest() {
+  ~OAHashTableTests() {
     // Clean up
     GetHashTable().Destroy();
   }
@@ -145,67 +145,68 @@ TEST_F(OAHashTableTests, CanIterateTest) {
   EXPECT_EQ(3, dup_count);
 }
 
-TEST_F(OAHashTableTests, CanCodegenProbeOrInsertTest) {
-  TEST_F(OAHashTableTests, MicroBenchmarkTest) {
-    uint32_t num_runs = 10;
+TEST_F(OAHashTableTests, CanCodegenProbeOrInsertTest) {}
 
-    std::vector<Key> keys;
-    Value v = {6, 5, 4, 3};
+TEST_F(OAHashTableTests, MicroBenchmarkTest) {
+  uint32_t num_runs = 10;
 
-    // Create all keys
-    uint32_t num_keys = 100000;
-    for (uint32_t i = 0; i < num_keys; i++) {
-      keys.push_back({1, static_cast<uint32_t>(rand())});
-    }
-
-    double avg_oaht = 0.0;
-    double avg_map = 0.0;
+  std::vector<Key> keys;
+  Value v = {6, 5, 4, 3};
 
-    // First, bench ours ...
-    {
-      for (uint32_t b = 0; b < num_runs; b++) {
-        Timer<std::ratio<1, 1000>> timer;
-        timer.Start();
+  // Create all keys
+  uint32_t num_keys = 100000;
+  for (uint32_t i = 0; i < num_keys; i++) {
+    keys.push_back({1, static_cast<uint32_t>(rand())});
+  }
 
-        // Start
-        for (uint32_t i = 0; i < num_keys; i++) {
-          Insert(keys[i], v);
-        }
-        // End
+  double avg_oaht = 0.0;
+  double avg_map = 0.0;
 
-        timer.Stop();
-        avg_oaht += timer.GetDuration();
+  // First, bench ours ...
+  {
+    for (uint32_t b = 0; b < num_runs; b++) {
+      Timer<std::ratio<1, 1000>> timer;
+      timer.Start();
 
-        // Reset
-        Reset();
+      // Start
+      for (uint32_t i = 0; i < num_keys; i++) {
+        Insert(keys[i], v);
       }
-    }
+      // End
 
-    // Next, unordered_map ...
-    {
-      struct Hasher {
-        size_t operator()(const Key &k) const { return Hash(k); }
-      };
+      timer.Stop();
+      avg_oaht += timer.GetDuration();
 
-      for (uint32_t b = 0; b < num_runs; b++) {
-        std::unordered_map<Key, Value, Hasher> ht{
-            codegen::util::OAHashTable::kDefaultInitialSize};
+      // Reset
+      Reset();
+    }
+  }
 
-        Timer<std::ratio<1, 1000>> timer;
-        timer.Start();
+  // Next, unordered_map ...
+  {
+    struct Hasher {
+      size_t operator()(const Key &k) const { return Hash(k); }
+    };
 
-        for (uint32_t i = 0; i < num_keys; i++) {
-          ht.insert(std::make_pair(keys[i], v));
-        }
+    for (uint32_t b = 0; b < num_runs; b++) {
+      std::unordered_map<Key, Value, Hasher> ht{
+          codegen::util::OAHashTable::kDefaultInitialSize};
 
-        timer.Stop();
-        avg_map += timer.GetDuration();
+      Timer<std::ratio<1, 1000>> timer;
+      timer.Start();
+
+      for (uint32_t i = 0; i < num_keys; i++) {
+        ht.insert(std::make_pair(keys[i], v));
       }
-    }
 
-    LOG_INFO("Avg OA_HT: %.2lf, Avg std::unordered_map: %.2lf",
-             avg_oaht / (double)num_runs, avg_map / (double)num_runs);
+      timer.Stop();
+      avg_map += timer.GetDuration();
+    }
   }
 
+  LOG_INFO("Avg OA_HT: %.2lf, Avg std::unordered_map: %.2lf",
+           avg_oaht / (double)num_runs, avg_map / (double)num_runs);
+}
+
 }  // namespace test
 }  // namespace peloton