From 7b8f1b0fcd94f6dcafa0cb1a8b8051adb3523fea Mon Sep 17 00:00:00 2001
From: tk <fiyne1a@dingtalk.com>
Date: Tue, 24 Dec 2024 18:12:06 +0800
Subject: [PATCH] =?UTF-8?q?perf:=20=E2=9A=A1=20nuget=20update?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 refs/Gurion                                   |  2 +-
 refs/NetAdmin.FreeSql                         |  2 +-
 .../Events/Sys/RequestLogEvent.cs             |  2 +-
 .../Events/Sys/UserCreatedEvent.cs            |  2 +-
 .../Events/Sys/UserUpdatedEvent.cs            |  2 +-
 .../Events/Sys/VerifyCodeCreatedEvent.cs      |  2 +-
 .../NetAdmin.Infrastructure.csproj            |  8 +-
 src/backend/UnitTests/Sys/ApiTests.cs         | 44 ++++-----
 src/backend/UnitTests/Sys/CacheTests.cs       | 18 ++--
 src/backend/UnitTests/Sys/CaptchaTests.cs     |  6 +-
 src/backend/UnitTests/Sys/ConfigTests.cs      | 46 ++++-----
 src/backend/UnitTests/Sys/ConstantTests.cs    |  8 +-
 src/backend/UnitTests/Sys/DeptTests.cs        | 44 ++++-----
 src/backend/UnitTests/Sys/DevTests.cs         |  4 +-
 src/backend/UnitTests/Sys/DicTests.cs         | 72 +++++++-------
 src/backend/UnitTests/Sys/DocTests.cs         | 72 +++++++-------
 src/backend/UnitTests/Sys/FileTests.cs        |  4 +-
 src/backend/UnitTests/Sys/JobTests.cs         | 78 +++++++--------
 src/backend/UnitTests/Sys/LoginLogTests.cs    | 40 ++++----
 src/backend/UnitTests/Sys/MenuTests.cs        | 42 ++++----
 src/backend/UnitTests/Sys/RequestLogTests.cs  | 52 +++++-----
 src/backend/UnitTests/Sys/RoleTests.cs        | 56 +++++------
 src/backend/UnitTests/Sys/SiteMsgTests.cs     | 52 +++++-----
 src/backend/UnitTests/Sys/ToolsTests.cs       | 14 +--
 src/backend/UnitTests/Sys/UserTests.cs        | 96 +++++++++----------
 src/backend/UnitTests/Sys/VerifyCodeTests.cs  | 48 +++++-----
 26 files changed, 408 insertions(+), 408 deletions(-)

diff --git a/refs/Gurion b/refs/Gurion
index b7b73bbd..bbaea747 160000
--- a/refs/Gurion
+++ b/refs/Gurion
@@ -1 +1 @@
-Subproject commit b7b73bbd298a5376eef8e250761760e9b4441eb0
+Subproject commit bbaea747eb04dfeaeafe29cf0927664be6293b81
diff --git a/refs/NetAdmin.FreeSql b/refs/NetAdmin.FreeSql
index 433c4ee9..81b91335 160000
--- a/refs/NetAdmin.FreeSql
+++ b/refs/NetAdmin.FreeSql
@@ -1 +1 @@
-Subproject commit 433c4ee94c0d19ed98d1713885cd60bad3424c5f
+Subproject commit 81b9133557cb2bbde7c19bdced930c459f31ae4d
diff --git a/src/backend/NetAdmin/NetAdmin.Domain/Events/Sys/RequestLogEvent.cs b/src/backend/NetAdmin/NetAdmin.Domain/Events/Sys/RequestLogEvent.cs
index 18a4d529..37dff4bf 100644
--- a/src/backend/NetAdmin/NetAdmin.Domain/Events/Sys/RequestLogEvent.cs
+++ b/src/backend/NetAdmin/NetAdmin.Domain/Events/Sys/RequestLogEvent.cs
@@ -10,7 +10,7 @@ public sealed record RequestLogEvent : DataAbstraction, IEventSourceGeneric<Crea
     /// <summary>
     ///     Initializes a new instance of the <see cref="RequestLogEvent" /> class.
     /// </summary>
-    public RequestLogEvent(CreateRequestLogReq data, bool isConsumeOnce = false, object payload = default, DateTime createdTime = default
+    public RequestLogEvent(CreateRequestLogReq data, bool isConsumeOnce = false, object payload = null, DateTime createdTime = default
                          , CancellationToken   cancellationToken = default)
     {
         Data              = data;
diff --git a/src/backend/NetAdmin/NetAdmin.Domain/Events/Sys/UserCreatedEvent.cs b/src/backend/NetAdmin/NetAdmin.Domain/Events/Sys/UserCreatedEvent.cs
index 66804576..6ad04a5d 100644
--- a/src/backend/NetAdmin/NetAdmin.Domain/Events/Sys/UserCreatedEvent.cs
+++ b/src/backend/NetAdmin/NetAdmin.Domain/Events/Sys/UserCreatedEvent.cs
@@ -10,7 +10,7 @@ public sealed record UserCreatedEvent : DataAbstraction, IEventSourceGeneric<Use
     /// <summary>
     ///     Initializes a new instance of the <see cref="UserCreatedEvent" /> class.
     /// </summary>
-    public UserCreatedEvent(UserInfoRsp       data, DateTime createdTime = default, bool isConsumeOnce = false, object payload = default
+    public UserCreatedEvent(UserInfoRsp       data, DateTime createdTime = default, bool isConsumeOnce = false, object payload = null
                           , CancellationToken cancellationToken = default)
     {
         Data              = data;
diff --git a/src/backend/NetAdmin/NetAdmin.Domain/Events/Sys/UserUpdatedEvent.cs b/src/backend/NetAdmin/NetAdmin.Domain/Events/Sys/UserUpdatedEvent.cs
index 6294cd2a..2eefb749 100644
--- a/src/backend/NetAdmin/NetAdmin.Domain/Events/Sys/UserUpdatedEvent.cs
+++ b/src/backend/NetAdmin/NetAdmin.Domain/Events/Sys/UserUpdatedEvent.cs
@@ -10,7 +10,7 @@ public sealed record UserUpdatedEvent : DataAbstraction, IEventSourceGeneric<Use
     /// <summary>
     ///     Initializes a new instance of the <see cref="UserUpdatedEvent" /> class.
     /// </summary>
-    public UserUpdatedEvent(UserInfoRsp       data, DateTime createdTime = default, bool isConsumeOnce = false, object payload = default
+    public UserUpdatedEvent(UserInfoRsp       data, DateTime createdTime = default, bool isConsumeOnce = false, object payload = null
                           , CancellationToken cancellationToken = default)
     {
         Data              = data;
diff --git a/src/backend/NetAdmin/NetAdmin.Domain/Events/Sys/VerifyCodeCreatedEvent.cs b/src/backend/NetAdmin/NetAdmin.Domain/Events/Sys/VerifyCodeCreatedEvent.cs
index 566ee99d..f6f20c2b 100644
--- a/src/backend/NetAdmin/NetAdmin.Domain/Events/Sys/VerifyCodeCreatedEvent.cs
+++ b/src/backend/NetAdmin/NetAdmin.Domain/Events/Sys/VerifyCodeCreatedEvent.cs
@@ -10,7 +10,7 @@ public sealed record VerifyCodeCreatedEvent : DataAbstraction, IEventSourceGener
     /// <summary>
     ///     Initializes a new instance of the <see cref="VerifyCodeCreatedEvent" /> class.
     /// </summary>
-    public VerifyCodeCreatedEvent(QueryVerifyCodeRsp data, DateTime createdTime = default, bool isConsumeOnce = false, object payload = default
+    public VerifyCodeCreatedEvent(QueryVerifyCodeRsp data, DateTime createdTime = default, bool isConsumeOnce = false, object payload = null
                                 , CancellationToken  cancellationToken = default)
     {
         Data              = data;
diff --git a/src/backend/NetAdmin/NetAdmin.Infrastructure/NetAdmin.Infrastructure.csproj b/src/backend/NetAdmin/NetAdmin.Infrastructure/NetAdmin.Infrastructure.csproj
index 0dc79045..b935e537 100644
--- a/src/backend/NetAdmin/NetAdmin.Infrastructure/NetAdmin.Infrastructure.csproj
+++ b/src/backend/NetAdmin/NetAdmin.Infrastructure/NetAdmin.Infrastructure.csproj
@@ -3,11 +3,11 @@
     <Import Project="$(SolutionDir)/build/copy.pkg.xml.comment.files.targets"/>
     <Import Project="$(SolutionDir)/build/prebuild.targets"/>
     <ItemGroup>
-        <PackageReference Include="NetAdmin.FreeSql.DbContext" Version="1.0.6" Label="refs"/>
-        <PackageReference Include="NetAdmin.FreeSql.Provider.Sqlite" Version="1.0.6" Label="refs"/>
-        <PackageReference Include="Gurion" Version="1.2.5" Label="refs"/>
+        <PackageReference Include="NetAdmin.FreeSql.DbContext" Version="1.0.7" Label="refs"/>
+        <PackageReference Include="NetAdmin.FreeSql.Provider.Sqlite" Version="1.0.7" Label="refs"/>
+        <PackageReference Include="Gurion" Version="1.2.6" Label="refs"/>
         <PackageReference Include="Microsoft.Extensions.Caching.StackExchangeRedis" Version="9.0.0"/>
-        <PackageReference Include="Minio" Version="6.0.3"/>
+        <PackageReference Include="Minio" Version="6.0.4"/>
         <PackageReference Include="NSExt" Version="2.3.2"/>
         <PackageReference Include="SixLabors.ImageSharp.Drawing" Version="2.1.4"/>
     </ItemGroup>
diff --git a/src/backend/UnitTests/Sys/ApiTests.cs b/src/backend/UnitTests/Sys/ApiTests.cs
index a3d48879..45aad3a7 100644
--- a/src/backend/UnitTests/Sys/ApiTests.cs
+++ b/src/backend/UnitTests/Sys/ApiTests.cs
@@ -11,113 +11,113 @@ public class ApiTests(WebTestApplicationFactory<Startup> factory, ITestOutputHel
     : WebApiTestBase<Startup>(factory, testOutputHelper), IApiModule
 {
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> BulkDeleteAsync(BulkReq<DelReq> req)
     {
         var rsp = await PostJsonAsync(typeof(ApiController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<long> CountAsync(QueryReq<QueryApiReq> req)
     {
         var rsp = await PostJsonAsync(typeof(ApiController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IOrderedEnumerable<KeyValuePair<IImmutableDictionary<string, string>, int>>> CountByAsync(QueryReq<QueryApiReq> req)
     {
         var rsp = await PostJsonAsync(typeof(ApiController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryApiRsp> CreateAsync(CreateApiReq req)
     {
         var rsp = await PostJsonAsync(typeof(ApiController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> DeleteAsync(DelReq req)
     {
         var rsp = await PostJsonAsync(typeof(ApiController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryApiRsp> EditAsync(EditApiReq req)
     {
         var rsp = await PostJsonAsync(typeof(ApiController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IActionResult> ExportAsync(QueryReq<QueryApiReq> req)
     {
         var rsp = await PostJsonAsync(typeof(ApiController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryApiRsp> GetAsync(QueryApiReq req)
     {
         var rsp = await PostJsonAsync(typeof(ApiController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<PagedQueryRsp<QueryApiRsp>> PagedQueryAsync(PagedQueryReq<QueryApiReq> req)
     {
         var rsp = await PostJsonAsync(typeof(ApiController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IEnumerable<QueryApiRsp>> PlainQueryAsync(QueryReq<QueryApiReq> req)
     {
         var rsp = await PostJsonAsync(typeof(ApiController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IEnumerable<QueryApiRsp>> QueryAsync(QueryReq<QueryApiReq> req)
     {
         var rsp = await PostJsonAsync(typeof(ApiController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
diff --git a/src/backend/UnitTests/Sys/CacheTests.cs b/src/backend/UnitTests/Sys/CacheTests.cs
index 0cfb7716..43ee3e08 100644
--- a/src/backend/UnitTests/Sys/CacheTests.cs
+++ b/src/backend/UnitTests/Sys/CacheTests.cs
@@ -11,13 +11,13 @@ public class CacheTests(WebTestApplicationFactory<Startup> factory, ITestOutputH
     : WebApiTestBase<Startup>(factory, testOutputHelper), ICacheModule
 {
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> BulkDeleteEntryAsync(BulkReq<DelEntryReq> req)
     {
         var rsp = await PostJsonAsync(typeof(CacheController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
@@ -26,36 +26,36 @@ public class CacheTests(WebTestApplicationFactory<Startup> factory, ITestOutputH
     {
         var rsp = await PostJsonAsync(typeof(CacheController));
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> DeleteEntryAsync(DelEntryReq req)
     {
         var rsp = await PostJsonAsync(typeof(CacheController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IEnumerable<GetEntryRsp>> GetAllEntriesAsync(GetAllEntriesReq req)
     {
         var rsp = await PostJsonAsync(typeof(CacheController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<GetEntryRsp> GetEntryAsync(GetEntriesReq req)
     {
         var rsp = await PostJsonAsync(typeof(CacheController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 }
\ No newline at end of file
diff --git a/src/backend/UnitTests/Sys/CaptchaTests.cs b/src/backend/UnitTests/Sys/CaptchaTests.cs
index 160fe465..611dc056 100644
--- a/src/backend/UnitTests/Sys/CaptchaTests.cs
+++ b/src/backend/UnitTests/Sys/CaptchaTests.cs
@@ -16,16 +16,16 @@ public class CaptchaTests(WebTestApplicationFactory<Startup> factory, ITestOutpu
     {
         var rsp = await PostJsonAsync(typeof(CaptchaController));
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<bool> VerifyCaptchaAsync(VerifyCaptchaReq req)
     {
         var rsp = await PostJsonAsync(typeof(CaptchaController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return false;
     }
 }
\ No newline at end of file
diff --git a/src/backend/UnitTests/Sys/ConfigTests.cs b/src/backend/UnitTests/Sys/ConfigTests.cs
index ffdae0b4..b836c8be 100644
--- a/src/backend/UnitTests/Sys/ConfigTests.cs
+++ b/src/backend/UnitTests/Sys/ConfigTests.cs
@@ -11,83 +11,83 @@ public class ConfigTests(WebTestApplicationFactory<Startup> factory, ITestOutput
     : WebApiTestBase<Startup>(factory, testOutputHelper), IConfigModule
 {
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> BulkDeleteAsync(BulkReq<DelReq> req)
     {
         var rsp = await PostJsonAsync(typeof(ConfigController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<long> CountAsync(QueryReq<QueryConfigReq> req)
     {
         var rsp = await PostJsonAsync(typeof(ConfigController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IOrderedEnumerable<KeyValuePair<IImmutableDictionary<string, string>, int>>> CountByAsync(QueryReq<QueryConfigReq> req)
     {
         var rsp = await PostJsonAsync(typeof(ConfigController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryConfigRsp> CreateAsync(CreateConfigReq req)
     {
         var rsp = await PostJsonAsync(typeof(ConfigController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> DeleteAsync(DelReq req)
     {
         var rsp = await PostJsonAsync(typeof(ConfigController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryConfigRsp> EditAsync(EditConfigReq req)
     {
         var rsp = await PostJsonAsync(typeof(ConfigController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IActionResult> ExportAsync(QueryReq<QueryConfigReq> req)
     {
         var rsp = await PostJsonAsync(typeof(ConfigController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryConfigRsp> GetAsync(QueryConfigReq req)
     {
         var rsp = await PostJsonAsync(typeof(ConfigController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
@@ -96,36 +96,36 @@ public class ConfigTests(WebTestApplicationFactory<Startup> factory, ITestOutput
     {
         var rsp = await PostJsonAsync(typeof(ConfigController));
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<PagedQueryRsp<QueryConfigRsp>> PagedQueryAsync(PagedQueryReq<QueryConfigReq> req)
     {
         var rsp = await PostJsonAsync(typeof(ConfigController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IEnumerable<QueryConfigRsp>> QueryAsync(QueryReq<QueryConfigReq> req)
     {
         var rsp = await PostJsonAsync(typeof(ConfigController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> SetEnabledAsync(SetConfigEnabledReq req)
     {
         var rsp = await PostJsonAsync(typeof(ConfigController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 }
\ No newline at end of file
diff --git a/src/backend/UnitTests/Sys/ConstantTests.cs b/src/backend/UnitTests/Sys/ConstantTests.cs
index f2239aa3..cdfefb03 100644
--- a/src/backend/UnitTests/Sys/ConstantTests.cs
+++ b/src/backend/UnitTests/Sys/ConstantTests.cs
@@ -15,7 +15,7 @@ public class ConstantTests(WebTestApplicationFactory<Startup> factory, ITestOutp
     {
         var rsp = PostJsonAsync(typeof(ConstantController)).GetAwaiter().GetResult();
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
@@ -24,7 +24,7 @@ public class ConstantTests(WebTestApplicationFactory<Startup> factory, ITestOutp
     {
         var rsp = PostJsonAsync(typeof(ConstantController)).GetAwaiter().GetResult();
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
@@ -33,7 +33,7 @@ public class ConstantTests(WebTestApplicationFactory<Startup> factory, ITestOutp
     {
         var rsp = PostJsonAsync(typeof(ConstantController)).GetAwaiter().GetResult();
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
@@ -42,6 +42,6 @@ public class ConstantTests(WebTestApplicationFactory<Startup> factory, ITestOutp
     {
         var rsp = PostJsonAsync(typeof(ConstantController)).GetAwaiter().GetResult();
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 }
\ No newline at end of file
diff --git a/src/backend/UnitTests/Sys/DeptTests.cs b/src/backend/UnitTests/Sys/DeptTests.cs
index 0eca9c68..7a9cbb7b 100644
--- a/src/backend/UnitTests/Sys/DeptTests.cs
+++ b/src/backend/UnitTests/Sys/DeptTests.cs
@@ -11,112 +11,112 @@ public class DeptTests(WebTestApplicationFactory<Startup> factory, ITestOutputHe
     : WebApiTestBase<Startup>(factory, testOutputHelper), IDeptModule
 {
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> BulkDeleteAsync(BulkReq<DelReq> req)
     {
         var rsp = await PostJsonAsync(typeof(DeptController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<long> CountAsync(QueryReq<QueryDeptReq> req)
     {
         var rsp = await PostJsonAsync(typeof(DeptController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IOrderedEnumerable<KeyValuePair<IImmutableDictionary<string, string>, int>>> CountByAsync(QueryReq<QueryDeptReq> req)
     {
         var rsp = await PostJsonAsync(typeof(DeptController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryDeptRsp> CreateAsync(CreateDeptReq req)
     {
         var rsp = await PostJsonAsync(typeof(DeptController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> DeleteAsync(DelReq req)
     {
         var rsp = await PostJsonAsync(typeof(DeptController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryDeptRsp> EditAsync(EditDeptReq req)
     {
         var rsp = await PostJsonAsync(typeof(DeptController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IActionResult> ExportAsync(QueryReq<QueryDeptReq> req)
     {
         var rsp = await PostJsonAsync(typeof(DeptController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryDeptRsp> GetAsync(QueryDeptReq req)
     {
         var rsp = await PostJsonAsync(typeof(DeptController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<PagedQueryRsp<QueryDeptRsp>> PagedQueryAsync(PagedQueryReq<QueryDeptReq> req)
     {
         var rsp = await PostJsonAsync(typeof(DeptController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IEnumerable<QueryDeptRsp>> QueryAsync(QueryReq<QueryDeptReq> req)
     {
         var rsp = await PostJsonAsync(typeof(DeptController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> SetEnabledAsync(SetDeptEnabledReq req)
     {
         var rsp = await PostJsonAsync(typeof(DeptController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 }
\ No newline at end of file
diff --git a/src/backend/UnitTests/Sys/DevTests.cs b/src/backend/UnitTests/Sys/DevTests.cs
index 45a0f58b..718184fd 100644
--- a/src/backend/UnitTests/Sys/DevTests.cs
+++ b/src/backend/UnitTests/Sys/DevTests.cs
@@ -11,7 +11,7 @@ public class DevTests(WebTestApplicationFactory<Startup> factory, ITestOutputHel
     : WebApiTestBase<Startup>(factory, testOutputHelper), IDevModule
 {
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task GenerateCsCodeAsync(GenerateCsCodeReq req)
     {
@@ -20,7 +20,7 @@ public class DevTests(WebTestApplicationFactory<Startup> factory, ITestOutputHel
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task GenerateIconCodeAsync(GenerateIconCodeReq req)
     {
diff --git a/src/backend/UnitTests/Sys/DicTests.cs b/src/backend/UnitTests/Sys/DicTests.cs
index 2cb2ed95..b3c48f12 100644
--- a/src/backend/UnitTests/Sys/DicTests.cs
+++ b/src/backend/UnitTests/Sys/DicTests.cs
@@ -12,183 +12,183 @@ public class DicTests(WebTestApplicationFactory<Startup> factory, ITestOutputHel
     : WebApiTestBase<Startup>(factory, testOutputHelper), IDicModule
 {
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> BulkDeleteCatalogAsync(BulkReq<DelReq> req)
     {
         var rsp = await PostJsonAsync(typeof(DicController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> BulkDeleteContentAsync(BulkReq<DelReq> req)
     {
         var rsp = await PostJsonAsync(typeof(DicController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IOrderedEnumerable<KeyValuePair<IImmutableDictionary<string, string>, int>>> ContentCountByAsync(
         QueryReq<QueryDicContentReq> req)
     {
         var rsp = await PostJsonAsync(typeof(DicController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryDicCatalogRsp> CreateCatalogAsync(CreateDicCatalogReq req)
     {
         var rsp = await PostJsonAsync(typeof(DicController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryDicContentRsp> CreateContentAsync(CreateDicContentReq req)
     {
         var rsp = await PostJsonAsync(typeof(DicController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> DeleteCatalogAsync(DelReq req)
     {
         var rsp = await PostJsonAsync(typeof(DicController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> DeleteContentAsync(DelReq req)
     {
         var rsp = await PostJsonAsync(typeof(DicController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryDicCatalogRsp> EditCatalogAsync(EditDicCatalogReq req)
     {
         var rsp = await PostJsonAsync(typeof(DicController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryDicContentRsp> EditContentAsync(EditDicContentReq req)
     {
         var rsp = await PostJsonAsync(typeof(DicController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IActionResult> ExportContentAsync(QueryReq<QueryDicContentReq> req)
     {
         var rsp = await PostJsonAsync(typeof(DicController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryDicCatalogRsp> GetCatalogAsync(QueryDicCatalogReq req)
     {
         var rsp = await PostJsonAsync(typeof(DicController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryDicContentRsp> GetContentAsync(QueryDicContentReq req)
     {
         var rsp = await PostJsonAsync(typeof(DicController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<string> GetDicValueAsync(GetDicValueReq req)
     {
         var rsp = await PostJsonAsync(typeof(DicController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<PagedQueryRsp<QueryDicCatalogRsp>> PagedQueryCatalogAsync(PagedQueryReq<QueryDicCatalogReq> req)
     {
         var rsp = await PostJsonAsync(typeof(DicController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<PagedQueryRsp<QueryDicContentRsp>> PagedQueryContentAsync(PagedQueryReq<QueryDicContentReq> req)
     {
         var rsp = await PostJsonAsync(typeof(DicController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IEnumerable<QueryDicCatalogRsp>> QueryCatalogAsync(QueryReq<QueryDicCatalogReq> req)
     {
         var rsp = await PostJsonAsync(typeof(DicController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IEnumerable<QueryDicContentRsp>> QueryContentAsync(QueryReq<QueryDicContentReq> req)
     {
         var rsp = await PostJsonAsync(typeof(DicController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> SetEnabledAsync(SetDicContentEnabledReq req)
     {
         var rsp = await PostJsonAsync(typeof(DicController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 }
\ No newline at end of file
diff --git a/src/backend/UnitTests/Sys/DocTests.cs b/src/backend/UnitTests/Sys/DocTests.cs
index f11b4f28..fe7e88d4 100644
--- a/src/backend/UnitTests/Sys/DocTests.cs
+++ b/src/backend/UnitTests/Sys/DocTests.cs
@@ -12,183 +12,183 @@ public class DocTests(WebTestApplicationFactory<Startup> factory, ITestOutputHel
     : WebApiTestBase<Startup>(factory, testOutputHelper), IDocModule
 {
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> BulkDeleteCatalogAsync(BulkReq<DelReq> req)
     {
         var rsp = await PostJsonAsync(typeof(DocController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> BulkDeleteContentAsync(BulkReq<DelReq> req)
     {
         var rsp = await PostJsonAsync(typeof(DocController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IOrderedEnumerable<KeyValuePair<IImmutableDictionary<string, string>, int>>> ContentCountByAsync(
         QueryReq<QueryDocContentReq> req)
     {
         var rsp = await PostJsonAsync(typeof(DocController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryDocCatalogRsp> CreateCatalogAsync(CreateDocCatalogReq req)
     {
         var rsp = await PostJsonAsync(typeof(DocController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryDocContentRsp> CreateContentAsync(CreateDocContentReq req)
     {
         var rsp = await PostJsonAsync(typeof(DocController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> DeleteCatalogAsync(DelReq req)
     {
         var rsp = await PostJsonAsync(typeof(DocController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> DeleteContentAsync(DelReq req)
     {
         var rsp = await PostJsonAsync(typeof(DocController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryDocCatalogRsp> EditCatalogAsync(EditDocCatalogReq req)
     {
         var rsp = await PostJsonAsync(typeof(DocController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryDocContentRsp> EditContentAsync(EditDocContentReq req)
     {
         var rsp = await PostJsonAsync(typeof(DocController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IActionResult> ExportContentAsync(QueryReq<QueryDocContentReq> req)
     {
         var rsp = await PostJsonAsync(typeof(DocController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryDocCatalogRsp> GetCatalogAsync(QueryDocCatalogReq req)
     {
         var rsp = await PostJsonAsync(typeof(DocController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryDocContentRsp> GetContentAsync(QueryDocContentReq req)
     {
         var rsp = await PostJsonAsync(typeof(DocController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<PagedQueryRsp<QueryDocCatalogRsp>> PagedQueryCatalogAsync(PagedQueryReq<QueryDocCatalogReq> req)
     {
         var rsp = await PostJsonAsync(typeof(DocController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<PagedQueryRsp<QueryDocContentRsp>> PagedQueryContentAsync(PagedQueryReq<QueryDocContentReq> req)
     {
         var rsp = await PostJsonAsync(typeof(DocController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IEnumerable<QueryDocCatalogRsp>> QueryCatalogAsync(QueryReq<QueryDocCatalogReq> req)
     {
         var rsp = await PostJsonAsync(typeof(DocController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IEnumerable<QueryDocContentRsp>> QueryContentAsync(QueryReq<QueryDocContentReq> req)
     {
         var rsp = await PostJsonAsync(typeof(DocController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> SetEnabledAsync(SetDocContentEnabledReq req)
     {
         var rsp = await PostJsonAsync(typeof(DocController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryDocContentRsp> ViewContentAsync(QueryDocContentReq req)
     {
         var rsp = await PostJsonAsync(typeof(DocController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 }
\ No newline at end of file
diff --git a/src/backend/UnitTests/Sys/FileTests.cs b/src/backend/UnitTests/Sys/FileTests.cs
index 78c7e200..4b7940d7 100644
--- a/src/backend/UnitTests/Sys/FileTests.cs
+++ b/src/backend/UnitTests/Sys/FileTests.cs
@@ -9,12 +9,12 @@ public class FileTests(WebTestApplicationFactory<Startup> factory, ITestOutputHe
     : WebApiTestBase<Startup>(factory, testOutputHelper), IFileModule
 {
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<string> UploadAsync(IFormFile file)
     {
         var rsp = await PostJsonAsync(typeof(FileController), file);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 }
\ No newline at end of file
diff --git a/src/backend/UnitTests/Sys/JobTests.cs b/src/backend/UnitTests/Sys/JobTests.cs
index 437ae88b..6b2b1f73 100644
--- a/src/backend/UnitTests/Sys/JobTests.cs
+++ b/src/backend/UnitTests/Sys/JobTests.cs
@@ -13,77 +13,77 @@ public class JobTests(WebTestApplicationFactory<Startup> factory, ITestOutputHel
     : WebApiTestBase<Startup>(factory, testOutputHelper), IJobModule
 {
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> BulkDeleteAsync(BulkReq<DelReq> req)
     {
         var rsp = await PostJsonAsync(typeof(JobController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<long> CountAsync(QueryReq<QueryJobReq> req)
     {
         var rsp = await PostJsonAsync(typeof(JobController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IOrderedEnumerable<KeyValuePair<IImmutableDictionary<string, string>, int>>> CountByAsync(QueryReq<QueryJobReq> req)
     {
         var rsp = await PostJsonAsync(typeof(JobController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<long> CountRecordAsync(QueryReq<QueryJobRecordReq> req)
     {
         var rsp = await PostJsonAsync(typeof(JobController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryJobRsp> CreateAsync(CreateJobReq req)
     {
         var rsp = await PostJsonAsync(typeof(JobController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> DeleteAsync(DelReq req)
     {
         var rsp = await PostJsonAsync(typeof(JobController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryJobRsp> EditAsync(EditJobReq req)
     {
         var rsp = await PostJsonAsync(typeof(JobController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task ExecuteAsync(QueryJobReq req)
     {
@@ -92,122 +92,122 @@ public class JobTests(WebTestApplicationFactory<Startup> factory, ITestOutputHel
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IActionResult> ExportAsync(QueryReq<QueryJobReq> req)
     {
         var rsp = await PostJsonAsync(typeof(JobController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IActionResult> ExportRecordAsync(QueryReq<QueryJobRecordReq> req)
     {
         var rsp = await PostJsonAsync(typeof(JobController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryJobRsp> GetAsync(QueryJobReq req)
     {
         var rsp = await PostJsonAsync(typeof(JobController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryJobRecordRsp> GetRecordAsync(QueryJobRecordReq req)
     {
         var rsp = await PostJsonAsync(typeof(JobController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IEnumerable<GetBarChartRsp>> GetRecordBarChartAsync(QueryReq<QueryJobRecordReq> req)
     {
         var rsp = await PostJsonAsync(typeof(JobController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IEnumerable<GetPieChartRsp>> GetRecordPieChartByHttpStatusCodeAsync(QueryReq<QueryJobRecordReq> req)
     {
         var rsp = await PostJsonAsync(typeof(JobController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IEnumerable<GetPieChartRsp>> GetRecordPieChartByNameAsync(QueryReq<QueryJobRecordReq> req)
     {
         var rsp = await PostJsonAsync(typeof(JobController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<PagedQueryRsp<QueryJobRsp>> PagedQueryAsync(PagedQueryReq<QueryJobReq> req)
     {
         var rsp = await PostJsonAsync(typeof(JobController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<PagedQueryRsp<QueryJobRecordRsp>> PagedQueryRecordAsync(PagedQueryReq<QueryJobRecordReq> req)
     {
         var rsp = await PostJsonAsync(typeof(JobController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IEnumerable<QueryJobRsp>> QueryAsync(QueryReq<QueryJobReq> req)
     {
         var rsp = await PostJsonAsync(typeof(JobController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IOrderedEnumerable<KeyValuePair<IImmutableDictionary<string, string>, int>>> RecordCountByAsync(QueryReq<QueryJobRecordReq> req)
     {
         var rsp = await PostJsonAsync(typeof(JobController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> SetEnabledAsync(SetJobEnabledReq req)
     {
         var rsp = await PostJsonAsync(typeof(JobController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 }
\ No newline at end of file
diff --git a/src/backend/UnitTests/Sys/LoginLogTests.cs b/src/backend/UnitTests/Sys/LoginLogTests.cs
index c58fba98..aff1253b 100644
--- a/src/backend/UnitTests/Sys/LoginLogTests.cs
+++ b/src/backend/UnitTests/Sys/LoginLogTests.cs
@@ -11,102 +11,102 @@ public class LoginLogTests(WebTestApplicationFactory<Startup> factory, ITestOutp
     : WebApiTestBase<Startup>(factory, testOutputHelper), ILoginLogModule
 {
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> BulkDeleteAsync(BulkReq<DelReq> req)
     {
         var rsp = await PostJsonAsync(typeof(LoginLogController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<long> CountAsync(QueryReq<QueryLoginLogReq> req)
     {
         var rsp = await PostJsonAsync(typeof(LoginLogController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IOrderedEnumerable<KeyValuePair<IImmutableDictionary<string, string>, int>>> CountByAsync(QueryReq<QueryLoginLogReq> req)
     {
         var rsp = await PostJsonAsync(typeof(LoginLogController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryLoginLogRsp> CreateAsync(CreateLoginLogReq req)
     {
         var rsp = await PostJsonAsync(typeof(LoginLogController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> DeleteAsync(DelReq req)
     {
         var rsp = await PostJsonAsync(typeof(LoginLogController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryLoginLogRsp> EditAsync(EditLoginLogReq req)
     {
         var rsp = await PostJsonAsync(typeof(LoginLogController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IActionResult> ExportAsync(QueryReq<QueryLoginLogReq> req)
     {
         var rsp = await PostJsonAsync(typeof(LoginLogController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryLoginLogRsp> GetAsync(QueryLoginLogReq req)
     {
         var rsp = await PostJsonAsync(typeof(LoginLogController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<PagedQueryRsp<QueryLoginLogRsp>> PagedQueryAsync(PagedQueryReq<QueryLoginLogReq> req)
     {
         var rsp = await PostJsonAsync(typeof(LoginLogController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IEnumerable<QueryLoginLogRsp>> QueryAsync(QueryReq<QueryLoginLogReq> req)
     {
         var rsp = await PostJsonAsync(typeof(LoginLogController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 }
\ No newline at end of file
diff --git a/src/backend/UnitTests/Sys/MenuTests.cs b/src/backend/UnitTests/Sys/MenuTests.cs
index 3953c873..6ea0ce85 100644
--- a/src/backend/UnitTests/Sys/MenuTests.cs
+++ b/src/backend/UnitTests/Sys/MenuTests.cs
@@ -11,103 +11,103 @@ public class MenuTests(WebTestApplicationFactory<Startup> factory, ITestOutputHe
     : WebApiTestBase<Startup>(factory, testOutputHelper), IMenuModule
 {
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> BulkDeleteAsync(BulkReq<DelReq> req)
     {
         var rsp = await PostJsonAsync(typeof(MenuTests), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<long> CountAsync(QueryReq<QueryMenuReq> req)
     {
         var rsp = await PostJsonAsync(typeof(MenuTests), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IOrderedEnumerable<KeyValuePair<IImmutableDictionary<string, string>, int>>> CountByAsync(QueryReq<QueryMenuReq> req)
     {
         var rsp = await PostJsonAsync(typeof(MenuTests), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryMenuRsp> CreateAsync(CreateMenuReq req)
     {
         var rsp = await PostJsonAsync(typeof(MenuTests), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> DeleteAsync(DelReq req)
     {
         var rsp = await PostJsonAsync(typeof(MenuTests), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryMenuRsp> EditAsync(EditMenuReq req)
     {
         var rsp = await PostJsonAsync(typeof(MenuTests), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IActionResult> ExportAsync(QueryReq<QueryMenuReq> req)
     {
         var rsp = await PostJsonAsync(typeof(MenuTests), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryMenuRsp> GetAsync(QueryMenuReq req)
     {
         var rsp = await PostJsonAsync(typeof(MenuTests), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<PagedQueryRsp<QueryMenuRsp>> PagedQueryAsync(PagedQueryReq<QueryMenuReq> req)
     {
         var rsp = await PostJsonAsync(typeof(MenuTests), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IEnumerable<QueryMenuRsp>> QueryAsync(QueryReq<QueryMenuReq> req)
     {
         var rsp = await PostJsonAsync(typeof(MenuTests), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
@@ -116,6 +116,6 @@ public class MenuTests(WebTestApplicationFactory<Startup> factory, ITestOutputHe
     {
         var rsp = await PostJsonAsync(typeof(MenuTests));
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 }
\ No newline at end of file
diff --git a/src/backend/UnitTests/Sys/RequestLogTests.cs b/src/backend/UnitTests/Sys/RequestLogTests.cs
index e425b7bc..b055e9c3 100644
--- a/src/backend/UnitTests/Sys/RequestLogTests.cs
+++ b/src/backend/UnitTests/Sys/RequestLogTests.cs
@@ -12,132 +12,132 @@ public class RequestLogTests(WebTestApplicationFactory<Startup> factory, ITestOu
     : WebApiTestBase<Startup>(factory, testOutputHelper), IRequestLogModule
 {
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> BulkDeleteAsync(BulkReq<DelReq> req)
     {
         var rsp = await PostJsonAsync(typeof(RequestLogController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<long> CountAsync(QueryReq<QueryRequestLogReq> req)
     {
         var rsp = await PostJsonAsync(typeof(RequestLogController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IOrderedEnumerable<KeyValuePair<IImmutableDictionary<string, string>, int>>> CountByAsync(QueryReq<QueryRequestLogReq> req)
     {
         var rsp = await PostJsonAsync(typeof(RequestLogController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryRequestLogRsp> CreateAsync(CreateRequestLogReq req)
     {
         var rsp = await PostJsonAsync(typeof(RequestLogController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> DeleteAsync(DelReq req)
     {
         var rsp = await PostJsonAsync(typeof(RequestLogController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryRequestLogRsp> EditAsync(EditRequestLogReq req)
     {
         var rsp = await PostJsonAsync(typeof(RequestLogController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IActionResult> ExportAsync(QueryReq<QueryRequestLogReq> req)
     {
         var rsp = await PostJsonAsync(typeof(RequestLogController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryRequestLogRsp> GetAsync(QueryRequestLogReq req)
     {
         var rsp = await PostJsonAsync(typeof(RequestLogController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IEnumerable<GetBarChartRsp>> GetBarChartAsync(QueryReq<QueryRequestLogReq> req)
     {
         var rsp = await PostJsonAsync(typeof(RequestLogController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IEnumerable<GetPieChartRsp>> GetPieChartByApiSummaryAsync(QueryReq<QueryRequestLogReq> req)
     {
         var rsp = await PostJsonAsync(typeof(RequestLogController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IEnumerable<GetPieChartRsp>> GetPieChartByHttpStatusCodeAsync(QueryReq<QueryRequestLogReq> req)
     {
         var rsp = await PostJsonAsync(typeof(RequestLogController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<PagedQueryRsp<QueryRequestLogRsp>> PagedQueryAsync(PagedQueryReq<QueryRequestLogReq> req)
     {
         var rsp = await PostJsonAsync(typeof(RequestLogController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IEnumerable<QueryRequestLogRsp>> QueryAsync(QueryReq<QueryRequestLogReq> req)
     {
         var rsp = await PostJsonAsync(typeof(RequestLogController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 }
\ No newline at end of file
diff --git a/src/backend/UnitTests/Sys/RoleTests.cs b/src/backend/UnitTests/Sys/RoleTests.cs
index 96ce69cc..b2fb51a1 100644
--- a/src/backend/UnitTests/Sys/RoleTests.cs
+++ b/src/backend/UnitTests/Sys/RoleTests.cs
@@ -12,142 +12,142 @@ public class RoleTests(WebTestApplicationFactory<Startup> factory, ITestOutputHe
     : WebApiTestBase<Startup>(factory, testOutputHelper), IRoleModule
 {
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> BulkDeleteAsync(BulkReq<DelReq> req)
     {
         var rsp = await PostJsonAsync(typeof(RoleController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<long> CountAsync(QueryReq<QueryRoleReq> req)
     {
         var rsp = await PostJsonAsync(typeof(RoleController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IOrderedEnumerable<KeyValuePair<IImmutableDictionary<string, string>, int>>> CountByAsync(QueryReq<QueryRoleReq> req)
     {
         var rsp = await PostJsonAsync(typeof(RoleController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryRoleRsp> CreateAsync(CreateRoleReq req)
     {
         var rsp = await PostJsonAsync(typeof(RoleController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> DeleteAsync(DelReq req)
     {
         var rsp = await PostJsonAsync(typeof(RoleController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryRoleRsp> EditAsync(EditRoleReq req)
     {
         var rsp = await PostJsonAsync(typeof(RoleController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IActionResult> ExportAsync(QueryReq<QueryRoleReq> req)
     {
         var rsp = await PostJsonAsync(typeof(RoleController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryRoleRsp> GetAsync(QueryRoleReq req)
     {
         var rsp = await PostJsonAsync(typeof(RoleController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<PagedQueryRsp<QueryRoleRsp>> PagedQueryAsync(PagedQueryReq<QueryRoleReq> req)
     {
         var rsp = await PostJsonAsync(typeof(RoleController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IEnumerable<QueryRoleRsp>> QueryAsync(QueryReq<QueryRoleReq> req)
     {
         var rsp = await PostJsonAsync(typeof(RoleController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> SetDisplayDashboardAsync(SetDisplayDashboardReq req)
     {
         var rsp = await PostJsonAsync(typeof(RoleController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> SetEnabledAsync(SetRoleEnabledReq req)
     {
         var rsp = await PostJsonAsync(typeof(RoleController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> SetIgnorePermissionControlAsync(SetIgnorePermissionControlReq req)
     {
         var rsp = await PostJsonAsync(typeof(RoleController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IOrderedEnumerable<KeyValuePair<IImmutableDictionary<string, string>, int>>> UserCountByAsync(QueryReq<QueryUserRoleReq> req)
     {
         var rsp = await PostJsonAsync(typeof(RoleController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 }
\ No newline at end of file
diff --git a/src/backend/UnitTests/Sys/SiteMsgTests.cs b/src/backend/UnitTests/Sys/SiteMsgTests.cs
index 935cdc97..f02c33d4 100644
--- a/src/backend/UnitTests/Sys/SiteMsgTests.cs
+++ b/src/backend/UnitTests/Sys/SiteMsgTests.cs
@@ -12,127 +12,127 @@ public class SiteMsgTests(WebTestApplicationFactory<Startup> factory, ITestOutpu
     : WebApiTestBase<Startup>(factory, testOutputHelper), ISiteMsgModule
 {
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> BulkDeleteAsync(BulkReq<DelReq> req)
     {
         var rsp = await PostJsonAsync(typeof(SiteMsgController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<long> CountAsync(QueryReq<QuerySiteMsgReq> req)
     {
         var rsp = await PostJsonAsync(typeof(SiteMsgController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IOrderedEnumerable<KeyValuePair<IImmutableDictionary<string, string>, int>>> CountByAsync(QueryReq<QuerySiteMsgReq> req)
     {
         var rsp = await PostJsonAsync(typeof(SiteMsgController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QuerySiteMsgRsp> CreateAsync(CreateSiteMsgReq req)
     {
         var rsp = await PostJsonAsync(typeof(SiteMsgController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> DeleteAsync(DelReq req)
     {
         var rsp = await PostJsonAsync(typeof(SiteMsgController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QuerySiteMsgRsp> EditAsync(EditSiteMsgReq req)
     {
         var rsp = await PostJsonAsync(typeof(SiteMsgController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IActionResult> ExportAsync(QueryReq<QuerySiteMsgReq> req)
     {
         var rsp = await PostJsonAsync(typeof(SiteMsgController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QuerySiteMsgRsp> GetAsync(QuerySiteMsgReq req)
     {
         var rsp = await PostJsonAsync(typeof(SiteMsgController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QuerySiteMsgRsp> GetMineAsync(QuerySiteMsgReq req)
     {
         var rsp = await PostJsonAsync(typeof(SiteMsgController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<PagedQueryRsp<QuerySiteMsgRsp>> PagedQueryAsync(PagedQueryReq<QuerySiteMsgReq> req)
     {
         var rsp = await PostJsonAsync(typeof(SiteMsgController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<PagedQueryRsp<QuerySiteMsgRsp>> PagedQueryMineAsync(PagedQueryReq<QuerySiteMsgReq> req)
     {
         var rsp = await PostJsonAsync(typeof(SiteMsgController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IEnumerable<QuerySiteMsgRsp>> QueryAsync(QueryReq<QuerySiteMsgReq> req)
     {
         var rsp = await PostJsonAsync(typeof(SiteMsgController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task SetSiteMsgStatusAsync(SetUserSiteMsgStatusReq req)
     {
@@ -146,6 +146,6 @@ public class SiteMsgTests(WebTestApplicationFactory<Startup> factory, ITestOutpu
     {
         var rsp = await PostJsonAsync(typeof(SiteMsgController));
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 }
\ No newline at end of file
diff --git a/src/backend/UnitTests/Sys/ToolsTests.cs b/src/backend/UnitTests/Sys/ToolsTests.cs
index 45b87698..aa551ba3 100644
--- a/src/backend/UnitTests/Sys/ToolsTests.cs
+++ b/src/backend/UnitTests/Sys/ToolsTests.cs
@@ -11,7 +11,7 @@ public class ToolsTests(WebTestApplicationFactory<Startup> factory, ITestOutputH
     : WebApiTestBase<Startup>(factory, testOutputHelper), IToolsModule
 {
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public string AesDecode(AesDecodeReq req)
     {
@@ -19,17 +19,17 @@ public class ToolsTests(WebTestApplicationFactory<Startup> factory, ITestOutputH
         var rsp = PostJsonAsync(typeof(ToolsController), req).Result;
         #pragma warning restore xUnit1031
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<object[][]> ExecuteSqlAsync(ExecuteSqlReq req)
     {
         var rsp = await PostJsonAsync(typeof(ToolsController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
@@ -38,7 +38,7 @@ public class ToolsTests(WebTestApplicationFactory<Startup> factory, ITestOutputH
     {
         var rsp = await PostJsonAsync(typeof(ToolsController));
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
@@ -47,7 +47,7 @@ public class ToolsTests(WebTestApplicationFactory<Startup> factory, ITestOutputH
     {
         var rsp = await PostJsonAsync(typeof(ToolsController));
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
@@ -65,6 +65,6 @@ public class ToolsTests(WebTestApplicationFactory<Startup> factory, ITestOutputH
     {
         var rsp = await PostJsonAsync(typeof(ToolsController));
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 }
\ No newline at end of file
diff --git a/src/backend/UnitTests/Sys/UserTests.cs b/src/backend/UnitTests/Sys/UserTests.cs
index acace4b1..81927287 100644
--- a/src/backend/UnitTests/Sys/UserTests.cs
+++ b/src/backend/UnitTests/Sys/UserTests.cs
@@ -14,62 +14,62 @@ public class UserTests(WebTestApplicationFactory<Startup> factory, ITestOutputHe
     : WebApiTestBase<Startup>(factory, testOutputHelper), IUserModule
 {
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     [TestPriority(100100)]
     public async Task<int> BulkDeleteAsync(BulkReq<DelReq> req)
     {
         var rsp = await PostJsonAsync(typeof(UserController), req);
         Assert.Equal(HttpStatusCode.NotFound, rsp.StatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     [TestPriority(100200)]
     public async Task<bool> CheckMobileAvailableAsync(CheckMobileAvailableReq req)
     {
         var rsp = await PostJsonAsync(typeof(UserController), new CheckMobileAvailableReq { Mobile = "13838381438" });
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return false;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     [TestPriority(100300)]
     public async Task<bool> CheckUserNameAvailableAsync(CheckUserNameAvailableReq req)
     {
         var rsp = await PostJsonAsync(typeof(UserController), new CheckUserNameAvailableReq { UserName = "test" });
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return false;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     [TestPriority(100400)]
     public async Task<long> CountAsync(QueryReq<QueryUserReq> req)
     {
         var rsp = await PostJsonAsync(typeof(UserController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     [TestPriority(100400)]
     public async Task<IOrderedEnumerable<KeyValuePair<IImmutableDictionary<string, string>, int>>> CountByAsync(QueryReq<QueryUserReq> req)
     {
         var rsp = await PostJsonAsync(typeof(UserController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     [TestPriority(100000)]
     public async Task<QueryUserRsp> CreateAsync(CreateUserReq req)
@@ -82,22 +82,22 @@ public class UserTests(WebTestApplicationFactory<Startup> factory, ITestOutputHe
                                                           , DeptId       = 372119301627909
                                                         });
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     [TestPriority(100600)]
     public async Task<int> DeleteAsync(DelReq req)
     {
         var rsp = await PostJsonAsync(typeof(UserController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     [TestPriority(100700)]
     public async Task<QueryUserRsp> EditAsync(EditUserReq req)
@@ -105,29 +105,29 @@ public class UserTests(WebTestApplicationFactory<Startup> factory, ITestOutputHe
         var rsp = await PostJsonAsync(typeof(UserController)
                                     , new EditUserReq { UserName = "test", RoleIds = [371729946431493], DeptId = 372119301627909 });
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     [TestPriority(100900)]
     public async Task<IActionResult> ExportAsync(QueryReq<QueryUserReq> req)
     {
         var rsp = await PostJsonAsync(typeof(UserController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     [TestPriority(101000)]
     public async Task<QueryUserRsp> GetAsync(QueryUserReq req)
     {
         var rsp = await PostJsonAsync(typeof(UserController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
@@ -137,150 +137,150 @@ public class UserTests(WebTestApplicationFactory<Startup> factory, ITestOutputHe
     {
         var rsp = await PostJsonAsync(typeof(UserController));
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     [TestPriority(101200)]
     public async Task<LoginRsp> LoginByPwdAsync(LoginByPwdReq req)
     {
         var rsp = await PostJsonAsync(typeof(UserController), new LoginByPwdReq { Account = "root", Password = "1234qwer" });
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     [TestPriority(101300)]
     public async Task<LoginRsp> LoginBySmsAsync(LoginBySmsReq req)
     {
         var rsp = await PostJsonAsync(typeof(UserController), new LoginBySmsReq { Code = "1234", DestDevice = "13838381438" });
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     [TestPriority(101400)]
     public async Task<PagedQueryRsp<QueryUserRsp>> PagedQueryAsync(PagedQueryReq<QueryUserReq> req)
     {
         var rsp = await PostJsonAsync(typeof(UserController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     [TestPriority(101500)]
     public async Task<IEnumerable<QueryUserRsp>> QueryAsync(QueryReq<QueryUserReq> req)
     {
         var rsp = await PostJsonAsync(typeof(UserController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     [TestPriority(101600)]
     public async Task<IEnumerable<QueryUserProfileRsp>> QueryProfileAsync(QueryReq<QueryUserProfileReq> req)
     {
         var rsp = await PostJsonAsync(typeof(UserController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     [TestPriority(101700)]
     public async Task<UserInfoRsp> RegisterAsync(RegisterUserReq req)
     {
         var rsp = await PostJsonAsync(typeof(UserController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     [TestPriority(101800)]
     public async Task<int> ResetPasswordAsync(ResetPasswordReq req)
     {
         var rsp = await PostJsonAsync(typeof(UserController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     [TestPriority(101900)]
     public async Task<UserInfoRsp> SetAvatarAsync(SetAvatarReq req)
     {
         var rsp = await PostJsonAsync(typeof(UserController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     [TestPriority(102000)]
     public async Task<UserInfoRsp> SetEmailAsync(SetEmailReq req)
     {
         var rsp = await PostJsonAsync(typeof(UserController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     [TestPriority(102100)]
     public async Task<int> SetEnabledAsync(SetUserEnabledReq req)
     {
         var rsp = await PostJsonAsync(typeof(UserController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     [TestPriority(102200)]
     public async Task<UserInfoRsp> SetMobileAsync(SetMobileReq req)
     {
         var rsp = await PostJsonAsync(typeof(UserController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     [TestPriority(102300)]
     public async Task<int> SetPasswordAsync(SetPasswordReq req)
     {
         var rsp = await PostJsonAsync(typeof(UserController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     [TestPriority(102400)]
     public async Task<int> SetSessionUserAppConfigAsync(SetSessionUserAppConfigReq req)
     {
         var rsp = await PostJsonAsync(typeof(UserController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
@@ -290,6 +290,6 @@ public class UserTests(WebTestApplicationFactory<Startup> factory, ITestOutputHe
     {
         var rsp = await PostJsonAsync(typeof(UserController));
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 }
\ No newline at end of file
diff --git a/src/backend/UnitTests/Sys/VerifyCodeTests.cs b/src/backend/UnitTests/Sys/VerifyCodeTests.cs
index 4d5383f4..f50a51c3 100644
--- a/src/backend/UnitTests/Sys/VerifyCodeTests.cs
+++ b/src/backend/UnitTests/Sys/VerifyCodeTests.cs
@@ -11,122 +11,122 @@ public class VerifyCodeTests(WebTestApplicationFactory<Startup> factory, ITestOu
     : WebApiTestBase<Startup>(factory, testOutputHelper), IVerifyCodeModule
 {
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> BulkDeleteAsync(BulkReq<DelReq> req)
     {
         var rsp = await PostJsonAsync(typeof(VerifyCodeController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<long> CountAsync(QueryReq<QueryVerifyCodeReq> req)
     {
         var rsp = await PostJsonAsync(typeof(VerifyCodeController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IOrderedEnumerable<KeyValuePair<IImmutableDictionary<string, string>, int>>> CountByAsync(QueryReq<QueryVerifyCodeReq> req)
     {
         var rsp = await PostJsonAsync(typeof(VerifyCodeController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryVerifyCodeRsp> CreateAsync(CreateVerifyCodeReq req)
     {
         var rsp = await PostJsonAsync(typeof(VerifyCodeController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<int> DeleteAsync(DelReq req)
     {
         var rsp = await PostJsonAsync(typeof(VerifyCodeController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return 0;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryVerifyCodeRsp> EditAsync(EditVerifyCodeReq req)
     {
         var rsp = await PostJsonAsync(typeof(VerifyCodeController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IActionResult> ExportAsync(QueryReq<QueryVerifyCodeReq> req)
     {
         var rsp = await PostJsonAsync(typeof(VerifyCodeController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<QueryVerifyCodeRsp> GetAsync(QueryVerifyCodeReq req)
     {
         var rsp = await PostJsonAsync(typeof(VerifyCodeController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<PagedQueryRsp<QueryVerifyCodeRsp>> PagedQueryAsync(PagedQueryReq<QueryVerifyCodeReq> req)
     {
         var rsp = await PostJsonAsync(typeof(VerifyCodeController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<IEnumerable<QueryVerifyCodeRsp>> QueryAsync(QueryReq<QueryVerifyCodeReq> req)
     {
         var rsp = await PostJsonAsync(typeof(VerifyCodeController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<SendVerifyCodeRsp> SendVerifyCodeAsync(SendVerifyCodeReq req)
     {
         var rsp = await PostJsonAsync(typeof(VerifyCodeController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return null;
     }
 
     /// <inheritdoc />
-    [InlineData(default)]
+    [InlineData(null)]
     [Theory]
     public async Task<bool> VerifyAsync(VerifyCodeReq req)
     {
         var rsp = await PostJsonAsync(typeof(VerifyCodeController), req);
         Assert.True(rsp.IsSuccessStatusCode);
-        return default;
+        return false;
     }
 }
\ No newline at end of file