src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_DefaultsSource.vb - main - githubmirror/roslyn

src/EditorFeatures/Test2/IntelliSense/CSharpCompletionCommandHandlerTests_DefaultsSource.vb
722 строки31 KB
Tomáš Matoušek
Refactoring of extension methods in source packages (#78620) - take 2 (#78894)
26 июн 2025, 18:42
26 июн 2025, 18:4205fc006
' Licensed to the .NET Foundation under one or more agreements.
' The .NET Foundation licenses this file to you under the MIT license.
' See the LICENSE file in the project root for more information.

Imports System.Collections.Immutable
Imports System.Composition
Imports System.Threading
Imports Microsoft.CodeAnalysis.Collections
Imports Microsoft.CodeAnalysis.Completion
Imports Microsoft.CodeAnalysis.Completion.Providers
Imports Microsoft.CodeAnalysis.CSharp.Completion
Imports Microsoft.CodeAnalysis.Editor.Implementation.IntelliSense.AsyncCompletion
Imports Microsoft.CodeAnalysis.Host.Mef
Imports Microsoft.CodeAnalysis.Options
Imports Microsoft.CodeAnalysis.PooledObjects
Imports Microsoft.CodeAnalysis.Shared.TestHooks
Imports Microsoft.CodeAnalysis.Text
Imports Microsoft.VisualStudio.Language.Intellisense.AsyncCompletion
Imports Microsoft.VisualStudio.Text.Editor

Namespace Microsoft.CodeAnalysis.Editor.UnitTests.IntelliSense
    <[UseExportProvider]>
    <Trait(Traits.Feature, Traits.Features.Completion)>
    Public Class CSharpCompletionCommandHandlerTests_DefaultsSource

        Private Shared Async Function AssertCompletionItemsContainPromotedItem(state As TestState, displayText As String) As Task
            Dim x As Integer
            Await state.AssertCompletionItemsContain(Function(i) i.DisplayText = displayText AndAlso i.DisplayTextSuffix = "" AndAlso Helpers.TryGetOriginalIndexOfPromotedItem(i, x))
        End Function

        Private Shared Sub AssertCompletionItemsInRelativeOrder(state As TestState, expectedItems As List(Of ValueTuple(Of String, Boolean)))

            Dim list = state.GetCompletionItems()
            Dim current = 0
            For Each item In list

                If current = expectedItems.Count Then
                    Exit For
                End If

                Dim currentExpectedItem = expectedItems(current)
                If item.DisplayText = currentExpectedItem.Item1 Then
                    Dim x As Integer
                    Assert.Equal(currentExpectedItem.Item2, Helpers.TryGetOriginalIndexOfPromotedItem(item, x))

                    current += 1
                End If
            Next
        End Sub

        <WpfFact>
        Public Async Function TestNoItemMatchesDefaults_NoMatchingItem() As Task
            ' We are not adding the additional file which contains type MyAB and MyA
            ' the the suggestion from default source doesn't match anything in the completion list.
            Using state = TestStateFactory.CreateCSharpTestState(
                              <Document>
class C
{
    void MyMethod()
    {
        My$$
    }
}
                              </Document>,
                              extraExportedTypes:={GetType(MockDefaultSource)}.ToList())

                MockDefaultSource.Defaults = ImmutableArray.Create("MyAB", "MyA")

                state.SendInvokeCompletionList()

                Await state.AssertCompletionItemsDoNotContainAny("MyAB", "MyA", "★ MyAB", "★ MyA")
                Await state.AssertSelectedCompletionItem("MyMethod", isHardSelected:=True)
            End Using
        End Function

        <WpfFact>
        Public Async Function TestNoItemMatchesDefaults_NoDefaultProvided() As Task
            Using state = CreateTestStateWithAdditionalDocumentAndMockDefaultSource(
                              <Document>
using NS1;
class C
{
    void MyMethod()
    {
        My$$
    }
}
                              </Document>)

                ' We are not setting any default
                MockDefaultSource.Defaults = ImmutableArray(Of String).Empty

                state.SendInvokeCompletionList()

                Await state.AssertCompletionItemsDoNotContainAny("★ MyAB", "★ MyA")
                Await state.AssertCompletionItemsContainAll("MyAB", "MyA", "MyMethod")
                Await state.AssertSelectedCompletionItem("MyA", isHardSelected:=True)

            End Using
        End Function

        <WpfFact>
        <WorkItem("https://github.com/dotnet/roslyn/issues/61120")>
        Public Async Function SelectFirstMatchingDefaultIfNoFilterText() As Task
            Using state = CreateTestStateWithAdditionalDocumentAndMockDefaultSource(
                              <Document>
using NS1;
class C
{
    void Method()
    {
        $$
    }
}
                              </Document>)

                MockDefaultSource.Defaults = ImmutableArray.Create("MyAB", "MyA")

                state.SendInvokeCompletionList()

                Dim expectedItems = New List(Of ValueTuple(Of String, Boolean)) From {
                    CreateExpectedItem("★ MyAB", isPromoted:=True),
                    CreateExpectedItem("★ MyA", isPromoted:=True),
                    CreateExpectedItem("MyA", isPromoted:=False),
                    CreateExpectedItem("MyAB", isPromoted:=False),
                    CreateExpectedItem("MyMethod", isPromoted:=False)
                }

                AssertCompletionItemsInRelativeOrder(state, expectedItems)

                Await state.AssertSelectedCompletionItem("★ MyAB", isHardSelected:=False)
            End Using
        End Function

        Private Shared Function CreateExpectedItem(displayText As String, isPromoted As Boolean) As ValueTuple(Of String, Boolean)
            Return New ValueTuple(Of String, Boolean)(displayText, isPromoted)
        End Function

        <WpfFact>
        Public Async Function SelectFirstMatchingDefaultWithPrefixFilterText() As Task
            Using state = CreateTestStateWithAdditionalDocumentAndMockDefaultSource(
                              <Document>
using NS1;
class C
{
    void MyMethod()
    {
        My$$
    }
}
                              </Document>)

                MockDefaultSource.Defaults = ImmutableArray.Create("MyAB", "MyA")

                state.SendInvokeCompletionList()

                Dim expectedItems = New List(Of ValueTuple(Of String, Boolean)) From {
                    CreateExpectedItem("★ MyAB", isPromoted:=True),
                    CreateExpectedItem("★ MyA", isPromoted:=True),
                    CreateExpectedItem("MyA", isPromoted:=False),
                    CreateExpectedItem("MyAB", isPromoted:=False),
                    CreateExpectedItem("MyMethod", isPromoted:=False)
                }

                AssertCompletionItemsInRelativeOrder(state, expectedItems)

                Await state.AssertSelectedCompletionItem("★ MyAB", isHardSelected:=True)
            End Using
        End Function

        <WpfFact>
        Public Async Function DoNotChangeSelectionIfBetterMatch_CaseSensitivePrefix() As Task
            Using state = CreateTestStateWithAdditionalDocumentAndMockDefaultSource(
                              <Document>
using NS1;
class C
{
    void Method(int my)
    {
        m$$
    }
}
                              </Document>)

                MockDefaultSource.Defaults = ImmutableArray.Create("MyAB", "MyA")

                state.SendInvokeCompletionList()

                Dim expectedItems = New List(Of ValueTuple(Of String, Boolean)) From {
                    CreateExpectedItem("my", isPromoted:=False),
                    CreateExpectedItem("★ MyA", isPromoted:=True),
                    CreateExpectedItem("MyA", isPromoted:=False),
                    CreateExpectedItem("★ MyAB", isPromoted:=True),
                    CreateExpectedItem("MyAB", isPromoted:=False)
                }

                AssertCompletionItemsInRelativeOrder(state, expectedItems)
                Await state.AssertSelectedCompletionItem("my", isHardSelected:=True)

            End Using
        End Function

        <WpfFact>
        Public Async Function DoNotChangeSelectionIfBetterMatch_ExactOverPrefix() As Task
            Using state = CreateTestStateWithAdditionalDocumentAndMockDefaultSource(
                              <Document>
using NS1;
class My
{
    void Method()
    {
        My$$
    }
}
                              </Document>)

                MockDefaultSource.Defaults = ImmutableArray.Create("MyAB", "MyA")

                state.SendInvokeCompletionList()

                Dim expectedItems = New List(Of ValueTuple(Of String, Boolean)) From {
                    CreateExpectedItem("My", isPromoted:=False),
                    CreateExpectedItem("★ MyA", isPromoted:=True),
                    CreateExpectedItem("MyA", isPromoted:=False),
                    CreateExpectedItem("★ MyAB", isPromoted:=True),
                    CreateExpectedItem("MyAB", isPromoted:=False)
                }

                AssertCompletionItemsInRelativeOrder(state, expectedItems)
                Await state.AssertSelectedCompletionItem("My", isHardSelected:=True)

            End Using
        End Function

        <WpfFact>
        Public Async Function DoNotChangeIfPreselection() As Task
            Using state = CreateTestStateWithAdditionalDocumentAndMockDefaultSource(
                              <Document>
using NS1;
class C
{
    void Method()
    {
        C x = new $$
    }
}
                              </Document>)

                MockDefaultSource.Defaults = ImmutableArray.Create("MyAB", "MyA")

                state.SendInvokeCompletionList()

                Dim expectedItems = New List(Of ValueTuple(Of String, Boolean)) From {
                    CreateExpectedItem("★ MyAB", isPromoted:=True),
                    CreateExpectedItem("★ MyA", isPromoted:=True),
                    CreateExpectedItem("C", isPromoted:=False),
                    CreateExpectedItem("MyA", isPromoted:=False),
                    CreateExpectedItem("MyAB", isPromoted:=False)
                }

                AssertCompletionItemsInRelativeOrder(state, expectedItems)

                ' "C" is an item with preselect priority
                Await state.AssertSelectedCompletionItem("C", isHardSelected:=True)
            End Using
        End Function

        Private Shared Function CreateTestStateWithAdditionalDocumentAndMockDefaultSource(documentElement As XElement) As TestState
            Return TestStateFactory.CreateTestStateFromWorkspace(
                <Workspace>
                    <Project Language="C#" LanguageVersion="Preview" CommonReferences="true">
                        <ProjectReference>RefProj</ProjectReference>
                        <Document FilePath="C.cs">
                            <%= documentElement.Value %>
                        </Document>
                    </Project>
                    <Project Language="C#" AssemblyName="RefProj" CommonReferences="true">
                        <Document><![CDATA[
namespace NS1
{
    public class MyA
    {
    }
    public class MyAB
    {
    }
}
                        ]]></Document>
                    </Project>
                </Workspace>,
                extraExportedTypes:={GetType(MockDefaultSource)}.ToList())
        End Function

        <ComponentModel.Composition.Export(GetType(IAsyncCompletionDefaultsSource))>
        <VisualStudio.Utilities.Name(NameOf(MockDefaultSource))>
        <VisualStudio.Utilities.ContentType(ContentTypeNames.RoslynContentType)>
        <TextViewRole(PredefinedTextViewRoles.Document)>
        Private Class MockDefaultSource
            Implements IAsyncCompletionDefaultsSource

            Public Shared Defaults As ImmutableArray(Of String) = ImmutableArray(Of String).Empty

            <ComponentModel.Composition.ImportingConstructor>
            <Obsolete(MefConstruction.ImportingConstructorMessage, True)>
            Public Sub New()
            End Sub

            Public Function GetSessionDefaultsAsync(session As IAsyncCompletionSession) As Task(Of ImmutableArray(Of String)) Implements IAsyncCompletionDefaultsSource.GetSessionDefaultsAsync
                Return Task.FromResult(Defaults)
            End Function
        End Class

        <WpfFact>
        Public Async Function SelectDefaultItemOverStarredItem_WithPromotion() As Task
            Using state = TestStateFactory.CreateCSharpTestState(
                <Document>
class MyClass 
{                          
    public bool FirstStarred()  => true;
    public bool SecondStarred() => true;
    public bool FirstDefault()  => true;
}
class Test
{
    void M(MyClass c)
    {
        c$$
    }
}
                </Document>,
                extraExportedTypes:={GetType(IntelliCodeMockProvider), GetType(MockDefaultSource)}.ToList())

                MockDefaultSource.Defaults = ImmutableArray.Create("FirstDefault")
                state.SendTypeChars(".")

                Dim expectedItems1 = New List(Of ValueTuple(Of String, Boolean)) From {
                    CreateExpectedItem("★ FirstDefault", isPromoted:=True),
                    CreateExpectedItem("★ FirstStarred", isPromoted:=False),
                    CreateExpectedItem("★ SecondStarred", isPromoted:=False),
                    CreateExpectedItem("FirstDefault", isPromoted:=False),
                    CreateExpectedItem("FirstStarred", isPromoted:=False),
                    CreateExpectedItem("SecondStarred", isPromoted:=False)
                }

                AssertCompletionItemsInRelativeOrder(state, expectedItems1)
                Await state.AssertSelectedCompletionItem("★ FirstDefault", isHardSelected:=False)

                Dim expectedItems2 = New List(Of ValueTuple(Of String, Boolean)) From {
                    CreateExpectedItem("★ FirstDefault", isPromoted:=True),
                    CreateExpectedItem("FirstDefault", isPromoted:=False),
                    CreateExpectedItem("★ FirstStarred", isPromoted:=False),
                    CreateExpectedItem("FirstStarred", isPromoted:=False)
                }

                state.SendTypeChars("First")
                AssertCompletionItemsInRelativeOrder(state, expectedItems2)
                Await state.AssertSelectedCompletionItem("★ FirstDefault", isHardSelected:=True)

                Dim expectedItems3 = New List(Of ValueTuple(Of String, Boolean)) From {
                    CreateExpectedItem("★ FirstStarred", isPromoted:=False),
                    CreateExpectedItem("FirstStarred", isPromoted:=False)
                }

                state.SendTypeChars("S")
                AssertCompletionItemsInRelativeOrder(state, expectedItems3)
                Await state.AssertSelectedCompletionItem("★ FirstStarred", isHardSelected:=True)
            End Using
        End Function

        <WpfFact>
        Public Async Function SelectStarredItemInDefaultList_NoPromotion() As Task
            Using state = TestStateFactory.CreateCSharpTestState(
                <Document>
class MyClass 
{                          
    public bool FirstStarred()  => true;
    public bool SecondStarred() => true;
    public bool FirstDefault()  => true;
}
class Test
{
    void M(MyClass c)
    {
        c$$
    }
}
                </Document>,
                extraExportedTypes:={GetType(IntelliCodeMockProvider), GetType(MockDefaultSource)}.ToList())

                MockDefaultSource.Defaults = ImmutableArray.Create("SecondStarred")
                state.SendTypeChars(".")

                Dim expectedItems1 = New List(Of ValueTuple(Of String, Boolean)) From {
                    CreateExpectedItem("★ FirstStarred", isPromoted:=False),
                    CreateExpectedItem("★ SecondStarred", isPromoted:=False),
                    CreateExpectedItem("FirstDefault", isPromoted:=False),
                    CreateExpectedItem("FirstStarred", isPromoted:=False),
                    CreateExpectedItem("SecondStarred", isPromoted:=False)
                }

                AssertCompletionItemsInRelativeOrder(state, expectedItems1)
                Await state.AssertSelectedCompletionItem("★ SecondStarred", isHardSelected:=False)

                Dim expectedItems2 = New List(Of ValueTuple(Of String, Boolean)) From {
                    CreateExpectedItem("★ FirstStarred", isPromoted:=False),
                    CreateExpectedItem("★ SecondStarred", isPromoted:=False),
                    CreateExpectedItem("FirstStarred", isPromoted:=False),
                    CreateExpectedItem("SecondStarred", isPromoted:=False)
                }

                state.SendTypeChars("starred")
                AssertCompletionItemsInRelativeOrder(state, expectedItems2)
                Await state.AssertSelectedCompletionItem("★ SecondStarred", isHardSelected:=True)
            End Using
        End Function

        <ExportCompletionProvider(NameOf(IntelliCodeMockProvider), LanguageNames.CSharp)>
        <[Shared]>
        <PartNotDiscoverable>
        Private Class IntelliCodeMockProvider
            Inherits CompletionProvider

            <ImportingConstructor>
            <Obsolete(MefConstruction.ImportingConstructorMessage, True)>
            Public Sub New()
            End Sub

            Public Overrides Function ProvideCompletionsAsync(context As CompletionContext) As Task
                ' Pythia sets the priority to Preselect
                Dim rules = CompletionItemRules.Default.WithSelectionBehavior(CompletionItemSelectionBehavior.HardSelection).WithMatchPriority(MatchPriority.Preselect)
                context.AddItem(CompletionItem.Create(displayText:="★ FirstStarred", filterText:="FirstStarred", sortText:=GetSortText(1), rules:=rules))
                context.AddItem(CompletionItem.Create(displayText:="★ SecondStarred", filterText:="SecondStarred", sortText:=GetSortText(2), rules:=rules))
                Return Task.CompletedTask
            End Function

            ' This is what Pythia uses to sort starred items to the top of completion list
            Private Shared Function GetSortText(index As Integer) As String
                Return "!" + index.ToString("D10")
            End Function

            Public Overrides Function ShouldTriggerCompletion(text As SourceText, caretPosition As Integer, trigger As CompletionTrigger, options As OptionSet) As Boolean
                Return True
            End Function
        End Class

        <WpfFact>
        Public Async Function CommitPromotedItemShouldNotIncludeStar() As Task
            Using state = TestStateFactory.CreateCSharpTestState(
                <Document>
class Test
{
    void M()
    {
        $$
    }
}
                </Document>,
                extraExportedTypes:={GetType(MockDefaultSource)}.ToList())

                MockDefaultSource.Defaults = ImmutableArray.Create("if")
                state.SendInvokeCompletionList()

                Dim expectedItems1 = New List(Of ValueTuple(Of String, Boolean)) From {
                    CreateExpectedItem("★ if", isPromoted:=True),
                    CreateExpectedItem("if", isPromoted:=False)
                }

                AssertCompletionItemsInRelativeOrder(state, expectedItems1)
                Await state.AssertSelectedCompletionItem("★ if", isHardSelected:=False)

                state.SendTab()
                Await state.AssertNoCompletionSession()
                Dim committedLine = state.GetLineTextFromCaretPosition()
                Assert.DoesNotContain("★", committedLine, StringComparison.Ordinal)
                Assert.Contains("if", committedLine, StringComparison.Ordinal)
            End Using
        End Function

        <WpfTheory, CombinatorialData>
        Public Async Function TestAutoHidingExpandedItems(afterDot As Boolean, responsiveTypingEnabled As Boolean) As Task
            Dim text As String
            If afterDot Then
                text = "this."
            Else
                text = String.Empty
            End If

            Using state = TestStateFactory.CreateCSharpTestState(
                <Document>
                    <%= text %>$$
                </Document>,
                excludedTypes:={GetType(CSharpCompletionService.Factory)}.ToList(),
                extraExportedTypes:={GetType(MockCompletionServiceFactory)}.ToList())

                Dim workspace = state.Workspace
                workspace.GlobalOptions.SetGlobalOption(CompletionOptionsStorage.ShowItemsFromUnimportedNamespaces, LanguageNames.CSharp, True)

                state.TextView.Options.SetOptionValue(DefaultOptions.ResponsiveCompletionOptionId, responsiveTypingEnabled)

                Dim completionService = DirectCast(workspace.Services.GetLanguageServices(LanguageNames.CSharp).GetRequiredService(Of CompletionService)(), MockCompletionServiceFactory.Service)

                If Not responsiveTypingEnabled And afterDot Then
                    ' we'd block on expanded items when responsive completion is disabled and triggered after a dot
                    ' so make sure the checkpoint is released first
                    completionService.ExpandedItemsCheckpoint.Release()

                    Await state.SendInvokeCompletionListAndWaitForUiRenderAsync()
                    state.AssertCompletionItemExpander(isAvailable:=True, isSelected:=True)
                    Dim items = state.GetCompletionItems()
                    Assert.Equal(completionService.RegularCount + completionService.ExpandedCount, items.Count)
                    Assert.Equal(completionService.ExpandedCount, items.Where(Function(x) x.Flags.IsExpanded()).Count())
                Else
                    ' we blocked the expanded item task, so only regular items in the list
                    ' this is true even with responsive typing disabled, since the filter text is empty.
                    Await state.SendInvokeCompletionListAndWaitForUiRenderAsync()
                    state.AssertCompletionItemExpander(isAvailable:=True, isSelected:=False)
                    Dim items = state.GetCompletionItems()
                    Assert.Equal(completionService.RegularCount, items.Count)
                    Assert.False(items.Any(Function(i) i.Flags.IsExpanded()))

                    ' make sure expanded item task completes
                    completionService.ExpandedItemsCheckpoint.Release()
                    Dim session = Await state.GetCompletionSession()
                    Dim sessionData = CompletionSessionData.GetOrCreateSessionData(session)
                    Assert.NotNull(sessionData.ExpandedItemsTask)
                    Await sessionData.ExpandedItemsTask
                End If

                Dim typedChars = "Item"
                For i = 0 To typedChars.Length - 1
                    Await state.SendTypeCharsAndWaitForUiRenderAsync(typedChars(i))
                    Dim items = state.GetCompletionItems()
                    Dim expandedCount As Integer

                    If (Not afterDot And i < ItemManager.FilterTextLengthToExcludeExpandedItemsExclusive - 1) Then
                        expandedCount = 0
                    Else
                        expandedCount = completionService.ExpandedCount
                    End If

                    Assert.True((completionService.RegularCount + expandedCount) = items.Count, $"Typed char: '{typedChars(i)}', expected: {completionService.RegularCount + expandedCount}, actual: {items.Count} ")
                    Assert.Equal(expandedCount, items.Where(Function(x) x.Flags.IsExpanded()).Count())
                Next

                ' once we show expanded items, we will not hide it in the same session, even if filter text became shorter
                For i = 1 To 4
                    state.SendBackspace()
                    Dim items = state.GetCompletionItems()
                    Assert.True((completionService.RegularCount + completionService.ExpandedCount) = items.Count, $"Backspace number: {i}expected: {completionService.RegularCount + completionService.ExpandedCount}, actual: {items.Count} ")
                    Assert.Equal(completionService.ExpandedCount, items.Where(Function(x) x.Flags.IsExpanded()).Count())
                Next
            End Using
        End Function

        <WpfFact>
        Public Async Function TestAutoHidingExpandedItemsWithDefaults() As Task
            Using state = TestStateFactory.CreateCSharpTestState(
                <Document>
$$
                </Document>,
                excludedTypes:={GetType(CSharpCompletionService.Factory)}.ToList(),
                extraExportedTypes:={GetType(MockCompletionServiceFactory), GetType(MockDefaultSource)}.ToList())

                Dim workspace = state.Workspace
                workspace.GlobalOptions.SetGlobalOption(CompletionOptionsStorage.ShowItemsFromUnimportedNamespaces, LanguageNames.CSharp, True)
                state.TextView.Options.SetOptionValue(DefaultOptions.ResponsiveCompletionOptionId, True)

                Dim completionService = DirectCast(workspace.Services.GetLanguageServices(LanguageNames.CSharp).GetRequiredService(Of CompletionService)(), MockCompletionServiceFactory.Service)
                MockDefaultSource.Defaults = ImmutableArray.Create("ItemExpanded1")

                ' we blocked the expanded item task, so only regular items in the list
                Await state.SendInvokeCompletionListAndWaitForUiRenderAsync()
                state.AssertCompletionItemExpander(isAvailable:=True, isSelected:=False)
                Dim items = state.GetCompletionItems()
                Assert.Equal(completionService.RegularCount, items.Count)
                Assert.False(items.Any(Function(i) i.Flags.IsExpanded()))

                ' make sure expanded item task completes
                completionService.ExpandedItemsCheckpoint.Release()
                Dim session = Await state.GetCompletionSession()
                Dim sessionData = CompletionSessionData.GetOrCreateSessionData(session)
                Assert.NotNull(sessionData.ExpandedItemsTask)
                Await sessionData.ExpandedItemsTask

                Await state.SendInvokeCompletionListAndWaitForUiRenderAsync()
                Await state.AssertSelectedCompletionItem("★ ItemExpanded1", isHardSelected:=False)
            End Using
        End Function

        <WpfFact>
        Public Async Function TestSelectionOfPromotedDefaultItemWithEmptyFilterTextTriggeredOnArgument() As Task
            Using state = TestStateFactory.CreateCSharpTestState(
                <Document>
using System;
using System.Text;
public class Program
{
    static string Title { get; } = "";
    static void Main(string[] args)
    {
        var sb = new StringBuilder();
        sb.Append$$
    }
}
                </Document>,
                showCompletionInArgumentLists:=True,
                extraExportedTypes:={GetType(MockDefaultSource)}.ToList())

                MockDefaultSource.Defaults = ImmutableArray.Create("Title")
                state.SendTypeChars("(")

                Dim expectedItems1 = New List(Of ValueTuple(Of String, Boolean)) From {
                    CreateExpectedItem("★ Title", isPromoted:=True),
                    CreateExpectedItem("Title", isPromoted:=False)
                }

                AssertCompletionItemsInRelativeOrder(state, expectedItems1)
                Await state.AssertSelectedCompletionItem("★ Title", isHardSelected:=False)

                state.SendTypeChars("""")
                Await state.AssertLineTextAroundCaret("        sb.Append(""", "")
            End Using
        End Function

        <ExportLanguageServiceFactory(GetType(CompletionService), LanguageNames.CSharp), [Shared], PartNotDiscoverable>
        Private Class MockCompletionServiceFactory
            Implements ILanguageServiceFactory

            Private ReadOnly _listenerProvider As IAsynchronousOperationListenerProvider

            <ImportingConstructor>
            <Obsolete(MefConstruction.ImportingConstructorMessage, True)>
            Public Sub New(listenerProvider As IAsynchronousOperationListenerProvider)
                _listenerProvider = listenerProvider
            End Sub

            Public Function CreateLanguageService(languageServices As CodeAnalysis.Host.HostLanguageServices) As CodeAnalysis.Host.ILanguageService Implements ILanguageServiceFactory.CreateLanguageService
                Return New Service(languageServices.LanguageServices.SolutionServices, _listenerProvider)
            End Function

            Public Class Service
                Inherits CompletionService

                Public Property RegularCount As Integer = 10
                Public Property ExpandedCount As Integer = 10

                Public ExpandedItemsCheckpoint As New Checkpoint()

                Public Sub New(services As CodeAnalysis.Host.SolutionServices, listenerProvider As IAsynchronousOperationListenerProvider)
                    MyBase.New(services, listenerProvider)
                End Sub

                Public Overrides ReadOnly Property Language As String
                    Get
                        Return LanguageNames.CSharp
                    End Get
                End Property

                Friend Overrides Function GetRules(options As CompletionOptions) As CompletionRules
                    Return CompletionRules.Default
                End Function

                Friend Overrides Async Function GetCompletionsAsync(document As Document,
                    caretPosition As Integer,
                    options As CompletionOptions,
                    passThroughOptions As OptionSet,
                    Optional trigger As CompletionTrigger = Nothing,
                    Optional roles As ImmutableHashSet(Of String) = Nothing,
                    Optional cancellationToken As CancellationToken = Nothing) As Task(Of CompletionList)

                    Dim text = Await document.GetTextAsync(cancellationToken).ConfigureAwait(False)
                    Dim defaultItemSpan = GetDefaultCompletionListSpan(text, caretPosition)

                    Dim builder = ArrayBuilder(Of CompletionItem).GetInstance(RegularCount + ExpandedCount)
                    If (options.ExpandedCompletionBehavior = ExpandedCompletionMode.AllItems) Then
                        CreateRegularItems(builder, RegularCount)
                        Await CreateExpandedItems(builder, ExpandedCount)
                    ElseIf (options.ExpandedCompletionBehavior = ExpandedCompletionMode.ExpandedItemsOnly) Then
                        Await CreateExpandedItems(builder, ExpandedCount)
                    Else
                        CreateRegularItems(builder, RegularCount)
                    End If

                    Return CompletionList.Create(defaultItemSpan, builder.ToImmutableAndFree())
                End Function

                Friend Overrides Function ShouldTriggerCompletion(project As Project,
                    languageServices As CodeAnalysis.Host.LanguageServices,
                    text As SourceText,
                    caretPosition As Integer,
                    trigger As CompletionTrigger,
                    options As CompletionOptions,
                    passThroughOptions As OptionSet,
                    Optional roles As ImmutableHashSet(Of String) = Nothing) As Boolean
                    Return True
                End Function

                Private Async Function CreateExpandedItems(builder As ArrayBuilder(Of CompletionItem), count As Integer) As Task
                    Await ExpandedItemsCheckpoint.Task
                    For i = 1 To count
                        Dim item = ImportCompletionItem.Create(
                        $"ItemExpanded{i}",
                        arity:=0,
                        containingNamespace:="NS",
                        glyph:=Glyph.ClassPublic,
                        genericTypeSuffix:=String.Empty,
                        flags:=CompletionItemFlags.Expanded,
                        extensionMethodData:=Nothing,
                        includedInTargetTypeCompletion:=True)
                        builder.Add(item)
                    Next
                End Function

                Private Shared Sub CreateRegularItems(builder As ArrayBuilder(Of CompletionItem), count As Integer)
                    For i = 1 To count
                        builder.Add(CompletionItem.Create($"ItemRegular{i}"))
                    Next
                End Sub
            End Class
        End Class
    End Class
End Namespace