/*
 * .============.
 * // 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>

//! 放开权限,方便测试
#define protected public
#define private public

#include "buffer.h"

namespace tbox {
namespace util {

TEST(Buffer, constuct) {
 Buffer b1;
 EXPECT_EQ(b1.readableSize(), 0u);

 Buffer b2(b1);
 EXPECT_EQ(b2.readableSize(), 0u);
}

TEST(Buffer, append_and_fetch) {
 Buffer b1(0);
 //! 先插入4个字节
 b1.append("abcd", 4);
 EXPECT_EQ(b1.readableSize(), 4u);
 //! 再插入4个字节
 b1.append("efgh", 4);
 EXPECT_EQ(b1.readableSize(), 8u);
 //! 将所有的数据读出来
 char buff1[10] = { 0 };
 EXPECT_EQ(b1.fetch(buff1, 10), 8u);
 EXPECT_STREQ(buff1, "abcdefgh");
 //! 现在缓冲区空了
 EXPECT_EQ(b1.readableSize(), 0u);
}

/**
 * 设置缓冲初始长度为8,先写入7字节,再读走5字节,再写入5字节
 * 检查缓冲区长度是否是8字节。
 * 本测试的目的是观察在写入时缓冲区长度不够时,Buffer会不会移动可读取的数据
 */
TEST(Buffer, append_and_move_data) {
 Buffer b1(8);
 b1.append("1234567", 7); //! 插入后只剩1字节
 b1.hasRead(5); //! 读走5字节
 b1.append("89abc", 5); //! 插入5字节
 EXPECT_EQ(b1.buffer_size_, 8u);
 char buff[10] = { 0 };
 EXPECT_EQ(b1.fetch(buff, 10), 7u);
 EXPECT_STREQ(buff, "6789abc");
 EXPECT_EQ(b1.readableSize(), 0u);
}

/**
 * 检查通过readBegin()读取数据是否正常
 */
TEST(Buffer, readBegin_hasRead) {
 Buffer b(8);
 const char *str = "hello world, my name is Sid Lee";
 size_t str_size = strlen(str) + 1;
 b.append(str, str_size);
 EXPECT_EQ(b.readableSize(), str_size);
 EXPECT_STREQ((const char*)b.readableBegin(), str);
 b.hasRead(14);
 EXPECT_STREQ((const char*)b.readableBegin(), (str + 14));

 b.hasRead(500);
 EXPECT_EQ(b.readableSize(), 0u);
}

/**
 * 检查通过writeBegin()写数据是否正常
 */
TEST(Buffer, writeBegin_hasWriten) {
 Buffer b(0);
 const char *str = "hello world";
 size_t str_size = strlen(str) + 1;
 b.ensureWritableSize(str_size);
 strcpy((char*)b.writableBegin(), str);
 b.hasWritten(str_size);

 EXPECT_STREQ((const char*)b.readableBegin(), str);
}

TEST(Buffer, swap) {
 Buffer b1(8);
 b1.append("abc", 4);

 Buffer b2(2);
 b2.append("hello", 6);

 b1.swap(b2);
 EXPECT_EQ(b1.readableSize(), 6u);
 EXPECT_EQ(b2.readableSize(), 4u);
 EXPECT_STREQ((const char*)b1.readableBegin(), "hello");
 EXPECT_STREQ((const char*)b2.readableBegin(), "abc");
}

TEST(Buffer, reset) {
 Buffer b1(8);
 b1.append("abc", 4);
 b1.reset();

 EXPECT_EQ(b1.readableSize(), 0u);
 EXPECT_TRUE(b1.buffer_ptr_ == NULL);
}

TEST(Buffer, copy_construct) {
 Buffer b1(8);
 b1.append("abc", 4);
 Buffer b2(b1);
 EXPECT_EQ(b2.readableSize(), 4u);
 EXPECT_STREQ((const char*)b2.readableBegin(), "abc");
}

TEST(Buffer, move_construct) {
 Buffer b1(8);
 b1.append("abc", 4);
 Buffer b2(std::move(b1));
 EXPECT_EQ(b2.readableSize(), 4u);
 EXPECT_STREQ((const char*)b2.readableBegin(), "abc");

 EXPECT_EQ(b1.readableBegin(), nullptr);
 EXPECT_EQ(b1.readableSize(), 0u);
}

TEST(Buffer, copy_assign) {
 Buffer b1(8);
 b1.append("abc", 4);
 Buffer b2(43);
 b2.append("1234567890", 10);
 b2 = b1;
 EXPECT_EQ(b2.readableSize(), 4u);
 EXPECT_STREQ((const char*)b2.readableBegin(), "abc");
}

TEST(Buffer, move_assign) {
 Buffer b1(8);
 b1.append("abc", 4);
 Buffer b2(43);
 b2.append("1234567890", 10);
 b2 = std::move(b1);
 EXPECT_EQ(b2.readableSize(), 4u);
 EXPECT_STREQ((const char*)b2.readableBegin(), "abc");

 EXPECT_EQ(b1.readableBegin(), nullptr);
 EXPECT_EQ(b1.readableSize(), 0u);
}

TEST(Buffer, huge_data) {
 Buffer b;
 int orig_data[100] = { 0 };
 for (int i = 0; i < 100; ++i) {
 orig_data[i] = i;
 }

 //! 存入10000个数据
 for (int i = 0; i < 10000; ++i) {
 EXPECT_EQ(b.append(orig_data, sizeof(orig_data)), sizeof(orig_data));
 }

 EXPECT_EQ(b.readableSize(), (sizeof(orig_data) * 10000));
 size_t max_size = b.buffer_size_;

 //! 取走9000个数据
 for (int i = 0; i < 9000; ++i) {
 int read_data[100] = { 0 };
 EXPECT_EQ(b.fetch(read_data, sizeof(read_data)), sizeof(read_data));
 EXPECT_EQ(memcmp(read_data, orig_data, sizeof(read_data)), 0);
 }

 //! 再写入9000个数据
 for (int i = 0; i < 9000; ++i) {
 EXPECT_EQ(b.append(orig_data, sizeof(orig_data)), sizeof(orig_data));
 }

 //! 期望缓冲的空间大小没有变化
 EXPECT_EQ(max_size, b.buffer_size_);

 //! 取走10000个数据
 for (int i = 0; i < 10000; ++i) {
 int read_data[100] = { 0 };
 EXPECT_EQ(b.fetch(read_data, sizeof(read_data)), sizeof(read_data));
 EXPECT_EQ(memcmp(read_data, orig_data, sizeof(read_data)), 0);
 }

 //! 期望缓冲的空间大小没有变化
 EXPECT_EQ(max_size, b.buffer_size_);
 EXPECT_EQ(b.readableSize(), 0u);
}

TEST(Buffer, shrink_after_readsize_0) {
 Buffer b;
 for (int i = 0; i < 100; ++i)
 b.append("1234567890", 10);
 b.hasReadAll();
 b.shrink();
 EXPECT_EQ(b.buffer_ptr_, nullptr);
 //!使用valgrind检查内存是否存在泄漏
}

TEST(Buffer, shrink_after_readsize_not_0) {
 Buffer b;
 for (int i = 0; i < 100; ++i)
 b.append("1234567890", 10);
 b.hasRead(990);
 b.shrink();
 EXPECT_NE(b.buffer_ptr_, nullptr);
 EXPECT_EQ(b.readableSize(), 10);
 //!使用valgrind检查内存是否存在泄漏
}

TEST(Buffer, read_all_except_index_reset) {
 Buffer b;

 b.append("123456789", 10);
 char read_data[10] = { 0 };
 b.fetch(read_data, 10);

 EXPECT_EQ(b.read_index_, 0u);
 EXPECT_EQ(b.write_index_, 0u);
}

}
}