Add verification that handlers are called at correct times

Co-authored-by: timcassell <[email protected]>

Author: Copilot

tests/BenchmarkDotNet.IntegrationTests/Diagnosers/MockInProcessDiagnoser.cs

@@ -14,6 +14,7 @@ namespace BenchmarkDotNet.IntegrationTests.Diagnosers;
 public abstract class BaseMockInProcessDiagnoser : IInProcessDiagnoser
 {
     public Dictionary<BenchmarkCase, string> Results { get; } = [];
+    public Dictionary<BenchmarkCase, List<BenchmarkSignal>> HandlerSignals { get; } = [];
 
     public abstract string DiagnoserName { get; }
     public abstract RunMode DiagnoserRunMode { get; }
@@ -42,17 +43,29 @@ public void Handle(HostSignal signal, DiagnoserActionParameters parameters) { }
         var (handlerType, serializedConfig) = GetSeparateProcessHandlerTypeAndSerializedConfig(benchmarkCase);
         if (handlerType == null)
             return null;
-        var handler = (IInProcessDiagnoserHandler)Activator.CreateInstance(handlerType);
+        var handler = (BaseMockInProcessDiagnoserHandler)Activator.CreateInstance(handlerType);
         handler.Initialize(serializedConfig);
+        handler.SetDiagnoser(this, benchmarkCase);
         return handler;
     }
 
     public void DeserializeResults(BenchmarkCase benchmarkCase, string results) => Results.Add(benchmarkCase, results);
+
+    internal void RecordSignal(BenchmarkCase benchmarkCase, BenchmarkSignal signal)
+    {
+        if (!HandlerSignals.ContainsKey(benchmarkCase))
+        {
+            HandlerSignals[benchmarkCase] = [];
+        }
+        HandlerSignals[benchmarkCase].Add(signal);
+    }
 }
 
 public abstract class BaseMockInProcessDiagnoserHandler : IInProcessDiagnoserHandler
 {
     private string _result;
+    private BaseMockInProcessDiagnoser _diagnoser;
+    private BenchmarkCase _benchmarkCase;
 
     protected BaseMockInProcessDiagnoserHandler() { }
 
@@ -61,7 +74,16 @@ public void Initialize(string? serializedConfig)
         _result = serializedConfig ?? string.Empty;
     }
 
-    public void Handle(BenchmarkSignal signal, InProcessDiagnoserActionArgs args) { }
+    internal void SetDiagnoser(BaseMockInProcessDiagnoser diagnoser, BenchmarkCase benchmarkCase)
+    {
+        _diagnoser = diagnoser;
+        _benchmarkCase = benchmarkCase;
+    }
+
+    public void Handle(BenchmarkSignal signal, InProcessDiagnoserActionArgs args)
+    {
+        _diagnoser?.RecordSignal(_benchmarkCase, signal);
+    }
 
     public string SerializeResults() => _result;
 }

tests/BenchmarkDotNet.IntegrationTests/InProcessDiagnoserTests.cs

@@ -109,17 +109,37 @@ public void MultipleInProcessDiagnosersWork(BaseMockInProcessDiagnoser[] diagnos
                     // SeparateLogic is not yet implemented for in-process diagnosers, so we expect it to fail
                     // This is marked as a known limitation to be fixed in the future
                     Assert.Empty(diagnoser.Results); // Expected to fail until SeparateLogic is implemented
+                    Assert.Empty(diagnoser.HandlerSignals); // No signals should be recorded
                 }
                 else
                 {
                     Assert.NotEmpty(diagnoser.Results);
                     Assert.Equal(summary.BenchmarksCases.Length, diagnoser.Results.Count);
                     Assert.All(diagnoser.Results.Values, result => Assert.Equal(diagnoser.ExpectedResult, result));
+
+                    // Verify handlers were called at the correct times
+                    Assert.NotEmpty(diagnoser.HandlerSignals);
+                    Assert.Equal(summary.BenchmarksCases.Length, diagnoser.HandlerSignals.Count);
+
+                    foreach (var (benchmarkCase, signals) in diagnoser.HandlerSignals)
+                    {
+                        // Verify the handler was called with all expected signals in the correct order
+                        Assert.NotEmpty(signals);
+                        Assert.Contains(Engines.BenchmarkSignal.BeforeActualRun, signals);
+                        Assert.Contains(Engines.BenchmarkSignal.AfterActualRun, signals);
+
+                        // Verify signals are in correct order
+                        var beforeIndex = signals.IndexOf(Engines.BenchmarkSignal.BeforeActualRun);
+                        var afterIndex = signals.IndexOf(Engines.BenchmarkSignal.AfterActualRun);
+                        Assert.True(beforeIndex < afterIndex,
+                            $"BeforeActualRun should come before AfterActualRun, but got indices {beforeIndex} and {afterIndex}");
+                    }
                 }
             }
             else
             {
                 Assert.Empty(diagnoser.Results);
+                Assert.Empty(diagnoser.HandlerSignals); // None should not have any signals
             }
         }
     }