/*
 *     .============.
 *    //  M A K E  / \
 *   //  C++ DEV  /   \
 *  //  E A S Y  /  \/ \
 * ++ ----------.  \/\  .
 *  \\     \     \ /\  /
 *   \\     \     \   /
 *    \\     \     \ /
 *     -============'
 *
 * Copyright (c) 2018 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 <gtest/gtest.h>
#include "serializer.h"

using namespace tbox::util;

TEST(Serializer, big_endian_raw) {
    uint8_t data_to_be[] = {
        0x01,
        0x02, 0x03,
        0x04, 0x05, 0x06, 0x07,
        0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
        0x21, 0x22
    };
    uint8_t data_be_write[17] = {0x00};

    Serializer w(data_be_write, sizeof(data_be_write));
    w.setEndian(Endian::kBig);

    EXPECT_TRUE(w.append(uint8_t(1)));
    EXPECT_TRUE(w.append(uint16_t(0x0203)));
    EXPECT_TRUE(w.append(uint32_t(0x04050607)));
    EXPECT_TRUE(w.append(uint64_t(0x1112131415161718ull)));
    uint8_t tmp[2] = {0x21, 0x22};
    EXPECT_TRUE(w.append(tmp, 2));
    EXPECT_FALSE(w.append(uint8_t(1)));

    EXPECT_EQ(0, memcmp(data_to_be, data_be_write, sizeof(data_be_write)));
}

TEST(Serializer, big_endian_vector) {
    uint8_t data_to_be[] = {
        0x01,
        0x02, 0x03,
        0x04, 0x05, 0x06, 0x07,
        0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
        0x21, 0x22
    };

    std::vector<uint8_t> data_be_write;
    Serializer w(data_be_write);
    w.setEndian(Endian::kBig);

    EXPECT_TRUE(w.append(uint8_t(1)));
    EXPECT_TRUE(w.append(uint16_t(0x0203)));
    EXPECT_TRUE(w.append(uint32_t(0x04050607)));
    EXPECT_TRUE(w.append(uint64_t(0x1112131415161718ull)));
    uint8_t tmp[2] = {0x21, 0x22};
    EXPECT_TRUE(w.append(tmp, 2));
    EXPECT_EQ(data_be_write.size(), 17u);

    EXPECT_EQ(0, memcmp(data_to_be, data_be_write.data(), sizeof(data_to_be)));
}

TEST(Serializer, big_endian_stream) {
    const uint8_t data_to_be[] = {
        0x01,
        0x02, 0x03,
        0x04, 0x05, 0x06, 0x07,
        0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
    };
    uint8_t data_be_write[sizeof(data_to_be)] = {0x00};

    Serializer w(data_be_write, sizeof(data_be_write));
    w << Endian::kBig << uint8_t(1) << uint16_t(0x0203) << uint32_t(0x04050607) << uint64_t(0x1112131415161718ull);

    EXPECT_EQ(0, memcmp(data_to_be, data_be_write, sizeof(data_to_be)));
}

TEST(Serializer, little_endian) {
    const uint8_t data_to_be[] = {
        0x01,
        0x02, 0x03,
        0x04, 0x05, 0x06, 0x07,
        0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
        0x21, 0x22
    };
    uint8_t data_be_write[sizeof(data_to_be)] = {0x00};

    Serializer w(data_be_write, sizeof(data_be_write));
    w.setEndian(Endian::kLittle);

    EXPECT_TRUE(w.append(uint8_t(1)));
    EXPECT_TRUE(w.append(uint16_t(0x0302)));
    EXPECT_TRUE(w.append(uint32_t(0x07060504)));
    EXPECT_TRUE(w.append(uint64_t(0x1817161514131211ull)));
    uint8_t tmp[2] = {0x21, 0x22};
    EXPECT_TRUE(w.append(tmp, 2));
    EXPECT_FALSE(w.append(uint8_t(1)));

    EXPECT_EQ(0, memcmp(data_to_be, data_be_write, sizeof(data_to_be)));
}

TEST(Serializer, little_endian_stream) {
    uint8_t data_to_be[] = {
        0x01,
        0x02, 0x03,
        0x04, 0x05, 0x06, 0x07,
        0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
    };
    uint8_t data_be_write[sizeof(data_to_be)] = {0x00};

    Serializer w(data_be_write, sizeof(data_be_write));
    w << Endian::kLittle << uint8_t(1) << uint16_t(0x0302) << uint32_t(0x07060504) << uint64_t(0x1817161514131211ull);

    EXPECT_EQ(0, memcmp(data_to_be, data_be_write, sizeof(data_to_be)));
}

TEST(Deserializer, big_endian) {
    uint8_t data_be_read[] = {
        0x01,
        0x02, 0x03,
        0x04, 0x05, 0x06, 0x07,
        0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
        0x21, 0x22, 0x23, 0x24
    };

    Deserializer r(data_be_read, sizeof(data_be_read));
    r.setEndian(Endian::kBig);

    uint8_t u8;
    EXPECT_TRUE(r.fetch(u8));
    EXPECT_EQ(u8, 0x1);

    uint16_t u16;
    EXPECT_TRUE(r.fetch(u16));
    EXPECT_EQ(u16, 0x0203);

    uint32_t u32;
    EXPECT_TRUE(r.fetch(u32));
    EXPECT_EQ(u32, 0x04050607ul);

    uint64_t u64;
    EXPECT_TRUE(r.fetch(u64));
    EXPECT_EQ(u64, 0x1112131415161718ull);

    uint8_t read_out[2];
    EXPECT_TRUE(r.fetch(read_out, 2));
    EXPECT_EQ(read_out[0], 0x21);
    EXPECT_EQ(read_out[1], 0x22);

    EXPECT_FALSE(r.fetch(u32));
}

TEST(Deserializer, big_endian_stream) {
    uint8_t data_be_read[] = {
        0x01,
        0x02, 0x03,
        0x04, 0x05, 0x06, 0x07,
        0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
    };

    Deserializer r(data_be_read, sizeof(data_be_read));

    uint8_t u8;
    uint16_t u16;
    uint32_t u32;
    uint64_t u64;

    r >> Endian::kBig >> u8 >> u16 >> u32 >> u64;

    EXPECT_EQ(u8, 0x1);
    EXPECT_EQ(u16, 0x0203);
    EXPECT_EQ(u32, 0x04050607ul);
    EXPECT_EQ(u64, 0x1112131415161718ull);
}

TEST(Deserializer, little_endian) {
    uint8_t data_be_read[] = {
        0x01,
        0x02, 0x03,
        0x04, 0x05, 0x06, 0x07,
        0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
        0x21, 0x22, 0x23, 0x24
    };

    Deserializer r(data_be_read, sizeof(data_be_read));
    r.setEndian(Endian::kLittle);

    uint8_t u8;
    EXPECT_TRUE(r.fetch(u8));
    EXPECT_EQ(u8, 0x1);

    uint16_t u16;
    EXPECT_TRUE(r.fetch(u16));
    EXPECT_EQ(u16, 0x0302);

    uint32_t u32;
    EXPECT_TRUE(r.fetch(u32));
    EXPECT_EQ(u32, 0x07060504ul);

    uint64_t u64;
    EXPECT_TRUE(r.fetch(u64));
    EXPECT_EQ(u64, 0x1817161514131211ull);

    uint8_t read_out[2];
    EXPECT_TRUE(r.fetch(read_out, 2));
    EXPECT_EQ(read_out[0], 0x21);
    EXPECT_EQ(read_out[1], 0x22);

    EXPECT_FALSE(r.fetch(u32));
}

TEST(Deserializer, little_endian_stream) {
    uint8_t data_be_read[] = {
        0x01,
        0x02, 0x03,
        0x04, 0x05, 0x06, 0x07,
        0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
    };

    Deserializer r(data_be_read, sizeof(data_be_read));

    uint8_t u8;
    uint16_t u16;
    uint32_t u32;
    uint64_t u64;

    r >> Endian::kLittle >> u8 >> u16 >> u32 >> u64;

    EXPECT_EQ(u8, 0x1);
    EXPECT_EQ(u16, 0x0302);
    EXPECT_EQ(u32, 0x07060504ul);
    EXPECT_EQ(u64, 0x1817161514131211ull);
}

TEST(SerializerDeserialize, big_endian)
{
    uint8_t buff[50];
    Serializer s(buff, sizeof(buff), Endian::kBig);
    s << int8_t(-1) << uint8_t(2) << int16_t(-3) << uint16_t(4) << int32_t(-5) << uint32_t(6)
        << int64_t(-7) << uint64_t(8) << float(1.0) << double(12.3);

    int8_t i8;
    uint8_t u8;
    int16_t i16;
    uint16_t u16;
    int32_t i32;
    uint32_t u32;
    int64_t i64;
    uint64_t u64;
    float ff;
    double dd;

    Deserializer d(buff, s.pos(), Endian::kBig);
    d >> i8 >> u8 >> i16 >> u16 >> i32 >> u32 >> i64 >> u64 >> ff >> dd;

    EXPECT_EQ(i8, -1);
    EXPECT_EQ(u8, 2);
    EXPECT_EQ(i16, -3);
    EXPECT_EQ(u16, 4);
    EXPECT_EQ(i32, -5);
    EXPECT_EQ(u32, 6);
    EXPECT_EQ(i64, -7);
    EXPECT_EQ(u64, 8);
    EXPECT_FLOAT_EQ(ff, 1.0);
    EXPECT_DOUBLE_EQ(dd, 12.3);
}

TEST(SerializerDeserialize, little_endian)
{
    uint8_t buff[50];
    Serializer s(buff, sizeof(buff), Endian::kLittle);
    s << int8_t(-1) << uint8_t(2) << int16_t(-3) << uint16_t(4) << int32_t(-5) << uint32_t(6)
        << int64_t(-7) << uint64_t(8) << float(1.0) << double(12.3);

    int8_t i8;
    uint8_t u8;
    int16_t i16;
    uint16_t u16;
    int32_t i32;
    uint32_t u32;
    int64_t i64;
    uint64_t u64;
    float ff;
    double dd;

    Deserializer d(buff, s.pos(), Endian::kLittle);
    d >> i8 >> u8 >> i16 >> u16 >> i32 >> u32 >> i64 >> u64 >> ff >> dd;

    EXPECT_EQ(i8, -1);
    EXPECT_EQ(u8, 2);
    EXPECT_EQ(i16, -3);
    EXPECT_EQ(u16, 4);
    EXPECT_EQ(i32, -5);
    EXPECT_EQ(u32, 6);
    EXPECT_EQ(i64, -7);
    EXPECT_EQ(u64, 8);
    EXPECT_FLOAT_EQ(ff, 1.0);
    EXPECT_DOUBLE_EQ(dd, 12.3);
}