323 lines
10 KiB
C++
323 lines
10 KiB
C++
#include <gtest/gtest.h>
|
|
#include <module/module_registry.h>
|
|
#include <module/imodule.h>
|
|
#include <types/const/priority.h>
|
|
|
|
using namespace extra2d;
|
|
|
|
// ============================================================================
|
|
// 测试用模块类
|
|
// ============================================================================
|
|
|
|
class TestModule : public IModule {
|
|
public:
|
|
TestModule(const char* name, ModuleType type, int priority)
|
|
: name_(name), type_(type), priority_(priority) {}
|
|
|
|
const char* name() const override { return name_.c_str(); }
|
|
ModuleType type() const override { return type_; }
|
|
int priority() const override { return priority_; }
|
|
|
|
bool init() override {
|
|
initCalled = true;
|
|
return initResult;
|
|
}
|
|
|
|
void shutdown() override {
|
|
shutdownCalled = true;
|
|
}
|
|
|
|
std::string name_;
|
|
ModuleType type_;
|
|
int priority_;
|
|
bool initCalled = false;
|
|
bool shutdownCalled = false;
|
|
bool initResult = true;
|
|
};
|
|
|
|
// ============================================================================
|
|
// ModuleRegistry 基础测试
|
|
// ============================================================================
|
|
|
|
TEST(ModuleRegistry, BasicOperations) {
|
|
ModuleRegistry registry;
|
|
|
|
TestModule module1("Module1", ModuleType::Feature, 0);
|
|
TestModule module2("Module2", ModuleType::System, 10);
|
|
|
|
// 注册模块
|
|
registry.registerModule(&module1);
|
|
EXPECT_EQ(1, registry.getModuleCount());
|
|
EXPECT_TRUE(registry.hasModule("Module1"));
|
|
|
|
registry.registerModule(&module2);
|
|
EXPECT_EQ(2, registry.getModuleCount());
|
|
EXPECT_TRUE(registry.hasModule("Module2"));
|
|
|
|
// 获取模块
|
|
EXPECT_EQ(&module1, registry.getModule("Module1"));
|
|
EXPECT_EQ(&module2, registry.getModule("Module2"));
|
|
EXPECT_EQ(nullptr, registry.getModule("NonExistent"));
|
|
|
|
// 注销模块
|
|
registry.unregisterModule("Module1");
|
|
EXPECT_EQ(1, registry.getModuleCount());
|
|
EXPECT_FALSE(registry.hasModule("Module1"));
|
|
EXPECT_TRUE(registry.hasModule("Module2"));
|
|
}
|
|
|
|
TEST(ModuleRegistry, DuplicateRegistration) {
|
|
ModuleRegistry registry;
|
|
|
|
TestModule module1("SameName", ModuleType::Feature, 0);
|
|
TestModule module2("SameName", ModuleType::System, 10);
|
|
|
|
registry.registerModule(&module1);
|
|
EXPECT_EQ(1, registry.getModuleCount());
|
|
|
|
// 重复注册同名模块，后注册的应覆盖
|
|
registry.registerModule(&module2);
|
|
EXPECT_EQ(1, registry.getModuleCount());
|
|
EXPECT_EQ(&module2, registry.getModule("SameName"));
|
|
}
|
|
|
|
TEST(ModuleRegistry, GetAllModules) {
|
|
ModuleRegistry registry;
|
|
|
|
TestModule module1("Module1", ModuleType::Feature, 0);
|
|
TestModule module2("Module2", ModuleType::System, 10);
|
|
TestModule module3("Module3", ModuleType::Core, 5);
|
|
|
|
registry.registerModule(&module1);
|
|
registry.registerModule(&module2);
|
|
registry.registerModule(&module3);
|
|
|
|
auto allModules = registry.getAllModules();
|
|
EXPECT_EQ(3, allModules.size());
|
|
}
|
|
|
|
TEST(ModuleRegistry, GetModulesByType) {
|
|
ModuleRegistry registry;
|
|
|
|
TestModule coreModule("CoreModule", ModuleType::Core, 0);
|
|
TestModule systemModule1("SystemModule1", ModuleType::System, 10);
|
|
TestModule systemModule2("SystemModule2", ModuleType::System, 20);
|
|
TestModule featureModule("FeatureModule", ModuleType::Feature, 5);
|
|
|
|
registry.registerModule(&coreModule);
|
|
registry.registerModule(&systemModule1);
|
|
registry.registerModule(&systemModule2);
|
|
registry.registerModule(&featureModule);
|
|
|
|
auto coreModules = registry.getModulesByType(ModuleType::Core);
|
|
EXPECT_EQ(1, coreModules.size());
|
|
|
|
auto systemModules = registry.getModulesByType(ModuleType::System);
|
|
EXPECT_EQ(2, systemModules.size());
|
|
|
|
auto featureModules = registry.getModulesByType(ModuleType::Feature);
|
|
EXPECT_EQ(1, featureModules.size());
|
|
|
|
auto extensionModules = registry.getModulesByType(ModuleType::Extension);
|
|
EXPECT_EQ(0, extensionModules.size());
|
|
}
|
|
|
|
// ============================================================================
|
|
// 初始化和关闭测试
|
|
// ============================================================================
|
|
|
|
TEST(ModuleRegistry, InitShutdown) {
|
|
ModuleRegistry registry;
|
|
|
|
TestModule module1("Module1", ModuleType::Feature, 0);
|
|
TestModule module2("Module2", ModuleType::System, 10);
|
|
|
|
registry.registerModule(&module1);
|
|
registry.registerModule(&module2);
|
|
|
|
// 初始化所有模块
|
|
EXPECT_TRUE(registry.initAll());
|
|
EXPECT_TRUE(module1.initCalled);
|
|
EXPECT_TRUE(module2.initCalled);
|
|
|
|
// 关闭所有模块
|
|
registry.shutdownAll();
|
|
EXPECT_TRUE(module1.shutdownCalled);
|
|
EXPECT_TRUE(module2.shutdownCalled);
|
|
}
|
|
|
|
TEST(ModuleRegistry, InitFailure) {
|
|
ModuleRegistry registry;
|
|
|
|
TestModule module1("Module1", ModuleType::Feature, 0);
|
|
TestModule module2("Module2", ModuleType::System, 10);
|
|
module2.initResult = false; // 模拟初始化失败
|
|
|
|
registry.registerModule(&module1);
|
|
registry.registerModule(&module2);
|
|
|
|
// 初始化应失败
|
|
EXPECT_FALSE(registry.initAll());
|
|
EXPECT_TRUE(module1.initCalled);
|
|
EXPECT_TRUE(module2.initCalled);
|
|
}
|
|
|
|
TEST(ModuleRegistry, PriorityOrder) {
|
|
ModuleRegistry registry;
|
|
|
|
std::vector<std::string> initOrder;
|
|
std::vector<std::string> shutdownOrder;
|
|
|
|
class OrderTrackingModule : public IModule {
|
|
public:
|
|
OrderTrackingModule(const char* name, int priority,
|
|
std::vector<std::string>& initVec,
|
|
std::vector<std::string>& shutdownVec)
|
|
: name_(name), priority_(priority),
|
|
initOrder_(initVec), shutdownOrder_(shutdownVec) {}
|
|
|
|
const char* name() const override { return name_.c_str(); }
|
|
int priority() const override { return priority_; }
|
|
|
|
bool init() override {
|
|
initOrder_.push_back(name_);
|
|
return true;
|
|
}
|
|
|
|
void shutdown() override {
|
|
shutdownOrder_.push_back(name_);
|
|
}
|
|
|
|
std::string name_;
|
|
int priority_;
|
|
std::vector<std::string>& initOrder_;
|
|
std::vector<std::string>& shutdownOrder_;
|
|
};
|
|
|
|
OrderTrackingModule module1("LowPriority", 100, initOrder, shutdownOrder);
|
|
OrderTrackingModule module2("HighPriority", 10, initOrder, shutdownOrder);
|
|
OrderTrackingModule module3("MediumPriority", 50, initOrder, shutdownOrder);
|
|
|
|
registry.registerModule(&module1);
|
|
registry.registerModule(&module2);
|
|
registry.registerModule(&module3);
|
|
|
|
registry.initAll();
|
|
|
|
// 初始化应按优先级顺序（数值小的先初始化）
|
|
EXPECT_EQ(3, initOrder.size());
|
|
EXPECT_EQ("HighPriority", initOrder[0]);
|
|
EXPECT_EQ("MediumPriority", initOrder[1]);
|
|
EXPECT_EQ("LowPriority", initOrder[2]);
|
|
|
|
registry.shutdownAll();
|
|
|
|
// 关闭应按优先级逆序（数值大的先关闭）
|
|
EXPECT_EQ(3, shutdownOrder.size());
|
|
EXPECT_EQ("LowPriority", shutdownOrder[0]);
|
|
EXPECT_EQ("MediumPriority", shutdownOrder[1]);
|
|
EXPECT_EQ("HighPriority", shutdownOrder[2]);
|
|
}
|
|
|
|
// ============================================================================
|
|
// 空注册表测试
|
|
// ============================================================================
|
|
|
|
TEST(ModuleRegistry, EmptyRegistry) {
|
|
ModuleRegistry registry;
|
|
|
|
EXPECT_EQ(0, registry.getModuleCount());
|
|
EXPECT_FALSE(registry.hasModule("AnyModule"));
|
|
EXPECT_EQ(nullptr, registry.getModule("AnyModule"));
|
|
|
|
auto allModules = registry.getAllModules();
|
|
EXPECT_EQ(0, allModules.size());
|
|
|
|
// 空注册表的初始化和关闭不应崩溃
|
|
EXPECT_TRUE(registry.initAll());
|
|
registry.shutdownAll();
|
|
}
|
|
|
|
TEST(ModuleRegistry, UnregisterNonExistent) {
|
|
ModuleRegistry registry;
|
|
|
|
// 注销不存在的模块不应崩溃
|
|
EXPECT_NO_THROW(registry.unregisterModule("NonExistent"));
|
|
}
|
|
|
|
// ============================================================================
|
|
// 模块生命周期测试
|
|
// ============================================================================
|
|
|
|
TEST(ModuleRegistry, ModuleLifecycle) {
|
|
ModuleRegistry registry;
|
|
|
|
enum class State { Created, Initialized, Running, Shutdown };
|
|
|
|
class LifecycleModule : public IModule {
|
|
public:
|
|
LifecycleModule(const char* name, State& state)
|
|
: name_(name), state_(state) {
|
|
state_ = State::Created;
|
|
}
|
|
|
|
const char* name() const override { return name_.c_str(); }
|
|
|
|
bool init() override {
|
|
state_ = State::Initialized;
|
|
return true;
|
|
}
|
|
|
|
void shutdown() override {
|
|
state_ = State::Shutdown;
|
|
}
|
|
|
|
std::string name_;
|
|
State& state_;
|
|
};
|
|
|
|
State state = State::Created;
|
|
LifecycleModule module("Lifecycle", state);
|
|
|
|
EXPECT_EQ(State::Created, state);
|
|
|
|
registry.registerModule(&module);
|
|
registry.initAll();
|
|
EXPECT_EQ(State::Initialized, state);
|
|
|
|
registry.shutdownAll();
|
|
EXPECT_EQ(State::Shutdown, state);
|
|
}
|
|
|
|
// ============================================================================
|
|
// 混合类型模块测试
|
|
// ============================================================================
|
|
|
|
TEST(ModuleRegistry, MixedModuleTypes) {
|
|
ModuleRegistry registry;
|
|
|
|
TestModule coreModule("Core", ModuleType::Core, Pri::System);
|
|
TestModule systemModule("System", ModuleType::System, Pri::Window);
|
|
TestModule featureModule("Feature", ModuleType::Feature, 0);
|
|
TestModule extensionModule("Extension", ModuleType::Extension, 100);
|
|
|
|
registry.registerModule(&coreModule);
|
|
registry.registerModule(&systemModule);
|
|
registry.registerModule(&featureModule);
|
|
registry.registerModule(&extensionModule);
|
|
|
|
EXPECT_EQ(4, registry.getModuleCount());
|
|
|
|
EXPECT_TRUE(registry.initAll());
|
|
EXPECT_TRUE(coreModule.initCalled);
|
|
EXPECT_TRUE(systemModule.initCalled);
|
|
EXPECT_TRUE(featureModule.initCalled);
|
|
EXPECT_TRUE(extensionModule.initCalled);
|
|
|
|
registry.shutdownAll();
|
|
EXPECT_TRUE(coreModule.shutdownCalled);
|
|
EXPECT_TRUE(systemModule.shutdownCalled);
|
|
EXPECT_TRUE(featureModule.shutdownCalled);
|
|
EXPECT_TRUE(extensionModule.shutdownCalled);
|
|
}
|