gewuyou/GFramework
1
0
Fork 0
mirror of https://github.com/GeWuYou/GFramework.git synced 2026-03-22 10:34:30 +08:00
Code Issues Packages Projects Releases Wiki Activity

style(coding-style): 统一代码风格并优化文档格式

Browse Source 
- 移除多余using语句和空行，统一代码缩进格式
- 优化注释文档中的缩进和对齐格式
- 简化条件语句和方法实现，提升代码可读性
- 重构协程系统相关类的字段和方法定义格式
- 更新架构服务中容器访问方式的实现
- 调整异步操作类的属性和方法组织结构
- [skip ci]
This commit is contained in:
GeWuYou 2026-01-27 20:30:04 +08:00
parent a71c7f6f1a
commit b49079de3e
212 changed files with 2798 additions and 2835 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
GFramework.Core.Abstractions/architecture/IArchitectureContext.cs
View File

@ -1,5 +1,3 @@
using System;
using System.Threading.Tasks;
using GFramework.Core.Abstractions.command;
using GFramework.Core.Abstractions.environment;
using GFramework.Core.Abstractions.events;

4
GFramework.Core.Abstractions/architecture/IAsyncInitializable.cs
View File

@ -1,6 +1,4 @@
using System.Threading.Tasks;
namespace GFramework.Core.Abstractions.architecture;
namespace GFramework.Core.Abstractions.architecture;
/// <summary>
/// 定义异步初始化接口，用于需要异步初始化的组件或服务

6
GFramework.Core.Abstractions/bases/IKeyValue.cs
View File

@ -1,19 +1,19 @@
namespace GFramework.Core.Abstractions.bases;
/// <summary>
/// 表示键值对的接口，定义了通用的键值对数据结构契约
/// 表示键值对的接口，定义了通用的键值对数据结构契约
/// </summary>
/// <typeparam name="TKey">键的类型</typeparam>
/// <typeparam name="TValue">值的类型</typeparam>
public interface IKeyValue<out TKey, out TValue>
{
/// <summary>
/// 获取键值对中的键
/// 获取键值对中的键
/// </summary>
TKey Key { get; }
/// <summary>
/// 获取键值对中的值
/// 获取键值对中的值
/// </summary>
TValue Value { get; }
}

9
GFramework.Core.Abstractions/command/IAsyncCommand.cs
View File

@ -1,28 +1,27 @@
using System.Threading.Tasks;
using GFramework.Core.Abstractions.rule;
namespace GFramework.Core.Abstractions.command;
/// <summary>
/// 表示一个异步命令接口，该命令不返回结果
/// 表示一个异步命令接口，该命令不返回结果
/// </summary>
public interface IAsyncCommand : IContextAware
{
/// <summary>
/// 异步执行命令
/// 异步执行命令
/// </summary>
/// <returns>表示异步操作的任务</returns>
Task ExecuteAsync();
}
/// <summary>
/// 表示一个异步命令接口，该命令返回指定类型的结果
/// 表示一个异步命令接口，该命令返回指定类型的结果
/// </summary>
/// <typeparam name="TResult">命令执行结果的类型</typeparam>
public interface IAsyncCommand<TResult> : IContextAware
{
/// <summary>
/// 异步执行命令并返回结果
/// 异步执行命令并返回结果
/// </summary>
/// <returns>表示异步操作的任务，任务结果为命令执行的返回值</returns>
Task<TResult> ExecuteAsync();

2
GFramework.Core.Abstractions/command/ICommandBus.cs
View File

@ -1,5 +1,3 @@
using System.Threading.Tasks;
namespace GFramework.Core.Abstractions.command;
/// <summary>

14
GFramework.Core.Abstractions/coroutine/CoroutineState.cs
View File

@ -1,32 +1,32 @@
namespace GFramework.Core.Abstractions.coroutine;
/// <summary>
/// 表示协程的执行状态枚举
/// 表示协程的执行状态枚举
/// </summary>
public enum CoroutineState
{
/// <summary>
/// 协程正在运行中
/// 协程正在运行中
/// </summary>
Running,
/// <summary>
/// 协程已暂停
/// 协程已暂停
/// </summary>
Paused,
/// <summary>
/// 协程被锁定或等待其他协程完成
/// 协程被锁定或等待其他协程完成
/// </summary>
Held,
/// <summary>
/// 协程已完成执行
/// 协程已完成执行
/// </summary>
Completed,
/// <summary>
/// 协程已被取消
/// 协程已被取消
/// </summary>
Cancelled,
Cancelled
}

8
GFramework.Core.Abstractions/coroutine/ITimeSource.cs
View File

@ -1,22 +1,22 @@
namespace GFramework.Core.Abstractions.coroutine;
/// <summary>
/// 时间源接口，提供当前时间、时间增量以及更新功能
/// 时间源接口，提供当前时间、时间增量以及更新功能
/// </summary>
public interface ITimeSource
{
/// <summary>
/// 获取当前时间
/// 获取当前时间
/// </summary>
double CurrentTime { get; }
/// <summary>
/// 获取时间增量（上一帧到当前帧的时间差）
/// 获取时间增量（上一帧到当前帧的时间差）
/// </summary>
double DeltaTime { get; }
/// <summary>
/// 更新时间源的状态
/// 更新时间源的状态
/// </summary>
void Update();
}

6
GFramework.Core.Abstractions/coroutine/IYieldInstruction.cs
View File

@ -1,17 +1,17 @@
namespace GFramework.Core.Abstractions.coroutine;
/// <summary>
/// 定义一个可等待指令的接口，用于协程系统中的异步操作控制
/// 定义一个可等待指令的接口，用于协程系统中的异步操作控制
/// </summary>
public interface IYieldInstruction
{
/// <summary>
/// 获取当前等待指令是否已完成执行
/// 获取当前等待指令是否已完成执行
/// </summary>
bool IsDone { get; }
/// <summary>
/// 每帧由调度器调用，用于更新当前等待指令的状态
/// 每帧由调度器调用，用于更新当前等待指令的状态
/// </summary>
/// <param name="deltaTime">自上一帧以来的时间间隔（以秒为单位）</param>
void Update(double deltaTime);

4
GFramework.Core.Abstractions/enums/ArchitecturePhase.cs
View File

@ -15,12 +15,12 @@ public enum ArchitecturePhase
None = 0,
/// <summary>
/// 工具类初始化之前阶段
/// 工具类初始化之前阶段
/// </summary>
BeforeUtilityInit,
/// <summary>
/// 工具类初始化之后阶段
/// 工具类初始化之后阶段
/// </summary>
AfterUtilityInit,

4
GFramework.Core.Abstractions/events/IEvent.cs
View File

@ -1,6 +1,4 @@
using System;
namespace GFramework.Core.Abstractions.events;
namespace GFramework.Core.Abstractions.events;
/// <summary>
/// 事件接口，定义了事件注册的基本功能

6
GFramework.Core.Abstractions/events/IEventBus.cs
View File

@ -1,9 +1,7 @@
using System;
namespace GFramework.Core.Abstractions.events;
namespace GFramework.Core.Abstractions.events;
/// <summary>
/// 事件总线接口，提供事件的发送、注册和注销功能
/// 事件总线接口，提供事件的发送、注册和注销功能
/// </summary>
public interface IEventBus
{

4
GFramework.Core.Abstractions/events/IUnRegisterList.cs
View File

@ -1,6 +1,4 @@
using System.Collections.Generic;
namespace GFramework.Core.Abstractions.events;
namespace GFramework.Core.Abstractions.events;
/// <summary>
/// 提供统一注销功能的接口，用于管理需要注销的对象列表

4
GFramework.Core.Abstractions/ioc/IIocContainer.cs
View File

@ -1,6 +1,4 @@
using System;
using System.Collections.Generic;
using GFramework.Core.Abstractions.rule;
using GFramework.Core.Abstractions.rule;
using GFramework.Core.Abstractions.system;
namespace GFramework.Core.Abstractions.ioc;

4
GFramework.Core.Abstractions/logging/ILogger.cs
View File

@ -1,6 +1,4 @@
using System;
namespace GFramework.Core.Abstractions.logging;
namespace GFramework.Core.Abstractions.logging;
/// <summary>
/// 定义日志记录接口，提供日志记录和级别检查功能

8
GFramework.Core.Abstractions/pool/IObjectPoolSystem.cs
View File

@ -1,7 +1,7 @@
namespace GFramework.Core.Abstractions.pool;
/// <summary>
/// 对象池系统接口，定义了对象池的基本操作
/// 对象池系统接口，定义了对象池的基本操作
/// </summary>
/// <typeparam name="TKey">池键的类型</typeparam>
/// <typeparam name="TObject">池中对象的类型，必须实现IPoolableObject接口</typeparam>
@ -10,21 +10,21 @@ public interface IObjectPoolSystem<in TKey, TObject>
where TKey : notnull
{
/// <summary>
/// 从对象池中获取一个对象实例
/// 从对象池中获取一个对象实例
/// </summary>
/// <param name="key">对象池的键</param>
/// <returns>池中的对象实例，如果池中没有可用对象则创建新实例</returns>
TObject Acquire(TKey key);
/// <summary>
/// 将对象释放回对象池
/// 将对象释放回对象池
/// </summary>
/// <param name="key">对象池的键</param>
/// <param name="obj">要释放的对象</param>
void Release(TKey key, TObject obj);
/// <summary>
/// 清空所有对象池
/// 清空所有对象池
/// </summary>
void Clear();
}

8
GFramework.Core.Abstractions/pool/IPoolableObject.cs
View File

@ -1,22 +1,22 @@
namespace GFramework.Core.Abstractions.pool;
/// <summary>
/// 定义可池化对象的接口，提供对象在池中的生命周期管理方法
/// 定义可池化对象的接口，提供对象在池中的生命周期管理方法
/// </summary>
public interface IPoolableObject
{
/// <summary>
/// 当对象从池中被获取时调用，用于初始化或重置对象状态
/// 当对象从池中被获取时调用，用于初始化或重置对象状态
/// </summary>
void OnAcquire();
/// <summary>
/// 当对象被释放回池中时调用，用于清理或重置对象状态以便下次使用
/// 当对象被释放回池中时调用，用于清理或重置对象状态以便下次使用
/// </summary>
void OnRelease();
/// <summary>
/// 当对象池被销毁时调用，用于执行最终的清理工作
/// 当对象池被销毁时调用，用于执行最终的清理工作
/// </summary>
void OnPoolDestroy();
}

1
GFramework.Core.Abstractions/property/IReadonlyBindableProperty.cs
View File

@ -1,4 +1,3 @@
using System;
using GFramework.Core.Abstractions.events;
namespace GFramework.Core.Abstractions.property;

8
GFramework.Core.Abstractions/query/IAsyncQuery.cs
View File

@ -1,15 +1,13 @@
using System.Threading.Tasks;
namespace GFramework.Core.Abstractions.query;
namespace GFramework.Core.Abstractions.query;
/// <summary>
/// 异步查询接口，定义了执行异步查询操作的方法
/// 异步查询接口，定义了执行异步查询操作的方法
/// </summary>
/// <typeparam name="TResult">查询结果的类型</typeparam>
public interface IAsyncQuery<TResult>
{
/// <summary>
/// 执行异步查询操作
/// 执行异步查询操作
/// </summary>
/// <returns>返回查询结果的Task，结果类型为TResult</returns>
Task<TResult> DoAsync();

8
GFramework.Core.Abstractions/query/IAsyncQueryBus.cs
View File

@ -1,14 +1,12 @@
using System.Threading.Tasks;
namespace GFramework.Core.Abstractions.query;
namespace GFramework.Core.Abstractions.query;
/// <summary>
/// 异步查询总线接口，用于处理异步查询请求
/// 异步查询总线接口，用于处理异步查询请求
/// </summary>
public interface IAsyncQueryBus
{
/// <summary>
/// 异步发送查询请求并返回结果
/// 异步发送查询请求并返回结果
/// </summary>
/// <typeparam name="TResult">查询结果的类型</typeparam>
/// <param name="query">要执行的异步查询对象</param>

10
GFramework.Core.Abstractions/registries/IRegistry.cs
View File

@ -3,34 +3,34 @@
namespace GFramework.Game.Abstractions.registry;
/// <summary>
/// 表示一个通用的注册表接口，用于根据键类型T获取值类型TR的对象
/// 表示一个通用的注册表接口，用于根据键类型T获取值类型TR的对象
/// </summary>
/// <typeparam name="T">注册表中用作键的类型</typeparam>
/// <typeparam name="Tr">注册表中存储的值的类型</typeparam>
public interface IRegistry<in T, Tr>
{
/// <summary>
/// 根据指定的键获取对应的值
/// 根据指定的键获取对应的值
/// </summary>
/// <param name="key">用于查找值的键</param>
/// <returns>与指定键关联的值</returns>
Tr Get(T key);
/// <summary>
/// 检查注册表是否包含指定的键
/// 检查注册表是否包含指定的键
/// </summary>
/// <param name="key">要检查的键</param>
/// <returns>如果注册表包含具有指定键的元素，则为true；否则为false</returns>
bool Contains(T key);
/// <summary>
/// 添加一个键值对到注册表中
/// 添加一个键值对到注册表中
/// </summary>
/// <param name="mapping">要添加的键值对映射对象</param>
IRegistry<T, Tr> Registry(IKeyValue<T, Tr> mapping);
/// <summary>
/// 添加一个键值对到注册表中
/// 添加一个键值对到注册表中
/// </summary>
/// <param name="key">要添加的键</param>
/// <param name="value">要添加的值</param>

31
GFramework.Core.Abstractions/registries/KeyValueRegistryBase.cs
View File

@ -1,12 +1,11 @@
using System.Collections.Generic;
using GFramework.Core.Abstractions.bases;
using GFramework.Core.Abstractions.bases;
using GFramework.Game.Abstractions.registry;
namespace GFramework.Core.Abstractions.registries;
/// <summary>
/// 基于Dictionary的通用键值注册表基类
/// 提供基于字典的键值对注册、查询和管理功能
/// 基于Dictionary的通用键值注册表基类
/// 提供基于字典的键值对注册、查询和管理功能
/// </summary>
/// <typeparam name="TKey">键的类型</typeparam>
/// <typeparam name="TValue">值的类型</typeparam>
@ -14,12 +13,12 @@ public abstract class KeyValueRegistryBase<TKey, TValue>
: IRegistry<TKey, TValue>
{
/// <summary>
/// 存储键值对映射关系的字典
/// 存储键值对映射关系的字典
/// </summary>
protected readonly IDictionary<TKey, TValue> Map;
/// <summary>
/// 初始化KeyValueRegistryBase的新实例
/// 初始化KeyValueRegistryBase的新实例
/// </summary>
/// <param name="comparer">用于比较键的相等性的比较器，如果为null则使用默认比较器</param>
protected KeyValueRegistryBase(IEqualityComparer<TKey>? comparer = null)
@ -29,26 +28,30 @@ public abstract class KeyValueRegistryBase<TKey, TValue>
}
/// <summary>
/// 根据指定的键获取对应的值
/// 根据指定的键获取对应的值
/// </summary>
/// <param name="key">要查找的键</param>
/// <returns>与键关联的值</returns>
/// <exception cref="KeyNotFoundException">当键不存在时抛出异常</exception>
public virtual TValue Get(TKey key)
=> Map.TryGetValue(key, out var value)
{
return Map.TryGetValue(key, out var value)
? value
: throw new KeyNotFoundException($"{GetType().Name}: key not registered: {key}");
}
/// <summary>
/// 判断是否包含指定的键
/// 判断是否包含指定的键
/// </summary>
/// <param name="key">要检查的键</param>
/// <returns>如果包含该键返回true，否则返回false</returns>
public virtual bool Contains(TKey key)
=> Map.ContainsKey(key);
{
return Map.ContainsKey(key);
}
/// <summary>
/// 注册键值对到注册表中
/// 注册键值对到注册表中
/// </summary>
/// <param name="key">要注册的键</param>
/// <param name="value">要注册的值</param>
@ -60,10 +63,12 @@ public abstract class KeyValueRegistryBase<TKey, TValue>
}
/// <summary>
/// 注册键值对映射对象到注册表中
/// 注册键值对映射对象到注册表中
/// </summary>
/// <param name="mapping">包含键值对的映射对象</param>
/// <returns>当前注册表实例，支持链式调用</returns>
public virtual IRegistry<TKey, TValue> Registry(IKeyValue<TKey, TValue> mapping)
=> Registry(mapping.Key, mapping.Value);
{
return Registry(mapping.Key, mapping.Value);
}
}

8
GFramework.Core.Abstractions/state/IState.cs
View File

@ -1,24 +1,24 @@
namespace GFramework.Core.Abstractions.state;
/// <summary>
/// 状态机状态接口，定义了状态的基本行为和转换规则
/// 状态机状态接口，定义了状态的基本行为和转换规则
/// </summary>
public interface IState
{
/// <summary>
/// 当状态被激活进入时调用
/// 当状态被激活进入时调用
/// </summary>
/// <param name="from">从哪个状态转换而来，可能为null表示初始状态</param>
void OnEnter(IState? from);
/// <summary>
/// 当状态退出时调用
/// 当状态退出时调用
/// </summary>
/// <param name="to">将要转换到的目标状态，可能为null表示结束状态</param>
void OnExit(IState? to);
/// <summary>
/// 判断当前状态是否可以转换到目标状态
/// 判断当前状态是否可以转换到目标状态
/// </summary>
/// <param name="target">目标状态</param>
/// <returns>如果可以转换则返回true，否则返回false</returns>

29
GFramework.Core.Abstractions/state/IStateMachine.cs
View File

@ -1,84 +1,81 @@
using System;
using System.Collections.Generic;
namespace GFramework.Core.Abstractions.state;
/// <summary>
/// 状态机接口，用于管理状态的注册、切换和验证
/// 状态机接口，用于管理状态的注册、切换和验证
/// </summary>
public interface IStateMachine
{
/// <summary>
/// 获取当前激活的状态
/// 获取当前激活的状态
/// </summary>
IState? Current { get; }
/// <summary>
/// 注册一个状态到状态机中
/// 注册一个状态到状态机中
/// </summary>
/// <param name="state">要注册的状态实例</param>
IStateMachine Register(IState state);
/// <summary>
/// 从状态机中注销指定类型的状态
/// 从状态机中注销指定类型的状态
/// </summary>
/// <typeparam name="T">要注销的状态类型，必须实现IState接口</typeparam>
IStateMachine Unregister<T>() where T : IState;
/// <summary>
/// 检查是否可以切换到指定类型的状态
/// 检查是否可以切换到指定类型的状态
/// </summary>
/// <typeparam name="T">目标状态类型，必须实现IState接口</typeparam>
/// <returns>如果可以切换则返回true，否则返回false</returns>
bool CanChangeTo<T>() where T : IState;
/// <summary>
/// 切换到指定类型的状态
/// 切换到指定类型的状态
/// </summary>
/// <typeparam name="T">要切换到的状态类型，必须实现IState接口</typeparam>
/// <returns>如果成功切换则返回true，否则返回false</returns>
bool ChangeTo<T>() where T : IState;
/// <summary>
/// 检查指定类型的状态是否已注册
/// 检查指定类型的状态是否已注册
/// </summary>
/// <typeparam name="T">要检查的状态类型</typeparam>
/// <returns>如果状态已注册则返回true，否则返回false</returns>
bool IsRegistered<T>() where T : IState;
/// <summary>
/// 获取指定类型的已注册状态实例
/// 获取指定类型的已注册状态实例
/// </summary>
/// <typeparam name="T">要获取的状态类型</typeparam>
/// <returns>如果状态存在则返回对应实例，否则返回null</returns>
T? GetState<T>() where T : class, IState;
/// <summary>
/// 获取所有已注册状态的类型集合
/// 获取所有已注册状态的类型集合
/// </summary>
/// <returns>包含所有已注册状态类型的枚举器</returns>
IEnumerable<Type> GetRegisteredStateTypes();
/// <summary>
/// 获取上一个状态
/// 获取上一个状态
/// </summary>
/// <returns>如果历史记录存在则返回上一个状态，否则返回null</returns>
IState? GetPreviousState();
/// <summary>
/// 获取状态历史记录
/// 获取状态历史记录
/// </summary>
/// <returns>状态历史记录的只读副本</returns>
IReadOnlyList<IState> GetStateHistory();
/// <summary>
/// 回退到上一个状态
/// 回退到上一个状态
/// </summary>
/// <returns>如果成功回退则返回true，否则返回false</returns>
bool GoBack();
/// <summary>
/// 清空状态历史记录
/// 清空状态历史记录
/// </summary>
void ClearHistory();
}

4
GFramework.Core.Abstractions/state/IStateMachineSystem.cs
View File

@ -3,7 +3,7 @@
namespace GFramework.Core.Abstractions.state;
/// <summary>
/// 状态机系统接口，继承自ISystem和IStateMachine接口
/// 提供状态机系统的功能定义，结合了系统管理和状态机管理的能力
/// 状态机系统接口，继承自ISystem和IStateMachine接口
/// 提供状态机系统的功能定义，结合了系统管理和状态机管理的能力
/// </summary>
public interface IStateMachineSystem : ISystem, IStateMachine;

21
GFramework.Core.Abstractions/storage/IStorage.cs
View File

@ -1,29 +1,28 @@
using System.Threading.Tasks;
using GFramework.Core.Abstractions.utility;
using GFramework.Core.Abstractions.utility;
namespace GFramework.Core.Abstractions.storage;
/// <summary>
/// 存储接口，提供同步和异步的数据存储操作功能
/// 存储接口，提供同步和异步的数据存储操作功能
/// </summary>
public interface IStorage : IUtility
{
/// <summary>
/// 检查指定键的存储项是否存在
/// 检查指定键的存储项是否存在
/// </summary>
/// <param name="key">要检查的键</param>
/// <returns>如果键存在则返回true，否则返回false</returns>
bool Exists(string key);
/// <summary>
/// 异步检查指定键的存储项是否存在
/// 异步检查指定键的存储项是否存在
/// </summary>
/// <param name="key">要检查的键</param>
/// <returns>如果键存在则返回true，否则返回false</returns>
Task<bool> ExistsAsync(string key);
/// <summary>
/// 读取指定键的值
/// 读取指定键的值
/// </summary>
/// <typeparam name="T">要读取的值的类型</typeparam>
/// <param name="key">要读取的键</param>
@ -31,7 +30,7 @@ public interface IStorage : IUtility
T Read<T>(string key);
/// <summary>
/// 读取指定键的值，如果键不存在则返回默认值
/// 读取指定键的值，如果键不存在则返回默认值
/// </summary>
/// <typeparam name="T">要读取的值的类型</typeparam>
/// <param name="key">要读取的键</param>
@ -40,7 +39,7 @@ public interface IStorage : IUtility
T Read<T>(string key, T defaultValue);
/// <summary>
/// 异步读取指定键的值
/// 异步读取指定键的值
/// </summary>
/// <typeparam name="T">要读取的值的类型</typeparam>
/// <param name="key">要读取的键</param>
@ -48,7 +47,7 @@ public interface IStorage : IUtility
Task<T> ReadAsync<T>(string key);
/// <summary>
/// 将值写入指定键
/// 将值写入指定键
/// </summary>
/// <typeparam name="T">要写入的值的类型</typeparam>
/// <param name="key">要写入的键</param>
@ -56,7 +55,7 @@ public interface IStorage : IUtility
void Write<T>(string key, T value);
/// <summary>
/// 异步将值写入指定键
/// 异步将值写入指定键
/// </summary>
/// <typeparam name="T">要写入的值的类型</typeparam>
/// <param name="key">要写入的键</param>
@ -65,7 +64,7 @@ public interface IStorage : IUtility
Task WriteAsync<T>(string key, T value);
/// <summary>
/// 删除指定键的存储项
/// 删除指定键的存储项
/// </summary>
/// <param name="key">要删除的键</param>
void Delete(string key);

8
GFramework.Core.Tests/GFramework.Core.Tests.csproj
View File

@ -6,13 +6,13 @@
<TargetFrameworks>net10.0;net8.0</TargetFrameworks>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
<PackageReference Include="NUnit" Version="4.4.0" />
<PackageReference Include="NUnit3TestAdapter" Version="6.1.0" />
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.1"/>
<PackageReference Include="NUnit" Version="4.4.0"/>
<PackageReference Include="NUnit3TestAdapter" Version="6.1.0"/>
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\GFramework.Core\GFramework.Core.csproj" />
<ProjectReference Include="..\GFramework.Core\GFramework.Core.csproj"/>
</ItemGroup>
</Project>

42
GFramework.Core.Tests/architecture/ArchitectureConfigurationTests.cs
View File

@ -8,15 +8,15 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.architecture;
/// <summary>
/// ArchitectureConfiguration类的单元测试
/// 测试内容包括：
/// - 构造函数默认值
/// - LoggerProperties默认配置（ConsoleLoggerFactoryProvider + Info级别）
/// - ArchitectureProperties默认配置（AllowLateRegistration=false, StrictPhaseValidation=true）
/// - 自定义配置替换
/// - LoggerProperties独立修改
/// - ArchitectureProperties独立修改
/// - IArchitectureConfiguration接口实现验证
/// ArchitectureConfiguration类的单元测试
/// 测试内容包括：
/// - 构造函数默认值
/// - LoggerProperties默认配置（ConsoleLoggerFactoryProvider + Info级别）
/// - ArchitectureProperties默认配置（AllowLateRegistration=false, StrictPhaseValidation=true）
/// - 自定义配置替换
/// - LoggerProperties独立修改
/// - ArchitectureProperties独立修改
/// - IArchitectureConfiguration接口实现验证
/// </summary>
[TestFixture]
public class ArchitectureConfigurationTests
@ -30,7 +30,7 @@ public class ArchitectureConfigurationTests
private ArchitectureConfiguration? _configuration;
/// <summary>
/// 测试构造函数是否正确初始化LoggerProperties
/// 测试构造函数是否正确初始化LoggerProperties
/// </summary>
[Test]
public void Constructor_Should_Initialize_LoggerProperties_With_Default_Values()
@ -40,7 +40,7 @@ public class ArchitectureConfigurationTests
}
/// <summary>
/// 测试LoggerProperties默认使用ConsoleLoggerFactoryProvider
/// 测试LoggerProperties默认使用ConsoleLoggerFactoryProvider
/// </summary>
[Test]
public void LoggerProperties_Should_Use_ConsoleLoggerFactoryProvider_By_Default()
@ -50,7 +50,7 @@ public class ArchitectureConfigurationTests
}
/// <summary>
/// 测试LoggerProperties默认使用Info日志级别
/// 测试LoggerProperties默认使用Info日志级别
/// </summary>
[Test]
public void LoggerProperties_Should_Use_Info_LogLevel_By_Default()
@ -63,7 +63,7 @@ public class ArchitectureConfigurationTests
}
/// <summary>
/// 测试ArchitectureProperties的AllowLateRegistration默认为false
/// 测试ArchitectureProperties的AllowLateRegistration默认为false
/// </summary>
[Test]
public void ArchitectureProperties_Should_Have_AllowLateRegistration_Set_To_False_By_Default()
@ -73,7 +73,7 @@ public class ArchitectureConfigurationTests
}
/// <summary>
/// 测试ArchitectureProperties的StrictPhaseValidation默认为true
/// 测试ArchitectureProperties的StrictPhaseValidation默认为true
/// </summary>
[Test]
public void ArchitectureProperties_Should_Have_StrictPhaseValidation_Set_To_True_By_Default()
@ -83,7 +83,7 @@ public class ArchitectureConfigurationTests
}
/// <summary>
/// 测试LoggerProperties可以被自定义配置替换
/// 测试LoggerProperties可以被自定义配置替换
/// </summary>
[Test]
public void LoggerProperties_Should_Be_Replaced_With_Custom_Configuration()
@ -105,7 +105,7 @@ public class ArchitectureConfigurationTests
}
/// <summary>
/// 测试ArchitectureProperties可以被自定义配置替换
/// 测试ArchitectureProperties可以被自定义配置替换
/// </summary>
[Test]
public void ArchitectureProperties_Should_Be_Replaced_With_Custom_Configuration()
@ -126,7 +126,7 @@ public class ArchitectureConfigurationTests
}
/// <summary>
/// 测试LoggerProperties可以独立修改
/// 测试LoggerProperties可以独立修改
/// </summary>
[Test]
public void LoggerProperties_Should_Be_Modifiable_Independently()
@ -142,7 +142,7 @@ public class ArchitectureConfigurationTests
}
/// <summary>
/// 测试ArchitectureProperties可以独立修改
/// 测试ArchitectureProperties可以独立修改
/// </summary>
[Test]
public void ArchitectureProperties_Should_Be_Modifiable_Independently()
@ -157,7 +157,7 @@ public class ArchitectureConfigurationTests
}
/// <summary>
/// 测试ArchitectureConfiguration实现IArchitectureConfiguration接口
/// 测试ArchitectureConfiguration实现IArchitectureConfiguration接口
/// </summary>
[Test]
public void ArchitectureConfiguration_Should_Implement_IArchitectureConfiguration_Interface()
@ -166,7 +166,7 @@ public class ArchitectureConfigurationTests
}
/// <summary>
/// 测试新实例不与其他实例共享LoggerProperties
/// 测试新实例不与其他实例共享LoggerProperties
/// </summary>
[Test]
public void New_Instance_Should_Not_Share_LoggerProperties_With_Other_Instance()
@ -178,7 +178,7 @@ public class ArchitectureConfigurationTests
}
/// <summary>
/// 测试新实例不与其他实例共享ArchitectureProperties
/// 测试新实例不与其他实例共享ArchitectureProperties
/// </summary>
[Test]
public void New_Instance_Should_Not_Share_ArchitectureProperties_With_Other_Instance()

42
GFramework.Core.Tests/architecture/ArchitectureConstantsTests.cs
View File

@ -6,19 +6,19 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.architecture;
/// <summary>
/// ArchitectureConstants类的单元测试
/// 测试内容包括：
/// - 常量值的正确性
/// - 常量类型验证
/// - 常量可访问性
/// - 常量命名规范
/// - 架构阶段定义常量
/// ArchitectureConstants类的单元测试
/// 测试内容包括：
/// - 常量值的正确性
/// - 常量类型验证
/// - 常量可访问性
/// - 常量命名规范
/// - 架构阶段定义常量
/// </summary>
[TestFixture]
public class ArchitectureConstantsTests
{
/// <summary>
/// 测试PhaseOrder数组不为空
/// 测试PhaseOrder数组不为空
/// </summary>
[Test]
public void PhaseOrder_Should_Not_Be_Empty()
@ -28,7 +28,7 @@ public class ArchitectureConstantsTests
}
/// <summary>
/// 测试PhaseOrder包含所有预期的架构阶段
/// 测试PhaseOrder包含所有预期的架构阶段
/// </summary>
[Test]
public void PhaseOrder_Should_Contain_All_Expected_Phases()
@ -50,13 +50,11 @@ public class ArchitectureConstantsTests
Assert.That(ArchitectureConstants.PhaseOrder.Length, Is.EqualTo(expectedPhases.Length));
foreach (var expectedPhase in expectedPhases)
{
Assert.That(ArchitectureConstants.PhaseOrder, Does.Contain(expectedPhase));
}
}
/// <summary>
/// 测试PhaseOrder数组是只读的
/// 测试PhaseOrder数组是只读的
/// </summary>
[Test]
public void PhaseOrder_Should_Be_Immutable()
@ -67,7 +65,7 @@ public class ArchitectureConstantsTests
}
/// <summary>
/// 测试PhaseOrder的顺序是正确的
/// 测试PhaseOrder的顺序是正确的
/// </summary>
[Test]
public void PhaseOrder_Should_Be_In_Correct_Sequence()
@ -91,7 +89,7 @@ public class ArchitectureConstantsTests
}
/// <summary>
/// 测试PhaseTransitions字典不为空
/// 测试PhaseTransitions字典不为空
/// </summary>
[Test]
public void PhaseTransitions_Should_Not_Be_Empty()
@ -101,7 +99,7 @@ public class ArchitectureConstantsTests
}
/// <summary>
/// 测试PhaseTransitions是只读的
/// 测试PhaseTransitions是只读的
/// </summary>
[Test]
public void PhaseTransitions_Should_Be_Immutable()
@ -111,7 +109,7 @@ public class ArchitectureConstantsTests
}
/// <summary>
/// 测试PhaseTransitions包含正常线性流程的转换
/// 测试PhaseTransitions包含正常线性流程的转换
/// </summary>
[Test]
public void PhaseTransitions_Should_Contain_Normal_Linear_Transitions()
@ -128,7 +126,7 @@ public class ArchitectureConstantsTests
}
/// <summary>
/// 测试PhaseTransitions中的转换方向是正确的
/// 测试PhaseTransitions中的转换方向是正确的
/// </summary>
[Test]
public void PhaseTransitions_Should_Have_Correct_Directions()
@ -147,7 +145,7 @@ public class ArchitectureConstantsTests
}
/// <summary>
/// 测试PhaseTransitions包含失败初始化的转换路径
/// 测试PhaseTransitions包含失败初始化的转换路径
/// </summary>
[Test]
public void PhaseTransitions_Should_Contain_FailedInitialization_Transition()
@ -158,20 +156,18 @@ public class ArchitectureConstantsTests
}
/// <summary>
/// 测试每个阶段的转换数量不超过1个（线性转换）
/// 测试每个阶段的转换数量不超过1个（线性转换）
/// </summary>
[Test]
public void PhaseTransitions_Should_Have_Maximum_One_Transition_Per_Phase()
{
foreach (var transition in ArchitectureConstants.PhaseTransitions)
{
Assert.That(transition.Value, Has.Length.LessThanOrEqualTo(1),
$"Phase {transition.Key} should have at most 1 transition");
}
}
/// <summary>
/// 测试PhaseOrder和PhaseTransitions的一致性
/// 测试PhaseOrder和PhaseTransitions的一致性
/// </summary>
[Test]
public void PhaseOrder_And_PhaseTransitions_Should_Be_Consistent()
@ -179,7 +175,7 @@ public class ArchitectureConstantsTests
var phaseOrder = ArchitectureConstants.PhaseOrder;
var transitions = ArchitectureConstants.PhaseTransitions;
for (int i = 0; i < phaseOrder.Length - 1; i++)
for (var i = 0; i < phaseOrder.Length - 1; i++)
{
var currentPhase = phaseOrder[i];
var nextPhase = phaseOrder[i + 1];

168
GFramework.Core.Tests/architecture/ArchitectureContextTests.cs
View File

@ -19,26 +19,26 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.architecture;
/// <summary>
/// ArchitectureContext类的单元测试
/// 测试内容包括：
/// - 构造函数参数验证（所有5个参数）
/// - 构造函数空参数异常
/// - SendQuery方法 - 正常查询发送
/// - SendQuery方法 - 空查询异常
/// - SendCommand方法 - 正常命令发送
/// - SendCommand方法 - 空命令异常
/// - SendCommand_WithResult方法 - 正常命令发送
/// - SendCommand_WithResult方法 - 空命令异常
/// - SendEvent方法 - 正常事件发送
/// - SendEvent_WithInstance方法 - 正常事件发送
/// - SendEvent_WithInstance方法 - 空事件异常
/// - GetSystem方法 - 获取已注册系统
/// - GetSystem方法 - 获取未注册系统
/// - GetModel方法 - 获取已注册模型
/// - GetModel方法 - 获取未注册模型
/// - GetUtility方法 - 获取已注册工具
/// - GetUtility方法 - 获取未注册工具
/// - GetEnvironment方法 - 获取环境对象
/// ArchitectureContext类的单元测试
/// 测试内容包括：
/// - 构造函数参数验证（所有5个参数）
/// - 构造函数空参数异常
/// - SendQuery方法 - 正常查询发送
/// - SendQuery方法 - 空查询异常
/// - SendCommand方法 - 正常命令发送
/// - SendCommand方法 - 空命令异常
/// - SendCommand_WithResult方法 - 正常命令发送
/// - SendCommand_WithResult方法 - 空命令异常
/// - SendEvent方法 - 正常事件发送
/// - SendEvent_WithInstance方法 - 正常事件发送
/// - SendEvent_WithInstance方法 - 空事件异常
/// - GetSystem方法 - 获取已注册系统
/// - GetSystem方法 - 获取未注册系统
/// - GetModel方法 - 获取已注册模型
/// - GetModel方法 - 获取未注册模型
/// - GetUtility方法 - 获取已注册工具
/// - GetUtility方法 - 获取未注册工具
/// - GetEnvironment方法 - 获取环境对象
/// </summary>
[TestFixture]
public class ArchitectureContextTests
@ -83,7 +83,7 @@ public class ArchitectureContextTests
private DefaultEnvironment? _environment;
/// <summary>
/// 测试构造函数在所有参数都有效时不应抛出异常
/// 测试构造函数在所有参数都有效时不应抛出异常
/// </summary>
[Test]
public void Constructor_Should_NotThrow_When_AllParameters_AreValid()
@ -92,7 +92,7 @@ public class ArchitectureContextTests
}
/// <summary>
/// 测试构造函数在 container 为 null 时应抛出 ArgumentNullException
/// 测试构造函数在 container 为 null 时应抛出 ArgumentNullException
/// </summary>
[Test]
public void Constructor_Should_Throw_When_Container_IsNull()
@ -101,7 +101,7 @@ public class ArchitectureContextTests
}
/// <summary>
/// 测试构造函数在Container为null时应抛出ArgumentNullException
/// 测试构造函数在Container为null时应抛出ArgumentNullException
/// </summary>
[Test]
public void Constructor_Should_ThrowArgumentNullException_When_Container_IsNull()
@ -111,7 +111,7 @@ public class ArchitectureContextTests
}
/// <summary>
/// 测试SendQuery方法在查询有效时返回正确结果
/// 测试SendQuery方法在查询有效时返回正确结果
/// </summary>
[Test]
public void SendQuery_Should_ReturnResult_When_Query_IsValid()
@ -123,7 +123,7 @@ public class ArchitectureContextTests
}
/// <summary>
/// 测试SendQuery方法在查询为null时应抛出ArgumentNullException
/// 测试SendQuery方法在查询为null时应抛出ArgumentNullException
/// </summary>
[Test]
public void SendQuery_Should_ThrowArgumentNullException_When_Query_IsNull()
@ -133,7 +133,7 @@ public class ArchitectureContextTests
}
/// <summary>
/// 测试SendCommand方法在命令有效时正确执行
/// 测试SendCommand方法在命令有效时正确执行
/// </summary>
[Test]
public void SendCommand_Should_ExecuteCommand_When_Command_IsValid()
@ -144,17 +144,17 @@ public class ArchitectureContextTests
}
/// <summary>
/// 测试SendCommand方法在命令为null时应抛出ArgumentNullException
/// 测试SendCommand方法在命令为null时应抛出ArgumentNullException
/// </summary>
[Test]
public void SendCommand_Should_ThrowArgumentNullException_When_Command_IsNull()
{
Assert.That(() => _context!.SendCommand((ICommand)null!),
Assert.That(() => _context!.SendCommand(null!),
Throws.ArgumentNullException.With.Property("ParamName").EqualTo("command"));
}
/// <summary>
/// 测试SendCommand方法（带返回值）在命令有效时返回正确结果
/// 测试SendCommand方法（带返回值）在命令有效时返回正确结果
/// </summary>
[Test]
public void SendCommand_WithResult_Should_ReturnResult_When_Command_IsValid()
@ -166,7 +166,7 @@ public class ArchitectureContextTests
}
/// <summary>
/// 测试SendCommand方法（带返回值）在命令为null时应抛出ArgumentNullException
/// 测试SendCommand方法（带返回值）在命令为null时应抛出ArgumentNullException
/// </summary>
[Test]
public void SendCommand_WithResult_Should_ThrowArgumentNullException_When_Command_IsNull()
@ -176,12 +176,12 @@ public class ArchitectureContextTests
}
/// <summary>
/// 测试SendEvent方法在事件类型有效时正确发送事件
/// 测试SendEvent方法在事件类型有效时正确发送事件
/// </summary>
[Test]
public void SendEvent_Should_SendEvent_When_EventType_IsValid()
{
bool eventReceived = false;
var eventReceived = false;
_context!.RegisterEvent<TestEventV2>(_ => eventReceived = true);
_context.SendEvent<TestEventV2>();
@ -189,12 +189,12 @@ public class ArchitectureContextTests
}
/// <summary>
/// 测试SendEvent方法（带实例）在事件实例有效时正确发送事件
/// 测试SendEvent方法（带实例）在事件实例有效时正确发送事件
/// </summary>
[Test]
public void SendEvent_WithInstance_Should_SendEvent_When_EventInstance_IsValid()
{
bool eventReceived = false;
var eventReceived = false;
var testEvent = new TestEventV2();
_context!.RegisterEvent<TestEventV2>(_ => eventReceived = true);
_context.SendEvent(testEvent);
@ -203,7 +203,7 @@ public class ArchitectureContextTests
}
/// <summary>
/// 测试SendEvent方法（带实例）在事件实例为null时应抛出ArgumentNullException
/// 测试SendEvent方法（带实例）在事件实例为null时应抛出ArgumentNullException
/// </summary>
[Test]
public void SendEvent_WithInstance_Should_ThrowArgumentNullException_When_EventInstance_IsNull()
@ -213,7 +213,7 @@ public class ArchitectureContextTests
}
/// <summary>
/// 测试GetSystem方法在系统已注册时返回注册的系统
/// 测试GetSystem方法在系统已注册时返回注册的系统
/// </summary>
[Test]
public void GetSystem_Should_ReturnRegisteredSystem_When_SystemIsRegistered()
@ -228,7 +228,7 @@ public class ArchitectureContextTests
}
/// <summary>
/// 测试GetSystem方法在系统未注册时返回null
/// 测试GetSystem方法在系统未注册时返回null
/// </summary>
[Test]
public void GetSystem_Should_ReturnNull_When_SystemIsNotRegistered()
@ -239,7 +239,7 @@ public class ArchitectureContextTests
}
/// <summary>
/// 测试GetModel方法在模型已注册时返回注册的模型
/// 测试GetModel方法在模型已注册时返回注册的模型
/// </summary>
[Test]
public void GetModel_Should_ReturnRegisteredModel_When_ModelIsRegistered()
@ -254,7 +254,7 @@ public class ArchitectureContextTests
}
/// <summary>
/// 测试GetModel方法在模型未注册时返回null
/// 测试GetModel方法在模型未注册时返回null
/// </summary>
[Test]
public void GetModel_Should_ReturnNull_When_ModelIsNotRegistered()
@ -265,7 +265,7 @@ public class ArchitectureContextTests
}
/// <summary>
/// 测试GetUtility方法在工具已注册时返回注册的工具
/// 测试GetUtility方法在工具已注册时返回注册的工具
/// </summary>
[Test]
public void GetUtility_Should_ReturnRegisteredUtility_When_UtilityIsRegistered()
@ -280,7 +280,7 @@ public class ArchitectureContextTests
}
/// <summary>
/// 测试GetUtility方法在工具未注册时返回null
/// 测试GetUtility方法在工具未注册时返回null
/// </summary>
[Test]
public void GetUtility_Should_ReturnNull_When_UtilityIsNotRegistered()
@ -291,7 +291,7 @@ public class ArchitectureContextTests
}
/// <summary>
/// 测试GetEnvironment方法返回环境实例
/// 测试GetEnvironment方法返回环境实例
/// </summary>
[Test]
public void GetEnvironment_Should_Return_EnvironmentInstance()
@ -310,8 +310,15 @@ public class TestSystemV2 : ISystem
private IArchitectureContext _context = null!;
public int Id { get; init; }
public void SetContext(IArchitectureContext context) => _context = context;
public IArchitectureContext GetContext() => _context;
public void SetContext(IArchitectureContext context)
{
_context = context;
}
public IArchitectureContext GetContext()
{
return _context;
}
public void Init()
{
@ -331,8 +338,15 @@ public class TestModelV2 : IModel
private IArchitectureContext _context = null!;
public int Id { get; init; }
public void SetContext(IArchitectureContext context) => _context = context;
public IArchitectureContext GetContext() => _context;
public void SetContext(IArchitectureContext context)
{
_context = context;
}
public IArchitectureContext GetContext()
{
return _context;
}
public void Init()
{
@ -352,8 +366,15 @@ public class TestUtilityV2 : IUtility
private IArchitectureContext _context = null!;
public int Id { get; init; }
public void SetContext(IArchitectureContext context) => _context = context;
public IArchitectureContext GetContext() => _context;
public void SetContext(IArchitectureContext context)
{
_context = context;
}
public IArchitectureContext GetContext()
{
return _context;
}
}
public class TestQueryV2 : IQuery<int>
@ -361,9 +382,20 @@ public class TestQueryV2 : IQuery<int>
private IArchitectureContext _context = null!;
public int Result { get; init; }
public int Do() => Result;
public void SetContext(IArchitectureContext context) => _context = context;
public IArchitectureContext GetContext() => _context;
public int Do()
{
return Result;
}
public void SetContext(IArchitectureContext context)
{
_context = context;
}
public IArchitectureContext GetContext()
{
return _context;
}
}
public class TestCommandV2 : ICommand
@ -371,9 +403,20 @@ public class TestCommandV2 : ICommand
private IArchitectureContext _context = null!;
public bool Executed { get; private set; }
public void Execute() => Executed = true;
public void SetContext(IArchitectureContext context) => _context = context;
public IArchitectureContext GetContext() => _context;
public void Execute()
{
Executed = true;
}
public void SetContext(IArchitectureContext context)
{
_context = context;
}
public IArchitectureContext GetContext()
{
return _context;
}
}
public class TestCommandWithResultV2 : ICommand<int>
@ -381,9 +424,20 @@ public class TestCommandWithResultV2 : ICommand<int>
private IArchitectureContext _context = null!;
public int Result { get; init; }
public int Execute() => Result;
public void SetContext(IArchitectureContext context) => _context = context;
public IArchitectureContext GetContext() => _context;
public int Execute()
{
return Result;
}
public void SetContext(IArchitectureContext context)
{
_context = context;
}
public IArchitectureContext GetContext()
{
return _context;
}
}
public class TestEventV2

98
GFramework.Core.Tests/architecture/ArchitectureServicesTests.cs
View File

@ -18,17 +18,17 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.architecture;
/// <summary>
/// ArchitectureServices类的单元测试
/// 测试内容包括：
/// - 服务容器初始化
/// - 所有服务实例创建（Container, EventBus, CommandBus, QueryBus）
/// - SetContext方法 - 设置上下文
/// - SetContext方法 - 重复设置上下文
/// - GetContext方法 - 获取已设置上下文
/// - GetContext方法 - 未设置上下文时返回null
/// - 上下文传播到容器
/// - IArchitectureServices接口实现验证
/// - 服务独立性验证（多个实例）
/// ArchitectureServices类的单元测试
/// 测试内容包括：
/// - 服务容器初始化
/// - 所有服务实例创建（Container, EventBus, CommandBus, QueryBus）
/// - SetContext方法 - 设置上下文
/// - SetContext方法 - 重复设置上下文
/// - GetContext方法 - 获取已设置上下文
/// - GetContext方法 - 未设置上下文时返回null
/// - 上下文传播到容器
/// - IArchitectureServices接口实现验证
/// - 服务独立性验证（多个实例）
/// </summary>
[TestFixture]
public class ArchitectureServicesTests
@ -44,7 +44,7 @@ public class ArchitectureServicesTests
private TestArchitectureContextV3? _context;
/// <summary>
/// 测试构造函数初始化所有服务
/// 测试构造函数初始化所有服务
/// </summary>
[Test]
public void Constructor_Should_Initialize_AllServices()
@ -63,7 +63,7 @@ public class ArchitectureServicesTests
}
/// <summary>
/// 测试EventBus是EventBus的实例
/// 测试EventBus是EventBus的实例
/// </summary>
[Test]
public void EventBus_Should_Be_Instance_Of_EventBus()
@ -73,7 +73,7 @@ public class ArchitectureServicesTests
}
/// <summary>
/// 测试CommandBus是CommandBus的实例
/// 测试CommandBus是CommandBus的实例
/// </summary>
[Test]
public void CommandBus_Should_Be_Instance_Of_CommandBus()
@ -83,7 +83,7 @@ public class ArchitectureServicesTests
}
/// <summary>
/// 测试QueryBus是QueryBus的实例
/// 测试QueryBus是QueryBus的实例
/// </summary>
[Test]
public void QueryBus_Should_Be_Instance_Of_QueryBus()
@ -93,7 +93,7 @@ public class ArchitectureServicesTests
}
/// <summary>
/// 测试SetContext设置内部Context字段
/// 测试SetContext设置内部Context字段
/// </summary>
[Test]
public void SetContext_Should_Set_Context_Internal_Field()
@ -105,7 +105,7 @@ public class ArchitectureServicesTests
}
/// <summary>
/// 测试SetContext将上下文传播到Container
/// 测试SetContext将上下文传播到Container
/// </summary>
[Test]
public void SetContext_Should_Propagate_Context_To_Container()
@ -117,7 +117,7 @@ public class ArchitectureServicesTests
}
/// <summary>
/// 测试GetContext在SetContext后返回上下文
/// 测试GetContext在SetContext后返回上下文
/// </summary>
[Test]
public void GetContext_Should_Return_Context_After_SetContext()
@ -130,7 +130,7 @@ public class ArchitectureServicesTests
}
/// <summary>
/// 测试GetContext在未设置上下文时返回null
/// 测试GetContext在未设置上下文时返回null
/// </summary>
[Test]
public void GetContext_Should_ReturnNull_When_Context_Not_Set()
@ -141,7 +141,7 @@ public class ArchitectureServicesTests
}
/// <summary>
/// 测试SetContext替换已存在的上下文
/// 测试SetContext替换已存在的上下文
/// </summary>
[Test]
public void SetContext_Should_Replace_Existing_Context()
@ -157,7 +157,7 @@ public class ArchitectureServicesTests
}
/// <summary>
/// 测试ArchitectureServices实现IArchitectureServices接口
/// 测试ArchitectureServices实现IArchitectureServices接口
/// </summary>
[Test]
public void ArchitectureServices_Should_Implement_IArchitectureServices_Interface()
@ -166,7 +166,7 @@ public class ArchitectureServicesTests
}
/// <summary>
/// 测试多个实例有独立的Container
/// 测试多个实例有独立的Container
/// </summary>
[Test]
public void Multiple_Instances_Should_Have_Independent_Container()
@ -178,7 +178,7 @@ public class ArchitectureServicesTests
}
/// <summary>
/// 测试多个实例有独立的EventBus
/// 测试多个实例有独立的EventBus
/// </summary>
[Test]
public void Multiple_Instances_Should_Have_Independent_EventBus()
@ -190,7 +190,7 @@ public class ArchitectureServicesTests
}
/// <summary>
/// 测试多个实例有独立的CommandBus
/// 测试多个实例有独立的CommandBus
/// </summary>
[Test]
public void Multiple_Instances_Should_Have_Independent_CommandBus()
@ -202,7 +202,7 @@ public class ArchitectureServicesTests
}
/// <summary>
/// 测试多个实例有独立的QueryBus
/// 测试多个实例有独立的QueryBus
/// </summary>
[Test]
public void Multiple_Instances_Should_Have_Independent_QueryBus()
@ -227,10 +227,25 @@ public class TestArchitectureContextV3 : IArchitectureContext
public ICommandBus CommandBus => new CommandBus();
public IQueryBus QueryBus => new QueryBus();
public TService? GetService<TService>() where TService : class => _container.Get<TService>();
public TModel? GetModel<TModel>() where TModel : class, IModel => _container.Get<TModel>();
public TSystem? GetSystem<TSystem>() where TSystem : class, ISystem => _container.Get<TSystem>();
public TUtility? GetUtility<TUtility>() where TUtility : class, IUtility => _container.Get<TUtility>();
public TService? GetService<TService>() where TService : class
{
return _container.Get<TService>();
}
public TModel? GetModel<TModel>() where TModel : class, IModel
{
return _container.Get<TModel>();
}
public TSystem? GetSystem<TSystem>() where TSystem : class, ISystem
{
return _container.Get<TSystem>();
}
public TUtility? GetUtility<TUtility>() where TUtility : class, IUtility
{
return _container.Get<TUtility>();
}
public void SendEvent<TEvent>() where TEvent : new()
{
@ -240,7 +255,10 @@ public class TestArchitectureContextV3 : IArchitectureContext
{
}
public IUnRegister RegisterEvent<TEvent>(Action<TEvent> handler) => new DefaultUnRegister(() => { });
public IUnRegister RegisterEvent<TEvent>(Action<TEvent> handler)
{
return new DefaultUnRegister(() => { });
}
public void UnRegisterEvent<TEvent>(Action<TEvent> onEvent)
{
@ -250,7 +268,10 @@ public class TestArchitectureContextV3 : IArchitectureContext
{
}
public TResult SendCommand<TResult>(ICommand<TResult> command) => default!;
public TResult SendCommand<TResult>(ICommand<TResult> command)
{
return default!;
}
public Task SendCommandAsync(IAsyncCommand command)
{
@ -262,11 +283,20 @@ public class TestArchitectureContextV3 : IArchitectureContext
return (Task<TResult>)Task.CompletedTask;
}
public TResult SendQuery<TResult>(IQuery<TResult> query) => default!;
public TResult SendQuery<TResult>(IQuery<TResult> query)
{
return default!;
}
public Task<TResult> SendQueryAsync<TResult>(IAsyncQuery<TResult> query) => (Task<TResult>)Task.CompletedTask;
public Task<TResult> SendQueryAsync<TResult>(IAsyncQuery<TResult> query)
{
return (Task<TResult>)Task.CompletedTask;
}
public IEnvironment GetEnvironment() => _environment;
public IEnvironment GetEnvironment()
{
return _environment;
}
}
#endregion

143
GFramework.Core.Tests/architecture/GameContextTests.cs
View File

@ -18,26 +18,26 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.architecture;
/// <summary>
/// GameContext类的单元测试
/// 测试内容包括：
/// - ArchitectureReadOnlyDictionary在启动时为空
/// - Bind方法添加上下文到字典
/// - Bind重复类型时抛出异常
/// - GetByType返回正确的上下文
/// - GetByType未找到时抛出异常
/// - Get泛型方法返回正确的上下文
/// - TryGet方法在找到时返回true
/// - TryGet方法在未找到时返回false
/// - GetFirstArchitectureContext在存在时返回
/// - GetFirstArchitectureContext为空时抛出异常
/// - Unbind移除上下文
/// - Clear移除所有上下文
/// GameContext类的单元测试
/// 测试内容包括：
/// - ArchitectureReadOnlyDictionary在启动时为空
/// - Bind方法添加上下文到字典
/// - Bind重复类型时抛出异常
/// - GetByType返回正确的上下文
/// - GetByType未找到时抛出异常
/// - Get泛型方法返回正确的上下文
/// - TryGet方法在找到时返回true
/// - TryGet方法在未找到时返回false
/// - GetFirstArchitectureContext在存在时返回
/// - GetFirstArchitectureContext为空时抛出异常
/// - Unbind移除上下文
/// - Clear移除所有上下文
/// </summary>
[TestFixture]
public class GameContextTests
{
/// <summary>
/// 测试初始化方法，在每个测试方法执行前清空GameContext
/// 测试初始化方法，在每个测试方法执行前清空GameContext
/// </summary>
[SetUp]
public void SetUp()
@ -46,7 +46,7 @@ public class GameContextTests
}
/// <summary>
/// 测试清理方法，在每个测试方法执行后清空GameContext
/// 测试清理方法，在每个测试方法执行后清空GameContext
/// </summary>
[TearDown]
public void TearDown()
@ -55,7 +55,7 @@ public class GameContextTests
}
/// <summary>
/// 测试ArchitectureReadOnlyDictionary在启动时返回空字典
/// 测试ArchitectureReadOnlyDictionary在启动时返回空字典
/// </summary>
[Test]
public void ArchitectureReadOnlyDictionary_Should_Return_Empty_At_Start()
@ -66,7 +66,7 @@ public class GameContextTests
}
/// <summary>
/// 测试Bind方法是否正确将上下文添加到字典中
/// 测试Bind方法是否正确将上下文添加到字典中
/// </summary>
[Test]
public void Bind_Should_Add_Context_To_Dictionary()
@ -79,7 +79,7 @@ public class GameContextTests
}
/// <summary>
/// 测试Bind方法在绑定重复类型时是否抛出InvalidOperationException异常
/// 测试Bind方法在绑定重复类型时是否抛出InvalidOperationException异常
/// </summary>
[Test]
public void Bind_WithDuplicateType_Should_ThrowInvalidOperationException()
@ -94,7 +94,7 @@ public class GameContextTests
}
/// <summary>
/// 测试GetByType方法是否返回正确的上下文
/// 测试GetByType方法是否返回正确的上下文
/// </summary>
[Test]
public void GetByType_Should_Return_Correct_Context()
@ -108,7 +108,7 @@ public class GameContextTests
}
/// <summary>
/// 测试GetByType方法在未找到对应类型时是否抛出InvalidOperationException异常
/// 测试GetByType方法在未找到对应类型时是否抛出InvalidOperationException异常
/// </summary>
[Test]
public void GetByType_Should_Throw_When_Not_Found()
@ -118,7 +118,7 @@ public class GameContextTests
}
/// <summary>
/// 测试Get泛型方法是否返回正确的上下文
/// 测试Get泛型方法是否返回正确的上下文
/// </summary>
[Test]
public void GetGeneric_Should_Return_Correct_Context()
@ -132,7 +132,7 @@ public class GameContextTests
}
/// <summary>
/// 测试TryGet方法在找到上下文时是否返回true并正确设置输出参数
/// 测试TryGet方法在找到上下文时是否返回true并正确设置输出参数
/// </summary>
[Test]
public void TryGet_Should_ReturnTrue_When_Found()
@ -147,7 +147,7 @@ public class GameContextTests
}
/// <summary>
/// 测试TryGet方法在未找到上下文时是否返回false且输出参数为null
/// 测试TryGet方法在未找到上下文时是否返回false且输出参数为null
/// </summary>
[Test]
public void TryGet_Should_ReturnFalse_When_Not_Found()
@ -159,7 +159,7 @@ public class GameContextTests
}
/// <summary>
/// 测试GetFirstArchitectureContext方法在存在上下文时是否返回正确的上下文
/// 测试GetFirstArchitectureContext方法在存在上下文时是否返回正确的上下文
/// </summary>
[Test]
public void GetFirstArchitectureContext_Should_Return_When_Exists()
@ -173,7 +173,7 @@ public class GameContextTests
}
/// <summary>
/// 测试GetFirstArchitectureContext方法在没有上下文时是否抛出InvalidOperationException异常
/// 测试GetFirstArchitectureContext方法在没有上下文时是否抛出InvalidOperationException异常
/// </summary>
[Test]
public void GetFirstArchitectureContext_Should_Throw_When_Empty()
@ -183,7 +183,7 @@ public class GameContextTests
}
/// <summary>
/// 测试Unbind方法是否正确移除指定类型的上下文
/// 测试Unbind方法是否正确移除指定类型的上下文
/// </summary>
[Test]
public void Unbind_Should_Remove_Context()
@ -197,7 +197,7 @@ public class GameContextTests
}
/// <summary>
/// 测试Clear方法是否正确移除所有上下文
/// 测试Clear方法是否正确移除所有上下文
/// </summary>
[Test]
public void Clear_Should_Remove_All_Contexts()
@ -212,12 +212,12 @@ public class GameContextTests
}
/// <summary>
/// 测试用的架构类，继承自Architecture
/// 测试用的架构类，继承自Architecture
/// </summary>
public class TestArchitecture : Architecture
{
/// <summary>
/// 初始化方法，当前为空实现
/// 初始化方法，当前为空实现
/// </summary>
protected override void Init()
{
@ -225,67 +225,79 @@ public class TestArchitecture : Architecture
}
/// <summary>
/// 测试用的架构上下文类，实现了IArchitectureContext接口
/// 测试用的架构上下文类，实现了IArchitectureContext接口
/// </summary>
public class TestArchitectureContext : IArchitectureContext
{
private readonly IocContainer _container = new();
/// <summary>
/// 获取依赖注入容器
/// 获取依赖注入容器
/// </summary>
public IIocContainer Container => _container;
/// <summary>
/// 获取事件总线
/// 获取事件总线
/// </summary>
public IEventBus EventBus => new EventBus();
/// <summary>
/// 获取命令总线
/// 获取命令总线
/// </summary>
public ICommandBus CommandBus => new CommandBus();
/// <summary>
/// 获取查询总线
/// 获取查询总线
/// </summary>
public IQueryBus QueryBus => new QueryBus();
/// <summary>
/// 获取环境对象
/// 获取环境对象
/// </summary>
public IEnvironment Environment => new DefaultEnvironment();
/// <summary>
/// 获取指定类型的服务
/// 获取指定类型的服务
/// </summary>
/// <typeparam name="TService">服务类型</typeparam>
/// <returns>服务实例或null</returns>
public TService? GetService<TService>() where TService : class => _container.Get<TService>();
public TService? GetService<TService>() where TService : class
{
return _container.Get<TService>();
}
/// <summary>
/// 获取指定类型的模型
/// 获取指定类型的模型
/// </summary>
/// <typeparam name="TModel">模型类型</typeparam>
/// <returns>模型实例或null</returns>
public TModel? GetModel<TModel>() where TModel : class, IModel => _container.Get<TModel>();
public TModel? GetModel<TModel>() where TModel : class, IModel
{
return _container.Get<TModel>();
}
/// <summary>
/// 获取指定类型的系统
/// 获取指定类型的系统
/// </summary>
/// <typeparam name="TSystem">系统类型</typeparam>
/// <returns>系统实例或null</returns>
public TSystem? GetSystem<TSystem>() where TSystem : class, ISystem => _container.Get<TSystem>();
public TSystem? GetSystem<TSystem>() where TSystem : class, ISystem
{
return _container.Get<TSystem>();
}
/// <summary>
/// 获取指定类型的工具
/// 获取指定类型的工具
/// </summary>
/// <typeparam name="TUtility">工具类型</typeparam>
/// <returns>工具实例或null</returns>
public TUtility? GetUtility<TUtility>() where TUtility : class, IUtility => _container.Get<TUtility>();
public TUtility? GetUtility<TUtility>() where TUtility : class, IUtility
{
return _container.Get<TUtility>();
}
/// <summary>
/// 发送事件
/// 发送事件
/// </summary>
/// <typeparam name="TEvent">事件类型</typeparam>
public void SendEvent<TEvent>() where TEvent : new()
@ -293,7 +305,7 @@ public class TestArchitectureContext : IArchitectureContext
}
/// <summary>
/// 发送事件
/// 发送事件
/// </summary>
/// <typeparam name="TEvent">事件类型</typeparam>
/// <param name="e">事件实例</param>
@ -302,15 +314,18 @@ public class TestArchitectureContext : IArchitectureContext
}
/// <summary>
/// 注册事件处理器
/// 注册事件处理器
/// </summary>
/// <typeparam name="TEvent">事件类型</typeparam>
/// <param name="handler">事件处理委托</param>
/// <returns>取消注册接口</returns>
public IUnRegister RegisterEvent<TEvent>(Action<TEvent> handler) => new DefaultUnRegister(() => { });
public IUnRegister RegisterEvent<TEvent>(Action<TEvent> handler)
{
return new DefaultUnRegister(() => { });
}
/// <summary>
/// 取消注册事件处理器
/// 取消注册事件处理器
/// </summary>
/// <typeparam name="TEvent">事件类型</typeparam>
/// <param name="onEvent">事件处理委托</param>
@ -319,7 +334,7 @@ public class TestArchitectureContext : IArchitectureContext
}
/// <summary>
/// 发送命令
/// 发送命令
/// </summary>
/// <param name="command">命令对象</param>
public void SendCommand(ICommand command)
@ -327,12 +342,15 @@ public class TestArchitectureContext : IArchitectureContext
}
/// <summary>
/// 发送带返回值的命令
/// 发送带返回值的命令
/// </summary>
/// <typeparam name="TResult">返回值类型</typeparam>
/// <param name="command">命令对象</param>
/// <returns>命令执行结果</returns>
public TResult SendCommand<TResult>(ICommand<TResult> command) => default!;
public TResult SendCommand<TResult>(ICommand<TResult> command)
{
return default!;
}
public Task SendCommandAsync(IAsyncCommand command)
{
@ -345,24 +363,33 @@ public class TestArchitectureContext : IArchitectureContext
}
/// <summary>
/// 发送查询请求
/// 发送查询请求
/// </summary>
/// <typeparam name="TResult">查询结果类型</typeparam>
/// <param name="query">查询对象</param>
/// <returns>查询结果</returns>
public TResult SendQuery<TResult>(IQuery<TResult> query) => default!;
public TResult SendQuery<TResult>(IQuery<TResult> query)
{
return default!;
}
/// <summary>
/// 异步发送查询请求
/// 异步发送查询请求
/// </summary>
/// <typeparam name="TResult">查询结果类型</typeparam>
/// <param name="query">异步查询对象</param>
/// <returns>查询结果</returns>
public Task<TResult> SendQueryAsync<TResult>(IAsyncQuery<TResult> query) => (Task<TResult>)Task.CompletedTask;
public Task<TResult> SendQueryAsync<TResult>(IAsyncQuery<TResult> query)
{
return (Task<TResult>)Task.CompletedTask;
}
/// <summary>
/// 获取环境对象
/// 获取环境对象
/// </summary>
/// <returns>环境对象</returns>
public IEnvironment GetEnvironment() => Environment;
public IEnvironment GetEnvironment()
{
return Environment;
}
}

98
GFramework.Core.Tests/command/AbstractAsyncCommandTests.cs
View File

@ -11,20 +11,20 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.command;
/// <summary>
/// AbstractAsyncCommand类的单元测试
/// 测试内容包括：
/// - 异步命令无返回值版本的基础实现
/// - 异步命令有返回值版本的基础实现
/// - ExecuteAsync方法调用
/// - ExecuteAsync方法的异常处理
/// - 上下文感知功能（SetContext, GetContext）
/// - 日志功能（Logger属性）
/// - 子类继承行为验证（两个版本）
/// - 命令执行前日志记录
/// - 命令执行后日志记录
/// - 错误情况下的日志记录
/// - 无返回值版本的行为
/// - 有返回值版本的行为
/// AbstractAsyncCommand类的单元测试
/// 测试内容包括：
/// - 异步命令无返回值版本的基础实现
/// - 异步命令有返回值版本的基础实现
/// - ExecuteAsync方法调用
/// - ExecuteAsync方法的异常处理
/// - 上下文感知功能（SetContext, GetContext）
/// - 日志功能（Logger属性）
/// - 子类继承行为验证（两个版本）
/// - 命令执行前日志记录
/// - 命令执行后日志记录
/// - 错误情况下的日志记录
/// - 无返回值版本的行为
/// - 有返回值版本的行为
/// </summary>
[TestFixture]
public class AbstractAsyncCommandTests
@ -45,7 +45,7 @@ public class AbstractAsyncCommandTests
private IocContainer _container = null!;
/// <summary>
/// 测试异步命令无返回值版本的基础实现
/// 测试异步命令无返回值版本的基础实现
/// </summary>
[Test]
public async Task AbstractAsyncCommand_Should_Implement_IAsyncCommand_Interface()
@ -57,7 +57,7 @@ public class AbstractAsyncCommandTests
}
/// <summary>
/// 测试异步命令有返回值版本的基础实现
/// 测试异步命令有返回值版本的基础实现
/// </summary>
[Test]
public async Task AbstractAsyncCommand_WithResult_Should_Implement_IAsyncCommand_Interface()
@ -69,7 +69,7 @@ public class AbstractAsyncCommandTests
}
/// <summary>
/// 测试ExecuteAsync方法调用
/// 测试ExecuteAsync方法调用
/// </summary>
[Test]
public async Task ExecuteAsync_Should_Invoke_OnExecuteAsync_Method()
@ -85,7 +85,7 @@ public class AbstractAsyncCommandTests
}
/// <summary>
/// 测试ExecuteAsync方法（带返回值）调用
/// 测试ExecuteAsync方法（带返回值）调用
/// </summary>
[Test]
public async Task ExecuteAsync_WithResult_Should_Invoke_OnExecuteAsync_Method_And_Return_Result()
@ -101,7 +101,7 @@ public class AbstractAsyncCommandTests
}
/// <summary>
/// 测试ExecuteAsync方法的异常处理
/// 测试ExecuteAsync方法的异常处理
/// </summary>
[Test]
public void ExecuteAsync_Should_Propagate_Exception_From_OnExecuteAsync()
@ -114,7 +114,7 @@ public class AbstractAsyncCommandTests
}
/// <summary>
/// 测试上下文感知功能 - SetContext方法
/// 测试上下文感知功能 - SetContext方法
/// </summary>
[Test]
public void SetContext_Should_Set_Context_Property()
@ -130,7 +130,7 @@ public class AbstractAsyncCommandTests
}
/// <summary>
/// 测试上下文感知功能 - GetContext方法
/// 测试上下文感知功能 - GetContext方法
/// </summary>
[Test]
public void GetContext_Should_Return_Context_Property()
@ -147,7 +147,7 @@ public class AbstractAsyncCommandTests
}
/// <summary>
/// 测试子类继承行为验证 - 无返回值版本
/// 测试子类继承行为验证 - 无返回值版本
/// </summary>
[Test]
public async Task Child_Class_Should_Inherit_And_Override_OnExecuteAsync_Method()
@ -163,7 +163,7 @@ public class AbstractAsyncCommandTests
}
/// <summary>
/// 测试子类继承行为验证 - 有返回值版本
/// 测试子类继承行为验证 - 有返回值版本
/// </summary>
[Test]
public async Task Child_Class_WithResult_Should_Inherit_And_Override_OnExecuteAsync_Method()
@ -179,7 +179,7 @@ public class AbstractAsyncCommandTests
}
/// <summary>
/// 测试异步命令执行生命周期完整性
/// 测试异步命令执行生命周期完整性
/// </summary>
[Test]
public async Task AsyncCommand_Should_Complete_Execution_Lifecycle()
@ -197,7 +197,7 @@ public class AbstractAsyncCommandTests
}
/// <summary>
/// 测试异步命令多次执行
/// 测试异步命令多次执行
/// </summary>
[Test]
public async Task AsyncCommand_Should_Be_Executable_Multiple_Times()
@ -214,7 +214,7 @@ public class AbstractAsyncCommandTests
}
/// <summary>
/// 测试异步命令（带返回值）的返回值类型
/// 测试异步命令（带返回值）的返回值类型
/// </summary>
[Test]
public async Task AsyncCommand_WithResult_Should_Return_Correct_Type()
@ -231,23 +231,23 @@ public class AbstractAsyncCommandTests
}
/// <summary>
/// 测试用命令输入类V2
/// 测试用命令输入类V2
/// </summary>
public sealed class TestCommandInputV2 : ICommandInput
{
/// <summary>
/// 获取或设置值
/// 获取或设置值
/// </summary>
public int Value { get; init; }
}
/// <summary>
/// 测试用异步命令类V3（无返回值）
/// 测试用异步命令类V3（无返回值）
/// </summary>
public sealed class TestAsyncCommandV3 : AbstractAsyncCommand<TestCommandInputV2>
{
/// <summary>
/// 构造函数
/// 构造函数
/// </summary>
/// <param name="input">命令输入</param>
public TestAsyncCommandV3(TestCommandInputV2 input) : base(input)
@ -255,17 +255,17 @@ public sealed class TestAsyncCommandV3 : AbstractAsyncCommand<TestCommandInputV2
}
/// <summary>
/// 获取命令是否已执行
/// 获取命令是否已执行
/// </summary>
public bool Executed { get; private set; }
/// <summary>
/// 获取执行的值
/// 获取执行的值
/// </summary>
public int ExecutedValue { get; private set; }
/// <summary>
/// 执行异步命令的重写方法
/// 执行异步命令的重写方法
/// </summary>
/// <param name="input">命令输入</param>
/// <returns>表示异步操作的任务</returns>
@ -278,12 +278,12 @@ public sealed class TestAsyncCommandV3 : AbstractAsyncCommand<TestCommandInputV2
}
/// <summary>
/// 测试用异步命令类V3（有返回值）
/// 测试用异步命令类V3（有返回值）
/// </summary>
public sealed class TestAsyncCommandWithResultV3 : AbstractAsyncCommand<TestCommandInputV2, int>
{
/// <summary>
/// 构造函数
/// 构造函数
/// </summary>
/// <param name="input">命令输入</param>
public TestAsyncCommandWithResultV3(TestCommandInputV2 input) : base(input)
@ -291,12 +291,12 @@ public sealed class TestAsyncCommandWithResultV3 : AbstractAsyncCommand<TestComm
}
/// <summary>
/// 获取命令是否已执行
/// 获取命令是否已执行
/// </summary>
public bool Executed { get; private set; }
/// <summary>
/// 执行异步命令并返回结果的重写方法
/// 执行异步命令并返回结果的重写方法
/// </summary>
/// <param name="input">命令输入</param>
/// <returns>执行结果的异步任务</returns>
@ -308,12 +308,12 @@ public sealed class TestAsyncCommandWithResultV3 : AbstractAsyncCommand<TestComm
}
/// <summary>
/// 测试用异步命令类（抛出异常）
/// 测试用异步命令类（抛出异常）
/// </summary>
public sealed class TestAsyncCommandWithExceptionV3 : AbstractAsyncCommand<TestCommandInputV2>
{
/// <summary>
/// 构造函数
/// 构造函数
/// </summary>
/// <param name="input">命令输入</param>
public TestAsyncCommandWithExceptionV3(TestCommandInputV2 input) : base(input)
@ -321,7 +321,7 @@ public sealed class TestAsyncCommandWithExceptionV3 : AbstractAsyncCommand<TestC
}
/// <summary>
/// 执行异步命令并抛出异常的重写方法
/// 执行异步命令并抛出异常的重写方法
/// </summary>
/// <param name="input">命令输入</param>
/// <returns>表示异步操作的任务</returns>
@ -333,12 +333,12 @@ public sealed class TestAsyncCommandWithExceptionV3 : AbstractAsyncCommand<TestC
}
/// <summary>
/// 测试用异步命令子类（无返回值）
/// 测试用异步命令子类（无返回值）
/// </summary>
public sealed class TestAsyncCommandChildV3 : AbstractAsyncCommand<TestCommandInputV2>
{
/// <summary>
/// 构造函数
/// 构造函数
/// </summary>
/// <param name="input">命令输入</param>
public TestAsyncCommandChildV3(TestCommandInputV2 input) : base(input)
@ -346,17 +346,17 @@ public sealed class TestAsyncCommandChildV3 : AbstractAsyncCommand<TestCommandIn
}
/// <summary>
/// 获取命令是否已执行
/// 获取命令是否已执行
/// </summary>
public bool Executed { get; private set; }
/// <summary>
/// 获取执行的值
/// 获取执行的值
/// </summary>
public int ExecutedValue { get; private set; }
/// <summary>
/// 执行异步命令的重写方法（子类实现）
/// 执行异步命令的重写方法（子类实现）
/// </summary>
/// <param name="input">命令输入</param>
/// <returns>表示异步操作的任务</returns>
@ -369,12 +369,12 @@ public sealed class TestAsyncCommandChildV3 : AbstractAsyncCommand<TestCommandIn
}
/// <summary>
/// 测试用异步命令子类（有返回值）
/// 测试用异步命令子类（有返回值）
/// </summary>
public sealed class TestAsyncCommandWithResultChildV3 : AbstractAsyncCommand<TestCommandInputV2, int>
{
/// <summary>
/// 构造函数
/// 构造函数
/// </summary>
/// <param name="input">命令输入</param>
public TestAsyncCommandWithResultChildV3(TestCommandInputV2 input) : base(input)
@ -382,12 +382,12 @@ public sealed class TestAsyncCommandWithResultChildV3 : AbstractAsyncCommand<Tes
}
/// <summary>
/// 获取命令是否已执行
/// 获取命令是否已执行
/// </summary>
public bool Executed { get; private set; }
/// <summary>
/// 执行异步命令并返回结果的重写方法（子类实现）
/// 执行异步命令并返回结果的重写方法（子类实现）
/// </summary>
/// <param name="input">命令输入</param>
/// <returns>执行结果的异步任务</returns>

76
GFramework.Core.Tests/command/CommandBusTests.cs
View File

@ -5,16 +5,16 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.command;
/// <summary>
/// CommandBus类的单元测试
/// 测试内容包括：
/// - Send方法执行命令
/// - Send方法处理null命令
/// - Send方法（带返回值）返回值
/// - Send方法（带返回值）处理null命令
/// - SendAsync方法执行异步命令
/// - SendAsync方法处理null异步命令
/// - SendAsync方法（带返回值）返回值
/// - SendAsync方法（带返回值）处理null异步命令
/// CommandBus类的单元测试
/// 测试内容包括：
/// - Send方法执行命令
/// - Send方法处理null命令
/// - Send方法（带返回值）返回值
/// - Send方法（带返回值）处理null命令
/// - SendAsync方法执行异步命令
/// - SendAsync方法处理null异步命令
/// - SendAsync方法（带返回值）返回值
/// - SendAsync方法（带返回值）处理null异步命令
/// </summary>
[TestFixture]
public class CommandBusTests
@ -28,7 +28,7 @@ public class CommandBusTests
private CommandBus _commandBus = null!;
/// <summary>
/// 测试Send方法执行命令
/// 测试Send方法执行命令
/// </summary>
[Test]
public void Send_Should_Execute_Command()
@ -42,7 +42,7 @@ public class CommandBusTests
}
/// <summary>
/// 测试Send方法处理null命令时抛出ArgumentNullException异常
/// 测试Send方法处理null命令时抛出ArgumentNullException异常
/// </summary>
[Test]
public void Send_WithNullCommand_Should_ThrowArgumentNullException()
@ -51,7 +51,7 @@ public class CommandBusTests
}
/// <summary>
/// 测试Send方法（带返回值）正确返回值
/// 测试Send方法（带返回值）正确返回值
/// </summary>
[Test]
public void Send_WithResult_Should_Return_Value()
@ -66,7 +66,7 @@ public class CommandBusTests
}
/// <summary>
/// 测试Send方法（带返回值）处理null命令时抛出ArgumentNullException异常
/// 测试Send方法（带返回值）处理null命令时抛出ArgumentNullException异常
/// </summary>
[Test]
public void Send_WithResult_AndNullCommand_Should_ThrowArgumentNullException()
@ -75,7 +75,7 @@ public class CommandBusTests
}
/// <summary>
/// 测试SendAsync方法执行异步命令
/// 测试SendAsync方法执行异步命令
/// </summary>
[Test]
public async Task SendAsync_Should_Execute_AsyncCommand()
@ -90,7 +90,7 @@ public class CommandBusTests
}
/// <summary>
/// 测试SendAsync方法处理null异步命令时抛出ArgumentNullException异常
/// 测试SendAsync方法处理null异步命令时抛出ArgumentNullException异常
/// </summary>
[Test]
public void SendAsync_WithNullCommand_Should_ThrowArgumentNullException()
@ -99,7 +99,7 @@ public class CommandBusTests
}
/// <summary>
/// 测试SendAsync方法（带返回值）正确返回值
/// 测试SendAsync方法（带返回值）正确返回值
/// </summary>
[Test]
public async Task SendAsync_WithResult_Should_Return_Value()
@ -114,7 +114,7 @@ public class CommandBusTests
}
/// <summary>
/// 测试SendAsync方法（带返回值）处理null异步命令时抛出ArgumentNullException异常
/// 测试SendAsync方法（带返回值）处理null异步命令时抛出ArgumentNullException异常
/// </summary>
[Test]
public void SendAsync_WithResult_AndNullCommand_Should_ThrowArgumentNullException()
@ -124,23 +124,23 @@ public class CommandBusTests
}
/// <summary>
/// 测试用命令输入类，实现ICommandInput接口
/// 测试用命令输入类，实现ICommandInput接口
/// </summary>
public sealed class TestCommandInput : ICommandInput
{
/// <summary>
/// 获取或设置值
/// 获取或设置值
/// </summary>
public int Value { get; init; }
}
/// <summary>
/// 测试用命令类，继承AbstractCommand
/// 测试用命令类，继承AbstractCommand
/// </summary>
public sealed class TestCommand : AbstractCommand<TestCommandInput>
{
/// <summary>
/// 构造函数
/// 构造函数
/// </summary>
/// <param name="input">命令输入</param>
public TestCommand(TestCommandInput input) : base(input)
@ -148,17 +148,17 @@ public sealed class TestCommand : AbstractCommand<TestCommandInput>
}
/// <summary>
/// 获取命令是否已执行
/// 获取命令是否已执行
/// </summary>
public bool Executed { get; private set; }
/// <summary>
/// 获取执行的值
/// 获取执行的值
/// </summary>
public int ExecutedValue { get; private set; }
/// <summary>
/// 执行命令的重写方法
/// 执行命令的重写方法
/// </summary>
/// <param name="input">命令输入</param>
protected override void OnExecute(TestCommandInput input)
@ -169,12 +169,12 @@ public sealed class TestCommand : AbstractCommand<TestCommandInput>
}
/// <summary>
/// 测试用带返回值的命令类，继承AbstractCommand
/// 测试用带返回值的命令类，继承AbstractCommand
/// </summary>
public sealed class TestCommandWithResult : AbstractCommand<TestCommandInput, int>
{
/// <summary>
/// 构造函数
/// 构造函数
/// </summary>
/// <param name="input">命令输入</param>
public TestCommandWithResult(TestCommandInput input) : base(input)
@ -182,12 +182,12 @@ public sealed class TestCommandWithResult : AbstractCommand<TestCommandInput, in
}
/// <summary>
/// 获取命令是否已执行
/// 获取命令是否已执行
/// </summary>
public bool Executed { get; private set; }
/// <summary>
/// 执行命令并返回结果的重写方法
/// 执行命令并返回结果的重写方法
/// </summary>
/// <param name="input">命令输入</param>
/// <returns>执行结果</returns>
@ -199,12 +199,12 @@ public sealed class TestCommandWithResult : AbstractCommand<TestCommandInput, in
}
/// <summary>
/// 测试用异步命令类，继承AbstractAsyncCommand
/// 测试用异步命令类，继承AbstractAsyncCommand
/// </summary>
public sealed class TestAsyncCommand : AbstractAsyncCommand<TestCommandInput>
{
/// <summary>
/// 构造函数
/// 构造函数
/// </summary>
/// <param name="input">命令输入</param>
public TestAsyncCommand(TestCommandInput input) : base(input)
@ -212,17 +212,17 @@ public sealed class TestAsyncCommand : AbstractAsyncCommand<TestCommandInput>
}
/// <summary>
/// 获取命令是否已执行
/// 获取命令是否已执行
/// </summary>
public bool Executed { get; private set; }
/// <summary>
/// 获取执行的值
/// 获取执行的值
/// </summary>
public int ExecutedValue { get; private set; }
/// <summary>
/// 执行异步命令的重写方法
/// 执行异步命令的重写方法
/// </summary>
/// <param name="input">命令输入</param>
/// <returns>表示异步操作的任务</returns>
@ -235,12 +235,12 @@ public sealed class TestAsyncCommand : AbstractAsyncCommand<TestCommandInput>
}
/// <summary>
/// 测试用带返回值的异步命令类，继承AbstractAsyncCommand
/// 测试用带返回值的异步命令类，继承AbstractAsyncCommand
/// </summary>
public sealed class TestAsyncCommandWithResult : AbstractAsyncCommand<TestCommandInput, int>
{
/// <summary>
/// 构造函数
/// 构造函数
/// </summary>
/// <param name="input">命令输入</param>
public TestAsyncCommandWithResult(TestCommandInput input) : base(input)
@ -248,12 +248,12 @@ public sealed class TestAsyncCommandWithResult : AbstractAsyncCommand<TestComman
}
/// <summary>
/// 获取命令是否已执行
/// 获取命令是否已执行
/// </summary>
public bool Executed { get; private set; }
/// <summary>
/// 执行异步命令并返回结果的重写方法
/// 执行异步命令并返回结果的重写方法
/// </summary>
/// <param name="input">命令输入</param>
/// <returns>执行结果的异步任务</returns>

24
GFramework.Core.Tests/constants/GFrameworkConstantsTests.cs
View File

@ -4,19 +4,19 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.constants;
/// <summary>
/// GFrameworkConstants类的单元测试
/// 测试内容包括：
/// - 版本号常量格式正确性
/// - 其他框架常量
/// - 常量值正确性
/// - 常量类型验证
/// - 常量可访问性
/// GFrameworkConstants类的单元测试
/// 测试内容包括：
/// - 版本号常量格式正确性
/// - 其他框架常量
/// - 常量值正确性
/// - 常量类型验证
/// - 常量可访问性
/// </summary>
[TestFixture]
public class GFrameworkConstantsTests
{
/// <summary>
/// 测试FrameworkName常量的值正确性
/// 测试FrameworkName常量的值正确性
/// </summary>
[Test]
public void FrameworkName_Should_Have_Correct_Value()
@ -25,7 +25,7 @@ public class GFrameworkConstantsTests
}
/// <summary>
/// 测试FrameworkName常量的类型
/// 测试FrameworkName常量的类型
/// </summary>
[Test]
public void FrameworkName_Should_Be_String_Type()
@ -34,7 +34,7 @@ public class GFrameworkConstantsTests
}
/// <summary>
/// 测试FrameworkName常量不为空
/// 测试FrameworkName常量不为空
/// </summary>
[Test]
public void FrameworkName_Should_Not_Be_Null_Or_Empty()
@ -44,7 +44,7 @@ public class GFrameworkConstantsTests
}
/// <summary>
/// 测试FrameworkName常量是公共可访问的
/// 测试FrameworkName常量是公共可访问的
/// </summary>
[Test]
public void FrameworkName_Should_Be_Publicly_Accessible()
@ -58,7 +58,7 @@ public class GFrameworkConstantsTests
}
/// <summary>
/// 测试FrameworkName常量是只读的（const）
/// 测试FrameworkName常量是只读的（const）
/// </summary>
[Test]
public void FrameworkName_Should_Be_Constant()

64
GFramework.Core.Tests/coroutine/AsyncOperationTests.cs
View File

@ -5,20 +5,20 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.coroutine;
/// <summary>
/// AsyncOperation的单元测试类
/// 测试内容包括：
/// - 初始化状态
/// - 完成和状态检查
/// - 异常处理
/// - 延续操作
/// - GetAwaiter
/// - IsCompleted属性
/// AsyncOperation的单元测试类
/// 测试内容包括：
/// - 初始化状态
/// - 完成和状态检查
/// - 异常处理
/// - 延续操作
/// - GetAwaiter
/// - IsCompleted属性
/// </summary>
[TestFixture]
public class AsyncOperationTests
{
/// <summary>
/// 验证AsyncOperation初始状态为未完成
/// 验证AsyncOperation初始状态为未完成
/// </summary>
[Test]
public void AsyncOperation_Should_Not_Be_Done_Initially()
@ -29,7 +29,7 @@ public class AsyncOperationTests
}
/// <summary>
/// 验证AsyncOperation初始状态IsCompleted为false
/// 验证AsyncOperation初始状态IsCompleted为false
/// </summary>
[Test]
public void AsyncOperation_Should_Not_Be_Completed_Initially()
@ -40,7 +40,7 @@ public class AsyncOperationTests
}
/// <summary>
/// 验证SetCompleted后IsDone应该为true
/// 验证SetCompleted后IsDone应该为true
/// </summary>
[Test]
public void SetCompleted_Should_Set_IsDone_To_True()
@ -53,7 +53,7 @@ public class AsyncOperationTests
}
/// <summary>
/// 验证SetCompleted后IsCompleted应该为true
/// 验证SetCompleted后IsCompleted应该为true
/// </summary>
[Test]
public void SetCompleted_Should_Set_IsCompleted_To_True()
@ -66,7 +66,7 @@ public class AsyncOperationTests
}
/// <summary>
/// 验证SetCompleted只能被调用一次
/// 验证SetCompleted只能被调用一次
/// </summary>
[Test]
public void SetCompleted_Should_Be_Idempotent()
@ -81,7 +81,7 @@ public class AsyncOperationTests
}
/// <summary>
/// 验证SetException后IsDone应该为true
/// 验证SetException后IsDone应该为true
/// </summary>
[Test]
public void SetException_Should_Set_IsDone_To_True()
@ -94,7 +94,7 @@ public class AsyncOperationTests
}
/// <summary>
/// 验证SetException后Task应该包含异常
/// 验证SetException后Task应该包含异常
/// </summary>
[Test]
public void SetException_Should_Set_Exception_On_Task()
@ -108,7 +108,7 @@ public class AsyncOperationTests
}
/// <summary>
/// 验证OnCompleted应该在已完成时立即执行延续
/// 验证OnCompleted应该在已完成时立即执行延续
/// </summary>
[Test]
public void OnCompleted_Should_Execute_Immediately_When_Already_Completed()
@ -123,7 +123,7 @@ public class AsyncOperationTests
}
/// <summary>
/// 验证OnCompleted应该在未完成时不立即执行延续
/// 验证OnCompleted应该在未完成时不立即执行延续
/// </summary>
[Test]
public void OnCompleted_Should_Not_Execute_Immediately_When_Not_Completed()
@ -137,7 +137,7 @@ public class AsyncOperationTests
}
/// <summary>
/// 验证延续应该在SetCompleted后被调用
/// 验证延续应该在SetCompleted后被调用
/// </summary>
[Test]
public void Continuation_Should_Be_Called_After_SetCompleted()
@ -152,7 +152,7 @@ public class AsyncOperationTests
}
/// <summary>
/// 验证多个延续应该都能被调用
/// 验证多个延续应该都能被调用
/// </summary>
[Test]
public void Multiple_Continuations_Should_All_Be_Called()
@ -169,7 +169,7 @@ public class AsyncOperationTests
}
/// <summary>
/// 验证延续应该在SetException后被调用
/// 验证延续应该在SetException后被调用
/// </summary>
[Test]
public void Continuation_Should_Be_Called_After_SetException()
@ -184,7 +184,7 @@ public class AsyncOperationTests
}
/// <summary>
/// 验证SetCompleted后设置的延续也应该被调用
/// 验证SetCompleted后设置的延续也应该被调用
/// </summary>
[Test]
public void Continuation_Registered_After_Completed_Should_Be_Called()
@ -202,7 +202,7 @@ public class AsyncOperationTests
}
/// <summary>
/// 验证GetAwaiter应该返回自身
/// 验证GetAwaiter应该返回自身
/// </summary>
[Test]
public void GetAwaiter_Should_Return_Self()
@ -215,7 +215,7 @@ public class AsyncOperationTests
}
/// <summary>
/// 验证Update方法不应该改变状态
/// 验证Update方法不应该改变状态
/// </summary>
[Test]
public void Update_Should_Not_Change_State()
@ -228,7 +228,7 @@ public class AsyncOperationTests
}
/// <summary>
/// 验证AsyncOperation实现IYieldInstruction接口
/// 验证AsyncOperation实现IYieldInstruction接口
/// </summary>
[Test]
public void AsyncOperation_Should_Implement_IYieldInstruction()
@ -239,7 +239,7 @@ public class AsyncOperationTests
}
/// <summary>
/// 验证Task属性应该返回有效的Task
/// 验证Task属性应该返回有效的Task
/// </summary>
[Test]
public void Task_Property_Should_Return_Valid_Task()
@ -250,7 +250,7 @@ public class AsyncOperationTests
}
/// <summary>
/// 验证SetCompleted后Task应该完成
/// 验证SetCompleted后Task应该完成
/// </summary>
[Test]
public async Task Task_Should_Complete_After_SetCompleted()
@ -265,7 +265,7 @@ public class AsyncOperationTests
}
/// <summary>
/// 验证SetException后Task应该失败
/// 验证SetException后Task应该失败
/// </summary>
[Test]
public void Task_Should_Fault_After_SetException()
@ -278,7 +278,7 @@ public class AsyncOperationTests
}
/// <summary>
/// 验证SetCompleted只能设置一次
/// 验证SetCompleted只能设置一次
/// </summary>
[Test]
public void SetCompleted_Should_Only_Set_Once()
@ -298,7 +298,7 @@ public class AsyncOperationTests
}
/// <summary>
/// 验证SetException只能在未完成时设置
/// 验证SetException只能在未完成时设置
/// </summary>
[Test]
public void SetException_Should_Not_Work_After_SetCompleted()
@ -313,7 +313,7 @@ public class AsyncOperationTests
}
/// <summary>
/// 验证SetCompleted不能在SetException后设置
/// 验证SetCompleted不能在SetException后设置
/// </summary>
[Test]
public void SetCompleted_Should_Not_Work_After_SetException()
@ -328,7 +328,7 @@ public class AsyncOperationTests
}
/// <summary>
/// 验证延续抛出的异常应该被捕获
/// 验证延续抛出的异常应该被捕获
/// </summary>
[Test]
public void Continuation_Exception_Should_Be_Caught()
@ -339,4 +339,4 @@ public class AsyncOperationTests
Assert.DoesNotThrow(() => op.SetCompleted());
}
}
}

137
GFramework.Core.Tests/coroutine/CoroutineExtensionsTests.cs
View File

@ -7,19 +7,19 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.coroutine;
/// <summary>
/// 协程扩展方法的单元测试类
/// 测试内容包括：
/// - RepeatEvery方法
/// - ExecuteAfter方法
/// - Sequence方法
/// - ParallelCoroutines方法
/// - WaitForSecondsWithProgress方法
/// 协程扩展方法的单元测试类
/// 测试内容包括：
/// - RepeatEvery方法
/// - ExecuteAfter方法
/// - Sequence方法
/// - ParallelCoroutines方法
/// - WaitForSecondsWithProgress方法
/// </summary>
[TestFixture]
public class CoroutineExtensionsTests
{
/// <summary>
/// 验证RepeatEvery应该返回有效的协程
/// 验证RepeatEvery应该返回有效的协程
/// </summary>
[Test]
public void RepeatEvery_Should_Return_Valid_Coroutine()
@ -31,7 +31,7 @@ public class CoroutineExtensionsTests
}
/// <summary>
/// 验证RepeatEvery应该执行指定次数
/// 验证RepeatEvery应该执行指定次数
/// </summary>
[Test]
public void RepeatEvery_Should_Execute_Specified_Times()
@ -39,16 +39,13 @@ public class CoroutineExtensionsTests
var callCount = 0;
var coroutine = CoroutineExtensions.RepeatEvery(0.1, () => callCount++, 3);
while (coroutine.MoveNext())
{
coroutine.Current.Update(0.1);
}
while (coroutine.MoveNext()) coroutine.Current.Update(0.1);
Assert.That(callCount, Is.EqualTo(3));
}
/// <summary>
/// 验证RepeatEvery应该无限执行当count为null
/// 验证RepeatEvery应该无限执行当count为null
/// </summary>
[Test]
public void RepeatEvery_Should_Execute_Forever_When_Count_Is_Null()
@ -67,7 +64,7 @@ public class CoroutineExtensionsTests
}
/// <summary>
/// 验证RepeatEvery应该处理负数count
/// 验证RepeatEvery应该处理负数count
/// </summary>
[Test]
public void RepeatEvery_Should_Handle_Negative_Count()
@ -80,7 +77,7 @@ public class CoroutineExtensionsTests
}
/// <summary>
/// 验证RepeatEvery应该处理零count
/// 验证RepeatEvery应该处理零count
/// </summary>
[Test]
public void RepeatEvery_Should_Handle_Zero_Count()
@ -93,24 +90,21 @@ public class CoroutineExtensionsTests
}
/// <summary>
/// 验证RepeatEvery应该处理null action
/// 验证RepeatEvery应该处理null action
/// </summary>
[Test]
public void RepeatEvery_Should_Handle_Null_Action()
{
var coroutine = CoroutineExtensions.RepeatEvery(0.1, null, 3);
Assert.DoesNotThrow(() =>
Assert.DoesNotThrow(() =>
{
while (coroutine.MoveNext())
{
coroutine.Current.Update(0.1);
}
while (coroutine.MoveNext()) coroutine.Current.Update(0.1);
});
}
/// <summary>
/// 验证ExecuteAfter应该返回有效的协程
/// 验证ExecuteAfter应该返回有效的协程
/// </summary>
[Test]
public void ExecuteAfter_Should_Return_Valid_Coroutine()
@ -122,7 +116,7 @@ public class CoroutineExtensionsTests
}
/// <summary>
/// 验证ExecuteAfter应该在延迟后执行action
/// 验证ExecuteAfter应该在延迟后执行action
/// </summary>
[Test]
public void ExecuteAfter_Should_Execute_Action_After_Delay()
@ -144,7 +138,7 @@ public class CoroutineExtensionsTests
}
/// <summary>
/// 验证ExecuteAfter应该处理零延迟
/// 验证ExecuteAfter应该处理零延迟
/// </summary>
[Test]
public void ExecuteAfter_Should_Handle_Zero_Delay()
@ -159,7 +153,7 @@ public class CoroutineExtensionsTests
}
/// <summary>
/// 验证ExecuteAfter应该处理负数延迟
/// 验证ExecuteAfter应该处理负数延迟
/// </summary>
[Test]
public void ExecuteAfter_Should_Handle_Negative_Delay()
@ -172,14 +166,14 @@ public class CoroutineExtensionsTests
}
/// <summary>
/// 验证ExecuteAfter应该处理null action
/// 验证ExecuteAfter应该处理null action
/// </summary>
[Test]
public void ExecuteAfter_Should_Handle_Null_Action()
{
var coroutine = CoroutineExtensions.ExecuteAfter(1.0, null);
Assert.DoesNotThrow(() =>
Assert.DoesNotThrow(() =>
{
coroutine.MoveNext();
coroutine.Current.Update(1.0);
@ -187,7 +181,7 @@ public class CoroutineExtensionsTests
}
/// <summary>
/// 验证Sequence应该返回有效的协程
/// 验证Sequence应该返回有效的协程
/// </summary>
[Test]
public void Sequence_Should_Return_Valid_Coroutine()
@ -200,7 +194,7 @@ public class CoroutineExtensionsTests
}
/// <summary>
/// 验证Sequence应该按顺序执行多个协程
/// 验证Sequence应该按顺序执行多个协程
/// </summary>
[Test]
public void Sequence_Should_Execute_Coroutines_In_Order()
@ -212,16 +206,13 @@ public class CoroutineExtensionsTests
var sequence = CoroutineExtensions.Sequence(coroutine1, coroutine2, coroutine3);
while (sequence.MoveNext())
{
sequence.Current.Update(0.1);
}
while (sequence.MoveNext()) sequence.Current.Update(0.1);
Assert.That(executionOrder, Is.EqualTo(new List<int> { 1, 2, 3 }));
}
/// <summary>
/// 验证Sequence应该处理空协程数组
/// 验证Sequence应该处理空协程数组
/// </summary>
[Test]
public void Sequence_Should_Handle_Empty_Coroutines()
@ -232,7 +223,7 @@ public class CoroutineExtensionsTests
}
/// <summary>
/// 验证Sequence应该处理单个协程
/// 验证Sequence应该处理单个协程
/// </summary>
[Test]
public void Sequence_Should_Handle_Single_Coroutine()
@ -244,7 +235,7 @@ public class CoroutineExtensionsTests
}
/// <summary>
/// 验证Sequence应该处理null协程
/// 验证Sequence应该处理null协程
/// </summary>
[Test]
public void Sequence_Should_Handle_Null_Coroutine()
@ -252,23 +243,20 @@ public class CoroutineExtensionsTests
var coroutine1 = CreateSimpleCoroutine();
var sequence = CoroutineExtensions.Sequence(coroutine1, null!);
Assert.Throws<NullReferenceException>(() =>
Assert.Throws<NullReferenceException>(() =>
{
while (sequence.MoveNext())
{
sequence.Current.Update(0.1);
}
while (sequence.MoveNext()) sequence.Current.Update(0.1);
});
}
/// <summary>
/// 验证ParallelCoroutines应该返回有效的协程
/// 验证ParallelCoroutines应该返回有效的协程
/// </summary>
[Test]
public void ParallelCoroutines_Should_Return_Valid_Coroutine()
{
var timeSource = new TestTimeSource();
var scheduler = new CoroutineScheduler(timeSource, instanceId: 1);
var scheduler = new CoroutineScheduler(timeSource, 1);
var coroutine1 = CreateSimpleCoroutine();
var coroutine2 = CreateSimpleCoroutine();
@ -278,13 +266,13 @@ public class CoroutineExtensionsTests
}
/// <summary>
/// 验证ParallelCoroutines应该并行执行多个协程
/// 验证ParallelCoroutines应该并行执行多个协程
/// </summary>
[Test]
public void ParallelCoroutines_Should_Execute_Coroutines_In_Parallel()
{
var timeSource = new TestTimeSource();
var scheduler = new CoroutineScheduler(timeSource, instanceId: 1);
var scheduler = new CoroutineScheduler(timeSource, 1);
var executionCounts = new Dictionary<int, int> { { 1, 0 }, { 2, 0 }, { 3, 0 } };
var coroutine1 = CreateDelayedCoroutine(() => executionCounts[1]++, 0.5);
@ -297,10 +285,7 @@ public class CoroutineExtensionsTests
Assert.That(scheduler.ActiveCoroutineCount, Is.GreaterThan(0));
while (scheduler.ActiveCoroutineCount > 0)
{
scheduler.Update();
}
while (scheduler.ActiveCoroutineCount > 0) scheduler.Update();
Assert.That(executionCounts[1], Is.EqualTo(1));
Assert.That(executionCounts[2], Is.EqualTo(1));
@ -308,13 +293,13 @@ public class CoroutineExtensionsTests
}
/// <summary>
/// 验证ParallelCoroutines应该处理空数组
/// 验证ParallelCoroutines应该处理空数组
/// </summary>
[Test]
public void ParallelCoroutines_Should_Handle_Empty_Array()
{
var timeSource = new TestTimeSource();
var scheduler = new CoroutineScheduler(timeSource, instanceId: 1);
var scheduler = new CoroutineScheduler(timeSource, 1);
var parallel = scheduler.ParallelCoroutines();
@ -322,13 +307,13 @@ public class CoroutineExtensionsTests
}
/// <summary>
/// 验证ParallelCoroutines应该处理null数组
/// 验证ParallelCoroutines应该处理null数组
/// </summary>
[Test]
public void ParallelCoroutines_Should_Handle_Null_Array()
{
var timeSource = new TestTimeSource();
var scheduler = new CoroutineScheduler(timeSource, instanceId: 1);
var scheduler = new CoroutineScheduler(timeSource, 1);
var parallel = scheduler.ParallelCoroutines(null);
@ -336,7 +321,7 @@ public class CoroutineExtensionsTests
}
/// <summary>
/// 验证WaitForSecondsWithProgress应该返回有效的协程
/// 验证WaitForSecondsWithProgress应该返回有效的协程
/// </summary>
[Test]
public void WaitForSecondsWithProgress_Should_Return_Valid_Coroutine()
@ -348,7 +333,7 @@ public class CoroutineExtensionsTests
}
/// <summary>
/// 验证WaitForSecondsWithProgress应该在指定时间后完成
/// 验证WaitForSecondsWithProgress应该在指定时间后完成
/// </summary>
[Test]
public void WaitForSecondsWithProgress_Should_Complete_After_Duration()
@ -364,7 +349,7 @@ public class CoroutineExtensionsTests
}
/// <summary>
/// 验证WaitForSecondsWithProgress应该调用进度回调
/// 验证WaitForSecondsWithProgress应该调用进度回调
/// </summary>
[Test]
public void WaitForSecondsWithProgress_Should_Call_Progress_Callback()
@ -374,10 +359,7 @@ public class CoroutineExtensionsTests
coroutine.MoveNext();
while (!coroutine.Current.IsDone)
{
coroutine.Current.Update(0.1);
}
while (!coroutine.Current.IsDone) coroutine.Current.Update(0.1);
Assert.That(progressValues.Count, Is.GreaterThan(0));
Assert.That(progressValues[0], Is.EqualTo(0.0f).Within(0.01f));
@ -385,7 +367,7 @@ public class CoroutineExtensionsTests
}
/// <summary>
/// 验证WaitForSecondsWithProgress应该处理零时间
/// 验证WaitForSecondsWithProgress应该处理零时间
/// </summary>
[Test]
public void WaitForSecondsWithProgress_Should_Handle_Zero_Duration()
@ -398,7 +380,7 @@ public class CoroutineExtensionsTests
}
/// <summary>
/// 验证WaitForSecondsWithProgress应该处理负数时间
/// 验证WaitForSecondsWithProgress应该处理负数时间
/// </summary>
[Test]
public void WaitForSecondsWithProgress_Should_Handle_Negative_Duration()
@ -411,7 +393,7 @@ public class CoroutineExtensionsTests
}
/// <summary>
/// 验证WaitForSecondsWithProgress应该处理null回调
/// 验证WaitForSecondsWithProgress应该处理null回调
/// </summary>
[Test]
public void WaitForSecondsWithProgress_Should_Handle_Null_Callback()
@ -427,7 +409,7 @@ public class CoroutineExtensionsTests
}
/// <summary>
/// 验证RepeatEvery应该使用Delay指令
/// 验证RepeatEvery应该使用Delay指令
/// </summary>
[Test]
public void RepeatEvery_Should_Use_Delay_Instruction()
@ -439,7 +421,7 @@ public class CoroutineExtensionsTests
}
/// <summary>
/// 验证ExecuteAfter应该使用Delay指令
/// 验证ExecuteAfter应该使用Delay指令
/// </summary>
[Test]
public void ExecuteAfter_Should_Use_Delay_Instruction()
@ -451,7 +433,7 @@ public class CoroutineExtensionsTests
}
/// <summary>
/// 验证Sequence应该清理已完成的协程
/// 验证Sequence应该清理已完成的协程
/// </summary>
[Test]
public void Sequence_Should_Dispose_Completed_Coroutines()
@ -461,16 +443,13 @@ public class CoroutineExtensionsTests
var sequence = CoroutineExtensions.Sequence(coroutine1, coroutine2);
while (sequence.MoveNext())
{
sequence.Current.Update(0.1);
}
while (sequence.MoveNext()) sequence.Current.Update(0.1);
Assert.That(sequence.MoveNext(), Is.False);
}
/// <summary>
/// 验证RepeatEvery的间隔时间
/// 验证RepeatEvery的间隔时间
/// </summary>
[Test]
public void RepeatEvery_Should_Respect_Interval()
@ -489,7 +468,7 @@ public class CoroutineExtensionsTests
}
/// <summary>
/// 验证ExecuteAfter的延迟时间
/// 验证ExecuteAfter的延迟时间
/// </summary>
[Test]
public void ExecuteAfter_Should_Respect_Delay()
@ -513,7 +492,7 @@ public class CoroutineExtensionsTests
}
/// <summary>
/// 创建简单的立即完成协程
/// 创建简单的立即完成协程
/// </summary>
private IEnumerator<IYieldInstruction> CreateSimpleCoroutine()
{
@ -521,7 +500,7 @@ public class CoroutineExtensionsTests
}
/// <summary>
/// 创建带回调的协程
/// 创建带回调的协程
/// </summary>
private IEnumerator<IYieldInstruction> CreateCoroutineWithCallback(int id, Action callback)
{
@ -530,7 +509,7 @@ public class CoroutineExtensionsTests
}
/// <summary>
/// 创建计数协程
/// 创建计数协程
/// </summary>
private IEnumerator<IYieldInstruction> CreateCountingCoroutine(int id, Action callback)
{
@ -539,7 +518,7 @@ public class CoroutineExtensionsTests
}
/// <summary>
/// 创建延迟协程
/// 创建延迟协程
/// </summary>
private IEnumerator<IYieldInstruction> CreateDelayedCoroutine(Action callback, double delay)
{
@ -548,7 +527,7 @@ public class CoroutineExtensionsTests
}
/// <summary>
/// 测试用时间源类
/// 测试用时间源类
/// </summary>
private class TestTimeSource : ITimeSource
{
@ -561,4 +540,4 @@ public class CoroutineExtensionsTests
CurrentTime += DeltaTime;
}
}
}
}

58
GFramework.Core.Tests/coroutine/CoroutineHandleTests.cs
View File

@ -4,19 +4,19 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.coroutine;
/// <summary>
/// 协程句柄的单元测试类
/// 测试内容包括：
/// - 协程句柄创建和有效性验证
/// - 相等性比较
/// - 哈希码生成
/// - 操作符重载
/// - 多实例独立性
/// 协程句柄的单元测试类
/// 测试内容包括：
/// - 协程句柄创建和有效性验证
/// - 相等性比较
/// - 哈希码生成
/// - 操作符重载
/// - 多实例独立性
/// </summary>
[TestFixture]
public class CoroutineHandleTests
{
/// <summary>
/// 验证协程句柄创建时应有有效的Key
/// 验证协程句柄创建时应有有效的Key
/// </summary>
[Test]
public void CoroutineHandle_Should_Have_Valid_Key_When_Created()
@ -28,7 +28,7 @@ public class CoroutineHandleTests
}
/// <summary>
/// 验证默认协程句柄应该无效
/// 验证默认协程句柄应该无效
/// </summary>
[Test]
public void Default_CoroutineHandle_Should_Be_Invalid()
@ -40,7 +40,7 @@ public class CoroutineHandleTests
}
/// <summary>
/// 验证相同实例ID创建的句柄应该具有不同的Key
/// 验证相同实例ID创建的句柄应该具有不同的Key
/// </summary>
[Test]
public void CoroutineHandles_With_Same_InstanceId_Should_Have_Different_Keys()
@ -52,7 +52,7 @@ public class CoroutineHandleTests
}
/// <summary>
/// 验证不同实例ID创建的句柄应该不同
/// 验证不同实例ID创建的句柄应该不同
/// </summary>
[Test]
public void CoroutineHandles_With_Different_InstanceIds_Should_Be_Different()
@ -64,7 +64,7 @@ public class CoroutineHandleTests
}
/// <summary>
/// 验证协程句柄的相等性比较
/// 验证协程句柄的相等性比较
/// </summary>
[Test]
public void Equals_Should_Return_True_For_Identical_Handles()
@ -76,7 +76,7 @@ public class CoroutineHandleTests
}
/// <summary>
/// 验证协程句柄的不相等性比较
/// 验证协程句柄的不相等性比较
/// </summary>
[Test]
public void Equals_Should_Return_False_For_Different_Handles()
@ -93,7 +93,7 @@ public class CoroutineHandleTests
/// <summary>
/// 验证Equals方法与null对象的比较
/// 验证Equals方法与null对象的比较
/// </summary>
[Test]
public void Equals_Should_Return_False_When_Comparing_To_Null()
@ -104,7 +104,7 @@ public class CoroutineHandleTests
}
/// <summary>
/// 验证Equals方法与其他类型对象的比较
/// 验证Equals方法与其他类型对象的比较
/// </summary>
[Test]
public void Equals_Should_Return_False_When_Comparing_To_Other_Type()
@ -115,7 +115,7 @@ public class CoroutineHandleTests
}
/// <summary>
/// 验证哈希码的一致性
/// 验证哈希码的一致性
/// </summary>
[Test]
public void GetHashCode_Should_Be_Consistent()
@ -128,7 +128,7 @@ public class CoroutineHandleTests
}
/// <summary>
/// 验证不同句柄应该有不同的哈希码
/// 验证不同句柄应该有不同的哈希码
/// </summary>
[Test]
public void GetHashCode_Should_Be_Different_For_Different_Handles()
@ -140,7 +140,7 @@ public class CoroutineHandleTests
}
/// <summary>
/// 验证相等操作符的正确性
/// 验证相等操作符的正确性
/// </summary>
[Test]
public void EqualityOperator_Should_Work_Correctly()
@ -154,7 +154,7 @@ public class CoroutineHandleTests
}
/// <summary>
/// 验证不等操作符的正确性
/// 验证不等操作符的正确性
/// </summary>
[Test]
public void InequalityOperator_Should_Work_Correctly()
@ -168,7 +168,7 @@ public class CoroutineHandleTests
}
/// <summary>
/// 验证协程句柄实现了IEquatable接口
/// 验证协程句柄实现了IEquatable接口
/// </summary>
[Test]
public void CoroutineHandle_Should_Implement_IEquatable_Interface()
@ -179,7 +179,7 @@ public class CoroutineHandleTests
}
/// <summary>
/// 验证协程句柄是只读结构体
/// 验证协程句柄是只读结构体
/// </summary>
[Test]
public void CoroutineHandle_Should_Be_Immutable_Struct()
@ -189,7 +189,7 @@ public class CoroutineHandleTests
}
/// <summary>
/// 验证实例ID超过预留空间时的处理
/// 验证实例ID超过预留空间时的处理
/// </summary>
[Test]
public void CoroutineHandle_Should_Handle_Large_InstanceId()
@ -201,25 +201,19 @@ public class CoroutineHandleTests
}
/// <summary>
/// 验证多个连续创建的句柄Key递增
/// 验证多个连续创建的句柄Key递增
/// </summary>
[Test]
public void Multiple_Creates_Should_Increment_Keys()
{
var handles = new List<CoroutineHandle>();
for (var i = 0; i < 5; i++)
{
handles.Add(new CoroutineHandle(1));
}
for (var i = 0; i < 5; i++) handles.Add(new CoroutineHandle(1));
for (var i = 0; i < handles.Count - 1; i++)
{
Assert.That(handles[i].Equals(handles[i + 1]), Is.False);
}
for (var i = 0; i < handles.Count - 1; i++) Assert.That(handles[i].Equals(handles[i + 1]), Is.False);
}
/// <summary>
/// 验证协程句柄的内部ID属性可以通过Key访问
/// 验证协程句柄的内部ID属性可以通过Key访问
/// </summary>
[Test]
public void CoroutineHandle_Key_Should_Return_Low_4_Bits_Of_Id()

75
GFramework.Core.Tests/coroutine/CoroutineHelperTests.cs
View File

@ -6,22 +6,22 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.coroutine;
/// <summary>
/// 协程辅助方法的单元测试类
/// 测试内容包括：
/// - WaitForSeconds方法
/// - WaitForOneFrame方法
/// - WaitForFrames方法
/// - WaitUntil方法
/// - WaitWhile方法
/// - DelayedCall方法
/// - RepeatCall方法
/// - RepeatCallForever方法
/// 协程辅助方法的单元测试类
/// 测试内容包括：
/// - WaitForSeconds方法
/// - WaitForOneFrame方法
/// - WaitForFrames方法
/// - WaitUntil方法
/// - WaitWhile方法
/// - DelayedCall方法
/// - RepeatCall方法
/// - RepeatCallForever方法
/// </summary>
[TestFixture]
public class CoroutineHelperTests
{
/// <summary>
/// 验证WaitForSeconds应该返回Delay实例
/// 验证WaitForSeconds应该返回Delay实例
/// </summary>
[Test]
public void WaitForSeconds_Should_Return_Delay_Instance()
@ -32,7 +32,7 @@ public class CoroutineHelperTests
}
/// <summary>
/// 验证WaitForSeconds可以处理正数秒数
/// 验证WaitForSeconds可以处理正数秒数
/// </summary>
[Test]
public void WaitForSeconds_Should_Handle_Positive_Seconds()
@ -44,7 +44,7 @@ public class CoroutineHelperTests
}
/// <summary>
/// 验证WaitForSeconds可以处理零秒数
/// 验证WaitForSeconds可以处理零秒数
/// </summary>
[Test]
public void WaitForSeconds_Should_Handle_Zero_Seconds()
@ -55,7 +55,7 @@ public class CoroutineHelperTests
}
/// <summary>
/// 验证WaitForOneFrame应该返回WaitOneFrame实例
/// 验证WaitForOneFrame应该返回WaitOneFrame实例
/// </summary>
[Test]
public void WaitForOneFrame_Should_Return_WaitOneFrame_Instance()
@ -66,7 +66,7 @@ public class CoroutineHelperTests
}
/// <summary>
/// 验证WaitForFrames应该返回WaitForFrames实例
/// 验证WaitForFrames应该返回WaitForFrames实例
/// </summary>
[Test]
public void WaitForFrames_Should_Return_WaitForFrames_Instance()
@ -77,7 +77,7 @@ public class CoroutineHelperTests
}
/// <summary>
/// 验证WaitForFrames可以处理正数帧数
/// 验证WaitForFrames可以处理正数帧数
/// </summary>
[Test]
public void WaitForFrames_Should_Handle_Positive_Frames()
@ -89,7 +89,7 @@ public class CoroutineHelperTests
}
/// <summary>
/// 验证WaitForFrames可以处理最小帧数1
/// 验证WaitForFrames可以处理最小帧数1
/// </summary>
[Test]
public void WaitForFrames_Should_Handle_Minimum_Frame_Count_Of_1()
@ -101,7 +101,7 @@ public class CoroutineHelperTests
}
/// <summary>
/// 验证WaitUntil应该返回WaitUntil实例
/// 验证WaitUntil应该返回WaitUntil实例
/// </summary>
[Test]
public void WaitUntil_Should_Return_WaitUntil_Instance()
@ -113,7 +113,7 @@ public class CoroutineHelperTests
}
/// <summary>
/// 验证WaitUntil应该使用提供的谓词函数
/// 验证WaitUntil应该使用提供的谓词函数
/// </summary>
[Test]
public void WaitUntil_Should_Use_Provided_Predicate()
@ -129,7 +129,7 @@ public class CoroutineHelperTests
}
/// <summary>
/// 验证WaitWhile应该返回WaitWhile实例
/// 验证WaitWhile应该返回WaitWhile实例
/// </summary>
[Test]
public void WaitWhile_Should_Return_WaitWhile_Instance()
@ -141,7 +141,7 @@ public class CoroutineHelperTests
}
/// <summary>
/// 验证WaitWhile应该在条件为假时完成
/// 验证WaitWhile应该在条件为假时完成
/// </summary>
[Test]
public void WaitWhile_Should_Complete_When_Condition_Is_False()
@ -157,7 +157,7 @@ public class CoroutineHelperTests
}
/// <summary>
/// 验证DelayedCall应该返回IEnumerator实例
/// 验证DelayedCall应该返回IEnumerator实例
/// </summary>
[Test]
public void DelayedCall_Should_Return_IEnumerator()
@ -169,7 +169,7 @@ public class CoroutineHelperTests
}
/// <summary>
/// 验证DelayedCall的action可以在延迟后执行
/// 验证DelayedCall的action可以在延迟后执行
/// </summary>
[Test]
public void DelayedCall_Should_Execute_Action_After_Delay()
@ -187,7 +187,7 @@ public class CoroutineHelperTests
}
/// <summary>
/// 验证DelayedCall可以处理null action
/// 验证DelayedCall可以处理null action
/// </summary>
[Test]
public void DelayedCall_Should_Handle_Null_Action()
@ -199,7 +199,7 @@ public class CoroutineHelperTests
}
/// <summary>
/// 验证RepeatCall应该返回IEnumerator实例
/// 验证RepeatCall应该返回IEnumerator实例
/// </summary>
[Test]
public void RepeatCall_Should_Return_IEnumerator()
@ -211,7 +211,7 @@ public class CoroutineHelperTests
}
/// <summary>
/// 验证RepeatCall应该执行指定次数
/// 验证RepeatCall应该执行指定次数
/// </summary>
[Test]
public void RepeatCall_Should_Execute_Specified_Times()
@ -219,16 +219,13 @@ public class CoroutineHelperTests
var callCount = 0;
var coroutine = CoroutineHelper.RepeatCall(0.1, 3, () => callCount++);
while (coroutine.MoveNext())
{
coroutine.Current.Update(0.1);
}
while (coroutine.MoveNext()) coroutine.Current.Update(0.1);
Assert.That(callCount, Is.EqualTo(3));
}
/// <summary>
/// 验证RepeatCall可以处理0次调用
/// 验证RepeatCall可以处理0次调用
/// </summary>
[Test]
public void RepeatCall_Should_Handle_Zero_Count()
@ -241,7 +238,7 @@ public class CoroutineHelperTests
}
/// <summary>
/// 验证RepeatCallForever应该返回IEnumerator实例
/// 验证RepeatCallForever应该返回IEnumerator实例
/// </summary>
[Test]
public void RepeatCallForever_Should_Return_IEnumerator()
@ -253,7 +250,7 @@ public class CoroutineHelperTests
}
/// <summary>
/// 验证RepeatCallForever应该无限执行
/// 验证RepeatCallForever应该无限执行
/// </summary>
[Test]
public void RepeatCallForever_Should_Execute_Forever()
@ -273,7 +270,7 @@ public class CoroutineHelperTests
}
/// <summary>
/// 验证RepeatCallForever可以处理null action
/// 验证RepeatCallForever可以处理null action
/// </summary>
[Test]
public void RepeatCallForever_Should_Handle_Null_Action()
@ -285,7 +282,7 @@ public class CoroutineHelperTests
}
/// <summary>
/// 验证RepeatCallForever可以处理负数间隔
/// 验证RepeatCallForever可以处理负数间隔
/// </summary>
[Test]
public void RepeatCallForever_Should_Handle_Negative_Interval()
@ -298,7 +295,7 @@ public class CoroutineHelperTests
}
/// <summary>
/// 验证DelayedCall可以处理负数延迟
/// 验证DelayedCall可以处理负数延迟
/// </summary>
[Test]
public void DelayedCall_Should_Handle_Negative_Delay()
@ -311,7 +308,7 @@ public class CoroutineHelperTests
}
/// <summary>
/// 验证RepeatCall可以处理负数间隔
/// 验证RepeatCall可以处理负数间隔
/// </summary>
[Test]
public void RepeatCall_Should_Handle_Negative_Interval()
@ -324,7 +321,7 @@ public class CoroutineHelperTests
}
/// <summary>
/// 验证WaitUntil应该抛出ArgumentNullException当predicate为null
/// 验证WaitUntil应该抛出ArgumentNullException当predicate为null
/// </summary>
[Test]
public void WaitUntil_Should_Throw_ArgumentNullException_When_Predicate_Is_Null()
@ -333,7 +330,7 @@ public class CoroutineHelperTests
}
/// <summary>
/// 验证WaitWhile应该抛出ArgumentNullException当predicate为null
/// 验证WaitWhile应该抛出ArgumentNullException当predicate为null
/// </summary>
[Test]
public void WaitWhile_Should_Throw_ArgumentNullException_When_Predicate_Is_Null()

118
GFramework.Core.Tests/coroutine/CoroutineSchedulerTests.cs
View File

@ -6,46 +6,46 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.coroutine;
/// <summary>
/// 协程调度器的单元测试类
/// 测试内容包括：
/// - 协程调度器的创建和初始化
/// - 运行协程
/// - 更新协程状态
/// - 暂停和恢复协程
/// - 终止协程
/// - 协程等待机制
/// - 标签管理
/// - 清空所有协程
/// - 异常处理
/// - 扩展容量
/// - 主动协程计数
/// - 时间差值属性
/// 协程调度器的单元测试类
/// 测试内容包括：
/// - 协程调度器的创建和初始化
/// - 运行协程
/// - 更新协程状态
/// - 暂停和恢复协程
/// - 终止协程
/// - 协程等待机制
/// - 标签管理
/// - 清空所有协程
/// - 异常处理
/// - 扩展容量
/// - 主动协程计数
/// - 时间差值属性
/// </summary>
[TestFixture]
public class CoroutineSchedulerTests
{
/// <summary>
/// 测试初始化方法，在每个测试方法执行前设置测试环境
/// 测试初始化方法，在每个测试方法执行前设置测试环境
/// </summary>
[SetUp]
public void SetUp()
{
_timeSource = new TestTimeSource();
_scheduler = new CoroutineScheduler(_timeSource, instanceId: 1, initialCapacity: 4);
_scheduler = new CoroutineScheduler(_timeSource, 1, 4);
}
/// <summary>
/// 测试用的时间源实例
/// 测试用的时间源实例
/// </summary>
private TestTimeSource _timeSource = null!;
/// <summary>
/// 测试用的协程调度器实例
/// 测试用的协程调度器实例
/// </summary>
private CoroutineScheduler _scheduler = null!;
/// <summary>
/// 验证协程调度器创建时应该有正确的初始状态
/// 验证协程调度器创建时应该有正确的初始状态
/// </summary>
[Test]
public void CoroutineScheduler_Should_Initialize_With_Correct_State()
@ -54,7 +54,7 @@ public class CoroutineSchedulerTests
}
/// <summary>
/// 验证协程调度器应该在创建时接受有效的时间源
/// 验证协程调度器应该在创建时接受有效的时间源
/// </summary>
[Test]
public void CoroutineScheduler_Should_Accept_Valid_TimeSource()
@ -63,7 +63,7 @@ public class CoroutineSchedulerTests
}
/// <summary>
/// 验证协程调度器应该抛出ArgumentNullException当timeSource为null
/// 验证协程调度器应该抛出ArgumentNullException当timeSource为null
/// </summary>
[Test]
public void CoroutineScheduler_Should_Throw_ArgumentNullException_When_TimeSource_Is_Null()
@ -72,7 +72,7 @@ public class CoroutineSchedulerTests
}
/// <summary>
/// 验证运行协程应该返回有效的句柄
/// 验证运行协程应该返回有效的句柄
/// </summary>
[Test]
public void Run_Should_Return_Valid_Handle()
@ -85,7 +85,7 @@ public class CoroutineSchedulerTests
}
/// <summary>
/// 验证运行null协程应该返回无效的句柄
/// 验证运行null协程应该返回无效的句柄
/// </summary>
[Test]
public void Run_Should_Return_Invalid_Handle_For_Null_Coroutine()
@ -97,7 +97,7 @@ public class CoroutineSchedulerTests
}
/// <summary>
/// 验证Update方法应该推进时间并更新协程状态
/// 验证Update方法应该推进时间并更新协程状态
/// </summary>
[Test]
public void Update_Should_Advance_Time_And_Update_Coroutines()
@ -111,7 +111,7 @@ public class CoroutineSchedulerTests
}
/// <summary>
/// 验证暂停协程应该成功
/// 验证暂停协程应该成功
/// </summary>
[Test]
public void Pause_Should_Succeed_For_Valid_Handle()
@ -125,7 +125,7 @@ public class CoroutineSchedulerTests
}
/// <summary>
/// 验证暂停无效的句柄应该失败
/// 验证暂停无效的句柄应该失败
/// </summary>
[Test]
public void Pause_Should_Fail_For_Invalid_Handle()
@ -136,7 +136,7 @@ public class CoroutineSchedulerTests
}
/// <summary>
/// 验证恢复协程应该成功
/// 验证恢复协程应该成功
/// </summary>
[Test]
public void Resume_Should_Succeed_For_Valid_Handle()
@ -151,7 +151,7 @@ public class CoroutineSchedulerTests
}
/// <summary>
/// 验证恢复无效的句柄应该失败
/// 验证恢复无效的句柄应该失败
/// </summary>
[Test]
public void Resume_Should_Fail_For_Invalid_Handle()
@ -162,7 +162,7 @@ public class CoroutineSchedulerTests
}
/// <summary>
/// 验证终止协程应该成功
/// 验证终止协程应该成功
/// </summary>
[Test]
public void Kill_Should_Succeed_For_Valid_Handle()
@ -177,7 +177,7 @@ public class CoroutineSchedulerTests
}
/// <summary>
/// 验证终止无效的句柄应该失败
/// 验证终止无效的句柄应该失败
/// </summary>
[Test]
public void Kill_Should_Fail_For_Invalid_Handle()
@ -188,7 +188,7 @@ public class CoroutineSchedulerTests
}
/// <summary>
/// 验证WaitForCoroutine方法应该正确设置等待状态
/// 验证WaitForCoroutine方法应该正确设置等待状态
/// </summary>
[Test]
public void WaitForCoroutine_Should_Set_Waiting_State()
@ -205,7 +205,7 @@ public class CoroutineSchedulerTests
}
/// <summary>
/// 验证WaitForCoroutine方法应该抛出异常当等待自己
/// 验证WaitForCoroutine方法应该抛出异常当等待自己
/// </summary>
[Test]
public void WaitForCoroutine_Should_Throw_When_Waiting_For_Self()
@ -217,7 +217,7 @@ public class CoroutineSchedulerTests
}
/// <summary>
/// 验证WaitForCoroutine方法应该处理无效的目标句柄
/// 验证WaitForCoroutine方法应该处理无效的目标句柄
/// </summary>
[Test]
public void WaitForCoroutine_Should_Handle_Invalid_Target_Handle()
@ -229,7 +229,7 @@ public class CoroutineSchedulerTests
}
/// <summary>
/// 验证根据标签终止协程应该正确工作
/// 验证根据标签终止协程应该正确工作
/// </summary>
[Test]
public void KillByTag_Should_Kill_All_Coroutines_With_Tag()
@ -249,7 +249,7 @@ public class CoroutineSchedulerTests
}
/// <summary>
/// 验证根据不存在的标签终止协程应该返回0
/// 验证根据不存在的标签终止协程应该返回0
/// </summary>
[Test]
public void KillByTag_Should_Return_Zero_For_Nonexistent_Tag()
@ -264,7 +264,7 @@ public class CoroutineSchedulerTests
}
/// <summary>
/// 验证清空所有协程应该正确工作
/// 验证清空所有协程应该正确工作
/// </summary>
[Test]
public void Clear_Should_Remove_All_Coroutines()
@ -282,7 +282,7 @@ public class CoroutineSchedulerTests
}
/// <summary>
/// 验证清空空的调度器应该返回0
/// 验证清空空的调度器应该返回0
/// </summary>
[Test]
public void Clear_Should_Return_Zero_For_Empty_Scheduler()
@ -293,7 +293,7 @@ public class CoroutineSchedulerTests
}
/// <summary>
/// 验证协程调度器应该正确处理协程异常
/// 验证协程调度器应该正确处理协程异常
/// </summary>
[Test]
public void Scheduler_Should_Handle_Coroutine_Exceptions()
@ -305,7 +305,7 @@ public class CoroutineSchedulerTests
}
/// <summary>
/// 验证协程调度器应该在协程抛出异常后减少活跃协程计数
/// 验证协程调度器应该在协程抛出异常后减少活跃协程计数
/// </summary>
[Test]
public void Scheduler_Should_Decrement_ActiveCount_After_Exception()
@ -321,27 +321,21 @@ public class CoroutineSchedulerTests
}
/// <summary>
/// 验证协程调度器应该扩展容量当槽位已满
/// 验证协程调度器应该扩展容量当槽位已满
/// </summary>
[Test]
public void Scheduler_Should_Expand_Capacity_When_Slots_Full()
{
var coroutines = new List<IEnumerator<IYieldInstruction>>();
for (var i = 0; i < 10; i++)
{
coroutines.Add(CreateYieldingCoroutine(new Delay(1.0)));
}
for (var i = 0; i < 10; i++) coroutines.Add(CreateYieldingCoroutine(new Delay(1.0)));
foreach (var coroutine in coroutines)
{
_scheduler.Run(coroutine);
}
foreach (var coroutine in coroutines) _scheduler.Run(coroutine);
Assert.That(_scheduler.ActiveCoroutineCount, Is.EqualTo(10));
}
/// <summary>
/// 验证协程调度器应该使用提供的时间源
/// 验证协程调度器应该使用提供的时间源
/// </summary>
[Test]
public void Scheduler_Should_Use_Provided_TimeSource()
@ -355,7 +349,7 @@ public class CoroutineSchedulerTests
}
/// <summary>
/// 验证协程调度器应该正确计算活跃协程计数
/// 验证协程调度器应该正确计算活跃协程计数
/// </summary>
[Test]
public void ActiveCoroutineCount_Should_Reflect_Active_Coroutines()
@ -377,7 +371,7 @@ public class CoroutineSchedulerTests
}
/// <summary>
/// 验证暂停的协程不应该被更新
/// 验证暂停的协程不应该被更新
/// </summary>
[Test]
public void Paused_Coroutine_Should_Not_Be_Updated()
@ -393,7 +387,7 @@ public class CoroutineSchedulerTests
}
/// <summary>
/// 验证恢复的协程应该继续执行
/// 验证恢复的协程应该继续执行
/// </summary>
[Test]
public void Resumed_Coroutine_Should_Continue_Execution()
@ -412,7 +406,7 @@ public class CoroutineSchedulerTests
}
/// <summary>
/// 创建简单的立即完成协程
/// 创建简单的立即完成协程
/// </summary>
private IEnumerator<IYieldInstruction> CreateSimpleCoroutine()
{
@ -420,7 +414,7 @@ public class CoroutineSchedulerTests
}
/// <summary>
/// 创建带等待指令的协程
/// 创建带等待指令的协程
/// </summary>
private IEnumerator<IYieldInstruction> CreateYieldingCoroutine(IYieldInstruction yieldInstruction)
{
@ -428,7 +422,7 @@ public class CoroutineSchedulerTests
}
/// <summary>
/// 创建带等待指令和回调的协程
/// 创建带等待指令和回调的协程
/// </summary>
private IEnumerator<IYieldInstruction> CreateYieldingCoroutine(IYieldInstruction yieldInstruction,
Action? onComplete = null)
@ -438,7 +432,7 @@ public class CoroutineSchedulerTests
}
/// <summary>
/// 创建立即完成并执行回调的协程
/// 创建立即完成并执行回调的协程
/// </summary>
private IEnumerator<IYieldInstruction> CreateImmediateCoroutine(Action? onComplete = null)
{
@ -447,7 +441,7 @@ public class CoroutineSchedulerTests
}
/// <summary>
/// 创建计数协程
/// 创建计数协程
/// </summary>
private IEnumerator<IYieldInstruction> CreateCountingCoroutine(Action? onExecute = null)
{
@ -458,7 +452,7 @@ public class CoroutineSchedulerTests
}
/// <summary>
/// 创建抛出异常的协程
/// 创建抛出异常的协程
/// </summary>
private IEnumerator<IYieldInstruction> CreateExceptionCoroutine()
{
@ -468,22 +462,22 @@ public class CoroutineSchedulerTests
}
/// <summary>
/// 测试用时间源类，实现ITimeSource接口
/// 测试用时间源类，实现ITimeSource接口
/// </summary>
public class TestTimeSource : ITimeSource
{
/// <summary>
/// 获取当前时间
/// 获取当前时间
/// </summary>
public double CurrentTime { get; private set; }
/// <summary>
/// 获取时间增量
/// 获取时间增量
/// </summary>
public double DeltaTime { get; private set; }
/// <summary>
/// 更新时间源状态
/// 更新时间源状态
/// </summary>
public void Update()
{

12
GFramework.Core.Tests/coroutine/CoroutineStateTests.cs
View File

@ -4,16 +4,16 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.coroutine;
/// <summary>
/// 协程状态枚举的单元测试类
/// 测试内容包括：
/// - 枚举值存在性验证
/// - 枚举值正确性
/// 协程状态枚举的单元测试类
/// 测试内容包括：
/// - 枚举值存在性验证
/// - 枚举值正确性
/// </summary>
[TestFixture]
public class CoroutineStateTests
{
/// <summary>
/// 验证协程状态枚举包含所有预期值
/// 验证协程状态枚举包含所有预期值
/// </summary>
[Test]
public void CoroutineState_Should_Have_All_Expected_Values()
@ -29,7 +29,7 @@ public class CoroutineStateTests
}
/// <summary>
/// 验证枚举基础值为整数类型
/// 验证枚举基础值为整数类型
/// </summary>
[Test]
public void CoroutineState_Should_Be_Integer_Based_Enum()

76
GFramework.Core.Tests/coroutine/TaskCoroutineExtensionsTests.cs
View File

@ -7,16 +7,16 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.coroutine;
/// <summary>
/// TaskCoroutineExtensions的单元测试类
/// 测试内容包括：
/// - AsCoroutineInstruction方法
/// - StartTaskAsCoroutine方法
/// TaskCoroutineExtensions的单元测试类
/// 测试内容包括：
/// - AsCoroutineInstruction方法
/// - StartTaskAsCoroutine方法
/// </summary>
[TestFixture]
public class TaskCoroutineExtensionsTests
{
/// <summary>
/// 验证AsCoroutineInstruction应该返回WaitForTask
/// 验证AsCoroutineInstruction应该返回WaitForTask
/// </summary>
[Test]
public void AsCoroutineInstruction_Should_Return_WaitForTask()
@ -28,19 +28,19 @@ public class TaskCoroutineExtensionsTests
}
/// <summary>
/// 验证AsCoroutineInstruction<T>应该返回WaitForTask<T>
/// 验证AsCoroutineInstruction<T>应该返回WaitForTask<T>
/// </summary>
[Test]
public void AsCoroutineInstructionOfT_Should_Return_WaitForTaskOfT()
{
var task = Task.FromResult(42);
var instruction = task.AsCoroutineInstruction<int>();
var instruction = task.AsCoroutineInstruction();
Assert.That(instruction, Is.InstanceOf<WaitForTask<int>>());
}
/// <summary>
/// 验证AsCoroutineInstruction可以处理已完成的Task并验证其状态
/// 验证AsCoroutineInstruction可以处理已完成的Task并验证其状态
/// </summary>
[Test]
public void AsCoroutineInstruction_Should_Handle_Completed_Task()
@ -50,21 +50,21 @@ public class TaskCoroutineExtensionsTests
// 验证指令类型
Assert.That(instruction, Is.InstanceOf<WaitForTask>());
// 验证已完成的任务是否立即可用
Assert.That(task.IsCompleted, Is.True);
Assert.That(task.Status, Is.EqualTo(TaskStatus.RanToCompletion));
}
/// <summary>
/// 验证AsCoroutineInstruction<T>应该能够访问Task结果
/// 验证AsCoroutineInstruction<T>应该能够访问Task结果
/// </summary>
[Test]
public void AsCoroutineInstructionOfT_Should_Access_Task_Result()
{
var task = Task.FromResult(42);
var instruction = task.AsCoroutineInstruction<int>();
var instruction = task.AsCoroutineInstruction();
task.Wait();
@ -72,7 +72,7 @@ public class TaskCoroutineExtensionsTests
}
/// <summary>
/// 验证AsCoroutineInstruction应该处理null Task（抛出异常）
/// 验证AsCoroutineInstruction应该处理null Task（抛出异常）
/// </summary>
[Test]
public void AsCoroutineInstruction_Should_Handle_Null_Task()
@ -83,18 +83,18 @@ public class TaskCoroutineExtensionsTests
}
/// <summary>
/// 验证AsCoroutineInstruction<T>应该处理null Task（抛出异常）
/// 验证AsCoroutineInstruction<T>应该处理null Task（抛出异常）
/// </summary>
[Test]
public void AsCoroutineInstructionOfT_Should_Handle_Null_Task()
{
Task<int> task = null!;
Assert.Throws<ArgumentNullException>(() => task.AsCoroutineInstruction<int>());
Assert.Throws<ArgumentNullException>(() => task.AsCoroutineInstruction());
}
/// <summary>
/// 验证AsCoroutineInstruction应该处理失败的Task
/// 验证AsCoroutineInstruction应该处理失败的Task
/// </summary>
[Test]
public void AsCoroutineInstruction_Should_Handle_Faulted_Task()
@ -106,25 +106,25 @@ public class TaskCoroutineExtensionsTests
}
/// <summary>
/// 验证AsCoroutineInstruction<T>应该处理失败的Task
/// 验证AsCoroutineInstruction<T>应该处理失败的Task
/// </summary>
[Test]
public void AsCoroutineInstructionOfT_Should_Handle_Faulted_Task()
{
var task = Task.FromException<int>(new InvalidOperationException("Test exception"));
var instruction = task.AsCoroutineInstruction<int>();
var instruction = task.AsCoroutineInstruction();
Assert.That(instruction, Is.InstanceOf<WaitForTask<int>>());
}
/// <summary>
/// 验证StartTaskAsCoroutine应该返回有效的协程句柄
/// 验证StartTaskAsCoroutine应该返回有效的协程句柄
/// </summary>
[Test]
public void StartTaskAsCoroutine_Should_Return_Valid_Handle()
{
var timeSource = new TestTimeSource();
var scheduler = new CoroutineScheduler(timeSource, instanceId: 1);
var scheduler = new CoroutineScheduler(timeSource);
var task = Task.CompletedTask;
var handle = scheduler.StartTaskAsCoroutine(task);
@ -133,13 +133,13 @@ public class TaskCoroutineExtensionsTests
}
/// <summary>
/// 验证StartTaskAsCoroutine<T>应该返回有效的协程句柄
/// 验证StartTaskAsCoroutine<T>应该返回有效的协程句柄
/// </summary>
[Test]
public void StartTaskAsCoroutineOfT_Should_Return_Valid_Handle()
{
var timeSource = new TestTimeSource();
var scheduler = new CoroutineScheduler(timeSource, instanceId: 1);
var scheduler = new CoroutineScheduler(timeSource);
var task = Task.FromResult(42);
var handle = scheduler.StartTaskAsCoroutine(task);
@ -148,13 +148,13 @@ public class TaskCoroutineExtensionsTests
}
/// <summary>
/// 验证StartTaskAsCoroutine应该等待Task完成
/// 验证StartTaskAsCoroutine应该等待Task完成
/// </summary>
[Test]
public void StartTaskAsCoroutine_Should_Wait_For_Task_Completion()
{
var timeSource = new TestTimeSource();
var scheduler = new CoroutineScheduler(timeSource, instanceId: 1);
var scheduler = new CoroutineScheduler(timeSource);
var completed = false;
var tcs = new TaskCompletionSource<object?>();
@ -174,13 +174,13 @@ public class TaskCoroutineExtensionsTests
}
/// <summary>
/// 验证StartTaskAsCoroutine<T>应该等待Task完成
/// 验证StartTaskAsCoroutine<T>应该等待Task完成
/// </summary>
[Test]
public void StartTaskAsCoroutineOfT_Should_Wait_For_Task_Completion()
{
var timeSource = new TestTimeSource();
var scheduler = new CoroutineScheduler(timeSource, instanceId: 1);
var scheduler = new CoroutineScheduler(timeSource);
var tcs = new TaskCompletionSource<int>();
@ -198,13 +198,13 @@ public class TaskCoroutineExtensionsTests
}
/// <summary>
/// 验证StartTaskAsCoroutine应该处理已完成的Task
/// 验证StartTaskAsCoroutine应该处理已完成的Task
/// </summary>
[Test]
public void StartTaskAsCoroutine_Should_Handle_Completed_Task()
{
var timeSource = new TestTimeSource();
var scheduler = new CoroutineScheduler(timeSource, instanceId: 1);
var scheduler = new CoroutineScheduler(timeSource);
var task = Task.CompletedTask;
scheduler.StartTaskAsCoroutine(task);
@ -215,13 +215,13 @@ public class TaskCoroutineExtensionsTests
}
/// <summary>
/// 验证StartTaskAsCoroutine应该处理失败的Task
/// 验证StartTaskAsCoroutine应该处理失败的Task
/// </summary>
[Test]
public void StartTaskAsCoroutine_Should_Handle_Faulted_Task()
{
var timeSource = new TestTimeSource();
var scheduler = new CoroutineScheduler(timeSource, instanceId: 1);
var scheduler = new CoroutineScheduler(timeSource);
var task = Task.FromException(new InvalidOperationException("Test"));
scheduler.StartTaskAsCoroutine(task);
@ -230,29 +230,29 @@ public class TaskCoroutineExtensionsTests
}
/// <summary>
/// 验证StartTaskAsCoroutine<T>应该处理失败的Task
/// 验证StartTaskAsCoroutine<T>应该处理失败的Task
/// </summary>
[Test]
public void StartTaskAsCoroutineOfT_Should_Handle_Faulted_Task()
{
var timeSource = new TestTimeSource();
var scheduler = new CoroutineScheduler(timeSource, instanceId: 1);
var scheduler = new CoroutineScheduler(timeSource);
var task = Task.FromException<int>(new InvalidOperationException("Test"));
scheduler.StartTaskAsCoroutine(task);
Assert.DoesNotThrow(() => scheduler.Update());
}
/// <summary>
/// 验证StartTaskAsCoroutine应该与调度器正常协作
/// 验证StartTaskAsCoroutine应该与调度器正常协作
/// </summary>
[Test]
public void StartTaskAsCoroutine_Should_Work_With_Scheduler()
{
var timeSource = new TestTimeSource();
var scheduler = new CoroutineScheduler(timeSource, instanceId: 1);
var scheduler = new CoroutineScheduler(timeSource);
var tcs = new TaskCompletionSource<object?>();
scheduler.StartTaskAsCoroutine(tcs.Task);
@ -273,7 +273,7 @@ public class TaskCoroutineExtensionsTests
}
/// <summary>
/// 测试用时间源类
/// 测试用时间源类
/// </summary>
private class TestTimeSource : ITimeSource
{
@ -286,4 +286,4 @@ public class TaskCoroutineExtensionsTests
CurrentTime += DeltaTime;
}
}
}
}

132
GFramework.Core.Tests/coroutine/WaitForAllCoroutinesTests.cs
View File

@ -7,26 +7,26 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.coroutine;
/// <summary>
/// WaitForAllCoroutines的单元测试类
/// 测试内容包括：
/// - 初始化和基本功能
/// - IsDone属性行为
/// - 空句柄集合处理
/// - 单个协程处理
/// - 多个协程处理
/// - 与CoroutineScheduler集成
/// WaitForAllCoroutines的单元测试类
/// 测试内容包括：
/// - 初始化和基本功能
/// - IsDone属性行为
/// - 空句柄集合处理
/// - 单个协程处理
/// - 多个协程处理
/// - 与CoroutineScheduler集成
/// </summary>
[TestFixture]
public class WaitForAllCoroutinesTests
{
/// <summary>
/// 验证WaitForAllCoroutines初始状态为未完成
/// 验证WaitForAllCoroutines初始状态为未完成
/// </summary>
[Test]
public void WaitForAllCoroutines_Should_Not_Be_Done_Initially_With_Running_Coroutines()
{
var timeSource = new TestTimeSource();
var scheduler = new CoroutineScheduler(timeSource, instanceId: 1);
var scheduler = new CoroutineScheduler(timeSource, 1);
var coroutine1 = CreateDelayedCoroutine(() => { }, 1.0);
var coroutine2 = CreateDelayedCoroutine(() => { }, 1.0);
@ -42,13 +42,13 @@ public class WaitForAllCoroutinesTests
}
/// <summary>
/// 验证WaitForAllCoroutines应该在所有协程完成后完成
/// 验证WaitForAllCoroutines应该在所有协程完成后完成
/// </summary>
[Test]
public void WaitForAllCoroutines_Should_Be_Done_When_All_Coroutines_Complete()
{
var timeSource = new TestTimeSource();
var scheduler = new CoroutineScheduler(timeSource, instanceId: 1);
var scheduler = new CoroutineScheduler(timeSource, 1);
var coroutine1 = CreateSimpleCoroutine();
var coroutine2 = CreateSimpleCoroutine();
@ -67,13 +67,13 @@ public class WaitForAllCoroutinesTests
}
/// <summary>
/// 验证WaitForAllCoroutines应该在所有协程完成后完成（使用Delay）
/// 验证WaitForAllCoroutines应该在所有协程完成后完成（使用Delay）
/// </summary>
[Test]
public void WaitForAllCoroutines_Should_Wait_For_All_Delayed_Coroutines()
{
var timeSource = new TestTimeSource();
var scheduler = new CoroutineScheduler(timeSource, instanceId: 1);
var scheduler = new CoroutineScheduler(timeSource, 1);
var executionCount = 0;
var coroutine1 = CreateDelayedCoroutine(() => executionCount++, 1.0);
@ -92,23 +92,20 @@ public class WaitForAllCoroutinesTests
Assert.That(wait.IsDone, Is.False);
Assert.That(executionCount, Is.EqualTo(0));
for (var i = 0; i < 12; i++)
{
scheduler.Update();
}
for (var i = 0; i < 12; i++) scheduler.Update();
Assert.That(wait.IsDone, Is.True);
Assert.That(executionCount, Is.EqualTo(3));
}
/// <summary>
/// 验证WaitForAllCoroutines应该处理空句柄列表
/// 验证WaitForAllCoroutines应该处理空句柄列表
/// </summary>
[Test]
public void WaitForAllCoroutines_Should_Handle_Empty_Handles_List()
{
var timeSource = new TestTimeSource();
var scheduler = new CoroutineScheduler(timeSource, instanceId: 1);
var scheduler = new CoroutineScheduler(timeSource, 1);
var handles = Array.Empty<CoroutineHandle>();
var wait = new WaitForAllCoroutines(scheduler, handles);
@ -117,19 +114,19 @@ public class WaitForAllCoroutinesTests
}
/// <summary>
/// 验证WaitForAllCoroutines应该抛出ArgumentNullException当handles为null
/// 验证WaitForAllCoroutines应该抛出ArgumentNullException当handles为null
/// </summary>
[Test]
public void WaitForAllCoroutines_Should_Throw_ArgumentNullException_When_Handles_Is_Null()
{
var timeSource = new TestTimeSource();
var scheduler = new CoroutineScheduler(timeSource, instanceId: 1);
var scheduler = new CoroutineScheduler(timeSource, 1);
Assert.Throws<ArgumentNullException>(() => new WaitForAllCoroutines(scheduler, null!));
}
/// <summary>
/// 验证WaitForAllCoroutines应该抛出ArgumentNullException当scheduler为null
/// 验证WaitForAllCoroutines应该抛出ArgumentNullException当scheduler为null
/// </summary>
[Test]
public void WaitForAllCoroutines_Should_Throw_ArgumentNullException_When_Scheduler_Is_Null()
@ -140,13 +137,13 @@ public class WaitForAllCoroutinesTests
}
/// <summary>
/// 验证WaitForAllCoroutines应该处理单个协程
/// 验证WaitForAllCoroutines应该处理单个协程
/// </summary>
[Test]
public void WaitForAllCoroutines_Should_Handle_Single_Coroutine()
{
var timeSource = new TestTimeSource();
var scheduler = new CoroutineScheduler(timeSource, instanceId: 1);
var scheduler = new CoroutineScheduler(timeSource, 1);
var coroutine = CreateSimpleCoroutine();
var handles = new List<CoroutineHandle> { scheduler.Run(coroutine) };
@ -159,13 +156,13 @@ public class WaitForAllCoroutinesTests
}
/// <summary>
/// 验证WaitForAllCoroutines应该在部分协程完成时未完成
/// 验证WaitForAllCoroutines应该在部分协程完成时未完成
/// </summary>
[Test]
public void WaitForAllCoroutines_Should_Not_Be_Done_When_Some_Coroutines_Complete()
{
var timeSource = new TestTimeSource();
var scheduler = new CoroutineScheduler(timeSource, instanceId: 1);
var scheduler = new CoroutineScheduler(timeSource, 1);
var executionCount = 0;
var coroutine1 = CreateSimpleCoroutine();
@ -188,13 +185,13 @@ public class WaitForAllCoroutinesTests
}
/// <summary>
/// 验证WaitForAllCoroutines应该处理被终止的协程
/// 验证WaitForAllCoroutines应该处理被终止的协程
/// </summary>
[Test]
public void WaitForAllCoroutines_Should_Handle_Killed_Coroutines()
{
var timeSource = new TestTimeSource();
var scheduler = new CoroutineScheduler(timeSource, instanceId: 1);
var scheduler = new CoroutineScheduler(timeSource, 1);
var coroutine1 = CreateDelayedCoroutine(() => { }, 1.0);
var coroutine2 = CreateDelayedCoroutine(() => { }, 1.0);
@ -219,13 +216,13 @@ public class WaitForAllCoroutinesTests
}
/// <summary>
/// 验证WaitForAllCoroutines应该处理被暂停和恢复的协程
/// 验证WaitForAllCoroutines应该处理被暂停和恢复的协程
/// </summary>
[Test]
public void WaitForAllCoroutines_Should_Handle_Paused_And_Resumed_Coroutines()
{
var timeSource = new TestTimeSource();
var scheduler = new CoroutineScheduler(timeSource, instanceId: 1);
var scheduler = new CoroutineScheduler(timeSource, 1);
var executionCount = 0;
var coroutine1 = CreateDelayedCoroutine(() => executionCount++, 1.0);
@ -241,33 +238,27 @@ public class WaitForAllCoroutinesTests
scheduler.Pause(handles[0]);
for (var i = 0; i < 12; i++)
{
scheduler.Update();
}
for (var i = 0; i < 12; i++) scheduler.Update();
Assert.That(wait.IsDone, Is.False);
Assert.That(executionCount, Is.EqualTo(1));
scheduler.Resume(handles[0]);
for (var i = 0; i < 12; i++)
{
scheduler.Update();
}
for (var i = 0; i < 12; i++) scheduler.Update();
Assert.That(wait.IsDone, Is.True);
Assert.That(executionCount, Is.EqualTo(2));
}
/// <summary>
/// 验证WaitForAllCoroutines的Update方法不影响状态
/// 验证WaitForAllCoroutines的Update方法不影响状态
/// </summary>
[Test]
public void WaitForAllCoroutines_Update_Should_Not_Affect_State()
{
var timeSource = new TestTimeSource();
var scheduler = new CoroutineScheduler(timeSource, instanceId: 1);
var scheduler = new CoroutineScheduler(timeSource, 1);
var coroutine = CreateDelayedCoroutine(() => { }, 1.0);
var handles = new List<CoroutineHandle> { scheduler.Run(coroutine) };
@ -281,13 +272,13 @@ public class WaitForAllCoroutinesTests
}
/// <summary>
/// 验证WaitForAllCoroutines应该处理无效句柄
/// 验证WaitForAllCoroutines应该处理无效句柄
/// </summary>
[Test]
public void WaitForAllCoroutines_Should_Handle_Invalid_Handles()
{
var timeSource = new TestTimeSource();
var scheduler = new CoroutineScheduler(timeSource, instanceId: 1);
var scheduler = new CoroutineScheduler(timeSource, 1);
var handles = new List<CoroutineHandle> { default };
@ -297,13 +288,13 @@ public class WaitForAllCoroutinesTests
}
/// <summary>
/// 验证WaitForAllCoroutines应该处理混合的有效和无效句柄
/// 验证WaitForAllCoroutines应该处理混合的有效和无效句柄
/// </summary>
[Test]
public void WaitForAllCoroutines_Should_Handle_Mixed_Valid_And_Invalid_Handles()
{
var timeSource = new TestTimeSource();
var scheduler = new CoroutineScheduler(timeSource, instanceId: 1);
var scheduler = new CoroutineScheduler(timeSource, 1);
var coroutine = CreateSimpleCoroutine();
var handles = new List<CoroutineHandle>
@ -320,42 +311,36 @@ public class WaitForAllCoroutinesTests
}
/// <summary>
/// 验证WaitForAllCoroutines应该处理大量协程
/// 验证WaitForAllCoroutines应该处理大量协程
/// </summary>
[Test]
public void WaitForAllCoroutines_Should_Handle_Many_Coroutines()
{
var timeSource = new TestTimeSource();
var scheduler = new CoroutineScheduler(timeSource, instanceId: 1);
var scheduler = new CoroutineScheduler(timeSource, 1);
var executionCount = 0;
var handles = new List<CoroutineHandle>();
for (var i = 0; i < 20; i++)
{
handles.Add(scheduler.Run(CreateDelayedCoroutine(() => executionCount++, 1.0)));
}
for (var i = 0; i < 20; i++) handles.Add(scheduler.Run(CreateDelayedCoroutine(() => executionCount++, 1.0)));
var wait = new WaitForAllCoroutines(scheduler, handles);
Assert.That(wait.IsDone, Is.False);
for (var i = 0; i < 120; i++)
{
scheduler.Update();
}
for (var i = 0; i < 120; i++) scheduler.Update();
Assert.That(wait.IsDone, Is.True);
Assert.That(executionCount, Is.EqualTo(20));
}
/// <summary>
/// 验证WaitForAllCoroutines应该处理抛出异常的协程
/// 验证WaitForAllCoroutines应该处理抛出异常的协程
/// </summary>
[Test]
public void WaitForAllCoroutines_Should_Handle_Coroutines_With_Exceptions()
{
var timeSource = new TestTimeSource();
var scheduler = new CoroutineScheduler(timeSource, instanceId: 1);
var scheduler = new CoroutineScheduler(timeSource, 1);
var coroutine1 = CreateSimpleCoroutine();
var coroutine2 = CreateExceptionCoroutine();
@ -376,13 +361,13 @@ public class WaitForAllCoroutinesTests
}
/// <summary>
/// 验证WaitForAllCoroutines应该与ParallelCoroutines扩展方法一起工作
/// 验证WaitForAllCoroutines应该与ParallelCoroutines扩展方法一起工作
/// </summary>
[Test]
public void WaitForAllCoroutines_Should_Work_With_ParallelCoroutines()
{
var timeSource = new TestTimeSource();
var scheduler = new CoroutineScheduler(timeSource, instanceId: 1);
var scheduler = new CoroutineScheduler(timeSource, 1);
var executionOrder = new List<int>();
var coroutine1 = CreateDelayedCoroutine(() => executionOrder.Add(1), 0.5);
@ -406,13 +391,13 @@ public class WaitForAllCoroutinesTests
}
/// <summary>
/// 验证WaitForAllCoroutines应该实现IYieldInstruction接口
/// 验证WaitForAllCoroutines应该实现IYieldInstruction接口
/// </summary>
[Test]
public void WaitForAllCoroutines_Should_Implement_IYieldInstruction()
{
var timeSource = new TestTimeSource();
var scheduler = new CoroutineScheduler(timeSource, instanceId: 1);
var scheduler = new CoroutineScheduler(timeSource, 1);
var handles = Array.Empty<CoroutineHandle>();
var wait = new WaitForAllCoroutines(scheduler, handles);
@ -421,13 +406,13 @@ public class WaitForAllCoroutinesTests
}
/// <summary>
/// 验证WaitForAllCoroutines应该在所有协程立即完成时立即完成
/// 验证WaitForAllCoroutines应该在所有协程立即完成时立即完成
/// </summary>
[Test]
public void WaitForAllCoroutines_Should_Be_Done_Immediately_When_All_Coroutines_Complete_Immediately()
{
var timeSource = new TestTimeSource();
var scheduler = new CoroutineScheduler(timeSource, instanceId: 1);
var scheduler = new CoroutineScheduler(timeSource, 1);
var coroutine1 = CreateSimpleCoroutine();
var coroutine2 = CreateSimpleCoroutine();
@ -447,13 +432,13 @@ public class WaitForAllCoroutinesTests
}
/// <summary>
/// 验证WaitForAllCoroutines应该处理重复的句柄
/// 验证WaitForAllCoroutines应该处理重复的句柄
/// </summary>
[Test]
public void WaitForAllCoroutines_Should_Handle_Duplicate_Handles()
{
var timeSource = new TestTimeSource();
var scheduler = new CoroutineScheduler(timeSource, instanceId: 1);
var scheduler = new CoroutineScheduler(timeSource, 1);
var coroutine = CreateDelayedCoroutine(() => { }, 1.0);
var handle = scheduler.Run(coroutine);
@ -461,16 +446,13 @@ public class WaitForAllCoroutinesTests
var wait = new WaitForAllCoroutines(scheduler, handles);
for (var i = 0; i < 12; i++)
{
scheduler.Update();
}
for (var i = 0; i < 12; i++) scheduler.Update();
Assert.That(wait.IsDone, Is.True);
}
/// <summary>
/// 创建简单的立即完成协程
/// 创建简单的立即完成协程
/// </summary>
private IEnumerator<IYieldInstruction> CreateSimpleCoroutine()
{
@ -478,7 +460,7 @@ public class WaitForAllCoroutinesTests
}
/// <summary>
/// 创建带回调的协程
/// 创建带回调的协程
/// </summary>
private IEnumerator<IYieldInstruction> CreateCoroutineWithCallback(int id, Action callback)
{
@ -487,7 +469,7 @@ public class WaitForAllCoroutinesTests
}
/// <summary>
/// 创建延迟协程
/// 创建延迟协程
/// </summary>
private IEnumerator<IYieldInstruction> CreateDelayedCoroutine(Action callback, double delay)
{
@ -496,7 +478,7 @@ public class WaitForAllCoroutinesTests
}
/// <summary>
/// 创建抛出异常的协程
/// 创建抛出异常的协程
/// </summary>
private IEnumerator<IYieldInstruction> CreateExceptionCoroutine()
{
@ -505,7 +487,7 @@ public class WaitForAllCoroutinesTests
}
/// <summary>
/// 测试用时间源类
/// 测试用时间源类
/// </summary>
private class TestTimeSource : ITimeSource
{
@ -518,4 +500,4 @@ public class WaitForAllCoroutinesTests
CurrentTime += DeltaTime;
}
}
}
}

60
GFramework.Core.Tests/coroutine/WaitForProgressTests.cs
View File

@ -5,18 +5,18 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.coroutine;
/// <summary>
/// WaitForProgress的单元测试类
/// 测试内容包括：
/// - 初始化和基本功能
/// - 进度回调
/// - 边界条件
/// - 异常处理
/// WaitForProgress的单元测试类
/// 测试内容包括：
/// - 初始化和基本功能
/// - 进度回调
/// - 边界条件
/// - 异常处理
/// </summary>
[TestFixture]
public class WaitForProgressTests
{
/// <summary>
/// 验证WaitForProgress初始状态为未完成
/// 验证WaitForProgress初始状态为未完成
/// </summary>
[Test]
public void WaitForProgress_Should_Not_Be_Done_Initially()
@ -28,7 +28,7 @@ public class WaitForProgressTests
}
/// <summary>
/// 验证WaitForProgress应该在指定时间后完成
/// 验证WaitForProgress应该在指定时间后完成
/// </summary>
[Test]
public void WaitForProgress_Should_Be_Done_After_Duration()
@ -44,7 +44,7 @@ public class WaitForProgressTests
}
/// <summary>
/// 验证WaitForProgress应该在Update时调用进度回调
/// 验证WaitForProgress应该在Update时调用进度回调
/// </summary>
[Test]
public void WaitForProgress_Should_Call_Progress_Callback_On_Update()
@ -58,7 +58,7 @@ public class WaitForProgressTests
}
/// <summary>
/// 验证进度值应该在0到1之间
/// 验证进度值应该在0到1之间
/// </summary>
[Test]
public void WaitForProgress_Should_Have_Progress_Between_0_And_1()
@ -66,10 +66,7 @@ public class WaitForProgressTests
var progressValues = new List<float>();
var wait = new WaitForProgress(1.0, progressValues.Add);
while (!wait.IsDone)
{
wait.Update(0.1);
}
while (!wait.IsDone) wait.Update(0.1);
foreach (var progress in progressValues)
{
@ -79,7 +76,7 @@ public class WaitForProgressTests
}
/// <summary>
/// 验证进度值应该随着时间增加
/// 验证进度值应该随着时间增加
/// </summary>
[Test]
public void WaitForProgress_Should_Increase_Progress_Over_Time()
@ -101,7 +98,7 @@ public class WaitForProgressTests
}
/// <summary>
/// 验证WaitForProgress应该抛出ArgumentNullException当回调为null
/// 验证WaitForProgress应该抛出ArgumentNullException当回调为null
/// </summary>
[Test]
public void WaitForProgress_Should_Throw_ArgumentNullException_When_Callback_Is_Null()
@ -110,7 +107,7 @@ public class WaitForProgressTests
}
/// <summary>
/// 验证WaitForProgress应该抛出ArgumentException当duration为0
/// 验证WaitForProgress应该抛出ArgumentException当duration为0
/// </summary>
[Test]
public void WaitForProgress_Should_Throw_ArgumentException_When_Duration_Is_Zero()
@ -119,7 +116,7 @@ public class WaitForProgressTests
}
/// <summary>
/// 验证WaitForProgress应该抛出ArgumentException当duration为负数
/// 验证WaitForProgress应该抛出ArgumentException当duration为负数
/// </summary>
[Test]
public void WaitForProgress_Should_Throw_ArgumentException_When_Duration_Is_Negative()
@ -128,7 +125,7 @@ public class WaitForProgressTests
}
/// <summary>
/// 验证WaitForProgress应该处理超过duration的更新
/// 验证WaitForProgress应该处理超过duration的更新
/// </summary>
[Test]
public void WaitForProgress_Should_Clamp_Progress_To_1_When_Exceeding_Duration()
@ -144,7 +141,7 @@ public class WaitForProgressTests
}
/// <summary>
/// 验证WaitForProgress可以处理精确的duration
/// 验证WaitForProgress可以处理精确的duration
/// </summary>
[Test]
public void WaitForProgress_Should_Handle_Exact_Duration()
@ -160,7 +157,7 @@ public class WaitForProgressTests
}
/// <summary>
/// 验证WaitForProgress可以处理不同的delta time
/// 验证WaitForProgress可以处理不同的delta time
/// </summary>
[Test]
public void WaitForProgress_Should_Handle_Variable_Delta_Time()
@ -179,7 +176,7 @@ public class WaitForProgressTests
}
/// <summary>
/// 验证WaitForProgress可以处理多次Update
/// 验证WaitForProgress可以处理多次Update
/// </summary>
[Test]
public void WaitForProgress_Should_Handle_Multiple_Updates()
@ -199,7 +196,7 @@ public class WaitForProgressTests
}
/// <summary>
/// 验证WaitForProgress应该确保最后一个进度为1.0
/// 验证WaitForProgress应该确保最后一个进度为1.0
/// </summary>
[Test]
public void WaitForProgress_Should_Ensure_Final_Progress_Is_1()
@ -207,16 +204,13 @@ public class WaitForProgressTests
var progressValues = new List<float>();
var wait = new WaitForProgress(1.0, progressValues.Add);
while (!wait.IsDone)
{
wait.Update(0.1);
}
while (!wait.IsDone) wait.Update(0.1);
Assert.That(progressValues[^1], Is.EqualTo(1.0f).Within(0.01f));
}
/// <summary>
/// 验证WaitForProgress实现IYieldInstruction接口
/// 验证WaitForProgress实现IYieldInstruction接口
/// </summary>
[Test]
public void WaitForProgress_Should_Implement_IYieldInstruction()
@ -228,7 +222,7 @@ public class WaitForProgressTests
}
/// <summary>
/// 验证WaitForProgress可以处理很短的duration
/// 验证WaitForProgress可以处理很短的duration
/// </summary>
[Test]
public void WaitForProgress_Should_Handle_Short_Duration()
@ -242,7 +236,7 @@ public class WaitForProgressTests
}
/// <summary>
/// 验证WaitForProgress可以处理很长的duration
/// 验证WaitForProgress可以处理很长的duration
/// </summary>
[Test]
public void WaitForProgress_Should_Handle_Long_Duration()
@ -258,7 +252,7 @@ public class WaitForProgressTests
}
/// <summary>
/// 验证WaitForProgress在完成前不会超过1.0
/// 验证WaitForProgress在完成前不会超过1.0
/// </summary>
[Test]
public void WaitForProgress_Should_Not_Exceed_1_Before_Completion()
@ -277,7 +271,7 @@ public class WaitForProgressTests
}
/// <summary>
/// 验证WaitForProgress的Update方法不影响未完成状态
/// 验证WaitForProgress的Update方法不影响未完成状态
/// </summary>
[Test]
public void WaitForProgress_Update_Should_Not_Affect_Before_Completion()
@ -291,4 +285,4 @@ public class WaitForProgressTests
wait.Update(0.1);
Assert.That(wait.IsDone, Is.False);
}
}
}

61
GFramework.Core.Tests/coroutine/WaitForTaskTests.cs
View File

@ -5,18 +5,20 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.coroutine;
/// <summary>
/// WaitForTask的单元测试类
/// 测试内容包括：
/// - WaitForTask初始化和等待
/// - WaitForTask<T>初始化、等待和结果获取
/// - 异常处理
/// - 边界条件
/// WaitForTask的单元测试类
/// 测试内容包括：
/// - WaitForTask初始化和等待
/// - WaitForTask
/// <T>
/// 初始化、等待和结果获取
/// - 异常处理
/// - 边界条件
/// </summary>
[TestFixture]
public class WaitForTaskTests
{
/// <summary>
/// 验证WaitForTask初始状态为未完成
/// 验证WaitForTask初始状态为未完成
/// </summary>
[Test]
public void WaitForTask_Should_Not_Be_Done_Initially()
@ -26,9 +28,9 @@ public class WaitForTaskTests
Assert.That(wait.IsDone, Is.False);
}
/// <summary>
/// 验证WaitForTask应该在Task完成后完成
/// 验证WaitForTask应该在Task完成后完成
/// </summary>
[Test]
public void WaitForTask_Should_Be_Done_After_Task_Completes()
@ -46,7 +48,7 @@ public class WaitForTaskTests
}
/// <summary>
/// 验证WaitForTask应该处理已完成的Task
/// 验证WaitForTask应该处理已完成的Task
/// </summary>
[Test]
public void WaitForTask_Should_Handle_Already_Completed_Task()
@ -63,7 +65,7 @@ public class WaitForTaskTests
}
/// <summary>
/// 验证WaitForTask应该处理失败的Task
/// 验证WaitForTask应该处理失败的Task
/// </summary>
[Test]
public void WaitForTask_Should_Handle_Faulted_Task()
@ -79,7 +81,7 @@ public class WaitForTaskTests
}
/// <summary>
/// 验证WaitForTask应该处理取消的Task
/// 验证WaitForTask应该处理取消的Task
/// </summary>
[Test]
public void WaitForTask_Should_Handle_Cancelled_Task()
@ -98,7 +100,7 @@ public class WaitForTaskTests
}
/// <summary>
/// 验证WaitForTask应该抛出ArgumentNullException当task为null
/// 验证WaitForTask应该抛出ArgumentNullException当task为null
/// </summary>
[Test]
public void WaitForTask_Should_Throw_ArgumentNullException_When_Task_Is_Null()
@ -107,7 +109,7 @@ public class WaitForTaskTests
}
/// <summary>
/// 验证WaitForTask<T>初始状态为未完成
/// 验证WaitForTask<T>初始状态为未完成
/// </summary>
[Test]
public void WaitForTaskOfT_Should_Not_Be_Done_Initially()
@ -119,7 +121,7 @@ public class WaitForTaskTests
}
/// <summary>
/// 验证WaitForTask<T>应该在Task完成后完成
/// 验证WaitForTask<T>应该在Task完成后完成
/// </summary>
[Test]
public void WaitForTaskOfT_Should_Be_Done_After_Task_Completes()
@ -137,7 +139,7 @@ public class WaitForTaskTests
}
/// <summary>
/// 验证WaitForTask<T>应该返回Task的结果
/// 验证WaitForTask<T>应该返回Task的结果
/// </summary>
[Test]
public void WaitForTaskOfT_Should_Return_Task_Result()
@ -153,7 +155,7 @@ public class WaitForTaskTests
}
/// <summary>
/// 验证WaitForTask<T>应该处理已完成的Task
/// 验证WaitForTask<T>应该处理已完成的Task
/// </summary>
[Test]
public void WaitForTaskOfT_Should_Handle_Already_Completed_Task()
@ -171,7 +173,7 @@ public class WaitForTaskTests
}
/// <summary>
/// 验证WaitForTask<T>应该处理失败的Task
/// 验证WaitForTask<T>应该处理失败的Task
/// </summary>
[Test]
public void WaitForTaskOfT_Should_Handle_Faulted_Task()
@ -185,11 +187,14 @@ public class WaitForTaskTests
Assert.That(wait.IsDone, Is.True);
Assert.Throws<InvalidOperationException>(() => { var _ = wait.Result; });
Assert.Throws<InvalidOperationException>(() =>
{
var _ = wait.Result;
});
}
/// <summary>
/// 验证WaitForTask<T>应该抛出ArgumentNullException当task为null
/// 验证WaitForTask<T>应该抛出ArgumentNullException当task为null
/// </summary>
[Test]
public void WaitForTaskOfT_Should_Throw_ArgumentNullException_When_Task_Is_Null()
@ -198,7 +203,7 @@ public class WaitForTaskTests
}
/// <summary>
/// 验证WaitForTask实现IYieldInstruction接口
/// 验证WaitForTask实现IYieldInstruction接口
/// </summary>
[Test]
public void WaitForTask_Should_Implement_IYieldInstruction()
@ -210,7 +215,7 @@ public class WaitForTaskTests
}
/// <summary>
/// 验证WaitForTask<T>实现IYieldInstruction接口
/// 验证WaitForTask<T>实现IYieldInstruction接口
/// </summary>
[Test]
public void WaitForTaskOfT_Should_Implement_IYieldInstruction()
@ -222,7 +227,7 @@ public class WaitForTaskTests
}
/// <summary>
/// 验证WaitForTask的Update方法不影响状态
/// 验证WaitForTask的Update方法不影响状态
/// </summary>
[Test]
public void WaitForTask_Update_Should_Not_Affect_State()
@ -238,7 +243,7 @@ public class WaitForTaskTests
}
/// <summary>
/// 验证WaitForTask<T>的Update方法不影响状态
/// 验证WaitForTask<T>的Update方法不影响状态
/// </summary>
[Test]
public void WaitForTaskOfT_Update_Should_Not_Affect_State()
@ -254,7 +259,7 @@ public class WaitForTaskTests
}
/// <summary>
/// 验证WaitForTask在延迟完成后能够正确等待
/// 验证WaitForTask在延迟完成后能够正确等待
/// </summary>
[Test]
public void WaitForTask_Should_Wait_For_Delayed_Task()
@ -271,7 +276,7 @@ public class WaitForTaskTests
}
/// <summary>
/// 验证WaitForTask<T>在异步操作完成后能够正确获取结果
/// 验证WaitForTask<T>在异步操作完成后能够正确获取结果
/// </summary>
[Test]
public async Task WaitForTaskOfT_Should_Get_Result_From_Async_Operation()
@ -294,7 +299,7 @@ public class WaitForTaskTests
}
/// <summary>
/// 验证WaitForTask应该处理长时间运行的Task
/// 验证WaitForTask应该处理长时间运行的Task
/// </summary>
[Test]
public void WaitForTask_Should_Handle_Long_Running_Task()
@ -308,4 +313,4 @@ public class WaitForTaskTests
Assert.That(wait.IsDone, Is.True);
}
}
}

79
GFramework.Core.Tests/coroutine/YieldInstructionTests.cs
View File

@ -5,20 +5,20 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.coroutine;
/// <summary>
/// 等待指令的单元测试类
/// 测试内容包括：
/// - Delay指令
/// - WaitOneFrame指令
/// - WaitForFrames指令
/// - WaitUntil指令
/// - WaitWhile指令
/// - WaitForCoroutine指令
/// 等待指令的单元测试类
/// 测试内容包括：
/// - Delay指令
/// - WaitOneFrame指令
/// - WaitForFrames指令
/// - WaitUntil指令
/// - WaitWhile指令
/// - WaitForCoroutine指令
/// </summary>
[TestFixture]
public class YieldInstructionTests
{
/// <summary>
/// 验证Delay指令初始状态为未完成
/// 验证Delay指令初始状态为未完成
/// </summary>
[Test]
public void Delay_Should_Not_Be_Done_Initially()
@ -29,7 +29,7 @@ public class YieldInstructionTests
}
/// <summary>
/// 验证Delay指令应该在指定时间后完成
/// 验证Delay指令应该在指定时间后完成
/// </summary>
[Test]
public void Delay_Should_Be_Done_After_Specified_Time()
@ -44,7 +44,7 @@ public class YieldInstructionTests
}
/// <summary>
/// 验证Delay指令可以处理零秒延迟
/// 验证Delay指令可以处理零秒延迟
/// </summary>
[Test]
public void Delay_Should_Handle_Zero_Seconds()
@ -55,7 +55,7 @@ public class YieldInstructionTests
}
/// <summary>
/// 验证Delay指令可以处理负数秒数
/// 验证Delay指令可以处理负数秒数
/// </summary>
[Test]
public void Delay_Should_Handle_Negative_Seconds()
@ -66,7 +66,7 @@ public class YieldInstructionTests
}
/// <summary>
/// 验证WaitOneFrame指令初始状态为未完成
/// 验证WaitOneFrame指令初始状态为未完成
/// </summary>
[Test]
public void WaitOneFrame_Should_Not_Be_Done_Initially()
@ -77,7 +77,7 @@ public class YieldInstructionTests
}
/// <summary>
/// 验证WaitOneFrame指令应该在第一次Update后完成
/// 验证WaitOneFrame指令应该在第一次Update后完成
/// </summary>
[Test]
public void WaitOneFrame_Should_Be_Done_After_First_Update()
@ -89,7 +89,7 @@ public class YieldInstructionTests
}
/// <summary>
/// 验证WaitForFrames指令初始状态为未完成
/// 验证WaitForFrames指令初始状态为未完成
/// </summary>
[Test]
public void WaitForFrames_Should_Not_Be_Done_Initially()
@ -100,7 +100,7 @@ public class YieldInstructionTests
}
/// <summary>
/// 验证WaitForFrames指令应该在指定帧数后完成
/// 验证WaitForFrames指令应该在指定帧数后完成
/// </summary>
[Test]
public void WaitForFrames_Should_Be_Done_After_Specified_Frames()
@ -118,7 +118,7 @@ public class YieldInstructionTests
}
/// <summary>
/// 验证WaitForFrames指令可以处理最小帧数1
/// 验证WaitForFrames指令可以处理最小帧数1
/// </summary>
[Test]
public void WaitForFrames_Should_Handle_Minimum_Frames_Of_1()
@ -130,7 +130,7 @@ public class YieldInstructionTests
}
/// <summary>
/// 验证WaitForFrames指令可以处理0帧数（会被修正为1）
/// 验证WaitForFrames指令可以处理0帧数（会被修正为1）
/// </summary>
[Test]
public void WaitForFrames_Should_Handle_Zero_Frames_As_1()
@ -142,7 +142,7 @@ public class YieldInstructionTests
}
/// <summary>
/// 验证WaitForFrames指令可以处理负数帧数（会被修正为1）
/// 验证WaitForFrames指令可以处理负数帧数（会被修正为1）
/// </summary>
[Test]
public void WaitForFrames_Should_Handle_Negative_Frames_As_1()
@ -154,7 +154,7 @@ public class YieldInstructionTests
}
/// <summary>
/// 验证WaitForFrames指令每次Update减少剩余帧数
/// 验证WaitForFrames指令每次Update减少剩余帧数
/// </summary>
[Test]
public void WaitForFrames_Should_Decrement_On_Each_Update()
@ -171,7 +171,7 @@ public class YieldInstructionTests
}
/// <summary>
/// 验证WaitUntil指令使用谓词函数
/// 验证WaitUntil指令使用谓词函数
/// </summary>
[Test]
public void WaitUntil_Should_Use_Predicate_Function()
@ -186,7 +186,7 @@ public class YieldInstructionTests
}
/// <summary>
/// 验证WaitUntil指令应该在条件满足时完成
/// 验证WaitUntil指令应该在条件满足时完成
/// </summary>
[Test]
public void WaitUntil_Should_Be_Done_When_Condition_Is_True()
@ -207,7 +207,7 @@ public class YieldInstructionTests
}
/// <summary>
/// 验证WaitUntil指令抛出ArgumentNullException当predicate为null
/// 验证WaitUntil指令抛出ArgumentNullException当predicate为null
/// </summary>
[Test]
public void WaitUntil_Should_Throw_ArgumentNullException_When_Predicate_Is_Null()
@ -216,7 +216,7 @@ public class YieldInstructionTests
}
/// <summary>
/// 验证WaitWhile指令使用谓词函数
/// 验证WaitWhile指令使用谓词函数
/// </summary>
[Test]
public void WaitWhile_Should_Use_Predicate_Function()
@ -246,7 +246,7 @@ public class YieldInstructionTests
}
/// <summary>
/// 验证WaitWhile指令应该在条件为假时完成
/// 验证WaitWhile指令应该在条件为假时完成
/// </summary>
[Test]
public void WaitWhile_Should_Be_Done_When_Condition_Is_False()
@ -261,7 +261,7 @@ public class YieldInstructionTests
}
/// <summary>
/// 验证WaitWhile指令应该在条件为真时持续等待
/// 验证WaitWhile指令应该在条件为真时持续等待
/// </summary>
[Test]
public void WaitWhile_Should_Continue_Waiting_While_Condition_Is_True()
@ -271,17 +271,14 @@ public class YieldInstructionTests
Assert.That(wait.IsDone, Is.False);
for (var i = 0; i < 10; i++)
{
Assert.That(wait.IsDone, Is.False);
}
for (var i = 0; i < 10; i++) Assert.That(wait.IsDone, Is.False);
continueWaiting = false;
Assert.That(wait.IsDone, Is.True);
}
/// <summary>
/// 验证WaitWhile指令抛出ArgumentNullException当predicate为null
/// 验证WaitWhile指令抛出ArgumentNullException当predicate为null
/// </summary>
[Test]
public void WaitWhile_Should_Throw_ArgumentNullException_When_Predicate_Is_Null()
@ -290,7 +287,7 @@ public class YieldInstructionTests
}
/// <summary>
/// 验证WaitForCoroutine指令初始状态为未完成
/// 验证WaitForCoroutine指令初始状态为未完成
/// </summary>
[Test]
public void WaitForCoroutine_Should_Not_Be_Done_Initially()
@ -301,7 +298,7 @@ public class YieldInstructionTests
}
/// <summary>
/// 验证WaitForCoroutine指令的Update方法不影响状态
/// 验证WaitForCoroutine指令的Update方法不影响状态
/// </summary>
[Test]
public void WaitForCoroutine_Update_Should_Not_Affect_State()
@ -316,7 +313,7 @@ public class YieldInstructionTests
}
/// <summary>
/// 验证Delay指令实现IYieldInstruction接口
/// 验证Delay指令实现IYieldInstruction接口
/// </summary>
[Test]
public void Delay_Should_Implement_IYieldInstruction_Interface()
@ -327,7 +324,7 @@ public class YieldInstructionTests
}
/// <summary>
/// 验证WaitOneFrame指令实现IYieldInstruction接口
/// 验证WaitOneFrame指令实现IYieldInstruction接口
/// </summary>
[Test]
public void WaitOneFrame_Should_Implement_IYieldInstruction_Interface()
@ -338,7 +335,7 @@ public class YieldInstructionTests
}
/// <summary>
/// 验证WaitForFrames指令实现IYieldInstruction接口
/// 验证WaitForFrames指令实现IYieldInstruction接口
/// </summary>
[Test]
public void WaitForFrames_Should_Implement_IYieldInstruction_Interface()
@ -349,7 +346,7 @@ public class YieldInstructionTests
}
/// <summary>
/// 验证WaitUntil指令实现IYieldInstruction接口
/// 验证WaitUntil指令实现IYieldInstruction接口
/// </summary>
[Test]
public void WaitUntil_Should_Implement_IYieldInstruction_Interface()
@ -360,7 +357,7 @@ public class YieldInstructionTests
}
/// <summary>
/// 验证WaitWhile指令实现IYieldInstruction接口
/// 验证WaitWhile指令实现IYieldInstruction接口
/// </summary>
[Test]
public void WaitWhile_Should_Implement_IYieldInstruction_Interface()
@ -371,7 +368,7 @@ public class YieldInstructionTests
}
/// <summary>
/// 验证WaitForCoroutine指令实现IYieldInstruction接口
/// 验证WaitForCoroutine指令实现IYieldInstruction接口
/// </summary>
[Test]
public void WaitForCoroutine_Should_Implement_IYieldInstruction_Interface()
@ -382,7 +379,7 @@ public class YieldInstructionTests
}
/// <summary>
/// 验证WaitUntil指令在Update后立即检查条件
/// 验证WaitUntil指令在Update后立即检查条件
/// </summary>
[Test]
public void WaitUntil_Should_Evaluate_Condition_Immediately()
@ -397,7 +394,7 @@ public class YieldInstructionTests
}
/// <summary>
/// 验证WaitWhile指令在Update后立即检查条件
/// 验证WaitWhile指令在Update后立即检查条件
/// </summary>
[Test]
public void WaitWhile_Should_Evaluate_Condition_Immediately()

38
GFramework.Core.Tests/environment/EnvironmentTests.cs
View File

@ -5,13 +5,13 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.environment;
/// <summary>
/// 测试环境相关的单元测试类，用于验证环境管理功能的正确性
/// 测试环境相关的单元测试类，用于验证环境管理功能的正确性
/// </summary>
[TestFixture]
public class EnvironmentTests
{
/// <summary>
/// 在每个测试方法执行前进行初始化设置
/// 在每个测试方法执行前进行初始化设置
/// </summary>
[SetUp]
public void SetUp()
@ -23,7 +23,7 @@ public class EnvironmentTests
private TestEnvironment _environment = null!;
/// <summary>
/// 验证默认环境的名称是否正确返回"Default"
/// 验证默认环境的名称是否正确返回"Default"
/// </summary>
[Test]
public void DefaultEnvironment_Name_Should_ReturnDefault()
@ -34,7 +34,7 @@ public class EnvironmentTests
}
/// <summary>
/// 验证默认环境的初始化方法不会抛出异常
/// 验证默认环境的初始化方法不会抛出异常
/// </summary>
[Test]
public void DefaultEnvironment_Initialize_Should_NotThrow()
@ -45,7 +45,7 @@ public class EnvironmentTests
}
/// <summary>
/// 验证当键存在时Get方法应该返回正确的值
/// 验证当键存在时Get方法应该返回正确的值
/// </summary>
[Test]
public void Get_Should_Return_Value_When_Key_Exists()
@ -58,7 +58,7 @@ public class EnvironmentTests
}
/// <summary>
/// 验证当键不存在时Get方法应该返回null
/// 验证当键不存在时Get方法应该返回null
/// </summary>
[Test]
public void Get_Should_ReturnNull_When_Key_Not_Exists()
@ -69,7 +69,7 @@ public class EnvironmentTests
}
/// <summary>
/// 验证当类型不匹配时Get方法应该返回null
/// 验证当类型不匹配时Get方法应该返回null
/// </summary>
[Test]
public void Get_Should_ReturnNull_When_Type_Does_Not_Match()
@ -82,7 +82,7 @@ public class EnvironmentTests
}
/// <summary>
/// 验证当键存在时TryGet方法应该返回true并输出正确的值
/// 验证当键存在时TryGet方法应该返回true并输出正确的值
/// </summary>
[Test]
public void TryGet_Should_ReturnTrue_And_Value_When_Key_Exists()
@ -96,7 +96,7 @@ public class EnvironmentTests
}
/// <summary>
/// 验证当键不存在时TryGet方法应该返回false且输出值为null
/// 验证当键不存在时TryGet方法应该返回false且输出值为null
/// </summary>
[Test]
public void TryGet_Should_ReturnFalse_When_Key_Not_Exists()
@ -108,7 +108,7 @@ public class EnvironmentTests
}
/// <summary>
/// 验证当类型不匹配时TryGet方法应该返回false且输出值为null
/// 验证当类型不匹配时TryGet方法应该返回false且输出值为null
/// </summary>
[Test]
public void TryGet_Should_ReturnFalse_When_Type_Does_Not_Match()
@ -122,7 +122,7 @@ public class EnvironmentTests
}
/// <summary>
/// 验证当键存在时GetRequired方法应该返回正确的值
/// 验证当键存在时GetRequired方法应该返回正确的值
/// </summary>
[Test]
public void GetRequired_Should_Return_Value_When_Key_Exists()
@ -135,7 +135,7 @@ public class EnvironmentTests
}
/// <summary>
/// 验证当键不存在时GetRequired方法应该抛出InvalidOperationException异常
/// 验证当键不存在时GetRequired方法应该抛出InvalidOperationException异常
/// </summary>
[Test]
public void GetRequired_Should_ThrowInvalidOperationException_When_Key_Not_Exists()
@ -145,7 +145,7 @@ public class EnvironmentTests
}
/// <summary>
/// 验证Register方法应该将值添加到字典中
/// 验证Register方法应该将值添加到字典中
/// </summary>
[Test]
public void Register_Should_Add_Value_To_Dictionary()
@ -158,7 +158,7 @@ public class EnvironmentTests
}
/// <summary>
/// 验证Register方法应该覆盖已存在的值
/// 验证Register方法应该覆盖已存在的值
/// </summary>
[Test]
public void Register_Should_Overwrite_Existing_Value()
@ -172,7 +172,7 @@ public class EnvironmentTests
}
/// <summary>
/// 验证通过IEnvironment接口的Register方法应该能够添加值
/// 验证通过IEnvironment接口的Register方法应该能够添加值
/// </summary>
[Test]
public void IEnvironment_Register_Should_Add_Value()
@ -187,17 +187,17 @@ public class EnvironmentTests
}
/// <summary>
/// 测试环境实现类，继承自EnvironmentBase
/// 测试环境实现类，继承自EnvironmentBase
/// </summary>
public class TestEnvironment : EnvironmentBase
{
/// <summary>
/// 获取环境名称
/// 获取环境名称
/// </summary>
public override string Name { get; } = "TestEnvironment";
/// <summary>
/// 注册键值对到环境中
/// 注册键值对到环境中
/// </summary>
/// <param name="key">要注册的键</param>
/// <param name="value">要注册的值</param>
@ -207,7 +207,7 @@ public class TestEnvironment : EnvironmentBase
}
/// <summary>
/// 初始化环境
/// 初始化环境
/// </summary>
public override void Initialize()
{

8
GFramework.Core.Tests/events/EasyEventsTests.cs
View File

@ -4,13 +4,13 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.events;
/// <summary>
/// EasyEvents功能测试类，用于验证事件系统的注册、触发和参数传递功能
/// EasyEvents功能测试类，用于验证事件系统的注册、触发和参数传递功能
/// </summary>
[TestFixture]
public class EasyEventsTests
{
/// <summary>
/// 测试用例初始化方法，在每个测试方法执行前设置EasyEvents实例
/// 测试用例初始化方法，在每个测试方法执行前设置EasyEvents实例
/// </summary>
[SetUp]
public void SetUp()
@ -21,7 +21,7 @@ public class EasyEventsTests
private EasyEvents _easyEvents = null!;
/// <summary>
/// 测试单参数事件的功能，验证事件能够正确接收并传递int类型参数
/// 测试单参数事件的功能，验证事件能够正确接收并传递int类型参数
/// </summary>
[Test]
public void Get_EventT_Should_Trigger_With_Parameter()
@ -38,7 +38,7 @@ public class EasyEventsTests
}
/// <summary>
/// 测试双参数事件的功能，验证事件能够正确接收并传递int和string类型的参数
/// 测试双参数事件的功能，验证事件能够正确接收并传递int和string类型的参数
/// </summary>
[Test]
public void Get_EventTTK_Should_Trigger_With_Two_Parameters()

18
GFramework.Core.Tests/events/EventBusTests.cs
View File

@ -4,13 +4,13 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.events;
/// <summary>
/// EventBus测试类，用于验证事件总线的各种功能
/// EventBus测试类，用于验证事件总线的各种功能
/// </summary>
[TestFixture]
public class EventBusTests
{
/// <summary>
/// 测试设置方法，在每个测试方法执行前初始化EventBus实例
/// 测试设置方法，在每个测试方法执行前初始化EventBus实例
/// </summary>
[SetUp]
public void SetUp()
@ -21,8 +21,8 @@ public class EventBusTests
private EventBus _eventBus = null!;
/// <summary>
/// 测试注册事件处理器的功能
/// 验证注册的处理器能够在发送对应事件时被正确调用
/// 测试注册事件处理器的功能
/// 验证注册的处理器能够在发送对应事件时被正确调用
/// </summary>
[Test]
public void Register_Should_Add_Handler()
@ -36,8 +36,8 @@ public class EventBusTests
}
/// <summary>
/// 测试注销事件处理器的功能
/// 验证已注册的处理器在注销后不会再被调用
/// 测试注销事件处理器的功能
/// 验证已注册的处理器在注销后不会再被调用
/// </summary>
[Test]
public void UnRegister_Should_Remove_Handler()
@ -57,8 +57,8 @@ public class EventBusTests
}
/// <summary>
/// 测试发送事件时调用所有处理器的功能
/// 验证同一事件类型的多个处理器都能被正确调用
/// 测试发送事件时调用所有处理器的功能
/// 验证同一事件类型的多个处理器都能被正确调用
/// </summary>
[Test]
public void SendEvent_Should_Invoke_All_Handlers()
@ -78,7 +78,7 @@ public class EventBusTests
}
/// <summary>
/// EventBus测试专用事件类
/// EventBus测试专用事件类
/// </summary>
public class EventBusTestsEvent
{

20
GFramework.Core.Tests/events/EventTests.cs
View File

@ -4,13 +4,13 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.events;
/// <summary>
/// 测试事件系统功能的测试类
/// 测试事件系统功能的测试类
/// </summary>
[TestFixture]
public class EventTests
{
/// <summary>
/// 在每个测试方法执行前进行初始化设置
/// 在每个测试方法执行前进行初始化设置
/// </summary>
[SetUp]
public void SetUp()
@ -25,7 +25,7 @@ public class EventTests
private Event<int, string> _eventIntString = null!;
/// <summary>
/// 测试EasyEvent注册功能是否正确添加处理器
/// 测试EasyEvent注册功能是否正确添加处理器
/// </summary>
[Test]
public void EasyEvent_Register_Should_Add_Handler()
@ -39,7 +39,7 @@ public class EventTests
}
/// <summary>
/// 测试EasyEvent取消注册功能是否正确移除处理器
/// 测试EasyEvent取消注册功能是否正确移除处理器
/// </summary>
[Test]
public void EasyEvent_UnRegister_Should_Remove_Handler()
@ -57,7 +57,7 @@ public class EventTests
}
/// <summary>
/// 测试EasyEvent多个处理器是否都能被调用
/// 测试EasyEvent多个处理器是否都能被调用
/// </summary>
[Test]
public void EasyEvent_Multiple_Handlers_Should_All_Be_Called()
@ -75,7 +75,7 @@ public class EventTests
}
/// <summary>
/// 测试带泛型参数的事件注册功能是否正确添加处理器
/// 测试带泛型参数的事件注册功能是否正确添加处理器
/// </summary>
[Test]
public void EventT_Register_Should_Add_Handler()
@ -89,7 +89,7 @@ public class EventTests
}
/// <summary>
/// 测试带泛型参数的事件取消注册功能是否正确移除处理器
/// 测试带泛型参数的事件取消注册功能是否正确移除处理器
/// </summary>
[Test]
public void EventT_UnRegister_Should_Remove_Handler()
@ -107,7 +107,7 @@ public class EventTests
}
/// <summary>
/// 测试带泛型参数的事件多个处理器是否都能被调用
/// 测试带泛型参数的事件多个处理器是否都能被调用
/// </summary>
[Test]
public void EventT_Multiple_Handlers_Should_All_Be_Called()
@ -125,7 +125,7 @@ public class EventTests
}
/// <summary>
/// 测试带两个泛型参数的事件注册功能是否正确添加处理器
/// 测试带两个泛型参数的事件注册功能是否正确添加处理器
/// </summary>
[Test]
public void EventTTK_Register_Should_Add_Handler()
@ -145,7 +145,7 @@ public class EventTests
}
/// <summary>
/// 测试带两个泛型参数的事件取消注册功能是否正确移除处理器
/// 测试带两个泛型参数的事件取消注册功能是否正确移除处理器
/// </summary>
[Test]
public void EventTTK_UnRegister_Should_Remove_Handler()

18
GFramework.Core.Tests/events/OrEventTests.cs
View File

@ -4,14 +4,14 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.events;
/// <summary>
/// 测试OrEvent类的功能，验证其在多个事件中的逻辑或操作行为
/// 测试OrEvent类的功能，验证其在多个事件中的逻辑或操作行为
/// </summary>
[TestFixture]
public class OrEventTests
{
/// <summary>
/// 测试当任意一个事件触发时，OrEvent应该被触发
/// 验证基本的OR逻辑功能
/// 测试当任意一个事件触发时，OrEvent应该被触发
/// 验证基本的OR逻辑功能
/// </summary>
[Test]
public void OrEvent_Should_Trigger_When_Any_Event_Fires()
@ -32,8 +32,8 @@ public class OrEventTests
}
/// <summary>
/// 测试当第二个事件触发时，OrEvent应该被触发
/// 验证OR逻辑对所有注册事件都有效
/// 测试当第二个事件触发时，OrEvent应该被触发
/// 验证OR逻辑对所有注册事件都有效
/// </summary>
[Test]
public void OrEvent_Should_Trigger_When_Second_Event_Fires()
@ -54,8 +54,8 @@ public class OrEventTests
}
/// <summary>
/// 测试OrEvent支持多个处理程序
/// 验证单个OrEvent可以注册多个回调函数
/// 测试OrEvent支持多个处理程序
/// 验证单个OrEvent可以注册多个回调函数
/// </summary>
[Test]
public void OrEvent_Should_Support_Multiple_Handlers()
@ -78,8 +78,8 @@ public class OrEventTests
}
/// <summary>
/// 测试UnRegister方法应该移除处理程序
/// 验证注销功能能够正确移除已注册的回调函数
/// 测试UnRegister方法应该移除处理程序
/// 验证注销功能能够正确移除已注册的回调函数
/// </summary>
[Test]
public void OrEvent_UnRegister_Should_Remove_Handler()

22
GFramework.Core.Tests/events/UnRegisterTests.cs
View File

@ -5,13 +5,13 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.events;
/// <summary>
/// 注销功能测试类，用于测试不同类型的注销行为
/// 注销功能测试类，用于测试不同类型的注销行为
/// </summary>
[TestFixture]
public class UnRegisterTests
{
/// <summary>
/// 测试DefaultUnRegister在调用注销时是否正确触发回调函数
/// 测试DefaultUnRegister在调用注销时是否正确触发回调函数
/// </summary>
[Test]
public void DefaultUnRegister_Should_InvokeCallback_When_UnRegisterCalled()
@ -25,7 +25,7 @@ public class UnRegisterTests
}
/// <summary>
/// 测试DefaultUnRegister在注销后是否清除回调函数，防止重复执行
/// 测试DefaultUnRegister在注销后是否清除回调函数，防止重复执行
/// </summary>
[Test]
public void DefaultUnRegister_Should_ClearCallback_After_UnRegister()
@ -40,7 +40,7 @@ public class UnRegisterTests
}
/// <summary>
/// 测试DefaultUnRegister在传入空回调函数时不会抛出异常
/// 测试DefaultUnRegister在传入空回调函数时不会抛出异常
/// </summary>
[Test]
public void DefaultUnRegister_WithNullCallback_Should_NotThrow()
@ -51,12 +51,12 @@ public class UnRegisterTests
}
/// <summary>
/// 测试BindablePropertyUnRegister是否能正确从属性中注销事件处理器
/// 测试BindablePropertyUnRegister是否能正确从属性中注销事件处理器
/// </summary>
[Test]
public void BindablePropertyUnRegister_Should_UnRegister_From_Property()
{
var property = new BindableProperty<int>(0);
var property = new BindableProperty<int>();
var callCount = 0;
Action<int> handler = _ => { callCount++; };
@ -71,12 +71,12 @@ public class UnRegisterTests
}
/// <summary>
/// 测试BindablePropertyUnRegister在注销后是否清除内部引用
/// 测试BindablePropertyUnRegister在注销后是否清除内部引用
/// </summary>
[Test]
public void BindablePropertyUnRegister_Should_Clear_References()
{
var property = new BindableProperty<int>(0);
var property = new BindableProperty<int>();
Action<int> handler = _ => { };
var unRegister = new BindablePropertyUnRegister<int>(property, handler);
@ -89,7 +89,7 @@ public class UnRegisterTests
}
/// <summary>
/// 测试BindablePropertyUnRegister在传入空属性时不会抛出异常
/// 测试BindablePropertyUnRegister在传入空属性时不会抛出异常
/// </summary>
[Test]
public void BindablePropertyUnRegister_WithNull_Property_Should_NotThrow()
@ -101,12 +101,12 @@ public class UnRegisterTests
}
/// <summary>
/// 测试BindablePropertyUnRegister在传入空处理器时不会抛出异常
/// 测试BindablePropertyUnRegister在传入空处理器时不会抛出异常
/// </summary>
[Test]
public void BindablePropertyUnRegister_WithNull_Handler_Should_NotThrow()
{
var property = new BindableProperty<int>(0);
var property = new BindableProperty<int>();
var unRegister = new BindablePropertyUnRegister<int>(property, null!);
Assert.DoesNotThrow(() => unRegister.UnRegister());

36
GFramework.Core.Tests/extensions/ObjectExtensionsTests.cs
View File

@ -4,13 +4,13 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.extensions;
/// <summary>
/// 测试ObjectExtensions扩展方法的功能
/// 测试ObjectExtensions扩展方法的功能
/// </summary>
[TestFixture]
public class ObjectExtensionsTests
{
/// <summary>
/// 验证IfType方法在类型匹配时执行指定操作
/// 验证IfType方法在类型匹配时执行指定操作
/// </summary>
[Test]
public void IfType_Should_Execute_Action_When_Type_Matches()
@ -24,7 +24,7 @@ public class ObjectExtensionsTests
}
/// <summary>
/// 验证IfType方法在类型不匹配时不执行指定操作
/// 验证IfType方法在类型不匹配时不执行指定操作
/// </summary>
[Test]
public void IfType_Should_Not_Execute_Action_When_Type_Does_Not_Match()
@ -38,7 +38,7 @@ public class ObjectExtensionsTests
}
/// <summary>
/// 验证IfType方法在类型匹配且谓词条件为真时执行指定操作
/// 验证IfType方法在类型匹配且谓词条件为真时执行指定操作
/// </summary>
[Test]
public void IfType_WithPredicate_Should_Execute_When_Type_Matches_And_Predicate_True()
@ -52,7 +52,7 @@ public class ObjectExtensionsTests
}
/// <summary>
/// 验证IfType方法在谓词条件为假时不执行指定操作
/// 验证IfType方法在谓词条件为假时不执行指定操作
/// </summary>
[Test]
public void IfType_WithPredicate_Should_Not_Execute_When_Predicate_False()
@ -66,7 +66,7 @@ public class ObjectExtensionsTests
}
/// <summary>
/// 验证IfType方法在类型匹配时执行匹配操作，在类型不匹配时执行不匹配操作
/// 验证IfType方法在类型匹配时执行匹配操作，在类型不匹配时执行不匹配操作
/// </summary>
[Test]
public void IfType_WithBoth_Actions_Should_Execute_Correct_Action()
@ -85,7 +85,7 @@ public class ObjectExtensionsTests
}
/// <summary>
/// 验证IfType方法在类型匹配时返回转换结果
/// 验证IfType方法在类型匹配时返回转换结果
/// </summary>
[Test]
public void IfType_WithResult_Should_Return_Value_When_Type_Matches()
@ -98,7 +98,7 @@ public class ObjectExtensionsTests
}
/// <summary>
/// 验证IfType方法在类型不匹配时返回默认值
/// 验证IfType方法在类型不匹配时返回默认值
/// </summary>
[Test]
public void IfType_WithResult_Should_Return_Default_When_Type_Does_Not_Match()
@ -111,7 +111,7 @@ public class ObjectExtensionsTests
}
/// <summary>
/// 验证As方法在类型匹配时返回实例
/// 验证As方法在类型匹配时返回实例
/// </summary>
[Test]
public void As_Should_Return_Instance_When_Type_Matches()
@ -125,7 +125,7 @@ public class ObjectExtensionsTests
}
/// <summary>
/// 验证As方法在类型不匹配时返回null
/// 验证As方法在类型不匹配时返回null
/// </summary>
[Test]
public void As_Should_Return_Null_When_Type_Does_Not_Match()
@ -138,7 +138,7 @@ public class ObjectExtensionsTests
}
/// <summary>
/// 验证Do方法执行操作并返回对象本身
/// 验证Do方法执行操作并返回对象本身
/// </summary>
[Test]
public void Do_Should_Execute_Action_And_Return_Object()
@ -152,7 +152,7 @@ public class ObjectExtensionsTests
}
/// <summary>
/// 验证Do方法支持链式调用
/// 验证Do方法支持链式调用
/// </summary>
[Test]
public void Do_Should_Support_Chaining()
@ -167,7 +167,7 @@ public class ObjectExtensionsTests
}
/// <summary>
/// 验证SwitchType方法执行匹配的处理器
/// 验证SwitchType方法执行匹配的处理器
/// </summary>
[Test]
public void SwitchType_Should_Execute_Matching_Handler()
@ -184,7 +184,7 @@ public class ObjectExtensionsTests
}
/// <summary>
/// 验证SwitchType方法只执行第一个匹配的处理器
/// 验证SwitchType方法只执行第一个匹配的处理器
/// </summary>
[Test]
public void SwitchType_Should_Execute_First_Matching_Handler()
@ -201,7 +201,7 @@ public class ObjectExtensionsTests
}
/// <summary>
/// 验证SwitchType方法在没有匹配项时不执行任何处理器
/// 验证SwitchType方法在没有匹配项时不执行任何处理器
/// </summary>
[Test]
public void SwitchType_Should_Not_Execute_When_No_Match()
@ -219,17 +219,17 @@ public class ObjectExtensionsTests
}
/// <summary>
/// 测试用的简单类
/// 测试用的简单类
/// </summary>
public class TestClass
{
/// <summary>
/// 获取或设置整数值
/// 获取或设置整数值
/// </summary>
public int Value { get; set; }
/// <summary>
/// 获取或设置名称字符串
/// 获取或设置名称字符串
/// </summary>
public string Name { get; set; } = string.Empty;
}

20
GFramework.Core.Tests/extensions/UnRegisterListExtensionTests.cs
View File

@ -6,13 +6,13 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.extensions;
/// <summary>
/// 测试UnRegisterList扩展方法的功能
/// 测试UnRegisterList扩展方法的功能
/// </summary>
[TestFixture]
public class UnRegisterListExtensionTests
{
/// <summary>
/// 在每个测试方法执行前初始化测试环境
/// 在每个测试方法执行前初始化测试环境
/// </summary>
[SetUp]
public void SetUp()
@ -23,7 +23,7 @@ public class UnRegisterListExtensionTests
private TestUnRegisterList _unRegisterList = null!;
/// <summary>
/// 验证AddToUnregisterList方法能够正确将元素添加到列表中
/// 验证AddToUnregisterList方法能够正确将元素添加到列表中
/// </summary>
[Test]
public void AddToUnregisterList_Should_Add_To_List()
@ -36,7 +36,7 @@ public class UnRegisterListExtensionTests
}
/// <summary>
/// 验证AddToUnregisterList方法能够正确添加多个元素到列表中
/// 验证AddToUnregisterList方法能够正确添加多个元素到列表中
/// </summary>
[Test]
public void AddToUnregisterList_Should_Add_Multiple_Elements()
@ -53,7 +53,7 @@ public class UnRegisterListExtensionTests
}
/// <summary>
/// 验证UnRegisterAll方法能够正确注销所有元素
/// 验证UnRegisterAll方法能够正确注销所有元素
/// </summary>
[Test]
public void UnRegisterAll_Should_UnRegister_All_Elements()
@ -79,7 +79,7 @@ public class UnRegisterListExtensionTests
}
/// <summary>
/// 验证UnRegisterAll方法在执行后会清空列表
/// 验证UnRegisterAll方法在执行后会清空列表
/// </summary>
[Test]
public void UnRegisterAll_Should_Clear_List()
@ -94,7 +94,7 @@ public class UnRegisterListExtensionTests
}
/// <summary>
/// 验证UnRegisterAll方法在空列表情况下不会抛出异常
/// 验证UnRegisterAll方法在空列表情况下不会抛出异常
/// </summary>
[Test]
public void UnRegisterAll_Should_Not_Throw_When_Empty()
@ -103,7 +103,7 @@ public class UnRegisterListExtensionTests
}
/// <summary>
/// 验证UnRegisterAll方法对每个元素只调用一次注销操作
/// 验证UnRegisterAll方法对每个元素只调用一次注销操作
/// </summary>
[Test]
public void UnRegisterAll_Should_Invoke_Once_Per_Element()
@ -121,12 +121,12 @@ public class UnRegisterListExtensionTests
}
/// <summary>
/// 测试用的UnRegisterList实现类，用于验证扩展方法功能
/// 测试用的UnRegisterList实现类，用于验证扩展方法功能
/// </summary>
public class TestUnRegisterList : IUnRegisterList
{
/// <summary>
/// 获取或设置注销列表
/// 获取或设置注销列表
/// </summary>
public IList<IUnRegister> UnregisterList { get; } = new List<IUnRegister>();
}

56
GFramework.Core.Tests/ioc/IocContainerTests.cs
View File

@ -7,13 +7,13 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.ioc;
/// <summary>
/// 测试 IoC 容器功能的单元测试类
/// 测试 IoC 容器功能的单元测试类
/// </summary>
[TestFixture]
public class IocContainerTests
{
/// <summary>
/// 在每个测试方法执行前进行设置
/// 在每个测试方法执行前进行设置
/// </summary>
[SetUp]
public void SetUp()
@ -33,7 +33,7 @@ public class IocContainerTests
private readonly Dictionary<Type, object> _mockContextServices = new();
/// <summary>
/// 测试注册单例实例的功能
/// 测试注册单例实例的功能
/// </summary>
[Test]
public void RegisterSingleton_Should_Register_Instance()
@ -44,7 +44,7 @@ public class IocContainerTests
}
/// <summary>
/// 测试重复注册单例时应抛出 InvalidOperationException 异常
/// 测试重复注册单例时应抛出 InvalidOperationException 异常
/// </summary>
[Test]
public void RegisterSingleton_WithDuplicate_Should_ThrowInvalidOperationException()
@ -58,7 +58,7 @@ public class IocContainerTests
}
/// <summary>
/// 测试在容器冻结后注册单例时应抛出 InvalidOperationException 异常
/// 测试在容器冻结后注册单例时应抛出 InvalidOperationException 异常
/// </summary>
[Test]
public void RegisterSingleton_AfterFreeze_Should_ThrowInvalidOperationException()
@ -70,7 +70,7 @@ public class IocContainerTests
}
/// <summary>
/// 测试注册多样性实例到所有类型的功能
/// 测试注册多样性实例到所有类型的功能
/// </summary>
[Test]
public void RegisterPlurality_Should_Register_Instance_To_All_Types()
@ -84,7 +84,7 @@ public class IocContainerTests
}
/// <summary>
/// 测试在容器冻结后注册多样性实例时应抛出 InvalidOperationException 异常
/// 测试在容器冻结后注册多样性实例时应抛出 InvalidOperationException 异常
/// </summary>
[Test]
public void RegisterPlurality_AfterFreeze_Should_ThrowInvalidOperationException()
@ -96,7 +96,7 @@ public class IocContainerTests
}
/// <summary>
/// 测试泛型注册实例的功能
/// 测试泛型注册实例的功能
/// </summary>
[Test]
public void Register_Generic_Should_Register_Instance()
@ -109,7 +109,7 @@ public class IocContainerTests
}
/// <summary>
/// 测试在容器冻结后使用泛型注册时应抛出 InvalidOperationException 异常
/// 测试在容器冻结后使用泛型注册时应抛出 InvalidOperationException 异常
/// </summary>
[Test]
public void Register_Generic_AfterFreeze_Should_ThrowInvalidOperationException()
@ -121,7 +121,7 @@ public class IocContainerTests
}
/// <summary>
/// 测试按类型注册实例的功能
/// 测试按类型注册实例的功能
/// </summary>
[Test]
public void Register_Type_Should_Register_Instance()
@ -134,7 +134,7 @@ public class IocContainerTests
}
/// <summary>
/// 测试获取第一个实例的功能
/// 测试获取第一个实例的功能
/// </summary>
[Test]
public void Get_Should_Return_First_Instance()
@ -149,7 +149,7 @@ public class IocContainerTests
}
/// <summary>
/// 测试当没有实例时获取应返回 null 的功能
/// 测试当没有实例时获取应返回 null 的功能
/// </summary>
[Test]
public void Get_WithNoInstances_Should_ReturnNull()
@ -160,7 +160,7 @@ public class IocContainerTests
}
/// <summary>
/// 测试获取必需的单个实例的功能
/// 测试获取必需的单个实例的功能
/// </summary>
[Test]
public void GetRequired_Should_Return_Single_Instance()
@ -175,7 +175,7 @@ public class IocContainerTests
}
/// <summary>
/// 测试当没有实例时获取必需实例应抛出 InvalidOperationException 异常
/// 测试当没有实例时获取必需实例应抛出 InvalidOperationException 异常
/// </summary>
[Test]
public void GetRequired_WithNoInstances_Should_ThrowInvalidOperationException()
@ -184,7 +184,7 @@ public class IocContainerTests
}
/// <summary>
/// 测试当有多个实例时获取必需实例应抛出 InvalidOperationException 异常
/// 测试当有多个实例时获取必需实例应抛出 InvalidOperationException 异常
/// </summary>
[Test]
public void GetRequired_WithMultipleInstances_Should_ThrowInvalidOperationException()
@ -196,7 +196,7 @@ public class IocContainerTests
}
/// <summary>
/// 测试获取所有实例的功能
/// 测试获取所有实例的功能
/// </summary>
[Test]
public void GetAll_Should_Return_All_Instances()
@ -215,7 +215,7 @@ public class IocContainerTests
}
/// <summary>
/// 测试当没有实例时获取所有实例应返回空数组的功能
/// 测试当没有实例时获取所有实例应返回空数组的功能
/// </summary>
[Test]
public void GetAll_WithNoInstances_Should_Return_Empty_Array()
@ -226,7 +226,7 @@ public class IocContainerTests
}
/// <summary>
/// 测试获取排序后的所有实例的功能
/// 测试获取排序后的所有实例的功能
/// </summary>
[Test]
public void GetAllSorted_Should_Return_Sorted_Instances()
@ -244,7 +244,7 @@ public class IocContainerTests
}
/// <summary>
/// 测试当存在实例时检查包含关系应返回 true 的功能
/// 测试当存在实例时检查包含关系应返回 true 的功能
/// </summary>
[Test]
public void Contains_WithExistingInstance_Should_ReturnTrue()
@ -256,7 +256,7 @@ public class IocContainerTests
}
/// <summary>
/// 测试当不存在实例时检查包含关系应返回 false 的功能
/// 测试当不存在实例时检查包含关系应返回 false 的功能
/// </summary>
[Test]
public void Contains_WithNoInstances_Should_ReturnFalse()
@ -265,7 +265,7 @@ public class IocContainerTests
}
/// <summary>
/// 测试当实例存在时检查实例包含关系应返回 true 的功能
/// 测试当实例存在时检查实例包含关系应返回 true 的功能
/// </summary>
[Test]
public void ContainsInstance_WithExistingInstance_Should_ReturnTrue()
@ -277,7 +277,7 @@ public class IocContainerTests
}
/// <summary>
/// 测试当实例不存在时检查实例包含关系应返回 false 的功能
/// 测试当实例不存在时检查实例包含关系应返回 false 的功能
/// </summary>
[Test]
public void ContainsInstance_WithNonExistingInstance_Should_ReturnFalse()
@ -288,7 +288,7 @@ public class IocContainerTests
}
/// <summary>
/// 测试清除所有实例的功能
/// 测试清除所有实例的功能
/// </summary>
[Test]
public void Clear_Should_Remove_All_Instances()
@ -302,7 +302,7 @@ public class IocContainerTests
}
/// <summary>
/// 测试冻结容器以防止进一步注册的功能
/// 测试冻结容器以防止进一步注册的功能
/// </summary>
[Test]
public void Freeze_Should_Prevent_Further_Registrations()
@ -316,7 +316,7 @@ public class IocContainerTests
}
/// <summary>
/// 测试注册系统实例的功能
/// 测试注册系统实例的功能
/// </summary>
[Test]
public void RegisterSystem_Should_Register_Instance()
@ -330,17 +330,17 @@ public class IocContainerTests
}
/// <summary>
/// 服务接口定义
/// 服务接口定义
/// </summary>
public interface IService;
/// <summary>
/// 测试服务类，实现 IService 接口
/// 测试服务类，实现 IService 接口
/// </summary>
public sealed class TestService : IService
{
/// <summary>
/// 获取或设置优先级
/// 获取或设置优先级
/// </summary>
public int Priority { get; set; }
}

74
GFramework.Core.Tests/logging/ConsoleLoggerTests.cs
View File

@ -6,14 +6,14 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.logging;
/// <summary>
/// 测试ConsoleLogger类的功能和行为的单元测试类
/// 测试ConsoleLogger类的功能和行为的单元测试类
/// </summary>
[TestFixture]
public class ConsoleLoggerTests
{
/// <summary>
/// 在每个测试方法执行前设置测试环境
/// 创建StringWriter和ConsoleLogger实例用于测试
/// 在每个测试方法执行前设置测试环境
/// 创建StringWriter和ConsoleLogger实例用于测试
/// </summary>
[SetUp]
public void SetUp()
@ -23,8 +23,8 @@ public class ConsoleLoggerTests
}
/// <summary>
/// 在每个测试方法执行后清理测试资源
/// 释放StringWriter资源
/// 在每个测试方法执行后清理测试资源
/// 释放StringWriter资源
/// </summary>
[TearDown]
public void TearDown()
@ -36,8 +36,8 @@ public class ConsoleLoggerTests
private ConsoleLogger _logger = null!;
/// <summary>
/// 测试使用默认名称构造函数时是否正确使用根日志器名称
/// 验证当未指定名称时，日志器使用"ROOT"作为默认名称
/// 测试使用默认名称构造函数时是否正确使用根日志器名称
/// 验证当未指定名称时，日志器使用"ROOT"作为默认名称
/// </summary>
[Test]
public void Constructor_WithDefaultName_ShouldUseRootLoggerName()
@ -48,8 +48,8 @@ public class ConsoleLoggerTests
}
/// <summary>
/// 测试使用自定义名称构造函数时是否正确使用自定义名称
/// 验证构造函数能够正确设置并返回指定的日志器名称
/// 测试使用自定义名称构造函数时是否正确使用自定义名称
/// 验证构造函数能够正确设置并返回指定的日志器名称
/// </summary>
[Test]
public void Constructor_WithCustomName_ShouldUseCustomName()
@ -60,8 +60,8 @@ public class ConsoleLoggerTests
}
/// <summary>
/// 测试使用自定义最小级别构造函数时是否正确遵循最小日志级别
/// 验证只有达到或超过最小级别的日志消息才会被记录
/// 测试使用自定义最小级别构造函数时是否正确遵循最小日志级别
/// 验证只有达到或超过最小级别的日志消息才会被记录
/// </summary>
[Test]
public void Constructor_WithCustomMinLevel_ShouldRespectMinLevel()
@ -77,8 +77,8 @@ public class ConsoleLoggerTests
}
/// <summary>
/// 测试使用自定义写入器构造函数时是否将日志写入到自定义写入器
/// 验证日志消息能够正确写入到指定的StringWriter中
/// 测试使用自定义写入器构造函数时是否将日志写入到自定义写入器
/// 验证日志消息能够正确写入到指定的StringWriter中
/// </summary>
[Test]
public void Constructor_WithCustomWriter_ShouldWriteToCustomWriter()
@ -90,8 +90,8 @@ public class ConsoleLoggerTests
}
/// <summary>
/// 测试写入操作是否包含时间戳信息
/// 验证每条日志消息都包含格式化的日期时间信息
/// 测试写入操作是否包含时间戳信息
/// 验证每条日志消息都包含格式化的日期时间信息
/// </summary>
[Test]
public void Write_ShouldIncludeTimestamp()
@ -103,8 +103,8 @@ public class ConsoleLoggerTests
}
/// <summary>
/// 测试写入操作是否包含日志级别信息
/// 验证不同级别的日志消息都能正确显示对应的级别标识
/// 测试写入操作是否包含日志级别信息
/// 验证不同级别的日志消息都能正确显示对应的级别标识
/// </summary>
[Test]
public void Write_ShouldIncludeLevel()
@ -121,8 +121,8 @@ public class ConsoleLoggerTests
}
/// <summary>
/// 测试写入操作是否包含日志器名称
/// 验证日志输出中包含创建时指定的日志器名称
/// 测试写入操作是否包含日志器名称
/// 验证日志输出中包含创建时指定的日志器名称
/// </summary>
[Test]
public void Write_ShouldIncludeLoggerName()
@ -134,8 +134,8 @@ public class ConsoleLoggerTests
}
/// <summary>
/// 测试写入操作在包含异常时是否正确包含异常信息
/// 验证异常的详细信息能够正确记录在日志中
/// 测试写入操作在包含异常时是否正确包含异常信息
/// 验证异常的详细信息能够正确记录在日志中
/// </summary>
[Test]
public void Write_WithException_ShouldIncludeException()
@ -149,8 +149,8 @@ public class ConsoleLoggerTests
}
/// <summary>
/// 测试写入多行日志时是否正确格式化
/// 验证多条日志消息能够正确分行显示且包含正确的级别信息
/// 测试写入多行日志时是否正确格式化
/// 验证多条日志消息能够正确分行显示且包含正确的级别信息
/// </summary>
[Test]
public void Write_WithMultipleLines_ShouldFormatCorrectly()
@ -169,8 +169,8 @@ public class ConsoleLoggerTests
}
/// <summary>
/// 测试写入格式化消息时是否正确格式化
/// 验证带参数的消息格式化功能正常工作
/// 测试写入格式化消息时是否正确格式化
/// 验证带参数的消息格式化功能正常工作
/// </summary>
[Test]
public void Write_WithFormattedMessage_ShouldFormatCorrectly()
@ -182,8 +182,8 @@ public class ConsoleLoggerTests
}
/// <summary>
/// 测试写入操作是否遵循最小日志级别限制
/// 验证低于最小级别的日志消息不会被记录
/// 测试写入操作是否遵循最小日志级别限制
/// 验证低于最小级别的日志消息不会被记录
/// </summary>
[Test]
public void Write_ShouldRespectMinLevel()
@ -199,8 +199,8 @@ public class ConsoleLoggerTests
}
/// <summary>
/// 测试启用颜色功能时是否不影响输出内容
/// 验证即使颜色功能被禁用，日志内容仍然正确记录
/// 测试启用颜色功能时是否不影响输出内容
/// 验证即使颜色功能被禁用，日志内容仍然正确记录
/// </summary>
[Test]
public void Write_WithColorsEnabled_ShouldNotAffectOutputContent()
@ -214,8 +214,8 @@ public class ConsoleLoggerTests
}
/// <summary>
/// 测试所有日志级别是否都能正确格式化
/// 验证从Trace到Fatal的所有日志级别都能正确显示
/// 测试所有日志级别是否都能正确格式化
/// 验证从Trace到Fatal的所有日志级别都能正确显示
/// </summary>
[Test]
public void Write_AllLogLevels_ShouldFormatCorrectly()
@ -235,8 +235,8 @@ public class ConsoleLoggerTests
}
/// <summary>
/// 测试写入嵌套异常时是否包含完整的异常信息
/// 验证嵌套异常的所有层级信息都能被正确记录
/// 测试写入嵌套异常时是否包含完整的异常信息
/// 验证嵌套异常的所有层级信息都能被正确记录
/// </summary>
[Test]
public void Write_WithNestedException_ShouldIncludeFullException()
@ -253,8 +253,8 @@ public class ConsoleLoggerTests
}
/// <summary>
/// 测试使用空写入器时是否不会抛出异常
/// 验证当传入null写入器时，日志器能够安全处理而不崩溃
/// 测试使用空写入器时是否不会抛出异常
/// 验证当传入null写入器时，日志器能够安全处理而不崩溃
/// </summary>
[Test]
public void Write_WithNullWriter_ShouldNotThrow()
@ -265,8 +265,8 @@ public class ConsoleLoggerTests
}
/// <summary>
/// 测试写入空消息时是否仍能正常写入
/// 验证即使消息为空字符串，日志框架仍能生成包含其他信息的完整日志条目
/// 测试写入空消息时是否仍能正常写入
/// 验证即使消息为空字符串，日志框架仍能生成包含其他信息的完整日志条目
/// </summary>
[Test]
public void Write_WithEmptyMessage_ShouldStillWrite()

36
GFramework.Core.Tests/logging/LoggerFactoryTests.cs
View File

@ -6,19 +6,19 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.logging;
/// <summary>
/// 测试LoggerFactory相关功能的测试类
/// 测试LoggerFactory相关功能的测试类
/// </summary>
[TestFixture]
public class LoggerFactoryTests
{
/// <summary>
/// 测试ConsoleLoggerFactory的GetLogger方法是否返回ConsoleLogger实例
/// 测试ConsoleLoggerFactory的GetLogger方法是否返回ConsoleLogger实例
/// </summary>
[Test]
public void ConsoleLoggerFactory_GetLogger_ShouldReturnConsoleLogger()
{
var factory = new ConsoleLoggerFactory();
var logger = factory.GetLogger("TestLogger", LogLevel.Info);
var logger = factory.GetLogger("TestLogger");
Assert.That(logger, Is.Not.Null);
Assert.That(logger, Is.InstanceOf<ConsoleLogger>());
@ -26,7 +26,7 @@ public class LoggerFactoryTests
}
/// <summary>
/// 测试ConsoleLoggerFactory使用不同名称获取不同的logger实例
/// 测试ConsoleLoggerFactory使用不同名称获取不同的logger实例
/// </summary>
[Test]
public void ConsoleLoggerFactory_GetLogger_WithDifferentNames_ShouldReturnDifferentLoggers()
@ -40,7 +40,7 @@ public class LoggerFactoryTests
}
/// <summary>
/// 测试ConsoleLoggerFactory使用默认最小级别时的行为（默认为Info级别）
/// 测试ConsoleLoggerFactory使用默认最小级别时的行为（默认为Info级别）
/// </summary>
[Test]
public void ConsoleLoggerFactory_GetLogger_WithDefaultMinLevel_ShouldUseInfo()
@ -61,7 +61,7 @@ public class LoggerFactoryTests
}
/// <summary>
/// 测试ConsoleLoggerFactoryProvider创建logger时使用提供者的最小级别设置
/// 测试ConsoleLoggerFactoryProvider创建logger时使用提供者的最小级别设置
/// </summary>
[Test]
public void ConsoleLoggerFactoryProvider_CreateLogger_ShouldReturnLoggerWithProviderMinLevel()
@ -82,7 +82,7 @@ public class LoggerFactoryTests
}
/// <summary>
/// 测试ConsoleLoggerFactoryProvider创建logger时使用提供的名称
/// 测试ConsoleLoggerFactoryProvider创建logger时使用提供的名称
/// </summary>
[Test]
public void ConsoleLoggerFactoryProvider_CreateLogger_ShouldUseProvidedName()
@ -94,7 +94,7 @@ public class LoggerFactoryTests
}
/// <summary>
/// 测试LoggerFactoryResolver的Provider属性是否有默认值
/// 测试LoggerFactoryResolver的Provider属性是否有默认值
/// </summary>
[Test]
public void LoggerFactoryResolver_Provider_ShouldHaveDefaultValue()
@ -104,7 +104,7 @@ public class LoggerFactoryTests
}
/// <summary>
/// 测试LoggerFactoryResolver的Provider属性可以被更改
/// 测试LoggerFactoryResolver的Provider属性可以被更改
/// </summary>
[Test]
public void LoggerFactoryResolver_Provider_CanBeChanged()
@ -120,7 +120,7 @@ public class LoggerFactoryTests
}
/// <summary>
/// 测试LoggerFactoryResolver的MinLevel属性是否有默认值
/// 测试LoggerFactoryResolver的MinLevel属性是否有默认值
/// </summary>
[Test]
public void LoggerFactoryResolver_MinLevel_ShouldHaveDefaultValue()
@ -129,7 +129,7 @@ public class LoggerFactoryTests
}
/// <summary>
/// 测试LoggerFactoryResolver的MinLevel属性可以被更改
/// 测试LoggerFactoryResolver的MinLevel属性可以被更改
/// </summary>
[Test]
public void LoggerFactoryResolver_MinLevel_CanBeChanged()
@ -144,7 +144,7 @@ public class LoggerFactoryTests
}
/// <summary>
/// 测试ConsoleLoggerFactoryProvider的MinLevel属性是否有默认值
/// 测试ConsoleLoggerFactoryProvider的MinLevel属性是否有默认值
/// </summary>
[Test]
public void ConsoleLoggerFactoryProvider_MinLevel_ShouldHaveDefaultValue()
@ -155,7 +155,7 @@ public class LoggerFactoryTests
}
/// <summary>
/// 测试ConsoleLoggerFactoryProvider的MinLevel属性可以被更改
/// 测试ConsoleLoggerFactoryProvider的MinLevel属性可以被更改
/// </summary>
[Test]
public void ConsoleLoggerFactoryProvider_MinLevel_CanBeChanged()
@ -168,7 +168,7 @@ public class LoggerFactoryTests
}
/// <summary>
/// 测试LoggerFactoryResolver的Provider创建logger时使用提供者设置
/// 测试LoggerFactoryResolver的Provider创建logger时使用提供者设置
/// </summary>
[Test]
public void LoggerFactoryResolver_Provider_CreateLogger_ShouldUseProviderSettings()
@ -195,7 +195,7 @@ public class LoggerFactoryTests
}
/// <summary>
/// 测试LoggerFactoryResolver的MinLevel属性影响新创建的logger
/// 测试LoggerFactoryResolver的MinLevel属性影响新创建的logger
/// </summary>
[Test]
public void LoggerFactoryResolver_MinLevel_AffectsNewLoggers()
@ -222,13 +222,13 @@ public class LoggerFactoryTests
}
/// <summary>
/// 测试ConsoleLoggerFactory创建的多个logger实例是独立的
/// 测试ConsoleLoggerFactory创建的多个logger实例是独立的
/// </summary>
[Test]
public void ConsoleLoggerFactory_MultipleLoggers_ShouldBeIndependent()
{
var factory = new ConsoleLoggerFactory();
var logger1 = factory.GetLogger("Logger1", LogLevel.Info);
var logger1 = factory.GetLogger("Logger1");
var logger2 = factory.GetLogger("Logger2", LogLevel.Debug);
Assert.That(logger1.Name(), Is.EqualTo("Logger1"));
@ -236,7 +236,7 @@ public class LoggerFactoryTests
}
/// <summary>
/// 测试ConsoleLoggerFactoryProvider的MinLevel不会影响已创建的logger
/// 测试ConsoleLoggerFactoryProvider的MinLevel不会影响已创建的logger
/// </summary>
[Test]
public void ConsoleLoggerFactoryProvider_MinLevel_DoesNotAffectCreatedLogger()

84
GFramework.Core.Tests/logging/LoggerTests.cs
View File

@ -5,25 +5,25 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.logging;
/// <summary>
/// 测试Logger功能的单元测试类
/// 测试Logger功能的单元测试类
/// </summary>
[TestFixture]
public class LoggerTests
{
/// <summary>
/// 在每个测试方法执行前设置测试环境
/// 创建一个新的TestLogger实例，名称为"TestLogger"，最小日志级别为Info
/// 在每个测试方法执行前设置测试环境
/// 创建一个新的TestLogger实例，名称为"TestLogger"，最小日志级别为Info
/// </summary>
[SetUp]
public void SetUp()
{
_logger = new TestLogger("TestLogger", LogLevel.Info);
_logger = new TestLogger("TestLogger");
}
private TestLogger _logger = null!;
/// <summary>
/// 验证Name方法是否正确返回Logger的名称
/// 验证Name方法是否正确返回Logger的名称
/// </summary>
[Test]
public void Name_Should_ReturnLoggerName()
@ -34,7 +34,7 @@ public class LoggerTests
}
/// <summary>
/// 验证当使用默认名称时，Name方法是否返回根Logger名称"ROOT"
/// 验证当使用默认名称时，Name方法是否返回根Logger名称"ROOT"
/// </summary>
[Test]
public void Name_WithDefaultName_Should_ReturnRootLoggerName()
@ -45,7 +45,7 @@ public class LoggerTests
}
/// <summary>
/// 验证当最小日志级别为Info时，IsTraceEnabled方法是否返回false
/// 验证当最小日志级别为Info时，IsTraceEnabled方法是否返回false
/// </summary>
[Test]
public void IsTraceEnabled_WithInfoMinLevel_Should_ReturnFalse()
@ -54,7 +54,7 @@ public class LoggerTests
}
/// <summary>
/// 验证当最小日志级别为Info时，IsDebugEnabled方法是否返回false
/// 验证当最小日志级别为Info时，IsDebugEnabled方法是否返回false
/// </summary>
[Test]
public void IsDebugEnabled_WithInfoMinLevel_Should_ReturnFalse()
@ -63,7 +63,7 @@ public class LoggerTests
}
/// <summary>
/// 验证当最小日志级别为Info时，IsInfoEnabled方法是否返回true
/// 验证当最小日志级别为Info时，IsInfoEnabled方法是否返回true
/// </summary>
[Test]
public void IsInfoEnabled_WithInfoMinLevel_Should_ReturnTrue()
@ -72,7 +72,7 @@ public class LoggerTests
}
/// <summary>
/// 验证当最小日志级别为Info时，IsWarnEnabled方法是否返回true
/// 验证当最小日志级别为Info时，IsWarnEnabled方法是否返回true
/// </summary>
[Test]
public void IsWarnEnabled_WithInfoMinLevel_Should_ReturnTrue()
@ -81,7 +81,7 @@ public class LoggerTests
}
/// <summary>
/// 验证当最小日志级别为Info时，IsErrorEnabled方法是否返回true
/// 验证当最小日志级别为Info时，IsErrorEnabled方法是否返回true
/// </summary>
[Test]
public void IsErrorEnabled_WithInfoMinLevel_Should_ReturnTrue()
@ -90,7 +90,7 @@ public class LoggerTests
}
/// <summary>
/// 验证当最小日志级别为Info时，IsFatalEnabled方法是否返回true
/// 验证当最小日志级别为Info时，IsFatalEnabled方法是否返回true
/// </summary>
[Test]
public void IsFatalEnabled_WithInfoMinLevel_Should_ReturnTrue()
@ -99,7 +99,7 @@ public class LoggerTests
}
/// <summary>
/// 验证IsEnabledForLevel方法对于不同日志级别的返回值是否正确
/// 验证IsEnabledForLevel方法对于不同日志级别的返回值是否正确
/// </summary>
[Test]
public void IsEnabledForLevel_WithValidLevel_Should_ReturnCorrectResult()
@ -113,7 +113,7 @@ public class LoggerTests
}
/// <summary>
/// 验证当传入无效的日志级别时，IsEnabledForLevel方法是否会抛出ArgumentException异常
/// 验证当传入无效的日志级别时，IsEnabledForLevel方法是否会抛出ArgumentException异常
/// </summary>
[Test]
public void IsEnabledForLevel_WithInvalidLevel_Should_ThrowArgumentException()
@ -122,7 +122,7 @@ public class LoggerTests
}
/// <summary>
/// 验证当Trace级别被禁用时，Trace方法不会写入日志
/// 验证当Trace级别被禁用时，Trace方法不会写入日志
/// </summary>
[Test]
public void Trace_ShouldNotWrite_WhenTraceDisabled()
@ -133,7 +133,7 @@ public class LoggerTests
}
/// <summary>
/// 验证当Trace级别被禁用时，带格式化参数的Trace方法不会写入日志
/// 验证当Trace级别被禁用时，带格式化参数的Trace方法不会写入日志
/// </summary>
[Test]
public void Trace_WithFormat_ShouldNotWrite_WhenTraceDisabled()
@ -144,7 +144,7 @@ public class LoggerTests
}
/// <summary>
/// 验证当Trace级别被禁用时，带两个参数的Trace方法不会写入日志
/// 验证当Trace级别被禁用时，带两个参数的Trace方法不会写入日志
/// </summary>
[Test]
public void Trace_WithTwoArgs_ShouldNotWrite_WhenTraceDisabled()
@ -155,7 +155,7 @@ public class LoggerTests
}
/// <summary>
/// 验证当Trace级别被禁用时，带异常参数的Trace方法不会写入日志
/// 验证当Trace级别被禁用时，带异常参数的Trace方法不会写入日志
/// </summary>
[Test]
public void Trace_WithException_ShouldNotWrite_WhenTraceDisabled()
@ -167,7 +167,7 @@ public class LoggerTests
}
/// <summary>
/// 验证当Debug级别被禁用时，Debug方法不会写入日志
/// 验证当Debug级别被禁用时，Debug方法不会写入日志
/// </summary>
[Test]
public void Debug_ShouldNotWrite_WhenDebugDisabled()
@ -178,7 +178,7 @@ public class LoggerTests
}
/// <summary>
/// 验证当Debug级别被禁用时，带格式化参数的Debug方法不会写入日志
/// 验证当Debug级别被禁用时，带格式化参数的Debug方法不会写入日志
/// </summary>
[Test]
public void Debug_WithFormat_ShouldNotWrite_WhenDebugDisabled()
@ -189,7 +189,7 @@ public class LoggerTests
}
/// <summary>
/// 验证当Info级别启用时，Info方法会正确写入日志
/// 验证当Info级别启用时，Info方法会正确写入日志
/// </summary>
[Test]
public void Info_ShouldWrite_WhenInfoEnabled()
@ -203,7 +203,7 @@ public class LoggerTests
}
/// <summary>
/// 验证带格式化参数的Info方法会正确写入格式化后的消息
/// 验证带格式化参数的Info方法会正确写入格式化后的消息
/// </summary>
[Test]
public void Info_WithFormat_ShouldWriteFormattedMessage()
@ -215,7 +215,7 @@ public class LoggerTests
}
/// <summary>
/// 验证带两个参数的Info方法会正确写入格式化后的消息
/// 验证带两个参数的Info方法会正确写入格式化后的消息
/// </summary>
[Test]
public void Info_WithTwoArgs_ShouldWriteFormattedMessage()
@ -227,7 +227,7 @@ public class LoggerTests
}
/// <summary>
/// 验证带多个参数的Info方法会正确写入格式化后的消息
/// 验证带多个参数的Info方法会正确写入格式化后的消息
/// </summary>
[Test]
public void Info_WithMultipleArgs_ShouldWriteFormattedMessage()
@ -239,7 +239,7 @@ public class LoggerTests
}
/// <summary>
/// 验证带异常参数的Info方法会正确写入消息和异常
/// 验证带异常参数的Info方法会正确写入消息和异常
/// </summary>
[Test]
public void Info_WithException_ShouldWriteMessageAndException()
@ -253,7 +253,7 @@ public class LoggerTests
}
/// <summary>
/// 验证当Warn级别启用时，Warn方法会正确写入日志
/// 验证当Warn级别启用时，Warn方法会正确写入日志
/// </summary>
[Test]
public void Warn_ShouldWrite_WhenWarnEnabled()
@ -266,7 +266,7 @@ public class LoggerTests
}
/// <summary>
/// 验证带格式化参数的Warn方法会正确写入格式化后的消息
/// 验证带格式化参数的Warn方法会正确写入格式化后的消息
/// </summary>
[Test]
public void Warn_WithFormat_ShouldWriteFormattedMessage()
@ -278,7 +278,7 @@ public class LoggerTests
}
/// <summary>
/// 验证带异常参数的Warn方法会正确写入消息和异常
/// 验证带异常参数的Warn方法会正确写入消息和异常
/// </summary>
[Test]
public void Warn_WithException_ShouldWriteMessageAndException()
@ -291,7 +291,7 @@ public class LoggerTests
}
/// <summary>
/// 验证当Error级别启用时，Error方法会正确写入日志
/// 验证当Error级别启用时，Error方法会正确写入日志
/// </summary>
[Test]
public void Error_ShouldWrite_WhenErrorEnabled()
@ -304,7 +304,7 @@ public class LoggerTests
}
/// <summary>
/// 验证带格式化参数的Error方法会正确写入格式化后的消息
/// 验证带格式化参数的Error方法会正确写入格式化后的消息
/// </summary>
[Test]
public void Error_WithFormat_ShouldWriteFormattedMessage()
@ -316,7 +316,7 @@ public class LoggerTests
}
/// <summary>
/// 验证带异常参数的Error方法会正确写入消息和异常
/// 验证带异常参数的Error方法会正确写入消息和异常
/// </summary>
[Test]
public void Error_WithException_ShouldWriteMessageAndException()
@ -329,7 +329,7 @@ public class LoggerTests
}
/// <summary>
/// 验证当Fatal级别启用时，Fatal方法会正确写入日志
/// 验证当Fatal级别启用时，Fatal方法会正确写入日志
/// </summary>
[Test]
public void Fatal_ShouldWrite_WhenFatalEnabled()
@ -342,7 +342,7 @@ public class LoggerTests
}
/// <summary>
/// 验证带格式化参数的Fatal方法会正确写入格式化后的消息
/// 验证带格式化参数的Fatal方法会正确写入格式化后的消息
/// </summary>
[Test]
public void Fatal_WithFormat_ShouldWriteFormattedMessage()
@ -354,7 +354,7 @@ public class LoggerTests
}
/// <summary>
/// 验证带异常参数的Fatal方法会正确写入消息和异常
/// 验证带异常参数的Fatal方法会正确写入消息和异常
/// </summary>
[Test]
public void Fatal_WithException_ShouldWriteMessageAndException()
@ -367,7 +367,7 @@ public class LoggerTests
}
/// <summary>
/// 验证多次调用日志方法会累积日志条目
/// 验证多次调用日志方法会累积日志条目
/// </summary>
[Test]
public void MultipleLogCalls_ShouldAccumulateLogs()
@ -383,7 +383,7 @@ public class LoggerTests
}
/// <summary>
/// 验证当最小日志级别设置为Trace时，所有级别的日志都会被启用
/// 验证当最小日志级别设置为Trace时，所有级别的日志都会被启用
/// </summary>
[Test]
public void Logger_WithTraceMinLevel_ShouldEnableAllLevels()
@ -401,7 +401,7 @@ public class LoggerTests
}
/// <summary>
/// 验证当最小日志级别设置为Fatal时，只有Fatal级别的日志会被启用
/// 验证当最小日志级别设置为Fatal时，只有Fatal级别的日志会被启用
/// </summary>
[Test]
public void Logger_WithFatalMinLevel_ShouldDisableAllButFatal()
@ -421,12 +421,12 @@ public class LoggerTests
}
/// <summary>
/// 测试用的日志记录器实现类，继承自AbstractLogger
/// 测试用的日志记录器实现类，继承自AbstractLogger
/// </summary>
public sealed class TestLogger : AbstractLogger
{
/// <summary>
/// 初始化TestLogger的新实例
/// 初始化TestLogger的新实例
/// </summary>
/// <param name="name">日志记录器的名称，默认为null</param>
/// <param name="minLevel">最小日志级别，默认为LogLevel.Info</param>
@ -435,12 +435,12 @@ public sealed class TestLogger : AbstractLogger
}
/// <summary>
/// 获取记录的日志条目列表
/// 获取记录的日志条目列表
/// </summary>
public List<LogEntry> Logs { get; } = new();
/// <summary>
/// 将日志信息写入内部存储
/// 将日志信息写入内部存储
/// </summary>
/// <param name="level">日志级别</param>
/// <param name="message">日志消息</param>
@ -451,7 +451,7 @@ public sealed class TestLogger : AbstractLogger
}
/// <summary>
/// 表示单个日志条目的记录类型
/// 表示单个日志条目的记录类型
/// </summary>
/// <param name="Level">日志级别</param>
/// <param name="Message">日志消息</param>

42
GFramework.Core.Tests/pool/ObjectPoolTests.cs
View File

@ -5,13 +5,13 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.pool;
/// <summary>
/// 对象池功能测试类，用于验证对象池的基本操作和行为
/// 对象池功能测试类，用于验证对象池的基本操作和行为
/// </summary>
[TestFixture]
public class ObjectPoolTests
{
/// <summary>
/// 测试初始化方法，在每个测试方法执行前设置测试环境
/// 测试初始化方法，在每个测试方法执行前设置测试环境
/// </summary>
[SetUp]
public void SetUp()
@ -20,12 +20,12 @@ public class ObjectPoolTests
}
/// <summary>
/// 测试用的对象池实例
/// 测试用的对象池实例
/// </summary>
private TestObjectPool _pool = null!;
/// <summary>
/// 验证当对象池为空时，Acquire方法应该创建新对象
/// 验证当对象池为空时，Acquire方法应该创建新对象
/// </summary>
[Test]
public void Acquire_Should_Create_New_Object_When_Pool_Empty()
@ -38,7 +38,7 @@ public class ObjectPoolTests
}
/// <summary>
/// 验证Acquire方法应该返回池中的可用对象
/// 验证Acquire方法应该返回池中的可用对象
/// </summary>
[Test]
public void Acquire_Should_Return_Pooled_Object()
@ -56,7 +56,7 @@ public class ObjectPoolTests
}
/// <summary>
/// 验证Release方法应该调用对象的OnRelease回调
/// 验证Release方法应该调用对象的OnRelease回调
/// </summary>
[Test]
public void Release_Should_Call_OnRelease()
@ -69,7 +69,7 @@ public class ObjectPoolTests
}
/// <summary>
/// 验证Clear方法应该销毁所有对象
/// 验证Clear方法应该销毁所有对象
/// </summary>
[Test]
public void Clear_Should_Destroy_All_Objects()
@ -87,7 +87,7 @@ public class ObjectPoolTests
}
/// <summary>
/// 验证多个池键应该相互独立
/// 验证多个池键应该相互独立
/// </summary>
[Test]
public void Multiple_Pools_Should_Be_Independent()
@ -105,7 +105,7 @@ public class ObjectPoolTests
}
/// <summary>
/// 验证OnAcquire回调应该在新对象和池中对象上都被调用
/// 验证OnAcquire回调应该在新对象和池中对象上都被调用
/// </summary>
[Test]
public void OnAcquire_Should_Be_Called_On_New_And_Pooled_Objects()
@ -122,12 +122,12 @@ public class ObjectPoolTests
}
/// <summary>
/// 测试用对象池实现类，继承自AbstractObjectPoolSystem
/// 测试用对象池实现类，继承自AbstractObjectPoolSystem
/// </summary>
public class TestObjectPool : AbstractObjectPoolSystem<string, TestPoolableObject>
{
/// <summary>
/// 创建新的池化对象
/// 创建新的池化对象
/// </summary>
/// <param name="key">用于标识对象的键</param>
/// <returns>新创建的TestPoolableObject实例</returns>
@ -137,7 +137,7 @@ public class TestObjectPool : AbstractObjectPoolSystem<string, TestPoolableObjec
}
/// <summary>
/// 初始化方法，用于对象池初始化时的操作
/// 初始化方法，用于对象池初始化时的操作
/// </summary>
protected override void OnInit()
{
@ -145,37 +145,37 @@ public class TestObjectPool : AbstractObjectPoolSystem<string, TestPoolableObjec
}
/// <summary>
/// 测试用池化对象类，实现了IPoolableObject接口
/// 测试用池化对象类，实现了IPoolableObject接口
/// </summary>
public class TestPoolableObject : IPoolableObject
{
/// <summary>
/// 获取或设置对象的池键
/// 获取或设置对象的池键
/// </summary>
public string PoolKey { get; set; } = string.Empty;
/// <summary>
/// 获取或设置测试用的整数值
/// 获取或设置测试用的整数值
/// </summary>
public int TestValue { get; set; }
/// <summary>
/// 获取或设置OnAcquire方法是否被调用的标志
/// 获取或设置OnAcquire方法是否被调用的标志
/// </summary>
public bool OnAcquireCalled { get; set; }
/// <summary>
/// 获取或设置OnRelease方法是否被调用的标志
/// 获取或设置OnRelease方法是否被调用的标志
/// </summary>
public bool OnReleaseCalled { get; set; }
/// <summary>
/// 获取或设置OnPoolDestroy方法是否被调用的标志
/// 获取或设置OnPoolDestroy方法是否被调用的标志
/// </summary>
public bool OnPoolDestroyCalled { get; set; }
/// <summary>
/// 对象被获取时的回调方法
/// 对象被获取时的回调方法
/// </summary>
public void OnAcquire()
{
@ -183,7 +183,7 @@ public class TestPoolableObject : IPoolableObject
}
/// <summary>
/// 对象被释放时的回调方法
/// 对象被释放时的回调方法
/// </summary>
public void OnRelease()
{
@ -191,7 +191,7 @@ public class TestPoolableObject : IPoolableObject
}
/// <summary>
/// 对象被销毁时的回调方法
/// 对象被销毁时的回调方法
/// </summary>
public void OnPoolDestroy()
{

24
GFramework.Core.Tests/property/BindablePropertyTests.cs
View File

@ -4,13 +4,13 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.property;
/// <summary>
/// BindableProperty类的单元测试
/// BindableProperty类的单元测试
/// </summary>
[TestFixture]
public class BindablePropertyTests
{
/// <summary>
/// 测试清理方法，在每个测试方法执行后重置比较器
/// 测试清理方法，在每个测试方法执行后重置比较器
/// </summary>
[TearDown]
public void TearDown()
@ -19,7 +19,7 @@ public class BindablePropertyTests
}
/// <summary>
/// 测试获取值时应返回默认值
/// 测试获取值时应返回默认值
/// </summary>
[Test]
public void Value_Get_Should_Return_Default_Value()
@ -30,7 +30,7 @@ public class BindablePropertyTests
}
/// <summary>
/// 测试设置值时应触发事件
/// 测试设置值时应触发事件
/// </summary>
[Test]
public void Value_Set_Should_Trigger_Event()
@ -46,7 +46,7 @@ public class BindablePropertyTests
}
/// <summary>
/// 测试设置相同值时不触发事件
/// 测试设置相同值时不触发事件
/// </summary>
[Test]
public void Value_Set_To_Same_Value_Should_Not_Trigger_Event()
@ -62,7 +62,7 @@ public class BindablePropertyTests
}
/// <summary>
/// 测试取消注册应移除处理器
/// 测试取消注册应移除处理器
/// </summary>
[Test]
public void UnRegister_Should_Remove_Handler()
@ -82,7 +82,7 @@ public class BindablePropertyTests
}
/// <summary>
/// 测试带初始值注册应立即调用处理器
/// 测试带初始值注册应立即调用处理器
/// </summary>
[Test]
public void RegisterWithInitValue_Should_Call_Handler_Immediately()
@ -96,7 +96,7 @@ public class BindablePropertyTests
}
/// <summary>
/// 测试无事件设置值不应触发事件
/// 测试无事件设置值不应触发事件
/// </summary>
[Test]
public void SetValueWithoutEvent_Should_Not_Trigger_Event()
@ -113,7 +113,7 @@ public class BindablePropertyTests
}
/// <summary>
/// 测试使用自定义比较器
/// 测试使用自定义比较器
/// </summary>
[Test]
public void WithComparer_Should_Use_Custom_Comparer()
@ -141,7 +141,7 @@ public class BindablePropertyTests
}
/// <summary>
/// 测试多个处理器都应被调用
/// 测试多个处理器都应被调用
/// </summary>
[Test]
public void Multiple_Handlers_Should_All_Be_Called()
@ -160,7 +160,7 @@ public class BindablePropertyTests
}
/// <summary>
/// 测试注册应返回IUnRegister接口
/// 测试注册应返回IUnRegister接口
/// </summary>
[Test]
public void Register_Should_Return_IUnRegister()
@ -172,7 +172,7 @@ public class BindablePropertyTests
}
/// <summary>
/// 测试ToString应返回值的字符串表示
/// 测试ToString应返回值的字符串表示
/// </summary>
[Test]
public void ToString_Should_Return_Value_As_String()

96
GFramework.Core.Tests/query/AbstractAsyncQueryTests.cs
View File

@ -11,18 +11,18 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.query;
/// <summary>
/// AbstractAsyncQuery类的单元测试
/// 测试内容包括：
/// - 异步查询的基础实现
/// - DoAsync方法调用
/// - DoAsync方法的异常处理
/// - 上下文感知功能（SetContext, GetContext）
/// - 日志功能（Logger属性）
/// - 子类继承行为验证
/// - 查询执行前日志记录
/// - 查询执行后日志记录
/// - 返回值类型验证
/// - 错误情况下的日志记录
/// AbstractAsyncQuery类的单元测试
/// 测试内容包括：
/// - 异步查询的基础实现
/// - DoAsync方法调用
/// - DoAsync方法的异常处理
/// - 上下文感知功能（SetContext, GetContext）
/// - 日志功能（Logger属性）
/// - 子类继承行为验证
/// - 查询执行前日志记录
/// - 查询执行后日志记录
/// - 返回值类型验证
/// - 错误情况下的日志记录
/// </summary>
[TestFixture]
public class AbstractAsyncQueryTests
@ -43,7 +43,7 @@ public class AbstractAsyncQueryTests
private IocContainer _container = null!;
/// <summary>
/// 测试异步查询的基础实现
/// 测试异步查询的基础实现
/// </summary>
[Test]
public async Task AbstractAsyncQuery_Should_Implement_IAsyncQuery_Interface()
@ -55,7 +55,7 @@ public class AbstractAsyncQueryTests
}
/// <summary>
/// 测试DoAsync方法调用
/// 测试DoAsync方法调用
/// </summary>
[Test]
public async Task DoAsync_Should_Invoke_OnDoAsync_Method()
@ -71,7 +71,7 @@ public class AbstractAsyncQueryTests
}
/// <summary>
/// 测试DoAsync方法的异常处理
/// 测试DoAsync方法的异常处理
/// </summary>
[Test]
public void DoAsync_Should_Propagate_Exception_From_OnDoAsync()
@ -84,7 +84,7 @@ public class AbstractAsyncQueryTests
}
/// <summary>
/// 测试上下文感知功能 - SetContext方法
/// 测试上下文感知功能 - SetContext方法
/// </summary>
[Test]
public void SetContext_Should_Set_Context_Property()
@ -100,7 +100,7 @@ public class AbstractAsyncQueryTests
}
/// <summary>
/// 测试上下文感知功能 - GetContext方法
/// 测试上下文感知功能 - GetContext方法
/// </summary>
[Test]
public void GetContext_Should_Return_Context_Property()
@ -117,7 +117,7 @@ public class AbstractAsyncQueryTests
}
/// <summary>
/// 测试子类继承行为验证
/// 测试子类继承行为验证
/// </summary>
[Test]
public async Task Child_Class_Should_Inherit_And_Override_OnDoAsync_Method()
@ -133,7 +133,7 @@ public class AbstractAsyncQueryTests
}
/// <summary>
/// 测试异步查询执行生命周期完整性
/// 测试异步查询执行生命周期完整性
/// </summary>
[Test]
public async Task AsyncQuery_Should_Complete_Execution_Lifecycle()
@ -151,7 +151,7 @@ public class AbstractAsyncQueryTests
}
/// <summary>
/// 测试异步查询多次执行
/// 测试异步查询多次执行
/// </summary>
[Test]
public async Task AsyncQuery_Should_Be_Executable_Multiple_Times()
@ -168,7 +168,7 @@ public class AbstractAsyncQueryTests
}
/// <summary>
/// 测试异步查询的返回值类型
/// 测试异步查询的返回值类型
/// </summary>
[Test]
public async Task AsyncQuery_Should_Return_Correct_Type()
@ -184,7 +184,7 @@ public class AbstractAsyncQueryTests
}
/// <summary>
/// 测试异步查询的字符串返回值
/// 测试异步查询的字符串返回值
/// </summary>
[Test]
public async Task AsyncQuery_WithStringResult_Should_Return_String()
@ -200,7 +200,7 @@ public class AbstractAsyncQueryTests
}
/// <summary>
/// 测试异步查询的复杂对象返回值
/// 测试异步查询的复杂对象返回值
/// </summary>
[Test]
public async Task AsyncQuery_WithComplexResult_Should_Return_ComplexObject()
@ -217,7 +217,7 @@ public class AbstractAsyncQueryTests
}
/// <summary>
/// 测试异步查询在不同实例之间的独立性
/// 测试异步查询在不同实例之间的独立性
/// </summary>
[Test]
public async Task AsyncQuery_Should_Maintain_Independence_Between_Different_Instances()
@ -238,23 +238,23 @@ public class AbstractAsyncQueryTests
}
/// <summary>
/// 测试用异步查询输入类V2
/// 测试用异步查询输入类V2
/// </summary>
public sealed class TestAsyncQueryInputV2 : IQueryInput
{
/// <summary>
/// 获取或设置值
/// 获取或设置值
/// </summary>
public int Value { get; init; }
}
/// <summary>
/// 整数类型测试异步查询类V4，继承AbstractAsyncQuery
/// 整数类型测试异步查询类V4，继承AbstractAsyncQuery
/// </summary>
public sealed class TestAsyncQueryV4 : AbstractAsyncQuery<TestAsyncQueryInputV2, int>
{
/// <summary>
/// 初始化TestAsyncQueryV4的新实例
/// 初始化TestAsyncQueryV4的新实例
/// </summary>
/// <param name="input">查询输入参数</param>
public TestAsyncQueryV4(TestAsyncQueryInputV2 input) : base(input)
@ -262,12 +262,12 @@ public sealed class TestAsyncQueryV4 : AbstractAsyncQuery<TestAsyncQueryInputV2,
}
/// <summary>
/// 获取查询是否已执行
/// 获取查询是否已执行
/// </summary>
public bool Executed { get; private set; }
/// <summary>
/// 执行异步查询操作的具体实现
/// 执行异步查询操作的具体实现
/// </summary>
/// <param name="input">查询输入参数</param>
/// <returns>查询结果，将输入值乘以2</returns>
@ -279,12 +279,12 @@ public sealed class TestAsyncQueryV4 : AbstractAsyncQuery<TestAsyncQueryInputV2,
}
/// <summary>
/// 字符串类型测试异步查询类V4，继承AbstractAsyncQuery
/// 字符串类型测试异步查询类V4，继承AbstractAsyncQuery
/// </summary>
public sealed class TestAsyncStringQueryV4 : AbstractAsyncQuery<TestAsyncQueryInputV2, string>
{
/// <summary>
/// 初始化TestAsyncStringQueryV4的新实例
/// 初始化TestAsyncStringQueryV4的新实例
/// </summary>
/// <param name="input">查询输入参数</param>
public TestAsyncStringQueryV4(TestAsyncQueryInputV2 input) : base(input)
@ -292,12 +292,12 @@ public sealed class TestAsyncStringQueryV4 : AbstractAsyncQuery<TestAsyncQueryIn
}
/// <summary>
/// 获取查询是否已执行
/// 获取查询是否已执行
/// </summary>
public bool Executed { get; private set; }
/// <summary>
/// 执行异步查询操作的具体实现
/// 执行异步查询操作的具体实现
/// </summary>
/// <param name="input">查询输入参数</param>
/// <returns>格式化的字符串结果</returns>
@ -309,12 +309,12 @@ public sealed class TestAsyncStringQueryV4 : AbstractAsyncQuery<TestAsyncQueryIn
}
/// <summary>
/// 复杂对象类型测试异步查询类V4，继承AbstractAsyncQuery
/// 复杂对象类型测试异步查询类V4，继承AbstractAsyncQuery
/// </summary>
public sealed class TestAsyncComplexQueryV4 : AbstractAsyncQuery<TestAsyncQueryInputV2, TestAsyncQueryResultV2>
{
/// <summary>
/// 初始化TestAsyncComplexQueryV4的新实例
/// 初始化TestAsyncComplexQueryV4的新实例
/// </summary>
/// <param name="input">查询输入参数</param>
public TestAsyncComplexQueryV4(TestAsyncQueryInputV2 input) : base(input)
@ -322,12 +322,12 @@ public sealed class TestAsyncComplexQueryV4 : AbstractAsyncQuery<TestAsyncQueryI
}
/// <summary>
/// 获取查询是否已执行
/// 获取查询是否已执行
/// </summary>
public bool Executed { get; private set; }
/// <summary>
/// 执行异步查询操作的具体实现
/// 执行异步查询操作的具体实现
/// </summary>
/// <param name="input">查询输入参数</param>
/// <returns>复杂对象查询结果</returns>
@ -344,12 +344,12 @@ public sealed class TestAsyncComplexQueryV4 : AbstractAsyncQuery<TestAsyncQueryI
}
/// <summary>
/// 测试用异步查询类（抛出异常）
/// 测试用异步查询类（抛出异常）
/// </summary>
public sealed class TestAsyncQueryWithExceptionV4 : AbstractAsyncQuery<TestAsyncQueryInputV2, int>
{
/// <summary>
/// 初始化TestAsyncQueryWithExceptionV4的新实例
/// 初始化TestAsyncQueryWithExceptionV4的新实例
/// </summary>
/// <param name="input">查询输入参数</param>
public TestAsyncQueryWithExceptionV4(TestAsyncQueryInputV2 input) : base(input)
@ -357,7 +357,7 @@ public sealed class TestAsyncQueryWithExceptionV4 : AbstractAsyncQuery<TestAsync
}
/// <summary>
/// 执行异步查询操作并抛出异常
/// 执行异步查询操作并抛出异常
/// </summary>
/// <param name="input">查询输入参数</param>
/// <exception cref="InvalidOperationException">总是抛出异常</exception>
@ -368,12 +368,12 @@ public sealed class TestAsyncQueryWithExceptionV4 : AbstractAsyncQuery<TestAsync
}
/// <summary>
/// 测试用异步查询子类V4，继承AbstractAsyncQuery
/// 测试用异步查询子类V4，继承AbstractAsyncQuery
/// </summary>
public sealed class TestAsyncQueryChildV4 : AbstractAsyncQuery<TestAsyncQueryInputV2, int>
{
/// <summary>
/// 初始化TestAsyncQueryChildV4的新实例
/// 初始化TestAsyncQueryChildV4的新实例
/// </summary>
/// <param name="input">查询输入参数</param>
public TestAsyncQueryChildV4(TestAsyncQueryInputV2 input) : base(input)
@ -381,12 +381,12 @@ public sealed class TestAsyncQueryChildV4 : AbstractAsyncQuery<TestAsyncQueryInp
}
/// <summary>
/// 获取查询是否已执行
/// 获取查询是否已执行
/// </summary>
public bool Executed { get; private set; }
/// <summary>
/// 执行异步查询操作的具体实现（子类实现，乘以3）
/// 执行异步查询操作的具体实现（子类实现，乘以3）
/// </summary>
/// <param name="input">查询输入参数</param>
/// <returns>查询结果，将输入值乘以3</returns>
@ -398,17 +398,17 @@ public sealed class TestAsyncQueryChildV4 : AbstractAsyncQuery<TestAsyncQueryInp
}
/// <summary>
/// 测试用复杂查询结果类V2
/// 测试用复杂查询结果类V2
/// </summary>
public sealed class TestAsyncQueryResultV2
{
/// <summary>
/// 获取或设置值
/// 获取或设置值
/// </summary>
public int Value { get; init; }
/// <summary>
/// 获取或设置双倍值
/// 获取或设置双倍值
/// </summary>
public int DoubleValue { get; init; }
}

80
GFramework.Core.Tests/query/AsyncQueryBusTests.cs
View File

@ -5,14 +5,14 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.query;
/// <summary>
/// AsyncQueryBus类的单元测试
/// 测试内容包括：
/// - SendAsync方法 - 正常查询发送
/// - SendAsync方法 - 空查询异常
/// - 异步查询结果正确性
/// - 不同返回类型的异步查询支持
/// - 异步查询的异常处理
/// - 异步查询的上下文传递
/// AsyncQueryBus类的单元测试
/// 测试内容包括：
/// - SendAsync方法 - 正常查询发送
/// - SendAsync方法 - 空查询异常
/// - 异步查询结果正确性
/// - 不同返回类型的异步查询支持
/// - 异步查询的异常处理
/// - 异步查询的上下文传递
/// </summary>
[TestFixture]
public class AsyncQueryBusTests
@ -26,7 +26,7 @@ public class AsyncQueryBusTests
private AsyncQueryBus _asyncQueryBus = null!;
/// <summary>
/// 测试SendAsync方法正确返回查询结果
/// 测试SendAsync方法正确返回查询结果
/// </summary>
[Test]
public async Task SendAsync_Should_Return_Query_Result()
@ -40,7 +40,7 @@ public class AsyncQueryBusTests
}
/// <summary>
/// 测试SendAsync方法在传入空查询对象时是否会抛出ArgumentNullException异常
/// 测试SendAsync方法在传入空查询对象时是否会抛出ArgumentNullException异常
/// </summary>
[Test]
public void SendAsync_WithNullQuery_Should_ThrowArgumentNullException()
@ -49,7 +49,7 @@ public class AsyncQueryBusTests
}
/// <summary>
/// 测试SendAsync方法是否能正确返回字符串类型的查询结果
/// 测试SendAsync方法是否能正确返回字符串类型的查询结果
/// </summary>
[Test]
public async Task SendAsync_WithStringResult_Should_Return_String()
@ -63,7 +63,7 @@ public class AsyncQueryBusTests
}
/// <summary>
/// 测试SendAsync方法是否能正确返回布尔类型的查询结果
/// 测试SendAsync方法是否能正确返回布尔类型的查询结果
/// </summary>
[Test]
public async Task SendAsync_WithBooleanResult_Should_Return_Boolean()
@ -77,7 +77,7 @@ public class AsyncQueryBusTests
}
/// <summary>
/// 测试SendAsync方法是否能正确处理复杂对象的查询结果
/// 测试SendAsync方法是否能正确处理复杂对象的查询结果
/// </summary>
[Test]
public async Task SendAsync_WithComplexObjectResult_Should_Return_ComplexObject()
@ -93,7 +93,7 @@ public class AsyncQueryBusTests
}
/// <summary>
/// 测试SendAsync方法是否能正确处理抛出异常的查询
/// 测试SendAsync方法是否能正确处理抛出异常的查询
/// </summary>
[Test]
public void SendAsync_Should_Propagate_Exception_From_Query()
@ -105,7 +105,7 @@ public class AsyncQueryBusTests
}
/// <summary>
/// 测试SendAsync方法多次调用
/// 测试SendAsync方法多次调用
/// </summary>
[Test]
public async Task SendAsync_Should_Be_Callable_Multiple_Times()
@ -121,7 +121,7 @@ public class AsyncQueryBusTests
}
/// <summary>
/// 测试SendAsync方法在不同查询之间保持独立性
/// 测试SendAsync方法在不同查询之间保持独立性
/// </summary>
[Test]
public async Task SendAsync_Should_Maintain_Independence_Between_Different_Queries()
@ -140,24 +140,24 @@ public class AsyncQueryBusTests
}
/// <summary>
/// 测试用异步查询输入类，实现IQueryInput接口
/// 测试用异步查询输入类，实现IQueryInput接口
/// </summary>
public sealed class TestAsyncQueryInput : IQueryInput
{
/// <summary>
/// 获取或设置查询值
/// 获取或设置查询值
/// </summary>
public int Value { get; init; }
}
/// <summary>
/// 整数类型测试异步查询类，继承AbstractAsyncQuery
/// 实现具体的异步查询逻辑并返回整数结果
/// 整数类型测试异步查询类，继承AbstractAsyncQuery
/// 实现具体的异步查询逻辑并返回整数结果
/// </summary>
public sealed class TestAsyncQuery : AbstractAsyncQuery<TestAsyncQueryInput, int>
{
/// <summary>
/// 初始化TestAsyncQuery的新实例
/// 初始化TestAsyncQuery的新实例
/// </summary>
/// <param name="input">查询输入参数</param>
public TestAsyncQuery(TestAsyncQueryInput input) : base(input)
@ -165,7 +165,7 @@ public sealed class TestAsyncQuery : AbstractAsyncQuery<TestAsyncQueryInput, int
}
/// <summary>
/// 执行异步查询操作的具体实现
/// 执行异步查询操作的具体实现
/// </summary>
/// <param name="input">查询输入参数</param>
/// <returns>查询结果，将输入值乘以2</returns>
@ -176,13 +176,13 @@ public sealed class TestAsyncQuery : AbstractAsyncQuery<TestAsyncQueryInput, int
}
/// <summary>
/// 字符串类型测试异步查询类，继承AbstractAsyncQuery
/// 实现具体的异步查询逻辑并返回字符串结果
/// 字符串类型测试异步查询类，继承AbstractAsyncQuery
/// 实现具体的异步查询逻辑并返回字符串结果
/// </summary>
public sealed class TestAsyncStringQuery : AbstractAsyncQuery<TestAsyncQueryInput, string>
{
/// <summary>
/// 初始化TestAsyncStringQuery的新实例
/// 初始化TestAsyncStringQuery的新实例
/// </summary>
/// <param name="input">查询输入参数</param>
public TestAsyncStringQuery(TestAsyncQueryInput input) : base(input)
@ -190,7 +190,7 @@ public sealed class TestAsyncStringQuery : AbstractAsyncQuery<TestAsyncQueryInpu
}
/// <summary>
/// 执行异步查询操作的具体实现
/// 执行异步查询操作的具体实现
/// </summary>
/// <param name="input">查询输入参数</param>
/// <returns>格式化的字符串结果</returns>
@ -201,13 +201,13 @@ public sealed class TestAsyncStringQuery : AbstractAsyncQuery<TestAsyncQueryInpu
}
/// <summary>
/// 布尔类型测试异步查询类，继承AbstractAsyncQuery
/// 实现具体的异步查询逻辑并返回布尔结果
/// 布尔类型测试异步查询类，继承AbstractAsyncQuery
/// 实现具体的异步查询逻辑并返回布尔结果
/// </summary>
public sealed class TestAsyncBooleanQuery : AbstractAsyncQuery<TestAsyncQueryInput, bool>
{
/// <summary>
/// 初始化TestAsyncBooleanQuery的新实例
/// 初始化TestAsyncBooleanQuery的新实例
/// </summary>
/// <param name="input">查询输入参数</param>
public TestAsyncBooleanQuery(TestAsyncQueryInput input) : base(input)
@ -215,7 +215,7 @@ public sealed class TestAsyncBooleanQuery : AbstractAsyncQuery<TestAsyncQueryInp
}
/// <summary>
/// 执行异步查询操作的具体实现
/// 执行异步查询操作的具体实现
/// </summary>
/// <param name="input">查询输入参数</param>
/// <returns>如果值大于0返回true，否则返回false</returns>
@ -226,13 +226,13 @@ public sealed class TestAsyncBooleanQuery : AbstractAsyncQuery<TestAsyncQueryInp
}
/// <summary>
/// 复杂对象类型测试异步查询类，继承AbstractAsyncQuery
/// 实现具体的异步查询逻辑并返回复杂对象结果
/// 复杂对象类型测试异步查询类，继承AbstractAsyncQuery
/// 实现具体的异步查询逻辑并返回复杂对象结果
/// </summary>
public sealed class TestAsyncComplexQuery : AbstractAsyncQuery<TestAsyncQueryInput, TestAsyncQueryResult>
{
/// <summary>
/// 初始化TestAsyncComplexQuery的新实例
/// 初始化TestAsyncComplexQuery的新实例
/// </summary>
/// <param name="input">查询输入参数</param>
public TestAsyncComplexQuery(TestAsyncQueryInput input) : base(input)
@ -240,7 +240,7 @@ public sealed class TestAsyncComplexQuery : AbstractAsyncQuery<TestAsyncQueryInp
}
/// <summary>
/// 执行异步查询操作的具体实现
/// 执行异步查询操作的具体实现
/// </summary>
/// <param name="input">查询输入参数</param>
/// <returns>复杂对象查询结果</returns>
@ -256,12 +256,12 @@ public sealed class TestAsyncComplexQuery : AbstractAsyncQuery<TestAsyncQueryInp
}
/// <summary>
/// 测试用异步查询类（抛出异常）
/// 测试用异步查询类（抛出异常）
/// </summary>
public sealed class TestAsyncQueryWithException : AbstractAsyncQuery<TestAsyncQueryInput, int>
{
/// <summary>
/// 初始化TestAsyncQueryWithException的新实例
/// 初始化TestAsyncQueryWithException的新实例
/// </summary>
/// <param name="input">查询输入参数</param>
public TestAsyncQueryWithException(TestAsyncQueryInput input) : base(input)
@ -269,7 +269,7 @@ public sealed class TestAsyncQueryWithException : AbstractAsyncQuery<TestAsyncQu
}
/// <summary>
/// 执行异步查询操作并抛出异常
/// 执行异步查询操作并抛出异常
/// </summary>
/// <param name="input">查询输入参数</param>
/// <exception cref="InvalidOperationException">总是抛出异常</exception>
@ -280,17 +280,17 @@ public sealed class TestAsyncQueryWithException : AbstractAsyncQuery<TestAsyncQu
}
/// <summary>
/// 测试用复杂查询结果类
/// 测试用复杂查询结果类
/// </summary>
public sealed class TestAsyncQueryResult
{
/// <summary>
/// 获取或设置值
/// 获取或设置值
/// </summary>
public int Value { get; init; }
/// <summary>
/// 获取或设置双倍值
/// 获取或设置双倍值
/// </summary>
public int DoubleValue { get; init; }
}

38
GFramework.Core.Tests/query/QueryBusTests.cs
View File

@ -5,13 +5,13 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.query;
/// <summary>
/// 查询总线测试类，用于测试QueryBus的功能和异常处理
/// 查询总线测试类，用于测试QueryBus的功能和异常处理
/// </summary>
[TestFixture]
public class QueryBusTests
{
/// <summary>
/// 测试设置方法，在每个测试方法执行前初始化查询总线实例
/// 测试设置方法，在每个测试方法执行前初始化查询总线实例
/// </summary>
[SetUp]
public void SetUp()
@ -22,8 +22,8 @@ public class QueryBusTests
private QueryBus _queryBus = null!;
/// <summary>
/// 测试Send方法是否能正确返回查询结果
/// 验证当传入有效查询对象时，能够得到预期的计算结果
/// 测试Send方法是否能正确返回查询结果
/// 验证当传入有效查询对象时，能够得到预期的计算结果
/// </summary>
[Test]
public void Send_Should_Return_Query_Result()
@ -37,8 +37,8 @@ public class QueryBusTests
}
/// <summary>
/// 测试Send方法在传入空查询对象时是否会抛出ArgumentNullException异常
/// 验证参数验证功能的正确性
/// 测试Send方法在传入空查询对象时是否会抛出ArgumentNullException异常
/// 验证参数验证功能的正确性
/// </summary>
[Test]
public void Send_WithNullQuery_Should_ThrowArgumentNullException()
@ -47,8 +47,8 @@ public class QueryBusTests
}
/// <summary>
/// 测试Send方法是否能正确返回字符串类型的查询结果
/// 验证不同返回类型的支持情况
/// 测试Send方法是否能正确返回字符串类型的查询结果
/// 验证不同返回类型的支持情况
/// </summary>
[Test]
public void Send_WithStringResult_Should_Return_String()
@ -63,25 +63,25 @@ public class QueryBusTests
}
/// <summary>
/// 测试用查询输入类，实现IQueryInput接口
/// 用于传递查询所需的参数信息
/// 测试用查询输入类，实现IQueryInput接口
/// 用于传递查询所需的参数信息
/// </summary>
public sealed class TestQueryInput : IQueryInput
{
/// <summary>
/// 获取或设置查询值
/// 获取或设置查询值
/// </summary>
public int Value { get; init; }
}
/// <summary>
/// 整数类型测试查询类，继承自AbstractQuery
/// 实现具体的查询逻辑并返回整数结果
/// 整数类型测试查询类，继承自AbstractQuery
/// 实现具体的查询逻辑并返回整数结果
/// </summary>
public sealed class TestQuery : AbstractQuery<TestQueryInput, int>
{
/// <summary>
/// 初始化TestQuery的新实例
/// 初始化TestQuery的新实例
/// </summary>
/// <param name="input">查询输入参数</param>
public TestQuery(TestQueryInput input) : base(input)
@ -89,7 +89,7 @@ public sealed class TestQuery : AbstractQuery<TestQueryInput, int>
}
/// <summary>
/// 执行查询操作的具体实现
/// 执行查询操作的具体实现
/// </summary>
/// <param name="input">查询输入参数</param>
/// <returns>查询结果，将输入值乘以2</returns>
@ -100,13 +100,13 @@ public sealed class TestQuery : AbstractQuery<TestQueryInput, int>
}
/// <summary>
/// 字符串类型测试查询类，继承自AbstractQuery
/// 实现具体的查询逻辑并返回字符串结果
/// 字符串类型测试查询类，继承自AbstractQuery
/// 实现具体的查询逻辑并返回字符串结果
/// </summary>
public sealed class TestStringQuery : AbstractQuery<TestQueryInput, string>
{
/// <summary>
/// 初始化TestStringQuery的新实例
/// 初始化TestStringQuery的新实例
/// </summary>
/// <param name="input">查询输入参数</param>
public TestStringQuery(TestQueryInput input) : base(input)
@ -114,7 +114,7 @@ public sealed class TestStringQuery : AbstractQuery<TestQueryInput, string>
}
/// <summary>
/// 执行查询操作的具体实现
/// 执行查询操作的具体实现
/// </summary>
/// <param name="input">查询输入参数</param>
/// <returns>格式化的字符串结果</returns>

42
GFramework.Core.Tests/rule/ContextAwareTests.cs
View File

@ -8,15 +8,15 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.rule;
/// <summary>
/// 测试 ContextAware 功能的单元测试类
/// 验证上下文感知对象的设置、获取和回调功能
/// 测试 ContextAware 功能的单元测试类
/// 验证上下文感知对象的设置、获取和回调功能
/// </summary>
[TestFixture]
public class ContextAwareTests
{
/// <summary>
/// 在每个测试方法执行前进行初始化设置
/// 创建测试用的 ContextAware 对象和模拟上下文，并绑定到游戏上下文中
/// 在每个测试方法执行前进行初始化设置
/// 创建测试用的 ContextAware 对象和模拟上下文，并绑定到游戏上下文中
/// </summary>
[SetUp]
public void SetUp()
@ -27,8 +27,8 @@ public class ContextAwareTests
}
/// <summary>
/// 在每个测试方法执行后进行清理工作
/// 从游戏上下文中解绑测试用的架构上下文类型
/// 在每个测试方法执行后进行清理工作
/// 从游戏上下文中解绑测试用的架构上下文类型
/// </summary>
[TearDown]
public void TearDown()
@ -40,8 +40,8 @@ public class ContextAwareTests
private TestArchitectureContext _mockContext = null!;
/// <summary>
/// 测试 SetContext 方法是否正确设置上下文属性
/// 验证通过 IContextAware 接口设置上下文后，内部的 PublicContext 属性能够正确返回设置的上下文
/// 测试 SetContext 方法是否正确设置上下文属性
/// 验证通过 IContextAware 接口设置上下文后，内部的 PublicContext 属性能够正确返回设置的上下文
/// </summary>
[Test]
public void SetContext_Should_Set_Context_Property()
@ -53,8 +53,8 @@ public class ContextAwareTests
}
/// <summary>
/// 测试 SetContext 方法是否正确调用 OnContextReady 回调方法
/// 验证设置上下文后，OnContextReady 方法被正确触发
/// 测试 SetContext 方法是否正确调用 OnContextReady 回调方法
/// 验证设置上下文后，OnContextReady 方法被正确触发
/// </summary>
[Test]
public void SetContext_Should_Call_OnContextReady()
@ -66,8 +66,8 @@ public class ContextAwareTests
}
/// <summary>
/// 测试 GetContext 方法是否返回已设置的上下文
/// 验证通过 IContextAware 接口设置上下文后，GetContext 方法能正确返回相同的上下文实例
/// 测试 GetContext 方法是否返回已设置的上下文
/// 验证通过 IContextAware 接口设置上下文后，GetContext 方法能正确返回相同的上下文实例
/// </summary>
[Test]
public void GetContext_Should_Return_Set_Context()
@ -81,9 +81,9 @@ public class ContextAwareTests
}
/// <summary>
/// 测试 GetContext 方法在未设置上下文时的行为
/// 验证当内部 Context 为 null 时，GetContext 方法不会抛出异常
/// 此时应返回第一个架构上下文（在测试环境中验证不抛出异常即可）
/// 测试 GetContext 方法在未设置上下文时的行为
/// 验证当内部 Context 为 null 时，GetContext 方法不会抛出异常
/// 此时应返回第一个架构上下文（在测试环境中验证不抛出异常即可）
/// </summary>
[Test]
public void GetContext_Should_Return_FirstArchitectureContext_When_Not_Set()
@ -102,24 +102,24 @@ public class ContextAwareTests
}
/// <summary>
/// 用于测试的 ContextAware 实现类
/// 继承自 ContextAwareBase，提供公共访问的上下文属性和回调状态跟踪
/// 用于测试的 ContextAware 实现类
/// 继承自 ContextAwareBase，提供公共访问的上下文属性和回调状态跟踪
/// </summary>
public class TestContextAware : ContextAwareBase
{
/// <summary>
/// 获取内部上下文的公共访问属性
/// 获取内部上下文的公共访问属性
/// </summary>
public IArchitectureContext? PublicContext => Context;
/// <summary>
/// 跟踪 OnContextReady 方法是否被调用的状态
/// 跟踪 OnContextReady 方法是否被调用的状态
/// </summary>
public bool OnContextReadyCalled { get; private set; }
/// <summary>
/// 重写上下文就绪回调方法
/// 设置 OnContextReadyCalled 标志为 true，用于测试验证
/// 重写上下文就绪回调方法
/// 设置 OnContextReadyCalled 标志为 true，用于测试验证
/// </summary>
protected override void OnContextReady()
{

104
GFramework.Core.Tests/state/StateMachineSystemTests.cs
View File

@ -15,21 +15,21 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.state;
/// <summary>
/// ContextAwareStateMachine类的单元测试
/// 测试内容包括：
/// - 作为ISystem的集成测试
/// - Init方法 - 初始化上下文感知状态
/// - Init方法 - 设置Context属性
/// - Destroy方法 - 清理状态
/// - OnArchitecturePhase方法 - 接收架构阶段
/// - 上下文感知状态初始化
/// - 状态变更事件发送
/// - SetContext方法
/// - GetContext方法
/// - ISystem接口实现验证
/// - 与EventBus的集成测试
/// - 多状态注册和切换
/// - 状态机生命周期完整性
/// ContextAwareStateMachine类的单元测试
/// 测试内容包括：
/// - 作为ISystem的集成测试
/// - Init方法 - 初始化上下文感知状态
/// - Init方法 - 设置Context属性
/// - Destroy方法 - 清理状态
/// - OnArchitecturePhase方法 - 接收架构阶段
/// - 上下文感知状态初始化
/// - 状态变更事件发送
/// - SetContext方法
/// - GetContext方法
/// - ISystem接口实现验证
/// - 与EventBus的集成测试
/// - 多状态注册和切换
/// - 状态机生命周期完整性
/// </summary>
[TestFixture]
public class StateMachineSystemTests
@ -66,7 +66,7 @@ public class StateMachineSystemTests
private EventBus? _eventBus;
/// <summary>
/// 测试ContextAwareStateMachine实现ISystem接口
/// 测试ContextAwareStateMachine实现ISystem接口
/// </summary>
[Test]
public void ContextAwareStateMachine_Should_Implement_ISystem_Interface()
@ -75,7 +75,7 @@ public class StateMachineSystemTests
}
/// <summary>
/// 测试SetContext设置Context属性
/// 测试SetContext设置Context属性
/// </summary>
[Test]
public void SetContext_Should_Set_Context_Property()
@ -87,7 +87,7 @@ public class StateMachineSystemTests
}
/// <summary>
/// 测试GetContext返回Context属性
/// 测试GetContext返回Context属性
/// </summary>
[Test]
public void GetContext_Should_Return_Context_Property()
@ -100,7 +100,7 @@ public class StateMachineSystemTests
}
/// <summary>
/// 测试Init方法为所有ContextAware状态设置Context
/// 测试Init方法为所有ContextAware状态设置Context
/// </summary>
[Test]
public void Init_Should_SetContext_On_All_ContextAware_States()
@ -121,7 +121,7 @@ public class StateMachineSystemTests
}
/// <summary>
/// 测试Init方法不为非ContextAware状态设置Context
/// 测试Init方法不为非ContextAware状态设置Context
/// </summary>
[Test]
public void Init_Should_Not_SetContext_On_NonContextAware_States()
@ -133,7 +133,7 @@ public class StateMachineSystemTests
}
/// <summary>
/// 测试Destroy方法不抛出异常
/// 测试Destroy方法不抛出异常
/// </summary>
[Test]
public void Destroy_Should_Not_Throw_Exception()
@ -142,7 +142,7 @@ public class StateMachineSystemTests
}
/// <summary>
/// 测试OnArchitecturePhase方法不抛出异常
/// 测试OnArchitecturePhase方法不抛出异常
/// </summary>
[Test]
public void OnArchitecturePhase_Should_Not_Throw_Exception()
@ -152,14 +152,14 @@ public class StateMachineSystemTests
}
/// <summary>
/// 测试ChangeTo发送StateChangedEvent事件
/// 验证当状态机切换到新状态时，会正确触发StateChangedEvent事件，并且事件中的旧状态为null（首次切换）
/// 测试ChangeTo发送StateChangedEvent事件
/// 验证当状态机切换到新状态时，会正确触发StateChangedEvent事件，并且事件中的旧状态为null（首次切换）
/// </summary>
[Test]
public void ChangeTo_Should_Send_StateChangedEvent()
{
// 订阅StateChangedEvent事件以验证事件是否被正确发送
bool eventReceived = false;
var eventReceived = false;
StateChangedEvent? receivedEvent = null;
_eventBus!.Register<StateChangedEvent>(e =>
@ -183,15 +183,15 @@ public class StateMachineSystemTests
}
/// <summary>
/// 测试ChangeTo发送StateChangedEvent事件（包含旧状态）
/// 验证当状态机从一个状态切换到另一个状态时，会正确触发StateChangedEvent事件，
/// 并且事件中包含正确的旧状态和新状态信息
/// 测试ChangeTo发送StateChangedEvent事件（包含旧状态）
/// 验证当状态机从一个状态切换到另一个状态时，会正确触发StateChangedEvent事件，
/// 并且事件中包含正确的旧状态和新状态信息
/// </summary>
[Test]
public void ChangeTo_Should_Send_StateChangedEvent_With_OldState()
{
// 订阅StateChangedEvent事件以验证事件是否被正确发送
bool eventReceived = false;
var eventReceived = false;
StateChangedEvent? receivedEvent = null;
_eventBus!.Register<StateChangedEvent>(e =>
@ -216,8 +216,8 @@ public class StateMachineSystemTests
}
/// <summary>
/// 测试CanChangeTo方法对于已注册状态的工作情况
/// 验证当状态已注册到状态机中时，CanChangeTo方法应返回true
/// 测试CanChangeTo方法对于已注册状态的工作情况
/// 验证当状态已注册到状态机中时，CanChangeTo方法应返回true
/// </summary>
[Test]
public void CanChangeTo_Should_Work_With_Registered_States()
@ -231,8 +231,8 @@ public class StateMachineSystemTests
}
/// <summary>
/// 测试可以注册多个状态
/// 验证状态机能够成功注册多个不同的状态实例，并且能够切换到这些已注册的状态
/// 测试可以注册多个状态
/// 验证状态机能够成功注册多个不同的状态实例，并且能够切换到这些已注册的状态
/// </summary>
[Test]
public void Multiple_States_Should_Be_Registered()
@ -251,7 +251,7 @@ public class StateMachineSystemTests
/// <summary>
/// 测试状态机生命周期完整
/// 测试状态机生命周期完整
/// </summary>
[Test]
public void StateMachine_Lifecycle_Should_Be_Complete()
@ -275,24 +275,27 @@ public class StateMachineSystemTests
#region Test Classes
/// <summary>
/// 测试用的ContextAwareStateMachine派生类，用于访问内部状态字典
/// 测试用的ContextAwareStateMachine派生类，用于访问内部状态字典
/// </summary>
public class TestStateMachineSystemV5 : StateMachineSystem
{
/// <summary>
/// 获取状态机内部的状态字典
/// 获取状态机内部的状态字典
/// </summary>
/// <returns>类型到状态实例的映射字典</returns>
public Dictionary<Type, IState> GetStates() => States;
public Dictionary<Type, IState> GetStates()
{
return States;
}
}
/// <summary>
/// 测试用的上下文感知状态基类实现
/// 测试用的上下文感知状态基类实现
/// </summary>
public class TestContextAwareStateV5 : ContextAwareStateBase
{
/// <summary>
/// 进入状态时调用
/// 进入状态时调用
/// </summary>
/// <param name="previous">前一个状态</param>
public override void OnEnter(IState? previous)
@ -300,7 +303,7 @@ public class TestContextAwareStateV5 : ContextAwareStateBase
}
/// <summary>
/// 退出状态时调用
/// 退出状态时调用
/// </summary>
/// <param name="next">下一个状态</param>
public override void OnExit(IState? next)
@ -309,12 +312,12 @@ public class TestContextAwareStateV5 : ContextAwareStateBase
}
/// <summary>
/// 第二个测试用的上下文感知状态基类实现
/// 第二个测试用的上下文感知状态基类实现
/// </summary>
public class TestContextAwareStateV5_2 : ContextAwareStateBase
{
/// <summary>
/// 进入状态时调用
/// 进入状态时调用
/// </summary>
/// <param name="previous">前一个状态</param>
public override void OnEnter(IState? previous)
@ -322,7 +325,7 @@ public class TestContextAwareStateV5_2 : ContextAwareStateBase
}
/// <summary>
/// 退出状态时调用
/// 退出状态时调用
/// </summary>
/// <param name="next">下一个状态</param>
public override void OnExit(IState? next)
@ -331,24 +334,27 @@ public class TestContextAwareStateV5_2 : ContextAwareStateBase
}
/// <summary>
/// 测试用的普通状态实现
/// 测试用的普通状态实现
/// </summary>
public class TestStateV5 : IState
{
/// <summary>
/// 状态标识符
/// 状态标识符
/// </summary>
public int Id { get; set; }
/// <summary>
/// 检查是否可以转换到指定状态
/// 检查是否可以转换到指定状态
/// </summary>
/// <param name="next">目标状态</param>
/// <returns>始终返回true表示允许转换</returns>
public bool CanTransitionTo(IState next) => true;
public bool CanTransitionTo(IState next)
{
return true;
}
/// <summary>
/// 进入状态时调用
/// 进入状态时调用
/// </summary>
/// <param name="previous">前一个状态</param>
public void OnEnter(IState? previous)
@ -356,7 +362,7 @@ public class TestStateV5 : IState
}
/// <summary>
/// 退出状态时调用
/// 退出状态时调用
/// </summary>
/// <param name="next">下一个状态</param>
public void OnExit(IState? next)

64
GFramework.Core.Tests/state/StateMachineTests.cs
View File

@ -6,13 +6,13 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.state;
/// <summary>
/// 测试状态机功能的单元测试类
/// 测试状态机功能的单元测试类
/// </summary>
[TestFixture]
public class StateMachineTests
{
/// <summary>
/// 在每个测试方法执行前初始化状态机实例
/// 在每个测试方法执行前初始化状态机实例
/// </summary>
[SetUp]
public void SetUp()
@ -23,7 +23,7 @@ public class StateMachineTests
private StateMachine _stateMachine = null!;
/// <summary>
/// 验证当没有活动状态时，当前状态应为null
/// 验证当没有活动状态时，当前状态应为null
/// </summary>
[Test]
public void Current_Should_BeNull_When_NoState_Active()
@ -32,7 +32,7 @@ public class StateMachineTests
}
/// <summary>
/// 验证注册状态后，状态会被添加到状态字典中
/// 验证注册状态后，状态会被添加到状态字典中
/// </summary>
[Test]
public void Register_Should_AddState_To_StatesDictionary()
@ -44,7 +44,7 @@ public class StateMachineTests
}
/// <summary>
/// 验证ChangeTo方法能够正确设置当前状态
/// 验证ChangeTo方法能够正确设置当前状态
/// </summary>
[Test]
public void ChangeTo_Should_SetCurrentState()
@ -57,7 +57,7 @@ public class StateMachineTests
}
/// <summary>
/// 验证ChangeTo方法会调用OnEnter回调
/// 验证ChangeTo方法会调用OnEnter回调
/// </summary>
[Test]
public void ChangeTo_Should_Invoke_OnEnter()
@ -71,7 +71,7 @@ public class StateMachineTests
}
/// <summary>
/// 验证当存在当前状态时，切换到新状态会调用原状态的OnExit回调
/// 验证当存在当前状态时，切换到新状态会调用原状态的OnExit回调
/// </summary>
[Test]
public void ChangeTo_When_CurrentStateExists_Should_Invoke_OnExit()
@ -89,7 +89,7 @@ public class StateMachineTests
}
/// <summary>
/// 验证当存在当前状态时，切换到新状态会调用新状态的OnEnter回调
/// 验证当存在当前状态时，切换到新状态会调用新状态的OnEnter回调
/// </summary>
[Test]
public void ChangeTo_When_CurrentStateExists_Should_Invoke_OnEnter()
@ -107,7 +107,7 @@ public class StateMachineTests
}
/// <summary>
/// 验证切换到相同状态时不应调用回调方法
/// 验证切换到相同状态时不应调用回调方法
/// </summary>
[Test]
public void ChangeTo_ToSameState_Should_NotInvoke_Callbacks()
@ -126,7 +126,7 @@ public class StateMachineTests
}
/// <summary>
/// 验证切换到未注册状态时应抛出InvalidOperationException异常
/// 验证切换到未注册状态时应抛出InvalidOperationException异常
/// </summary>
[Test]
public void ChangeTo_ToUnregisteredState_Should_ThrowInvalidOperationException()
@ -135,7 +135,7 @@ public class StateMachineTests
}
/// <summary>
/// 验证当状态未注册时CanChangeTo方法应返回false
/// 验证当状态未注册时CanChangeTo方法应返回false
/// </summary>
[Test]
public void CanChangeTo_WhenStateNotRegistered_Should_ReturnFalse()
@ -145,7 +145,7 @@ public class StateMachineTests
}
/// <summary>
/// 验证当状态已注册时CanChangeTo方法应返回true
/// 验证当状态已注册时CanChangeTo方法应返回true
/// </summary>
[Test]
public void CanChangeTo_WhenStateRegistered_Should_ReturnTrue()
@ -158,7 +158,7 @@ public class StateMachineTests
}
/// <summary>
/// 验证当当前状态拒绝转换时CanChangeTo方法应返回false
/// 验证当当前状态拒绝转换时CanChangeTo方法应返回false
/// </summary>
[Test]
public void CanChangeTo_WhenCurrentStateDeniesTransition_Should_ReturnFalse()
@ -195,7 +195,7 @@ public class StateMachineTests
}
/// <summary>
/// 验证注销状态后应从字典中移除该状态
/// 验证注销状态后应从字典中移除该状态
/// </summary>
[Test]
public void Unregister_Should_RemoveState_FromDictionary()
@ -208,7 +208,7 @@ public class StateMachineTests
}
/// <summary>
/// 验证当活动状态被注销时应调用OnExit并清除当前状态
/// 验证当活动状态被注销时应调用OnExit并清除当前状态
/// </summary>
[Test]
public void Unregister_WhenStateIsActive_Should_Invoke_OnExit_AndClearCurrent()
@ -224,7 +224,7 @@ public class StateMachineTests
}
/// <summary>
/// 验证当非活动状态被注销时不应调用OnExit
/// 验证当非活动状态被注销时不应调用OnExit
/// </summary>
[Test]
public void Unregister_WhenStateNotActive_Should_Not_Invoke_OnExit()
@ -242,7 +242,7 @@ public class StateMachineTests
}
/// <summary>
/// 验证多次状态转换应正确调用回调方法
/// 验证多次状态转换应正确调用回调方法
/// </summary>
[Test]
public void MultipleStateChanges_Should_Invoke_Callbacks_Correctly()
@ -267,7 +267,7 @@ public class StateMachineTests
}
/// <summary>
/// 验证ChangeTo方法应遵循CanTransitionTo逻辑
/// 验证ChangeTo方法应遵循CanTransitionTo逻辑
/// </summary>
[Test]
public void ChangeTo_Should_Respect_CanTransitionTo_Logic()
@ -289,7 +289,7 @@ public class StateMachineTests
}
/// <summary>
/// 测试状态类V2版本，实现IState接口用于测试
/// 测试状态类V2版本，实现IState接口用于测试
/// </summary>
public sealed class TestStateV2 : IState
{
@ -302,7 +302,7 @@ public sealed class TestStateV2 : IState
public IState? ExitTo { get; private set; }
/// <summary>
/// 进入状态时的回调方法
/// 进入状态时的回调方法
/// </summary>
/// <param name="from">从哪个状态进入</param>
public void OnEnter(IState? from)
@ -313,7 +313,7 @@ public sealed class TestStateV2 : IState
}
/// <summary>
/// 离开状态时的回调方法
/// 离开状态时的回调方法
/// </summary>
/// <param name="to">离开到哪个状态</param>
public void OnExit(IState? to)
@ -324,7 +324,7 @@ public sealed class TestStateV2 : IState
}
/// <summary>
/// 判断是否可以转换到目标状态
/// 判断是否可以转换到目标状态
/// </summary>
/// <param name="target">目标状态</param>
/// <returns>是否允许转换</returns>
@ -335,7 +335,7 @@ public sealed class TestStateV2 : IState
}
/// <summary>
/// 测试状态类V3版本，实现IState接口用于测试
/// 测试状态类V3版本，实现IState接口用于测试
/// </summary>
public sealed class TestStateV3 : IState
{
@ -347,7 +347,7 @@ public sealed class TestStateV3 : IState
public IState? ExitTo { get; private set; }
/// <summary>
/// 进入状态时的回调方法
/// 进入状态时的回调方法
/// </summary>
/// <param name="from">从哪个状态进入</param>
public void OnEnter(IState? from)
@ -358,7 +358,7 @@ public sealed class TestStateV3 : IState
}
/// <summary>
/// 离开状态时的回调方法
/// 离开状态时的回调方法
/// </summary>
/// <param name="to">离开到哪个状态</param>
public void OnExit(IState? to)
@ -369,7 +369,7 @@ public sealed class TestStateV3 : IState
}
/// <summary>
/// 判断是否可以转换到目标状态
/// 判断是否可以转换到目标状态
/// </summary>
/// <param name="target">目标状态</param>
/// <returns>是否允许转换</returns>
@ -380,7 +380,7 @@ public sealed class TestStateV3 : IState
}
/// <summary>
/// 测试状态类V4版本，实现IState接口用于测试
/// 测试状态类V4版本，实现IState接口用于测试
/// </summary>
public sealed class TestStateV4 : IState
{
@ -392,7 +392,7 @@ public sealed class TestStateV4 : IState
public IState? ExitTo { get; private set; }
/// <summary>
/// 进入状态时的回调方法
/// 进入状态时的回调方法
/// </summary>
/// <param name="from">从哪个状态进入</param>
public void OnEnter(IState? from)
@ -403,7 +403,7 @@ public sealed class TestStateV4 : IState
}
/// <summary>
/// 离开状态时的回调方法
/// 离开状态时的回调方法
/// </summary>
/// <param name="to">离开到哪个状态</param>
public void OnExit(IState? to)
@ -414,7 +414,7 @@ public sealed class TestStateV4 : IState
}
/// <summary>
/// 判断是否可以转换到目标状态
/// 判断是否可以转换到目标状态
/// </summary>
/// <param name="target">目标状态</param>
/// <returns>是否允许转换</returns>
@ -425,12 +425,12 @@ public sealed class TestStateV4 : IState
}
/// <summary>
/// 状态机扩展方法类
/// 状态机扩展方法类
/// </summary>
public static class StateMachineExtensions
{
/// <summary>
/// 检查状态机是否包含指定类型的状态
/// 检查状态机是否包含指定类型的状态
/// </summary>
/// <typeparam name="T">要检查的状态类型</typeparam>
/// <param name="stateMachine">状态机实例</param>

112
GFramework.Core.Tests/state/StateTests.cs
View File

@ -4,13 +4,13 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.state;
/// <summary>
/// 测试状态模式实现的功能和行为
/// 测试状态模式实现的功能和行为
/// </summary>
[TestFixture]
public class StateTests
{
/// <summary>
/// 验证状态类是否正确实现了IState接口
/// 验证状态类是否正确实现了IState接口
/// </summary>
[Test]
public void State_Should_Implement_IState_Interface()
@ -21,7 +21,7 @@ public class StateTests
}
/// <summary>
/// 验证进入状态时OnEnter方法被正确调用并记录来源状态
/// 验证进入状态时OnEnter方法被正确调用并记录来源状态
/// </summary>
[Test]
public void OnEnter_Should_BeCalled_When_State_Enters()
@ -36,7 +36,7 @@ public class StateTests
}
/// <summary>
/// 验证当传入null作为来源状态时的处理情况
/// 验证当传入null作为来源状态时的处理情况
/// </summary>
[Test]
public void OnEnter_WithNull_Should_Set_EnterFrom_ToNull()
@ -50,7 +50,7 @@ public class StateTests
}
/// <summary>
/// 验证退出状态时OnExit方法被正确调用并记录目标状态
/// 验证退出状态时OnExit方法被正确调用并记录目标状态
/// </summary>
[Test]
public void OnExit_Should_BeCalled_When_State_Exits()
@ -65,7 +65,7 @@ public class StateTests
}
/// <summary>
/// 验证当传入null作为目标状态时的处理情况
/// 验证当传入null作为目标状态时的处理情况
/// </summary>
[Test]
public void OnExit_WithNull_Should_Set_ExitTo_ToNull()
@ -79,7 +79,7 @@ public class StateTests
}
/// <summary>
/// 验证允许转换时CanTransitionTo方法返回true
/// 验证允许转换时CanTransitionTo方法返回true
/// </summary>
[Test]
public void CanTransitionTo_WithAllowTrue_Should_ReturnTrue()
@ -93,7 +93,7 @@ public class StateTests
}
/// <summary>
/// 验证不允许转换时CanTransitionTo方法返回false
/// 验证不允许转换时CanTransitionTo方法返回false
/// </summary>
[Test]
public void CanTransitionTo_WithAllowFalse_Should_ReturnFalse()
@ -107,7 +107,7 @@ public class StateTests
}
/// <summary>
/// 验证CanTransitionTo方法正确接收目标状态参数
/// 验证CanTransitionTo方法正确接收目标状态参数
/// </summary>
[Test]
public void CanTransitionTo_Should_Receive_TargetState()
@ -123,7 +123,7 @@ public class StateTests
}
/// <summary>
/// 验证具有复杂转换规则的状态类功能
/// 验证具有复杂转换规则的状态类功能
/// </summary>
[Test]
public void State_WithComplexTransitionRules_Should_Work()
@ -137,7 +137,7 @@ public class StateTests
}
/// <summary>
/// 验证多个状态之间的协作功能
/// 验证多个状态之间的协作功能
/// </summary>
[Test]
public void MultipleStates_Should_WorkTogether()
@ -159,7 +159,7 @@ public class StateTests
}
/// <summary>
/// 验证状态对多次转换的跟踪能力
/// 验证状态对多次转换的跟踪能力
/// </summary>
[Test]
public void State_Should_Track_MultipleTransitions()
@ -177,7 +177,7 @@ public class StateTests
}
/// <summary>
/// 验证相同类型状态间的转换处理
/// 验证相同类型状态间的转换处理
/// </summary>
[Test]
public void State_Should_Handle_SameState_Transition()
@ -197,42 +197,42 @@ public class StateTests
}
/// <summary>
/// 具体状态实现类V2版本，用于测试状态的基本功能
/// 具体状态实现类V2版本，用于测试状态的基本功能
/// </summary>
public sealed class ConcreteStateV2 : IState
{
/// <summary>
/// 获取或设置是否允许转换
/// 获取或设置是否允许转换
/// </summary>
public bool AllowTransitions { get; set; } = true;
/// <summary>
/// 获取进入状态是否被调用的标志
/// 获取进入状态是否被调用的标志
/// </summary>
public bool EnterCalled { get; private set; }
/// <summary>
/// 获取退出状态是否被调用的标志
/// 获取退出状态是否被调用的标志
/// </summary>
public bool ExitCalled { get; private set; }
/// <summary>
/// 获取进入此状态的来源状态
/// 获取进入此状态的来源状态
/// </summary>
public IState? EnterFrom { get; private set; }
/// <summary>
/// 获取从此状态退出的目标状态
/// 获取从此状态退出的目标状态
/// </summary>
public IState? ExitTo { get; private set; }
/// <summary>
/// 获取或设置转换到目标状态时执行的动作
/// 获取或设置转换到目标状态时执行的动作
/// </summary>
public Action<IState>? CanTransitionToAction { get; set; }
/// <summary>
/// 进入当前状态时调用的方法
/// 进入当前状态时调用的方法
/// </summary>
/// <param name="from">从哪个状态进入</param>
public void OnEnter(IState? from)
@ -242,7 +242,7 @@ public sealed class ConcreteStateV2 : IState
}
/// <summary>
/// 退出当前状态时调用的方法
/// 退出当前状态时调用的方法
/// </summary>
/// <param name="to">退出到哪个状态</param>
public void OnExit(IState? to)
@ -252,7 +252,7 @@ public sealed class ConcreteStateV2 : IState
}
/// <summary>
/// 判断是否可以转换到目标状态
/// 判断是否可以转换到目标状态
/// </summary>
/// <param name="target">目标状态</param>
/// <returns>如果可以转换则返回true，否则返回false</returns>
@ -264,32 +264,32 @@ public sealed class ConcreteStateV2 : IState
}
/// <summary>
/// 具体状态实现类V3版本，用于测试状态的基本功能
/// 具体状态实现类V3版本，用于测试状态的基本功能
/// </summary>
public sealed class ConcreteStateV3 : IState
{
/// <summary>
/// 获取进入状态是否被调用的标志
/// 获取进入状态是否被调用的标志
/// </summary>
public bool EnterCalled { get; private set; }
/// <summary>
/// 获取退出状态是否被调用的标志
/// 获取退出状态是否被调用的标志
/// </summary>
public bool ExitCalled { get; private set; }
/// <summary>
/// 获取进入此状态的来源状态
/// 获取进入此状态的来源状态
/// </summary>
public IState? EnterFrom { get; private set; }
/// <summary>
/// 获取从此状态退出的目标状态
/// 获取从此状态退出的目标状态
/// </summary>
public IState? ExitTo { get; private set; }
/// <summary>
/// 进入当前状态时调用的方法
/// 进入当前状态时调用的方法
/// </summary>
/// <param name="from">从哪个状态进入</param>
public void OnEnter(IState? from)
@ -299,7 +299,7 @@ public sealed class ConcreteStateV3 : IState
}
/// <summary>
/// 退出当前状态时调用的方法
/// 退出当前状态时调用的方法
/// </summary>
/// <param name="to">退出到哪个状态</param>
public void OnExit(IState? to)
@ -309,7 +309,7 @@ public sealed class ConcreteStateV3 : IState
}
/// <summary>
/// 判断是否可以转换到目标状态
/// 判断是否可以转换到目标状态
/// </summary>
/// <param name="target">目标状态</param>
/// <returns>如果可以转换则返回true，否则返回false</returns>
@ -320,32 +320,32 @@ public sealed class ConcreteStateV3 : IState
}
/// <summary>
/// 具体状态实现类V4版本，用于测试状态的基本功能
/// 具体状态实现类V4版本，用于测试状态的基本功能
/// </summary>
public sealed class ConcreteStateV4 : IState
{
/// <summary>
/// 获取进入状态是否被调用的标志
/// 获取进入状态是否被调用的标志
/// </summary>
public bool EnterCalled { get; private set; }
/// <summary>
/// 获取退出状态是否被调用的标志
/// 获取退出状态是否被调用的标志
/// </summary>
public bool ExitCalled { get; private set; }
/// <summary>
/// 获取进入此状态的来源状态
/// 获取进入此状态的来源状态
/// </summary>
public IState? EnterFrom { get; private set; }
/// <summary>
/// 获取从此状态退出的目标状态
/// 获取从此状态退出的目标状态
/// </summary>
public IState? ExitTo { get; private set; }
/// <summary>
/// 进入当前状态时调用的方法
/// 进入当前状态时调用的方法
/// </summary>
/// <param name="from">从哪个状态进入</param>
public void OnEnter(IState? from)
@ -355,7 +355,7 @@ public sealed class ConcreteStateV4 : IState
}
/// <summary>
/// 退出当前状态时调用的方法
/// 退出当前状态时调用的方法
/// </summary>
/// <param name="to">退出到哪个状态</param>
public void OnExit(IState? to)
@ -365,7 +365,7 @@ public sealed class ConcreteStateV4 : IState
}
/// <summary>
/// 判断是否可以转换到目标状态
/// 判断是否可以转换到目标状态
/// </summary>
/// <param name="target">目标状态</param>
/// <returns>如果可以转换则返回true，否则返回false</returns>
@ -376,37 +376,37 @@ public sealed class ConcreteStateV4 : IState
}
/// <summary>
/// 条件状态实现类V2版本，支持基于类型的条件转换规则
/// 条件状态实现类V2版本，支持基于类型的条件转换规则
/// </summary>
public sealed class ConditionalStateV2 : IState
{
/// <summary>
/// 获取或设置允许转换到的状态类型数组
/// 获取或设置允许转换到的状态类型数组
/// </summary>
public Type[] AllowedTransitions { get; set; } = Array.Empty<Type>();
/// <summary>
/// 获取进入状态是否被调用的标志
/// 获取进入状态是否被调用的标志
/// </summary>
public bool EnterCalled { get; private set; }
/// <summary>
/// 获取退出状态是否被调用的标志
/// 获取退出状态是否被调用的标志
/// </summary>
public bool ExitCalled { get; private set; }
/// <summary>
/// 获取进入此状态的来源状态
/// 获取进入此状态的来源状态
/// </summary>
public IState? EnterFrom { get; private set; }
/// <summary>
/// 获取从此状态退出的目标状态
/// 获取从此状态退出的目标状态
/// </summary>
public IState? ExitTo { get; private set; }
/// <summary>
/// 进入当前状态时调用的方法
/// 进入当前状态时调用的方法
/// </summary>
/// <param name="from">从哪个状态进入</param>
public void OnEnter(IState? from)
@ -416,7 +416,7 @@ public sealed class ConditionalStateV2 : IState
}
/// <summary>
/// 退出当前状态时调用的方法
/// 退出当前状态时调用的方法
/// </summary>
/// <param name="to">退出到哪个状态</param>
public void OnExit(IState? to)
@ -426,7 +426,7 @@ public sealed class ConditionalStateV2 : IState
}
/// <summary>
/// 判断是否可以转换到目标状态
/// 判断是否可以转换到目标状态
/// </summary>
/// <param name="target">目标状态</param>
/// <returns>如果目标状态类型在允许列表中则返回true，否则返回false</returns>
@ -437,32 +437,32 @@ public sealed class ConditionalStateV2 : IState
}
/// <summary>
/// 跟踪状态实现类V2版本，用于跟踪状态转换次数
/// 跟踪状态实现类V2版本，用于跟踪状态转换次数
/// </summary>
public sealed class TrackingStateV2 : IState
{
/// <summary>
/// 获取进入状态被调用的次数
/// 获取进入状态被调用的次数
/// </summary>
public int EnterCallCount { get; private set; }
/// <summary>
/// 获取退出状态被调用的次数
/// 获取退出状态被调用的次数
/// </summary>
public int ExitCallCount { get; private set; }
/// <summary>
/// 获取进入此状态的来源状态
/// 获取进入此状态的来源状态
/// </summary>
public IState? EnterFrom { get; private set; }
/// <summary>
/// 获取从此状态退出的目标状态
/// 获取从此状态退出的目标状态
/// </summary>
public IState? ExitTo { get; private set; }
/// <summary>
/// 进入当前状态时调用的方法
/// 进入当前状态时调用的方法
/// </summary>
/// <param name="from">从哪个状态进入</param>
public void OnEnter(IState? from)
@ -472,7 +472,7 @@ public sealed class TrackingStateV2 : IState
}
/// <summary>
/// 退出当前状态时调用的方法
/// 退出当前状态时调用的方法
/// </summary>
/// <param name="to">退出到哪个状态</param>
public void OnExit(IState? to)
@ -482,7 +482,7 @@ public sealed class TrackingStateV2 : IState
}
/// <summary>
/// 判断是否可以转换到目标状态
/// 判断是否可以转换到目标状态
/// </summary>
/// <param name="target">目标状态</param>
/// <returns>总是返回true</returns>

66
GFramework.Core.Tests/utility/AbstractContextUtilityTests.cs
View File

@ -13,16 +13,16 @@ using NUnit.Framework;
namespace GFramework.Core.Tests.utility;
/// <summary>
/// AbstractContextUtility类的单元测试
/// 测试内容包括：
/// - 抽象工具类实现
/// - IContextUtility接口实现
/// - Init方法调用
/// - 日志初始化
/// - 上下文感知功能（SetContext, GetContext）
/// - 子类继承行为
/// - 工具初始化日志记录
/// - 工具生命周期完整性
/// AbstractContextUtility类的单元测试
/// 测试内容包括：
/// - 抽象工具类实现
/// - IContextUtility接口实现
/// - Init方法调用
/// - 日志初始化
/// - 上下文感知功能（SetContext, GetContext）
/// - 子类继承行为
/// - 工具初始化日志记录
/// - 工具生命周期完整性
/// </summary>
[TestFixture]
public class AbstractContextUtilityTests
@ -43,7 +43,7 @@ public class AbstractContextUtilityTests
private IocContainer _container = null!;
/// <summary>
/// 测试AbstractContextUtility实现IContextUtility接口
/// 测试AbstractContextUtility实现IContextUtility接口
/// </summary>
[Test]
public void AbstractContextUtility_Should_Implement_IContextUtility_Interface()
@ -54,7 +54,7 @@ public class AbstractContextUtilityTests
}
/// <summary>
/// 测试Init方法调用
/// 测试Init方法调用
/// </summary>
[Test]
public void Init_Should_Call_OnInit_Method()
@ -69,7 +69,7 @@ public class AbstractContextUtilityTests
}
/// <summary>
/// 测试Init方法设置Logger属性
/// 测试Init方法设置Logger属性
/// </summary>
[Test]
public void Init_Should_Set_Logger_Property()
@ -84,7 +84,7 @@ public class AbstractContextUtilityTests
}
/// <summary>
/// 测试Init方法记录初始化日志
/// 测试Init方法记录初始化日志
/// </summary>
[Test]
public void Init_Should_Log_Initialization()
@ -99,7 +99,7 @@ public class AbstractContextUtilityTests
}
/// <summary>
/// 测试Destroy方法调用
/// 测试Destroy方法调用
/// </summary>
[Test]
public void Destroy_Should_Call_OnDestroy_Method()
@ -115,7 +115,7 @@ public class AbstractContextUtilityTests
}
/// <summary>
/// 测试上下文感知功能 - SetContext方法
/// 测试上下文感知功能 - SetContext方法
/// </summary>
[Test]
public void SetContext_Should_Set_Context_Property()
@ -130,7 +130,7 @@ public class AbstractContextUtilityTests
}
/// <summary>
/// 测试上下文感知功能 - GetContext方法
/// 测试上下文感知功能 - GetContext方法
/// </summary>
[Test]
public void GetContext_Should_Return_Context_Property()
@ -146,7 +146,7 @@ public class AbstractContextUtilityTests
}
/// <summary>
/// 测试子类继承行为
/// 测试子类继承行为
/// </summary>
[Test]
public void Child_Class_Should_Override_OnInit_Method()
@ -163,7 +163,7 @@ public class AbstractContextUtilityTests
}
/// <summary>
/// 测试工具生命周期完整性
/// 测试工具生命周期完整性
/// </summary>
[Test]
public void ContextUtility_Should_Complete_Full_Lifecycle()
@ -186,7 +186,7 @@ public class AbstractContextUtilityTests
}
/// <summary>
/// 测试工具类可以多次初始化和销毁
/// 测试工具类可以多次初始化和销毁
/// </summary>
[Test]
public void ContextUtility_Should_Be_Initializable_And_Destroyable_Multiple_Times()
@ -211,27 +211,27 @@ public class AbstractContextUtilityTests
}
/// <summary>
/// 测试用上下文工具类V1
/// 测试用上下文工具类V1
/// </summary>
public sealed class TestContextUtilityV1 : AbstractContextUtility
{
/// <summary>
/// 获取工具是否已初始化
/// 获取工具是否已初始化
/// </summary>
public bool Initialized { get; private set; }
/// <summary>
/// 获取工具是否已销毁
/// 获取工具是否已销毁
/// </summary>
public bool Destroyed { get; set; }
/// <summary>
/// 获取Init方法是否被调用
/// 获取Init方法是否被调用
/// </summary>
public bool InitCalled { get; private set; }
/// <summary>
/// 获取Logger对象（用于测试）
/// 获取Logger对象（用于测试）
/// </summary>
public ILogger? GetLogger()
{
@ -239,7 +239,7 @@ public sealed class TestContextUtilityV1 : AbstractContextUtility
}
/// <summary>
/// 初始化方法
/// 初始化方法
/// </summary>
protected override void OnInit()
{
@ -248,7 +248,7 @@ public sealed class TestContextUtilityV1 : AbstractContextUtility
}
/// <summary>
/// 销毁方法
/// 销毁方法
/// </summary>
protected override void OnDestroy()
{
@ -257,27 +257,27 @@ public sealed class TestContextUtilityV1 : AbstractContextUtility
}
/// <summary>
/// 测试用上下文工具类V2，自定义初始化逻辑
/// 测试用上下文工具类V2，自定义初始化逻辑
/// </summary>
public sealed class TestContextUtilityV2 : AbstractContextUtility
{
/// <summary>
/// 获取工具是否已初始化
/// 获取工具是否已初始化
/// </summary>
public bool Initialized { get; private set; }
/// <summary>
/// 获取工具是否已销毁
/// 获取工具是否已销毁
/// </summary>
public bool Destroyed { get; set; }
/// <summary>
/// 获取自定义初始化是否完成
/// 获取自定义初始化是否完成
/// </summary>
public bool CustomInitializationDone { get; private set; }
/// <summary>
/// 初始化方法（自定义逻辑）
/// 初始化方法（自定义逻辑）
/// </summary>
protected override void OnInit()
{
@ -286,7 +286,7 @@ public sealed class TestContextUtilityV2 : AbstractContextUtility
}
/// <summary>
/// 销毁方法
/// 销毁方法
/// </summary>
protected override void OnDestroy()
{

2
GFramework.Core/GFramework.Core.csproj
View File

@ -7,6 +7,6 @@
<Nullable>enable</Nullable>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="..\$(AssemblyName).Abstractions\$(AssemblyName).Abstractions.csproj" />
<ProjectReference Include="..\$(AssemblyName).Abstractions\$(AssemblyName).Abstractions.csproj"/>
</ItemGroup>
</Project>

17
GFramework.Core/architecture/Architecture.cs
View File

@ -1,7 +1,3 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using GFramework.Core.Abstractions.architecture;
using GFramework.Core.Abstractions.enums;
using GFramework.Core.Abstractions.environment;
@ -86,9 +82,11 @@ public abstract class Architecture(
#endregion
#region Fields
private readonly TaskCompletionSource _readyTcs = new(TaskCreationOptions.RunContinuationsAsynchronously);
public bool IsReady => CurrentPhase == ArchitecturePhase.Ready;
/// <summary>
/// 待初始化组件的去重集合
/// </summary>
@ -336,13 +334,9 @@ public abstract class Architecture(
private static async Task InitializeComponentAsync(IInitializable component, bool asyncMode)
{
if (asyncMode && component is IAsyncInitializable asyncInit)
{
await asyncInit.InitializeAsync();
}
else
{
component.Init();
}
}
/// <summary>
@ -557,16 +551,17 @@ public abstract class Architecture(
EnterPhase(ArchitecturePhase.Ready);
// 🔥 释放 Ready await
_readyTcs.TrySetResult();
_logger.Info($"Architecture {GetType().Name} is ready - all components initialized");
}
/// <summary>
/// 等待架构初始化完成（Ready 阶段）
/// 等待架构初始化完成（Ready 阶段）
/// </summary>
public Task WaitUntilReadyAsync()
{
return IsReady ? Task.CompletedTask : _readyTcs.Task;
}
#endregion
}

14
GFramework.Core/architecture/ArchitectureServices.cs
View File

@ -26,8 +26,6 @@ public class ArchitectureServices : IArchitectureServices
/// </summary>
private readonly ICommandBus _commandBus;
private readonly IIocContainer _container;
/// <summary>
/// 事件总线实例
/// </summary>
@ -45,7 +43,7 @@ public class ArchitectureServices : IArchitectureServices
/// </summary>
public ArchitectureServices()
{
_container = new IocContainer();
Container = new IocContainer();
// 创建服务实例
_eventBus = new EventBus();
@ -54,16 +52,16 @@ public class ArchitectureServices : IArchitectureServices
_asyncQueryBus = new AsyncQueryBus();
// 将服务注册到容器
_container.RegisterPlurality(_eventBus);
_container.RegisterPlurality(_commandBus);
_container.RegisterPlurality(_queryBus);
_container.RegisterPlurality(_asyncQueryBus);
Container.RegisterPlurality(_eventBus);
Container.RegisterPlurality(_commandBus);
Container.RegisterPlurality(_queryBus);
Container.RegisterPlurality(_asyncQueryBus);
}
/// <summary>
/// 获取依赖注入容器
/// </summary>
public IIocContainer Container => _container;
public IIocContainer Container { get; }
/// <summary>
/// 获取类型事件系统

5
GFramework.Core/architecture/GameContext.cs
View File

@ -1,7 +1,4 @@
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Collections.Concurrent;
using GFramework.Core.Abstractions.architecture;
namespace GFramework.Core.architecture;

61
GFramework.Core/architecture/README.md
View File

@ -147,12 +147,12 @@ public enum ArchitecturePhase
// 1. 定义你的架构（继承 Architecture 基类）
public class GameArchitecture : Architecture
{
protected override void Init()
{
// 注册 Model
RegisterModel(new PlayerModel());
RegisterModel(new InventoryModel());
protected override void Init()
{
// 注册 Model
RegisterModel(new PlayerModel());
RegisterModel(new InventoryModel());
// 注册 System
RegisterSystem(new GameplaySystem());
RegisterSystem(new SaveSystem());
@ -161,6 +161,7 @@ public class GameArchitecture : Architecture
RegisterUtility(new StorageUtility());
RegisterUtility(new TimeUtility());
}
}
// 2. 创建并初始化架构
@ -175,8 +176,8 @@ architecture.Initialize();
// 在 Controller 或其他组件中注入架构实例
public class GameController : IController
{
private readonly IArchitecture _architecture;
private readonly IArchitecture _architecture;
// 通过构造函数注入架构
public GameController(IArchitecture architecture)
{
@ -202,7 +203,9 @@ public class GameController : IController
{
// 处理玩家死亡事件
}
}
```
**核心方法与属性：**
@ -244,6 +247,7 @@ await architecture.InitializeAsync(); // 异步等待初始化完成
```
**优势：**
- 支持异步初始化 Model 和 System
- 可以利用异步 I/O 操作（如异步加载数据）
- 提高初始化性能
@ -259,6 +263,7 @@ public void InstallModule(IArchitectureModule module)
```
**参数：**
- `module`：要安装的模块实例
**使用示例：**
@ -291,6 +296,7 @@ public void RegisterLifecycleHook(IArchitectureLifecycle hook)
```
**参数：**
- `hook`：生命周期钩子实例
**使用示例：**
@ -389,28 +395,29 @@ architecture.InstallModule(module);
// 3. 监听架构阶段变化
public class GamePhaseListener : IArchitecturePhaseAware
{
public void OnArchitecturePhase(ArchitecturePhase phase)
{
switch (phase)
{
case ArchitecturePhase.Ready:
GD.Print("架构已就绪，可以开始游戏了");
break;
case ArchitecturePhase.Destroying:
GD.Print("架构正在销毁");
break;
}
}
public void OnArchitecturePhase(ArchitecturePhase phase)
{
switch (phase)
{
case ArchitecturePhase.Ready:
GD.Print("架构已就绪，可以开始游戏了");
break;
case ArchitecturePhase.Destroying:
GD.Print("架构正在销毁");
break;
}
}
}
// 4. 生命周期钩子
public class LifecycleHook : IArchitectureLifecycle
{
public void OnPhase(ArchitecturePhase phase, IArchitecture architecture)
{
GD.Print($"架构阶段变化: {phase}");
}
public void OnPhase(ArchitecturePhase phase, IArchitecture architecture)
{
GD.Print($"架构阶段变化: {phase}");
}
}
```
### [`ArchitectureConfiguration`](ArchitectureConfiguration.cs)
@ -477,9 +484,9 @@ var architecture = new GameArchitecture(configuration: config);
1. **保持架构类简洁**：只在 `Init()` 中注册组件，不要包含业务逻辑
2. **合理划分职责**：
- Model：数据和状态
- System：业务逻辑和规则
- Utility：无状态的工具方法
- Model：数据和状态
- System：业务逻辑和规则
- Utility：无状态的工具方法
3. **使用依赖注入**：通过构造函数注入架构实例，便于测试
4. **事件命名规范**：使用过去式命名事件类，如 `PlayerDiedEvent`
5. **避免循环依赖**：System 不应直接引用 System，应通过事件通信

14
GFramework.Core/command/AbstractAsyncCommand.cs
View File

@ -4,14 +4,14 @@ using GFramework.Core.rule;
namespace GFramework.Core.command;
/// <summary>
/// 异步命令的抽象基类，实现了IAsyncCommand接口
/// 提供异步命令执行的基础框架和上下文感知功能
/// 异步命令的抽象基类，实现了IAsyncCommand接口
/// 提供异步命令执行的基础框架和上下文感知功能
/// </summary>
public abstract class AbstractAsyncCommand : ContextAwareBase, IAsyncCommand
{
/// <summary>
/// 执行异步命令的实现方法
/// 该方法通过调用受保护的抽象方法OnExecuteAsync来执行具体的命令逻辑
/// 执行异步命令的实现方法
/// 该方法通过调用受保护的抽象方法OnExecuteAsync来执行具体的命令逻辑
/// </summary>
/// <returns>表示异步操作的任务</returns>
async Task IAsyncCommand.ExecuteAsync()
@ -20,9 +20,9 @@ public abstract class AbstractAsyncCommand : ContextAwareBase, IAsyncCommand
}
/// <summary>
/// 子类必须实现的异步执行方法
/// 包含具体的命令执行逻辑
/// 子类必须实现的异步执行方法
/// 包含具体的命令执行逻辑
/// </summary>
/// <returns>表示异步操作的任务</returns>
protected abstract Task OnExecuteAsync();
}
}

6
GFramework.Core/command/AbstractAsyncCommandWithInput.cs
View File

@ -4,14 +4,14 @@ using GFramework.Core.rule;
namespace GFramework.Core.command;
/// <summary>
/// 抽象异步命令基类，用于处理无返回值的异步命令操作
/// 抽象异步命令基类，用于处理无返回值的异步命令操作
/// </summary>
/// <typeparam name="TInput">命令输入类型，必须实现ICommandInput接口</typeparam>
public abstract class AbstractAsyncCommand<TInput>(TInput input) : ContextAwareBase, IAsyncCommand
where TInput : ICommandInput
{
/// <summary>
/// 执行异步命令的实现方法
/// 执行异步命令的实现方法
/// </summary>
/// <returns>表示异步操作的任务</returns>
async Task IAsyncCommand.ExecuteAsync()
@ -20,7 +20,7 @@ public abstract class AbstractAsyncCommand<TInput>(TInput input) : ContextAwareB
}
/// <summary>
/// 定义异步执行逻辑的抽象方法，由派生类实现具体业务逻辑
/// 定义异步执行逻辑的抽象方法，由派生类实现具体业务逻辑
/// </summary>
/// <param name="input">命令输入参数</param>
/// <returns>表示异步操作的任务</returns>

6
GFramework.Core/command/AbstractAsyncCommandWithResult.cs
View File

@ -4,7 +4,7 @@ using GFramework.Core.rule;
namespace GFramework.Core.command;
/// <summary>
/// 抽象异步命令基类，用于处理有返回值的异步命令操作
/// 抽象异步命令基类，用于处理有返回值的异步命令操作
/// </summary>
/// <typeparam name="TInput">命令输入类型，必须实现ICommandInput接口</typeparam>
/// <typeparam name="TResult">命令执行结果类型</typeparam>
@ -12,7 +12,7 @@ public abstract class AbstractAsyncCommand<TInput, TResult>(TInput input) : Cont
where TInput : ICommandInput
{
/// <summary>
/// 执行异步命令并返回结果的实现方法
/// 执行异步命令并返回结果的实现方法
/// </summary>
/// <returns>表示异步操作且包含结果的任务</returns>
async Task<TResult> IAsyncCommand<TResult>.ExecuteAsync()
@ -21,7 +21,7 @@ public abstract class AbstractAsyncCommand<TInput, TResult>(TInput input) : Cont
}
/// <summary>
/// 定义异步执行逻辑的抽象方法，由派生类实现具体业务逻辑并返回结果
/// 定义异步执行逻辑的抽象方法，由派生类实现具体业务逻辑并返回结果
/// </summary>
/// <param name="input">命令输入参数</param>
/// <returns>表示异步操作且包含结果的任务</returns>

8
GFramework.Core/command/EmptyCommandInput.cs
View File

@ -3,10 +3,10 @@ using GFramework.Core.Abstractions.command;
namespace GFramework.Core.command;
/// <summary>
/// 空命令输入类，用于表示一个不包含任何输入参数的命令
/// 空命令输入类，用于表示一个不包含任何输入参数的命令
/// </summary>
/// <remarks>
/// 该类实现了ICommandInput接口，作为命令模式中的输入参数载体
/// 通常用于不需要额外输入参数的简单命令操作
/// 该类实现了ICommandInput接口，作为命令模式中的输入参数载体
/// 通常用于不需要额外输入参数的简单命令操作
/// </remarks>
public sealed class EmptyCommandInput : ICommandInput;
public sealed class EmptyCommandInput : ICommandInput;

59
GFramework.Core/coroutine/CoroutineHandle.cs
View File

@ -1,30 +1,30 @@
namespace GFramework.Core.coroutine;
/// <summary>
/// 协程句柄
/// 用于唯一标识和管理协程实例的结构体，通过ID系统实现协程的跟踪和比较功能
/// 协程句柄
/// 用于唯一标识和管理协程实例的结构体，通过ID系统实现协程的跟踪和比较功能
/// </summary>
public readonly struct CoroutineHandle : IEquatable<CoroutineHandle>
{
/// <summary>
/// 预留空间常量，用于ID分配的基数
/// 预留空间常量，用于ID分配的基数
/// </summary>
private const byte ReservedSpace = 0x0F;
/// <summary>
/// 下一个索引数组，用于跟踪每个实例ID的下一个可用索引位置
/// 索引范围：0-15，对应16个不同的实例槽位
/// 下一个索引数组，用于跟踪每个实例ID的下一个可用索引位置
/// 索引范围：0-15，对应16个不同的实例槽位
/// </summary>
private static readonly int[] NextIndex = new int[16];
/// <summary>
/// 协程句柄的内部ID，用于唯一标识协程实例
/// 协程句柄的内部ID，用于唯一标识协程实例
/// </summary>
private readonly int _id;
/// <summary>
/// 静态构造函数，初始化NextIndex数组的默认值
/// 将索引0的下一个可用位置设置为ReservedSpace + 1
/// 静态构造函数，初始化NextIndex数组的默认值
/// 将索引0的下一个可用位置设置为ReservedSpace + 1
/// </summary>
static CoroutineHandle()
{
@ -33,18 +33,18 @@ public readonly struct CoroutineHandle : IEquatable<CoroutineHandle>
/// <summary>
/// 获取当前协程句柄的键值（低4位）
/// 获取当前协程句柄的键值（低4位）
/// </summary>
public byte Key => (byte)(_id & ReservedSpace);
/// <summary>
/// 判断当前协程句柄是否有效
/// 有效性通过Key是否为0来判断
/// 判断当前协程句柄是否有效
/// 有效性通过Key是否为0来判断
/// </summary>
public bool IsValid => Key != 0;
/// <summary>
/// 构造函数，创建一个新的协程句柄
/// 构造函数，创建一个新的协程句柄
/// </summary>
/// <param name="instanceId">实例ID，用于区分不同的协程实例槽位</param>
public CoroutineHandle(byte instanceId)
@ -57,38 +57,53 @@ public readonly struct CoroutineHandle : IEquatable<CoroutineHandle>
}
/// <summary>
/// 比较当前协程句柄与另一个协程句柄是否相等
/// 比较当前协程句柄与另一个协程句柄是否相等
/// </summary>
/// <param name="other">要比较的协程句柄</param>
/// <returns>如果两个句柄的ID相同则返回true，否则返回false</returns>
public bool Equals(CoroutineHandle other) => _id == other._id;
public bool Equals(CoroutineHandle other)
{
return _id == other._id;
}
/// <summary>
/// 比较当前对象与指定对象是否相等
/// 比较当前对象与指定对象是否相等
/// </summary>
/// <param name="obj">要比较的对象</param>
/// <returns>如果对象是协程句柄且ID相同则返回true，否则返回false</returns>
public override bool Equals(object? obj) => obj is CoroutineHandle handle && Equals(handle);
public override bool Equals(object? obj)
{
return obj is CoroutineHandle handle && Equals(handle);
}
/// <summary>
/// 获取当前协程句柄的哈希码
/// 获取当前协程句柄的哈希码
/// </summary>
/// <returns>基于内部ID计算的哈希码</returns>
public override int GetHashCode() => _id;
public override int GetHashCode()
{
return _id;
}
/// <summary>
/// 比较两个协程句柄是否相等
/// 比较两个协程句柄是否相等
/// </summary>
/// <param name="a">第一个协程句柄</param>
/// <param name="b">第二个协程句柄</param>
/// <returns>如果两个句柄的ID相同则返回true，否则返回false</returns>
public static bool operator ==(CoroutineHandle a, CoroutineHandle b) => a._id == b._id;
public static bool operator ==(CoroutineHandle a, CoroutineHandle b)
{
return a._id == b._id;
}
/// <summary>
/// 比较两个协程句柄是否不相等
/// 比较两个协程句柄是否不相等
/// </summary>
/// <param name="a">第一个协程句柄</param>
/// <param name="b">第二个协程句柄</param>
/// <returns>如果两个句柄的ID不同则返回true，否则返回false</returns>
public static bool operator !=(CoroutineHandle a, CoroutineHandle b) => a._id != b._id;
public static bool operator !=(CoroutineHandle a, CoroutineHandle b)
{
return a._id != b._id;
}
}

31
GFramework.Core/coroutine/CoroutineHelper.cs
View File

@ -1,16 +1,15 @@
using System.Threading;
using GFramework.Core.Abstractions.coroutine;
using GFramework.Core.coroutine.instructions;
namespace GFramework.Core.coroutine;
/// <summary>
/// 协程辅助方法
/// 协程辅助方法
/// </summary>
public static class CoroutineHelper
{
/// <summary>
/// 等待指定秒数
/// 等待指定秒数
/// </summary>
/// <param name="seconds">要等待的秒数</param>
/// <returns>延迟等待指令</returns>
@ -20,7 +19,7 @@ public static class CoroutineHelper
}
/// <summary>
/// 等待一帧
/// 等待一帧
/// </summary>
/// <returns>等待一帧的指令</returns>
public static WaitOneFrame WaitForOneFrame()
@ -29,7 +28,7 @@ public static class CoroutineHelper
}
/// <summary>
/// 等待指定帧数
/// 等待指定帧数
/// </summary>
/// <param name="frames">要等待的帧数</param>
/// <returns>等待帧数指令</returns>
@ -39,7 +38,7 @@ public static class CoroutineHelper
}
/// <summary>
/// 等待直到条件满足
/// 等待直到条件满足
/// </summary>
/// <param name="predicate">条件判断函数</param>
/// <returns>等待条件指令</returns>
@ -49,7 +48,7 @@ public static class CoroutineHelper
}
/// <summary>
/// 等待当条件为真时持续等待
/// 等待当条件为真时持续等待
/// </summary>
/// <param name="predicate">条件判断函数</param>
/// <returns>等待条件指令</returns>
@ -59,7 +58,7 @@ public static class CoroutineHelper
}
/// <summary>
/// 等待指定时间并提供进度回调
/// 等待指定时间并提供进度回调
/// </summary>
/// <param name="duration">等待的持续时间（秒）</param>
/// <param name="onProgress">进度回调函数，接收0-1之间的进度值</param>
@ -70,7 +69,7 @@ public static class CoroutineHelper
}
/// <summary>
/// 延迟调用指定的委托
/// 延迟调用指定的委托
/// </summary>
/// <param name="delay">延迟时间（秒）</param>
/// <param name="action">要执行的动作委托</param>
@ -82,7 +81,7 @@ public static class CoroutineHelper
}
/// <summary>
/// 重复调用指定的委托指定次数
/// 重复调用指定的委托指定次数
/// </summary>
/// <param name="interval">每次调用之间的间隔时间（秒）</param>
/// <param name="count">调用次数</param>
@ -96,17 +95,17 @@ public static class CoroutineHelper
yield return new Delay(interval);
}
}
/// <summary>
/// 无限重复调用指定的委托，直到条件不满足
/// 无限重复调用指定的委托，直到条件不满足
/// </summary>
/// <param name="interval">每次调用之间的间隔时间（秒）</param>
/// <param name="action">要执行的动作委托</param>
/// <param name="shouldContinue">继续执行的条件，返回false时停止</param>
/// <returns>返回一个枚举器，用于协程执行</returns>
public static IEnumerator<IYieldInstruction> RepeatCallForever(
double interval,
Action? action,
double interval,
Action? action,
Func<bool>? shouldContinue = null)
{
// 循环执行动作直到条件不再满足
@ -116,9 +115,9 @@ public static class CoroutineHelper
yield return new Delay(interval);
}
}
/// <summary>
/// 无限重复调用指定的委托，直到取消令牌被触发
/// 无限重复调用指定的委托，直到取消令牌被触发
/// </summary>
/// <param name="interval">每次调用之间的间隔时间（秒）</param>
/// <param name="action">要执行的动作委托</param>

10
GFramework.Core/coroutine/CoroutineMetadata.cs
View File

@ -3,27 +3,27 @@
namespace GFramework.Core.coroutine;
/// <summary>
/// 存储协程元数据信息的内部类，包含协程的状态、枚举器、标签等信息
/// 存储协程元数据信息的内部类，包含协程的状态、枚举器、标签等信息
/// </summary>
internal class CoroutineMetadata
{
/// <summary>
/// 协程在调度器中的槽位索引
/// 协程在调度器中的槽位索引
/// </summary>
public int SlotIndex;
/// <summary>
/// 协程当前的执行状态
/// 协程当前的执行状态
/// </summary>
public CoroutineState State;
/// <summary>
/// 协程的标签标识符，用于协程的分类和查找
/// 协程的标签标识符，用于协程的分类和查找
/// </summary>
public string? Tag;
/// <summary>
/// 判断协程是否处于活跃状态（运行中、暂停或挂起）
/// 判断协程是否处于活跃状态（运行中、暂停或挂起）
/// </summary>
public bool IsActive =>
State is CoroutineState.Running

62
GFramework.Core/coroutine/CoroutineScheduler.cs
View File

@ -3,7 +3,7 @@
namespace GFramework.Core.coroutine;
/// <summary>
/// 协程调度器，用于管理和执行协程
/// 协程调度器，用于管理和执行协程
/// </summary>
/// <param name="timeSource">时间源接口，提供时间相关数据</param>
/// <param name="instanceId">实例ID，默认为1</param>
@ -17,25 +17,29 @@ public sealed class CoroutineScheduler(
private readonly Dictionary<string, HashSet<CoroutineHandle>> _tagged = new();
private readonly ITimeSource _timeSource = timeSource ?? throw new ArgumentNullException(nameof(timeSource));
private readonly Dictionary<CoroutineHandle, HashSet<CoroutineHandle>> _waiting = new();
private int _activeCount;
private int _nextSlot;
private CoroutineSlot?[] _slots = new CoroutineSlot?[initialCapacity];
/// <summary>
/// 获取时间差值
/// 获取时间差值
/// </summary>
public double DeltaTime => _timeSource.DeltaTime;
/// <summary>
/// 获取活跃协程数量
/// 获取活跃协程数量
/// </summary>
public int ActiveCoroutineCount => _activeCount;
public int ActiveCoroutineCount { get; private set; }
public bool IsCoroutineAlive(CoroutineHandle handle)
{
return _metadata.ContainsKey(handle);
}
#region Run / Update
/// <summary>
/// 运行协程
/// 运行协程
/// </summary>
/// <param name="coroutine">要运行的协程枚举器</param>
/// <param name="tag">协程标签，可选</param>
@ -72,13 +76,13 @@ public sealed class CoroutineScheduler(
AddTag(tag, handle);
Prewarm(slotIndex);
_activeCount++;
ActiveCoroutineCount++;
return handle;
}
/// <summary>
/// 更新所有协程状态
/// 更新所有协程状态
/// </summary>
public void Update()
{
@ -106,13 +110,9 @@ public sealed class CoroutineScheduler(
// 2️⃣ 推进协程
if (!slot.Enumerator.MoveNext())
{
Complete(i);
}
else
{
slot.Waiting = slot.Enumerator.Current;
}
}
catch (Exception ex)
{
@ -126,7 +126,7 @@ public sealed class CoroutineScheduler(
#region Pause / Resume / Kill
/// <summary>
/// 暂停指定协程
/// 暂停指定协程
/// </summary>
/// <param name="handle">协程句柄</param>
/// <returns>是否成功暂停</returns>
@ -145,7 +145,7 @@ public sealed class CoroutineScheduler(
}
/// <summary>
/// 恢复指定协程
/// 恢复指定协程
/// </summary>
/// <param name="handle">协程句柄</param>
/// <returns>是否成功恢复</returns>
@ -164,7 +164,7 @@ public sealed class CoroutineScheduler(
}
/// <summary>
/// 终止指定协程
/// 终止指定协程
/// </summary>
/// <param name="handle">协程句柄</param>
/// <returns>是否成功终止</returns>
@ -182,7 +182,7 @@ public sealed class CoroutineScheduler(
#region Wait / Tag / Clear
/// <summary>
/// 让当前协程等待目标协程完成
/// 让当前协程等待目标协程完成
/// </summary>
/// <param name="current">当前协程句柄</param>
/// <param name="target">目标协程句柄</param>
@ -216,7 +216,7 @@ public sealed class CoroutineScheduler(
}
/// <summary>
/// 根据标签终止协程
/// 根据标签终止协程
/// </summary>
/// <param name="tag">协程标签</param>
/// <returns>被终止的协程数量</returns>
@ -229,12 +229,12 @@ public sealed class CoroutineScheduler(
}
/// <summary>
/// 清空所有协程
/// 清空所有协程
/// </summary>
/// <returns>被清除的协程数量</returns>
public int Clear()
{
var count = _activeCount;
var count = ActiveCoroutineCount;
Array.Clear(_slots);
_metadata.Clear();
@ -242,7 +242,7 @@ public sealed class CoroutineScheduler(
_waiting.Clear();
_nextSlot = 0;
_activeCount = 0;
ActiveCoroutineCount = 0;
return count;
}
@ -252,7 +252,7 @@ public sealed class CoroutineScheduler(
#region Internal
/// <summary>
/// 预热协程槽位，执行协程的第一步
/// 预热协程槽位，执行协程的第一步
/// </summary>
/// <param name="slotIndex">槽位索引</param>
private void Prewarm(int slotIndex)
@ -264,13 +264,9 @@ public sealed class CoroutineScheduler(
try
{
if (!slot.Enumerator.MoveNext())
{
Complete(slotIndex);
}
else
{
slot.Waiting = slot.Enumerator.Current;
}
}
catch (Exception ex)
{
@ -279,7 +275,7 @@ public sealed class CoroutineScheduler(
}
/// <summary>
/// 完成指定槽位的协程
/// 完成指定槽位的协程
/// </summary>
/// <param name="slotIndex">槽位索引</param>
private void Complete(int slotIndex)
@ -293,7 +289,7 @@ public sealed class CoroutineScheduler(
return;
_slots[slotIndex] = null;
_activeCount--;
ActiveCoroutineCount--;
RemoveTag(handle);
_metadata.Remove(handle);
@ -313,7 +309,7 @@ public sealed class CoroutineScheduler(
}
/// <summary>
/// 处理协程执行中的错误
/// 处理协程执行中的错误
/// </summary>
/// <param name="slotIndex">槽位索引</param>
/// <param name="ex">异常对象</param>
@ -324,7 +320,7 @@ public sealed class CoroutineScheduler(
}
/// <summary>
/// 扩展协程槽位数组容量
/// 扩展协程槽位数组容量
/// </summary>
private void Expand()
{
@ -332,7 +328,7 @@ public sealed class CoroutineScheduler(
}
/// <summary>
/// 为协程添加标签
/// 为协程添加标签
/// </summary>
/// <param name="tag">标签名称</param>
/// <param name="handle">协程句柄</param>
@ -349,7 +345,7 @@ public sealed class CoroutineScheduler(
}
/// <summary>
/// 移除协程标签
/// 移除协程标签
/// </summary>
/// <param name="handle">协程句柄</param>
private void RemoveTag(CoroutineHandle handle)
@ -368,8 +364,4 @@ public sealed class CoroutineScheduler(
}
#endregion
public bool IsCoroutineAlive(CoroutineHandle handle)
{
return _metadata.ContainsKey(handle);
}
}

20
GFramework.Core/coroutine/CoroutineSlot.cs
View File

@ -3,27 +3,27 @@
namespace GFramework.Core.coroutine;
/// <summary>
/// 协程槽位类，用于管理单个协程的执行状态和调度信息
/// 协程槽位类，用于管理单个协程的执行状态和调度信息
/// </summary>
internal sealed class CoroutineSlot
{
/// <summary>
/// 协程枚举器，包含协程的执行逻辑
/// 协程枚举器，包含协程的执行逻辑
/// </summary>
public required IEnumerator<IYieldInstruction> Enumerator;
/// <summary>
/// 协程当前状态
/// 协程句柄，用于标识和管理协程实例
/// </summary>
public CoroutineHandle Handle;
/// <summary>
/// 协程当前状态
/// </summary>
public CoroutineState State;
/// <summary>
/// 当前等待的指令，用于控制协程的暂停和恢复
/// 当前等待的指令，用于控制协程的暂停和恢复
/// </summary>
public IYieldInstruction? Waiting;
/// <summary>
/// 协程句柄，用于标识和管理协程实例
/// </summary>
public CoroutineHandle Handle;
}
}

44
GFramework.Core/coroutine/extensions/CoroutineExtensions.cs
View File

@ -4,12 +4,12 @@ using GFramework.Core.coroutine.instructions;
namespace GFramework.Core.coroutine.extensions;
/// <summary>
/// 协程相关的扩展方法
/// 协程相关的扩展方法
/// </summary>
public static class CoroutineExtensions
{
/// <summary>
/// 在指定时间间隔内重复执行动作的协程
/// 在指定时间间隔内重复执行动作的协程
/// </summary>
/// <param name="interval">执行间隔时间（秒）</param>
/// <param name="action">要重复执行的动作</param>
@ -20,10 +20,7 @@ public static class CoroutineExtensions
Action action,
int? count = null)
{
if (count is < 0)
{
yield break;
}
if (count is < 0) yield break;
var executedCount = 0;
while (count == null || executedCount < count)
@ -35,7 +32,7 @@ public static class CoroutineExtensions
}
/// <summary>
/// 在指定延迟后执行动作的协程
/// 在指定延迟后执行动作的协程
/// </summary>
/// <param name="delay">延迟时间（秒）</param>
/// <param name="action">要执行的动作</param>
@ -44,17 +41,14 @@ public static class CoroutineExtensions
double delay,
Action? action)
{
if (delay < 0)
{
yield break;
}
if (delay < 0) yield break;
yield return new Delay(delay);
action?.Invoke();
}
/// <summary>
/// 顺序执行多个协程
/// 顺序执行多个协程
/// </summary>
/// <param name="coroutines">要顺序执行的协程集合</param>
/// <returns>协程枚举器</returns>
@ -63,19 +57,16 @@ public static class CoroutineExtensions
{
foreach (var coroutine in coroutines)
{
while (coroutine.MoveNext())
{
yield return coroutine.Current;
}
while (coroutine.MoveNext()) yield return coroutine.Current;
// 清理协程
coroutine.Dispose();
}
}
/// <summary>
/// 并行执行多个协程（等待所有协程完成）
/// 注意：这需要协程调度器的支持，这里提供一个包装器返回多个句柄
/// 并行执行多个协程（等待所有协程完成）
/// 注意：这需要协程调度器的支持，这里提供一个包装器返回多个句柄
/// </summary>
/// <param name="scheduler">协程调度器</param>
/// <param name="coroutines">要并行执行的协程集合</param>
@ -84,10 +75,7 @@ public static class CoroutineExtensions
this CoroutineScheduler scheduler,
params IEnumerator<IYieldInstruction>[]? coroutines)
{
if (coroutines == null || coroutines.Length == 0)
{
yield break;
}
if (coroutines == null || coroutines.Length == 0) yield break;
// 启动所有协程并收集句柄
var handles = new List<CoroutineHandle>();
@ -98,11 +86,11 @@ public static class CoroutineExtensions
}
// 等待所有协程完成
yield return new WaitForAllCoroutines(scheduler,handles);
yield return new WaitForAllCoroutines(scheduler, handles);
}
/// <summary>
/// 带进度回调的等待协程
/// 带进度回调的等待协程
/// </summary>
/// <param name="totalTime">总等待时间（秒）</param>
/// <param name="onProgress">进度回调，参数为0-1之间的进度值</param>
@ -120,12 +108,8 @@ public static class CoroutineExtensions
onProgress?.Invoke(0.0f);
if (onProgress != null)
{
yield return new WaitForProgress(totalTime, onProgress);
}
else
{
yield return new Delay(totalTime);
}
}
}
}

14
GFramework.Core/coroutine/extensions/TaskCoroutineExtensions.cs
View File

@ -4,12 +4,12 @@ using GFramework.Core.coroutine.instructions;
namespace GFramework.Core.coroutine.extensions;
/// <summary>
/// Task与协程之间的扩展方法
/// Task与协程之间的扩展方法
/// </summary>
public static class TaskCoroutineExtensions
{
/// <summary>
/// 将Task转换为协程等待指令
/// 将Task转换为协程等待指令
/// </summary>
/// <param name="task">要等待的Task</param>
/// <returns>等待Task的协程指令</returns>
@ -19,7 +19,7 @@ public static class TaskCoroutineExtensions
}
/// <summary>
/// 将泛型Task转换为协程等待指令
/// 将泛型Task转换为协程等待指令
/// </summary>
/// <typeparam name="T">Task返回值的类型</typeparam>
/// <param name="task">要等待的Task</param>
@ -30,7 +30,7 @@ public static class TaskCoroutineExtensions
}
/// <summary>
/// 在调度器中启动一个Task并等待其完成
/// 在调度器中启动一个Task并等待其完成
/// </summary>
/// <param name="scheduler">协程调度器</param>
/// <param name="task">要等待的Task</param>
@ -41,7 +41,7 @@ public static class TaskCoroutineExtensions
}
/// <summary>
/// 在调度器中启动一个泛型Task并等待其完成
/// 在调度器中启动一个泛型Task并等待其完成
/// </summary>
/// <typeparam name="T">Task返回值的类型</typeparam>
/// <param name="scheduler">协程调度器</param>
@ -53,7 +53,7 @@ public static class TaskCoroutineExtensions
}
/// <summary>
/// 创建等待Task的协程
/// 创建等待Task的协程
/// </summary>
private static IEnumerator<IYieldInstruction> CreateTaskCoroutine(Task task)
{
@ -61,7 +61,7 @@ public static class TaskCoroutineExtensions
}
/// <summary>
/// 创建等待泛型Task的协程
/// 创建等待泛型Task的协程
/// </summary>
private static IEnumerator<IYieldInstruction> CreateTaskCoroutine<T>(Task<T> task)
{

146
GFramework.Core/coroutine/instructions/AsyncOperation.cs
View File

@ -1,11 +1,10 @@
using System.Runtime.CompilerServices;
using System.Threading;
using GFramework.Core.Abstractions.coroutine;
namespace GFramework.Core.coroutine.instructions;
/// <summary>
/// 异步操作包装器，用于桥接协程系统和async/await异步编程模型
/// 异步操作包装器，用于桥接协程系统和async/await异步编程模型
/// </summary>
public class AsyncOperation : IYieldInstruction, INotifyCompletion
{
@ -14,75 +13,17 @@ public class AsyncOperation : IYieldInstruction, INotifyCompletion
private volatile Action? _continuation;
/// <summary>
/// 获取异步操作是否已完成
/// </summary>
public bool IsDone => _completed;
/// <summary>
/// 获取异步操作的任务
/// 获取异步操作的任务
/// </summary>
public Task Task => _tcs.Task;
/// <summary>
/// 更新方法，用于处理时间更新逻辑
/// 检查是否已完成
/// </summary>
/// <param name="deltaTime">时间增量</param>
public void Update(double deltaTime)
{
// 由外部调用SetCompleted来更新状态
}
public bool IsCompleted => _completed;
/// <summary>
/// 标记异步操作已完成
/// </summary>
public void SetCompleted()
{
if (_completed) return;
_completed = true;
_tcs.SetResult(null);
var continuation = Interlocked.Exchange(ref _continuation, null);
if (continuation != null)
{
try
{
continuation.Invoke();
}
catch
{
// 忽略延续中的异常
}
}
}
/// <summary>
/// 标记异步操作因异常而失败
/// </summary>
/// <param name="exception">导致失败的异常</param>
public void SetException(Exception exception)
{
if (_completed) return;
_completed = true;
_tcs.SetException(exception);
var continuation = Interlocked.Exchange(ref _continuation, null);
if (continuation != null)
{
try
{
continuation.Invoke();
}
catch
{
// 忽略延续中的异常
}
}
}
/// <summary>
/// 设置延续操作
/// 设置延续操作
/// </summary>
/// <param name="continuation">要执行的延续操作</param>
public void OnCompleted(Action continuation)
@ -95,14 +36,10 @@ public class AsyncOperation : IYieldInstruction, INotifyCompletion
{
// 如果CAS失败，说明可能已经完成，直接执行
if (_completed)
{
continuation();
}
else
{
// 重试
OnCompleted(continuation);
}
return;
}
@ -111,15 +48,71 @@ public class AsyncOperation : IYieldInstruction, INotifyCompletion
if (_completed)
{
var cont = Interlocked.Exchange(ref _continuation, null);
if (cont != null)
{
cont();
}
if (cont != null) cont();
}
}
/// <summary>
/// 获取异步操作结果
/// 获取异步操作是否已完成
/// </summary>
public bool IsDone => _completed;
/// <summary>
/// 更新方法，用于处理时间更新逻辑
/// </summary>
/// <param name="deltaTime">时间增量</param>
public void Update(double deltaTime)
{
// 由外部调用SetCompleted来更新状态
}
/// <summary>
/// 标记异步操作已完成
/// </summary>
public void SetCompleted()
{
if (_completed) return;
_completed = true;
_tcs.SetResult(null);
var continuation = Interlocked.Exchange(ref _continuation, null);
if (continuation != null)
try
{
continuation.Invoke();
}
catch
{
// 忽略延续中的异常
}
}
/// <summary>
/// 标记异步操作因异常而失败
/// </summary>
/// <param name="exception">导致失败的异常</param>
public void SetException(Exception exception)
{
if (_completed) return;
_completed = true;
_tcs.SetException(exception);
var continuation = Interlocked.Exchange(ref _continuation, null);
if (continuation != null)
try
{
continuation.Invoke();
}
catch
{
// 忽略延续中的异常
}
}
/// <summary>
/// 获取异步操作结果
/// </summary>
/// <returns>操作结果</returns>
public object? GetResult()
@ -128,15 +121,10 @@ public class AsyncOperation : IYieldInstruction, INotifyCompletion
}
/// <summary>
/// 获取awaiter对象
/// 获取awaiter对象
/// </summary>
public AsyncOperation GetAwaiter()
{
return this;
}
/// <summary>
/// 检查是否已完成
/// </summary>
public bool IsCompleted => _completed;
}

8
GFramework.Core/coroutine/instructions/Delay.cs
View File

@ -3,18 +3,18 @@
namespace GFramework.Core.coroutine.instructions;
/// <summary>
/// 延迟等待指令，实现IYieldInstruction接口，用于协程中的时间延迟
/// 延迟等待指令，实现IYieldInstruction接口，用于协程中的时间延迟
/// </summary>
/// <param name="seconds">需要延迟的秒数</param>
public sealed class Delay(double seconds) : IYieldInstruction
{
/// <summary>
/// 剩余等待时间
/// 剩余等待时间
/// </summary>
private double _remaining = Math.Max(0, seconds);
/// <summary>
/// 更新延迟计时器
/// 更新延迟计时器
/// </summary>
/// <param name="deltaTime">时间增量</param>
public void Update(double deltaTime)
@ -23,7 +23,7 @@ public sealed class Delay(double seconds) : IYieldInstruction
}
/// <summary>
/// 获取延迟是否完成
/// 获取延迟是否完成
/// </summary>
public bool IsDone => _remaining <= 0;
}

13
GFramework.Core/coroutine/instructions/WaitForAllCoroutines.cs
View File

@ -3,15 +3,17 @@
namespace GFramework.Core.coroutine.instructions;
/// <summary>
/// 等待所有协程完成的等待指令
/// 等待所有协程完成的等待指令
/// </summary>
public sealed class WaitForAllCoroutines(
CoroutineScheduler scheduler,
IReadOnlyList<CoroutineHandle> handles)
: IYieldInstruction
{
private readonly IReadOnlyList<CoroutineHandle> _handles =
handles ?? throw new ArgumentNullException(nameof(handles));
private readonly CoroutineScheduler _scheduler = scheduler ?? throw new ArgumentNullException(nameof(scheduler));
private readonly IReadOnlyList<CoroutineHandle> _handles = handles ?? throw new ArgumentNullException(nameof(handles));
public void Update(double deltaTime)
{
@ -20,9 +22,6 @@ public sealed class WaitForAllCoroutines(
public bool IsDone
{
get
{
return _handles.All(handle => !_scheduler.IsCoroutineAlive(handle));
}
get { return _handles.All(handle => !_scheduler.IsCoroutineAlive(handle)); }
}
}
}

17
GFramework.Core/coroutine/instructions/WaitForCoroutine.cs
View File

@ -3,14 +3,12 @@
namespace GFramework.Core.coroutine.instructions;
/// <summary>
/// 等待协程完成的指令类，实现IYieldInstruction接口
/// 等待协程完成的指令类，实现IYieldInstruction接口
/// </summary>
public sealed class WaitForCoroutine : IYieldInstruction
{
private bool _done;
/// <summary>
/// 更新方法，用于处理时间更新逻辑
/// 更新方法，用于处理时间更新逻辑
/// </summary>
/// <param name="delta">时间增量</param>
public void Update(double delta)
@ -18,12 +16,15 @@ public sealed class WaitForCoroutine : IYieldInstruction
}
/// <summary>
/// 获取协程是否已完成的状态
/// 获取协程是否已完成的状态
/// </summary>
public bool IsDone => _done;
public bool IsDone { get; private set; }
/// <summary>
/// 内部方法，用于标记协程完成状态
/// 内部方法，用于标记协程完成状态
/// </summary>
internal void Complete() => _done = true;
internal void Complete()
{
IsDone = true;
}
}

8
GFramework.Core/coroutine/instructions/WaitForFrames.cs
View File

@ -3,18 +3,18 @@
namespace GFramework.Core.coroutine.instructions;
/// <summary>
/// 等待指定帧数的等待指令类
/// 等待指定帧数的等待指令类
/// </summary>
/// <param name="frames">需要等待的帧数，最小值为1</param>
public sealed class WaitForFrames(int frames) : IYieldInstruction
{
/// <summary>
/// 剩余等待帧数
/// 剩余等待帧数
/// </summary>
private int _remaining = Math.Max(1, frames);
/// <summary>
/// 更新方法，在每一帧调用时减少剩余帧数
/// 更新方法，在每一帧调用时减少剩余帧数
/// </summary>
/// <param name="deltaTime">时间间隔（秒）</param>
public void Update(double deltaTime)
@ -23,7 +23,7 @@ public sealed class WaitForFrames(int frames) : IYieldInstruction
}
/// <summary>
/// 获取等待是否完成的状态
/// 获取等待是否完成的状态
/// </summary>
public bool IsDone => _remaining <= 0;
}

23
GFramework.Core/coroutine/instructions/WaitForProgress.cs
View File

@ -3,47 +3,46 @@ using GFramework.Core.Abstractions.coroutine;
namespace GFramework.Core.coroutine.instructions;
/// <summary>
/// 带进度回调的等待指令
/// 带进度回调的等待指令
/// </summary>
public class WaitForProgress : IYieldInstruction
{
private readonly double _duration;
private readonly Action<float> _onProgress;
private double _elapsed;
private bool _progressCompleted;
/// <summary>
/// 初始化等待进度指令
/// 初始化等待进度指令
/// </summary>
/// <param name="duration">总持续时间（秒）</param>
/// <param name="onProgress">进度回调，参数为0-1之间的进度值</param>
public WaitForProgress(double duration, Action<float> onProgress)
{
if (duration <= 0)
if (duration <= 0)
throw new ArgumentException("Duration must be positive", nameof(duration));
_duration = duration;
_onProgress = onProgress ?? throw new ArgumentNullException(nameof(onProgress));
_elapsed = 0;
_progressCompleted = false;
IsDone = false;
}
/// <summary>
/// 更新方法
/// 更新方法
/// </summary>
/// <param name="deltaTime">时间增量</param>
public void Update(double deltaTime)
{
if (_progressCompleted)
if (IsDone)
return;
_elapsed += deltaTime;
// 计算进度并回调
if (_elapsed >= _duration)
{
_elapsed = _duration;
_progressCompleted = true;
IsDone = true;
_onProgress(1.0f);
}
else
@ -54,7 +53,7 @@ public class WaitForProgress : IYieldInstruction
}
/// <summary>
/// 获取等待是否已完成
/// 获取等待是否已完成
/// </summary>
public bool IsDone => _progressCompleted;
public bool IsDone { get; private set; }
}

39
GFramework.Core/coroutine/instructions/WaitForTask.T.cs
View File

@ -3,7 +3,7 @@ using GFramework.Core.Abstractions.coroutine;
namespace GFramework.Core.coroutine.instructions;
/// <summary>
/// 等待泛型Task完成的等待指令
/// 等待泛型Task完成的等待指令
/// </summary>
/// <typeparam name="T">Task返回值的类型</typeparam>
public sealed class WaitForTask<T> : IYieldInstruction
@ -12,30 +12,33 @@ public sealed class WaitForTask<T> : IYieldInstruction
private volatile bool _done;
/// <summary>
/// 初始化等待泛型Task的指令
/// 初始化等待泛型Task的指令
/// </summary>
/// <param name="task">要等待完成的Task</param>
public WaitForTask(Task<T> task)
{
_task = task ?? throw new ArgumentNullException(nameof(task));
// 检查Task是否已经完成
if (_task.IsCompleted)
{
_done = true;
}
else
{
// 注册完成回调
_task.ContinueWith(_ =>
{
_done = true;
}, TaskContinuationOptions.ExecuteSynchronously);
}
_task.ContinueWith(_ => { _done = true; }, TaskContinuationOptions.ExecuteSynchronously);
}
/// <summary>
/// 更新方法，用于处理时间更新逻辑
/// 获取Task的结果值
/// </summary>
public T Result => _task.GetAwaiter().GetResult();
/// <summary>
/// 获取Task的异常（如果有）
/// </summary>
public Exception? Exception => _task.Exception;
/// <summary>
/// 更新方法，用于处理时间更新逻辑
/// </summary>
/// <param name="deltaTime">时间增量</param>
public void Update(double deltaTime)
@ -44,17 +47,7 @@ public sealed class WaitForTask<T> : IYieldInstruction
}
/// <summary>
/// 获取等待是否已完成
/// 获取等待是否已完成
/// </summary>
public bool IsDone => _done;
/// <summary>
/// 获取Task的结果值
/// </summary>
public T Result => _task.GetAwaiter().GetResult();
/// <summary>
/// 获取Task的异常（如果有）
/// </summary>
public Exception? Exception => _task.Exception;
}

31
GFramework.Core/coroutine/instructions/WaitForTask.cs
View File

@ -3,10 +3,10 @@ using GFramework.Core.Abstractions.coroutine;
namespace GFramework.Core.coroutine.instructions;
/// <summary>
/// 等待Task完成的等待指令
/// 等待Task完成的等待指令
/// </summary>
/// <summary>
/// 等待Task完成的等待指令
/// 等待Task完成的等待指令
/// </summary>
public sealed class WaitForTask : IYieldInstruction
{
@ -14,30 +14,28 @@ public sealed class WaitForTask : IYieldInstruction
private volatile bool _done;
/// <summary>
/// 初始化等待Task的指令
/// 初始化等待Task的指令
/// </summary>
/// <param name="task">要等待完成的Task</param>
public WaitForTask(Task task)
{
_task = task ?? throw new ArgumentNullException(nameof(task));
// 检查Task是否已经完成
if (_task.IsCompleted)
{
_done = true;
}
else
{
// 注册完成回调
_task.ContinueWith(_ =>
{
_done = true;
}, TaskContinuationOptions.ExecuteSynchronously);
}
_task.ContinueWith(_ => { _done = true; }, TaskContinuationOptions.ExecuteSynchronously);
}
/// <summary>
/// 更新方法，用于处理时间更新逻辑
/// 获取Task的异常（如果有）
/// </summary>
public Exception? Exception => _task.Exception;
/// <summary>
/// 更新方法，用于处理时间更新逻辑
/// </summary>
/// <param name="deltaTime">时间增量</param>
public void Update(double deltaTime)
@ -46,12 +44,7 @@ public sealed class WaitForTask : IYieldInstruction
}
/// <summary>
/// 获取等待是否已完成
/// 获取等待是否已完成
/// </summary>
public bool IsDone => _done;
/// <summary>
/// 获取Task的异常（如果有）
/// </summary>
public Exception? Exception => _task.Exception;
}

14
GFramework.Core/coroutine/instructions/WaitOneFrame.cs
View File

@ -3,24 +3,22 @@
namespace GFramework.Core.coroutine.instructions;
/// <summary>
/// 表示等待一帧的等待指令实现
/// 实现IYieldInstruction接口，用于协程中等待一个游戏帧的执行
/// 表示等待一帧的等待指令实现
/// 实现IYieldInstruction接口，用于协程中等待一个游戏帧的执行
/// </summary>
public sealed class WaitOneFrame : IYieldInstruction
{
private bool _done;
/// <summary>
/// 更新方法，在每一帧被调用时将完成状态设置为true
/// 更新方法，在每一帧被调用时将完成状态设置为true
/// </summary>
/// <param name="deltaTime">时间间隔，表示当前帧与上一帧的时间差</param>
public void Update(double deltaTime)
{
_done = true;
IsDone = true;
}
/// <summary>
/// 获取当前等待指令是否已完成
/// 获取当前等待指令是否已完成
/// </summary>
public bool IsDone => _done;
public bool IsDone { get; private set; }
}

6
GFramework.Core/coroutine/instructions/WaitUntil.cs
View File

@ -3,7 +3,7 @@
namespace GFramework.Core.coroutine.instructions;
/// <summary>
/// 表示一个等待直到指定条件满足的协程指令
/// 表示一个等待直到指定条件满足的协程指令
/// </summary>
/// <param name="predicate">用于判断条件是否满足的函数委托</param>
public sealed class WaitUntil(Func<bool> predicate) : IYieldInstruction
@ -11,7 +11,7 @@ public sealed class WaitUntil(Func<bool> predicate) : IYieldInstruction
private readonly Func<bool> _predicate = predicate ?? throw new ArgumentNullException(nameof(predicate));
/// <summary>
/// 更新协程状态（此实现中不需要处理时间）
/// 更新协程状态（此实现中不需要处理时间）
/// </summary>
/// <param name="deltaTime">时间增量</param>
public void Update(double deltaTime)
@ -20,7 +20,7 @@ public sealed class WaitUntil(Func<bool> predicate) : IYieldInstruction
}
/// <summary>
/// 获取协程指令是否已完成
/// 获取协程指令是否已完成
/// </summary>
public bool IsDone => _predicate();
}

8
GFramework.Core/coroutine/instructions/WaitWhile.cs
View File

@ -3,7 +3,7 @@
namespace GFramework.Core.coroutine.instructions;
/// <summary>
/// 表示一个等待条件为假时才完成的协程指令
/// 表示一个等待条件为假时才完成的协程指令
/// </summary>
/// <param name="predicate">用于判断是否继续等待的条件函数，当返回true时继续等待，返回false时完成</param>
public sealed class WaitWhile(Func<bool> predicate) : IYieldInstruction
@ -11,7 +11,7 @@ public sealed class WaitWhile(Func<bool> predicate) : IYieldInstruction
private readonly Func<bool> _predicate = predicate ?? throw new ArgumentNullException(nameof(predicate));
/// <summary>
/// 更新协程状态（此实现中为空方法）
/// 更新协程状态（此实现中为空方法）
/// </summary>
/// <param name="deltaTime">时间增量</param>
public void Update(double deltaTime)
@ -19,8 +19,8 @@ public sealed class WaitWhile(Func<bool> predicate) : IYieldInstruction
}
/// <summary>
/// 获取协程指令是否已完成
/// 当谓词函数返回false时，表示条件不再满足，指令完成
/// 获取协程指令是否已完成
/// 当谓词函数返回false时，表示条件不再满足，指令完成
/// </summary>
public bool IsDone => !_predicate();
}

3
GFramework.Core/events/DefaultUnRegister.cs
View File

@ -1,5 +1,4 @@
using System;
using GFramework.Core.Abstractions.events;
using GFramework.Core.Abstractions.events;
namespace GFramework.Core.events;

3
GFramework.Core/events/EasyEventGeneric.cs
View File

@ -1,5 +1,4 @@
using System;
using GFramework.Core.Abstractions.events;
using GFramework.Core.Abstractions.events;
namespace GFramework.Core.events;

1
GFramework.Core/events/README.md
View File

@ -27,6 +27,7 @@ void UnRegister(); // 执行注销操作
```
### 3. [
`IUnRegisterList`](file:///d:/Project/Rider/GFramework/GFramework.Core.Abstractions/events/IUnRegisterList.cs#L6-L10)
注销列表接口，用于批量管理注销对象。

4
GFramework.Core/extensions/ObjectExtensions.cs
View File

@ -1,6 +1,4 @@
using System;
namespace GFramework.Core.extensions;
namespace GFramework.Core.extensions;
/// <summary>
/// 提供基于运行时类型判断的对象扩展方法，

1
GFramework.Core/ioc/IocContainer.cs
View File

@ -1,4 +1,3 @@
using System.Threading;
using GFramework.Core.Abstractions.ioc;
using GFramework.Core.Abstractions.logging;
using GFramework.Core.Abstractions.system;

8
GFramework.Core/ioc/README.md
View File

@ -390,9 +390,11 @@ public bool Contains<T>() where T : class
```
**参数：**
- 无泛型参数
**返回值：**
- 如果容器中包含指定类型的实例则返回 `true`，否则返回 `false`
**使用示例：**
@ -414,6 +416,7 @@ if (!container.Contains<ISettingsService>())
```
**应用场景：**
- 条件注册服务
- 检查依赖是否可用
- 动态功能开关
@ -427,9 +430,11 @@ public bool ContainsInstance(object instance)
```
**参数：**
- `instance`：待查询的实例对象
**返回值：**
- 若容器中包含该实例则返回 `true`，否则返回 `false`
**使用示例：**
@ -455,6 +460,7 @@ if (!container.ContainsInstance(anotherService))
```
**应用场景：**
- 避免重复注册同一实例
- 检查对象是否已被管理
- 调试和日志记录
@ -486,11 +492,13 @@ Console.WriteLine($"Contains IService2: {container.Contains<IService2>()}"); //
```
**应用场景：**
- 重置容器状态
- 内存清理
- 测试环境准备
**注意事项：**
- 容器冻结后也可以调用 `Clear()` 方法
- 清空后，所有已注册的实例都将丢失
- 不会自动清理已注册对象的其他引用

Some files were not shown because too many files have changed in this diff Show More