Move record batch test fixtures into test-common.h

Change-Id: Ifc17c1aebf1d1884c3b3f468c83b486dbf5e08ac

Author: wesm

cpp/src/arrow/ipc/file.cc

@@ -100,7 +100,7 @@ Status FileWriter::WriteRecordBatch(
   int32_t metadata_length = body_end_offset - header_end_offset;
   int32_t body_length = body_end_offset - offset;
 
-  // Append metadata, to be written in the footer latera
+  // Append metadata, to be written in the footer later
   record_batches_.emplace_back(offset, metadata_length, body_length);
 
   return Status::OK();

cpp/src/arrow/ipc/ipc-adapter-test.cc

@@ -43,13 +43,6 @@
 namespace arrow {
 namespace ipc {
 
-// TODO(emkornfield) convert to google style kInt32, etc?
-const auto INT32 = std::make_shared<Int32Type>();
-const auto LIST_INT32 = std::make_shared<ListType>(INT32);
-const auto LIST_LIST_INT32 = std::make_shared<ListType>(LIST_INT32);
-
-typedef Status MakeRecordBatch(std::shared_ptr<RecordBatch>* out);
-
 class TestWriteRecordBatch : public ::testing::TestWithParam<MakeRecordBatch*>,
                              public io::MemoryMapFixture {
  public:
@@ -96,186 +89,6 @@ TEST_P(TestWriteRecordBatch, RoundTrip) {
   }
 }
 
-Status MakeIntRecordBatch(std::shared_ptr<RecordBatch>* out) {
-  const int length = 1000;
-
-  // Make the schema
-  auto f0 = std::make_shared<Field>("f0", INT32);
-  auto f1 = std::make_shared<Field>("f1", INT32);
-  std::shared_ptr<Schema> schema(new Schema({f0, f1}));
-
-  // Example data
-  std::shared_ptr<Array> a0, a1;
-  MemoryPool* pool = default_memory_pool();
-  RETURN_NOT_OK(MakeRandomInt32Array(length, false, pool, &a0));
-  RETURN_NOT_OK(MakeRandomInt32Array(length, true, pool, &a1));
-  out->reset(new RecordBatch(schema, length, {a0, a1}));
-  return Status::OK();
-}
-
-template <class Builder, class RawType>
-Status MakeRandomBinaryArray(
-    const TypePtr& type, int32_t length, MemoryPool* pool, ArrayPtr* array) {
-  const std::vector<std::string> values = {
-      "", "", "abc", "123", "efg", "456!@#!@#", "12312"};
-  Builder builder(pool, type);
-  const auto values_len = values.size();
-  for (int32_t i = 0; i < length; ++i) {
-    int values_index = i % values_len;
-    if (values_index == 0) {
-      RETURN_NOT_OK(builder.AppendNull());
-    } else {
-      const std::string& value = values[values_index];
-      RETURN_NOT_OK(
-          builder.Append(reinterpret_cast<const RawType*>(value.data()), value.size()));
-    }
-  }
-  *array = builder.Finish();
-  return Status::OK();
-}
-
-Status MakeStringTypesRecordBatch(std::shared_ptr<RecordBatch>* out) {
-  const int32_t length = 500;
-  auto string_type = std::make_shared<StringType>();
-  auto binary_type = std::make_shared<BinaryType>();
-  auto f0 = std::make_shared<Field>("f0", string_type);
-  auto f1 = std::make_shared<Field>("f1", binary_type);
-  std::shared_ptr<Schema> schema(new Schema({f0, f1}));
-
-  std::shared_ptr<Array> a0, a1;
-  MemoryPool* pool = default_memory_pool();
-
-  {
-    auto status =
-        MakeRandomBinaryArray<StringBuilder, char>(string_type, length, pool, &a0);
-    RETURN_NOT_OK(status);
-  }
-  {
-    auto status =
-        MakeRandomBinaryArray<BinaryBuilder, uint8_t>(binary_type, length, pool, &a1);
-    RETURN_NOT_OK(status);
-  }
-  out->reset(new RecordBatch(schema, length, {a0, a1}));
-  return Status::OK();
-}
-
-Status MakeListRecordBatch(std::shared_ptr<RecordBatch>* out) {
-  // Make the schema
-  auto f0 = std::make_shared<Field>("f0", LIST_INT32);
-  auto f1 = std::make_shared<Field>("f1", LIST_LIST_INT32);
-  auto f2 = std::make_shared<Field>("f2", INT32);
-  std::shared_ptr<Schema> schema(new Schema({f0, f1, f2}));
-
-  // Example data
-
-  MemoryPool* pool = default_memory_pool();
-  const int length = 200;
-  std::shared_ptr<Array> leaf_values, list_array, list_list_array, flat_array;
-  const bool include_nulls = true;
-  RETURN_NOT_OK(MakeRandomInt32Array(1000, include_nulls, pool, &leaf_values));
-  RETURN_NOT_OK(
-      MakeRandomListArray(leaf_values, length, include_nulls, pool, &list_array));
-  RETURN_NOT_OK(
-      MakeRandomListArray(list_array, length, include_nulls, pool, &list_list_array));
-  RETURN_NOT_OK(MakeRandomInt32Array(length, include_nulls, pool, &flat_array));
-  out->reset(new RecordBatch(schema, length, {list_array, list_list_array, flat_array}));
-  return Status::OK();
-}
-
-Status MakeZeroLengthRecordBatch(std::shared_ptr<RecordBatch>* out) {
-  // Make the schema
-  auto f0 = std::make_shared<Field>("f0", LIST_INT32);
-  auto f1 = std::make_shared<Field>("f1", LIST_LIST_INT32);
-  auto f2 = std::make_shared<Field>("f2", INT32);
-  std::shared_ptr<Schema> schema(new Schema({f0, f1, f2}));
-
-  // Example data
-  MemoryPool* pool = default_memory_pool();
-  const int length = 200;
-  const bool include_nulls = true;
-  std::shared_ptr<Array> leaf_values, list_array, list_list_array, flat_array;
-  RETURN_NOT_OK(MakeRandomInt32Array(0, include_nulls, pool, &leaf_values));
-  RETURN_NOT_OK(MakeRandomListArray(leaf_values, 0, include_nulls, pool, &list_array));
-  RETURN_NOT_OK(
-      MakeRandomListArray(list_array, 0, include_nulls, pool, &list_list_array));
-  RETURN_NOT_OK(MakeRandomInt32Array(0, include_nulls, pool, &flat_array));
-  out->reset(new RecordBatch(schema, length, {list_array, list_list_array, flat_array}));
-  return Status::OK();
-}
-
-Status MakeNonNullRecordBatch(std::shared_ptr<RecordBatch>* out) {
-  // Make the schema
-  auto f0 = std::make_shared<Field>("f0", LIST_INT32);
-  auto f1 = std::make_shared<Field>("f1", LIST_LIST_INT32);
-  auto f2 = std::make_shared<Field>("f2", INT32);
-  std::shared_ptr<Schema> schema(new Schema({f0, f1, f2}));
-
-  // Example data
-  MemoryPool* pool = default_memory_pool();
-  const int length = 50;
-  std::shared_ptr<Array> leaf_values, list_array, list_list_array, flat_array;
-
-  RETURN_NOT_OK(MakeRandomInt32Array(1000, true, pool, &leaf_values));
-  bool include_nulls = false;
-  RETURN_NOT_OK(
-      MakeRandomListArray(leaf_values, length, include_nulls, pool, &list_array));
-  RETURN_NOT_OK(
-      MakeRandomListArray(list_array, length, include_nulls, pool, &list_list_array));
-  RETURN_NOT_OK(MakeRandomInt32Array(length, include_nulls, pool, &flat_array));
-  out->reset(new RecordBatch(schema, length, {list_array, list_list_array, flat_array}));
-  return Status::OK();
-}
-
-Status MakeDeeplyNestedList(std::shared_ptr<RecordBatch>* out) {
-  const int batch_length = 5;
-  TypePtr type = INT32;
-
-  MemoryPool* pool = default_memory_pool();
-  ArrayPtr array;
-  const bool include_nulls = true;
-  RETURN_NOT_OK(MakeRandomInt32Array(1000, include_nulls, pool, &array));
-  for (int i = 0; i < 63; ++i) {
-    type = std::static_pointer_cast<DataType>(std::make_shared<ListType>(type));
-    RETURN_NOT_OK(MakeRandomListArray(array, batch_length, include_nulls, pool, &array));
-  }
-
-  auto f0 = std::make_shared<Field>("f0", type);
-  std::shared_ptr<Schema> schema(new Schema({f0}));
-  std::vector<ArrayPtr> arrays = {array};
-  out->reset(new RecordBatch(schema, batch_length, arrays));
-  return Status::OK();
-}
-
-Status MakeStruct(std::shared_ptr<RecordBatch>* out) {
-  // reuse constructed list columns
-  std::shared_ptr<RecordBatch> list_batch;
-  RETURN_NOT_OK(MakeListRecordBatch(&list_batch));
-  std::vector<ArrayPtr> columns = {
-      list_batch->column(0), list_batch->column(1), list_batch->column(2)};
-  auto list_schema = list_batch->schema();
-
-  // Define schema
-  std::shared_ptr<DataType> type(new StructType(
-      {list_schema->field(0), list_schema->field(1), list_schema->field(2)}));
-  auto f0 = std::make_shared<Field>("non_null_struct", type);
-  auto f1 = std::make_shared<Field>("null_struct", type);
-  std::shared_ptr<Schema> schema(new Schema({f0, f1}));
-
-  // construct individual nullable/non-nullable struct arrays
-  ArrayPtr no_nulls(new StructArray(type, list_batch->num_rows(), columns));
-  std::vector<uint8_t> null_bytes(list_batch->num_rows(), 1);
-  null_bytes[0] = 0;
-  std::shared_ptr<Buffer> null_bitmask;
-  RETURN_NOT_OK(util::bytes_to_bits(null_bytes, &null_bitmask));
-  ArrayPtr with_nulls(
-      new StructArray(type, list_batch->num_rows(), columns, 1, null_bitmask));
-
-  // construct batch
-  std::vector<ArrayPtr> arrays = {no_nulls, with_nulls};
-  out->reset(new RecordBatch(schema, list_batch->num_rows(), arrays));
-  return Status::OK();
-}
-
 INSTANTIATE_TEST_CASE_P(RoundTripTests, TestWriteRecordBatch,
     ::testing::Values(&MakeIntRecordBatch, &MakeListRecordBatch, &MakeNonNullRecordBatch,
                             &MakeZeroLengthRecordBatch, &MakeDeeplyNestedList,
@@ -319,7 +132,7 @@ class RecursionLimits : public ::testing::Test, public io::MemoryMapFixture {
   Status WriteToMmap(int recursion_level, bool override_level,
       int64_t* header_out = nullptr, std::shared_ptr<Schema>* schema_out = nullptr) {
     const int batch_length = 5;
-    TypePtr type = INT32;
+    TypePtr type = kInt32;
     ArrayPtr array;
     const bool include_nulls = true;
     RETURN_NOT_OK(MakeRandomInt32Array(1000, include_nulls, pool_, &array));