Function TestRleBitPackedParser

cpp/src/arrow/util/rle_encoding_test.cc:412–464

template <typename T>
void TestRleBitPackedParser(std::vector<uint8_t> bytes, rle_size_t bit_width,
                            std::vector<T> expected) {
  auto parser =
      RleBitPackedParser(bytes.data(), static_cast<rle_size_t>(bytes.size()), bit_width);
  EXPECT_FALSE(parser.exhausted());

  // Try to decode all data of all runs in the decoded vector
  decltype(expected) decoded = {};
  auto rle_decoder = RleRunDecoder<T>();
  auto bit_packed_decoder = BitPackedRunDecoder<T>();

  struct {
    decltype(rle_decoder)* rle_decoder_ptr_;
    decltype(bit_packed_decoder)* bit_packed_decoder_ptr_;
    decltype(decoded)* decoded_ptr_;
    decltype(bit_width) bit_width_;

    auto OnRleRun(RleRun run) {
      rle_decoder_ptr_->Reset(run, bit_width_);

      const auto n_decoded = decoded_ptr_->size();
      const auto n_to_decode = rle_decoder_ptr_->remaining();
      decoded_ptr_->resize(n_decoded + n_to_decode);
      EXPECT_EQ(rle_decoder_ptr_->GetBatch(decoded_ptr_->data() + n_decoded, n_to_decode,
                                           bit_width_),
                n_to_decode);
      EXPECT_EQ(rle_decoder_ptr_->remaining(), 0);

      return RleBitPackedParser::ControlFlow::Continue;
    }

    auto OnBitPackedRun(BitPackedRun run) {
      bit_packed_decoder_ptr_->Reset(run, bit_width_);

      const auto n_decoded = decoded_ptr_->size();
      const auto n_to_decode = bit_packed_decoder_ptr_->remaining();
      decoded_ptr_->resize(n_decoded + n_to_decode);
      EXPECT_EQ(bit_packed_decoder_ptr_->GetBatch(decoded_ptr_->data() + n_decoded,
                                                  n_to_decode, bit_width_),
                n_to_decode);
      EXPECT_EQ(bit_packed_decoder_ptr_->remaining(), 0);

      return RleBitPackedParser::ControlFlow::Continue;
    }
  } handler{&rle_decoder, &bit_packed_decoder, &decoded, bit_width};

  // Iterate over all runs
  parser.Parse(handler);

  EXPECT_TRUE(parser.exhausted());
  EXPECT_EQ(decoded.size(), expected.size());
  EXPECT_EQ(decoded, expected);
}

void TestRleBitPackedParserError(std::span<const uint8_t> bytes, rle_size_t bit_width) {
  auto parser =