|
' 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.Completion
Imports Microsoft.CodeAnalysis.Editor.Implementation.IntelliSense.AsyncCompletion
Imports Microsoft.CodeAnalysis.Editor.UnitTests.Extensions
Imports Microsoft.CodeAnalysis.Host.Mef
Imports Microsoft.CodeAnalysis.Options
Imports Microsoft.CodeAnalysis.PooledObjects
Imports Microsoft.CodeAnalysis.Snippets
Imports Microsoft.CodeAnalysis.Tags
Imports Microsoft.CodeAnalysis.VisualBasic
Imports Microsoft.VisualStudio.Language.Intellisense.AsyncCompletion
Imports Microsoft.VisualStudio.LanguageServices.VisualBasic.Snippets
Imports Microsoft.VisualStudio.Text
Imports Microsoft.VisualStudio.Text.Projection
Imports Roslyn.Utilities
Namespace Microsoft.CodeAnalysis.Editor.UnitTests.IntelliSense
<[UseExportProvider]>
<Trait(Traits.Feature, Traits.Features.Completion)>
Public Class VisualBasicCompletionCommandHandlerTests
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/546208")>
Public Async Function MultiWordKeywordCommitBehavior() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Class C
Sub M()
$$
End Sub
End Class
</Document>)
state.SendTypeChars("on")
Await state.AssertSelectedCompletionItem("On Error GoTo", description:=String.Format(FeaturesResources._0_Keyword, "On Error GoTo") + vbCrLf + VBFeaturesResources.Enables_the_error_handling_routine_that_starts_at_the_line_specified_in_the_line_argument_The_specified_line_must_be_in_the_same_procedure_as_the_On_Error_statement_On_Error_GoTo_bracket_label_0_1_bracket)
state.SendTypeChars(" ")
Await state.AssertSelectedCompletionItem("On Error GoTo", description:=String.Format(FeaturesResources._0_Keyword, "On Error GoTo") + vbCrLf + VBFeaturesResources.Enables_the_error_handling_routine_that_starts_at_the_line_specified_in_the_line_argument_The_specified_line_must_be_in_the_same_procedure_as_the_On_Error_statement_On_Error_GoTo_bracket_label_0_1_bracket)
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/546208")>
Public Async Function MultiWordKeywordCommitBehavior2() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Class C
Sub M()
$$
End Sub
End Class
</Document>)
state.SendTypeChars("next")
Await state.AssertSelectedCompletionItem("On Error Resume Next", description:=String.Format(FeaturesResources._0_Keyword, "On Error Resume Next") + vbCrLf + VBFeaturesResources.When_a_run_time_error_occurs_execution_transfers_to_the_statement_following_the_statement_or_procedure_call_that_resulted_in_the_error)
state.SendTypeChars(" ")
Await state.AssertNoCompletionSession()
End Using
End Function
<WpfFact>
Public Async Function CompletionNotShownWhenBackspacingThroughWhitespace() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Module M
Sub Goo()
If True Then $$Console.WriteLine()
End Sub
End Module
</Document>)
state.SendBackspace()
Await state.AssertNoCompletionSession()
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/541032")>
Public Async Function CompletionNotShownWhenBackspacingThroughNewline() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Module Program
Sub Main()
If True And
$$False Then
End If
End Sub
End Module
</Document>)
state.SendBackspace()
Await state.AssertNoCompletionSession()
End Using
End Function
<WpfFact>
Public Async Function CompletionAdjustInsertionText_CommitsOnOpenParens1() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<document>
Module M
Sub FogBar()
End Sub
Sub test()
$$
End Sub
End Module
</document>)
state.SendTypeChars("Fog(")
Await state.AssertCompletionSession()
Assert.Contains(" FogBar(", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
End Using
End Function
<WpfFact>
Public Async Function CompletionUpAfterDot() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<document>
Class Program
Sub Main(args As String())
Program$$
End Sub
End Class
</document>)
Await state.AssertNoCompletionSession()
state.SendTypeChars(".")
Await state.AssertCompletionSession()
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/546432")>
Public Sub ImplementsCompletionFaultTolerance()
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Imports System
Class C
Sub Goo() Implements ICloneable$$
End Module
</Document>)
state.SendTypeChars(".")
End Using
End Sub
<WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/5487")>
Public Async Function TestCommitCharTypedAtTheBeginingOfTheFilterSpan() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Class C
Public Fuction F() As Boolean
If $$
End Function
End Class
]]></Document>)
state.SendTypeChars("tru")
Await state.AssertCompletionSession()
state.SendLeftKey()
state.SendLeftKey()
state.SendLeftKey()
Await state.AssertSelectedCompletionItem(isSoftSelected:=True)
state.SendTypeChars("(")
Assert.Equal("If (tru", state.GetLineTextFromCaretPosition().Trim())
Assert.Equal("t", state.GetCaretPoint().BufferPosition.GetChar())
End Using
End Function
<WpfFact>
Public Async Function CompletionAdjustInsertionText_CommitsOnOpenParens2() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<document>
Module M
Sub FogBar(Of T)()
End Sub
Sub test()
$$
End Sub
End Module
</document>)
state.SendTypeChars("Fog(")
Await state.AssertCompletionSession()
Assert.Contains(" FogBar(", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/543497")>
Public Async Function CompletionDismissedAfterEscape1() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<document>
Class Program
Sub Main(args As String())
Program$$
End Sub
End Class
</document>)
Await state.AssertNoCompletionSession()
state.SendTypeChars(".")
Await state.AssertCompletionSession()
state.SendEscape()
Await state.AssertNoCompletionSession()
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/543497")>
Public Async Function TestEnterOnSoftSelection1() As Task
' Code must be left-aligned because of https://github.com/dotnet/roslyn/issues/27988
Using state = TestStateFactory.CreateVisualBasicTestState(
<document>
Class Program
Shared Sub Main(args As String())
Program.$$
End Sub
End Class
</document>)
state.SendInvokeCompletionList()
Await state.AssertSelectedCompletionItem("Equals", isSoftSelected:=True)
Dim caretPos = state.GetCaretPoint().BufferPosition.Position
state.SendReturn()
state.Workspace.Documents.First().GetTextView().Caret.MoveTo(New SnapshotPoint(state.Workspace.Documents.First().GetTextBuffer().CurrentSnapshot, caretPos))
Assert.Contains("Program." + vbCrLf, state.GetLineFromCurrentCaretPosition().GetTextIncludingLineBreak(), StringComparison.Ordinal)
End Using
End Function
<WpfFact>
Public Async Function CompletionTestTab1() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<document>
Module M
Sub FogBar()
End Sub
Sub test()
$$
End Sub
End Module
</document>)
state.SendTypeChars("Fog")
state.SendTab()
Await state.AssertNoCompletionSession()
Assert.Contains(" FogBar", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
End Using
End Function
<WpfFact>
Public Async Function DotIsInserted() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<document>
Class Program
Sub Main(args As String())
$$
End Sub
End Class
</document>)
state.SendTypeChars("Progra.")
Await state.AssertCompletionSession()
Await state.AssertSelectedCompletionItem(displayText:="Equals", isSoftSelected:=True)
Assert.Contains("Program.", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
End Using
End Function
<WpfFact>
Public Async Function TestReturn1() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<document>
Class Program
Sub Main(args As String())
$$
End Sub
End Class
</document>)
state.SendTypeChars("Progra")
state.SendReturn()
Await state.AssertNoCompletionSession()
Assert.Contains(<text>
Sub Main(args As String())
Program
End Sub</text>.NormalizedValue, state.GetDocumentText(), StringComparison.Ordinal)
End Using
End Function
<WpfFact>
Public Async Function TestDown1() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<document>
Namespace N
Class A
End Class
Class B
End Class
Class C
End Class
End Namespace
Class Program
Sub Main(args As String())
N$$
End Sub
End Class
</document>)
state.SendTypeChars(".A")
Await state.AssertCompletionSession()
Await state.AssertSelectedCompletionItem(displayText:="A", isHardSelected:=True)
state.SendDownKey()
Await state.AssertSelectedCompletionItem(displayText:="B", isHardSelected:=True)
state.SendDownKey()
Await state.AssertSelectedCompletionItem(displayText:="C", isHardSelected:=True)
state.SendDownKey()
Await state.AssertSelectedCompletionItem(displayText:="C", isHardSelected:=True)
state.SendPageUp()
Await state.AssertSelectedCompletionItem(displayText:="A", isHardSelected:=True)
state.SendUpKey()
Await state.AssertSelectedCompletionItem(displayText:="A", isHardSelected:=True)
End Using
End Function
<WpfFact>
Public Async Function TestFirstCharacterDoesNotFilter1() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<document>
Namespace N
Class A
End Class
Class B
End Class
Class C
End Class
End Namespace
Class Program
Sub Main(args As String())
N$$
End Sub
End Class
</document>)
state.SendTypeChars(".A")
Await state.AssertCompletionSession()
Assert.Equal(3, state.GetCompletionItems().Count)
End Using
End Function
<WpfFact>
Public Async Function TestSecondCharacterDoesFilter1() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<document>
Namespace N
Class AAA
End Class
Class AAB
End Class
Class BB
End Class
Class CC
End Class
End Namespace
Class Program
Sub Main(args As String())
N$$
End Sub
End Class
</document>)
state.SendTypeChars(".A")
Await state.AssertCompletionSession()
Assert.Equal(4, state.GetCompletionItems().Count)
state.SendTypeChars("A")
Await state.AssertCompletionSession()
Assert.Equal(2, state.GetCompletionItems().Count)
End Using
End Function
<WpfFact>
Public Async Function TestNavigateSoftToHard() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<document>
Class Program
Shared Sub Main(args As String())
Program.$$
End Sub
End Class
</document>)
state.SendInvokeCompletionList()
Await state.AssertSelectedCompletionItem(displayText:="Equals", isSoftSelected:=True)
state.SendUpKey()
Await state.AssertSelectedCompletionItem(displayText:="Equals", isHardSelected:=True)
End Using
End Function
<WpfFact(Skip:="https://devdiv.visualstudio.com/DevDiv/_workitems/edit/1906990")>
Public Async Function TestBackspaceBeforeCompletedComputation() As Task
' Simulate a very slow completionImplementation provider.
Using state = TestStateFactory.CreateVisualBasicTestState(
<document>
Class Program
Shared Sub Main(args As String())
Program$$
End Sub
End Class
</document>,
extraExportedTypes:={GetType(TriggeredCompletionProvider)}.ToList())
Dim completionService = state.Workspace.Services.GetLanguageServices(LanguageNames.VisualBasic).GetRequiredService(Of CompletionService)()
Dim provider = completionService.GetTestAccessor().GetImportedAndBuiltInProviders(ImmutableHashSet(Of String).Empty).OfType(Of TriggeredCompletionProvider)().Single()
Await state.AssertNoCompletionSession()
state.SendTypeChars(".M")
' We should not have a session now. Note: do not block as this will just deadlock things
' since the provider will not return.
state.AssertNoCompletionSessionWithNoBlock()
' Now, navigate back.
state.SendBackspace()
' allow the provider to continue
provider.e.Set()
' At this point, completionImplementation will be available since the caret is still within the model's span.
Await state.AssertCompletionSession()
' Now, navigate back again. Completion should be dismissed
state.SendBackspace()
Await state.AssertNoCompletionSession()
End Using
End Function
<WpfFact>
Public Async Function TestNavigationBeforeCompletedComputation() As Task
' Simulate a very slow completionImplementation provider.
Using state = TestStateFactory.CreateVisualBasicTestState(
<document>
Class Program
Shared Sub Main(args As String())
Program$$
End Sub
End Class
</document>,
extraExportedTypes:={GetType(TriggeredCompletionProvider)}.ToList())
Dim completionService = state.Workspace.Services.GetLanguageServices(LanguageNames.VisualBasic).GetRequiredService(Of CompletionService)()
Dim provider = completionService.GetTestAccessor().GetImportedAndBuiltInProviders(ImmutableHashSet(Of String).Empty).OfType(Of TriggeredCompletionProvider)().Single()
Await state.AssertNoCompletionSession()
state.SendTypeChars(".Ma")
' We should not have a session now. Note: do not block as this will just deadlock things
' since the provider will not return.
state.AssertNoCompletionSessionWithNoBlock()
' Now, navigate using the caret.
state.SendMoveToPreviousCharacter()
' allow the provider to continue
provider.e.Set()
' Async provider can handle keys pressed while waiting for providers.
Await state.AssertCompletionSession()
End Using
End Function
<WpfFact>
Public Async Function TestNavigationOutBeforeCompletedComputation() As Task
' Simulate a very slow completionImplementation provider.
Using state = TestStateFactory.CreateVisualBasicTestState(
<document>
Class Program
Shared Sub Main(args As String())
Program$$
End Sub
End Class
</document>,
extraExportedTypes:={GetType(TriggeredCompletionProvider)}.ToList())
Dim completionService = state.Workspace.Services.GetLanguageServices(LanguageNames.VisualBasic).GetRequiredService(Of CompletionService)()
Dim provider = completionService.GetTestAccessor().GetImportedAndBuiltInProviders(ImmutableHashSet(Of String).Empty).OfType(Of TriggeredCompletionProvider)().Single()
Await state.AssertNoCompletionSession()
state.SendTypeChars(".Ma")
' We should not have a session now. Note: do not block as this will just deadlock things
' since the provider will not return.
state.AssertNoCompletionSessionWithNoBlock()
' Now, navigate using the caret.
state.SendDownKey()
' allow the provider to continue
provider.e.Set()
' Caret was intended to be moved out of the span.
' Therefore, we should cancel the completion And move the caret.
Await state.AssertNoCompletionSession()
Assert.Contains(" End Sub", state.GetLineFromCurrentCaretPosition().GetText(), StringComparison.Ordinal)
End Using
End Function
<WpfFact>
Public Async Function TestNavigateOutOfItemChangeSpan() As Task
' Code must be left-aligned because of https://github.com/dotnet/roslyn/issues/27988
Using state = TestStateFactory.CreateVisualBasicTestState(
<document>
Class Program
Shared Sub Main(args As String())
Program$$
End Sub
End Class
</document>)
Await state.AssertNoCompletionSession()
state.SendTypeChars(".Ma")
Await state.AssertCompletionSession()
state.SendMoveToPreviousCharacter()
Await state.AssertCompletionSession()
state.SendMoveToPreviousCharacter()
Await state.AssertCompletionSession()
state.SendMoveToPreviousCharacter()
Await state.AssertNoCompletionSession()
End Using
End Function
<WpfFact>
Public Async Function TestUndo1() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<document>
Class Program
Shared Sub Main(args As String())
Program$$
End Sub
End Class
</document>)
Await state.AssertNoCompletionSession()
state.SendTypeChars(".Ma(")
Await state.AssertCompletionSession()
Assert.Contains(".Main(", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
state.SendUndo()
Assert.Contains(".Ma(", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
End Using
End Function
<WpfFact>
Public Async Function TestCommitAfterNavigation() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<document>
Namespace N
Class A
End Class
Class B
End Class
Class C
End Class
End Namespace
Class Program
Sub Main(args As String())
N$$
End Sub
End Class
</document>)
state.SendTypeChars(".A")
Await state.AssertCompletionSession()
Await state.AssertSelectedCompletionItem(displayText:="A", isHardSelected:=True)
state.SendDownKey()
Await state.AssertSelectedCompletionItem(displayText:="B", isHardSelected:=True)
state.SendTab()
Assert.Contains(".B", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
End Using
End Function
<WpfFact>
Public Async Function TestFiltering1() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<document>
Imports System
Class c
Sub Main
$$
End Sub
End Class</document>)
state.SendTypeChars("Sy")
Await state.AssertCompletionItemsContainAll("OperatingSystem", "System")
Await state.AssertCompletionItemsDoNotContainAny("Exception", "Activator")
End Using
End Function
<WpfFact>
Public Async Function TestMSCorLibTypes() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<document>
Imports System
Class c
Inherits$$
End Class</document>)
state.SendTypeChars(" ")
Await state.AssertCompletionItemsContainAll("Attribute", "Exception")
End Using
End Function
<WpfFact>
Public Async Function TestDescription1() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<document>
<![CDATA[Imports System
''' <summary>
''' TestDoc
''' </summary>
Class TestException
Inherits Exception
End Class
Class MyException
Inherits $$
End Class]]></document>)
state.SendTypeChars("TestEx")
Await state.AssertCompletionSession()
Await state.AssertSelectedCompletionItem(description:="Class TestException" & vbCrLf & "TestDoc")
End Using
End Function
<WpfFact>
Public Async Function TestObjectCreationPreselection1() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Imports System
Imports System.Collections.Generic
Imports System.Linq
Module Program
Sub Main(args As String())
Dim x As List(Of Integer) = New$$
End Sub
End Module]]></Document>)
state.SendTypeChars(" ")
Await state.AssertSelectedCompletionItem(displayText:="List(Of Integer)", isHardSelected:=True)
Await state.AssertCompletionItemsContainAll("LinkedList", "List", "System")
state.SendTypeChars("Li")
Await state.AssertSelectedCompletionItem(displayText:="List(Of Integer)", isHardSelected:=True)
Await state.AssertCompletionItemsContainAll("LinkedList", "List")
Await state.AssertCompletionItemsDoNotContainAny("System")
state.SendTypeChars("n")
Await state.AssertSelectedCompletionItem(displayText:="LinkedList", displayTextSuffix:="(Of " & ChrW(&H2026) & ")", isHardSelected:=True)
state.SendBackspace()
Await state.AssertSelectedCompletionItem(displayText:="List(Of Integer)", isHardSelected:=True)
state.SendTab()
Assert.Contains("New List(Of Integer)", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
End Using
End Function
<WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/287")> Public Async Function NotEnumPreselectionAfterBackspace() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Enum E
Bat
End Enum
Class C
Sub Test(param As E)
Dim b As E
Test(b.$$)
End Sub
End Class]]></Document>)
state.SendBackspace()
Await state.AssertSelectedCompletionItem(displayText:="b", isHardSelected:=True)
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/543496")>
Public Async Function TestNumericLiteralWithNoMatch() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Imports System
Module Program
Sub Main(args As String())
Dim i =$$
End Sub
End Module</Document>)
state.SendTypeChars(" 0")
Await state.AssertNoCompletionSession()
state.SendReturn()
Await state.AssertNoCompletionSession()
Assert.Equal(<Document>
Imports System
Module Program
Sub Main(args As String())
Dim i = 0
End Sub
End Module</Document>.NormalizedValue, state.GetDocumentText())
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/543496")>
Public Async Function TestNumericLiteralWithPartialMatch() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Imports System
Module Program
Sub Main(args As String())
Dim i =$$
End Sub
End Module</Document>)
' Could match Int32
' kayleh 1/17/2013, but we decided to have #s always dismiss the list in bug 547287
state.SendTypeChars(" 3")
Await state.AssertNoCompletionSession()
state.SendReturn()
Await state.AssertNoCompletionSession()
Assert.Equal(<Document>
Imports System
Module Program
Sub Main(args As String())
Dim i = 3
End Sub
End Module</Document>.NormalizedValue, state.GetDocumentText())
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/543496")>
Public Async Function TestNumbersAfterLetters() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Imports System
Module Program
Sub Main(args As String())
Dim i =$$
End Sub
End Module</Document>)
' Could match Int32
state.SendTypeChars(" I3")
Await state.AssertCompletionSession()
Await state.AssertSelectedCompletionItem(displayText:="Int32", isHardSelected:=True)
state.SendReturn()
Await state.AssertNoCompletionSession()
Assert.Equal(<Document>
Imports System
Module Program
Sub Main(args As String())
Dim i = Int32
End Sub
End Module</Document>.NormalizedValue, state.GetDocumentText())
End Using
End Function
<WpfFact>
Public Async Function TestNotAfterTypingDotAfterIntegerLiteral() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
class c
sub M()
WriteLine(3$$
end sub
end class
</Document>)
state.SendTypeChars(".")
Await state.AssertNoCompletionSession()
End Using
End Function
<WpfFact>
Public Async Function TestAfterExplicitInvokeAfterDotAfterIntegerLiteral() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
class c
sub M()
WriteLine(3.$$
end sub
end class
</Document>)
state.SendInvokeCompletionList()
Await state.AssertCompletionItemsContainAll("ToString")
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/543669")>
Public Async Function TestDeleteWordToLeft() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
class c
sub M()
$$
end sub
end class
</Document>)
state.SendTypeChars("Dim i =")
Await state.AssertCompletionSession()
state.SendDeleteWordToLeft()
Await state.AssertNoCompletionSession()
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/543617")>
Public Async Function TestCompletionGenericWithOpenParen() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
class c
sub Goo(Of X)()
$$
end sub
end class
</Document>)
state.SendTypeChars("Go(")
Await state.AssertCompletionSession()
Assert.Equal(" Goo(", state.GetLineTextFromCaretPosition())
Assert.DoesNotContain("Goo(Of", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/543617")>
Public Async Function TestCompletionGenericWithSpace() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
class c
sub Goo(Of X)()
$$
end sub
end class
</Document>)
state.SendTypeChars("Go ")
Await state.AssertCompletionSession()
Assert.Equal(" Goo(Of ", state.GetLineTextFromCaretPosition())
End Using
End Function
<WpfFact>
Public Async Function CommitForImportsStatement1() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
$$
</Document>)
state.SendTypeChars("Imports Sys")
Await state.AssertSelectedCompletionItem(displayText:="System", isHardSelected:=True)
state.SendTypeChars("(")
Await state.AssertNoCompletionSession()
Assert.Contains("Imports Sys(", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
End Using
End Function
<WpfFact>
Public Async Function CommitForImportsStatement2() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
$$
</Document>)
state.SendTypeChars("Imports Sys")
Await state.AssertSelectedCompletionItem(displayText:="System", isHardSelected:=True)
state.SendTypeChars(".")
Await state.AssertCompletionSession()
Assert.Contains("Imports System.", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
End Using
End Function
<WpfFact>
Public Async Function CommitForImportsStatement3() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
$$
</Document>)
state.SendTypeChars("Imports Sys")
Await state.AssertSelectedCompletionItem(displayText:="System", isHardSelected:=True)
state.SendTypeChars(" ")
Await state.AssertNoCompletionSession()
Assert.Contains("Imports Sys ", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/544190")>
Public Async Function DoNotInsertEqualsForNamedParameterCommitWithColon() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Class Class1
Sub Method()
Test($$
End Sub
Sub Test(Optional x As Integer = 42)
End Sub
End Class
</Document>)
state.SendTypeChars("x:")
Await state.AssertNoCompletionSession()
Assert.DoesNotContain(":=", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/544190")>
Public Async Function DoInsertEqualsForNamedParameterCommitWithSpace() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Class Class1
Sub Method()
Test($$
End Sub
Sub Test(Optional x As Integer = 42)
End Sub
End Class
</Document>)
state.SendTypeChars("x")
state.SendTab()
Await state.AssertNoCompletionSession()
Assert.Contains(":=", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/544150")>
Public Async Function ConsumeHashForPreprocessorCompletion() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
$$
</Document>)
state.SendTypeChars("#re")
state.SendTab()
Await state.AssertNoCompletionSession()
Assert.Equal("#Region", state.GetLineTextFromCaretPosition())
End Using
End Function
<WpfFact>
Public Async Function EnumCompletionTriggeredOnSpace() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Enum Numeros
Uno
Dos
End Enum
Class Goo
Sub Bar(a As Integer, n As Numeros)
End Sub
Sub Baz()
Bar(0$$
End Sub
End Class
</Document>)
state.SendTypeChars(", ")
Await state.AssertSelectedCompletionItem(displayText:="Numeros.Dos", isSoftSelected:=True)
End Using
End Function
<ExportCompletionProvider(NameOf(TriggeredCompletionProvider), LanguageNames.VisualBasic)>
<[Shared]>
<PartNotDiscoverable>
Friend Class TriggeredCompletionProvider
Inherits MockCompletionProvider
Public ReadOnly e As ManualResetEvent = New ManualResetEvent(False)
<ImportingConstructor>
<Obsolete(MefConstruction.ImportingConstructorMessage, True)>
Public Sub New()
MyBase.New(getItems:=Function(t, p, c)
Return Nothing
End Function,
isTriggerCharacter:=Function(t, p) True)
End Sub
Friend Overrides ReadOnly Property Language As String
Get
Return LanguageNames.VisualBasic
End Get
End Property
Public Overrides Function ProvideCompletionsAsync(context As CompletionContext) As Task
e.WaitOne()
Return MyBase.ProvideCompletionsAsync(context)
End Function
End Class
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/544297")>
Public Async Function TestVerbatimNamedIdentifierFiltering() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Class Class1
Private Sub Test([string] As String)
Test($$
End Sub
End Class
</Document>)
state.SendTypeChars("s")
Await state.AssertCompletionSession()
Await state.AssertCompletionItemsContain("string", ":=")
state.SendTypeChars("t")
Await state.AssertCompletionSession()
Await state.AssertCompletionItemsContain("string", ":=")
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/544299")>
Public Async Function TestExclusiveNamedParameterCompletion() As Task
Using state = TestStateFactory.CreateTestStateFromWorkspace(
<Workspace>
<Project Language="Visual Basic" CommonReferences="true" LanguageVersion="15">
<Document>
Class Class1
Private Sub Test()
Goo(bool:=False,$$
End Sub
Private Sub Goo(str As String, character As Char)
End Sub
Private Sub Goo(str As String, bool As Boolean)
End Sub
End Class
</Document>
</Project>
</Workspace>)
state.SendTypeChars(" ")
Await state.AssertCompletionSession()
Assert.Equal(1, state.GetCompletionItems().Count)
Await state.AssertCompletionItemsContain("str", ":=")
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/544299")>
Public Async Function TestExclusiveNamedParameterCompletion2() As Task
Using state = TestStateFactory.CreateTestStateFromWorkspace(
<Workspace>
<Project Language="Visual Basic" CommonReferences="true" LanguageVersion="15">
<Document>
Class Goo
Private Sub Test()
Dim m As Object = Nothing
Method(obj:=m, $$
End Sub
Private Sub Method(obj As Object, num As Integer, str As String)
End Sub
Private Sub Method(dbl As Double, str As String)
End Sub
Private Sub Method(num As Integer, b As Boolean, str As String)
End Sub
Private Sub Method(obj As Object, b As Boolean, str As String)
End Sub
End Class
</Document>
</Project>
</Workspace>)
state.SendTypeChars(" ")
Await state.AssertCompletionSession()
Assert.Equal(3, state.GetCompletionItems().Count)
Await state.AssertCompletionItemsContain("b", ":=")
Await state.AssertCompletionItemsContain("num", ":=")
Await state.AssertCompletionItemsContain("str", ":=")
Assert.False(state.GetCompletionItems().Any(Function(i) i.DisplayText = "dbl" AndAlso i.DisplayTextSuffix = ":="))
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/544471")>
Public Async Function TestDoNotCrashOnEmptyParameterList() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
<Obsolete()$$>
</Document>)
state.SendTypeChars(" ")
Await state.AssertNoCompletionSession()
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/544628")>
Public Async Function OnlyMatchOnLowercaseIfPrefixWordMatch() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Module Program
$$
End Module
</Document>)
state.SendTypeChars("z")
Await state.AssertCompletionSession()
Await state.AssertSelectedCompletionItem("#Const", isSoftSelected:=True)
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/544989")>
Public Async Function MyBaseFinalize() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Class C
Protected Overrides Sub Finalize()
MyBase.Finalize$$
End Sub
End Class
</Document>)
state.SendTypeChars("(")
Await state.AssertSignatureHelpSession()
Await state.AssertSignatureHelpItemsContainAll({"Object.Finalize()"})
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/551117")>
Public Async Function TestNamedParameterSortOrder() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Imports System
Module Program
Sub Main(args As String())
Main($$
End Sub
End Module
</Document>)
state.SendTypeChars("a")
Await state.AssertCompletionSession()
Await state.AssertSelectedCompletionItem("args", isHardSelected:=True)
state.SendDownKey()
Await state.AssertSelectedCompletionItem("args", displayTextSuffix:=":=", isHardSelected:=True)
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/546810")>
Public Async Function TestLineContinuationCharacter() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Imports System
Module Program
Sub Main()
Dim x = New $$
End Sub
End Module
</Document>)
state.SendTypeChars("_")
Await state.AssertCompletionSession()
Await state.AssertSelectedCompletionItem("_AppDomain", isHardSelected:=False)
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/547287")>
Public Async Function TestNumberDismissesCompletion() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Imports System
Module Program
Sub Main()
Console.WriteLine$$
End Sub
End Module
</Document>)
state.SendTypeChars("(")
Await state.AssertCompletionSession()
state.SendTypeChars(".")
Await state.AssertNoCompletionSession()
state.SendBackspace()
state.SendBackspace()
state.SendTypeChars("(")
Await state.AssertCompletionSession()
state.SendTypeChars("-")
Await state.AssertNoCompletionSession()
state.SendBackspace()
state.SendBackspace()
state.SendTypeChars("(")
Await state.AssertCompletionSession()
state.SendTypeChars("1")
Await state.AssertNoCompletionSession()
End Using
End Function
<WpfFact(Skip:="https://github.com/dotnet/roslyn/issues/27446")>
Public Async Function TestProjections() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
{|S1:
Imports System
Module Program
Sub Main(arg As String)
Dim bbb = 234
Console.WriteLine$$
End Sub
End Module|} </Document>)
Dim subjectDocument = state.Workspace.Documents.First()
Dim firstProjection = state.Workspace.CreateProjectionBufferDocument(
<Document>
{|S1:|}
{|S2: some text that's mapped to the surface buffer |}
</Document>.NormalizedValue, {subjectDocument}, options:=ProjectionBufferOptions.WritableLiteralSpans)
Dim topProjectionBuffer = state.Workspace.CreateProjectionBufferDocument(
<Document>
{|S1:|}
{|S2:|}
</Document>.NormalizedValue, {firstProjection}, options:=ProjectionBufferOptions.WritableLiteralSpans)
' Test a view that has a subject buffer with multiple projection buffers in between
Dim view = topProjectionBuffer.GetTextView()
Dim subjectBuffer = subjectDocument.GetTextBuffer()
state.SendTypeCharsToSpecificViewAndBuffer("(", view, subjectBuffer)
Await state.AssertCompletionSession(view)
state.SendTypeCharsToSpecificViewAndBuffer("a", view, subjectBuffer)
Await state.AssertSelectedCompletionItem(displayText:="arg", projectionsView:=view)
Dim text = view.TextSnapshot.GetText()
Dim projection = DirectCast(topProjectionBuffer.GetTextBuffer(), IProjectionBuffer)
Dim sourceSpans = projection.CurrentSnapshot.GetSourceSpans()
' unmap our source spans without changing the top buffer
projection.ReplaceSpans(0, sourceSpans.Count, {subjectBuffer.CurrentSnapshot.CreateTrackingSpan(0, subjectBuffer.CurrentSnapshot.Length, SpanTrackingMode.EdgeInclusive)}, EditOptions.DefaultMinimalChange, editTag:=Nothing)
state.SendBackspace()
state.SendTypeChars("b")
Await state.AssertSelectedCompletionItem(displayText:="bbb")
' prepare to remap our subject buffer
Dim subjectBufferText = subjectDocument.GetTextBuffer().CurrentSnapshot.GetText()
Using edit = subjectDocument.GetTextBuffer().CreateEdit(EditOptions.DefaultMinimalChange, reiteratedVersionNumber:=Nothing, editTag:=Nothing)
edit.Replace(New Span(0, subjectBufferText.Length), subjectBufferText.Replace("Console.WriteLine(a", "Console.WriteLine(b"))
edit.Apply()
End Using
Dim replacementSpans = sourceSpans.Select(Function(ss)
If ss.Snapshot.TextBuffer.ContentType.TypeName = "inert" Then
Return DirectCast(ss.Snapshot.GetText(ss.Span), Object)
Else
Return DirectCast(ss.Snapshot.CreateTrackingSpan(ss.Span, SpanTrackingMode.EdgeExclusive), Object)
End If
End Function).ToList()
projection.ReplaceSpans(0, 1, replacementSpans, EditOptions.DefaultMinimalChange, editTag:=Nothing)
' the same completionImplementation session should still be active after the remapping.
Await state.AssertSelectedCompletionItem(displayText:="bbb", projectionsView:=view)
state.SendTypeCharsToSpecificViewAndBuffer("b", view, subjectBuffer)
Await state.AssertSelectedCompletionItem(displayText:="bbb", projectionsView:=view)
' verify we can commit even when unmapped
projection.ReplaceSpans(0, projection.CurrentSnapshot.GetSourceSpans.Count, {projection.CurrentSnapshot.GetText()}, EditOptions.DefaultMinimalChange, editTag:=Nothing)
Await state.SendCommitUniqueCompletionListItemAsync()
Assert.Contains(<text>
Imports System
Module Program
Sub Main(arg As String)
Dim bbb = 234
Console.WriteLine(bbb
End Sub
End Module </text>.NormalizedValue, state.GetDocumentText(), StringComparison.Ordinal)
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/622957")>
Public Async Function TestBangFiltersInDocComment() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
''' $$
Public Class TestClass
End Class
]]></Document>)
state.SendTypeChars("<")
Await state.AssertCompletionSession()
state.SendTypeChars("!")
Await state.AssertCompletionSession()
Await state.AssertSelectedCompletionItem("!--")
End Using
End Function
<WpfFact>
Public Async Function CompletionUpAfterBackSpacetoWord() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Public E$$
</Document>)
state.SendBackspace()
Await state.AssertCompletionSession()
state.SendBackspace()
Await state.AssertNoCompletionSession()
End Using
End Function
<WpfFact>
Public Async Function NoCompletionAfterBackspaceInStringLiteral() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Sub Goo()
Dim z = "aa$$"
End Sub
</Document>)
state.SendBackspace()
Await state.AssertNoCompletionSession()
End Using
End Function
<WpfFact>
Public Async Function CompletionUpAfterDeleteDot() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Sub Goo()
Dim z = "a"
z.$$ToString()
End Sub
</Document>)
state.SendBackspace()
Await state.AssertCompletionSession()
End Using
End Function
<WpfFact>
Public Async Function NotCompletionUpAfterDeleteRParen() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Sub Goo()
"a".ToString()$$
End Sub
</Document>)
state.SendBackspace()
Await state.AssertNoCompletionSession()
End Using
End Function
<WpfFact>
Public Async Function NotCompletionUpAfterDeleteLParen() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Sub Goo()
"a".ToString($$
End Sub
</Document>)
state.SendBackspace()
Await state.AssertNoCompletionSession()
End Using
End Function
<WpfFact>
Public Async Function NotCompletionUpAfterDeleteComma() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Sub Goo(x as Integer, y as Integer)
Goo(1,$$)
End Sub
</Document>)
state.SendBackspace()
Await state.AssertNoCompletionSession()
End Using
End Function
<WpfFact>
Public Async Function CompletionAfterDeleteKeyword() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Sub Goo(x as Integer, y as Integer)
Goo(1,2)
End$$ Sub
</Document>)
state.SendBackspace()
Await state.AssertCompletionSession()
Await state.AssertSelectedCompletionItem("End", description:=String.Format(FeaturesResources._0_Keyword, "End") + vbCrLf + VBFeaturesResources.Stops_execution_immediately)
End Using
End Function
<WpfFact>
Public Async Function NoCompletionOnBackspaceAtBeginningOfFile() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>$$</Document>)
state.SendBackspace()
Await state.AssertNoCompletionSession()
End Using
End Function
<WpfFact>
Public Async Function CompletionUpAfterLeftCurlyBrace() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<document>
Imports System
Imports System.Collections.Generic
Imports System.Linq
Module Program
Sub Main(args As String())
Dim l As New List(Of Integer) From $$
End Sub
End Module
</document>)
Await state.AssertNoCompletionSession()
state.SendTypeChars("{")
Await state.AssertCompletionSession()
End Using
End Function
<WpfFact>
Public Async Function CompletionUpAfterLeftAngleBracket() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<document>
$$
Module Program
Sub Main(args As String())
End Sub
End Module
</document>)
Await state.AssertNoCompletionSession()
state.SendTypeChars("<")
Await state.AssertCompletionSession()
End Using
End Function
<WpfFact>
Public Async Function InvokeCompletionDoesNotFilter() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Imports System
Class G
Sub goo()
Dim x as String$$
End Sub
End Class
]]></Document>)
state.SendInvokeCompletionList()
Await state.AssertSelectedCompletionItem("String")
Await state.AssertCompletionItemsContainAll("Integer", "G")
End Using
End Function
<WpfFact>
Public Async Function InvokeCompletionSelectsWithoutRegardToCaretPosition() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Imports System
Class G
Sub goo()
Dim x as Str$$ing
End Sub
End Class
]]></Document>)
state.SendInvokeCompletionList()
Await state.AssertSelectedCompletionItem("String")
Await state.AssertCompletionItemsContainAll("Integer", "G")
End Using
End Function
<WpfFact>
Public Async Function InvokeCompletionBeforeWordDoesNotSelect() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Imports System
Class G
Sub goo()
Dim x as $$String
End Sub
End Class
]]></Document>)
state.SendInvokeCompletionList()
Await state.AssertSelectedCompletionItem("AccessViolationException")
End Using
End Function
<WpfFact>
Public Async Function BackspaceCompletionInvokedSelectedAndUnfiltered() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Imports System
Class G
Sub goo()
Dim x as String$$
End Sub
End Class
]]></Document>)
state.SendBackspace()
Await state.AssertSelectedCompletionItem("String")
Await state.AssertCompletionItemsContainAll("Integer", "G")
End Using
End Function
<WpfFact>
Public Async Function ListDismissedIfNoMatches() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Imports System
Class G
Sub goo()
Dim x as $$
End Sub
End Class
]]></Document>)
state.SendTypeChars("str")
Await state.AssertCompletionSession()
Await state.AssertSelectedCompletionItem("String", isHardSelected:=True)
state.SendTypeChars("gg")
Await state.AssertNoCompletionSession()
End Using
End Function
<WpfFact>
Public Async Function InvokeCompletionComesUpEvenIfNoMatches() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Imports System
Class G
Sub goo()
Dim x as gggg$$
End Sub
End Class
]]></Document>)
state.SendInvokeCompletionList()
Await state.AssertCompletionSession()
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/674422")>
Public Async Function BackspaceInvokeCompletionComesUpEvenIfNoMatches() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Imports System
Class G
Sub goo()
Dim x as gggg$$
End Sub
End Class
]]></Document>)
state.SendBackspace()
Await state.AssertCompletionSession()
state.SendBackspace()
Await state.AssertCompletionSession()
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/674366")>
Public Async Function BackspaceCompletionSelects() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Imports System
Class G
Sub goo()
Dim x as Integrr$$
End Sub
End Class
]]></Document>)
state.SendBackspace()
Await state.AssertCompletionSession()
Await state.AssertSelectedCompletionItem("Integer")
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/675555")>
Public Async Function BackspaceCompletionNeverFilters() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Imports System
Class G
Sub goo()
Dim x as String$$
End Sub
End Class
]]></Document>)
state.SendBackspace()
Await state.AssertCompletionSession()
Await state.AssertCompletionItemsContainAll("AccessViolationException")
state.SendBackspace()
Await state.AssertCompletionSession()
Await state.AssertCompletionItemsContainAll("AccessViolationException")
End Using
End Function
<WpfFact>
Public Sub TabAfterQuestionMarkInEmptyLine()
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Imports System
Class G
Sub goo()
?$$
End Sub
End Class
]]></Document>)
state.SendTab()
Assert.Equal(state.GetLineTextFromCaretPosition(), " ?" + vbTab)
End Using
End Sub
<WpfFact>
Public Sub TabAfterTextFollowedByQuestionMark()
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Imports System
Class G
Sub goo()
a?$$
End Sub
End Class
]]></Document>)
state.SendTab()
Assert.Equal(state.GetLineTextFromCaretPosition(), " a")
End Using
End Sub
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/669942")>
Public Async Function DistinguishItemsWithDifferentGlyphs() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Imports System
Imports System.Linq
Class Test
Sub [Select]()
End Sub
Sub Goo()
Dim k As Integer = 1
$$
End Sub
End Class
]]></Document>)
state.SendTypeChars("selec")
Await state.AssertCompletionSession()
Assert.Equal(state.GetCompletionItems().Count, 2)
End Using
End Function
<WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/670149")>
<WpfFact>
Public Sub TabAfterNullableFollowedByQuestionMark()
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Imports System
Class G
Dim a As Integer?$$
End Class
]]></Document>)
state.SendTab()
Assert.Equal(state.GetLineTextFromCaretPosition(), " Dim a As Integer?" + vbTab)
End Using
End Sub
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/672474")>
Public Async Function TestInvokeSnippetCommandDismissesCompletion() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>$$</Document>)
state.SendTypeChars("Imp")
Await state.AssertCompletionSession()
state.SendInsertSnippetCommand()
Await state.AssertNoCompletionSession()
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/672474")>
Public Async Function TestSurroundWithCommandDismissesCompletion() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>$$</Document>)
state.SendTypeChars("Imp")
Await state.AssertCompletionSession()
state.SendSurroundWithCommand()
Await state.AssertNoCompletionSession()
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/716117")>
Public Async Function XmlCompletionNotTriggeredOnBackspaceInText() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
''' <summary>
''' text$$
''' </summary>
Class G
Dim a As Integer?
End Class]]></Document>)
state.SendBackspace()
Await state.AssertNoCompletionSession()
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/716117")>
Public Async Function XmlCompletionNotTriggeredOnBackspaceInTag() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
''' <summary$$>
''' text
''' </summary>
Class G
Dim a As Integer?
End Class]]></Document>)
state.SendBackspace()
Await state.AssertCompletionSession()
Await state.AssertSelectedCompletionItem("summary")
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/674415")>
Public Async Function BackspacingLastCharacterDismisses() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>$$</Document>)
state.SendTypeChars("A")
Await state.AssertCompletionSession()
state.SendBackspace()
Await state.AssertNoCompletionSession()
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/719977")>
Public Async Function HardSelectionWithBuilderAndOneExactMatch() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>Module M
Public $$
End Module</Document>)
state.SendTypeChars("sub")
Await state.AssertCompletionSession()
Await state.AssertSelectedCompletionItem("Sub")
Assert.True(state.HasSuggestedItem())
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/828603")>
Public Async Function SoftSelectionWithBuilderAndNoExactMatch() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>Module M
Public $$
End Module</Document>)
state.SendTypeChars("prop")
Await state.AssertCompletionSession()
Await state.AssertSelectedCompletionItem("Property", isSoftSelected:=True)
Assert.True(state.HasSuggestedItem())
End Using
End Function
' The test verifies the CommitCommandHandler isolated behavior which does not add '()' after 'Main'.
' The integrated VS behavior for the case is to get 'Main()'.
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/792569")>
Public Sub CommitOnEnter()
Dim expected = <Document>Module M
Sub Main()
Main
End Sub
End Module</Document>.Value.Replace(vbLf, vbCrLf)
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>Module M
Sub Main()
Ma$$i
End Sub
End Module</Document>)
state.SendInvokeCompletionList()
state.SendReturn()
Assert.Equal(expected, state.GetDocumentText())
End Using
End Sub
<WpfFact>
Public Sub TestEnterIsConsumedWithAfterFullyTypedWordOption_NotFullyTyped()
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Class Class1
Sub Main(args As String())
$$
End Sub
End Class
</Document>)
state.Workspace.GlobalOptions.SetGlobalOption(CompletionOptionsStorage.EnterKeyBehavior, LanguageNames.VisualBasic, EnterKeyRule.AfterFullyTypedWord)
state.SendTypeChars("System.TimeSpan.FromMin")
state.SendReturn()
Assert.Equal(<text>
Class Class1
Sub Main(args As String())
System.TimeSpan.FromMinutes
End Sub
End Class
</text>.NormalizedValue, state.GetDocumentText())
End Using
End Sub
<WpfFact>
Public Sub TestEnterIsConsumedWithAfterFullyTypedWordOption_FullyTyped()
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Class Class1
Sub Main(args As String())
$$
End Sub
End Class
</Document>)
state.Workspace.GlobalOptions.SetGlobalOption(CompletionOptionsStorage.EnterKeyBehavior, LanguageNames.VisualBasic, EnterKeyRule.AfterFullyTypedWord)
state.SendTypeChars("System.TimeSpan.FromMinutes")
state.SendReturn()
Assert.Equal(<text>
Class Class1
Sub Main(args As String())
System.TimeSpan.FromMinutes
End Sub
End Class
</text>.NormalizedValue, state.GetDocumentText())
End Using
End Sub
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/546208")>
Public Async Function SelectKeywordFirst() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Class C
Sub M()
$$
End Sub
Sub GetType()
End Sub
End Class
</Document>)
state.SendTypeChars("GetType")
Await state.AssertSelectedCompletionItem(
displayText:="GetType",
displayTextSuffix:=String.Empty,
description:=VBFeaturesResources.GetType_function + vbCrLf +
VBWorkspaceResources.Returns_a_System_Type_object_for_the_specified_type_name + vbCrLf +
$"GetType({VBWorkspaceResources.typeName}) As Type")
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/828392")>
Public Async Function ConstructorFiltersAsNew() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Public Class Base
Public Sub New(x As Integer)
End Sub
End Class
Public Class Derived
Inherits Base
Public Sub New(x As Integer)
MyBase.$$
End Sub
End Class
</Document>)
state.SendTypeChars("New")
Await state.AssertSelectedCompletionItem("New", isHardSelected:=True)
End Using
End Function
<WpfFact>
Public Async Function NoUnmentionableTypeInObjectCreation() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Public Class C
Sub Goo()
Dim a = new$$
End Sub
End Class
</Document>)
state.SendTypeChars(" ")
Await state.AssertSelectedCompletionItem("AccessViolationException", isSoftSelected:=True)
End Using
End Function
<WpfFact>
Public Async Function FilterPreferEnum() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Enum E
Goo
Bar
End Enum
Class Goo
End Class
Public Class C
Sub Goo()
E e = $$
End Sub
End Class</Document>)
state.SendTypeChars("g")
Await state.AssertSelectedCompletionItem("E.Goo", isHardSelected:=True)
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/883295")>
Public Async Function InsertOfOnSpace() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Imports System.Threading.Tasks
Public Class C
Sub Goo()
Dim a as $$
End Sub
End Class
</Document>)
Await state.SendTypeCharsAndWaitForUiRenderAsync("Task")
state.SendDownKey()
state.SendTypeChars(" ")
Assert.Equal(" Dim a as Task(Of ", state.GetLineTextFromCaretPosition())
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/883295")>
Public Sub DoNotInsertOfOnTab()
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Imports System.Threading.Tasks
Public Class C
Sub Goo()
Dim a as $$
End Sub
End Class
</Document>)
state.SendTypeChars("Task")
state.SendTab()
Assert.Equal(state.GetLineTextFromCaretPosition(), " Dim a as Task")
End Using
End Sub
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/899414")>
Public Async Function NotInPartialMethodDeclaration() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Module Module1
Sub Main()
End Sub
End Module
Public Class Class2
Partial Private Sub PartialMethod(ByVal x As Integer)
$$
End Sub
End Class</Document>)
state.SendInvokeCompletionList()
Await state.AssertNoCompletionSession()
End Using
End Function
<WpfFact>
Public Async Function TestCompletionInLinkedFiles() As Task
Using state = TestStateFactory.CreateTestStateFromWorkspace(
<Workspace>
<Project Language="Visual Basic" CommonReferences="true" AssemblyName="VBProj" PreprocessorSymbols="Thing2=True">
<Document FilePath="C.vb">
Class C
Sub M()
$$
End Sub
#If Thing1 Then
Sub Thing1()
End Sub
#End If
#If Thing2 Then
Sub Thing2()
End Sub
#End If
End Class
</Document>
</Project>
<Project Language="Visual Basic" CommonReferences="true" PreprocessorSymbols="Thing1=True">
<Document IsLinkFile="true" LinkAssemblyName="VBProj" LinkFilePath="C.vb"/>
</Project>
</Workspace>)
Dim documents = state.Workspace.Documents
Dim linkDocument = documents.Single(Function(d) d.IsLinkFile)
state.SendTypeChars("Thi")
Await state.AssertSelectedCompletionItem("Thing1")
state.SendBackspace()
state.SendBackspace()
state.SendBackspace()
' Assert the lack of a completion session (which implicitly waits for background operations to complete)
' to ensure the session is dismissed before typing the next character.
' https://devdiv.visualstudio.com/DevDiv/_workitems/edit/2003327
Await state.AssertNoCompletionSession()
state.Workspace.SetDocumentContext(linkDocument.Id)
state.SendTypeChars("Thi")
Await state.AssertSelectedCompletionItem("Thing1")
Assert.True(state.GetSelectedItem().Tags.Contains(WellKnownTags.Warning))
state.SendBackspace()
state.SendBackspace()
state.SendBackspace()
Await state.AssertNoCompletionSession()
state.SendTypeChars("M")
Await state.AssertSelectedCompletionItem("M")
Assert.False(state.GetSelectedItem().Tags.Contains(WellKnownTags.Warning))
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/916452")>
Public Async Function SoftSelectedWithNoFilterText() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Imports System
Class C
Public Sub M(day As DayOfWeek)
M$$
End Sub
End Class</Document>)
state.SendTypeChars("(")
Await state.AssertCompletionSession()
Assert.True(state.IsSoftSelected())
End Using
End Function
<WpfFact>
Public Async Function EnumSortingOrder() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Imports System
Class C
Public Sub M(day As DayOfWeek)
M$$
End Sub
End Class</Document>)
state.SendTypeChars("(")
Await state.AssertCompletionSession()
' DayOfWeek.Monday should immediately follow DayOfWeek.Friday
Dim friday = state.GetCompletionItems().First(Function(i) i.DisplayText = "DayOfWeek.Friday")
Dim monday = state.GetCompletionItems().First(Function(i) i.DisplayText = "DayOfWeek.Monday")
Assert.True(state.GetCompletionItems().IndexOf(friday) = state.GetCompletionItems().IndexOf(monday) - 1)
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/951726")>
Public Async Function DismissUponSave() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Class C
$$
End Class]]></Document>)
state.SendTypeChars("Su")
Await state.AssertSelectedCompletionItem("Sub")
state.SendSave()
Await state.AssertNoCompletionSession()
state.AssertMatchesTextStartingAtLine(2, " Su")
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/969794")>
Public Async Function DeleteCompletionInvokedSelectedAndUnfiltered() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Imports System
Class G
Sub goo()
Dim x as Stri$$ng
End Sub
End Class
]]></Document>)
state.SendDelete()
Await state.AssertSelectedCompletionItem("String")
End Using
End Function
<WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/871755")>
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/954556")>
Public Async Function FilterPrefixOnlyOnBackspace1() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Imports System
Class G
Public Re$$
End Class
]]></Document>)
state.SendBackspace()
Await state.AssertSelectedCompletionItem("ReadOnly")
state.SendTypeChars("a")
Await state.AssertNoCompletionSession()
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/969040")>
Public Async Function BackspaceTriggerOnlyIfOptionEnabled() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Imports System
Class G
Public Re$$
End Class
]]></Document>)
state.Workspace.GlobalOptions.SetGlobalOption(CompletionOptionsStorage.TriggerOnTyping, LanguageNames.VisualBasic, False)
state.SendBackspace()
Await state.AssertNoCompletionSession()
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/957450")>
Public Async Function KeywordsForIntrinsicsDeduplicated() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Imports System
Class G
Sub Goo()
$$
End Sub
End Class
]]></Document>)
state.SendInvokeCompletionList()
Await state.AssertCompletionSession()
' Should only have one item called 'Double' and it should have a keyword glyph
Dim doubleItem = state.GetCompletionItems().Single(Function(c) c.DisplayText = "Double")
Assert.True(doubleItem.Tags.Contains(WellKnownTags.Keyword))
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/957450")>
Public Async Function KeywordDeduplicationLeavesEscapedIdentifiers() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Imports System
Class [Double]
Sub Goo()
Dim x as $$
End Sub
End Class
]]></Document>)
state.SendInvokeCompletionList()
Await state.AssertCompletionSession()
' We should have gotten the item corresponding to [Double] and the item for the Double keyword
Dim doubleItems = state.GetCompletionItems().Where(Function(c) c.DisplayText = "Double")
Assert.Equal(2, doubleItems.Count())
Assert.True(doubleItems.Any(Function(c) c.Tags.Contains(WellKnownTags.Keyword)))
Assert.True(doubleItems.Any(Function(c) c.Tags.Contains(WellKnownTags.Class) AndAlso c.Tags.Contains(WellKnownTags.Internal)))
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/957450")>
Public Async Function TestEscapedItemCommittedWithCloseBracket() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Imports System
Class [Interface]
Sub Goo()
Dim x As $$
End Sub
End Class
]]></Document>)
state.SendInvokeCompletionList()
Await state.AssertCompletionSession()
state.SendTypeChars("Interf]")
state.AssertMatchesTextStartingAtLine(4, "Dim x As [Interface]")
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1075298")>
Public Sub CommitOnQuestionMarkForConditionalAccess()
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Imports System
Class G
Sub Goo()
Dim x = String.$$
End Sub
End Class
]]></Document>)
state.SendTypeChars("emp?")
state.AssertMatchesTextStartingAtLine(4, "Dim x = String.Empty?")
End Using
End Sub
<WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/1659")>
Public Async Function DismissOnSelectAllCommand() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Class C
Sub goo()
$$]]></Document>)
' Note: the caret is at the file, so the Select All command's movement
' of the caret to the end of the selection isn't responsible for
' dismissing the session.
state.SendInvokeCompletionList()
Await state.AssertCompletionSession()
state.SendSelectAll()
Await state.AssertNoCompletionSession()
End Using
End Function
<WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/3088")>
Public Async Function DoNotPreferParameterNames() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Module Program
Sub Main(args As String())
Dim Table As Integer
goo(table$$)
End Sub
Sub goo(table As String)
End Sub
End Module]]></Document>)
state.SendInvokeCompletionList()
Await state.AssertSelectedCompletionItem("Table")
End Using
End Function
<WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/4892")>
Public Async Function BooleanPreselection1() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Module Program
Sub Main(args As String())
Dim x as boolean = $$
End Sub
End Module]]></Document>)
state.SendTypeChars("f")
Await state.AssertSelectedCompletionItem("False")
state.SendBackspace()
state.SendTypeChars("t")
Await state.AssertSelectedCompletionItem("True")
End Using
End Function
<WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/4892")>
Public Async Function BooleanPreselection2() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Module Program
Sub Main(args As String())
foot($$
End Sub
Sub foot(x as boolean)
End Sub
End Module]]></Document>)
state.SendTypeChars("f")
Await state.AssertSelectedCompletionItem("False")
state.SendBackspace()
state.SendTypeChars("t")
Await state.AssertSelectedCompletionItem("True")
End Using
End Function
<WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/4892")>
Public Async Function BooleanPreselection3() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Module Program
Class F
End Class
Class T
End Class
Sub Main(args As String())
$$
End Sub
End Module]]></Document>)
state.SendTypeChars("f")
Await state.AssertSelectedCompletionItem("F")
state.SendBackspace()
state.SendTypeChars("t")
Await state.AssertSelectedCompletionItem("T")
End Using
End Function
<WpfFact>
Public Async Function TargetTypePreselection1() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Imports System.Threading
Module Program
Sub Cancel(x As Integer, cancellationToken As CancellationToken)
Cancel(x + 1, $$)
End Sub
End Module]]></Document>)
state.SendInvokeCompletionList()
Await state.AssertSelectedCompletionItem("cancellationToken").ConfigureAwait(True)
End Using
End Function
<WpfFact>
Public Async Function TargetTypePreselection2() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Module Program
Sub Main(args As String())
Dim aaz As Integer
args = $$
End Sub
End Module]]></Document>)
state.SendTypeChars("a")
Await state.AssertSelectedCompletionItem("args").ConfigureAwait(True)
End Using
End Function
<WpfFact>
Public Async Function TargetTypePreselection3() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Class D
End Class
Class Program
Sub Main(string() args)
Dim cw = 7
Dim cx as D = new D()
Dim cx2 as D = $$
End Sub
End Class
]]></Document>)
state.SendTypeChars("c")
Await state.AssertSelectedCompletionItem("cx", isHardSelected:=True).ConfigureAwait(True)
End Using
End Function
<WpfFact>
Public Async Function TargetTypePreselectionLocalsOverType() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Class A
End Class
Class Program
Sub Main(string() args)
Dim cx = new A()
Dim cx2 as A = $$
End Sub
End Class
]]></Document>)
state.SendTypeChars("c")
Await state.AssertSelectedCompletionItem("cx", isHardSelected:=True).ConfigureAwait(True)
End Using
End Function
<WpfFact(Skip:="https://github.com/dotnet/roslyn/issues/6942")>
Public Async Function TargetTypePreselectionConvertibility1() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Mustinherit Class C
End Class
Class D
inherits C
End Class
Class Program
Sub Main(string() args)
Dim cx = new D()
Dim cx2 as C = $$
End Sub
End Class
]]></Document>)
state.SendTypeChars("c")
Await state.AssertSelectedCompletionItem("cx", isHardSelected:=True).ConfigureAwait(True)
End Using
End Function
<WpfFact>
Public Async Function TargetTypePreselectionParamsArray() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Class Program
Sub Main(string() args)
Dim azc as integer
M2(a$$
End Sub
Sub M2(params int() yx)
End Sub
End Class
]]></Document>)
state.SendInvokeCompletionList()
Await state.AssertSelectedCompletionItem("azc", isHardSelected:=True).ConfigureAwait(True)
End Using
End Function
<WpfFact>
Public Async Function TargetTypePreselectionSetterValue() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Class Program
Private Async As Integer
Public Property NewProperty() As Integer
Get
Return Async
End Get
Set(ByVal value As Integer)
Async = $$
End Set
End Property
End Class]]></Document>)
state.SendInvokeCompletionList()
Await state.AssertSelectedCompletionItem("value", isHardSelected:=False, isSoftSelected:=True).ConfigureAwait(True)
End Using
End Function
<WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/12530")>
Public Async Function TestAnonymousTypeDescription() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Imports System.Linq
Public Class Class1
Sub Method()
Dim x = {New With {.x = 1}}.ToArr$$
End Sub
End Class
]]></Document>)
state.SendInvokeCompletionList()
Await state.AssertSelectedCompletionItem(description:=
$"<{ VBFeaturesResources.Extension }> Function IEnumerable(Of 'a).ToArray() As 'a()
{ FeaturesResources.Types_colon }
'a { FeaturesResources.is_ } New With {{ .x As Integer }}")
End Using
End Function
<WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/12530")>
Public Async Function TestAnonymousTypeDescription2() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Imports System.Linq
Public Class Class1
Sub Method()
Dim x = {New With { Key .x = 1}}.ToArr$$
End Sub
End Class
]]></Document>)
state.SendInvokeCompletionList()
Await state.AssertSelectedCompletionItem(description:=
$"<{ VBFeaturesResources.Extension }> Function IEnumerable(Of 'a).ToArray() As 'a()
{ FeaturesResources.Types_colon }
'a { FeaturesResources.is_ } New With {{ Key .x As Integer }}")
End Using
End Function
<WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/11812")>
Public Async Function TestObjectCreationQualifiedName() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Class A
Sub Test()
Dim b As B.C(Of Integer) = New$$
End Sub
End Class
Namespace B
Class C(Of T)
End Class
End Namespace]]></Document>)
state.SendTypeChars(" ")
Await state.AssertCompletionSession()
state.SendTypeChars("(")
state.AssertMatchesTextStartingAtLine(3, "Dim b As B.C(Of Integer) = New B.C(Of Integer)(")
End Using
End Function
<WpfFact>
Public Async Function TestNonTrailingNamedArgumentInVB15_3() As Task
Using state = TestStateFactory.CreateTestStateFromWorkspace(
<Workspace>
<Project Language="Visual Basic" LanguageVersion="15.3" CommonReferences="true" AssemblyName="VBProj">
<Document FilePath="C.vb">
Class C
Sub M()
Dim better As Integer = 2
M(a:=1, $$)
End Sub
Sub M(a As Integer, bar As Integer, c As Integer)
End Sub
End Class
</Document>
</Project>
</Workspace>)
state.SendTypeChars("b")
Await state.AssertSelectedCompletionItem(displayText:="bar", displayTextSuffix:=":=", isHardSelected:=True)
state.SendTypeChars("e")
Await state.AssertNoCompletionSession()
End Using
End Function
<WpfFact>
Public Async Function TestNonTrailingNamedArgumentInVB15_5() As Task
Using state = TestStateFactory.CreateTestStateFromWorkspace(
<Workspace>
<Project Language="Visual Basic" LanguageVersion="15.5" CommonReferences="true" AssemblyName="VBProj">
<Document FilePath="C.vb">
Class C
Sub M()
Dim better As Integer = 2
M(a:=1, $$)
End Sub
Sub M(a As Integer, bar As Integer, c As Integer)
End Sub
End Class
</Document>
</Project>
</Workspace>)
state.SendTypeChars("bar")
Await state.AssertSelectedCompletionItem(displayText:="bar", displayTextSuffix:=":=", isHardSelected:=True)
state.SendBackspace()
state.SendBackspace()
state.SendTypeChars("et")
Await state.AssertSelectedCompletionItem(displayText:="better", isHardSelected:=True)
state.SendTypeChars(", ")
Assert.Contains("M(a:=1, better,", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
End Using
End Function
<WpfFact>
Public Async Function TestSymbolInTupleLiteral() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Class C
Public Sub Goo()
Dim t = ($$)
End Sub
End Class
}]]></Document>)
state.SendTypeChars("Go")
Await state.AssertSelectedCompletionItem(displayText:="Goo", isHardSelected:=True)
state.SendTypeChars(":")
Assert.Contains("(Go:", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
End Using
End Function
<WpfFact>
Public Async Function TestSymbolInTupleLiteralAfterComma() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Class C
Public Sub Goo()
Dim t = (1, $$)
End Sub
End Class
]]></Document>)
state.SendTypeChars("Go")
Await state.AssertSelectedCompletionItem(displayText:="Goo", isHardSelected:=True)
state.SendTypeChars(":")
Assert.Contains("(1, Go:", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
End Using
End Function
<WpfFact>
Public Async Function TestSnippetInTupleLiteral() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Class C
Public Sub Goo()
Dim t = ($$)
End Sub
End Class
}]]></Document>,
extraExportedTypes:={GetType(MockSnippetInfoService), GetType(SnippetCompletionProvider), GetType(StubVsEditorAdaptersFactoryService)}.ToList())
state.Workspace.GlobalOptions.SetGlobalOption(CompletionOptionsStorage.SnippetsBehavior, LanguageNames.VisualBasic, SnippetsRule.AlwaysInclude)
state.SendTypeChars("Shortcu")
Await state.AssertNoCompletionSession()
state.SendTypeChars(":")
Assert.Contains("(Shortcu:", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
End Using
End Function
<WpfFact>
Public Async Function TestSnippetInTupleLiteralAfterComma() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Class C
Public Sub Goo()
Dim t = (1, $$)
End Sub
End Class
}]]></Document>,
extraExportedTypes:={GetType(MockSnippetInfoService), GetType(SnippetCompletionProvider), GetType(StubVsEditorAdaptersFactoryService)}.ToList())
state.Workspace.GlobalOptions.SetGlobalOption(CompletionOptionsStorage.SnippetsBehavior, LanguageNames.VisualBasic, SnippetsRule.AlwaysInclude)
state.SendTypeChars("Shortcu")
Await state.AssertNoCompletionSession()
state.SendTypeChars(":")
Assert.Contains("(1, Shortcu:", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
End Using
End Function
<WpfFact>
Public Async Function TestSnippetsNotExclusiveWhenAlwaysShowing() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Class C
Public Sub Goo()
Dim x as Integer = 3
Dim t = $$
End Sub
End Class
}]]></Document>,
extraExportedTypes:={GetType(MockSnippetInfoService), GetType(SnippetCompletionProvider), GetType(StubVsEditorAdaptersFactoryService)}.ToList())
state.Workspace.GlobalOptions.SetGlobalOption(CompletionOptionsStorage.SnippetsBehavior, LanguageNames.VisualBasic, SnippetsRule.AlwaysInclude)
state.SendInvokeCompletionList()
Await state.AssertCompletionItemsContainAll("x", "Shortcut")
End Using
End Function
<WpfFact>
Public Async Function TestBuiltInTypesKeywordInTupleLiteral() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Class C
Public Sub Goo()
Dim t = ($$)
End Sub
End Class
}]]></Document>)
state.SendTypeChars("Intege")
Await state.AssertSelectedCompletionItem(displayText:="Integer", isHardSelected:=True)
state.SendTypeChars(":")
Assert.Contains("(Intege:", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
End Using
End Function
<WpfFact>
Public Async Function TestBuiltInTypesKeywordInTupleLiteralAfterComma() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Class C
Public Sub Goo()
Dim t = (1, $$)
End Sub
End Class
}]]></Document>)
state.SendTypeChars("Intege")
Await state.AssertSelectedCompletionItem(displayText:="Integer", isHardSelected:=True)
state.SendTypeChars(":")
Assert.Contains("(1, Intege:", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
End Using
End Function
<WpfFact>
Public Async Function TestFunctionKeywordInTupleLiteral() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Class C
Public Sub Goo()
Dim t = ($$)
End Sub
End Class
}]]></Document>)
state.SendTypeChars("Functio")
Await state.AssertSelectedCompletionItem(displayText:="Function", isHardSelected:=True)
state.SendTypeChars(":")
Assert.Contains("(Functio:", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
End Using
End Function
<WpfFact>
Public Async Function TestFunctionKeywordInTupleLiteralAfterComma() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Class C
Public Sub Goo()
Dim t = (1, $$)
End Sub
End Class
}]]></Document>)
state.SendTypeChars("Functio")
Await state.AssertSelectedCompletionItem(displayText:="Function", isHardSelected:=True)
state.SendTypeChars(":")
Assert.Contains("(1, Functio:", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
End Using
End Function
<WpfFact>
Public Async Function TestSymbolInTupleType() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Class C
Public Sub Goo()
Dim t As ($$)
End Sub
End Class
]]></Document>)
state.SendTypeChars("Integ")
Await state.AssertSelectedCompletionItem(displayText:="Integer", isHardSelected:=True)
state.SendTypeChars(",")
Assert.Contains("(Integer,", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
End Using
End Function
<WpfFact>
Public Async Function TestInvocationExpression() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Class C
Public Sub Goo(Alice As Integer)
Goo($$)
End Sub
End Class
]]></Document>)
state.SendTypeChars("Alic")
Await state.AssertSelectedCompletionItem(displayText:="Alice", isHardSelected:=True)
state.SendTypeChars(":")
Assert.Contains("Goo(Alice:", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
End Using
End Function
<WpfFact>
Public Async Function TestInvocationExpressionAfterComma() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Class C
Public Sub Goo(Alice As Integer, Bob As Integer)
Goo(1, $$)
End Sub
End Class
]]></Document>)
state.SendTypeChars("B")
Await state.AssertSelectedCompletionItem(displayText:="Bob", isHardSelected:=True)
state.SendTypeChars(":")
Assert.Contains("Goo(1, Bob:", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
End Using
End Function
<WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/13161")>
Public Sub CommitGenericDoesNotInsertEllipsis()
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Interface Goo(Of T)
End Interface
Class Bar
Implements $$
End Class]]></Document>)
Dim unicodeEllipsis = ChrW(&H2026).ToString()
state.SendTypeChars("Goo")
state.SendTab()
Assert.Equal("Implements Goo(Of", state.GetLineTextFromCaretPosition().Trim())
Assert.DoesNotContain(unicodeEllipsis, state.GetLineTextFromCaretPosition())
End Using
End Sub
<WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/13161")>
Public Sub CommitGenericDoesNotInsertEllipsisCommitOnParen()
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Interface Goo(Of T)
End Interface
Class Bar
Implements $$
End Class]]></Document>)
Dim unicodeEllipsis = ChrW(&H2026).ToString()
state.SendTypeChars("Goo(")
Assert.Equal("Implements Goo(", state.GetLineTextFromCaretPosition().Trim())
Assert.DoesNotContain(unicodeEllipsis, state.GetLineTextFromCaretPosition())
End Using
End Sub
<WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/13161")>
Public Sub CommitGenericItemDoesNotInsertEllipsisCommitOnTab()
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Interface Goo(Of T)
End Interface
Class Bar
Dim x as $$
End Class]]></Document>)
Dim unicodeEllipsis = ChrW(&H2026).ToString()
state.SendTypeChars("Goo")
state.SendTab()
Assert.Equal("Dim x as Goo(Of", state.GetLineTextFromCaretPosition().Trim())
Assert.DoesNotContain(unicodeEllipsis, state.GetLineTextFromCaretPosition())
End Using
End Sub
<WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/15011")>
Public Async Function SymbolAndObjectPreselectionUnification() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Module Module1
Sub Main()
Dim x As ProcessStartInfo = New $$
End Sub
End Module
]]></Document>)
state.SendInvokeCompletionList()
Await state.AssertCompletionSession()
Dim psi = state.GetCompletionItems().Where(Function(i) i.DisplayText.Contains("ProcessStartInfo")).ToArray()
Assert.Equal(1, psi.Length)
End Using
End Function
<WpfFact, WorkItem("https://devdiv.visualstudio.com/DevDiv/_workitems?_a=edit&id=394863&triage=true")>
Public Async Function ImplementsClause() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Partial Class TestClass
Implements IComparable(Of TestClass)
Public Function CompareTo(other As TestClass) As Integer Implements I$$
End Function
End Class
]]></Document>)
state.SendInvokeCompletionList()
Await state.AssertCompletionSession()
state.SendTab()
Assert.Contains("IComparable(Of TestClass)", state.GetLineTextFromCaretPosition())
End Using
End Function
<WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/18785")>
Public Async Function BackspaceSoftSelectionIfNotPrefixMatch() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Class C
Sub Do()
Dim x = new System.Collections.Generic.List(Of String)()
x.$$Add("stuff")
End Sub
End Class
]]></Document>)
state.SendBackspace()
Await state.AssertSelectedCompletionItem("x", isSoftSelected:=True)
state.SendTypeChars(".")
Assert.Contains("x.Add", state.GetLineTextFromCaretPosition())
End Using
End Function
<WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/28767")>
Public Async Function CompletionDoesNotRemoveBracketsOnEnum() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Class C
Sub S
[$$]
End Sub
End Class
</Document>)
Await state.AssertNoCompletionSession()
state.SendTypeChars("Enu")
Await state.AssertSelectedCompletionItem(displayText:="Enum", isHardSelected:=True)
state.SendTab()
Assert.Contains("[Enum]", state.GetDocumentText(), StringComparison.Ordinal)
End Using
End Function
<WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/30097")>
Public Async Function TestMRUKeepsTwoRecentlyUsedItems() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Class C
Public Sub Ma(m As Double)
End Sub
Public Sub Test()
$$
End Sub
End Class
</Document>)
state.SendTypeChars("M(M(M(M(")
Await state.AssertCompletionSession()
Assert.Equal(" Ma(m:=(Ma(m:=(", state.GetLineTextFromCaretPosition())
End Using
End Function
<WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/36546")>
Public Async Function TestDoNotDismissIfEmptyOnBackspaceIfStartedWithBackspace() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Imports System
Class C
Public Sub M()
Console.W$$
End Sub
End Class
</Document>)
state.SendBackspace()
Await state.AssertCompletionItemsContainAll("WriteLine")
End Using
End Function
<WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/36546")>
Public Async Function TestDoNotDismissIfEmptyOnMultipleBackspaceIfStartedInvoke() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Imports System
Class C
Public Sub M()
Console.Wr$$
End Sub
End Class
</Document>)
state.SendInvokeCompletionList()
Await state.AssertCompletionSession()
state.SendBackspace()
state.SendBackspace()
Await state.AssertCompletionSession()
End Using
End Function
<WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/588")>
Public Async Function TestMatchWithTurkishIWorkaround1() As Task
Using New CultureContext(New Globalization.CultureInfo("tr-TR", useUserOverride:=False))
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Class C
Sub goo(x As Integer)
String.$$
]]></Document>)
state.SendTypeChars("is")
Await state.WaitForAsynchronousOperationsAsync()
Await state.AssertSelectedCompletionItem("IsInterned")
End Using
End Using
End Function
<WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/588")>
Public Async Function TestMatchWithTurkishIWorkaround2() As Task
Using New CultureContext(New Globalization.CultureInfo("tr-TR", useUserOverride:=False))
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Class C
Sub goo(x As Integer)
String.$$]]></Document>)
state.SendTypeChars("ı")
Await state.WaitForAsynchronousOperationsAsync()
Await state.AssertSelectedCompletionItem()
End Using
End Using
End Function
<WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/29938")>
Public Async Function TestMatchWithTurkishIWorkaround3() As Task
Using New CultureContext(New Globalization.CultureInfo("tr-TR", useUserOverride:=False))
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Class TARIFE
End Class
Class C
Sub goo(x As Integer)
Dim t As $$
]]></Document>)
state.SendTypeChars("tarif")
Await state.WaitForAsynchronousOperationsAsync()
Await state.AssertSelectedCompletionItem("TARIFE")
End Using
End Using
End Function
<WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/29938")>
Public Async Function TestMatchWithTurkishIWorkaround4() As Task
Using New CultureContext(New Globalization.CultureInfo("tr-TR", useUserOverride:=False))
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Class IFADE
End Class
Class ifTest
End Class
Class C
Sub goo(x As Integer)
Dim ifade As IFADE
$$]]></Document>)
state.SendTypeChars("if")
Await state.WaitForAsynchronousOperationsAsync()
Await state.AssertSelectedCompletionItem("If")
End Using
End Using
End Function
<WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/29938")>
Public Async Function TestMatchWithTurkishIWorkaround5() As Task
Using New CultureContext(New Globalization.CultureInfo("tr-TR", useUserOverride:=False))
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Class İFADE
End Class
Class ifTest
End Class
Class C
Sub goo(x As Integer)
Dim ifade As İFADE
$$
]]></Document>)
state.SendTypeChars("if")
Await state.WaitForAsynchronousOperationsAsync()
Await state.AssertSelectedCompletionItem("If")
End Using
End Using
End Function
<WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/29938")>
Public Async Function TestMatchWithTurkishIWorkaround6() As Task
Using New CultureContext(New Globalization.CultureInfo("tr-TR", useUserOverride:=False))
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Class TARİFE
End Class
Class C
Sub goo(x As Integer)
Dim obj As $$
]]></Document>)
state.SendTypeChars("tarif")
Await state.WaitForAsynchronousOperationsAsync()
Await state.AssertSelectedCompletionItem("TARİFE")
End Using
End Using
End Function
<WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/29938")>
Public Async Function TestMatchWithTurkishIWorkaround7() As Task
Using New CultureContext(New Globalization.CultureInfo("tr-TR", useUserOverride:=False))
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Class İFADE
End Class
Class ifTest
End Class
Class C
Sub goo(x As Integer)
Dim obj As $$
]]></Document>)
state.SendTypeChars("ifad")
Await state.WaitForAsynchronousOperationsAsync()
Await state.AssertSelectedCompletionItem("İFADE")
End Using
End Using
End Function
<WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/29938")>
Public Async Function TestMatchWithTurkishIWorkaround8() As Task
Using New CultureContext(New Globalization.CultureInfo("tr-TR", useUserOverride:=False))
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Class IFADE
End Class
Class ifTest
End Class
Class C
Sub goo(x As Integer)
Dim obj As $$
]]></Document>)
state.SendTypeChars("ifad")
Await state.WaitForAsynchronousOperationsAsync()
Await state.AssertSelectedCompletionItem("IFADE")
End Using
End Using
End Function
<WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/29938")>
Public Async Function TestMatchWithTurkishIWorkaround9() As Task
Using New CultureContext(New Globalization.CultureInfo("tr-TR", useUserOverride:=False))
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Class IFADE
End Class
Class ifTest
End Class
Class C
Sub goo(x As Integer)
Dim ifade_ As İFADE
$$]]></Document>)
state.SendTypeChars("IF")
Await state.WaitForAsynchronousOperationsAsync()
Await state.AssertSelectedCompletionItem("If")
End Using
End Using
End Function
<WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/29938")>
Public Async Function TestMatchWithTurkishIWorkaround10() As Task
Using New CultureContext(New Globalization.CultureInfo("tr-TR", useUserOverride:=False))
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document><![CDATA[
Class İFADE
End Class
Class ifTest
End Class
Class C
Sub goo(x As Integer)
Dim ifade As İFADE
$$
]]></Document>)
state.SendTypeChars("IF")
Await state.WaitForAsynchronousOperationsAsync()
Await state.AssertSelectedCompletionItem("If")
End Using
End Using
End Function
<WpfTheory, CombinatorialData>
Public Async Function CompletionInPreprocessorIf(showCompletionInArgumentLists As Boolean) As Task
Using state = TestStateFactory.CreateTestStateFromWorkspace(
<Workspace>
<Project Language="Visual Basic" CommonReferences="true" PreprocessorSymbols="Goo=1,Bar=2,Baz=3">
<Document>
#if $$
</Document>
</Project>
</Workspace>,
showCompletionInArgumentLists:=showCompletionInArgumentLists)
state.SendInvokeCompletionList()
Await state.AssertCompletionItemsContainAll({"Goo", "Bar", "Baz", "True", "False"})
state.SendTypeChars("Go")
state.SendTab()
Await state.AssertNoCompletionSession()
Assert.Contains("#if Goo", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
End Using
End Function
<WpfTheory, CombinatorialData>
Public Async Function CompletionInPreprocessorElseIf(showCompletionInArgumentLists As Boolean) As Task
Using state = TestStateFactory.CreateTestStateFromWorkspace(
<Workspace>
<Project Language="Visual Basic" CommonReferences="true" PreprocessorSymbols="Goo=1,Bar=2,Baz=3">
<Document>
#if false
#elseif $$
</Document>
</Project>
</Workspace>,
showCompletionInArgumentLists:=showCompletionInArgumentLists)
state.SendInvokeCompletionList()
Await state.AssertCompletionItemsContainAll({"Goo", "Bar", "Baz", "True", "False"})
state.SendTypeChars("Go")
state.SendTab()
Await state.AssertNoCompletionSession()
Assert.Contains("#elseif Goo", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
End Using
End Function
<WpfTheory, CombinatorialData>
Public Async Function CompletionNotInPreprocessorElse(showCompletionInArgumentLists As Boolean) As Task
Using state = TestStateFactory.CreateTestStateFromWorkspace(
<Workspace>
<Project Language="Visual Basic" CommonReferences="true" PreprocessorSymbols="Goo=1,Bar=2,Baz=3">
<Document>
#if false
#elseif false
#else $$
</Document>
</Project>
</Workspace>,
showCompletionInArgumentLists:=showCompletionInArgumentLists)
state.SendInvokeCompletionList()
Await state.AssertNoCompletionSession()
End Using
End Function
<WpfTheory, CombinatorialData>
Public Async Function CompletionInPreprocessorParenthesized(showCompletionInArgumentLists As Boolean) As Task
Using state = TestStateFactory.CreateTestStateFromWorkspace(
<Workspace>
<Project Language="Visual Basic" CommonReferences="true" PreprocessorSymbols="Goo=1,Bar=2,Baz=3">
<Document>
#if ($$
</Document>
</Project>
</Workspace>,
showCompletionInArgumentLists:=showCompletionInArgumentLists)
state.SendInvokeCompletionList()
Await state.AssertCompletionItemsContainAll({"Goo", "Bar", "Baz", "True", "False"})
state.SendTypeChars("Go")
state.SendTab()
Await state.AssertNoCompletionSession()
Assert.Contains("#if (Goo", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
End Using
End Function
<WpfTheory, CombinatorialData>
Public Async Function CompletionInPreprocessorNot(showCompletionInArgumentLists As Boolean) As Task
Using state = TestStateFactory.CreateTestStateFromWorkspace(
<Workspace>
<Project Language="Visual Basic" CommonReferences="true" PreprocessorSymbols="Goo=1,Bar=2,Baz=3">
<Document>
#if not $$
</Document>
</Project>
</Workspace>,
showCompletionInArgumentLists:=showCompletionInArgumentLists)
state.SendInvokeCompletionList()
Await state.AssertCompletionItemsContainAll({"Goo", "Bar", "Baz", "True", "False"})
state.SendTypeChars("Go")
state.SendTab()
Await state.AssertNoCompletionSession()
Assert.Contains("#if not Goo", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
End Using
End Function
<WpfTheory, CombinatorialData>
Public Async Function CompletionInPreprocessorAnd(showCompletionInArgumentLists As Boolean) As Task
Using state = TestStateFactory.CreateTestStateFromWorkspace(
<Workspace>
<Project Language="Visual Basic" CommonReferences="true" PreprocessorSymbols="Goo=1,Bar=2,Baz=3">
<Document>
#if true and $$
</Document>
</Project>
</Workspace>,
showCompletionInArgumentLists:=showCompletionInArgumentLists)
state.SendInvokeCompletionList()
Await state.AssertCompletionItemsContainAll({"Goo", "Bar", "Baz", "True", "False"})
state.SendTypeChars("Go")
state.SendTab()
Await state.AssertNoCompletionSession()
Assert.Contains("#if true and Goo", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
End Using
End Function
<WpfTheory, CombinatorialData>
Public Async Function CompletionInPreprocessorAndAlso(showCompletionInArgumentLists As Boolean) As Task
Using state = TestStateFactory.CreateTestStateFromWorkspace(
<Workspace>
<Project Language="Visual Basic" CommonReferences="true" PreprocessorSymbols="Goo=1,Bar=2,Baz=3">
<Document>
#if true andalso $$
</Document>
</Project>
</Workspace>,
showCompletionInArgumentLists:=showCompletionInArgumentLists)
state.SendInvokeCompletionList()
Await state.AssertCompletionItemsContainAll({"Goo", "Bar", "Baz", "True", "False"})
state.SendTypeChars("Go")
state.SendTab()
Await state.AssertNoCompletionSession()
Assert.Contains("#if true andalso Goo", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
End Using
End Function
<WpfTheory, CombinatorialData>
Public Async Function CompletionInPreprocessorOr(showCompletionInArgumentLists As Boolean) As Task
Using state = TestStateFactory.CreateTestStateFromWorkspace(
<Workspace>
<Project Language="Visual Basic" CommonReferences="true" PreprocessorSymbols="Goo=1,Bar=2,Baz=3">
<Document>
#if true or $$
</Document>
</Project>
</Workspace>,
showCompletionInArgumentLists:=showCompletionInArgumentLists)
state.SendInvokeCompletionList()
Await state.AssertCompletionItemsContainAll({"Goo", "Bar", "Baz", "True", "False"})
state.SendTypeChars("Go")
state.SendTab()
Await state.AssertNoCompletionSession()
Assert.Contains("#if true or Goo", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
End Using
End Function
<WpfTheory, CombinatorialData>
Public Async Function CompletionInPreprocessorOrElse(showCompletionInArgumentLists As Boolean) As Task
Using state = TestStateFactory.CreateTestStateFromWorkspace(
<Workspace>
<Project Language="Visual Basic" CommonReferences="true" PreprocessorSymbols="Goo=1,Bar=2,Baz=3">
<Document>
#if true orelse $$
</Document>
</Project>
</Workspace>,
showCompletionInArgumentLists:=showCompletionInArgumentLists)
state.SendInvokeCompletionList()
Await state.AssertCompletionItemsContainAll({"Goo", "Bar", "Baz", "True", "False"})
state.SendTypeChars("Go")
state.SendTab()
Await state.AssertNoCompletionSession()
Assert.Contains("#if true orelse Goo", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
End Using
End Function
<WpfTheory, CombinatorialData>
Public Async Function CompletionInPreprocessorCasingDifference(showCompletionInArgumentLists As Boolean) As Task
Using state = TestStateFactory.CreateTestStateFromWorkspace(
<Workspace>
<Project Language="Visual Basic" CommonReferences="true" PreprocessorSymbols="Goo=1,Bar=2,BAR=2,Baz=3">
<Document>
#if $$
</Document>
</Project>
</Workspace>,
showCompletionInArgumentLists:=showCompletionInArgumentLists)
state.SendInvokeCompletionList()
Await state.AssertCompletionItemsContainAll({"Goo", "Bar", "Baz", "True", "False"})
state.SendTypeChars("Go")
state.SendTab()
Await state.AssertNoCompletionSession()
Assert.Contains("#if Goo", state.GetLineTextFromCaretPosition(), StringComparison.Ordinal)
End Using
End Function
<ExportLanguageService(GetType(ISnippetInfoService), LanguageNames.VisualBasic, ServiceLayer.Test), [Shared], PartNotDiscoverable>
Friend Class MockSnippetInfoService
Implements ISnippetInfoService
<ImportingConstructor>
<Obsolete(MefConstruction.ImportingConstructorMessage, True)>
Public Sub New()
End Sub
Public Function GetSnippetsAsync_NonBlocking() As IEnumerable(Of SnippetInfo) Implements ISnippetInfoService.GetSnippetsIfAvailable
Return SpecializedCollections.SingletonEnumerable(New SnippetInfo("Shortcut", "Title", "Description", "Path"))
End Function
Public Function ShouldFormatSnippet(snippetInfo As SnippetInfo) As Boolean Implements ISnippetInfoService.ShouldFormatSnippet
Return False
End Function
Public Function SnippetShortcutExists_NonBlocking(shortcut As String) As Boolean Implements ISnippetInfoService.SnippetShortcutExists_NonBlocking
Return shortcut = "Shortcut"
End Function
End Class
<WpfFact, Trait(Traits.Feature, Traits.Features.Completion)>
Public Async Function SelectEnumMemberAdditionalFilterTextMatchOverFilterTextMatchWithLowerPriority() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Enum Colors
Red
Green
End Enum
Class Program
Property Green As Program
Sub M()
Dim x As Colors = Green$$
End Sub
End Class
</Document>)
state.SendInvokeCompletionList()
Await state.AssertCompletionItemsContainAll("Colors.Green", "Green")
Await state.AssertSelectedCompletionItem("Colors.Green", isHardSelected:=True)
End Using
End Function
<WpfFact, Trait(Traits.Feature, Traits.Features.Completion)>
Public Async Function DoNotSelectEnumMemberAdditionalFilterTextMatchOverBetterFilterTextMatch() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Enum Colors
Red
Green
End Enum
Class Program
Sub M()
Dim gree = ""
Dim x As Colors = gree$$
End Sub
End Class
</Document>)
state.SendInvokeCompletionList()
Await state.AssertCompletionItemsContainAll("Colors.Green", "gree")
Await state.AssertSelectedCompletionItem("gree", isHardSelected:=True)
End Using
End Function
<WpfFact, WorkItem("http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/815963")>
Public Async Function TestEnumMemberContainsLocal() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Enum E
A
End Enum
Class C
Sub M()
Const e As E = e$$
End Sub
End Class
</Document>)
state.SendInvokeCompletionList()
Await state.AssertCompletionItemsContainAll("e", "E", "E.A")
Await state.AssertCompletionItemsDoNotContainAny("e As E")
End Using
End Function
<WpfFact, Trait(Traits.Feature, Traits.Features.Completion)>
Public Async Function TestEnumMembersMatchTargetType() As Task
Using state = TestStateFactory.CreateVisualBasicTestState(
<Document>
Enum Colors
Red
Green
End Enum
Class Program
Property Green As Program
Sub M()
Dim x As Colors = $$
End Sub
End Class
</Document>)
Await state.SendInvokeCompletionListAndWaitForUiRenderAsync()
Await state.AssertCompletionItemsContainAll("Colors.Red", "Colors.Green", "Colors")
Dim oldFilters = state.GetCompletionItemFilters()
Dim newFiltersBuilder = ArrayBuilder(Of Data.CompletionFilterWithState).GetInstance()
Dim hasTargetTypedFilter = False
For Each oldState In oldFilters
If Object.ReferenceEquals(oldState.Filter, FilterSet.TargetTypedFilter) Then
hasTargetTypedFilter = True
newFiltersBuilder.Add(oldState.WithSelected(True))
Continue For
End If
newFiltersBuilder.Add(oldState.WithSelected(False))
Next
Assert.True(hasTargetTypedFilter)
Await state.RaiseFiltersChangedAndWaitForUiRenderAsync(newFiltersBuilder.ToImmutableAndFree())
Await state.AssertCompletionItemsContainAll("Colors.Red", "Colors.Green")
Await state.AssertCompletionItemsDoNotContainAny("Colors")
End Using
End Function
<WpfFact, WorkItem("https://github.com/dotnet/roslyn/issues/64531")>
<Trait(Traits.Feature, Traits.Features.Completion)>
Public Async Function AttributeCompletionNoColonsIfAlreadyPresent() As Task
Dim documentContent = "
Imports System
Class Test
Inherits Attribute
Public Property Text As String
End Class
<Test($$:=)>
Class Goo
End Class"
Using state = TestStateFactory.CreateVisualBasicTestState(<Document><%= documentContent %></Document>)
state.SendTypeChars("Tex")
Await state.AssertSelectedCompletionItem("Text", displayTextSuffix:=Nothing)
state.SendTab()
Await state.WaitForAsynchronousOperationsAsync()
state.AssertMatchesTextStartingAtLine(14, "<Test(Text:=)>")
End Using
End Function
End Class
End Namespace
|