Function test_compression

test/storage/compression_test.cpp:162–223

template<typename T>
void test_compression(CompressionAlg& alg, std::vector<T> src, bool force_offset_zero = true) {
    if (force_offset_zero) {
        // Force offset of 0 for bitpacking
        src[0] = 0;
    }
    auto pageSize = 4096;
    std::vector<uint8_t> dest(pageSize);

    const auto& [min, max] = std::minmax_element(src.begin(), src.end());
    auto metadata =
        CompressionMetadata(StorageValue(*min), StorageValue(*max), alg.getCompressionType());
    // For simplicity, we'll ignore the possibility of it requiring multiple pages
    // That's tested separately

    auto numValuesRemaining = src.size();
    const uint8_t* srcCursor = (uint8_t*)src.data();
    alg.compressNextPage(srcCursor, numValuesRemaining, dest.data(), pageSize, metadata);
    std::vector<T> decompressed(src.size());
    alg.decompressFromPage(dest.data(), 0 /*srcOffset*/, (uint8_t*)decompressed.data(),
        0 /*dstOffset*/, src.size(), metadata);
    EXPECT_EQ(src, decompressed);
    // works with all bit widths (but not all offsets)
    T value = 0;
    if (!force_offset_zero) {
        // make sure we can update in place to not fail runtime assertions
        value = *std::min_element(src.begin(), src.end());
    }

    alg.setValuesFromUncompressed((uint8_t*)&value, 0 /*srcOffset*/, (uint8_t*)dest.data(),
        1 /*dstOffset*/, 1 /*numValues*/, metadata, nullptr /*nullMask*/);
    alg.decompressFromPage(dest.data(), 0 /*srcOffset*/, (uint8_t*)decompressed.data(),
        0 /*dstOffset*/, src.size(), metadata);
    src[1] = value;
    EXPECT_EQ(decompressed, src);
    EXPECT_EQ(decompressed[1], value);

    for (auto i = 0u; i < src.size(); i++) {
        alg.decompressFromPage(dest.data(), i, (uint8_t*)decompressed.data(), i, 1 /*numValues*/,
            metadata);
        EXPECT_EQ(decompressed[i], src[i]);
    }
    EXPECT_EQ(decompressed, src);

    // Decompress part of a page
    decompressed.clear();
    decompressed.resize(src.size() / 2);
    alg.decompressFromPage(dest.data(), src.size() / 3 /*srcOffset*/, (uint8_t*)decompressed.data(),
        0 /*dstOffset*/, src.size() / 2 /*numValues*/, metadata);
    auto expected = std::vector(src);
    expected.erase(expected.begin(), expected.begin() + src.size() / 3);
    expected.resize(src.size() / 2);
    EXPECT_EQ(decompressed, expected);

    decompressed.clear();
    decompressed.resize(src.size() / 2);
    alg.decompressFromPage(dest.data(), src.size() / 7 /*srcOffset*/, (uint8_t*)decompressed.data(),
        0 /*dstOffset*/, src.size() / 2 /*numValues*/, metadata);
    expected = std::vector(src);