Function CheckDecoderClobber

cpp/src/arrow/util/rle_bitmap_test.cc:146–201

/// @see CheckDecoderValuesChunked
template <typename Decoder>
void CheckDecoderClobber(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 with enough capacity to store a full chunk plus extra bytes as
  // clobbers/guard to check for out of bounds write.
  const auto n_bytes = static_cast<size_t>(bit_util::BytesForBits(chunk_size) +
                                           bit_util::CeilDiv(n_vals, chunk_size) + 2);
  // This seed is arbitrary and of little importance. We are simply trying to avoid an
  // unlikely case where guards have the same pattern in all invocations.
  const auto out_pattern =
      MakeRandomBytes(n_bytes, /* seed= */ (chunk_size << 16) ^ expected_skip);
  auto out = out_pattern;

  rle_size_t n_val_read = 0;
  rle_size_t out_bit_start = 0;
  while (n_val_read < n_vals_to_decode) {
    // Clean output buffer
    out = out_pattern;
    const auto want = std::min(chunk_size, n_vals_to_decode - n_val_read);
    const auto got = decoder.GetBatch(BitmapSpanMut(out.data(), out_bit_start), want);
    ASSERT_GT(got, 0) << "at pos " << n_val_read;  // break on failure
    EXPECT_EQ(got, want) << "at pos " << n_val_read;
    // Check that the leading bits have not been modified
    CheckBitsEqual({.actual = out, .expected = out_pattern, .count = out_bit_start});
    // Check that the trailing bits have not been modified
    CheckBitsEqual({
        .actual = out,
        .expected = out_pattern,
        .count = static_cast<rle_size_t>(8 * n_bytes) - (out_bit_start + want),
        .actual_start_bit = out_bit_start + want,
        .expected_start_bit = out_bit_start + want,
    });
    // Check decoded bits are also correct
    CheckDecodedBits({
        .actual = out,
        .expected = expected,
        .count = want,
        .actual_start_bit = out_bit_start,
        .expected_start_idx = expected_skip + n_val_read,
    });

    n_val_read += got;
    ++out_bit_start;
    EXPECT_EQ(decoder.remaining(), n_vals_to_decode - n_val_read);
  }
}

/// All the checks shared by both decoder types.