public async Task VisualBasicOutliningTagger()
{
var code = @"Imports System
Namespace MyNamespace
#Region ""MyRegion""
Module MyClass
Sub Main(args As String())
Dim x As Integer = 5
End Sub
End Module
#End Region
End Namespace";
using (var workspace = await TestWorkspace.CreateVisualBasicAsync(code))
{
var tags = await GetTagsFromWorkspaceAsync(workspace);
// ensure all 4 outlining region tags were found
Assert.Equal(4, tags.Count);
// ensure only the method outlining region is marked as an implementation
Assert.False(tags[0].IsImplementation);
Assert.False(tags[1].IsImplementation);
Assert.False(tags[2].IsImplementation);
Assert.True(tags[3].IsImplementation);
// verify line counts
var hints = tags.Select(x => x.CollapsedHintForm).Cast <ViewHostingControl>().Select(vhc => vhc.TextView_TestOnly).ToList();
Assert.Equal(9, hints[0].TextSnapshot.LineCount); // namespace
Assert.Equal(7, hints[1].TextSnapshot.LineCount); // region
Assert.Equal(5, hints[2].TextSnapshot.LineCount); // class
Assert.Equal(3, hints[3].TextSnapshot.LineCount); // method
hints.Do(v => v.Close());
}
}
public static async Task <ChangeSignatureTestState> CreateAsync(string markup, string languageName, ParseOptions parseOptions = null)
{
var workspace = languageName == LanguageNames.CSharp
? await TestWorkspace.CreateCSharpAsync(markup, exportProvider : s_exportProvider, parseOptions : (CSharpParseOptions)parseOptions)
: await TestWorkspace.CreateVisualBasicAsync(markup, exportProvider : s_exportProvider, parseOptions : parseOptions, compilationOptions : new VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
return(new ChangeSignatureTestState(workspace));
}
public static async Task <ExtractInterfaceTestState> CreateAsync(string markup, string languageName, CompilationOptions compilationOptions)
{
var workspace = languageName == LanguageNames.CSharp
? await TestWorkspace.CreateCSharpAsync(markup, exportProvider : ExportProvider, compilationOptions : compilationOptions as CSharpCompilationOptions)
: await TestWorkspace.CreateVisualBasicAsync(markup, exportProvider : ExportProvider, compilationOptions : compilationOptions);
return(new ExtractInterfaceTestState(workspace));
}
private async Task <TestWorkspace> CreateWorkspaceAsync(string language, string code, ParseOptions options = null)
{
var workspace = (language == LanguageNames.CSharp) ?
await TestWorkspace.CreateCSharpAsync(code, parseOptions : options, exportProvider : TestHostServices.SharedExportProvider) :
await TestWorkspace.CreateVisualBasicAsync(code, parseOptions : options, exportProvider : TestHostServices.SharedExportProvider);
workspace.Options = workspace.Options.WithChangedOption(RemoteHostOptions.RemoteHostTest, true)
.WithChangedOption(ServiceFeatureOnOffOptions.ClosedFileDiagnostic, LanguageNames.CSharp, true)
.WithChangedOption(ServiceFeatureOnOffOptions.ClosedFileDiagnostic, LanguageNames.VisualBasic, true);
return(workspace);
}
public static async Task <GenerateTypeTestState> CreateAsync(
string initial,
bool isLine,
string projectToBeModified,
string typeName,
string existingFileName,
string languageName)
{
var workspace = languageName == LanguageNames.CSharp
? isLine ? await TestWorkspace.CreateCSharpAsync(initial, exportProvider : s_exportProvider) : await TestWorkspace.CreateAsync(initial, exportProvider : s_exportProvider)
: isLine ? await TestWorkspace.CreateVisualBasicAsync(initial, exportProvider : s_exportProvider) : await TestWorkspace.CreateAsync(initial, exportProvider : s_exportProvider);
return(new GenerateTypeTestState(projectToBeModified, typeName, existingFileName, workspace));
}
private static Task <TestWorkspace> CreateWorkspaceFromFileAsync(string source, string language, string rootNamespace)
{
if (language == LanguageNames.CSharp)
{
return(TestWorkspace.CreateCSharpAsync(source));
}
else
{
return(TestWorkspace.CreateVisualBasicAsync(
source,
compilationOptions: new VisualBasic.VisualBasicCompilationOptions(
OutputKind.DynamicallyLinkedLibrary, rootNamespace: rootNamespace)));
}
}
public async Task OutliningTaggerTooltipText()
{
var code = @"Module Module1
Sub Main(args As String())
End Sub
End Module";
using (var workspace = await TestWorkspace.CreateVisualBasicAsync(code))
{
var tags = await GetTagsFromWorkspaceAsync(workspace);
var hints = tags.Select(x => x.CollapsedHintForm).Cast <ViewHostingControl>().ToArray();
Assert.Equal("Sub Main(args As String())\r\nEnd Sub", hints[1].ToString()); // method
hints.Do(v => v.TextView_TestOnly.Close());
}
}
private static async Task <TestWorkspace> CreateWorkspaceFromFileAsync(string file, bool isVisualBasic, ParseOptions parseOptions, CompilationOptions compilationOptions)
{
return(isVisualBasic ?
await TestWorkspace.CreateVisualBasicAsync(file, (VB.VisualBasicParseOptions) parseOptions, (VB.VisualBasicCompilationOptions) compilationOptions) :
await TestWorkspace.CreateCSharpAsync(file, (CS.CSharpParseOptions) parseOptions, (CS.CSharpCompilationOptions) compilationOptions));
}
