进度传递与测试框架修复

Shared/General/Progress.cs

@@ -10,14 +10,16 @@ public class ProgressProvider {
     /// 当原始进度可能被改变时触发。
     /// </summary>
     public event Action<(double actual, double skiped)>? ProgressChanged;
-    private void InvokeProgressChanged((double actual, double skiped) raw) => ProgressChanged?.Invoke(raw);
-    private void InvokeProgressChanged() => InvokeProgressChanged(GetRaw());
+    private event Action? ChildProgressChanged;
+    private void InvokeProgressChanged() {
+        ProgressChanged?.Invoke(GetRaw());
+        ChildProgressChanged?.Invoke();
+    }
 
     // ===================================== 主项进度 =====================================
 
     private (double actual, double skiped, double splited) progressParts = (0, 0, 0);
     private double progressSum => progressParts.actual + progressParts.skiped + progressParts.splited;
-    public bool Finished => progressParts.actual + progressParts.skiped > 0.9999999;
 
     private bool _Set(double value, bool skiped) {
         value = value.Clamp(0, 1);
@@ -71,6 +73,7 @@ public class ProgressProvider {
         lock (this) {
             changed = progressSum > 0;
             progressParts = (0, 0, 0);
+            childrens.ForEach(c => c.child.ChildProgressChanged -= InvokeProgressChanged);
             childrens.Clear();
         }
         if (changed) InvokeProgressChanged();
@@ -97,7 +100,7 @@ public class ProgressProvider {
             progressParts.splited += (percentages.Sum() + progressSum).Clamp(0, 1) - progressSum;
             return percentages.Select(percentage => {
                 var sub = new ProgressProvider();
-                sub.ProgressChanged += InvokeProgressChanged;
+                sub.ChildProgressChanged += InvokeProgressChanged;
                 childrens.Add((percentage, sub));
                 return sub;
             }).ToList();
@@ -126,7 +129,7 @@ public class ProgressProvider {
                     var (subActual, subSkiped) = c.child.GetRaw();
                     progressParts.actual += mult * c.percentage * (action == ChildrenAction.Finished ? (1 - subSkiped) : subActual);
                     progressParts.skiped += mult * c.percentage * (action == ChildrenAction.Skiped ? (1 - subActual) : subSkiped);
-                    c.child.ProgressChanged -= InvokeProgressChanged;
+                    c.child.ChildProgressChanged -= InvokeProgressChanged;
                     if (subActual + subSkiped < 0.9999999) changed = true;
                 });
             }
@@ -199,4 +202,4 @@ public class ProgressObserver : RateLimitedWorker {
         updateAction(progress);
     }
 
-}
+}

Tests/General/ProgressTest.cs

@@ -21,13 +21,19 @@ public class ProgressTest : TestBase {
     public async Task ProgressChanged_子进度改变时向父级传播() {
         var progress = new ProgressProvider();
         int changedCount = 0;
-        progress.ProgressChanged += _ => changedCount++;
+        (double actual, double skiped) changedProgress = default;
+        progress.ProgressChanged += value => {
+            changedCount++;
+            changedProgress = value;
+        };
 
         var sub = progress.SplitBy(0.5).Single();
         sub.Set(0.5);
         sub.Set(0.5);
 
         await Assert.That(changedCount).IsEqualTo(1);
+        await Assert.That(changedProgress.actual).IsEqualTo(0.25);
+        await Assert.That(changedProgress.skiped).IsEqualTo(0);
     }
 
     [Test]

Tests/Utils/TaskUtilsTest.cs

@@ -28,18 +28,4 @@ public class TaskUtilsTest : TestBase {
         await Assert.That(progress.GetIncrement()).IsEqualTo(1);
     }
 
-    [Test]
-    public async Task WhenAll_省略父进度时仍传入独立进度() {
-        ProgressProvider? receivedProgress = null;
-
-        await TaskUtils.WhenAll([
-            child => {
-                receivedProgress = child;
-                return Task.CompletedTask;
-            }
-        ]);
-
-        await Assert.That(receivedProgress is not null).IsTrue();
-    }
-
 }

global.json

@@ -0,0 +1,5 @@
+{
+  "test": {
+    "runner": "Microsoft.Testing.Platform"
+  }
+}