Port BasicNavigationBar.CodeSpit to the new test harness

src/VisualStudio/IntegrationTest/New.IntegrationTests/AbstractIntegrationTest.cs

@@ -96,6 +96,9 @@ protected CancellationToken HangMitigatingCancellationToken
         public virtual async Task InitializeAsync()
         {
             TestServices = await CreateTestServicesAsync();
+
+            await TestServices.StateReset.ResetGlobalOptionsAsync(HangMitigatingCancellationToken);
+            await TestServices.StateReset.ResetHostSettingsAsync(HangMitigatingCancellationToken);
         }
 
         /// <summary>

src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/EditorInProcess.cs

@@ -4,26 +4,38 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Linq;
+using System.Runtime.InteropServices;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
 using Microsoft;
 using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.Editor;
 using Microsoft.CodeAnalysis.Editor.Implementation.Suggestions;
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
+using Microsoft.CodeAnalysis.UnitTests;
 using Microsoft.VisualStudio;
 using Microsoft.VisualStudio.Editor;
 using Microsoft.VisualStudio.IntegrationTest.Utilities;
+using Microsoft.VisualStudio.IntegrationTest.Utilities.Input;
 using Microsoft.VisualStudio.Language.Intellisense;
 using Microsoft.VisualStudio.Language.Intellisense.AsyncCompletion;
 using Microsoft.VisualStudio.Shell.Interop;
 using Microsoft.VisualStudio.Text;
 using Microsoft.VisualStudio.Text.Editor;
 using Microsoft.VisualStudio.TextManager.Interop;
 using Microsoft.VisualStudio.Utilities;
+using Roslyn.Utilities;
+using Xunit;
+using IObjectWithSite = Microsoft.VisualStudio.OLE.Interop.IObjectWithSite;
 using IOleCommandTarget = Microsoft.VisualStudio.OLE.Interop.IOleCommandTarget;
+using IOleServiceProvider = Microsoft.VisualStudio.OLE.Interop.IServiceProvider;
 using OLECMDEXECOPT = Microsoft.VisualStudio.OLE.Interop.OLECMDEXECOPT;
 
 namespace Roslyn.VisualStudio.IntegrationTests.InProcess
@@ -132,6 +144,186 @@ public async Task SetUseSuggestionModeAsync(bool value, CancellationToken cancel
             }
         }
 
+        #region Navigation bars
+
+        public async Task ExpandNavigationBarAsync(NavigationBarDropdownKind index, CancellationToken cancellationToken)
+        {
+            await TestServices.Workspace.WaitForAsyncOperationsAsync(FeatureAttribute.NavigationBar, cancellationToken);
+
+            await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
+
+            var view = await GetActiveTextViewAsync(cancellationToken);
+            var combobox = (await GetNavigationBarComboBoxesAsync(view, cancellationToken))[(int)index];
+            FocusManager.SetFocusedElement(FocusManager.GetFocusScope(combobox), combobox);
+            combobox.IsDropDownOpen = true;
+        }
+
+        public async Task<ImmutableArray<string>> GetNavigationBarItemsAsync(NavigationBarDropdownKind index, CancellationToken cancellationToken)
+        {
+            await TestServices.Workspace.WaitForAsyncOperationsAsync(FeatureAttribute.NavigationBar, cancellationToken);
+
+            await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
+
+            var view = await GetActiveTextViewAsync(cancellationToken);
+            var combobox = (await GetNavigationBarComboBoxesAsync(view, cancellationToken))[(int)index];
+            return combobox.Items.OfType<object>().SelectAsArray(i => $"{i}");
+        }
+
+        public async Task<string?> GetNavigationBarSelectionAsync(NavigationBarDropdownKind index, CancellationToken cancellationToken)
+        {
+            await TestServices.Workspace.WaitForAsyncOperationsAsync(FeatureAttribute.NavigationBar, cancellationToken);
+
+            await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
+
+            var view = await GetActiveTextViewAsync(cancellationToken);
+            var combobox = (await GetNavigationBarComboBoxesAsync(view, cancellationToken))[(int)index];
+            return combobox.SelectedItem?.ToString();
+        }
+
+        public async Task SelectNavigationBarItemAsync(NavigationBarDropdownKind index, string item, CancellationToken cancellationToken)
+        {
+            await TestServices.Workspace.WaitForAsyncOperationsAsync(FeatureAttribute.NavigationBar, cancellationToken);
+
+            await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
+
+            var itemIndex = await GetNavigationBarItemIndexAsync(index, item, cancellationToken);
+            if (itemIndex < 0)
+            {
+                Assert.Contains(item, await GetNavigationBarItemsAsync(index, cancellationToken));
+                throw ExceptionUtilities.Unreachable;
+            }
+
+            await ExpandNavigationBarAsync(index, cancellationToken);
+            await TestServices.Input.SendAsync(VirtualKey.Home);
+            for (var i = 0; i < itemIndex; i++)
+            {
+                await TestServices.Input.SendAsync(VirtualKey.Down);
+            }
+
+            await TestServices.Input.SendAsync(VirtualKey.Enter);
+
+            // Navigation and/or code generation following selection is tracked under FeatureAttribute.NavigationBar
+            await TestServices.Workspace.WaitForAsyncOperationsAsync(FeatureAttribute.NavigationBar, cancellationToken);
+        }
+
+        public async Task<int> GetNavigationBarItemIndexAsync(NavigationBarDropdownKind index, string item, CancellationToken cancellationToken)
+        {
+            var items = await GetNavigationBarItemsAsync(index, cancellationToken);
+            return items.IndexOf(item);
+        }
+
+        public async Task<bool> IsNavigationBarEnabledAsync(CancellationToken cancellationToken)
+        {
+            await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
+
+            var view = await GetActiveTextViewAsync(cancellationToken);
+            return (await GetNavigationBarMarginAsync(view, cancellationToken)) is not null;
+        }
+
+        private async Task<List<ComboBox>> GetNavigationBarComboBoxesAsync(IWpfTextView textView, CancellationToken cancellationToken)
+        {
+            await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
+
+            var margin = await GetNavigationBarMarginAsync(textView, cancellationToken);
+            return margin.GetFieldValue<List<ComboBox>>("_combos");
+        }
+
+        private async Task<UIElement?> GetNavigationBarMarginAsync(IWpfTextView textView, CancellationToken cancellationToken)
+        {
+            await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
+
+            var editorAdaptersFactoryService = await GetComponentModelServiceAsync<IVsEditorAdaptersFactoryService>(cancellationToken);
+            var viewAdapter = editorAdaptersFactoryService.GetViewAdapter(textView);
+            Assumes.Present(viewAdapter);
+
+            // Make sure we have the top pane
+            //
+            // The docs are wrong. When a secondary view exists, it is the secondary view which is on top. The primary
+            // view is only on top when there is no secondary view.
+            var codeWindow = TryGetCodeWindow(viewAdapter);
+            Assumes.Present(codeWindow);
+
+            if (ErrorHandler.Succeeded(codeWindow.GetSecondaryView(out var secondaryViewAdapter)))
+            {
+                viewAdapter = secondaryViewAdapter;
+            }
+
+            var textViewHost = editorAdaptersFactoryService.GetWpfTextViewHost(viewAdapter);
+            Assumes.Present(textViewHost);
+
+            var dropDownMargin = textViewHost.GetTextViewMargin("DropDownMargin");
+            if (dropDownMargin != null)
+            {
+                return ((Decorator)dropDownMargin.VisualElement).Child;
+            }
+
+            return null;
+
+            static IVsCodeWindow? TryGetCodeWindow(IVsTextView textView)
+            {
+                if (textView is not IObjectWithSite objectWithSite)
+                {
+                    return null;
+                }
+
+                var riid = typeof(IOleServiceProvider).GUID;
+                objectWithSite.GetSite(ref riid, out var ppvSite);
+                if (ppvSite == IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                IOleServiceProvider? oleServiceProvider = null;
+                try
+                {
+                    oleServiceProvider = Marshal.GetObjectForIUnknown(ppvSite) as IOleServiceProvider;
+                }
+                finally
+                {
+                    Marshal.Release(ppvSite);
+                }
+
+                if (oleServiceProvider == null)
+                {
+                    return null;
+                }
+
+                var guidService = typeof(SVsWindowFrame).GUID;
+                riid = typeof(IVsWindowFrame).GUID;
+                if (ErrorHandler.Failed(oleServiceProvider.QueryService(ref guidService, ref riid, out var ppvObject)) || ppvObject == IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                IVsWindowFrame? frame = null;
+                try
+                {
+                    frame = (IVsWindowFrame)Marshal.GetObjectForIUnknown(ppvObject);
+                }
+                finally
+                {
+                    Marshal.Release(ppvObject);
+                }
+
+                riid = typeof(IVsCodeWindow).GUID;
+                if (ErrorHandler.Failed(frame.QueryViewInterface(ref riid, out ppvObject)) || ppvObject == IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                try
+                {
+                    return Marshal.GetObjectForIUnknown(ppvObject) as IVsCodeWindow;
+                }
+                finally
+                {
+                    Marshal.Release(ppvObject);
+                }
+            }
+        }
+
+        #endregion
+
         public async Task DismissLightBulbSessionAsync(CancellationToken cancellationToken)
         {
             await JoinableTaskFactory.SwitchToMainThreadAsync(cancellationToken);
@@ -176,6 +368,17 @@ public async Task InvokeCodeActionListAsync(CancellationToken cancellationToken)
             await TestServices.Workspace.WaitForAsyncOperationsAsync(FeatureAttribute.SolutionCrawler, cancellationToken);
             await TestServices.Workspace.WaitForAsyncOperationsAsync(FeatureAttribute.DiagnosticService, cancellationToken);
 
+            if (Version.Parse("17.1.31916.450") > await TestServices.Shell.GetVersionAsync(cancellationToken))
+            {
+                // Workaround for extremely unstable async lightbulb prior to:
+                // https://devdiv.visualstudio.com/DevDiv/_git/VS-Platform/pullrequest/361759
+                await TestServices.Input.SendAsync(new KeyPress(VirtualKey.Period, ShiftState.Ctrl));
+                await Task.Delay(5000, cancellationToken);
+
+                await TestServices.Editor.DismissLightBulbSessionAsync(cancellationToken);
+                await Task.Delay(5000, cancellationToken);
+            }
+
             await ShowLightBulbAsync(cancellationToken);
             await TestServices.Workspace.WaitForAsyncOperationsAsync(FeatureAttribute.LightBulb, cancellationToken);
         }

src/VisualStudio/IntegrationTest/New.IntegrationTests/InProcess/EditorVerifierInProcess.cs

@@ -12,6 +12,7 @@
 using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.VisualStudio.IntegrationTest.Utilities;
 using Roslyn.Utilities;
+using Xunit;
 
 namespace Roslyn.VisualStudio.IntegrationTests.InProcess
 {
@@ -22,6 +23,94 @@ public EditorVerifierInProcess(TestServices testServices)
         {
         }
 
+        public async Task CurrentLineTextAsync(
+            string expectedText,
+            bool assertCaretPosition = false,
+            CancellationToken cancellationToken = default)
+        {
+            if (assertCaretPosition)
+            {
+                await CurrentLineTextAndAssertCaretPositionAsync(expectedText, cancellationToken);
+            }
+            else
+            {
+                var view = await TestServices.Editor.GetActiveTextViewAsync(cancellationToken);
+                var lineText = view.Caret.Position.BufferPosition.GetContainingLine().GetText();
+                Assert.Equal(expectedText, lineText);
+            }
+        }
+
+        private async Task CurrentLineTextAndAssertCaretPositionAsync(
+            string expectedText,
+            CancellationToken cancellationToken)
+        {
+            var expectedCaretIndex = expectedText.IndexOf("$$");
+            if (expectedCaretIndex < 0)
+            {
+                throw new ArgumentException("Expected caret position to be specified with $$", nameof(expectedText));
+            }
+
+            var expectedCaretMarkupEndIndex = expectedCaretIndex + "$$".Length;
+
+            var expectedTextBeforeCaret = expectedText.Substring(0, expectedCaretIndex);
+            var expectedTextAfterCaret = expectedText.Substring(expectedCaretMarkupEndIndex);
+
+            var view = await TestServices.Editor.GetActiveTextViewAsync(cancellationToken);
+            var bufferPosition = view.Caret.Position.BufferPosition;
+            var line = bufferPosition.GetContainingLine();
+            var lineText = line.GetText();
+            var lineTextBeforeCaret = lineText[..(bufferPosition.Position - line.Start)];
+            var lineTextAfterCaret = lineText[(bufferPosition.Position - line.Start)..];
+
+            Assert.Equal(expectedTextBeforeCaret, lineTextBeforeCaret);
+            Assert.Equal(expectedTextAfterCaret, lineTextAfterCaret);
+            Assert.Equal(expectedTextBeforeCaret.Length + expectedTextAfterCaret.Length, lineText.Length);
+        }
+
+        public async Task TextContainsAsync(
+            string expectedText,
+            bool assertCaretPosition = false,
+            CancellationToken cancellationToken = default)
+        {
+            if (assertCaretPosition)
+            {
+                await TextContainsAndAssertCaretPositionAsync(expectedText, cancellationToken);
+            }
+            else
+            {
+                var view = await TestServices.Editor.GetActiveTextViewAsync(cancellationToken);
+                var editorText = view.TextSnapshot.GetText();
+                Assert.Contains(expectedText, editorText);
+            }
+        }
+
+        private async Task TextContainsAndAssertCaretPositionAsync(
+            string expectedText,
+            CancellationToken cancellationToken)
+        {
+            var caretStartIndex = expectedText.IndexOf("$$");
+            if (caretStartIndex < 0)
+            {
+                throw new ArgumentException("Expected caret position to be specified with $$", nameof(expectedText));
+            }
+
+            var caretEndIndex = caretStartIndex + "$$".Length;
+
+            var expectedTextBeforeCaret = expectedText[..caretStartIndex];
+            var expectedTextAfterCaret = expectedText[caretEndIndex..];
+
+            var expectedTextWithoutCaret = expectedTextBeforeCaret + expectedTextAfterCaret;
+
+            var view = await TestServices.Editor.GetActiveTextViewAsync(cancellationToken);
+            var editorText = view.TextSnapshot.GetText();
+            Assert.Contains(expectedTextWithoutCaret, editorText);
+
+            var index = editorText.IndexOf(expectedTextWithoutCaret);
+
+            var caretPosition = await TestServices.Editor.GetCaretPositionAsync(cancellationToken);
+            Assert.Equal(caretStartIndex + index, caretPosition);
+        }
+
         public async Task CodeActionAsync(
             string expectedItem,
             bool applyFix = false,
@@ -113,5 +202,10 @@ public async Task CodeActionsNotShowingAsync(CancellationToken cancellationToken
                 throw new InvalidOperationException("Expected no light bulb session, but one was found.");
             }
         }
+
+        public async Task CaretPositionAsync(int expectedCaretPosition, CancellationToken cancellationToken)
+        {
+            Assert.Equal(expectedCaretPosition, await TestServices.Editor.GetCaretPositionAsync(cancellationToken));
+        }
     }
 }