Function AssertTableWriteReadEqual

cpp/src/arrow/adapters/orc/adapter_test.cc:225–260

}

void AssertTableWriteReadEqual(const std::vector<std::shared_ptr<Table>>& input_tables,
                               const std::shared_ptr<Table>& expected_output_table,
                               const int64_t max_size = kDefaultSmallMemStreamSize,
                               std::vector<int>* opt_selected_read_indices = nullptr) {
  EXPECT_OK_AND_ASSIGN(auto buffer_output_stream,
                       io::BufferOutputStream::Create(max_size));
  auto write_options = adapters::orc::WriteOptions();
#ifdef ARROW_WITH_SNAPPY
  write_options.compression = Compression::SNAPPY;
#else
  write_options.compression = Compression::UNCOMPRESSED;
#endif
  write_options.file_version = adapters::orc::FileVersion(0, 11);
  write_options.compression_block_size = 64 * 1024;
  write_options.row_index_stride = 5000;
  EXPECT_OK_AND_ASSIGN(auto writer, adapters::orc::ORCFileWriter::Open(
                                        buffer_output_stream.get(), write_options));
  for (const auto& input_table : input_tables) {
    ARROW_EXPECT_OK(writer->Write(*input_table));
  }
  ARROW_EXPECT_OK(writer->Close());
  EXPECT_OK_AND_ASSIGN(auto buffer, buffer_output_stream->Finish());
  std::shared_ptr<io::RandomAccessFile> in_stream(new io::BufferReader(buffer));
  EXPECT_OK_AND_ASSIGN(
      auto reader, adapters::orc::ORCFileReader::Open(in_stream, default_memory_pool()));
  ASSERT_EQ(reader->GetFileVersion(), write_options.file_version);
  ASSERT_EQ(reader->GetCompression(), write_options.compression);
  ASSERT_EQ(reader->GetCompressionSize(), write_options.compression_block_size);
  ASSERT_EQ(reader->GetRowIndexStride(), write_options.row_index_stride);
  EXPECT_OK_AND_ASSIGN(auto actual_output_table,
                       opt_selected_read_indices == nullptr
                           ? reader->Read()
                           : reader->Read(*opt_selected_read_indices));
  ASSERT_OK(actual_output_table->ValidateFull());
  AssertTablesEqual(*expected_output_table, *actual_output_table, false, false);
}

void AssertBatchWriteReadEqual(
    const std::vector<std::shared_ptr<RecordBatch>>& input_batches,