Function CheckRleBitPackedDecode

cpp/src/arrow/util/rle_bitmap_test.cc:411–452

Decode the whole `bytes` into a bitmap and check it against `expected`. Decode `chunk_size` values per GetBatch call to check the decoder state between calls. The output starts at bit offset `out_offset`. A non-zero offset makes the output and the encoded `bytes` use different bit alignment.

/// calls. The output starts at bit offset `out_offset`. A non-zero offset makes
/// the output and the encoded `bytes` use different bit alignment.
void CheckRleBitPackedDecode(const std::vector<uint8_t>& bytes,
                             const std::vector<bool>& expected, rle_size_t chunk_size,
                             rle_size_t out_offset = 0) {
  ARROW_SCOPED_TRACE("chunk_size = ", chunk_size, ", out_offset = ", out_offset);
  const auto n_vals = static_cast<rle_size_t>(expected.size());

  RleBitPackedToBitmapDecoder decoder(bytes.data(),
                                      static_cast<rle_size_t>(bytes.size()));
  EXPECT_EQ(decoder.exhausted(), n_vals == 0);

  // Output buffer with one guard byte to catch out-of-bounds writes.
  std::vector<uint8_t> out(
      static_cast<size_t>(bit_util::BytesForBits(out_offset + n_vals)) + 1, 0);
  const uint8_t guard = 0xA5;
  out.back() = guard;

  rle_size_t read = 0;
  while (read < n_vals) {
    const auto want = std::min(chunk_size, n_vals - read);
    const auto got = decoder.GetBatch(
        BitmapSpanMut(out.data(), /*bit_start=*/out_offset + read), want);
    EXPECT_EQ(got, want) << "at pos " << read;
    ASSERT_GT(got, 0) << "at pos " << read;  // break on failure
    read += got;
  }

  EXPECT_EQ(read, n_vals);
  EXPECT_TRUE(decoder.exhausted());
  // Reading past the end yields nothing and leaves the decoder exhausted.
  uint8_t scratch = 0;
  const auto past_end = decoder.GetBatch(BitmapSpanMut(&scratch), 8);
  EXPECT_EQ(past_end, 0);
  EXPECT_TRUE(decoder.exhausted());

  EXPECT_EQ(out.back(), guard) << "decoder wrote past the end of the output";
  CheckDecodedBits({
      .actual = out,
      .expected = expected,
      .count = n_vals,
      .actual_start_bit = out_offset,
  });
}

/// Run the decode check over a battery of chunk sizes and output offsets.
void CheckRleBitPackedToBitmap(const std::vector<uint8_t>& bytes,