Remove test.

Author: brianrob

src/PerfView.Tests/StackViewer/StackWindowTests.cs

@@ -349,89 +349,6 @@ public Task TestSetTimeRangeAfterGotoCalleesAsync()
             return RunUITestAsync(setupAsync, testDriverAsync, cleanupAsync);
         }
 
-        [WpfFact]
-        [WorkItem(2280, "https://github.com/Microsoft/perfview/issues/2280")]
-        [UseCulture("en-US")]
-        public Task TestGotoCallersAccumulatesAcrossAllThreadsAsync()
-        {
-            Func<Task<StackWindow>> setupAsync = async () =>
-            {
-                await JoinableTaskFactory.SwitchToMainThreadAsync();
-
-                var file = new MultiThreadFile();
-                await OpenAsync(JoinableTaskFactory, file, GuiApp.MainWindow, GuiApp.MainWindow.StatusBar).ConfigureAwait(true);
-                var stackSource = file.GetStackSource();
-                return stackSource.Viewer;
-            };
-
-            Func<StackWindow, Task> cleanupAsync = async stackWindow =>
-            {
-                await JoinableTaskFactory.SwitchToMainThreadAsync();
-                stackWindow.Close();
-            };
-
-            Func<StackWindow, Task> testDriverAsync = async stackWindow =>
-            {
-                await JoinableTaskFactory.SwitchToMainThreadAsync();
-
-                // Start from the call tree tab (where user typically starts)
-                stackWindow.CallTreeTab.IsSelected = true;
-                await WaitForUIAsync(stackWindow.Dispatcher, CancellationToken.None);
-
-                // Find a specific node in the call tree (simulating selecting a thread-specific node)
-                var callTreeRoot = stackWindow.m_callTreeView.Root;
-                Assert.NotNull(callTreeRoot);
-                Assert.True(callTreeRoot.Callees.Count > 0, "Should have callees");
-
-                // Find a callee that exists across multiple threads
-                var targetNodeName = "MultiThreadMethod";
-                var callTreeNode = callTreeRoot.Callees.FirstOrDefault(c => c.Name == targetNodeName);
-                Assert.NotNull(callTreeNode, $"Should find {targetNodeName} in call tree");
-
-                // Simulate selecting this node in CallTree view
-                stackWindow.CallTreeDataGrid.Grid.SelectedIndex = 0; // Select first item
-                await WaitForUIAsync(stackWindow.Dispatcher, CancellationToken.None);
-
-                // Get the inclusive metric from ByName view (this aggregates across all threads)
-                stackWindow.ByNameTab.IsSelected = true;
-                await WaitForUIAsync(stackWindow.Dispatcher, CancellationToken.None);
-                
-                var byNameNode = stackWindow.m_byNameView.FirstOrDefault(n => n.Name == targetNodeName);
-                Assert.NotNull(byNameNode, $"Should find {targetNodeName} in ByName view");
-                var expectedInclusiveMetric = byNameNode.InclusiveMetric;
-
-                // Go back to CallTree and use F10 (Goto Item in Callers)
-                stackWindow.CallTreeTab.IsSelected = true;
-                await WaitForUIAsync(stackWindow.Dispatcher, CancellationToken.None);
-
-                // Execute the "Goto Item in Callers" command (this calls DoViewInCallers)
-                stackWindow.CallersTab.IsSelected = true;
-                await WaitForUIAsync(stackWindow.Dispatcher, CancellationToken.None);
-
-                // Verify that the callers view shows accumulated data from all threads
-                var focusName = stackWindow.FocusName;
-                Assert.Equal(targetNodeName, focusName);
-
-                // The key test: verify that the focus node in callers view has the same
-                // inclusive metric as the ByName view (indicating it's aggregated across all threads)
-                var callersView = stackWindow.m_callersView;
-                Assert.True(callersView.Count > 0, "Should have callers");
-                
-                // Find the root of callers view which should represent all callers across all threads
-                var callersRoot = callersView.FirstOrDefault();
-                Assert.NotNull(callersRoot);
-                
-                // This is the critical assertion: the callers view should show aggregated data
-                // If the regression existed, this would only show one thread's worth of callers
-                Assert.True(callersRoot.InclusiveMetric > 0, "Callers should have positive inclusive metric");
-                
-                // For a multi-thread scenario, we should see multiple samples
-                Assert.True(callersRoot.InclusiveCount >= 2, "Should accumulate samples from multiple threads");
-            };
-
-            return RunUITestAsync(setupAsync, testDriverAsync, cleanupAsync);
-        }
-
         private Task TestSetTimeRangeWithSpaceImplAsync(CultureInfo culture)
         {
             Func<Task<StackWindow>> setupAsync = async () =>
@@ -942,167 +859,5 @@ public override string GetFrameName(StackSourceFrameIndex frameIndex, bool verbo
                 return frameIndex.ToString();
             }
         }
-
-        /// <summary>
-        /// A file containing multiple threads with the same method to test caller/callee aggregation
-        /// </summary>
-        private class MultiThreadFile : PerfViewFile
-        {
-            public MultiThreadFile() : this(new MultiThreadStackSource())
-            {
-            }
-
-            public MultiThreadFile(MultiThreadStackSource stackSource)
-            {
-                Title = FormatName = nameof(MultiThreadFile);
-                StackSource = stackSource;
-            }
-
-            public override string Title { get; }
-
-            public override string FormatName { get; }
-
-            public override string[] FileExtensions { get; } = new[] { "Multi Thread Test" };
-
-            public MultiThreadStackSource StackSource { get; }
-
-            protected override Action<Action> OpenImpl(Window parentWindow, StatusBar worker)
-            {
-                return doAfter =>
-                {
-                    m_singletonStackSource = new PerfViewStackSource(this, string.Empty);
-                    m_singletonStackSource.Open(parentWindow, worker, doAfter);
-                };
-            }
-
-            protected internal override StackSource OpenStackSourceImpl(TextWriter log)
-            {
-                return StackSource;
-            }
-        }
-
-        private class MultiThreadStackSource : StackSource
-        {
-            // Define call stacks for multi-thread scenario
-            private const StackSourceCallStackIndex StackRoot = StackSourceCallStackIndex.Invalid;
-            private const StackSourceCallStackIndex StackThread1Entry = StackSourceCallStackIndex.Start + 0;
-            private const StackSourceCallStackIndex StackThread1Multi = StackSourceCallStackIndex.Start + 1;
-            private const StackSourceCallStackIndex StackThread2Entry = StackSourceCallStackIndex.Start + 2;
-            private const StackSourceCallStackIndex StackThread2Multi = StackSourceCallStackIndex.Start + 3;
-
-            private const StackSourceFrameIndex FrameThread1Entry = StackSourceFrameIndex.Start + 0;
-            private const StackSourceFrameIndex FrameMultiThreadMethod = StackSourceFrameIndex.Start + 1;
-            private const StackSourceFrameIndex FrameThread2Entry = StackSourceFrameIndex.Start + 2;
-
-            public MultiThreadStackSource()
-            {
-                Samples = new List<StackSourceSample>(4)
-                {
-                    new StackSourceSample(this)
-                    {
-                        SampleIndex = 0,
-                        StackIndex = StackThread1Multi,
-                        Metric = 1,
-                        TimeRelativeMSec = 0
-                    },
-                    new StackSourceSample(this)
-                    {
-                        SampleIndex = (StackSourceSampleIndex)1,
-                        StackIndex = StackThread2Multi,
-                        Metric = 1,
-                        TimeRelativeMSec = 100
-                    },
-                    new StackSourceSample(this)
-                    {
-                        SampleIndex = (StackSourceSampleIndex)2,
-                        StackIndex = StackThread1Multi,
-                        Metric = 1,
-                        TimeRelativeMSec = 200
-                    },
-                    new StackSourceSample(this)
-                    {
-                        SampleIndex = (StackSourceSampleIndex)3,
-                        StackIndex = StackThread2Multi,
-                        Metric = 1,
-                        TimeRelativeMSec = 300
-                    },
-                };
-            }
-
-            public List<StackSourceSample> Samples { get; }
-
-            public override int CallStackIndexLimit
-                => (int)StackThread2Multi + 1;
-
-            public override int CallFrameIndexLimit
-                => (int)FrameThread2Entry + 1;
-
-            public override int SampleIndexLimit
-                => Samples.Count;
-
-            public override double SampleTimeRelativeMSecLimit
-                => 400;
-
-            public override void ForEach(Func<StackSourceSample, bool> callback)
-            {
-                foreach (var sample in Samples)
-                {
-                    if (!callback(sample))
-                    {
-                        break;
-                    }
-                }
-            }
-
-            public override StackSourceSample GetSampleByIndex(StackSourceSampleIndex sampleIndex)
-                => Samples[(int)sampleIndex];
-
-            public override StackSourceCallStackIndex GetCallerIndex(StackSourceCallStackIndex callStackIndex)
-            {
-                switch (callStackIndex)
-                {
-                    case StackThread1Multi:
-                        return StackThread1Entry;
-                    case StackThread2Multi:
-                        return StackThread2Entry;
-                    case StackThread1Entry:
-                    case StackThread2Entry:
-                        return StackSourceCallStackIndex.Invalid;
-                    default:
-                        return StackSourceCallStackIndex.Invalid;
-                }
-            }
-
-            public override StackSourceFrameIndex GetFrameIndex(StackSourceCallStackIndex callStackIndex)
-            {
-                switch (callStackIndex)
-                {
-                    case StackThread1Entry:
-                        return FrameThread1Entry;
-                    case StackThread1Multi:
-                    case StackThread2Multi:
-                        return FrameMultiThreadMethod;
-                    case StackThread2Entry:
-                        return FrameThread2Entry;
-                    default:
-                        return StackSourceFrameIndex.Root;
-                }
-            }
-
-            public override string GetFrameName(StackSourceFrameIndex frameIndex, bool verboseName)
-            {
-                switch (frameIndex)
-                {
-                    case FrameThread1Entry:
-                        return "Thread1Entry";
-                    case FrameMultiThreadMethod:
-                        return "MultiThreadMethod";
-                    case FrameThread2Entry:
-                        return "Thread2Entry";
-                    default:
-                        return frameIndex.ToString();
-                }
-            }
-        }
     }
 }