Function RandomUnpackAndDecodeTest

be/src/util/bit-packing-test.cc:264–305

// bit-packed literal run (no RLE).
template <typename UINT_T>
void RandomUnpackAndDecodeTest() {
  constexpr int MAX_BITWIDTH = BitPacking::MAX_BITWIDTH;
  const int max_bit_width = std::min<int>({MAX_BITWIDTH, sizeof(UINT_T) * 8,
      sizeof(uint32_t) * 8 /* dictionary indices are 32 bit values */});

  const std::vector<int> lengths = GetLengths();

  for (int bit_width = 0; bit_width <= max_bit_width; ++bit_width) {
    const UINT_T max_dict_size = bit_width == sizeof(UINT_T) * 8
        ? std::numeric_limits<UINT_T>::max() : (1UL << bit_width);

    const std::vector<UINT_T> input = GenerateRandomInput<UINT_T>(NUM_IN_VALUES, 0,
        max_dict_size - 1 /* inclusive range */);

    for (int length : lengths) {
      const std::vector<UINT_T> in_data(input.begin(), input.begin() + length);

      std::pair<std::vector<UINT_T>, std::vector<uint8_t>> dict_and_data
          = DictEncode(in_data, bit_width);
      std::vector<UINT_T>& dict = dict_and_data.first;
      const std::vector<uint8_t>& data = dict_and_data.second;

      const std::vector<int> strides = {sizeof(UINT_T), sizeof(UINT_T) + 5,
        2 * sizeof(UINT_T) + 5};

      for (int stride : strides) {
        bool decode_error = false;
        std::vector<uint8_t> out(in_data.size() * stride);

        std::pair<const uint8_t*, int64_t> res
            = BitPacking::UnpackAndDecodeValues<UINT_T>(bit_width, data.data(),
                data.size(), dict.data(), dict.size(), in_data.size(),
            reinterpret_cast<UINT_T*>(out.data()), stride, &decode_error);

        EXPECT_FALSE(decode_error);
        EXPECT_EQ(in_data.size(), res.second);
        ExpectEqualsWithStride<UINT_T>(in_data.data(), in_data.size(), out.data(),
            out.size(), stride);
      }
    }
  }
}

TEST(BitPackingTest, RandomUnpackAndDecode8) {
  RandomUnpackAndDecodeTest<uint8_t>();