/*
 *     .============.
 *    //  M A K E  / \
 *   //  C++ DEV  /   \
 *  //  E A S Y  /  \/ \
 * ++ ----------.  \/\  .
 *  \\     \     \ /\  /
 *   \\     \     \   /
 *    \\     \     \ /
 *     -============'
 *
 * Copyright (c) 2024 Hevake and contributors, all rights reserved.
 *
 * This file is part of cpp-tbox (https://github.com/cpp-main/cpp-tbox)
 * Use of this source code is governed by MIT license that can be found
 * in the LICENSE file in the root of the source tree. All contributing
 * project authors may be found in the CONTRIBUTORS.md file in the root
 * of the source tree.
 */
#include <random>
#include <ctime>

#include <gtest/gtest.h>
#include "scalable_integer.h"

namespace tbox {
namespace util {

TEST(ScalableInteger, Dump_0) {
    uint8_t out_array[10];
    memset(out_array, 0xcc, sizeof(out_array));

    EXPECT_EQ(DumpScalableInteger(0, out_array, sizeof(out_array)), 1);
    EXPECT_EQ(out_array[0], 0);
    EXPECT_EQ(out_array[1], 0xcc);
}

TEST(ScalableInteger, Dump_127) {
    uint8_t out_array[10];
    memset(out_array, 0xcc, sizeof(out_array));

    EXPECT_EQ(DumpScalableInteger(127, out_array, sizeof(out_array)), 1);
    EXPECT_EQ(out_array[0], 127);
    EXPECT_EQ(out_array[1], 0xcc);
}

TEST(ScalableInteger, Dump_128) {
    uint8_t out_array[10];
    memset(out_array, 0xcc, sizeof(out_array));

    EXPECT_EQ(DumpScalableInteger(128, out_array, sizeof(out_array)), 2);
    EXPECT_EQ(out_array[0], 0x80);
    EXPECT_EQ(out_array[1], 0x00);
}

TEST(ScalableInteger, Dump_16511) {
    uint8_t out_array[10];
    memset(out_array, 0xcc, sizeof(out_array));

    EXPECT_EQ(DumpScalableInteger(16511, out_array, sizeof(out_array)), 2);
    EXPECT_EQ(out_array[0], 0xff);
    EXPECT_EQ(out_array[1], 0x7f);
}

TEST(ScalableInteger, Dump_16512) {
    uint8_t out_array[10];
    memset(out_array, 0xcc, sizeof(out_array));

    EXPECT_EQ(DumpScalableInteger(16512, out_array, sizeof(out_array)), 3);
    EXPECT_EQ(out_array[0], 0x80);
    EXPECT_EQ(out_array[1], 0x80);
    EXPECT_EQ(out_array[2], 0x00);
}

TEST(ScalableInteger, Parse_0) {
    uint8_t in_array[10];
    memset(in_array, 0xcc, sizeof(in_array));
    in_array[0] = 0;

    uint64_t value = 0xcc;
    EXPECT_EQ(ParseScalableInteger(in_array, sizeof(in_array), value), 1);
    EXPECT_EQ(value, 0);
}

TEST(ScalableInteger, Parse_127) {
    uint8_t in_array[10];
    memset(in_array, 0xcc, sizeof(in_array));
    in_array[0] = 0x7f;

    uint64_t value = 0xcc;
    EXPECT_EQ(ParseScalableInteger(in_array, sizeof(in_array), value), 1);
    EXPECT_EQ(value, 127);
}

TEST(ScalableInteger, Parse_128) {
    uint8_t in_array[10];
    memset(in_array, 0xcc, sizeof(in_array));
    in_array[0] = 0x80;
    in_array[1] = 0x00;

    uint64_t value = 0xcc;
    EXPECT_EQ(ParseScalableInteger(in_array, sizeof(in_array), value), 2);
    EXPECT_EQ(value, 128);
}

TEST(ScalableInteger, Parse_16511) {
    uint8_t in_array[10];
    memset(in_array, 0xcc, sizeof(in_array));
    in_array[0] = 0xff;
    in_array[1] = 0x7f;

    uint64_t value = 0xcc;
    EXPECT_EQ(ParseScalableInteger(in_array, sizeof(in_array), value), 2);
    EXPECT_EQ(value, 16511);
}

TEST(ScalableInteger, Parse_16512) {
    uint8_t in_array[10];
    memset(in_array, 0xcc, sizeof(in_array));
    in_array[0] = 0x80;
    in_array[1] = 0x80;
    in_array[2] = 0x00;

    uint64_t value = 0xcc;
    EXPECT_EQ(ParseScalableInteger(in_array, sizeof(in_array), value), 3);
    EXPECT_EQ(value, 16512);
}

TEST(ScalableInteger, DumpAndParseMax) {
    uint8_t array[10];

    memset(array, 0xcc, sizeof(array));
    uint64_t max_value = std::numeric_limits<uint64_t>::max();
    EXPECT_EQ(DumpScalableInteger(max_value, array, sizeof(array)), 10);

    uint64_t value = 0;
    EXPECT_EQ(ParseScalableInteger(array, sizeof(array), value), 10);
    EXPECT_EQ(value, max_value);
}

//! 产生随机数，存入然后读出，对比
TEST(ScalableInteger, DumpAndParseRandom) {
    std::default_random_engine e;
    e.seed(time(nullptr));
    std::uniform_int_distribution<uint64_t> u(0, std::numeric_limits<uint64_t>::max());

    uint8_t array[10];

    for (int i = 0; i < 100000; ++i) {
        uint64_t write_value = u(e);
        EXPECT_NE(DumpScalableInteger(write_value, array, sizeof(array)), 0);

        uint64_t read_value = 0;
        EXPECT_NE(ParseScalableInteger(array, sizeof(array), read_value), 0);
        EXPECT_EQ(write_value, read_value);
    }
}

}
}