   GDFGroupByTest() 
   {
     // Use constant seed so the psuedo-random order is the same each time
-    // Each time the class is constructed a new constant seed is used
-    static size_t number_of_instantiations{0};
-    std::srand(number_of_instantiations++);
+    std::srand(0);
   }
 
   ~GDFGroupByTest() {} 

  using agg_output_type = accumulation_type;
  const static agg_op the_aggregator{the_agg};
};
using TestCases = ::testing::Types< TestParameters<int32_t, int32_t, agg_op::MAX>,
                                    TestParameters<int32_t, float, agg_op::MAX>
                                    //TestParameters<int32_t, double, agg_op::MAX>,
                                    //TestParameters<int32_t, int64_t, agg_op::MAX>,
                                    //TestParameters<int32_t, uint64_t, agg_op::MAX>,
                                    //TestParameters<int64_t, int32_t, agg_op::MAX>,
                                    //TestParameters<int64_t, float, agg_op::MAX>,
                                    //TestParameters<int64_t, double, agg_op::MAX>,
                                    //TestParameters<int64_t, int64_t, agg_op::MAX>,
                                    //TestParameters<int64_t, uint64_t, agg_op::MAX>,
                                    //TestParameters<uint64_t, int32_t, agg_op::MAX>,
                                    //TestParameters<uint64_t, float, agg_op::MAX>,
                                    //TestParameters<uint64_t, double, agg_op::MAX>,
                                    //TestParameters<uint64_t, int64_t, agg_op::MAX>,
                                    //TestParameters<uint64_t, uint64_t, agg_op::MAX>,
                                    //TestParameters<int32_t, int32_t, agg_op::MIN>,
                                    //TestParameters<int32_t, float, agg_op::MIN>,
                                    //TestParameters<int32_t, double, agg_op::MIN>,
                                    //TestParameters<int32_t, int64_t, agg_op::MIN>,
                                    //TestParameters<int32_t, uint64_t, agg_op::MIN>,
                                    //TestParameters<uint64_t, int32_t, agg_op::MIN>,
                                    //TestParameters<uint64_t, float, agg_op::MIN>,
                                    //TestParameters<uint64_t, double, agg_op::MIN>,
                                    //TestParameters<uint64_t, int64_t, agg_op::MIN>,
                                    //TestParameters<uint64_t, uint64_t, agg_op::MIN>,
                                    //TestParameters<int32_t, int32_t, agg_op::COUNT>,
                                    //TestParameters<int32_t, float, agg_op::COUNT>,
                                    //TestParameters<int32_t, double, agg_op::COUNT>,
                                    //TestParameters<int32_t, int64_t, agg_op::COUNT>,
                                    //TestParameters<int32_t, uint64_t, agg_op::COUNT>,
                                    //TestParameters<uint64_t, int32_t, agg_op::COUNT>,
                                    //TestParameters<uint64_t, float, agg_op::COUNT>,
                                    //TestParameters<uint64_t, double, agg_op::COUNT>,
                                    //TestParameters<uint64_t, int64_t, agg_op::COUNT>,
                                    //TestParameters<uint64_t, uint64_t, agg_op::COUNT>,
                                    //TestParameters<int32_t, int32_t, agg_op::SUM>,
                                    //// TODO: Tests for SUM on single precision floats currently fail due to numerical stability issues
                                    //TestParameters<int32_t, float, agg_op::SUM>, 
                                    //TestParameters<int32_t, double, agg_op::SUM>,
                                    //TestParameters<int32_t, int64_t, agg_op::SUM>,
                                    //TestParameters<int32_t, uint64_t, agg_op::SUM>,
                                    //TestParameters<uint64_t, double, agg_op::SUM>,
                                    //TestParameters<uint64_t, double, agg_op::SUM>,
                                    //TestParameters<uint64_t, int64_t, agg_op::SUM>,
                                    //TestParameters<uint64_t, uint64_t, agg_op::SUM>,
                                    //TestParameters<int32_t, int32_t, agg_op::AVG, double>
                                    >;

TYPED_TEST_CASE(GDFGroupByTest, TestCases);

TYPED_TEST(GDFGroupByTest, ExampleTest)
{
  const int num_keys = 5;
  const int num_values_per_key = 1;
  std::tie(this->groupby_column, 
           this->aggregation_column) = this->create_reference_input(num_keys, 
                                                                    num_values_per_key, 
                                                                    5, 5,
                                                                    true);

  auto expected_values = this->compute_reference_solution(this->groupby_column, 
                                                          this->aggregation_column,
                                                          true);

  this->gdf_groupby_column = create_gdf_column(this->groupby_column);
  this->gdf_aggregation_column = create_gdf_column(this->aggregation_column);

  this->compute_gdf_result(this->gdf_groupby_column.get(), 
                           this->gdf_aggregation_column.get(), 
                           this->gdf_groupby_output.get(),
                           this->gdf_agg_output.get());

  ASSERT_EQ(expected_values.size(), this->gdf_groupby_output->size) << "Size of GDF Group By output does not match reference solution";
  ASSERT_EQ(expected_values.size(), this->gdf_agg_output->size) << "Size of GDF Aggregation output does not match reference solution";
