[Components][E2E] Stabilize NonZeroStartIndex_ScrollToMiddleThenMeasure test setup (#66290)

* Stabilize NonZeroStartIndex_ScrollToMiddleThenMeasure E2E test setup

Apply the same retry-based scroll stabilization pattern from PR #66194
to NonZeroStartIndex_ScrollToMiddleThenMeasure. The test was racing in
server mode because it set scrollTop and then immediately checked the
rendered items, but the async virtualization update had not finished yet.

The fix computes the target offset up front, then retries both the
scroll assignment and the rendered-index check inside a single
Browser.True() loop before calling WaitForScrollStabilization.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

* Apply review feedback: fix spacing and reuse ScrollToOffsetWithStabilization helper

- Fix missing space around = in targetScrollTop assignment
- Extract scroll+retry logic into generalized ScrollToOffsetWithStabilization overload
- Reuse the helper in NonZeroStartIndex_ScrollToMiddleThenMeasure instead of duplicating

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

* Fix bad merge: remove stale CanElevateEffectiveMaxItemCount quarantine, restore missing PrependItems quarantine

The merge from main incorrectly re-introduced a quarantine for
CanElevateEffectiveMaxItemCount_WhenOverscanExceedsMax (#65962) which
was already fixed and unquarantined by #66291 on main. It also dropped
the DynamicContent_PrependItemsWhileScrolledToMiddle quarantine (#66308)
that was added by #66312 on main.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

* Use MutationObserver instead of scroll retry loop in NonZeroStartIndex test

Replace the retry-based ScrollToOffsetWithStabilization call with a
single scrollTop assignment followed by a MutationObserver that waits
for Blazor's DOM update to settle. This makes the test more
deterministic: it scrolls once and waits for the effect, rather than
retrying the scroll which could mask real bugs where the component
fails to handle the initial scroll correctly.

The MutationObserver waits for a 200ms quiet period after the last
DOM mutation, with a 2s fallback timeout. After that, scroll position
stabilization is verified, and the item index assertion is a hard
assert (not a retry loop).

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

---------

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: ilonatommy

src/Components/test/E2ETest/ServerExecutionTests/TestSubclasses.cs

@@ -104,10 +104,6 @@ public ServerVirtualizationTest(BrowserFixture browserFixture, ToggleExecutionMo
     public override void CanRenderHtmlTable()
         => base.CanRenderHtmlTable();
 
-    [QuarantinedTest("https://github.com/dotnet/aspnetcore/issues/66119")]
-    public override void NonZeroStartIndex_ScrollToMiddleThenMeasure()
-        => base.NonZeroStartIndex_ScrollToMiddleThenMeasure();
-
     [QuarantinedTest("https://github.com/dotnet/aspnetcore/issues/66120")]
     public override void CancelsOutdatedRefreshes_Async()
         => base.CancelsOutdatedRefreshes_Async();

src/Components/test/E2ETest/Tests/VirtualizationTest.cs

@@ -753,6 +753,26 @@ private void ScrollToOffsetWithStabilization(
         IWebElement container,
         double targetScrollTop,
         int minFirstRenderedIndexExclusive)
+    {
+        ScrollToOffsetWithStabilization(container, targetScrollTop, () =>
+        {
+            var items = container.FindElements(By.CssSelector(".item"));
+            if (items.Count == 0)
+            {
+                return false;
+            }
+
+            var indexText = items.First().GetDomAttribute("data-index");
+            return indexText != null
+                && int.TryParse(indexText, NumberStyles.Integer, CultureInfo.InvariantCulture, out var index)
+                && index > minFirstRenderedIndexExclusive;
+        });
+    }
+
+    private void ScrollToOffsetWithStabilization(
+        IWebElement container,
+        double targetScrollTop,
+        Func<bool> itemCheckPredicate)
     {
         var js = (IJavaScriptExecutor)Browser;
 
@@ -769,16 +789,7 @@ private void ScrollToOffsetWithStabilization(
                 return false;
             }
 
-            var items = container.FindElements(By.CssSelector(".item"));
-            if (items.Count == 0)
-            {
-                return false;
-            }
-
-            var indexText = items.First().GetDomAttribute("data-index");
-            return indexText != null
-                && int.TryParse(indexText, NumberStyles.Integer, CultureInfo.InvariantCulture, out var index)
-                && index > minFirstRenderedIndexExclusive;
+            return itemCheckPredicate();
         });
 
         WaitForScrollStabilization(container);
@@ -1615,29 +1626,39 @@ public void ProgrammaticScrollToBottom_ReachesLastItems()
     }
 
     [Fact]
-    public virtual void NonZeroStartIndex_ScrollToMiddleThenMeasure()
+    public void NonZeroStartIndex_ScrollToMiddleThenMeasure()
     {
         Browser.MountTestComponent<VirtualizationScrollBehavior>();
 
         var container = Browser.Exists(By.Id("scroll-behavior-container"));
         var js = (IJavaScriptExecutor)Browser;
         Browser.True(() => GetElementCount(container, ".scroll-behavior-item") > 0);
 
-        js.ExecuteScript("arguments[0].scrollTop = arguments[0].scrollHeight / 2", container);
+        // Scroll to middle and wait for Blazor's DOM update to land via MutationObserver.
+        // This sets scrollTop once and waits for the virtualization render to complete,
+        // rather than retrying the scroll which could mask bugs.
+        js.ExecuteAsyncScript(@"
+            var container = arguments[0];
+            var callback = arguments[1];
+            var targetTop = container.scrollHeight / 2;
+            container.scrollTop = targetTop;
+            var timer;
+            var observer = new MutationObserver(function() {
+                clearTimeout(timer);
+                timer = setTimeout(function() { observer.disconnect(); callback(); }, 200);
+            });
+            observer.observe(container, { childList: true, subtree: true });
+            // Fallback in case scroll didn't trigger any DOM mutations (e.g., already at target)
+            timer = setTimeout(function() { observer.disconnect(); callback(); }, 2000);
+        ", container);
+
         WaitForScrollStabilization(container);
 
-        Browser.True(() =>
-        {
-            var items = container.FindElements(By.CssSelector(".scroll-behavior-item .item-index"));
-            return items.Any(item =>
-            {
-                if (int.TryParse(item.Text, out var idx))
-                {
-                    return idx > 50;
-                }
-                return false;
-            });
-        });
+        // Verify that scrolling to the middle actually rendered middle items
+        var items = container.FindElements(By.CssSelector(".scroll-behavior-item .item-index"));
+        Assert.True(
+            items.Any(item => int.TryParse(item.Text, out var idx) && idx > 50),
+            "After scrolling to middle, expected items with index > 50 to be visible");
 
         var visibleItems = container.FindElements(By.CssSelector(".scroll-behavior-item"));
         Assert.True(visibleItems.Count > 0, "Should have visible items at non-zero start");