Add C++ tests for different compression implementations (#18690)

Add tests that are parameterized on the compression codec and the implementation (nvCOMP, internal kernel, host) to ensure all available implementations are tested for all supported codecs.

More tests will be added as issues with non-nvCOMP implementations are fixed.

Also: tests uncovered another bug in the Parquet writer; fixed it in this PR.

Authors:
  - Vukasin Milovanovic (https://github.com/vuule)

Approvers:
  - David Wendt (https://github.com/davidwendt)
  - MithunR (https://github.com/mythrocks)

URL: #18690

Author: vuule

cpp/src/io/parquet/page_enc.cu

@@ -689,6 +689,7 @@ CUDF_KERNEL void __launch_bounds__(128)
           util::round_up_unsafe(page_g.max_hdr_size + page_g.max_data_size, page_align);
         if (not comp_page_sizes.empty()) {
           comp_page_offset += page_g.max_hdr_size + comp_page_sizes[ck_g.first_page];
+          page_g.comp_data_size = comp_page_sizes[ck_g.first_page + num_pages];
         }
         page_headers_size += page_g.max_hdr_size;
         max_page_data_size = max(max_page_data_size, page_g.max_data_size);

cpp/tests/io/compression_common.hpp

@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2025, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cudf/io/types.hpp>
+#include <cudf/utilities/error.hpp>
+
+#include <gtest/gtest.h>
+
+#include <cstdlib>
+#include <list>
+#include <string>
+#include <tuple>
+
+class tmp_env_var {
+ public:
+  explicit tmp_env_var(std::string name, std::string const& value) : name_(std::move(name))
+  {
+    auto const previous_value = std::getenv(name_.c_str());
+    if (previous_value != nullptr) { previous_value_ = std::string(previous_value); }
+
+    setenv(name_.c_str(), value.c_str(), 1);
+  }
+
+  tmp_env_var(tmp_env_var const&)            = delete;
+  tmp_env_var& operator=(tmp_env_var const&) = delete;
+  tmp_env_var(tmp_env_var&&)                 = delete;
+  tmp_env_var& operator=(tmp_env_var&&)      = delete;
+
+  ~tmp_env_var()
+  {
+    if (previous_value_.has_value()) {
+      setenv(name_.c_str(), previous_value_->c_str(), 1);
+    } else {
+      unsetenv(name_.c_str());
+    }
+  }
+
+ private:
+  std::string name_;
+  std::optional<std::string> previous_value_;
+};
+
+static constexpr char const* host_comp_env_var     = "LIBCUDF_HOST_COMPRESSION";
+static constexpr char const* host_decomp_env_var   = "LIBCUDF_HOST_DECOMPRESSION";
+static constexpr char const* nvcomp_policy_env_var = "LIBCUDF_NVCOMP_POLICY";
+
+template <typename Base>
+struct CompressionTest
+  : public Base,
+    public ::testing::WithParamInterface<std::tuple<std::string, cudf::io::compression_type>> {
+  CompressionTest()
+  {
+    auto const comp_impl = std::get<0>(GetParam());
+
+    if (comp_impl == "NVCOMP") {
+      env_vars.emplace_back(host_comp_env_var, "OFF");
+      env_vars.emplace_back(nvcomp_policy_env_var, "ALWAYS");
+    } else if (comp_impl == "DEVICE_INTERNAL") {
+      env_vars.emplace_back(host_comp_env_var, "OFF");
+      env_vars.emplace_back(nvcomp_policy_env_var, "OFF");
+    } else if (comp_impl == "HOST") {
+      env_vars.emplace_back(host_comp_env_var, "ON");
+    } else {
+      CUDF_FAIL("Invalid test parameter");
+    }
+  }
+
+ private:
+  std::list<tmp_env_var> env_vars;
+};
+
+template <typename Base>
+struct DecompressionTest
+  : public Base,
+    public ::testing::WithParamInterface<std::tuple<std::string, cudf::io::compression_type>> {
+  DecompressionTest()
+  {
+    auto const comp_impl = std::get<0>(GetParam());
+
+    if (comp_impl == "NVCOMP") {
+      env_vars.emplace_back(host_decomp_env_var, "OFF");
+      env_vars.emplace_back(nvcomp_policy_env_var, "ALWAYS");
+    } else if (comp_impl == "DEVICE_INTERNAL") {
+      env_vars.emplace_back(host_decomp_env_var, "OFF");
+      env_vars.emplace_back(nvcomp_policy_env_var, "OFF");
+    } else if (comp_impl == "HOST") {
+      env_vars.emplace_back(host_decomp_env_var, "ON");
+    } else {
+      CUDF_FAIL("Invalid test parameter");
+    }
+  }
+
+ private:
+  std::list<tmp_env_var> env_vars;
+};

cpp/tests/io/orc_chunked_reader_test.cu

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2024, NVIDIA CORPORATION.
+ * Copyright (c) 2024-2025, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+#include "compression_common.hpp"
+
 #include <cudf_test/base_fixture.hpp>
 #include <cudf_test/column_utilities.hpp>
 #include <cudf_test/column_wrapper.hpp>
@@ -161,6 +163,8 @@ auto chunked_read(std::string const& filepath,
 
 struct OrcChunkedReaderTest : public cudf::test::BaseFixture {};
 
+using OrcChunkedDecompressionTest = DecompressionTest<OrcChunkedReaderTest>;
+
 TEST_F(OrcChunkedReaderTest, TestChunkedReadNoData)
 {
   std::vector<std::unique_ptr<cudf::column>> input_columns;
@@ -1477,3 +1481,62 @@ TEST_F(OrcChunkedReaderInputLimitTest, SizeTypeRowsOverflow)
 
 #endif  // LOCAL_TEST
 }
+
+TEST_P(OrcChunkedDecompressionTest, RoundTripBasic)
+{
+  auto const compression_type = std::get<1>(GetParam());
+
+  auto const num_rows = 12'345;
+
+  std::vector<std::unique_ptr<cudf::column>> input_columns;
+  auto value_iter = cudf::detail::make_counting_transform_iterator(0, [](auto i) { return i / 4; });
+  input_columns.emplace_back(int32s_col(value_iter, value_iter + num_rows).release());
+  input_columns.emplace_back(int64s_col(value_iter, value_iter + num_rows).release());
+  auto expected = std::make_unique<cudf::table>(std::move(input_columns));
+
+  auto const filepath = temp_env->get_temp_filepath("chunked_read_compressions.orc");
+  auto const write_opts =
+    cudf::io::orc_writer_options::builder(cudf::io::sink_info{filepath}, *expected)
+      .compression(compression_type)
+      .stripe_size_rows(2'000)
+      .row_index_stride(1'000)
+      .build();
+  cudf::io::write_orc(write_opts);
+
+  {
+    auto const [result, num_chunks] =
+      chunked_read(filepath, output_limit{0}, input_limit{2'400'000});
+    CUDF_TEST_EXPECT_TABLES_EQUAL(*expected, *result);
+  }
+
+  {
+    auto const [result, num_chunks] = chunked_read(filepath, output_limit{0}, input_limit{240'000});
+    CUDF_TEST_EXPECT_TABLES_EQUAL(*expected, *result);
+  }
+
+  {
+    auto const [result, num_chunks] = chunked_read(filepath, output_limit{0}, input_limit{24'000});
+    CUDF_TEST_EXPECT_TABLES_EQUAL(*expected, *result);
+  }
+}
+
+INSTANTIATE_TEST_CASE_P(Nvcomp,
+                        OrcChunkedDecompressionTest,
+                        ::testing::Combine(::testing::Values("NVCOMP"),
+                                           ::testing::Values(cudf::io::compression_type::AUTO,
+                                                             cudf::io::compression_type::SNAPPY,
+                                                             cudf::io::compression_type::LZ4,
+                                                             cudf::io::compression_type::ZSTD)));
+
+INSTANTIATE_TEST_CASE_P(DeviceInternal,
+                        OrcChunkedDecompressionTest,
+                        ::testing::Combine(::testing::Values("DEVICE_INTERNAL"),
+                                           ::testing::Values(cudf::io::compression_type::AUTO,
+                                                             cudf::io::compression_type::SNAPPY)));
+
+INSTANTIATE_TEST_CASE_P(Host,
+                        OrcChunkedDecompressionTest,
+                        ::testing::Combine(::testing::Values("HOST"),
+                                           ::testing::Values(cudf::io::compression_type::AUTO,
+                                                             cudf::io::compression_type::SNAPPY,
+                                                             cudf::io::compression_type::ZSTD)));