Refactor test code to use simplified lambda expressions and improve code clarity

- Simplified lambda expressions by removing explicit parameter types
- Added missing using statements for System.Collections.Generic and System.Reflection
- Removed redundant System namespace prefixes
- Changed DelayFrame(1) to DelayFrame() for default behavior
- Minor code cleanup for better readability

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: JasonXuDeveloper

UnityProject/Packages/com.jasonxudeveloper.jengine.util/Tests/Editor/JActionTests.cs

@@ -1,6 +1,8 @@
 // JActionTests.cs
 // EditMode unit tests for JAction (synchronous execution)
 
+using System.Collections.Generic;
+using System.Reflection;
 using NUnit.Framework;
 
 namespace JEngine.Util.Tests
@@ -92,7 +94,7 @@ public void Do_WithState_PassesStateToAction()
             int result = 0;
 
             JAction.Create()
-                .Do((int x) => result = x, 42)
+                .Do(x => result = x, 42)
                 .Execute();
 
             Assert.AreEqual(42, result);
@@ -105,7 +107,7 @@ public void Do_WithReferenceState_PassesStateToAction()
             int result = 0;
 
             JAction.Create()
-                .Do((TestData d) => result = d.Value, data)
+                .Do(d => result = d.Value, data)
                 .Execute();
 
             Assert.AreEqual(10, result);
@@ -129,7 +131,7 @@ public void Repeat_WithState_PassesStateEachTime()
             int sum = 0;
 
             JAction.Create()
-                .Repeat((int x) => sum += x, state: 10, count: 3)
+                .Repeat(x => sum += x, state: 10, count: 3)
                 .Execute();
 
             Assert.AreEqual(30, sum);
@@ -156,8 +158,8 @@ public void Cancel_InvokesOnCancelCallback()
 
             // Force executing state and cancel
             typeof(JAction).GetField("IsExecuting",
-                System.Reflection.BindingFlags.NonPublic |
-                System.Reflection.BindingFlags.Instance)
+                BindingFlags.NonPublic |
+                BindingFlags.Instance)
                 ?.SetValue(action2, true);
 
             action2.Cancel();
@@ -173,12 +175,12 @@ public void Cancel_WithState_PassesStateToCallback()
             int result = 0;
 
             var action = JAction.Create()
-                .OnCancel((int x) => result = x, 42);
+                .OnCancel(x => result = x, 42);
 
             // Force executing state
             typeof(JAction).GetField("IsExecuting",
-                System.Reflection.BindingFlags.NonPublic |
-                System.Reflection.BindingFlags.Instance)
+                BindingFlags.NonPublic |
+                BindingFlags.Instance)
                 ?.SetValue(action, true);
 
             action.Cancel();
@@ -293,7 +295,7 @@ public void Do_WithIntState_WorksCorrectly()
             int result = 0;
 
             JAction.Create()
-                .Do((int x) => result = x, 123)
+                .Do(x => result = x, 123)
                 .Execute();
 
             Assert.AreEqual(123, result);
@@ -305,7 +307,7 @@ public void Do_WithFloatState_WorksCorrectly()
             float result = 0;
 
             JAction.Create()
-                .Do((float x) => result = x, 3.14f)
+                .Do(x => result = x, 3.14f)
                 .Execute();
 
             Assert.AreEqual(3.14f, result, 0.001f);
@@ -317,7 +319,7 @@ public void Do_WithBoolState_WorksCorrectly()
             bool result = false;
 
             JAction.Create()
-                .Do((bool x) => result = x, true)
+                .Do(x => result = x, true)
                 .Execute();
 
             Assert.IsTrue(result);
@@ -349,8 +351,8 @@ public void Dispose_DuringExecution_CancelsFirst()
 
             // Start execution
             typeof(JAction).GetField("IsExecuting",
-                System.Reflection.BindingFlags.NonPublic |
-                System.Reflection.BindingFlags.Instance)
+                BindingFlags.NonPublic |
+                BindingFlags.Instance)
                 ?.SetValue(action, true);
 
             action.Dispose();
@@ -378,7 +380,7 @@ public void Execute_WithNullAction_SkipsGracefully()
         [Test]
         public void ComplexChain_ExecutesInOrder()
         {
-            var order = new System.Collections.Generic.List<int>();
+            var order = new List<int>();
 
             JAction.Create()
                 .Do(() => order.Add(1))
@@ -402,10 +404,10 @@ public void ComplexChain_WithState_PassesCorrectState()
             int sum = 0;
 
             JAction.Create()
-                .Do((int x) => sum += x, 1)
-                .Do((int x) => sum += x, 10)
-                .Repeat((int x) => sum += x, state: 100, count: 2)
-                .Do((int x) => sum += x, 1000)
+                .Do(x => sum += x, 1)
+                .Do(x => sum += x, 10)
+                .Repeat(x => sum += x, state: 100, count: 2)
+                .Do(x => sum += x, 1000)
                 .Execute();
 
             Assert.AreEqual(1211, sum); // 1 + 10 + 100 + 100 + 1000
@@ -414,15 +416,15 @@ public void ComplexChain_WithState_PassesCorrectState()
         [Test]
         public void ComplexChain_MixedStaticAndState_WorksCorrectly()
         {
-            var results = new System.Collections.Generic.List<string>();
+            var results = new List<string>();
 
             // Mix static lambdas (no closure) with state overloads
             using var action = JAction.Create()
                 .Do(static () => { }) // static lambda, no state needed
-                .Do(static (System.Collections.Generic.List<string> r) => r.Add("step1"), results)
+                .Do(static r => r.Add("step1"), results)
                 .Delay(0.01f)
-                .Do(static (System.Collections.Generic.List<string> r) => r.Add("step2"), results)
-                .Repeat(static (System.Collections.Generic.List<string> r) => r.Add("repeat"), results, count: 2)
+                .Do(static r => r.Add("step2"), results)
+                .Repeat(static r => r.Add("repeat"), results, count: 2)
                 .Execute();
 
             Assert.AreEqual(4, results.Count);
@@ -437,7 +439,7 @@ public void Using_AutoDisposesAction()
         {
             int initialPoolCount = JAction.PooledCount;
 
-            using (var action = JAction.Create().Do(() => { }).Execute())
+            using (JAction.Create().Do(() => { }).Execute())
             {
                 Assert.AreEqual(initialPoolCount, JAction.PooledCount);
             }
@@ -457,7 +459,7 @@ public void WaitUntil_WithState_PassesStateToCondition()
             bool completed = false;
 
             JAction.Create()
-                .WaitUntil((TestData d) =>
+                .WaitUntil(d =>
                 {
                     d.Value++;
                     return d.Value >= 3;
@@ -476,7 +478,7 @@ public void WaitWhile_WithState_PassesStateToCondition()
             bool completed = false;
 
             JAction.Create()
-                .WaitWhile((TestData d) =>
+                .WaitWhile(d =>
                 {
                     d.Value++;
                     return d.Value < 3;
@@ -496,8 +498,8 @@ public void RepeatWhile_WithState_PassesStateToActionAndCondition()
 
             JAction.Create()
                 .RepeatWhile(
-                    (TestData d) => { actionCount++; d.Value++; },
-                    (TestData d) => d.Value < 5,
+                    d => { actionCount++; d.Value++; },
+                    d => d.Value < 5,
                     data)
                 .Execute();
 
@@ -513,8 +515,8 @@ public void RepeatUntil_WithState_PassesStateToActionAndCondition()
 
             JAction.Create()
                 .RepeatUntil(
-                    (TestData d) => { actionCount++; d.Value++; },
-                    (TestData d) => d.Value >= 5,
+                    d => { actionCount++; d.Value++; },
+                    d => d.Value >= 5,
                     data)
                 .Execute();
 

UnityProject/Packages/com.jasonxudeveloper.jengine.util/Tests/Runtime/JActionRuntimeTests.cs

@@ -1,7 +1,9 @@
 // JActionRuntimeTests.cs
 // PlayMode tests for JAction (require Unity frame execution)
 
+using System;
 using System.Collections;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 using NUnit.Framework;
 using UnityEngine;
@@ -27,7 +29,7 @@ public void TearDown()
         /// <summary>
         /// Helper to run async code in coroutine context and wait for completion.
         /// </summary>
-        private IEnumerator RunAsync(System.Func<Task> asyncFunc)
+        private IEnumerator RunAsync(Func<Task> asyncFunc)
         {
             var task = asyncFunc();
 
@@ -192,7 +194,7 @@ public IEnumerator ExecuteAsync_CanBeAwaited()
             {
                 using var action = await JAction.Create()
                     .Do(() => step1 = true)
-                    .DelayFrame(1)
+                    .DelayFrame()
                     .Do(() => step2 = true)
                     .ExecuteAsync();
 
@@ -277,7 +279,7 @@ public IEnumerator WaitUntil_WithState_PassesState()
             return RunAsync(async () =>
             {
                 using var action = await JAction.Create()
-                    .WaitUntil(static (TestData d) =>
+                    .WaitUntil(static d =>
                     {
                         d.Counter++;
                         return d.Counter >= 3;
@@ -300,8 +302,8 @@ public IEnumerator RepeatWhile_WithState_PassesState()
             {
                 using var action = await JAction.Create()
                     .RepeatWhile(
-                        static (TestData d) => d.Counter++,
-                        static (TestData d) => d.Counter < 5,
+                        static d => d.Counter++,
+                        static d => d.Counter < 5,
                         data)
                     .Do(() => completed = true)
                     .ExecuteAsync();
@@ -318,13 +320,13 @@ public IEnumerator RepeatWhile_WithState_PassesState()
         [UnityTest]
         public IEnumerator ComplexChain_Async_ExecutesInOrder()
         {
-            var order = new System.Collections.Generic.List<int>();
+            var order = new List<int>();
 
             return RunAsync(async () =>
             {
                 using var action = await JAction.Create()
                     .Do(() => order.Add(1))
-                    .DelayFrame(1)
+                    .DelayFrame()
                     .Do(() => order.Add(2))
                     .Delay(0.05f)
                     .Do(() => order.Add(3))
@@ -345,18 +347,18 @@ public IEnumerator ComplexChain_Async_ExecutesInOrder()
         [UnityTest]
         public IEnumerator ComplexChain_Async_WithStaticLambdasAndState()
         {
-            var results = new System.Collections.Generic.List<string>();
+            var results = new List<string>();
             bool completed = false;
 
             return RunAsync(async () =>
             {
                 // Mix static lambdas with state overloads - zero closure allocations
                 using var action = await JAction.Create()
-                    .Do(static (System.Collections.Generic.List<string> r) => r.Add("start"), results)
-                    .DelayFrame(1)
-                    .Do(static (System.Collections.Generic.List<string> r) => r.Add("after_frame"), results)
+                    .Do(static r => r.Add("start"), results)
+                    .DelayFrame()
+                    .Do(static r => r.Add("after_frame"), results)
                     .Delay(0.05f)
-                    .Repeat(static (System.Collections.Generic.List<string> r) => r.Add("repeat"), results, count: 2)
+                    .Repeat(static r => r.Add("repeat"), results, count: 2)
                     .Do(() => completed = true) // This one has closure (for test verification)
                     .ExecuteAsync();
 
@@ -384,7 +386,7 @@ public IEnumerator UsingAwait_AutoDisposesAfterExecution()
                 // Use explicit using block so we can check pool count after disposal
                 using (var action = await JAction.Create()
                     .Do(() => completed = true)
-                    .DelayFrame(1)
+                    .DelayFrame()
                     .ExecuteAsync())
                 {
                     Assert.IsTrue(completed);