gewuyou/GFramework
1
0
Fork 0
mirror of https://github.com/GeWuYou/GFramework.git synced 2026-05-07 00:39:00 +08:00
Code Issues Packages Projects Releases Wiki Activity

test(core-tests): 批量拆分测试辅助类型以消减警告

Browse Source 
- 拆分 GFramework.Core.Tests 中多组测试辅助类型到独立文件以消减 MA0048 warning

- 更新 analyzer-warning-reduction 的 tracking 与 trace 以记录批处理基线和下一恢复点

- 验证 GFramework.Core.Tests Release 构建清零并将仓库根权威 warning 基线压降到 288
This commit is contained in:
gewuyou 2026-04-27 19:44:07 +08:00
parent 26ba3d62f6
commit f0a36de07c
63 changed files with 1811 additions and 1502 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
GFramework.Core.Tests/Architectures/AdditionalAssemblyNotification.cs Normal file
View File

@ -0,0 +1,8 @@
using GFramework.Cqrs.Abstractions.Cqrs;
namespace GFramework.Core.Tests.Architectures;
/// <summary>
/// 用于验证额外程序集接入是否成功的测试通知。
/// </summary>
public sealed record AdditionalAssemblyNotification : INotification;

46
GFramework.Core.Tests/Architectures/AdditionalAssemblyNotificationHandlerRegistry.cs Normal file
View File

@ -0,0 +1,46 @@
using GFramework.Core.Abstractions.Logging;
using GFramework.Cqrs;
using GFramework.Cqrs.Abstractions.Cqrs;
namespace GFramework.Core.Tests.Architectures;
/// <summary>
/// 模拟由 source-generator 为扩展程序集生成的 CQRS handler registry。
/// </summary>
internal sealed class AdditionalAssemblyNotificationHandlerRegistry : ICqrsHandlerRegistry
{
/// <summary>
/// 将扩展程序集中的通知处理器映射写入服务集合。
/// </summary>
/// <param name="services">目标服务集合。</param>
/// <param name="logger">日志记录器。</param>
/// <exception cref="ArgumentNullException">
/// 当 <paramref name="services" /> 或 <paramref name="logger" /> 为 <see langword="null" /> 时抛出。
/// </exception>
public void Register(IServiceCollection services, ILogger logger)
{
ArgumentNullException.ThrowIfNull(services);
ArgumentNullException.ThrowIfNull(logger);
services.AddTransient<INotificationHandler<AdditionalAssemblyNotification>>(_ => CreateHandler());
logger.Debug(
$"Registered CQRS handler proxy for {typeof(INotificationHandler<AdditionalAssemblyNotification>).FullName}.");
}
/// <summary>
/// 创建一个仅供显式程序集注册路径使用的动态通知处理器。
/// </summary>
/// <returns>用于记录通知触发次数的测试替身处理器。</returns>
private static INotificationHandler<AdditionalAssemblyNotification> CreateHandler()
{
var handler = new Mock<INotificationHandler<AdditionalAssemblyNotification>>();
handler
.Setup(target => target.Handle(It.IsAny<AdditionalAssemblyNotification>(), It.IsAny<CancellationToken>()))
.Returns(() =>
{
AdditionalAssemblyNotificationHandlerState.RecordInvocation();
return ValueTask.CompletedTask;
});
return handler.Object;
}
}

33
GFramework.Core.Tests/Architectures/AdditionalAssemblyNotificationHandlerState.cs Normal file
View File

@ -0,0 +1,33 @@
namespace GFramework.Core.Tests.Architectures;
/// <summary>
/// 记录模拟扩展程序集通知处理器的执行次数。
/// </summary>
public static class AdditionalAssemblyNotificationHandlerState
{
private static int _invocationCount;
/// <summary>
/// 获取当前测试进程中该处理器的执行次数。
/// </summary>
/// <remarks>
/// 该计数器通过原子读写维护，以支持 NUnit 并行执行环境中的并发访问。
/// </remarks>
public static int InvocationCount => Volatile.Read(ref _invocationCount);
/// <summary>
/// 记录一次通知处理，供测试断言显式程序集接入后的运行时行为。
/// </summary>
public static void RecordInvocation()
{
Interlocked.Increment(ref _invocationCount);
}
/// <summary>
/// 清理共享计数器，避免测试间相互污染。
/// </summary>
public static void Reset()
{
Interlocked.Exchange(ref _invocationCount, 0);
}
}

85
GFramework.Core.Tests/Architectures/ArchitectureAdditionalCqrsHandlersTests.cs
View File

@ -121,88 +121,3 @@ public sealed class ArchitectureAdditionalCqrsHandlersTests
return architecture;
}
}
/// <summary>
/// 用于验证额外程序集接入是否成功的测试通知。
/// </summary>
public sealed record AdditionalAssemblyNotification : INotification;
/// <summary>
/// 记录模拟扩展程序集通知处理器的执行次数。
/// </summary>
public static class AdditionalAssemblyNotificationHandlerState
{
private static int _invocationCount;
/// <summary>
/// 获取当前测试进程中该处理器的执行次数。
/// </summary>
/// <remarks>
/// 该计数器通过原子读写维护，以支持 NUnit 并行执行环境中的并发访问。
/// </remarks>
public static int InvocationCount => Volatile.Read(ref _invocationCount);
/// <summary>
/// 记录一次通知处理，供测试断言显式程序集接入后的运行时行为。
/// </summary>
public static void RecordInvocation()
{
Interlocked.Increment(ref _invocationCount);
}
/// <summary>
/// 清理共享计数器，避免测试间相互污染。
/// </summary>
public static void Reset()
{
Interlocked.Exchange(ref _invocationCount, 0);
}
}
/// <summary>
/// 模拟由 source-generator 为扩展程序集生成的 CQRS handler registry。
/// </summary>
internal sealed class AdditionalAssemblyNotificationHandlerRegistry : ICqrsHandlerRegistry
{
/// <summary>
/// 将扩展程序集中的通知处理器映射写入服务集合。
/// </summary>
/// <param name="services">目标服务集合。</param>
/// <param name="logger">日志记录器。</param>
/// <exception cref="ArgumentNullException">
/// 当 <paramref name="services" /> 或 <paramref name="logger" /> 为 <see langword="null" /> 时抛出。
/// </exception>
public void Register(IServiceCollection services, ILogger logger)
{
if (services is null)
{
throw new ArgumentNullException(nameof(services));
}
if (logger is null)
{
throw new ArgumentNullException(nameof(logger));
}
services.AddTransient<INotificationHandler<AdditionalAssemblyNotification>>(_ => CreateHandler());
logger.Debug(
$"Registered CQRS handler proxy for {typeof(INotificationHandler<AdditionalAssemblyNotification>).FullName}.");
}
/// <summary>
/// 创建一个仅供显式程序集注册路径使用的动态通知处理器。
/// </summary>
/// <returns>用于记录通知触发次数的测试替身处理器。</returns>
private static INotificationHandler<AdditionalAssemblyNotification> CreateHandler()
{
var handler = new Mock<INotificationHandler<AdditionalAssemblyNotification>>();
handler
.Setup(target => target.Handle(It.IsAny<AdditionalAssemblyNotification>(), It.IsAny<CancellationToken>()))
.Returns(() =>
{
AdditionalAssemblyNotificationHandlerState.RecordInvocation();
return ValueTask.CompletedTask;
});
return handler.Object;
}
}

148
GFramework.Core.Tests/Architectures/ArchitectureContextTests.cs
View File

@ -1,14 +1,10 @@
using System.Reflection;
using GFramework.Core.Abstractions.Architectures;
using GFramework.Core.Abstractions.Command;
using GFramework.Core.Abstractions.Enums;
using GFramework.Core.Abstractions.Environment;
using GFramework.Core.Abstractions.Ioc;
using GFramework.Core.Abstractions.Logging;
using GFramework.Core.Abstractions.Model;
using GFramework.Core.Abstractions.Query;
using GFramework.Core.Abstractions.Systems;
using GFramework.Core.Abstractions.Utility;
using GFramework.Core.Architectures;
using GFramework.Core.Command;
using GFramework.Core.Environment;
@ -373,147 +369,3 @@ public class ArchitectureContextTests
{
}
}
#region Test Classes
public class TestSystemV2 : ISystem
{
private IArchitectureContext _context = null!;
public int Id { get; init; }
public void SetContext(IArchitectureContext context)
{
_context = context;
}
public IArchitectureContext GetContext()
{
return _context;
}
public void Initialize()
{
}
public void Destroy()
{
}
public void OnArchitecturePhase(ArchitecturePhase phase)
{
}
}
public class TestModelV2 : IModel
{
private IArchitectureContext _context = null!;
public int Id { get; init; }
public void SetContext(IArchitectureContext context)
{
_context = context;
}
public IArchitectureContext GetContext()
{
return _context;
}
public void Initialize()
{
}
public void OnArchitecturePhase(ArchitecturePhase phase)
{
}
public void Destroy()
{
}
}
public class TestUtilityV2 : IUtility
{
private IArchitectureContext _context = null!;
public int Id { get; init; }
public void SetContext(IArchitectureContext context)
{
_context = context;
}
public IArchitectureContext GetContext()
{
return _context;
}
}
public class TestQueryV2 : IQuery<int>
{
private IArchitectureContext _context = null!;
public int Result { get; init; }
public int Do()
{
return Result;
}
public void SetContext(IArchitectureContext context)
{
_context = context;
}
public IArchitectureContext GetContext()
{
return _context;
}
}
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()
{
return _context;
}
}
public class TestCommandWithResultV2 : ICommand<int>
{
private IArchitectureContext _context = null!;
public int Result { get; init; }
public int Execute()
{
return Result;
}
public void SetContext(IArchitectureContext context)
{
_context = context;
}
public IArchitectureContext GetContext()
{
return _context;
}
}
public class TestEventV2
{
public int Data { get; init; }
}
#endregion

54
GFramework.Core.Tests/Architectures/ArchitectureModulesBehaviorTests.cs
View File

@ -3,7 +3,6 @@ using GFramework.Core.Abstractions.Logging;
using GFramework.Core.Abstractions.Utility;
using GFramework.Core.Architectures;
using GFramework.Core.Logging;
using GFramework.Cqrs.Abstractions.Cqrs;
namespace GFramework.Core.Tests.Architectures;
@ -126,56 +125,3 @@ public class ArchitectureModulesBehaviorTests
{
}
}
/// <summary>
/// 用于验证管道行为注册是否生效的测试请求。
/// </summary>
public sealed class ModuleBehaviorRequest : IRequest<string>
{
}
/// <summary>
/// 处理测试请求的处理器。
/// </summary>
public sealed class ModuleBehaviorRequestHandler : IRequestHandler<ModuleBehaviorRequest, string>
{
/// <summary>
/// 返回固定结果，便于聚焦验证管道行为是否执行。
/// </summary>
/// <param name="request">请求实例。</param>
/// <param name="cancellationToken">取消令牌。</param>
/// <returns>固定响应内容。</returns>
public ValueTask<string> Handle(ModuleBehaviorRequest request, CancellationToken cancellationToken)
{
return ValueTask.FromResult("handled");
}
}
/// <summary>
/// 记录请求通过管道次数的测试行为。
/// </summary>
/// <typeparam name="TRequest">请求类型。</typeparam>
/// <typeparam name="TResponse">响应类型。</typeparam>
public sealed class TrackingPipelineBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
where TRequest : IRequest<TResponse>
{
/// <summary>
/// 获取当前测试进程中该请求类型对应的行为触发次数。
/// </summary>
public static int InvocationCount { get; set; }
/// <summary>
/// 记录一次行为执行，然后继续执行下一个处理器。
/// </summary>
/// <param name="message">当前请求消息。</param>
/// <param name="next">下一个处理委托。</param>
/// <param name="cancellationToken">取消令牌。</param>
/// <returns>下游处理器的响应结果。</returns>
public async ValueTask<TResponse> Handle(
TRequest message, MessageHandlerDelegate<TRequest, TResponse> next,
CancellationToken cancellationToken)
{
InvocationCount++;
return await next(message, cancellationToken).ConfigureAwait(false);
}
}

10
GFramework.Core.Tests/Architectures/ModuleBehaviorRequest.cs Normal file
View File

@ -0,0 +1,10 @@
using GFramework.Cqrs.Abstractions.Cqrs;
namespace GFramework.Core.Tests.Architectures;
/// <summary>
/// 用于验证管道行为注册是否生效的测试请求。
/// </summary>
public sealed class ModuleBehaviorRequest : IRequest<string>
{
}

20
GFramework.Core.Tests/Architectures/ModuleBehaviorRequestHandler.cs Normal file
View File

@ -0,0 +1,20 @@
using GFramework.Cqrs.Abstractions.Cqrs;
namespace GFramework.Core.Tests.Architectures;
/// <summary>
/// 处理测试请求的处理器。
/// </summary>
public sealed class ModuleBehaviorRequestHandler : IRequestHandler<ModuleBehaviorRequest, string>
{
/// <summary>
/// 返回固定结果，便于聚焦验证管道行为是否执行。
/// </summary>
/// <param name="request">请求实例。</param>
/// <param name="cancellationToken">取消令牌。</param>
/// <returns>固定响应内容。</returns>
public ValueTask<string> Handle(ModuleBehaviorRequest request, CancellationToken cancellationToken)
{
return ValueTask.FromResult("handled");
}
}

43
GFramework.Core.Tests/Architectures/TestCommandV2.cs Normal file
View File

@ -0,0 +1,43 @@
using GFramework.Core.Abstractions.Architectures;
using GFramework.Core.Abstractions.Command;
namespace GFramework.Core.Tests.Architectures;
/// <summary>
/// 为 <see cref="ArchitectureContextTests" /> 提供的测试命令桩。
/// </summary>
public sealed class TestCommandV2 : ICommand
{
private IArchitectureContext _context = null!;
/// <summary>
/// 获取命令是否已经执行。
/// </summary>
public bool Executed { get; private set; }
/// <summary>
/// 执行测试命令，并记录执行状态。
/// </summary>
public void Execute()
{
Executed = true;
}
/// <summary>
/// 关联当前命令所属的架构上下文。
/// </summary>
/// <param name="context">要保存的架构上下文。</param>
public void SetContext(IArchitectureContext context)
{
_context = context;
}
/// <summary>
/// 获取当前命令已绑定的架构上下文。
/// </summary>
/// <returns>测试期间保存的架构上下文。</returns>
public IArchitectureContext GetContext()
{
return _context;
}
}

44
GFramework.Core.Tests/Architectures/TestCommandWithResultV2.cs Normal file
View File

@ -0,0 +1,44 @@
using GFramework.Core.Abstractions.Architectures;
using GFramework.Core.Abstractions.Command;
namespace GFramework.Core.Tests.Architectures;
/// <summary>
/// 为 <see cref="ArchitectureContextTests" /> 提供的带返回值测试命令桩。
/// </summary>
public sealed class TestCommandWithResultV2 : ICommand<int>
{
private IArchitectureContext _context = null!;
/// <summary>
/// 获取或设置命令执行结果。
/// </summary>
public int Result { get; init; }
/// <summary>
/// 执行测试命令并返回预设结果。
/// </summary>
/// <returns>测试预设的命令结果。</returns>
public int Execute()
{
return Result;
}
/// <summary>
/// 关联当前命令所属的架构上下文。
/// </summary>
/// <param name="context">要保存的架构上下文。</param>
public void SetContext(IArchitectureContext context)
{
_context = context;
}
/// <summary>
/// 获取当前命令已绑定的架构上下文。
/// </summary>
/// <returns>测试期间保存的架构上下文。</returns>
public IArchitectureContext GetContext()
{
return _context;
}
}

12
GFramework.Core.Tests/Architectures/TestEventV2.cs Normal file
View File

@ -0,0 +1,12 @@
namespace GFramework.Core.Tests.Architectures;
/// <summary>
/// 为 <see cref="ArchitectureContextTests" /> 提供的测试事件载荷。
/// </summary>
public sealed class TestEventV2
{
/// <summary>
/// 获取或设置测试事件数据。
/// </summary>
public int Data { get; init; }
}

58
GFramework.Core.Tests/Architectures/TestModelV2.cs Normal file
View File

@ -0,0 +1,58 @@
using GFramework.Core.Abstractions.Architectures;
using GFramework.Core.Abstractions.Enums;
using GFramework.Core.Abstractions.Model;
namespace GFramework.Core.Tests.Architectures;
/// <summary>
/// 为 <see cref="ArchitectureContextTests" /> 提供的测试模型桩。
/// </summary>
public sealed class TestModelV2 : IModel
{
private IArchitectureContext _context = null!;
/// <summary>
/// 获取或设置测试用标识。
/// </summary>
public int Id { get; init; }
/// <summary>
/// 关联当前模型所属的架构上下文。
/// </summary>
/// <param name="context">要保存的架构上下文。</param>
public void SetContext(IArchitectureContext context)
{
_context = context;
}
/// <summary>
/// 获取当前模型已绑定的架构上下文。
/// </summary>
/// <returns>测试期间保存的架构上下文。</returns>
public IArchitectureContext GetContext()
{
return _context;
}
/// <summary>
/// 初始化测试模型。
/// </summary>
public void Initialize()
{
}
/// <summary>
/// 接收架构阶段切换通知。
/// </summary>
/// <param name="phase">当前架构阶段。</param>
public void OnArchitecturePhase(ArchitecturePhase phase)
{
}
/// <summary>
/// 销毁测试模型。
/// </summary>
public void Destroy()
{
}
}

44
GFramework.Core.Tests/Architectures/TestQueryV2.cs Normal file
View File

@ -0,0 +1,44 @@
using GFramework.Core.Abstractions.Architectures;
using GFramework.Core.Abstractions.Query;
namespace GFramework.Core.Tests.Architectures;
/// <summary>
/// 为 <see cref="ArchitectureContextTests" /> 提供的测试查询桩。
/// </summary>
public sealed class TestQueryV2 : IQuery<int>
{
private IArchitectureContext _context = null!;
/// <summary>
/// 获取或设置查询返回值。
/// </summary>
public int Result { get; init; }
/// <summary>
/// 执行查询并返回预设结果。
/// </summary>
/// <returns>测试预设的查询结果。</returns>
public int Do()
{
return Result;
}
/// <summary>
/// 关联当前查询所属的架构上下文。
/// </summary>
/// <param name="context">要保存的架构上下文。</param>
public void SetContext(IArchitectureContext context)
{
_context = context;
}
/// <summary>
/// 获取当前查询已绑定的架构上下文。
/// </summary>
/// <returns>测试期间保存的架构上下文。</returns>
public IArchitectureContext GetContext()
{
return _context;
}
}

58
GFramework.Core.Tests/Architectures/TestSystemV2.cs Normal file
View File

@ -0,0 +1,58 @@
using GFramework.Core.Abstractions.Architectures;
using GFramework.Core.Abstractions.Enums;
using GFramework.Core.Abstractions.Systems;
namespace GFramework.Core.Tests.Architectures;
/// <summary>
/// 为 <see cref="ArchitectureContextTests" /> 提供的测试系统桩。
/// </summary>
public sealed class TestSystemV2 : ISystem
{
private IArchitectureContext _context = null!;
/// <summary>
/// 获取或设置测试用标识。
/// </summary>
public int Id { get; init; }
/// <summary>
/// 关联当前系统所属的架构上下文。
/// </summary>
/// <param name="context">要保存的架构上下文。</param>
public void SetContext(IArchitectureContext context)
{
_context = context;
}
/// <summary>
/// 获取当前系统已绑定的架构上下文。
/// </summary>
/// <returns>测试期间保存的架构上下文。</returns>
public IArchitectureContext GetContext()
{
return _context;
}
/// <summary>
/// 初始化测试系统。
/// </summary>
public void Initialize()
{
}
/// <summary>
/// 销毁测试系统。
/// </summary>
public void Destroy()
{
}
/// <summary>
/// 接收架构阶段切换通知。
/// </summary>
/// <param name="phase">当前架构阶段。</param>
public void OnArchitecturePhase(ArchitecturePhase phase)
{
}
}

35
GFramework.Core.Tests/Architectures/TestUtilityV2.cs Normal file
View File

@ -0,0 +1,35 @@
using GFramework.Core.Abstractions.Architectures;
using GFramework.Core.Abstractions.Utility;
namespace GFramework.Core.Tests.Architectures;
/// <summary>
/// 为 <see cref="ArchitectureContextTests" /> 提供的测试工具桩。
/// </summary>
public sealed class TestUtilityV2 : IUtility
{
private IArchitectureContext _context = null!;
/// <summary>
/// 获取或设置测试用标识。
/// </summary>
public int Id { get; init; }
/// <summary>
/// 关联当前工具所属的架构上下文。
/// </summary>
/// <param name="context">要保存的架构上下文。</param>
public void SetContext(IArchitectureContext context)
{
_context = context;
}
/// <summary>
/// 获取当前工具已绑定的架构上下文。
/// </summary>
/// <returns>测试期间保存的架构上下文。</returns>
public IArchitectureContext GetContext()
{
return _context;
}
}

33
GFramework.Core.Tests/Architectures/TrackingPipelineBehavior.cs Normal file
View File

@ -0,0 +1,33 @@
using GFramework.Cqrs.Abstractions.Cqrs;
namespace GFramework.Core.Tests.Architectures;
/// <summary>
/// 记录请求通过管道次数的测试行为。
/// </summary>
/// <typeparam name="TRequest">请求类型。</typeparam>
/// <typeparam name="TResponse">响应类型。</typeparam>
public sealed class TrackingPipelineBehavior<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
where TRequest : IRequest<TResponse>
{
/// <summary>
/// 获取当前测试进程中该请求类型对应的行为触发次数。
/// </summary>
public static int InvocationCount { get; set; }
/// <summary>
/// 记录一次行为执行，然后继续执行下一个处理器。
/// </summary>
/// <param name="message">当前请求消息。</param>
/// <param name="next">下一个处理委托。</param>
/// <param name="cancellationToken">取消令牌。</param>
/// <returns>下游处理器的响应结果。</returns>
public async ValueTask<TResponse> Handle(
TRequest message,
MessageHandlerDelegate<TRequest, TResponse> next,
CancellationToken cancellationToken)
{
InvocationCount++;
return await next(message, cancellationToken).ConfigureAwait(false);
}
}

168
GFramework.Core.Tests/Command/AbstractAsyncCommandTests.cs
View File

@ -229,171 +229,3 @@ public class AbstractAsyncCommandTests
Assert.That(result, Is.EqualTo(200));
}
}
/// <summary>
/// 测试用命令输入类V2
/// </summary>
public sealed class TestCommandInputV2 : ICommandInput
{
/// <summary>
/// 获取或设置值
/// </summary>
public int Value { get; init; }
}
/// <summary>
/// 测试用异步命令类V3（无返回值）
/// </summary>
public sealed class TestAsyncCommandV3 : AbstractAsyncCommand<TestCommandInputV2>
{
/// <summary>
/// 构造函数
/// </summary>
/// <param name="input">命令输入</param>
public TestAsyncCommandV3(TestCommandInputV2 input) : base(input)
{
}
/// <summary>
/// 获取命令是否已执行
/// </summary>
public bool Executed { get; private set; }
/// <summary>
/// 获取执行的值
/// </summary>
public int ExecutedValue { get; private set; }
/// <summary>
/// 执行异步命令的重写方法
/// </summary>
/// <param name="input">命令输入</param>
/// <returns>表示异步操作的任务</returns>
protected override Task OnExecuteAsync(TestCommandInputV2 input)
{
Executed = true;
ExecutedValue = input.Value;
return Task.CompletedTask;
}
}
/// <summary>
/// 测试用异步命令类V3（有返回值）
/// </summary>
public sealed class TestAsyncCommandWithResultV3 : AbstractAsyncCommand<TestCommandInputV2, int>
{
/// <summary>
/// 构造函数
/// </summary>
/// <param name="input">命令输入</param>
public TestAsyncCommandWithResultV3(TestCommandInputV2 input) : base(input)
{
}
/// <summary>
/// 获取命令是否已执行
/// </summary>
public bool Executed { get; private set; }
/// <summary>
/// 执行异步命令并返回结果的重写方法
/// </summary>
/// <param name="input">命令输入</param>
/// <returns>执行结果的异步任务</returns>
protected override Task<int> OnExecuteAsync(TestCommandInputV2 input)
{
Executed = true;
return Task.FromResult(input.Value * 2);
}
}
/// <summary>
/// 测试用异步命令类（抛出异常）
/// </summary>
public sealed class TestAsyncCommandWithExceptionV3 : AbstractAsyncCommand<TestCommandInputV2>
{
/// <summary>
/// 构造函数
/// </summary>
/// <param name="input">命令输入</param>
public TestAsyncCommandWithExceptionV3(TestCommandInputV2 input) : base(input)
{
}
/// <summary>
/// 执行异步命令并抛出异常的重写方法
/// </summary>
/// <param name="input">命令输入</param>
/// <returns>表示异步操作的任务</returns>
/// <exception cref="InvalidOperationException">总是抛出异常</exception>
protected override Task OnExecuteAsync(TestCommandInputV2 input)
{
throw new InvalidOperationException("Test exception");
}
}
/// <summary>
/// 测试用异步命令子类（无返回值）
/// </summary>
public sealed class TestAsyncCommandChildV3 : AbstractAsyncCommand<TestCommandInputV2>
{
/// <summary>
/// 构造函数
/// </summary>
/// <param name="input">命令输入</param>
public TestAsyncCommandChildV3(TestCommandInputV2 input) : base(input)
{
}
/// <summary>
/// 获取命令是否已执行
/// </summary>
public bool Executed { get; private set; }
/// <summary>
/// 获取执行的值
/// </summary>
public int ExecutedValue { get; private set; }
/// <summary>
/// 执行异步命令的重写方法（子类实现）
/// </summary>
/// <param name="input">命令输入</param>
/// <returns>表示异步操作的任务</returns>
protected override Task OnExecuteAsync(TestCommandInputV2 input)
{
Executed = true;
ExecutedValue = input.Value * 2;
return Task.CompletedTask;
}
}
/// <summary>
/// 测试用异步命令子类（有返回值）
/// </summary>
public sealed class TestAsyncCommandWithResultChildV3 : AbstractAsyncCommand<TestCommandInputV2, int>
{
/// <summary>
/// 构造函数
/// </summary>
/// <param name="input">命令输入</param>
public TestAsyncCommandWithResultChildV3(TestCommandInputV2 input) : base(input)
{
}
/// <summary>
/// 获取命令是否已执行
/// </summary>
public bool Executed { get; private set; }
/// <summary>
/// 执行异步命令并返回结果的重写方法（子类实现）
/// </summary>
/// <param name="input">命令输入</param>
/// <returns>执行结果的异步任务</returns>
protected override Task<int> OnExecuteAsync(TestCommandInputV2 input)
{
Executed = true;
return Task.FromResult(input.Value * 3);
}
}

142
GFramework.Core.Tests/Command/CommandExecutorTests.cs
View File

@ -1,5 +1,4 @@
using GFramework.Core.Command;
using GFramework.Cqrs.Abstractions.Cqrs.Command;
namespace GFramework.Core.Tests.Command;
@ -121,144 +120,3 @@ public class CommandExecutorTests
Assert.ThrowsAsync<ArgumentNullException>(() => _commandExecutor.SendAsync<int>(null!));
}
}
/// <summary>
/// 测试用命令输入类，实现ICommandInput接口
/// </summary>
public sealed class TestCommandInput : ICommandInput
{
/// <summary>
/// 获取或设置值
/// </summary>
public int Value { get; init; }
}
/// <summary>
/// 测试用命令类，继承AbstractCommand
/// </summary>
public sealed class TestCommand : AbstractCommand<TestCommandInput>
{
/// <summary>
/// 构造函数
/// </summary>
/// <param name="input">命令输入</param>
public TestCommand(TestCommandInput input) : base(input)
{
}
/// <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)
{
Executed = true;
ExecutedValue = 42;
}
}
/// <summary>
/// 测试用带返回值的命令类，继承AbstractCommand
/// </summary>
public sealed class TestCommandWithResult : AbstractCommand<TestCommandInput, int>
{
/// <summary>
/// 构造函数
/// </summary>
/// <param name="input">命令输入</param>
public TestCommandWithResult(TestCommandInput input) : base(input)
{
}
/// <summary>
/// 获取命令是否已执行
/// </summary>
public bool Executed { get; private set; }
/// <summary>
/// 执行命令并返回结果的重写方法
/// </summary>
/// <param name="input">命令输入</param>
/// <returns>执行结果</returns>
protected override int OnExecute(TestCommandInput input)
{
Executed = true;
return input.Value * 2;
}
}
/// <summary>
/// 测试用异步命令类，继承AbstractAsyncCommand
/// </summary>
public sealed class TestAsyncCommand : AbstractAsyncCommand<TestCommandInput>
{
/// <summary>
/// 构造函数
/// </summary>
/// <param name="input">命令输入</param>
public TestAsyncCommand(TestCommandInput input) : base(input)
{
}
/// <summary>
/// 获取命令是否已执行
/// </summary>
public bool Executed { get; private set; }
/// <summary>
/// 获取执行的值
/// </summary>
public int ExecutedValue { get; private set; }
/// <summary>
/// 执行异步命令的重写方法
/// </summary>
/// <param name="input">命令输入</param>
/// <returns>表示异步操作的任务</returns>
protected override Task OnExecuteAsync(TestCommandInput input)
{
Executed = true;
ExecutedValue = 42;
return Task.CompletedTask;
}
}
/// <summary>
/// 测试用带返回值的异步命令类，继承AbstractAsyncCommand
/// </summary>
public sealed class TestAsyncCommandWithResult : AbstractAsyncCommand<TestCommandInput, int>
{
/// <summary>
/// 构造函数
/// </summary>
/// <param name="input">命令输入</param>
public TestAsyncCommandWithResult(TestCommandInput input) : base(input)
{
}
/// <summary>
/// 获取命令是否已执行
/// </summary>
public bool Executed { get; private set; }
/// <summary>
/// 执行异步命令并返回结果的重写方法
/// </summary>
/// <param name="input">命令输入</param>
/// <returns>执行结果的异步任务</returns>
protected override Task<int> OnExecuteAsync(TestCommandInput input)
{
Executed = true;
return Task.FromResult(input.Value * 2);
}
}

39
GFramework.Core.Tests/Command/TestAsyncCommand.cs Normal file
View File

@ -0,0 +1,39 @@
using GFramework.Core.Command;
namespace GFramework.Core.Tests.Command;
/// <summary>
/// 表示 <see cref="CommandExecutorTests" /> 使用的异步测试命令。
/// </summary>
public sealed class TestAsyncCommand : AbstractAsyncCommand<TestCommandInput>
{
/// <summary>
/// 初始化 <see cref="TestAsyncCommand" /> 的新实例。
/// </summary>
/// <param name="input">命令输入。</param>
public TestAsyncCommand(TestCommandInput input) : base(input)
{
}
/// <summary>
/// 获取一个值，该值指示命令是否已经执行。
/// </summary>
public bool Executed { get; private set; }
/// <summary>
/// 获取命令记录的执行结果值。
/// </summary>
public int ExecutedValue { get; private set; }
/// <summary>
/// 执行异步测试命令并记录执行状态。
/// </summary>
/// <param name="input">命令输入。</param>
/// <returns>已完成的异步任务。</returns>
protected override Task OnExecuteAsync(TestCommandInput input)
{
Executed = true;
ExecutedValue = 42;
return Task.CompletedTask;
}
}

39
GFramework.Core.Tests/Command/TestAsyncCommandChildV3.cs Normal file
View File

@ -0,0 +1,39 @@
using GFramework.Core.Command;
namespace GFramework.Core.Tests.Command;
/// <summary>
/// 表示 <see cref="AbstractAsyncCommandTests" /> 使用的子类化无返回值异步测试命令。
/// </summary>
public sealed class TestAsyncCommandChildV3 : AbstractAsyncCommand<TestCommandInputV2>
{
/// <summary>
/// 初始化 <see cref="TestAsyncCommandChildV3" /> 的新实例。
/// </summary>
/// <param name="input">命令输入。</param>
public TestAsyncCommandChildV3(TestCommandInputV2 input) : base(input)
{
}
/// <summary>
/// 获取一个值，该值指示命令是否已经执行。
/// </summary>
public bool Executed { get; private set; }
/// <summary>
/// 获取子类记录的执行值。
/// </summary>
public int ExecutedValue { get; private set; }
/// <summary>
/// 执行子类测试命令并记录经过变换的输入值。
/// </summary>
/// <param name="input">命令输入。</param>
/// <returns>已完成的异步任务。</returns>
protected override Task OnExecuteAsync(TestCommandInputV2 input)
{
Executed = true;
ExecutedValue = input.Value * 2;
return Task.CompletedTask;
}
}

39
GFramework.Core.Tests/Command/TestAsyncCommandV3.cs Normal file
View File

@ -0,0 +1,39 @@
using GFramework.Core.Command;
namespace GFramework.Core.Tests.Command;
/// <summary>
/// 表示 <see cref="AbstractAsyncCommandTests" /> 使用的无返回值异步测试命令。
/// </summary>
public sealed class TestAsyncCommandV3 : AbstractAsyncCommand<TestCommandInputV2>
{
/// <summary>
/// 初始化 <see cref="TestAsyncCommandV3" /> 的新实例。
/// </summary>
/// <param name="input">命令输入。</param>
public TestAsyncCommandV3(TestCommandInputV2 input) : base(input)
{
}
/// <summary>
/// 获取一个值，该值指示命令是否已经执行。
/// </summary>
public bool Executed { get; private set; }
/// <summary>
/// 获取命令记录的执行值。
/// </summary>
public int ExecutedValue { get; private set; }
/// <summary>
/// 执行测试命令并回写执行状态。
/// </summary>
/// <param name="input">命令输入。</param>
/// <returns>已完成的异步任务。</returns>
protected override Task OnExecuteAsync(TestCommandInputV2 input)
{
Executed = true;
ExecutedValue = input.Value;
return Task.CompletedTask;
}
}

28
GFramework.Core.Tests/Command/TestAsyncCommandWithExceptionV3.cs Normal file
View File

@ -0,0 +1,28 @@
using GFramework.Core.Command;
namespace GFramework.Core.Tests.Command;
/// <summary>
/// 表示 <see cref="AbstractAsyncCommandTests" /> 使用的异常路径异步测试命令。
/// </summary>
public sealed class TestAsyncCommandWithExceptionV3 : AbstractAsyncCommand<TestCommandInputV2>
{
/// <summary>
/// 初始化 <see cref="TestAsyncCommandWithExceptionV3" /> 的新实例。
/// </summary>
/// <param name="input">命令输入。</param>
public TestAsyncCommandWithExceptionV3(TestCommandInputV2 input) : base(input)
{
}
/// <summary>
/// 执行测试命令并始终抛出预期异常。
/// </summary>
/// <param name="input">命令输入。</param>
/// <returns>此方法不会正常返回。</returns>
/// <exception cref="InvalidOperationException">始终抛出，用于验证异常传播行为。</exception>
protected override Task OnExecuteAsync(TestCommandInputV2 input)
{
throw new InvalidOperationException("Test exception");
}
}

33
GFramework.Core.Tests/Command/TestAsyncCommandWithResult.cs Normal file
View File

@ -0,0 +1,33 @@
using GFramework.Core.Command;
namespace GFramework.Core.Tests.Command;
/// <summary>
/// 表示 <see cref="CommandExecutorTests" /> 使用的带返回值异步测试命令。
/// </summary>
public sealed class TestAsyncCommandWithResult : AbstractAsyncCommand<TestCommandInput, int>
{
/// <summary>
/// 初始化 <see cref="TestAsyncCommandWithResult" /> 的新实例。
/// </summary>
/// <param name="input">命令输入。</param>
public TestAsyncCommandWithResult(TestCommandInput input) : base(input)
{
}
/// <summary>
/// 获取一个值，该值指示命令是否已经执行。
/// </summary>
public bool Executed { get; private set; }
/// <summary>
/// 执行异步测试命令并返回基于输入值计算的结果。
/// </summary>
/// <param name="input">命令输入。</param>
/// <returns>输入值两倍的异步结果。</returns>
protected override Task<int> OnExecuteAsync(TestCommandInput input)
{
Executed = true;
return Task.FromResult(input.Value * 2);
}
}

33
GFramework.Core.Tests/Command/TestAsyncCommandWithResultChildV3.cs Normal file
View File

@ -0,0 +1,33 @@
using GFramework.Core.Command;
namespace GFramework.Core.Tests.Command;
/// <summary>
/// 表示 <see cref="AbstractAsyncCommandTests" /> 使用的子类化带返回值异步测试命令。
/// </summary>
public sealed class TestAsyncCommandWithResultChildV3 : AbstractAsyncCommand<TestCommandInputV2, int>
{
/// <summary>
/// 初始化 <see cref="TestAsyncCommandWithResultChildV3" /> 的新实例。
/// </summary>
/// <param name="input">命令输入。</param>
public TestAsyncCommandWithResultChildV3(TestCommandInputV2 input) : base(input)
{
}
/// <summary>
/// 获取一个值，该值指示命令是否已经执行。
/// </summary>
public bool Executed { get; private set; }
/// <summary>
/// 执行子类测试命令并返回经过变换的输入值。
/// </summary>
/// <param name="input">命令输入。</param>
/// <returns>输入值三倍的异步结果。</returns>
protected override Task<int> OnExecuteAsync(TestCommandInputV2 input)
{
Executed = true;
return Task.FromResult(input.Value * 3);
}
}

33
GFramework.Core.Tests/Command/TestAsyncCommandWithResultV3.cs Normal file
View File

@ -0,0 +1,33 @@
using GFramework.Core.Command;
namespace GFramework.Core.Tests.Command;
/// <summary>
/// 表示 <see cref="AbstractAsyncCommandTests" /> 使用的带返回值异步测试命令。
/// </summary>
public sealed class TestAsyncCommandWithResultV3 : AbstractAsyncCommand<TestCommandInputV2, int>
{
/// <summary>
/// 初始化 <see cref="TestAsyncCommandWithResultV3" /> 的新实例。
/// </summary>
/// <param name="input">命令输入。</param>
public TestAsyncCommandWithResultV3(TestCommandInputV2 input) : base(input)
{
}
/// <summary>
/// 获取一个值，该值指示命令是否已经执行。
/// </summary>
public bool Executed { get; private set; }
/// <summary>
/// 执行测试命令并返回基于输入值计算的结果。
/// </summary>
/// <param name="input">命令输入。</param>
/// <returns>输入值两倍的异步结果。</returns>
protected override Task<int> OnExecuteAsync(TestCommandInputV2 input)
{
Executed = true;
return Task.FromResult(input.Value * 2);
}
}

37
GFramework.Core.Tests/Command/TestCommand.cs Normal file
View File

@ -0,0 +1,37 @@
using GFramework.Core.Command;
namespace GFramework.Core.Tests.Command;
/// <summary>
/// 表示 <see cref="CommandExecutorTests" /> 使用的同步测试命令。
/// </summary>
public sealed class TestCommand : AbstractCommand<TestCommandInput>
{
/// <summary>
/// 初始化 <see cref="TestCommand" /> 的新实例。
/// </summary>
/// <param name="input">命令输入。</param>
public TestCommand(TestCommandInput input) : base(input)
{
}
/// <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)
{
Executed = true;
ExecutedValue = 42;
}
}

14
GFramework.Core.Tests/Command/TestCommandInput.cs Normal file
View File

@ -0,0 +1,14 @@
using GFramework.Cqrs.Abstractions.Cqrs.Command;
namespace GFramework.Core.Tests.Command;
/// <summary>
/// 表示 <see cref="CommandExecutorTests" /> 使用的测试命令输入。
/// </summary>
public sealed class TestCommandInput : ICommandInput
{
/// <summary>
/// 获取或设置测试值。
/// </summary>
public int Value { get; init; }
}

14
GFramework.Core.Tests/Command/TestCommandInputV2.cs Normal file
View File

@ -0,0 +1,14 @@
using GFramework.Cqrs.Abstractions.Cqrs.Command;
namespace GFramework.Core.Tests.Command;
/// <summary>
/// 表示 <see cref="AbstractAsyncCommandTests" /> 使用的测试命令输入。
/// </summary>
public sealed class TestCommandInputV2 : ICommandInput
{
/// <summary>
/// 获取或设置用于驱动测试断言的输入值。
/// </summary>
public int Value { get; init; }
}

33
GFramework.Core.Tests/Command/TestCommandWithResult.cs Normal file
View File

@ -0,0 +1,33 @@
using GFramework.Core.Command;
namespace GFramework.Core.Tests.Command;
/// <summary>
/// 表示 <see cref="CommandExecutorTests" /> 使用的带返回值同步测试命令。
/// </summary>
public sealed class TestCommandWithResult : AbstractCommand<TestCommandInput, int>
{
/// <summary>
/// 初始化 <see cref="TestCommandWithResult" /> 的新实例。
/// </summary>
/// <param name="input">命令输入。</param>
public TestCommandWithResult(TestCommandInput input) : base(input)
{
}
/// <summary>
/// 获取一个值，该值指示命令是否已经执行。
/// </summary>
public bool Executed { get; private set; }
/// <summary>
/// 执行测试命令并返回基于输入值计算的结果。
/// </summary>
/// <param name="input">命令输入。</param>
/// <returns>输入值的两倍。</returns>
protected override int OnExecute(TestCommandInput input)
{
Executed = true;
return input.Value * 2;
}
}

16
GFramework.Core.Tests/Extensions/ObjectExtensionsTests.cs
View File

@ -218,19 +218,3 @@ public class ObjectExtensionsTests
Assert.That(executed, Is.False);
}
}
/// <summary>
/// 测试用的简单类
/// </summary>
public class TestClass
{
/// <summary>
/// 获取或设置整数值
/// </summary>
public int Value { get; set; }
/// <summary>
/// 获取或设置名称字符串
/// </summary>
public string Name { get; set; } = string.Empty;
}

17
GFramework.Core.Tests/Extensions/TestClass.cs Normal file
View File

@ -0,0 +1,17 @@
namespace GFramework.Core.Tests.Extensions;
/// <summary>
/// 为 <see cref="ObjectExtensionsTests" /> 提供类型匹配断言所需的简单测试对象。
/// </summary>
public class TestClass
{
/// <summary>
/// 获取或设置用于数值分支断言的测试值。
/// </summary>
public int Value { get; set; }
/// <summary>
/// 获取或设置用于字符串结果断言的测试名称。
/// </summary>
public string Name { get; set; } = string.Empty;
}

157
GFramework.Core.Tests/Query/AsyncQueryExecutorTests.cs
View File

@ -1,5 +1,4 @@
using GFramework.Core.Query;
using GFramework.Cqrs.Abstractions.Cqrs.Query;
namespace GFramework.Core.Tests.Query;
@ -137,159 +136,3 @@ public class AsyncQueryExecutorTests
Assert.That(result2, Is.EqualTo(40));
}
}
/// <summary>
/// 测试用异步查询输入类，实现IQueryInput接口
/// </summary>
public sealed class TestAsyncQueryInput : IQueryInput
{
/// <summary>
/// 获取或设置查询值
/// </summary>
public int Value { get; init; }
}
/// <summary>
/// 整数类型测试异步查询类，继承AbstractAsyncQuery
/// 实现具体的异步查询逻辑并返回整数结果
/// </summary>
public sealed class TestAsyncQuery : AbstractAsyncQuery<TestAsyncQueryInput, int>
{
/// <summary>
/// 初始化TestAsyncQuery的新实例
/// </summary>
/// <param name="input">查询输入参数</param>
public TestAsyncQuery(TestAsyncQueryInput input) : base(input)
{
}
/// <summary>
/// 执行异步查询操作的具体实现
/// </summary>
/// <param name="input">查询输入参数</param>
/// <returns>查询结果，将输入值乘以2</returns>
protected override Task<int> OnDoAsync(TestAsyncQueryInput input)
{
return Task.FromResult(input.Value * 2);
}
}
/// <summary>
/// 字符串类型测试异步查询类，继承AbstractAsyncQuery
/// 实现具体的异步查询逻辑并返回字符串结果
/// </summary>
public sealed class TestAsyncStringQuery : AbstractAsyncQuery<TestAsyncQueryInput, string>
{
/// <summary>
/// 初始化TestAsyncStringQuery的新实例
/// </summary>
/// <param name="input">查询输入参数</param>
public TestAsyncStringQuery(TestAsyncQueryInput input) : base(input)
{
}
/// <summary>
/// 执行异步查询操作的具体实现
/// </summary>
/// <param name="input">查询输入参数</param>
/// <returns>格式化的字符串结果</returns>
protected override Task<string> OnDoAsync(TestAsyncQueryInput input)
{
return Task.FromResult($"Result: {input.Value * 2}");
}
}
/// <summary>
/// 布尔类型测试异步查询类，继承AbstractAsyncQuery
/// 实现具体的异步查询逻辑并返回布尔结果
/// </summary>
public sealed class TestAsyncBooleanQuery : AbstractAsyncQuery<TestAsyncQueryInput, bool>
{
/// <summary>
/// 初始化TestAsyncBooleanQuery的新实例
/// </summary>
/// <param name="input">查询输入参数</param>
public TestAsyncBooleanQuery(TestAsyncQueryInput input) : base(input)
{
}
/// <summary>
/// 执行异步查询操作的具体实现
/// </summary>
/// <param name="input">查询输入参数</param>
/// <returns>如果值大于0返回true，否则返回false</returns>
protected override Task<bool> OnDoAsync(TestAsyncQueryInput input)
{
return Task.FromResult(input.Value > 0);
}
}
/// <summary>
/// 复杂对象类型测试异步查询类，继承AbstractAsyncQuery
/// 实现具体的异步查询逻辑并返回复杂对象结果
/// </summary>
public sealed class TestAsyncComplexQuery : AbstractAsyncQuery<TestAsyncQueryInput, TestAsyncQueryResult>
{
/// <summary>
/// 初始化TestAsyncComplexQuery的新实例
/// </summary>
/// <param name="input">查询输入参数</param>
public TestAsyncComplexQuery(TestAsyncQueryInput input) : base(input)
{
}
/// <summary>
/// 执行异步查询操作的具体实现
/// </summary>
/// <param name="input">查询输入参数</param>
/// <returns>复杂对象查询结果</returns>
protected override Task<TestAsyncQueryResult> OnDoAsync(TestAsyncQueryInput input)
{
var result = new TestAsyncQueryResult
{
Value = input.Value * 2,
DoubleValue = input.Value * 3
};
return Task.FromResult(result);
}
}
/// <summary>
/// 测试用异步查询类（抛出异常）
/// </summary>
public sealed class TestAsyncQueryWithException : AbstractAsyncQuery<TestAsyncQueryInput, int>
{
/// <summary>
/// 初始化TestAsyncQueryWithException的新实例
/// </summary>
/// <param name="input">查询输入参数</param>
public TestAsyncQueryWithException(TestAsyncQueryInput input) : base(input)
{
}
/// <summary>
/// 执行异步查询操作并抛出异常
/// </summary>
/// <param name="input">查询输入参数</param>
/// <exception cref="InvalidOperationException">总是抛出异常</exception>
protected override Task<int> OnDoAsync(TestAsyncQueryInput input)
{
throw new InvalidOperationException("Test exception");
}
}
/// <summary>
/// 测试用复杂查询结果类
/// </summary>
public sealed class TestAsyncQueryResult
{
/// <summary>
/// 获取或设置值
/// </summary>
public int Value { get; init; }
/// <summary>
/// 获取或设置双倍值
/// </summary>
public int DoubleValue { get; init; }
}

63
GFramework.Core.Tests/Query/QueryExecutorTests.cs
View File

@ -1,5 +1,4 @@
using GFramework.Core.Query;
using GFramework.Cqrs.Abstractions.Cqrs.Query;
namespace GFramework.Core.Tests.Query;
@ -60,65 +59,3 @@ public class QueryExecutorTests
Assert.That(result, Is.EqualTo("Result: 10"));
}
}
/// <summary>
/// 测试用查询输入类，实现IQueryInput接口
/// 用于传递查询所需的参数信息
/// </summary>
public sealed class TestQueryInput : IQueryInput
{
/// <summary>
/// 获取或设置查询值
/// </summary>
public int Value { get; init; }
}
/// <summary>
/// 整数类型测试查询类，继承自AbstractQuery
/// 实现具体的查询逻辑并返回整数结果
/// </summary>
public sealed class TestQuery : AbstractQuery<TestQueryInput, int>
{
/// <summary>
/// 初始化TestQuery的新实例
/// </summary>
/// <param name="input">查询输入参数</param>
public TestQuery(TestQueryInput input) : base(input)
{
}
/// <summary>
/// 执行查询操作的具体实现
/// </summary>
/// <param name="input">查询输入参数</param>
/// <returns>查询结果，将输入值乘以2</returns>
protected override int OnDo(TestQueryInput input)
{
return input.Value * 2;
}
}
/// <summary>
/// 字符串类型测试查询类，继承自AbstractQuery
/// 实现具体的查询逻辑并返回字符串结果
/// </summary>
public sealed class TestStringQuery : AbstractQuery<TestQueryInput, string>
{
/// <summary>
/// 初始化TestStringQuery的新实例
/// </summary>
/// <param name="input">查询输入参数</param>
public TestStringQuery(TestQueryInput input) : base(input)
{
}
/// <summary>
/// 执行查询操作的具体实现
/// </summary>
/// <param name="input">查询输入参数</param>
/// <returns>格式化的字符串结果</returns>
protected override string OnDo(TestQueryInput input)
{
return $"Result: {input.Value * 2}";
}
}

27
GFramework.Core.Tests/Query/TestAsyncBooleanQuery.cs Normal file
View File

@ -0,0 +1,27 @@
using GFramework.Core.Query;
namespace GFramework.Core.Tests.Query;
/// <summary>
/// 为 <see cref="AsyncQueryExecutorTests" /> 提供布尔结果的测试异步查询。
/// </summary>
public sealed class TestAsyncBooleanQuery : AbstractAsyncQuery<TestAsyncQueryInput, bool>
{
/// <summary>
/// 初始化 <see cref="TestAsyncBooleanQuery" /> 的新实例。
/// </summary>
/// <param name="input">查询输入参数。</param>
public TestAsyncBooleanQuery(TestAsyncQueryInput input) : base(input)
{
}
/// <summary>
/// 执行异步查询并根据输入值是否大于零返回布尔结果。
/// </summary>
/// <param name="input">查询输入参数。</param>
/// <returns>当输入值大于 0 时返回 <see langword="true" />；否则返回 <see langword="false" />。</returns>
protected override Task<bool> OnDoAsync(TestAsyncQueryInput input)
{
return Task.FromResult(input.Value > 0);
}
}

33
GFramework.Core.Tests/Query/TestAsyncComplexQuery.cs Normal file
View File

@ -0,0 +1,33 @@
using GFramework.Core.Query;
namespace GFramework.Core.Tests.Query;
/// <summary>
/// 为 <see cref="AsyncQueryExecutorTests" /> 提供复杂对象结果的测试异步查询。
/// </summary>
public sealed class TestAsyncComplexQuery : AbstractAsyncQuery<TestAsyncQueryInput, TestAsyncQueryResult>
{
/// <summary>
/// 初始化 <see cref="TestAsyncComplexQuery" /> 的新实例。
/// </summary>
/// <param name="input">查询输入参数。</param>
public TestAsyncComplexQuery(TestAsyncQueryInput input) : base(input)
{
}
/// <summary>
/// 执行异步查询并构造组合结果对象。
/// </summary>
/// <param name="input">查询输入参数。</param>
/// <returns>包含双倍值和三倍值的测试结果对象。</returns>
protected override Task<TestAsyncQueryResult> OnDoAsync(TestAsyncQueryInput input)
{
var result = new TestAsyncQueryResult
{
Value = input.Value * 2,
DoubleValue = input.Value * 3
};
return Task.FromResult(result);
}
}

27
GFramework.Core.Tests/Query/TestAsyncQuery.cs Normal file
View File

@ -0,0 +1,27 @@
using GFramework.Core.Query;
namespace GFramework.Core.Tests.Query;
/// <summary>
/// 为 <see cref="AsyncQueryExecutorTests" /> 提供整数结果的测试异步查询。
/// </summary>
public sealed class TestAsyncQuery : AbstractAsyncQuery<TestAsyncQueryInput, int>
{
/// <summary>
/// 初始化 <see cref="TestAsyncQuery" /> 的新实例。
/// </summary>
/// <param name="input">查询输入参数。</param>
public TestAsyncQuery(TestAsyncQueryInput input) : base(input)
{
}
/// <summary>
/// 执行异步查询并返回输入值的两倍。
/// </summary>
/// <param name="input">查询输入参数。</param>
/// <returns>将输入值乘以 2 的结果。</returns>
protected override Task<int> OnDoAsync(TestAsyncQueryInput input)
{
return Task.FromResult(input.Value * 2);
}
}

14
GFramework.Core.Tests/Query/TestAsyncQueryInput.cs Normal file
View File

@ -0,0 +1,14 @@
using GFramework.Cqrs.Abstractions.Cqrs.Query;
namespace GFramework.Core.Tests.Query;
/// <summary>
/// 为 <see cref="AsyncQueryExecutorTests" /> 提供输入值的测试查询输入。
/// </summary>
public sealed class TestAsyncQueryInput : IQueryInput
{
/// <summary>
/// 获取或设置查询值。
/// </summary>
public int Value { get; init; }
}

17
GFramework.Core.Tests/Query/TestAsyncQueryResult.cs Normal file
View File

@ -0,0 +1,17 @@
namespace GFramework.Core.Tests.Query;
/// <summary>
/// 表示 <see cref="AsyncQueryExecutorTests" /> 使用的复杂测试查询结果。
/// </summary>
public sealed class TestAsyncQueryResult
{
/// <summary>
/// 获取或设置主结果值。
/// </summary>
public int Value { get; init; }
/// <summary>
/// 获取或设置派生的双重结果值。
/// </summary>
public int DoubleValue { get; init; }
}

28
GFramework.Core.Tests/Query/TestAsyncQueryWithException.cs Normal file
View File

@ -0,0 +1,28 @@
using GFramework.Core.Query;
namespace GFramework.Core.Tests.Query;
/// <summary>
/// 为 <see cref="AsyncQueryExecutorTests" /> 提供固定抛出异常的测试异步查询。
/// </summary>
public sealed class TestAsyncQueryWithException : AbstractAsyncQuery<TestAsyncQueryInput, int>
{
/// <summary>
/// 初始化 <see cref="TestAsyncQueryWithException" /> 的新实例。
/// </summary>
/// <param name="input">查询输入参数。</param>
public TestAsyncQueryWithException(TestAsyncQueryInput input) : base(input)
{
}
/// <summary>
/// 执行异步查询并始终抛出测试异常。
/// </summary>
/// <param name="input">查询输入参数。</param>
/// <returns>此方法不会返回结果。</returns>
/// <exception cref="InvalidOperationException">始终抛出，模拟查询执行失败。</exception>
protected override Task<int> OnDoAsync(TestAsyncQueryInput input)
{
throw new InvalidOperationException("Test exception");
}
}

27
GFramework.Core.Tests/Query/TestAsyncStringQuery.cs Normal file
View File

@ -0,0 +1,27 @@
using GFramework.Core.Query;
namespace GFramework.Core.Tests.Query;
/// <summary>
/// 为 <see cref="AsyncQueryExecutorTests" /> 提供字符串结果的测试异步查询。
/// </summary>
public sealed class TestAsyncStringQuery : AbstractAsyncQuery<TestAsyncQueryInput, string>
{
/// <summary>
/// 初始化 <see cref="TestAsyncStringQuery" /> 的新实例。
/// </summary>
/// <param name="input">查询输入参数。</param>
public TestAsyncStringQuery(TestAsyncQueryInput input) : base(input)
{
}
/// <summary>
/// 执行异步查询并返回格式化的字符串结果。
/// </summary>
/// <param name="input">查询输入参数。</param>
/// <returns>包含双倍值的格式化字符串。</returns>
protected override Task<string> OnDoAsync(TestAsyncQueryInput input)
{
return Task.FromResult($"Result: {input.Value * 2}");
}
}

27
GFramework.Core.Tests/Query/TestQuery.cs Normal file
View File

@ -0,0 +1,27 @@
using GFramework.Core.Query;
namespace GFramework.Core.Tests.Query;
/// <summary>
/// 为 <see cref="QueryExecutorTests" /> 提供整数结果的测试同步查询。
/// </summary>
public sealed class TestQuery : AbstractQuery<TestQueryInput, int>
{
/// <summary>
/// 初始化 <see cref="TestQuery" /> 的新实例。
/// </summary>
/// <param name="input">查询输入参数。</param>
public TestQuery(TestQueryInput input) : base(input)
{
}
/// <summary>
/// 执行同步查询并返回输入值的双倍结果。
/// </summary>
/// <param name="input">查询输入参数。</param>
/// <returns>输入值乘以 2 后的结果。</returns>
protected override int OnDo(TestQueryInput input)
{
return input.Value * 2;
}
}

14
GFramework.Core.Tests/Query/TestQueryInput.cs Normal file
View File

@ -0,0 +1,14 @@
using GFramework.Cqrs.Abstractions.Cqrs.Query;
namespace GFramework.Core.Tests.Query;
/// <summary>
/// 为 <see cref="QueryExecutorTests" /> 提供输入值的测试查询输入。
/// </summary>
public sealed class TestQueryInput : IQueryInput
{
/// <summary>
/// 获取或设置查询值。
/// </summary>
public int Value { get; init; }
}

27
GFramework.Core.Tests/Query/TestStringQuery.cs Normal file
View File

@ -0,0 +1,27 @@
using GFramework.Core.Query;
namespace GFramework.Core.Tests.Query;
/// <summary>
/// 为 <see cref="QueryExecutorTests" /> 提供字符串结果的测试同步查询。
/// </summary>
public sealed class TestStringQuery : AbstractQuery<TestQueryInput, string>
{
/// <summary>
/// 初始化 <see cref="TestStringQuery" /> 的新实例。
/// </summary>
/// <param name="input">查询输入参数。</param>
public TestStringQuery(TestQueryInput input) : base(input)
{
}
/// <summary>
/// 执行同步查询并返回格式化后的字符串结果。
/// </summary>
/// <param name="input">查询输入参数。</param>
/// <returns>包含双倍值的格式化字符串。</returns>
protected override string OnDo(TestQueryInput input)
{
return $"Result: {input.Value * 2}";
}
}

26
GFramework.Core.Tests/Rule/ContextAwareTests.cs
View File

@ -99,29 +99,3 @@ public class ContextAwareTests
Assert.DoesNotThrow(() => aware.GetContext());
}
}
/// <summary>
/// 用于测试的 ContextAware 实现类
/// 继承自 ContextAwareBase，提供公共访问的上下文属性和回调状态跟踪
/// </summary>
public class TestContextAware : ContextAwareBase
{
/// <summary>
/// 获取内部上下文的公共访问属性
/// </summary>
public IArchitectureContext? PublicContext => Context;
/// <summary>
/// 跟踪 OnContextReady 方法是否被调用的状态
/// </summary>
public bool OnContextReadyCalled { get; private set; }
/// <summary>
/// 重写上下文就绪回调方法
/// 设置 OnContextReadyCalled 标志为 true，用于测试验证
/// </summary>
protected override void OnContextReady()
{
OnContextReadyCalled = true;
}
}

28
GFramework.Core.Tests/Rule/TestContextAware.cs Normal file
View File

@ -0,0 +1,28 @@
using GFramework.Core.Abstractions.Architectures;
using GFramework.Core.Rule;
namespace GFramework.Core.Tests.Rule;
/// <summary>
/// 提供给 ContextAware 相关测试复用的上下文感知对象。
/// </summary>
public class TestContextAware : ContextAwareBase
{
/// <summary>
/// 获取当前测试对象已绑定的上下文实例。
/// </summary>
public IArchitectureContext? PublicContext => Context;
/// <summary>
/// 获取一个值，指示上下文就绪回调是否已经触发。
/// </summary>
public bool OnContextReadyCalled { get; private set; }
/// <summary>
/// 在上下文完成绑定后记录回调已被触发，供断言使用。
/// </summary>
protected override void OnContextReady()
{
OnContextReadyCalled = true;
}
}

116
GFramework.Core.Tests/State/ConcreteAsyncStateV2.cs Normal file
View File

@ -0,0 +1,116 @@
using GFramework.Core.Abstractions.State;
namespace GFramework.Core.Tests.State;
/// <summary>
/// 异步具体状态实现类V2版本，用于测试异步状态的基本功能。
/// </summary>
public sealed class ConcreteAsyncStateV2 : IState, IAsyncState
{
/// <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 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>
public Action<IState>? CanTransitionToAsyncAction { get; set; }
/// <summary>
/// 异步进入当前状态时调用的方法。
/// </summary>
/// <param name="from">从哪个状态进入。</param>
public async Task OnEnterAsync(IState? from)
{
await Task.Delay(1).ConfigureAwait(false);
EnterCalled = true;
EnterCallCount++;
EnterFrom = from;
}
/// <summary>
/// 异步退出当前状态时调用的方法。
/// </summary>
/// <param name="to">退出到哪个状态。</param>
public async Task OnExitAsync(IState? to)
{
await Task.Delay(1).ConfigureAwait(false);
ExitCalled = true;
ExitCallCount++;
ExitTo = to;
}
/// <summary>
/// 异步判断是否可以转换到目标状态。
/// </summary>
/// <param name="target">目标状态。</param>
/// <returns>如果可以转换则返回 <see langword="true" />，否则返回 <see langword="false" />。</returns>
public async Task<bool> CanTransitionToAsync(IState target)
{
await Task.Delay(1).ConfigureAwait(false);
CanTransitionToAsyncAction?.Invoke(target);
return AllowTransitions;
}
/// <summary>
/// 进入当前状态时调用的方法（同步版本，抛出异常表示不应被调用）。
/// </summary>
/// <param name="from">从哪个状态进入。</param>
/// <exception cref="InvalidOperationException">总是抛出，表示异步状态不应走同步入口。</exception>
public void OnEnter(IState? from)
{
throw new InvalidOperationException("Sync OnEnter should not be called for async state");
}
/// <summary>
/// 退出当前状态时调用的方法（同步版本，抛出异常表示不应被调用）。
/// </summary>
/// <param name="to">退出到哪个状态。</param>
/// <exception cref="InvalidOperationException">总是抛出，表示异步状态不应走同步入口。</exception>
public void OnExit(IState? to)
{
throw new InvalidOperationException("Sync OnExit should not be called for async state");
}
/// <summary>
/// 判断是否可以转换到目标状态（同步版本，抛出异常表示不应被调用）。
/// </summary>
/// <param name="target">目标状态。</param>
/// <returns>此方法不会正常返回。</returns>
/// <exception cref="InvalidOperationException">总是抛出，表示异步状态不应走同步入口。</exception>
public bool CanTransitionTo(IState target)
{
throw new InvalidOperationException("Sync CanTransitionTo should not be called for async state");
}
}

70
GFramework.Core.Tests/State/ConcreteStateV2.cs Normal file
View File

@ -0,0 +1,70 @@
using GFramework.Core.Abstractions.State;
namespace GFramework.Core.Tests.State;
/// <summary>
/// 具体状态实现类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)
{
EnterCalled = true;
EnterFrom = from;
}
/// <summary>
/// 退出当前状态时调用的方法。
/// </summary>
/// <param name="to">退出到哪个状态。</param>
public void OnExit(IState? to)
{
ExitCalled = true;
ExitTo = to;
}
/// <summary>
/// 判断是否可以转换到目标状态。
/// </summary>
/// <param name="target">目标状态。</param>
/// <returns>如果可以转换则返回 <see langword="true" />，否则返回 <see langword="false" />。</returns>
public bool CanTransitionTo(IState target)
{
CanTransitionToAction?.Invoke(target);
return AllowTransitions;
}
}

59
GFramework.Core.Tests/State/ConcreteStateV3.cs Normal file
View File

@ -0,0 +1,59 @@
using GFramework.Core.Abstractions.State;
namespace GFramework.Core.Tests.State;
/// <summary>
/// 具体状态实现类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)
{
EnterCalled = true;
EnterFrom = from;
}
/// <summary>
/// 退出当前状态时调用的方法。
/// </summary>
/// <param name="to">退出到哪个状态。</param>
public void OnExit(IState? to)
{
ExitCalled = true;
ExitTo = to;
}
/// <summary>
/// 判断是否可以转换到目标状态。
/// </summary>
/// <param name="target">目标状态。</param>
/// <returns>始终返回 <see langword="true" />。</returns>
public bool CanTransitionTo(IState target)
{
return true;
}
}

59
GFramework.Core.Tests/State/ConcreteStateV4.cs Normal file
View File

@ -0,0 +1,59 @@
using GFramework.Core.Abstractions.State;
namespace GFramework.Core.Tests.State;
/// <summary>
/// 具体状态实现类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)
{
EnterCalled = true;
EnterFrom = from;
}
/// <summary>
/// 退出当前状态时调用的方法。
/// </summary>
/// <param name="to">退出到哪个状态。</param>
public void OnExit(IState? to)
{
ExitCalled = true;
ExitTo = to;
}
/// <summary>
/// 判断是否可以转换到目标状态。
/// </summary>
/// <param name="target">目标状态。</param>
/// <returns>始终返回 <see langword="true" />。</returns>
public bool CanTransitionTo(IState target)
{
return true;
}
}

64
GFramework.Core.Tests/State/ConditionalStateV2.cs Normal file
View File

@ -0,0 +1,64 @@
using GFramework.Core.Abstractions.State;
namespace GFramework.Core.Tests.State;
/// <summary>
/// 条件状态实现类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)
{
EnterCalled = true;
EnterFrom = from;
}
/// <summary>
/// 退出当前状态时调用的方法。
/// </summary>
/// <param name="to">退出到哪个状态。</param>
public void OnExit(IState? to)
{
ExitCalled = true;
ExitTo = to;
}
/// <summary>
/// 判断是否可以转换到目标状态。
/// </summary>
/// <param name="target">目标状态。</param>
/// <returns>如果目标状态类型在允许列表中则返回 <see langword="true" />，否则返回 <see langword="false" />。</returns>
public bool CanTransitionTo(IState target)
{
return AllowedTransitions.Contains(target.GetType());
}
}

138
GFramework.Core.Tests/State/StateMachineSystemTests.cs
View File

@ -1,7 +1,6 @@
using System.Reflection;
using GFramework.Core.Abstractions.Enums;
using GFramework.Core.Abstractions.Logging;
using GFramework.Core.Abstractions.State;
using GFramework.Core.Abstractions.Systems;
using GFramework.Core.Architectures;
using GFramework.Core.Command;
@ -238,140 +237,3 @@ public class StateMachineSystemTests
Assert.That(eventCount, Is.EqualTo(3));
}
}
#region Test Classes
/// <summary>
/// 测试用的ContextAwareStateMachine派生类，用于访问内部状态字典
/// </summary>
public class TestStateMachineSystemV5 : StateMachineSystem
{
/// <summary>
/// 获取状态机内部的状态字典
/// </summary>
/// <returns>类型到状态实例的映射字典</returns>
public IDictionary<Type, IState> GetStates()
{
return States;
}
}
/// <summary>
/// 测试用的上下文感知状态基类实现
/// </summary>
public class TestContextAwareStateV5 : ContextAwareStateBase
{
/// <summary>
/// 进入状态时调用
/// </summary>
/// <param name="previous">前一个状态</param>
public override void OnEnter(IState? previous)
{
}
/// <summary>
/// 退出状态时调用
/// </summary>
/// <param name="next">下一个状态</param>
public override void OnExit(IState? next)
{
}
}
/// <summary>
/// 第二个测试用的上下文感知状态基类实现
/// </summary>
public class TestContextAwareStateV5_2 : ContextAwareStateBase
{
/// <summary>
/// 进入状态时调用
/// </summary>
/// <param name="previous">前一个状态</param>
public override void OnEnter(IState? previous)
{
}
/// <summary>
/// 退出状态时调用
/// </summary>
/// <param name="next">下一个状态</param>
public override void OnExit(IState? next)
{
}
}
/// <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)
{
return true;
}
/// <summary>
/// 进入状态时调用
/// </summary>
/// <param name="previous">前一个状态</param>
public void OnEnter(IState? previous)
{
}
/// <summary>
/// 退出状态时调用
/// </summary>
/// <param name="next">下一个状态</param>
public void OnExit(IState? next)
{
}
}
/// <summary>
/// 第二个测试用的普通状态实现，用于区分不同状态类型
/// </summary>
public class TestStateV5_2 : IState
{
/// <summary>
/// 状态标识符
/// </summary>
public int Id { get; set; }
/// <summary>
/// 检查是否可以转换到指定状态
/// </summary>
/// <param name="next">目标状态</param>
/// <returns>始终返回true表示允许转换</returns>
public bool CanTransitionTo(IState next)
{
return true;
}
/// <summary>
/// 进入状态时调用
/// </summary>
/// <param name="previous">前一个状态</param>
public void OnEnter(IState? previous)
{
}
/// <summary>
/// 退出状态时调用
/// </summary>
/// <param name="next">下一个状态</param>
public void OnExit(IState? next)
{
}
}
#endregion

406
GFramework.Core.Tests/State/StateTests.cs
View File

@ -326,409 +326,3 @@ public class StateTests
Assert.That(state.ExitCallCount, Is.EqualTo(2));
}
}
/// <summary>
/// 具体状态实现类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)
{
EnterCalled = true;
EnterFrom = from;
}
/// <summary>
/// 退出当前状态时调用的方法
/// </summary>
/// <param name="to">退出到哪个状态</param>
public void OnExit(IState? to)
{
ExitCalled = true;
ExitTo = to;
}
/// <summary>
/// 判断是否可以转换到目标状态
/// </summary>
/// <param name="target">目标状态</param>
/// <returns>如果可以转换则返回true，否则返回false</returns>
public bool CanTransitionTo(IState target)
{
CanTransitionToAction?.Invoke(target);
return AllowTransitions;
}
}
/// <summary>
/// 具体状态实现类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)
{
EnterCalled = true;
EnterFrom = from;
}
/// <summary>
/// 退出当前状态时调用的方法
/// </summary>
/// <param name="to">退出到哪个状态</param>
public void OnExit(IState? to)
{
ExitCalled = true;
ExitTo = to;
}
/// <summary>
/// 判断是否可以转换到目标状态
/// </summary>
/// <param name="target">目标状态</param>
/// <returns>如果可以转换则返回true，否则返回false</returns>
public bool CanTransitionTo(IState target)
{
return true;
}
}
/// <summary>
/// 具体状态实现类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)
{
EnterCalled = true;
EnterFrom = from;
}
/// <summary>
/// 退出当前状态时调用的方法
/// </summary>
/// <param name="to">退出到哪个状态</param>
public void OnExit(IState? to)
{
ExitCalled = true;
ExitTo = to;
}
/// <summary>
/// 判断是否可以转换到目标状态
/// </summary>
/// <param name="target">目标状态</param>
/// <returns>如果可以转换则返回true，否则返回false</returns>
public bool CanTransitionTo(IState target)
{
return true;
}
}
/// <summary>
/// 条件状态实现类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)
{
EnterCalled = true;
EnterFrom = from;
}
/// <summary>
/// 退出当前状态时调用的方法
/// </summary>
/// <param name="to">退出到哪个状态</param>
public void OnExit(IState? to)
{
ExitCalled = true;
ExitTo = to;
}
/// <summary>
/// 判断是否可以转换到目标状态
/// </summary>
/// <param name="target">目标状态</param>
/// <returns>如果目标状态类型在允许列表中则返回true，否则返回false</returns>
public bool CanTransitionTo(IState target)
{
return AllowedTransitions.Contains(target.GetType());
}
}
/// <summary>
/// 跟踪状态实现类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)
{
EnterCallCount++;
EnterFrom = from;
}
/// <summary>
/// 退出当前状态时调用的方法
/// </summary>
/// <param name="to">退出到哪个状态</param>
public void OnExit(IState? to)
{
ExitCallCount++;
ExitTo = to;
}
/// <summary>
/// 判断是否可以转换到目标状态
/// </summary>
/// <param name="target">目标状态</param>
/// <returns>总是返回true</returns>
public bool CanTransitionTo(IState target)
{
return true;
}
}
/// <summary>
/// 异步具体状态实现类V2版本，用于测试异步状态的基本功能
/// </summary>
public sealed class ConcreteAsyncStateV2 : IState, IAsyncState
{
/// <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 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>
public Action<IState>? CanTransitionToAsyncAction { get; set; }
/// <summary>
/// 异步进入当前状态时调用的方法
/// </summary>
/// <param name="from">从哪个状态进入</param>
public async Task OnEnterAsync(IState? from)
{
await Task.Delay(1).ConfigureAwait(false);
EnterCalled = true;
EnterCallCount++;
EnterFrom = from;
}
/// <summary>
/// 异步退出当前状态时调用的方法
/// </summary>
/// <param name="to">退出到哪个状态</param>
public async Task OnExitAsync(IState? to)
{
await Task.Delay(1).ConfigureAwait(false);
ExitCalled = true;
ExitCallCount++;
ExitTo = to;
}
/// <summary>
/// 异步判断是否可以转换到目标状态
/// </summary>
/// <param name="target">目标状态</param>
/// <returns>如果可以转换则返回true，否则返回false</returns>
public async Task<bool> CanTransitionToAsync(IState target)
{
await Task.Delay(1).ConfigureAwait(false);
CanTransitionToAsyncAction?.Invoke(target);
return AllowTransitions;
}
/// <summary>
/// 进入当前状态时调用的方法（同步版本，抛出异常表示不应被调用）
/// </summary>
/// <param name="from">从哪个状态进入</param>
public void OnEnter(IState? from)
{
throw new InvalidOperationException("Sync OnEnter should not be called for async state");
}
/// <summary>
/// 退出当前状态时调用的方法（同步版本，抛出异常表示不应被调用）
/// </summary>
/// <param name="to">退出到哪个状态</param>
public void OnExit(IState? to)
{
throw new InvalidOperationException("Sync OnExit should not be called for async state");
}
/// <summary>
/// 判断是否可以转换到目标状态（同步版本，抛出异常表示不应被调用）
/// </summary>
/// <param name="target">目标状态</param>
/// <returns>如果可以转换则返回true，否则返回false</returns>
public bool CanTransitionTo(IState target)
{
throw new InvalidOperationException("Sync CanTransitionTo should not be called for async state");
}
}

26
GFramework.Core.Tests/State/TestContextAwareStateV5.cs Normal file
View File

@ -0,0 +1,26 @@
using GFramework.Core.Abstractions.State;
using GFramework.Core.State;
namespace GFramework.Core.Tests.State;
/// <summary>
/// 为 <see cref="StateMachineSystemTests" /> 提供最小化的上下文感知状态实现。
/// </summary>
public class TestContextAwareStateV5 : ContextAwareStateBase
{
/// <summary>
/// 进入状态时调用。该测试替身不需要额外行为。
/// </summary>
/// <param name="previous">前一个状态。</param>
public override void OnEnter(IState? previous)
{
}
/// <summary>
/// 退出状态时调用。该测试替身不需要额外行为。
/// </summary>
/// <param name="next">下一个状态。</param>
public override void OnExit(IState? next)
{
}
}

26
GFramework.Core.Tests/State/TestContextAwareStateV5_2.cs Normal file
View File

@ -0,0 +1,26 @@
using GFramework.Core.Abstractions.State;
using GFramework.Core.State;
namespace GFramework.Core.Tests.State;
/// <summary>
/// 为 <see cref="StateMachineSystemTests" /> 提供第二个可区分类型的上下文感知状态实现。
/// </summary>
public class TestContextAwareStateV5_2 : ContextAwareStateBase
{
/// <summary>
/// 进入状态时调用。该测试替身不需要额外行为。
/// </summary>
/// <param name="previous">前一个状态。</param>
public override void OnEnter(IState? previous)
{
}
/// <summary>
/// 退出状态时调用。该测试替身不需要额外行为。
/// </summary>
/// <param name="next">下一个状态。</param>
public override void OnExit(IState? next)
{
}
}

21
GFramework.Core.Tests/State/TestStateMachineSystemV5.cs Normal file
View File

@ -0,0 +1,21 @@
using System;
using System.Collections.Generic;
using GFramework.Core.Abstractions.State;
using GFramework.Core.State;
namespace GFramework.Core.Tests.State;
/// <summary>
/// 为 <see cref="StateMachineSystemTests" /> 提供可观察内部状态注册表的测试状态机实现。
/// </summary>
public class TestStateMachineSystemV5 : StateMachineSystem
{
/// <summary>
/// 获取状态机当前维护的状态实例映射，供测试断言注册结果使用。
/// </summary>
/// <returns>状态类型到状态实例的只读视图。</returns>
public IDictionary<Type, IState> GetStates()
{
return States;
}
}

40
GFramework.Core.Tests/State/TestStateV5.cs Normal file
View File

@ -0,0 +1,40 @@
using GFramework.Core.Abstractions.State;
namespace GFramework.Core.Tests.State;
/// <summary>
/// 为 <see cref="StateMachineSystemTests" /> 提供最小化的普通状态实现。
/// </summary>
public class TestStateV5 : IState
{
/// <summary>
/// 获取或设置测试状态标识符。
/// </summary>
public int Id { get; set; }
/// <summary>
/// 判断是否允许转换到下一个状态。
/// </summary>
/// <param name="next">目标状态。</param>
/// <returns>始终返回 <see langword="true" /> 以简化状态机切换测试。</returns>
public bool CanTransitionTo(IState next)
{
return true;
}
/// <summary>
/// 进入状态时调用。该测试替身不需要额外行为。
/// </summary>
/// <param name="previous">前一个状态。</param>
public void OnEnter(IState? previous)
{
}
/// <summary>
/// 退出状态时调用。该测试替身不需要额外行为。
/// </summary>
/// <param name="next">下一个状态。</param>
public void OnExit(IState? next)
{
}
}

40
GFramework.Core.Tests/State/TestStateV5_2.cs Normal file
View File

@ -0,0 +1,40 @@
using GFramework.Core.Abstractions.State;
namespace GFramework.Core.Tests.State;
/// <summary>
/// 为 <see cref="StateMachineSystemTests" /> 提供第二个可区分类型的普通状态实现。
/// </summary>
public class TestStateV5_2 : IState
{
/// <summary>
/// 获取或设置测试状态标识符。
/// </summary>
public int Id { get; set; }
/// <summary>
/// 判断是否允许转换到下一个状态。
/// </summary>
/// <param name="next">目标状态。</param>
/// <returns>始终返回 <see langword="true" /> 以简化状态机切换测试。</returns>
public bool CanTransitionTo(IState next)
{
return true;
}
/// <summary>
/// 进入状态时调用。该测试替身不需要额外行为。
/// </summary>
/// <param name="previous">前一个状态。</param>
public void OnEnter(IState? previous)
{
}
/// <summary>
/// 退出状态时调用。该测试替身不需要额外行为。
/// </summary>
/// <param name="next">下一个状态。</param>
public void OnExit(IState? next)
{
}
}

59
GFramework.Core.Tests/State/TrackingStateV2.cs Normal file
View File

@ -0,0 +1,59 @@
using GFramework.Core.Abstractions.State;
namespace GFramework.Core.Tests.State;
/// <summary>
/// 跟踪状态实现类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)
{
EnterCallCount++;
EnterFrom = from;
}
/// <summary>
/// 退出当前状态时调用的方法。
/// </summary>
/// <param name="to">退出到哪个状态。</param>
public void OnExit(IState? to)
{
ExitCallCount++;
ExitTo = to;
}
/// <summary>
/// 判断是否可以转换到目标状态。
/// </summary>
/// <param name="target">目标状态。</param>
/// <returns>始终返回 <see langword="true" />。</returns>
public bool CanTransitionTo(IState target)
{
return true;
}
}

85
GFramework.Core.Tests/Utility/AbstractContextUtilityTests.cs
View File

@ -1,4 +1,3 @@
using GFramework.Core.Abstractions.Logging;
using GFramework.Core.Abstractions.Rule;
using GFramework.Core.Abstractions.Utility;
using GFramework.Core.Architectures;
@ -208,87 +207,3 @@ public class AbstractContextUtilityTests
Assert.That(utility.Destroyed, Is.True);
}
}
/// <summary>
/// 测试用上下文工具类V1
/// </summary>
public sealed class TestContextUtilityV1 : AbstractContextUtility
{
/// <summary>
/// 获取工具是否已初始化
/// </summary>
public bool Initialized { get; private set; }
/// <summary>
/// 获取工具是否已销毁
/// </summary>
public bool Destroyed { get; set; }
/// <summary>
/// 获取Init方法是否被调用
/// </summary>
public bool InitCalled { get; private set; }
/// <summary>
/// 获取Logger对象（用于测试）
/// </summary>
public ILogger? GetLogger()
{
return Logger;
}
/// <summary>
/// 初始化方法
/// </summary>
protected override void OnInit()
{
Initialized = true;
InitCalled = true;
}
/// <summary>
/// 销毁方法
/// </summary>
protected override void OnDestroy()
{
Destroyed = true;
}
}
/// <summary>
/// 测试用上下文工具类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()
{
Initialized = true;
CustomInitializationDone = true;
}
/// <summary>
/// 销毁方法
/// </summary>
protected override void OnDestroy()
{
Destroyed = true;
}
}

51
GFramework.Core.Tests/Utility/TestContextUtilityV1.cs Normal file
View File

@ -0,0 +1,51 @@
using GFramework.Core.Abstractions.Logging;
using GFramework.Core.Utility;
namespace GFramework.Core.Tests.Utility;
/// <summary>
/// 为 <see cref="AbstractContextUtilityTests" /> 提供的基础上下文工具测试桩。
/// </summary>
public sealed class TestContextUtilityV1 : AbstractContextUtility
{
/// <summary>
/// 获取一个值，该值指示当前工具是否已完成初始化。
/// </summary>
public bool Initialized { get; private set; }
/// <summary>
/// 获取或设置一个值，该值指示当前工具是否已执行销毁逻辑。
/// </summary>
public bool Destroyed { get; set; }
/// <summary>
/// 获取一个值，该值指示测试初始化钩子是否已被调用。
/// </summary>
public bool InitCalled { get; private set; }
/// <summary>
/// 获取初始化阶段创建的日志记录器，供测试断言使用。
/// </summary>
/// <returns>初始化后缓存的日志记录器；初始化前返回 <see langword="null" />。</returns>
public ILogger? GetLogger()
{
return Logger;
}
/// <summary>
/// 记录初始化已发生，并标记测试钩子调用状态。
/// </summary>
protected override void OnInit()
{
Initialized = true;
InitCalled = true;
}
/// <summary>
/// 记录销毁流程已运行，供生命周期测试断言使用。
/// </summary>
protected override void OnDestroy()
{
Destroyed = true;
}
}

41
GFramework.Core.Tests/Utility/TestContextUtilityV2.cs Normal file
View File

@ -0,0 +1,41 @@
using GFramework.Core.Utility;
namespace GFramework.Core.Tests.Utility;
/// <summary>
/// 为 <see cref="AbstractContextUtilityTests" /> 提供的自定义初始化上下文工具测试桩。
/// </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()
{
Initialized = true;
CustomInitializationDone = true;
}
/// <summary>
/// 记录销毁流程已运行，供生命周期测试断言使用。
/// </summary>
protected override void OnDestroy()
{
Destroyed = true;
}
}

37
ai-plan/public/analyzer-warning-reduction/todos/analyzer-warning-reduction-tracking.md
View File

@ -6,18 +6,24 @@
## 当前恢复点
- 恢复点编号：`ANALYZER-WARNING-REDUCTION-RP-084`
- 当前阶段：`Phase 84`
- 恢复点编号：`ANALYZER-WARNING-REDUCTION-RP-085`
- 当前阶段：`Phase 85`
- 当前焦点：
- `2026-04-27` 已完成 PR `#297` 的 CodeRabbit follow-up，修复 `YamlConfigLoader` 的取消语义与 `IntegerTryParseDelegate` 可空性问题
- 已补齐 `GFramework.Core.Tests/Ioc` 与 `GFramework.Core.Tests/Query` 中 review 指向的 XML 文档缺口，并让 `IPrioritizedService` 复用 `IMixedService.Name` 契约
- 已新增 `YamlConfigLoaderTests` 回归测试，锁定“取消时保留 `OperationCanceledException`”这一行为
- 当前分支的下一波 warning reduction 仍建议回到 `ArchitectureContextTests.cs`、`AsyncQueryExecutorTests.cs` 或 `YamlConfigSchemaValidator*` 的后续 slice
- `2026-04-27` 已按 `$gframework-batch-boot 100` 连续执行多波 `MA0048` 小切片，当前以 `GFramework.Core.Tests` 的测试辅助类型拆分为主
- 本轮已完成 `ArchitectureContextTests`、`AsyncQueryExecutorTests`、`CommandExecutorTests`、`StateTests`、`StateMachineTests`、`StateMachineSystemTests`、`ArchitectureModulesBehaviorTests`、`ArchitectureAdditionalCqrsHandlersTests`、`QueryCoroutineExtensionsTests`、`ObjectPoolTests`、`AbstractContextUtilityTests` 等低风险单文件切片
- 当前仓库根权威基线已从 `353 Warning(s)` / `279` 个唯一位点下降到 `288 Warning(s)` / `214` 个唯一位点
- 当前分支下一波更适合转向 `GameContextTests.cs`、`ArchitectureServicesTests.cs`、`RegistryInitializationHookBaseTests.cs` 这类仍在 `GFramework.Core.Tests` 内、但已混入 `CS8766` / `MA0016` 的小型混合切片
## 当前活跃事实
- 当前 `origin/main` 基线提交为 `b6a9fef`（`2026-04-27T10:53:34+08:00`）。
- 当前 `origin/main` 基线提交为 `7cfdd2c`（`2026-04-27T16:59:57+08:00`）。
- 当前直接验证结果：
- `dotnet build GFramework.Core.Tests/GFramework.Core.Tests.csproj -c Release`
- 最新结果：成功；`0 Warning(s)`、`0 Error(s)`
- `dotnet clean`
- 最新结果：成功；已刷新仓库根 non-incremental 基线
- `dotnet build`
- 最新结果：成功；`288 Warning(s)`、`0 Error(s)`，唯一位点 `214`
- `dotnet build GFramework.Game/GFramework.Game.csproj -c Release`
- 最新结果：成功；`0 Warning(s)`、`0 Error(s)`
- `dotnet build GFramework.Core.Tests/GFramework.Core.Tests.csproj -c Release`
@ -29,18 +35,21 @@
- `dotnet format GFramework.sln --verify-no-changes --include GFramework.Game/Config/YamlConfigLoader.cs GFramework.Game.Tests/Config/YamlConfigLoaderTests.cs GFramework.Core.Tests/Ioc/IMixedService.cs GFramework.Core.Tests/Ioc/IPrioritizedService.cs GFramework.Core.Tests/Ioc/PrioritizedService.cs GFramework.Core.Tests/Query/TestAsyncQueryWithExceptionV4.cs`
- 最新结果：成功；本次 PR follow-up 改动文件无需额外格式化
- 当前批次摘要：
- 本轮完成 PR `#297` 最新 head review 中仍然有效的 `3` 个 open threads 修复：`YamlConfigLoader` 取消语义、`IMixedService.Name` XML 文档、`IPrioritizedService` 相关契约整理
- 本轮同时吸收 CodeRabbit folded nitpick 中仍然成立的 `2` 个点：`IntegerTryParseDelegate` 可空性对齐、`TestAsyncQueryWithExceptionV4.OnDoAsync` 的 `<returns>` 文档
- 本轮新增一条精确回归测试，确保底层 YAML 文件读取在取消时继续抛出 `OperationCanceledException` 系列异常，而不是包装成 `ConfigLoadException`
- 本轮通过多批并行 worker 共完成 `20+` 个 `GFramework.Core.Tests` 文件的测试辅助类型拆分，集中消化纯 `MA0048` warning 热点
- 本轮停止时共享工作树共有 `61` 个变更条目，仍低于 `$gframework-batch-boot 100` 的文件停止线
- 本轮仓库根权威 warning 已从开始时的 `353` 下降到 `288`，且 `GFramework.Core.Tests` 受影响项目的 Release 构建已恢复到 `0 Warning(s)` / `0 Error(s)`
- 当前建议保留到下一波次的候选：
- `GFramework.Core.Tests/Architectures/ArchitectureContextTests.cs` 的 `7` 个 `MA0048`
- `GFramework.Core.Tests/Query/AsyncQueryExecutorTests.cs` 的 `7` 个 `MA0048`
- `GFramework.Core.Tests/Architectures/GameContextTests.cs` 的 `4` 个 `CS8766` 与 `2` 个 `MA0048`
- `GFramework.Core.Tests/Architectures/ArchitectureServicesTests.cs` 的 `4` 个 `CS8766` 与 `1` 个 `MA0048`
- `GFramework.Core.Tests/Architectures/RegistryInitializationHookBaseTests.cs` 的 `1` 个 `MA0016` 与 `5` 个 `MA0048`
- `GFramework.Game/Config/YamlConfigSchemaValidator.cs` 与 `YamlConfigSchemaValidator.ObjectKeywords.cs` 的高耦合 warning 热点
## 当前风险
- `GFramework.Cqrs.Tests/Mediator/*` 仍有 `47` / `44` / `34` 个唯一 warning 位点，属于高 changed-file 风险的 `MA0048` 大波次。
- 缓解措施：优先继续处理 `6-7` 个 warning 的小文件切片，避免一次性推高文件数。
- `GameContextTests.cs`、`ArchitectureServicesTests.cs` 这类混合 `CS8766` / `MA0048` 文件不再适合继续用“纯拆分”模式批量下发。
- 缓解措施：下一波由主线程先局部修正可空签名，再决定是否继续并行拆分。
- `YamlConfigSchemaValidator*` 仍然聚集多类高耦合 warning。
- 缓解措施：继续把它们留在独立波次，不与测试项目的低风险拆分混提。
@ -67,6 +76,6 @@
## 下一步建议
1. 提交本轮 PR `#297` review follow-up 与 `ai-plan` 同步。
2. 下一波优先挑选 `ArchitectureContextTests.cs` 或 `AsyncQueryExecutorTests.cs` 这类 `7`-warning 的纯 `MA0048` 单文件切片。
1. 提交本轮多批 `MA0048` warning reduction 与 `ai-plan` 同步。
2. 下一波由主线程先处理 `GameContextTests.cs` / `ArchitectureServicesTests.cs` 的 `CS8766`，再决定是否继续拆分剩余 `MA0048`。
3. 继续将 `YamlConfigSchemaValidator*` 与 `GFramework.Cqrs.Tests/Mediator/*` 作为独立高风险波次处理。

44
ai-plan/public/analyzer-warning-reduction/traces/analyzer-warning-reduction-trace.md
View File

@ -1,5 +1,49 @@
# Analyzer Warning Reduction 追踪
## 2026-04-27 — RP-085
### 阶段：按 `$gframework-batch-boot 100` 并行消化 `GFramework.Core.Tests` 低风险 `MA0048`
- 触发背景：
- 用户要求以仓库根 non-incremental 构建 warning 为准，并在上下文可控前提下把小切片分派给多个 subagent 并行处理
- 本轮开始时，当前分支与 `origin/main@7cfdd2c` 无提交差异，适合从纯 `MA0048` 单文件切片起步
- 主线程实施：
- 执行权威基线：`dotnet clean` + 仓库根 `dotnet build`
- 初始结果：`353 Warning(s)`、唯一位点 `279`
- 分四波次并行下发 `GFramework.Core.Tests` 小切片，累计完成 `20+` 个文件的测试辅助类型拆分
- 主线程持续复核共享工作树、处理并发编译阻断，并在每一轮后复跑 `GFramework.Core.Tests` Release 构建
- 在工作树达到 `61` 个变更条目时主动停止扩批，保留对 `100` 文件停止线的充分余量
- 代表性已落地切片：
- `ArchitectureContextTests.cs`
- `AsyncQueryExecutorTests.cs`
- `CommandExecutorTests.cs`
- `StateTests.cs`
- `StateMachineTests.cs`
- `StateMachineSystemTests.cs`
- `ArchitectureModulesBehaviorTests.cs`
- `ArchitectureAdditionalCqrsHandlersTests.cs`
- `QueryCoroutineExtensionsTests.cs`
- `ObjectPoolTests.cs`
- `AbstractContextUtilityTests.cs`
- `EnvironmentTests.cs`
- `EventBusTests.cs`
- `ContextAwareTests.cs`
- 验证里程碑：
- `dotnet build GFramework.Core.Tests/GFramework.Core.Tests.csproj -c Release`
- 结果：成功；`0 Warning(s)`、`0 Error(s)`
- `dotnet clean`
- 结果：成功
- `dotnet build`
- 结果：成功；`288 Warning(s)`、`0 Error(s)`，唯一位点 `214`
- 当前结论：
- 本轮主要收益来自 `GFramework.Core.Tests` 内的纯 `MA0048` 大范围收敛
- 仓库根权威 warning 已从 `353` 降到 `288`，唯一位点从 `279` 降到 `214`
- 下一波不再适合继续盲目平铺纯拆分，因为剩余 `GFramework.Core.Tests` 热点已开始混入 `CS8766` / `MA0016`
- 下一步：
1. 提交本轮 warning reduction 与 `ai-plan` 同步。
2. 下一波优先由主线程处理 `GameContextTests.cs` / `ArchitectureServicesTests.cs` 的混合 warning。
3. 保持 `YamlConfigSchemaValidator*` 与 `GFramework.Cqrs.Tests/Mediator/*` 为独立高风险波次。
## 2026-04-27 — RP-084
### 阶段：收敛 PR #297 的 CodeRabbit follow-up