590 lines
15 KiB
C++
590 lines
15 KiB
C++
/**
|
||
* @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"
|
||
#include "misc/dl_tilemap.h"
|
||
#include "misc/dl_json_config.h"
|
||
#include "misc/dl_language.h"
|
||
#include "io/dl_file.h"
|
||
#include "render/dl_factory.h"
|
||
|
||
#include <OpenXLSX.hpp>
|
||
|
||
//------------------------------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");
|
||
}
|
||
|
||
TEST(CodeWriterTest, StructGetVariable)
|
||
{
|
||
dl::CodeWriter::Struct s;
|
||
s._name = "Student";
|
||
s._value = "stu";
|
||
dl::CodeWriter::Variable v;
|
||
v._name = "id";
|
||
v._type = "int";
|
||
s._allVariable.push_back(v);
|
||
|
||
auto* p = s.GetVariable("id");
|
||
ASSERT_NE(p, nullptr);
|
||
EXPECT_EQ(p->_type, "int");
|
||
EXPECT_EQ(s.GetVariable("none"), nullptr);
|
||
}
|
||
|
||
TEST(CodeWriterTest, SegmentGetStruct)
|
||
{
|
||
dl::CodeWriter::Segment seg;
|
||
dl::CodeWriter::Struct s;
|
||
s._name = "Student";
|
||
s._value = "stu";
|
||
dl::CodeWriter::Variable v;
|
||
v._name = "id";
|
||
v._type = "int";
|
||
s._allVariable.push_back(v);
|
||
seg._allStruct.push_back(s);
|
||
|
||
auto* ps = seg.GetStruct("Student");
|
||
ASSERT_NE(ps, nullptr);
|
||
EXPECT_EQ(ps->_value, "stu");
|
||
|
||
auto* pv = seg.GetVariable("Student", "id");
|
||
ASSERT_NE(pv, nullptr);
|
||
EXPECT_EQ(pv->_type, "int");
|
||
|
||
EXPECT_EQ(seg.GetStruct("None"), nullptr);
|
||
EXPECT_EQ(seg.GetVariable("Student", "none"), nullptr);
|
||
}
|
||
|
||
TEST(CodeWriterTest, StructFormatVariable)
|
||
{
|
||
dl::CodeWriter::Struct s;
|
||
s._name = "Test";
|
||
s._value = "t";
|
||
dl::CodeWriter::Variable v1;
|
||
v1._name = "a";
|
||
v1._type = "int";
|
||
dl::CodeWriter::Variable v2;
|
||
v2._name = "long_name";
|
||
v2._type = "std::string";
|
||
s._allVariable.push_back(v1);
|
||
s._allVariable.push_back(v2);
|
||
|
||
s.FormatVariable();
|
||
// 对齐后，短的名字/类型会被补 tab，长度不小于 4
|
||
EXPECT_GE(s._allVariable[0]._name.size(), 4u);
|
||
EXPECT_GE(s._allVariable[1]._name.size(), 4u);
|
||
EXPECT_GE(s._allVariable[0]._type.size(), 4u);
|
||
EXPECT_GE(s._allVariable[1]._type.size(), 4u);
|
||
EXPECT_EQ(s._allVariable[0]._name.back(), '\t');
|
||
EXPECT_EQ(s._allVariable[1]._name.back(), '\t');
|
||
EXPECT_EQ(s._allVariable[0]._type.back(), '\t');
|
||
EXPECT_EQ(s._allVariable[1]._type.back(), '\t');
|
||
}
|
||
|
||
//------------------------------TileMap------------------------------
|
||
TEST(TileMapTest, Rectangle)
|
||
{
|
||
dl::TileMap::Rectangle<dl::Position{32.0f, 32.0f}> map;
|
||
auto world = map.Map2World(dl::Point{1, 2});
|
||
EXPECT_FLOAT_EQ(world[0], 32.0f);
|
||
EXPECT_FLOAT_EQ(world[1], 64.0f);
|
||
|
||
auto mp = map.World2Map(dl::Position{32.0f, 64.0f});
|
||
EXPECT_EQ(mp[0], 1);
|
||
EXPECT_EQ(mp[1], 2);
|
||
}
|
||
|
||
TEST(TileMapTest, DiamondSlant)
|
||
{
|
||
dl::TileMap::DiamondSlant<dl::Position{32.0f, 32.0f}> map;
|
||
auto world = map.Map2World(dl::Point{0, 0});
|
||
EXPECT_FLOAT_EQ(world[0], 0.0f);
|
||
EXPECT_FLOAT_EQ(world[1], 0.0f);
|
||
|
||
auto world2 = map.Map2World(dl::Point{1, 0});
|
||
EXPECT_FLOAT_EQ(world2[0], 16.0f);
|
||
EXPECT_FLOAT_EQ(world2[1], -16.0f);
|
||
}
|
||
|
||
//------------------------------JsonConfig------------------------------
|
||
TEST(JsonConfigTest, LoadFailed)
|
||
{
|
||
dl::JsonConfig cfg;
|
||
EXPECT_FALSE(cfg.Load("/nonexistent/path/file.json"));
|
||
}
|
||
|
||
TEST(JsonConfigTest, LoadGenerateCode)
|
||
{
|
||
std::string path = dl::g_factory->GetPathTemp() + "dl_json_config_test.json";
|
||
std::string json_str = R"({
|
||
"name": "测试配置",
|
||
"desc": "配置描述",
|
||
"type": "config",
|
||
"value": {
|
||
"speed": {
|
||
"name": "速度",
|
||
"desc": "移动速度",
|
||
"type": "int",
|
||
"value": 100
|
||
},
|
||
"title": {
|
||
"name": "标题",
|
||
"type": "string",
|
||
"value": "hello"
|
||
}
|
||
}
|
||
})";
|
||
ASSERT_TRUE(dl::File::SaveString(json_str, path));
|
||
|
||
dl::JsonConfig cfg;
|
||
ASSERT_TRUE(cfg.Load(path));
|
||
|
||
dl::JsonConfig::GenerateParam p;
|
||
p._filename = "test.h";
|
||
p._brief = "测试";
|
||
p._author = "tester";
|
||
p._date = "2026";
|
||
p._logFunction = "log_err";
|
||
p._namespace = "test";
|
||
std::string code = cfg.GenerateCode(p);
|
||
EXPECT_FALSE(code.empty());
|
||
EXPECT_NE(code.find("struct config"), std::string::npos);
|
||
EXPECT_NE(code.find("int speed"), std::string::npos);
|
||
|
||
dl::File::Delete(path);
|
||
}
|
||
|
||
TEST(JsonConfigTest, GenerateConfigUser)
|
||
{
|
||
std::string path = dl::g_factory->GetPathTemp() + "dl_json_config_test.json";
|
||
std::string json_str = R"({
|
||
"name": "测试配置",
|
||
"type": "config",
|
||
"value": {
|
||
"speed": {
|
||
"type": "int",
|
||
"value": 100
|
||
}
|
||
}
|
||
})";
|
||
ASSERT_TRUE(dl::File::SaveString(json_str, path));
|
||
|
||
dl::JsonConfig cfg;
|
||
ASSERT_TRUE(cfg.Load(path));
|
||
|
||
std::string user = cfg.GenerateConfigUser();
|
||
EXPECT_FALSE(user.empty());
|
||
EXPECT_NE(user.find("speed"), std::string::npos);
|
||
EXPECT_NE(user.find("100"), std::string::npos);
|
||
|
||
dl::File::Delete(path);
|
||
}
|
||
|
||
//------------------------------Language------------------------------
|
||
TEST(LanguageTest, LoadGet)
|
||
{
|
||
std::string path = dl::g_factory->GetPathTemp() + "dl_language_test.xlsx";
|
||
// 用 OpenXLSX 写临时 xlsx：第0列 tag、第1列 name、第2+列语言
|
||
{
|
||
OpenXLSX::XLDocument doc;
|
||
doc.create(path);
|
||
auto wks = doc.workbook().worksheet("Sheet1");
|
||
wks.cell(1, 1).value() = "tag";
|
||
wks.cell(1, 2).value() = "name";
|
||
wks.cell(1, 3).value() = "English";
|
||
wks.cell(1, 4).value() = "简体中文";
|
||
wks.cell(2, 1).value() = "menu";
|
||
wks.cell(2, 2).value() = "start";
|
||
wks.cell(2, 3).value() = "Start";
|
||
wks.cell(2, 4).value() = "开始";
|
||
wks.cell(3, 1).value() = "menu";
|
||
wks.cell(3, 2).value() = "exit";
|
||
wks.cell(3, 3).value() = "Exit";
|
||
wks.cell(3, 4).value() = "退出";
|
||
doc.save();
|
||
doc.close();
|
||
}
|
||
|
||
dl::Language lang;
|
||
lang.LoadXlsx(path);
|
||
|
||
// 英文
|
||
lang.SetLangCurrent(dl::Language::E_ENGLISH);
|
||
EXPECT_EQ(lang.Get("menu", "start"), "Start");
|
||
EXPECT_EQ(lang.Get("menu", "exit"), "Exit");
|
||
|
||
// 中文
|
||
lang.SetLangCurrent(dl::Language::E_CHINESE);
|
||
EXPECT_EQ(lang.Get("menu", "start"), "开始");
|
||
EXPECT_EQ(lang.Get("menu", "exit"), "退出");
|
||
|
||
// 失败返回特定字符串
|
||
EXPECT_EQ(lang.Get("nottag", "start"), "not_find_tag");
|
||
EXPECT_EQ(lang.Get("menu", "notname"), "not_find");
|
||
|
||
// GetCheck
|
||
auto check = lang.GetCheck("menu", "start");
|
||
ASSERT_TRUE(check.has_value());
|
||
EXPECT_EQ(*check, "开始");
|
||
EXPECT_FALSE(lang.GetCheck("menu", "none").has_value());
|
||
|
||
// GetTagSize
|
||
EXPECT_EQ(lang.GetTagSize("menu"), 2u);
|
||
|
||
// GetTagMap
|
||
auto m = lang.GetTagMap("menu");
|
||
EXPECT_EQ(m.size(), 2u);
|
||
EXPECT_EQ(m["start"], "开始");
|
||
EXPECT_EQ(m["exit"], "退出");
|
||
|
||
// GetLangAll
|
||
const auto& langs = lang.GetLangAll();
|
||
ASSERT_EQ(langs.size(), 2u);
|
||
EXPECT_EQ(langs[0], "English");
|
||
|
||
dl::File::Delete(path);
|
||
}
|