 
 TYPED_TEST(JoinTest, ExampleTest)
 {
-  this->create_input(100,10,
-                     100,10);
+  this->create_input(10000,100,
+                     10000,100);
 
   std::vector<result_type> reference_result = this->compute_reference_solution();
 
-  std::vector<result_type> gdf_result{};
-  this->compute_gdf_result(gdf_result);
+  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";
 

            //                                             right_gdf_columns, 
            //                                             &gdf_join_result);
            std::cout << "Multi column *inner* joins not supported yet\n";
            ASSERT_TRUE(false);
            break;
          }
        default:
          std::cout << "Invalid join method" << std::endl;
          ASSERT_TRUE(false);
      }
    }
    ASSERT_EQ(GDF_SUCCESS, result_error) << "The gdf join function did not complete successfully";

    // The output is an array of size `n` where the first n/2 elements are the 
    // left_indices and the last n/2 elements are the right indices
    size_t output_size = gdf_join_result_size(gdf_join_result);
    size_t total_pairs = output_size/2;

    // Copy join result to a Thrust vector
    int * join_output = static_cast<int*>(gdf_join_result_data(gdf_join_result));
    thrust::device_vector<int> d_output(join_output, join_output + output_size);

    // Free the original join result
    gdf_join_result_free(gdf_join_result);

    // Copy the left and right indices into their own arrays for convenience 
    thrust::device_vector<int> left_indices(d_output.begin(), d_output.begin() + total_pairs);
    thrust::device_vector<int> right_indices(d_output.begin() + total_pairs, d_output.end());

    gdf_result.resize(total_pairs);

    // Copy the gdf results list of matching {left, right} indices into the host vector
    for(size_t i = 0; i < total_pairs; ++i){
      gdf_result[i].left_index = left_indices[i];
      gdf_result[i].right_index = right_indices[i];
    }

    // Sort the output for comparison to reference solution
    if(sort){
      std::sort(gdf_result.begin(), gdf_result.end());
    }

    if(print){
      std::cout << "GDF result size: " << gdf_result.size() << std::endl;
      std::cout << "left index, right index" << std::endl;
      std::copy(gdf_result.begin(), gdf_result.end(), std::ostream_iterator<result_type>(std::cout, ""));
      std::cout << "\n";
    }
  }
};


   * @Param sort Option to sort the result. This is required to compare the result against the reference solution
   */
  /* ----------------------------------------------------------------------------*/
  std::vector<result_type> compute_gdf_result(bool print = false, bool sort = true)
  {
    const int num_columns = std::tuple_size<multi_column_t>::value;

