Function CheckDecoderValuesChunked

cpp/src/arrow/util/rle_bitmap_test.cc:104–140

/// and only the aligned path runs.
template <typename Decoder>
void CheckDecoderValuesChunked(const typename Decoder::RunType& run,
                               const std::vector<bool>& expected,
                               rle_size_t chunk_size = 1, rle_size_t expected_skip = 0) {
  ARROW_SCOPED_TRACE("chunk_size = ", chunk_size, ", expected_skip = ", expected_skip);

  const auto n_vals = static_cast<rle_size_t>(expected.size());
  ASSERT_LE(expected_skip, n_vals);

  Decoder decoder(run);
  const auto advanced = decoder.Advance(expected_skip);
  ASSERT_EQ(advanced, expected_skip);
  const auto n_vals_to_decode = n_vals - expected_skip;

  // Output buffer
  const auto n_bytes = static_cast<size_t>(bit_util::BytesForBits(n_vals_to_decode));
  std::vector<uint8_t> out(n_bytes, 0);

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

  EXPECT_EQ(decoder.remaining(), 0);
  CheckDecodedBits({
      .actual = out,
      .expected = expected,
      .count = n_vals_to_decode,
      .actual_start_bit = 0,
      .expected_start_idx = expected_skip,
  });
}

/// Decode a chunk of data into a known output to check for out of bounds write.
///