Function ValidateRleBitPacked

cpp/src/arrow/util/rle_encoding_test.cc:643–689

Validates encoding of values by encoding and decoding them. If expected_encoding != NULL, also validates that the encoded buffer is exactly 'expected_encoding'. if expected_len is not -1, it will validate the encoded size is correct.

// exactly 'expected_encoding'.
// if expected_len is not -1, it will validate the encoded size is correct.
void ValidateRleBitPacked(const std::vector<int>& values, int bit_width,
                          uint8_t* expected_encoding, int expected_len) {
  const int len = 64 * 1024;
#ifdef __EMSCRIPTEN__
  // don't make this on the stack as it is
  // too big for emscripten
  std::vector<uint8_t> buffer_vec(static_cast<size_t>(len));
  uint8_t* buffer = buffer_vec.data();
#else
  uint8_t buffer[len];
#endif
  EXPECT_LE(expected_len, len);

  RleBitPackedEncoder encoder(buffer, len, bit_width);
  for (size_t i = 0; i < values.size(); ++i) {
    bool result = encoder.Put(values[i]);
    EXPECT_TRUE(result);
  }
  int encoded_len = encoder.Flush();

  if (expected_len != -1) {
    EXPECT_EQ(encoded_len, expected_len);
  }
  if (expected_encoding != NULL && encoded_len == expected_len) {
    EXPECT_EQ(memcmp(buffer, expected_encoding, encoded_len), 0);
  }

  // Verify read
  {
    RleBitPackedDecoder<uint64_t> decoder(buffer, len, bit_width);
    for (size_t i = 0; i < values.size(); ++i) {
      uint64_t val;
      bool result = decoder.Get(&val);
      EXPECT_TRUE(result);
      EXPECT_EQ(values[i], val);
    }
  }

  // Verify batch read
  {
    RleBitPackedDecoder<int> decoder(buffer, len, bit_width);
    std::vector<int> values_read(values.size());
    ASSERT_EQ(values.size(),
              decoder.GetBatch(values_read.data(), static_cast<int>(values.size())));
    EXPECT_EQ(values, values_read);
  }
}

// A version of ValidateRle that round-trips the values and returns false if
// the returned values are not all the same