 // The columns to be hashed to determine the partition assignment are the last N integer template
 // arguments, where N <= the number of columns specified in the VTuple
 typedef ::testing::Types< TestParameters< VTuple<int32_t>, 0 >,
-                          TestParameters< VTuple<int32_t, int32_t>, 0, 1> >Implementations;
+                          TestParameters< VTuple<int32_t, int32_t>, 0, 1>,
+                          TestParameters< VTuple<float, double>, 1>,
+                          TestParameters< VTuple<int64_t, int32_t>, 1>,
+                          TestParameters< VTuple<int64_t, int64_t>, 0, 1>,
+                          TestParameters< VTuple<int64_t, int64_t, float, double>, 2, 3>,
+                          TestParameters< VTuple<uint32_t, double, int32_t, double>, 0, 2, 3>,
+                          TestParameters< VTuple<int64_t, int64_t, float, double>, 1, 3>,
+                          TestParameters< VTuple<int64_t, int64_t>, 0, 1>,
+                          TestParameters< VTuple<float, int32_t>, 0>
+                         >Implementations;
 
 TYPED_TEST_CASE(HashPartitionTest, Implementations);
 
 TYPED_TEST(HashPartitionTest, ExampleTest)
 {
-
-  const int num_partitions = 2;
-
-  this->create_input(10, 2, true);
-
-  this->compute_gdf_result(num_partitions);
-
-  /*
-
-  std::vector<result_type> reference_result = this->compute_reference_solution();
-
-  std::vector<result_type> gdf_result = this->compute_gdf_result();
-
-  ASSERT_EQ(reference_result.size(), gdf_result.size()) << "Size of gdf result does not match reference result\n";
-
-  // Compare the GDF and reference solutions
-  for(size_t i = 0; i < reference_result.size(); ++i){
-    EXPECT_EQ(reference_result[i], gdf_result[i]);
-  }
-  */
+  const int num_partitions = 1;
+
+  this->create_input(100, 100);
+
+  std::vector<int> partition_offsets = this->compute_gdf_result(num_partitions, true);
+
+  this->verify_gdf_result(num_partitions, partition_offsets);
 }
+
+TYPED_TEST(HashPartitionTest, OnePartition)
+{
+  const int num_partitions = 1;
+
+  this->create_input(100000, 1000);
+
+  std::vector<int> partition_offsets = this->compute_gdf_result(num_partitions, true);
+
+  this->verify_gdf_result(num_partitions, partition_offsets);
+}
+
+TYPED_TEST(HashPartitionTest, TenPartitions)
+{
+  const int num_partitions = 10;
+
+  this->create_input(100000, 1000);
+
+  std::vector<int> partition_offsets = this->compute_gdf_result(num_partitions, true);
+
+  this->verify_gdf_result(num_partitions, partition_offsets);
+}

  std::vector<gdf_col_pointer> gdf_input_columns;
  std::vector<gdf_col_pointer> gdf_output_columns;


  // Containers for the raw pointers to the gdf_columns
  std::vector<gdf_column*> raw_gdf_input_columns;
  std::vector<gdf_column*> raw_gdf_output_columns;


    EXPECT_EQ(GDF_SUCCESS, result_error);

    if(print)
    {
      std::cout << "Partition offsets: ";
      for(int i = 0; i < num_partitions; ++i)
      {
        std::cout << partition_offsets[i] << " ";
      }
      std::cout << std::endl;
    }

    return partition_offsets;
  } 


  void verify_gdf_result(int num_partitions, std::vector<int> partition_offsets)
  {


    std::vector<gdf_column*> gdf_cols_to_hash;

    for(int i = 0; i < num_cols_to_hash; ++i)
    {
      gdf_cols_to_hash.push_back(raw_gdf_output_columns[cols_to_hash[i]]);
    }

    // Create a table from the gdf output of only the columns that were hashed
    std::unique_ptr< gdf_table<int> > table_to_hash{new gdf_table<int>(num_cols_to_hash, gdf_cols_to_hash.data())};

    thrust::device_vector<int> row_partition_numbers(table_to_hash->get_column_length());

    // Compute the partition number for every row in the result
    thrust::tabulate(thrust::device,
                     row_partition_numbers.begin(),
                     row_partition_numbers.end(),
                     row_partition_mapper<MurmurHash3_32,int>(*table_to_hash,num_partitions));

    // Check that the partition number for every row is correct
    for(int partition_number = 0; partition_number < num_partitions; ++partition_number)
    {
      const int partition_start = partition_offsets[partition_number];
      int partition_stop{0};

      if(partition_number < (num_partitions - 1))
      {
        partition_stop = partition_offsets[partition_number + 1];
      }
      // The end of the last partition is the end of the table
      else
      {
        partition_stop = table_to_hash->get_column_length();
      }

      // Everything in the current partition should have the same partition
      // number
      for(int i = partition_start; i < partition_stop; ++i)
      {
        EXPECT_EQ(partition_number, row_partition_numbers[i]);
      }
    }
  }
};
