Files
dl_old/project/dl_unit_test/test_misc.cpp
T
2026-09-03 17:00:34 +08:00

353 lines
8.9 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/**
* @file test_misc.cpp
* @brief misc 模块单元测试(Value、Locator、Timer、Layout、AStar、CodeWriter)
*
*
* @version 1.0
* @author CodeBuddy
* @date 26-09-03
*
* @note
*/
#include <gtest/gtest.h>
#include "dl_type.h"
#include "misc/dl_value.h"
#include "misc/dl_locator.h"
#include "misc/dl_layout.h"
#include "misc/dl_timer.h"
#include "misc/dl_astar.h"
#include "misc/dl_code_writer.h"
//------------------------------Value------------------------------
TEST(ValueTest, DefaultNone)
{
dl::Value v;
EXPECT_EQ(v.GetType(), dl::ValueType::NONE);
EXPECT_FALSE(v);
EXPECT_EQ(v.GetString(), "null");
}
TEST(ValueTest, Bool)
{
dl::Value v(true);
EXPECT_EQ(v.GetType(), dl::ValueType::BOOL);
EXPECT_TRUE(v.ToBool());
EXPECT_EQ(v.GetString(), "true");
dl::Value vf(false);
EXPECT_FALSE(vf.ToBool());
EXPECT_EQ(vf.GetString(), "false");
}
TEST(ValueTest, Int)
{
dl::Value v(42);
EXPECT_EQ(v.GetType(), dl::ValueType::INT);
EXPECT_EQ(v.ToInt(), 42);
EXPECT_FLOAT_EQ(v.ToFloat(), 42.0f);
EXPECT_DOUBLE_EQ(v.ToDouble(), 42.0);
EXPECT_EQ(v.GetString(), "42");
}
TEST(ValueTest, FloatDouble)
{
dl::Value vf(3.14f);
EXPECT_EQ(vf.GetType(), dl::ValueType::FLOAT);
EXPECT_FLOAT_EQ(vf.ToFloat(), 3.14f);
dl::Value vd(3.14);
EXPECT_EQ(vd.GetType(), dl::ValueType::DOUBLE);
EXPECT_DOUBLE_EQ(vd.ToDouble(), 3.14);
}
TEST(ValueTest, String)
{
dl::Value v("hello");
EXPECT_EQ(v.GetType(), dl::ValueType::STRING);
EXPECT_EQ(v.ToString(), "hello");
EXPECT_EQ(v.GetString(), "\"hello\"");
EXPECT_EQ(v.GetString(false), "hello");
}
TEST(ValueTest, CopyString)
{
dl::Value a(std::string("hello"));
dl::Value b = a;
EXPECT_EQ(b.GetType(), dl::ValueType::STRING);
EXPECT_EQ(b.ToString(), "hello");
}
TEST(ValueTest, Vector)
{
dl::ValueVector vec(dl::ValueType::INT);
vec.PushBack(1);
vec.PushBack(2);
vec.PushBack(3);
dl::Value v(vec);
EXPECT_EQ(v.GetType(), dl::ValueType::VECTOR);
EXPECT_EQ(v.GetString(), "{ 1, 2, 3 }");
auto j = v.GetJson();
ASSERT_TRUE(j.is_array());
ASSERT_EQ(j.size(), 3u);
EXPECT_EQ(j[0], 1);
EXPECT_EQ(j[2], 3);
}
TEST(ValueTest, Array)
{
dl::Value v(std::array<int, 3>{10, 20, 30});
EXPECT_EQ(v.GetType(), dl::ValueType::ARRAY);
auto arr = v.ToArray<3>();
EXPECT_EQ(arr[0].ToInt(), 10);
EXPECT_EQ(arr[1].ToInt(), 20);
EXPECT_EQ(arr[2].ToInt(), 30);
}
TEST(ValueTest, Struct)
{
dl::ValueStruct s("student");
dl::Value v_id(100);
dl::Value v_name("tom");
s.AddMember("id", v_id);
s.AddMember("name", v_name);
EXPECT_EQ(s.GetName(), "student");
EXPECT_EQ(s["id"].ToInt(), 100);
EXPECT_EQ(s.GetMember("name").ToString(), "tom");
}
TEST(ValueTest, CastFailed)
{
dl::Value v("hello");
EXPECT_EQ(v.ToInt(), 0);
EXPECT_FLOAT_EQ(v.ToFloat(), 0.0f);
EXPECT_FALSE(v.ToBool());
}
TEST(ValueTest, OperatorBool)
{
dl::Value v_none;
EXPECT_FALSE(v_none);
dl::Value v_false(false);
EXPECT_FALSE(v_false);
dl::Value v_true(true);
EXPECT_TRUE(v_true);
dl::Value v_int(0);
EXPECT_TRUE(v_int); // 非 NONE/BOOL 恒为真
}
//------------------------------类型转换------------------------------
TEST(ValueTest, String2ValueType)
{
EXPECT_EQ(dl::String2ValueType("bool"), dl::ValueType::BOOL);
EXPECT_EQ(dl::String2ValueType("int"), dl::ValueType::INT);
EXPECT_EQ(dl::String2ValueType("uint"), dl::ValueType::UINT);
EXPECT_EQ(dl::String2ValueType("int64"), dl::ValueType::INT64);
EXPECT_EQ(dl::String2ValueType("float"), dl::ValueType::FLOAT);
EXPECT_EQ(dl::String2ValueType("double"), dl::ValueType::DOUBLE);
EXPECT_EQ(dl::String2ValueType("string"), dl::ValueType::STRING);
EXPECT_EQ(dl::String2ValueType("array<int, 3>"), dl::ValueType::ARRAY);
EXPECT_EQ(dl::String2ValueType("vector<int>"), dl::ValueType::VECTOR);
EXPECT_EQ(dl::String2ValueType("MyStruct"), dl::ValueType::STRUCT);
}
TEST(ValueTest, String2ValueTypeEx)
{
auto info = dl::String2ValueTypeEx("array<int, 3>");
EXPECT_EQ(info._type0, dl::ValueType::ARRAY);
EXPECT_EQ(info._type1, dl::ValueType::INT);
EXPECT_EQ(info._length, 3u);
EXPECT_EQ(info._strType1, "int");
auto info2 = dl::String2ValueTypeEx("vector<float>");
EXPECT_EQ(info2._type0, dl::ValueType::VECTOR);
EXPECT_EQ(info2._type1, dl::ValueType::FLOAT);
EXPECT_EQ(info2._length, 0u);
}
TEST(ValueTest, ToStringType)
{
EXPECT_EQ(dl::to_string(dl::ValueType::NONE), "null");
EXPECT_EQ(dl::to_string(dl::ValueType::INT), "int");
EXPECT_EQ(dl::to_string(dl::ValueType::STRING), "string");
EXPECT_EQ(dl::to_string(dl::ValueType::ARRAY), "array");
EXPECT_EQ(dl::to_string(dl::ValueType::MAP), "map");
}
TEST(ValueTest, Type2CppType)
{
EXPECT_EQ(dl::Type2CppType(dl::ValueType::INT), "int");
EXPECT_EQ(dl::Type2CppType(dl::ValueType::UINT), "unsigned");
EXPECT_EQ(dl::Type2CppType(dl::ValueType::UCHAR), "unsigned char");
EXPECT_EQ(dl::Type2CppType(dl::ValueType::STRING), "std::string");
EXPECT_EQ(dl::Type2CppType(dl::ValueType::ARRAY), "std::array");
EXPECT_EQ(dl::Type2CppType(dl::ValueType::VECTOR), "std::vector");
EXPECT_EQ(dl::Type2CppType(dl::ValueType::POINTER), "void*");
EXPECT_EQ(dl::Type2CppTypeEx(dl::ValueType::ARRAY, dl::ValueType::INT, 3), "std::array<int, 3>");
}
//------------------------------Layout------------------------------
TEST(LayoutTest, String2Layout)
{
EXPECT_EQ(dl::String2Layout("x"), dl::Layout::X);
EXPECT_EQ(dl::String2Layout("y"), dl::Layout::Y);
EXPECT_EQ(dl::String2Layout("xy"), dl::Layout::XY);
EXPECT_EQ(dl::String2Layout("origin"), dl::Layout::ORIGIN);
EXPECT_EQ(dl::String2Layout("X"), dl::Layout::X);
EXPECT_EQ(dl::String2Layout("XY"), dl::Layout::XY);
}
//------------------------------Locator------------------------------
TEST(LocatorTest, DirectX)
{
auto loc = dl::createLocatorX(10.0f);
EXPECT_FLOAT_EQ(loc.Get(0)[0], 0.0f);
EXPECT_FLOAT_EQ(loc.Get(0)[1], 0.0f);
EXPECT_FLOAT_EQ(loc.Get(1)[0], 10.0f);
EXPECT_FLOAT_EQ(loc.Get(2)[0], 20.0f);
}
TEST(LocatorTest, DirectXWrap)
{
auto loc = dl::createLocatorX(10.0f, 3);
EXPECT_FLOAT_EQ(loc.Get(0)[0], 0.0f);
EXPECT_FLOAT_EQ(loc.Get(1)[0], 10.0f);
EXPECT_FLOAT_EQ(loc.Get(2)[0], 20.0f);
auto p3 = loc.Get(3);
EXPECT_FLOAT_EQ(p3[0], 0.0f);
EXPECT_FLOAT_EQ(p3[1], 32.0f);
}
TEST(LocatorTest, DirectY)
{
auto loc = dl::createLocatorY(10.0f);
EXPECT_FLOAT_EQ(loc.Get(0)[1], 0.0f);
EXPECT_FLOAT_EQ(loc.Get(1)[1], 10.0f);
EXPECT_FLOAT_EQ(loc.Get(2)[1], 20.0f);
}
TEST(LocatorTest, DirectXY)
{
dl::Locator::SL sl;
sl._dt = { 10.0f, 20.0f };
sl._layout = dl::Layout::XY;
dl::Locator loc(sl);
auto p = loc.Get(3);
EXPECT_FLOAT_EQ(p[0], 30.0f);
EXPECT_FLOAT_EQ(p[1], 60.0f);
}
TEST(LocatorTest, Origin)
{
auto loc = dl::createLocatorZero();
auto p = loc.Get(5);
EXPECT_FLOAT_EQ(p[0], 0.0f);
EXPECT_FLOAT_EQ(p[1], 0.0f);
}
TEST(LocatorTest, AdaptX)
{
auto loc = dl::createLocatorX(10.0f, 0, 32.0f, dl::Locator::Mode::ADAPT);
dl::Size s{ 10, 10 };
auto p0 = loc.Get(s);
EXPECT_FLOAT_EQ(p0[0], 0.0f);
auto p1 = loc.Get(s);
EXPECT_FLOAT_EQ(p1[0], 20.0f);
}
TEST(LocatorTest, ExGet)
{
auto loc = dl::createLocatorX(10.0f);
dl::Position pos{ 5.0f, 5.0f };
EXPECT_TRUE(loc.ExGet(2, dl::Size{}, pos));
EXPECT_FLOAT_EQ(pos[0], 25.0f);
EXPECT_FLOAT_EQ(pos[1], 5.0f);
}
//------------------------------Timer------------------------------
TEST(TimerTest, Regular)
{
dl::TimerRegular t(2.0f);
EXPECT_FALSE(t.Run(1.0f));
EXPECT_FALSE(t.Run(0.5f));
EXPECT_TRUE(t.Run(0.5f));
EXPECT_FALSE(t.Run(0.1f));
}
TEST(TimerTest, Reverse)
{
dl::TimerReverse t(1.0f);
EXPECT_FALSE(t.Run(0.5f));
EXPECT_TRUE(t.Run(0.5f));
EXPECT_TRUE(t.Run(0.5f));
EXPECT_FALSE(t.Run(0.5f));
}
//------------------------------AStar------------------------------
TEST(AStarTest, Search)
{
auto g = [](const dl::Point& a, const dl::Point& b) -> int { return 10; };
dl::AStar<dl::Point, int> astar(dl::Point{}, g);
astar.SetSize({ 5, 5 });
std::list<dl::Point> path;
EXPECT_TRUE(astar.Search({ 0, 0 }, { 4, 4 }, false, path));
EXPECT_FALSE(path.empty());
EXPECT_EQ(path.front(), (dl::Point{ 0, 0 }));
EXPECT_EQ(path.back(), (dl::Point{ 4, 4 }));
}
TEST(AStarTest, SearchBlocked)
{
auto g = [](const dl::Point& a, const dl::Point& b) -> int
{
if (b.x == 2)
return 0; // x=2 整列不可通行
return 10;
};
dl::AStar<dl::Point, int> astar(dl::Point{}, g);
astar.SetSize({ 5, 5 });
std::list<dl::Point> path;
EXPECT_FALSE(astar.Search({ 0, 0 }, { 4, 4 }, false, path));
}
//------------------------------CodeWriter------------------------------
TEST(CodeWriterTest, IsStdType)
{
EXPECT_TRUE(dl::CodeWriter::IsStdType("string"));
EXPECT_FALSE(dl::CodeWriter::IsStdType("int"));
}
TEST(CodeWriterTest, AddStdNamespace)
{
std::string s = "string";
dl::CodeWriter::AddStdNamespace(s);
EXPECT_EQ(s, "std::string");
std::string i = "int";
dl::CodeWriter::AddStdNamespace(i);
EXPECT_EQ(i, "int");
}
TEST(CodeWriterTest, ReplaceType)
{
std::string s = "uchar";
dl::CodeWriter::ReplaceType(s);
EXPECT_EQ(s, "unsigned char");
std::string i = "int64";
dl::CodeWriter::ReplaceType(i);
EXPECT_EQ(i, "int64_t");
std::string i2 = "int32";
dl::CodeWriter::ReplaceType(i2);
EXPECT_EQ(i2, "int32_t");
}