     // Allocate storage in each vector 
     // Fill each vector with random values
     if(num_columns >= 1){
-      std::get<0>(the_columns).reserve(column_length);
+      std::get<0>(the_columns).resize(column_length);
       std::generate(std::get<0>(the_columns).begin(), std::get<0>(the_columns).end(), [column_range](){return std::rand() % column_range;});
     }
     if(num_columns >= 2){
-      std::get<1>(the_columns).reserve(column_length);
+      std::get<1>(the_columns).resize(column_length);
       std::generate(std::get<1>(the_columns).begin(), std::get<1>(the_columns).end(), [column_range](){return std::rand() % column_range;});
     }
     if(num_columns >= 3){
-      std::get<2>(the_columns).reserve(column_length);
+      std::get<2>(the_columns).resize(column_length);
       std::generate(std::get<2>(the_columns).begin(), std::get<2>(the_columns).end(), [column_range](){return std::rand() % column_range;});
     }
 

  // TODO: Support more than 3 columns
  void create_input(size_t num_columns, 
                    size_t left_column_length, size_t left_column_range,
                    size_t right_column_length, size_t right_column_range)
  {
    assert(num_columns > 0);
    assert(num_columns <= std::tuple_size<multi_column_t>::value);

    left_columns = create_random_columns(num_columns, left_column_length, left_column_range);

    right_columns = create_random_columns(num_columns, right_column_length, right_column_range);
  }

  bool rows_match(size_t num_columns, size_t left_index, size_t right_index){

  return the_column;
}

// Each element of the result will be an index into the left and right columns where
// left_columns[left_index] == right_columns[right_index]
struct result_type 
{
  size_t left_index{};
  size_t right_index{};

  result_type(size_t _l, size_t _r) : 
    left_index{_l}, right_index{_r} {}

  // Overload comparison so the result vector can be sorted
  bool operator <(result_type const& rhs){
    return( std::tie(left_index, right_index) < std::tie(rhs.left_index, rhs.right_index) );
  }

  friend std::ostream& operator<<(std::ostream& os, const result_type& result);

};

// Overload the stream operator to make it easier to print a result 
std::ostream& operator<<(std::ostream& os, const result_type& result)
{
  os << result.left_index << ", " << result.right_index << std::endl;
  return os;
}

// A new instance of this class will be created for each *TEST(JoinTest, ...)
// Put all repeated setup and validation stuff here
template <class T>
struct InnerJoinTest : public testing::Test
{

  // Extract the types for the input columns 
