   void create_input( size_t num_rows, size_t max_value,
                      bool print = false)
   {
-    initialize_tuple(the_columns, num_rows, max_value);
+    initialize_tuple(input_columns, num_rows, max_value);
+    initialize_tuple(output_columns, num_rows, max_value);
 
-    gdf_columns = initialize_gdf_columns(the_columns);
+    gdf_input_columns = initialize_gdf_columns(input_columns);
+    gdf_output_columns = initialize_gdf_columns(output_columns);
 
     // Fill vector of raw pointers to gdf_columns
-    for(auto const& c : gdf_columns){
-      this->raw_gdf_columns.push_back(c.get());
+    for(auto const& c : gdf_input_columns){
+      this->raw_gdf_input_columns.push_back(c.get());
+      this->raw_gdf_output_columns.push_back(c.get());
     }
 
     if(print)
     {
-      std::cout << "Column(s) created. Size: " << std::get<0>(the_columns).size() << std::endl;
-      print_tuple(the_columns);
+      std::cout << "Input column(s) created. Size: " 
+                << std::get<0>(input_columns).size() << std::endl;
+      print_tuple(input_columns);
     }
   }
 
-  void compute_reference_solution(bool print = false, bool sort = true)
-  {
-
-  }
-
-  void compute_gdf_result(bool print = false, bool sort = true)
+  void compute_gdf_result(const int num_partitions, bool print = false)
   {
     const int num_columns = std::tuple_size<multi_column_t>::value;
 
     gdf_error result_error{GDF_SUCCESS};
 
-    gdf_column ** gdf_input_columns = raw_gdf_columns.data();
+    gdf_column ** gdf_input_columns = raw_gdf_input_columns.data();
+    gdf_column ** gdf_output_columns = raw_gdf_output_columns.data();
+
+    std::vector<int> partition_offsets(num_partitions,0);
+
+    result_error = gdf_hash_partition(num_columns, 
+                                      gdf_input_columns,
+                                      this->cols_to_hash.data(),
+                                      this->num_cols_to_hash,
+                                      num_partitions,
+                                      gdf_output_columns,
+                                      partition_offsets.data(),
+                                      GDF_HASH_MURMUR3);
 
     EXPECT_EQ(GDF_SUCCESS, result_error);
 

  }
};

template< typename tuple_of_vectors >
struct TestParameters
{
  // The tuple of vectors that determines the number and types of the columns 
  using multi_column_t = tuple_of_vectors;
};



// TestParameters defined below
// The number and types of columns determined by the number and types of vectors 
// in the VTuple<...> 
// 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;

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();

