feat(tests): 添加ArchitectureEventsTests测试类并更新测试覆盖率计划

- 新增ArchitectureEventsTests.cs文件，包含9个测试用例
- 覆盖架构生命周期事件、事件订阅、事件顺序等核心功能
- 测试用例包括ArchitectureLifecycleReadyEvent、ArchitectureDestroyingEvent、
  ArchitectureDestroyedEvent、ArchitectureFailedInitializationEvent等事件
- 更新TEST_COVERAGE_PLAN.md中的测试统计数据
- 测试覆盖率从44%提升至45%
- 现有测试数从277个增加到286个
- 缺失测试数相应调整为122-178个
- 已完成文件数更新为4/26个

GFramework.Core.Tests/TEST_COVERAGE_PLAN.md

@@ -2,7 +2,7 @@
  
 > **生成日期**: 2026-01-16
 > **最后更新**: 2026-01-16
-> **当前版本**: Core测试覆盖率 ~44%
+> **当前版本**: Core测试覆盖率 ~45%
 > **目标**: 提升Core模块测试覆盖率至 85%+
 
 ---
@@ -148,11 +148,13 @@
 
 **预计测试数**: 8-10 个
 
+**实际测试数**: 9 个
+
 **优先级**: 🔴 高
 
 **创建路径**: `GFramework.Core.Tests/events/ArchitectureEventsTests.cs`
 
-**状态**: ❌ 待创建
+**状态**: ✅ 已创建
 
 ---
 
@@ -760,10 +762,10 @@
 ## 🎯 目标达成路径
 
 ### 当前状态
-- **现有测试数**: 277 个
-- **测试覆盖率**: ~44%
-- **缺失测试**: 131-187 个
-- **已完成文件**: 3/26 (ArchitectureConfigurationTests.cs, ArchitectureContextTests.cs, ArchitectureServicesTests.cs)
+- **现有测试数**: 286 个
+- **测试覆盖率**: ~45%
+- **缺失测试**: 122-178 个
+- **已完成文件**: 4/26 (ArchitectureConfigurationTests.cs, ArchitectureContextTests.cs, ArchitectureServicesTests.cs, ArchitectureEventsTests.cs)
 
 ### 第一批完成 1/5
 - **当前测试数**: 240 个
@@ -777,6 +779,10 @@
 - **当前测试数**: 277 个
 - **当前覆盖率**: ~44%
 
+### 第一批完成 4/5
+- **当前测试数**: 286 个
+- **当前覆盖率**: ~45%
+
 ### 第一批完成后
 - **预计测试数**: 228 + 53-67 = 281-295 个
 - **预计覆盖率**: ~50-55%
@@ -833,6 +839,7 @@
 | 2026-01-16 | 完成 ArchitectureConfigurationTests.cs | 创建了12个测试用例，涵盖默认配置、自定义配置、接口实现验证等功能 |
 | 2026-01-16 | 完成 ArchitectureContextTests.cs | 创建了22个测试用例，涵盖构造函数、命令/查询/事件发送、组件获取等功能 |
 | 2026-01-16 | 完成 ArchitectureServicesTests.cs | 创建了15个测试用例，涵盖服务初始化、上下文管理、服务独立性等功能 |
+| 2026-01-16 | 完成 ArchitectureEventsTests.cs | 创建了9个测试用例，涵盖生命周期事件、事件订阅、事件顺序等功能 |
 | | | |
 
 ---

GFramework.Core.Tests/events/ArchitectureEventsTests.cs

@@ -0,0 +1,137 @@
+using System;
+using GFramework.Core.events;
+using NUnit.Framework;
+
+namespace GFramework.Core.Tests.events;
+
+[TestFixture]
+public class ArchitectureEventsTests
+{
+    private EventBus? _eventBus;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _eventBus = new EventBus();
+    }
+
+    [Test]
+    public void ArchitectureLifecycleReadyEvent_Should_Be_Created_And_Sent()
+    {
+        bool eventReceived = false;
+        
+        _eventBus!.Register<ArchitectureEvents.ArchitectureLifecycleReadyEvent>(_ => eventReceived = true);
+        _eventBus.Send<ArchitectureEvents.ArchitectureLifecycleReadyEvent>();
+        
+        Assert.That(eventReceived, Is.True);
+    }
+
+    [Test]
+    public void ArchitectureDestroyingEvent_Should_Be_Created_And_Sent()
+    {
+        bool eventReceived = false;
+        
+        _eventBus!.Register<ArchitectureEvents.ArchitectureDestroyingEvent>(_ => eventReceived = true);
+        _eventBus.Send<ArchitectureEvents.ArchitectureDestroyingEvent>();
+        
+        Assert.That(eventReceived, Is.True);
+    }
+
+    [Test]
+    public void ArchitectureDestroyedEvent_Should_Be_Created_And_Sent()
+    {
+        bool eventReceived = false;
+        
+        _eventBus!.Register<ArchitectureEvents.ArchitectureDestroyedEvent>(_ => eventReceived = true);
+        _eventBus.Send<ArchitectureEvents.ArchitectureDestroyedEvent>();
+        
+        Assert.That(eventReceived, Is.True);
+    }
+
+    [Test]
+    public void ArchitectureFailedInitializationEvent_Should_Be_Created_And_Sent()
+    {
+        bool eventReceived = false;
+        
+        _eventBus!.Register<ArchitectureEvents.ArchitectureFailedInitializationEvent>(_ => eventReceived = true);
+        _eventBus.Send<ArchitectureEvents.ArchitectureFailedInitializationEvent>();
+        
+        Assert.That(eventReceived, Is.True);
+    }
+
+    [Test]
+    public void Events_Should_Be_Sent_In_Correct_Order()
+    {
+        var events = new List<string>();
+        
+        _eventBus!.Register<ArchitectureEvents.ArchitectureLifecycleReadyEvent>(_ => events.Add("Ready"));
+        _eventBus!.Register<ArchitectureEvents.ArchitectureDestroyingEvent>(_ => events.Add("Destroying"));
+        _eventBus!.Register<ArchitectureEvents.ArchitectureDestroyedEvent>(_ => events.Add("Destroyed"));
+        
+        _eventBus.Send<ArchitectureEvents.ArchitectureLifecycleReadyEvent>();
+        _eventBus.Send<ArchitectureEvents.ArchitectureDestroyingEvent>();
+        _eventBus.Send<ArchitectureEvents.ArchitectureDestroyedEvent>();
+        
+        Assert.That(events.Count, Is.EqualTo(3));
+        Assert.That(events[0], Is.EqualTo("Ready"));
+        Assert.That(events[1], Is.EqualTo("Destroying"));
+        Assert.That(events[2], Is.EqualTo("Destroyed"));
+    }
+
+    [Test]
+    public void Multiple_Subscribers_Should_All_Receive_Events()
+    {
+        var count1 = 0;
+        var count2 = 0;
+        
+        _eventBus!.Register<ArchitectureEvents.ArchitectureLifecycleReadyEvent>(_ => count1++);
+        _eventBus!.Register<ArchitectureEvents.ArchitectureLifecycleReadyEvent>(_ => count2++);
+        
+        _eventBus.Send<ArchitectureEvents.ArchitectureLifecycleReadyEvent>();
+        
+        Assert.That(count1, Is.EqualTo(1));
+        Assert.That(count2, Is.EqualTo(1));
+    }
+
+    [Test]
+    public void Event_UnRegister_Should_Prevent_Future_Events()
+    {
+        var count = 0;
+        var unregister = _eventBus!.Register<ArchitectureEvents.ArchitectureLifecycleReadyEvent>(_ => count++);
+        
+        _eventBus.Send<ArchitectureEvents.ArchitectureLifecycleReadyEvent>();
+        Assert.That(count, Is.EqualTo(1));
+        
+        unregister.UnRegister();
+        _eventBus.Send<ArchitectureEvents.ArchitectureLifecycleReadyEvent>();
+        
+        Assert.That(count, Is.EqualTo(1));
+    }
+
+    [Test]
+    public void Different_Events_Should_Not_Interfere()
+    {
+        bool readyReceived = false;
+        bool destroyingReceived = false;
+        
+        _eventBus!.Register<ArchitectureEvents.ArchitectureLifecycleReadyEvent>(_ => readyReceived = true);
+        _eventBus!.Register<ArchitectureEvents.ArchitectureDestroyingEvent>(_ => destroyingReceived = true);
+        
+        _eventBus.Send<ArchitectureEvents.ArchitectureLifecycleReadyEvent>();
+        
+        Assert.That(readyReceived, Is.True);
+        Assert.That(destroyingReceived, Is.False);
+        
+        _eventBus.Send<ArchitectureEvents.ArchitectureDestroyingEvent>();
+        
+        Assert.That(destroyingReceived, Is.True);
+    }
+
+    [Test]
+    public void Event_Can_Be_Sent_Without_Subscribers()
+    {
+        Assert.That(() => _eventBus!.Send<ArchitectureEvents.ArchitectureLifecycleReadyEvent>(), 
+            Throws.Nothing);
+    }
+}
+