Function CheckBitmapDecoder

cpp/src/arrow/util/rle_bitmap_test.cc:207–286

/// `expected` is the full sequence of booleans the run should decode to.
template <typename Decoder>
void CheckBitmapDecoder(const typename Decoder::RunType& run,
                        const std::vector<bool>& expected) {
  const auto n_vals = static_cast<rle_size_t>(expected.size());

  // remaining() reflects the run size before any value is read.
  {
    Decoder decoder(run);
    EXPECT_EQ(decoder.remaining(), n_vals);
  }

  // Empty requests are a no-op.
  {
    Decoder decoder(run);
    uint8_t out = 0;
    const auto got = decoder.GetBatch(BitmapSpanMut(&out), /*batch_size=*/0);
    EXPECT_EQ(got, 0);
    EXPECT_EQ(decoder.remaining(), n_vals);
  }

  // Decode the whole run in several chunks.
  for (const rle_size_t chunk_size : {rle_size_t{1}, rle_size_t{3}, rle_size_t{7},
                                      rle_size_t{8}, rle_size_t{9}, n_vals, n_vals + 1}) {
    CheckDecoderValuesChunked<Decoder>(run, expected, chunk_size);
  }

  // Decode the whole run in several chunks, after an initial Advance that shifts
  // the run and output bit alignment.
  for (const rle_size_t chunk_size : {rle_size_t{1}, rle_size_t{3}, rle_size_t{7},
                                      rle_size_t{8}, rle_size_t{9}, n_vals, n_vals + 1}) {
    for (rle_size_t expected_skip = 1; expected_skip < 8 && expected_skip < n_vals;
         ++expected_skip) {
      // Check the decoding happens as expected
      CheckDecoderValuesChunked<Decoder>(run, expected, chunk_size, expected_skip);
      // Check the decoding does not write out of bounds
      CheckDecoderClobber<Decoder>(run, expected, chunk_size, expected_skip);
    }
  }

  // Get() one value at a time, then read past the end.
  {
    Decoder decoder(run);
    std::vector<uint8_t> out(static_cast<size_t>(bit_util::BytesForBits(n_vals)) + 1, 0);
    for (rle_size_t i = 0; i < n_vals; ++i) {
      const bool ok = decoder.Get(BitmapSpanMut(out.data(), /*bit_start=*/i));
      EXPECT_TRUE(ok);
      EXPECT_EQ(decoder.remaining(), n_vals - i - 1);
    }
    // Exhausted: nothing more can be read or advanced.
    const bool ok = decoder.Get(BitmapSpanMut(out.data()));
    EXPECT_FALSE(ok);
    const auto advanced = decoder.Advance(1);
    EXPECT_EQ(advanced, 0);
    EXPECT_EQ(decoder.remaining(), 0);
    CheckDecodedBits({.actual = out, .expected = expected, .count = n_vals});
  }

  // Advancing more than available stops at the run boundary.
  {