dl/project/dl_unit_test/test_memory.cpp

/**
* @file		test_memory.cpp
* @brief	memory 模块单元测试（压缩）
*
*
* @version	1.0
* @author	CodeBuddy
* @date		26-09-03
*
* @note		
*/
#include <gtest/gtest.h>

#include "memory/dl_memory.h"
#include "memory/dl_stream_output.h"
#include "memory/dl_stream_input.h"
#include "base/dl_string.h"

TEST(MemoryTest, CompressLz4)
{
	std::string str("abcabcabcabcabc");
	dl::BufferView buf = dl::CreateBufferView(str);
	dl::Buffer zip = dl::Memory::CompressLz4(buf);
	EXPECT_FALSE(zip.empty());

	dl::Buffer unzip = dl::Memory::DecompressLz4(zip);
	EXPECT_EQ(dl::to_string(unzip), str);
}

TEST(MemoryTest, DecompressLz4WithSize)
{
	std::string str("hello world hello world");
	dl::BufferView buf = dl::CreateBufferView(str);
	dl::Buffer zip = dl::Memory::CompressLz4(buf);

	dl::Buffer unzip = dl::Memory::DecompressLz4(zip, str.size());
	EXPECT_EQ(dl::to_string(unzip), str);
}

TEST(MemoryTest, CompressZip)
{
	std::string str("abcabcabcabcabc");
	dl::BufferView buf = dl::CreateBufferView(str);
	dl::Buffer zip = dl::Memory::CompressZip(buf);
	EXPECT_FALSE(zip.empty());

	dl::Buffer unzip = dl::Memory::DecompressZip(zip);
	EXPECT_EQ(dl::to_string(unzip), str);
}

TEST(MemoryTest, CompressEmpty)
{
	std::string str;
	dl::BufferView buf = dl::CreateBufferView(str);
	dl::Buffer zip = dl::Memory::CompressLz4(buf);
	dl::Buffer unzip = dl::Memory::DecompressLz4(zip);
	EXPECT_EQ(dl::to_string(unzip), str);
}

//------------------------------Stream 序列化往返------------------------------
TEST(StreamTest, WriteReadBasic)
{
	dl::StreamOutput s;
	int a = 42;
	float b = 3.14f;
	double c = 2.718;
	s.Write(&a);
	s.Write(&b);
	s.Write(&c);

	dl::Buffer buf = s.ToBuffer();
	dl::StreamInput in;
	in.LoadFromMemory(buf);

	int a2 = 0;
	float b2 = 0;
	double c2 = 0;
	in.Read(&a2);
	in.Read(&b2);
	in.Read(&c2);

	EXPECT_EQ(a2, 42);
	EXPECT_FLOAT_EQ(b2, 3.14f);
	EXPECT_DOUBLE_EQ(c2, 2.718);
}

TEST(StreamTest, WriteRead64)
{
	dl::StreamOutput s;
	size_t v = 123456789;
	s.Write64(&v);

	dl::Buffer buf = s.ToBuffer();
	dl::StreamInput in;
	in.LoadFromMemory(buf);

	size_t v2 = 0;
	in.Read64(&v2);
	EXPECT_EQ(v2, 123456789u);
}

TEST(StreamTest, WriteReadString)
{
	dl::StreamOutput s;
	std::string str = "hello world";
	s.Write(&str);

	dl::Buffer buf = s.ToBuffer();
	dl::StreamInput in;
	in.LoadFromMemory(buf);

	std::string str2;
	in.Read(&str2);
	EXPECT_EQ(str2, "hello world");
}

TEST(StreamTest, WriteReadVector)
{
	dl::StreamOutput s;
	std::vector<int> vec = { 1, 2, 3, 4, 5 };
	s.Write(&vec);

	dl::Buffer buf = s.ToBuffer();
	dl::StreamInput in;
	in.LoadFromMemory(buf);

	std::vector<int> vec2;
	in.Read(&vec2);
	ASSERT_EQ(vec2.size(), 5u);
	EXPECT_EQ(vec2[0], 1);
	EXPECT_EQ(vec2[4], 5);
}

TEST(StreamTest, WriteReadMap)
{
	dl::StreamOutput s;
	std::map<std::string, int> m = { {"a", 1}, {"b", 2} };
	s.Write(&m);

	dl::Buffer buf = s.ToBuffer();
	dl::StreamInput in;
	in.LoadFromMemory(buf);

	std::map<std::string, int> m2;
	in.Read(&m2);
	ASSERT_EQ(m2.size(), 2u);
	EXPECT_EQ(m2["a"], 1);
	EXPECT_EQ(m2["b"], 2);
}

TEST(StreamTest, WriteReadUnorderedMap)
{
	dl::StreamOutput s;
	std::unordered_map<std::string, int> m = { {"x", 10}, {"y", 20} };
	s.Write(&m);

	dl::Buffer buf = s.ToBuffer();
	dl::StreamInput in;
	in.LoadFromMemory(buf);

	std::unordered_map<std::string, int> m2;
	in.Read(&m2);
	ASSERT_EQ(m2.size(), 2u);
	EXPECT_EQ(m2["x"], 10);
	EXPECT_EQ(m2["y"], 20);
}

//------------------------------Buffer------------------------------
TEST(BufferTest, Hex)
{
	// "Hello" 的十六进制
	dl::Buffer buf = dl::CreateBufferHex("48656c6c6f");
	ASSERT_EQ(buf.size(), 5u);
	EXPECT_EQ(dl::to_string(buf), "Hello");
	EXPECT_EQ(dl::to_string_hex(buf), "48656c6c6f");
	EXPECT_EQ(dl::to_string_hex(buf, false, true), "0x48656c6c6f");
}

TEST(BufferTest, Append)
{
	dl::Buffer buf = dl::CreateBuffer(dl::CreateBufferView(std::string("hello")));
	dl::BufferAppend(buf, dl::CreateBufferView(std::string(" world")));
	EXPECT_EQ(dl::to_string(buf), "hello world");
}

TEST(BufferTest, Basic)
{
	dl::Buffer buf;
	EXPECT_TRUE(buf.empty());

	buf.resize(10);
	EXPECT_EQ(buf.size(), 10u);
	EXPECT_FALSE(buf.empty());

	buf.clear();
	EXPECT_TRUE(buf.empty());
	EXPECT_EQ(buf.size(), 0u);
}