Method TestPageCompressionRoundTrip

cpp/src/parquet/file_deserialize_test.cc:729–775

}

void TestPageSerde::TestPageCompressionRoundTrip(const std::vector<int>& page_sizes) {
  auto codec_types = GetSupportedCodecTypes();

  const int32_t num_rows = 32;  // dummy value
  data_page_header_.num_values = num_rows;

  std::vector<std::vector<uint8_t>> faux_data;
  int num_pages = static_cast<int>(page_sizes.size());
  faux_data.resize(num_pages);
  for (int i = 0; i < num_pages; ++i) {
    test::random_bytes(page_sizes[i], 0, &faux_data[i]);
  }
  for (auto codec_type : codec_types) {
    auto codec = GetCodec(codec_type);

    std::vector<uint8_t> buffer;
    for (int i = 0; i < num_pages; ++i) {
      const uint8_t* data = faux_data[i].data();
      int data_size = static_cast<int>(faux_data[i].size());

      int64_t max_compressed_size = codec->MaxCompressedLen(data_size, data);
      buffer.resize(max_compressed_size);

      int64_t actual_size;
      ASSERT_OK_AND_ASSIGN(
          actual_size, codec->Compress(data_size, data, max_compressed_size, &buffer[0]));

      ASSERT_NO_FATAL_FAILURE(
          WriteDataPageHeader(1024, data_size, static_cast<int32_t>(actual_size)));
      ASSERT_OK(out_stream_->Write(buffer.data(), actual_size));
    }

    InitSerializedPageReader(num_rows * num_pages, codec_type);

    std::shared_ptr<Page> page;
    const DataPageV1* data_page;
    for (int i = 0; i < num_pages; ++i) {
      int data_size = static_cast<int>(faux_data[i].size());
      page = page_reader_->NextPage();
      data_page = static_cast<const DataPageV1*>(page.get());
      ASSERT_EQ(data_size, data_page->size());
      ASSERT_EQ(0, memcmp(faux_data[i].data(), data_page->data(), data_size));
    }

    ResetStream();
  }
}

TEST_F(TestPageSerde, Compression) {
  std::vector<int> page_sizes;