tests/test_varint.cpp - master - smychkov/SStorage

tests/test_varint.cpp
119 строк4 KB
Андрей Смычков
feat: util varint, crc32c, murmur3, compression (snappy)
25 апр 2026, 09:00
25 апр 2026, 09:00a7cf584
//============================================================================
// Тесты для varint-кодирования
//============================================================================
#include "../src/util/varint.hpp"
#include <cassert>
#include <iostream>
#include <limits>
#include <string>

using namespace sstorage::util;

static int g_passed = 0;
static int g_failed = 0;

#define CHECK(cond) do { \
    if (cond) { ++g_passed; } \
    else { ++g_failed; std::cerr << "FAIL: " #cond " at line " << __LINE__ << "\n"; } \
} while (0)

// Roundtrip-тест для одного значения
static void testRoundtrip(uint64_t value) {
    std::string buf;
    encodeVarint(value, buf);

    uint64_t decoded;
    size_t consumed;
    CHECK(decodeVarint(buf.data(), buf.size(), decoded, consumed));
    CHECK(decoded == value);
    CHECK(consumed == buf.size());
    CHECK(consumed == varintLength(value));
}

int main() {
    // Нуле��ое значение
    testRoundtrip(0);
    // Граница между 1 и 2 байтами
    testRoundtrip(127);
    testRoundtrip(128);
    // Граница 2/3 байта
    testRoundtrip(16383);
    testRoundtrip(16384);
    // Большие значения
    testRoundtrip(1000000);
    testRoundtrip(1ULL << 32);
    testRoundtrip(std::numeric_limits<uint64_t>::max());

    // Проверка длины
    CHECK(varintLength(0) == 1);
    CHECK(varintLength(127) == 1);
    CHECK(varintLength(128) == 2);
    CHECK(varintLength(16383) == 2);
    CHECK(varintLength(16384) == 3);
    CHECK(varintLength(std::numeric_limits<uint64_t>::max()) == 10);

    // Обрыв данных — декодирование должно упасть
    {
        std::string buf;
        encodeVarint(1000000, buf);
        // Обрезаем п��следний байт, оставляем continuation-биты висящими
        uint64_t value;
        size_t consumed;
        CHECK(!decodeVarint(buf.data(), buf.size() - 1, value, consumed));
    }

    // Пустой буфер
    {
        uint64_t value;
        size_t consumed;
        CHECK(!decodeVarint(nullptr, 0, value, consumed));
    }

    // ZigZag: проверка кодирования
    CHECK(zigzagEncode(0) == 0);
    CHECK(zigzagEncode(-1) == 1);
    CHECK(zigzagEncode(1) == 2);
    CHECK(zigzagEncode(-2) == 3);
    CHECK(zigzagEncode(2) == 4);

    // ZigZag: roundtrip для отрицательных
    for (int64_t v : {(int64_t)0, (int64_t)-1, (int64_t)1, (int64_t)-1000000, (int64_t)1000000,
                     std::numeric_limits<int64_t>::min(),
                     std::numeric_limits<int64_t>::max()}) {
        std::string buf;
        encodeVarintSigned(v, buf);
        int64_t decoded;
        size_t consumed;
        CHECK(decodeVarintSigned(buf.data(), buf.size(), decoded, consumed));
        CHECK(decoded == v);
    }

    // Множественные varint подряд — consumed должен правильно двигаться
    {
        std::string buf;
        encodeVarint(10, buf);
        encodeVarint(1000, buf);
        encodeVarint(100000, buf);

        uint64_t v;
        size_t consumed;
        size_t offset = 0;

        CHECK(decodeVarint(buf.data() + offset, buf.size() - offset, v, consumed));
        CHECK(v == 10);
        offset += consumed;

        CHECK(decodeVarint(buf.data() + offset, buf.size() - offset, v, consumed));
        CHECK(v == 1000);
        offset += consumed;

        CHECK(decodeVarint(buf.data() + offset, buf.size() - offset, v, consumed));
        CHECK(v == 100000);
        offset += consumed;

        CHECK(offset == buf.size());
    }

    std::cout << "test_varint: passed=" << g_passed << " failed=" << g_failed << "\n";
    return g_failed == 0 ? 0 : 1;
}