private static string[] GetSupportedDiagnosticIdsForCodeCleanupService(string language)
{
using var workspace = GetTestWorkspaceForLanguage(language);
var hostdoc = workspace.Documents.Single();
var document = workspace.CurrentSolution.GetDocument(hostdoc.Id);
var codeCleanupService = document.GetLanguageService <ICodeCleanupService>();
var enabledDiagnostics = codeCleanupService.GetAllDiagnostics();
var supportedDiagnostics = enabledDiagnostics.Diagnostics.SelectMany(x => x.DiagnosticIds).ToArray();
return(supportedDiagnostics);
TestWorkspace GetTestWorkspaceForLanguage(string language)
{
if (language == LanguageNames.CSharp)
{
return(TestWorkspace.CreateCSharp(string.Empty, composition: EditorTestCompositions.EditorFeaturesWpf));
}
if (language == LanguageNames.VisualBasic)
{
return(TestWorkspace.CreateVisualBasic(string.Empty, composition: EditorTestCompositions.EditorFeaturesWpf));
}
return(null);
}
}
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 = TestWorkspace.CreateVisualBasic(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());
}
}
private TestLspServer CreateTestLspServer(
string[] markups,
out Dictionary <string, IList <LSP.Location> > locations,
string languageName
)
{
var workspace = languageName switch
{
LanguageNames.CSharp
=> TestWorkspace.CreateCSharp(markups, composition: Composition),
LanguageNames.VisualBasic
=> TestWorkspace.CreateVisualBasic(markups, composition: Composition),
_
=> throw new ArgumentException(
$"language name {languageName} is not valid for a test workspace"
),
};
RegisterWorkspaceForLsp(workspace);
var solution = workspace.CurrentSolution;
foreach (var document in workspace.Documents)
{
solution = solution.WithDocumentFilePath(
document.Id,
GetDocumentFilePathFromName(document.Name)
);
}
workspace.ChangeSolution(solution);
locations = GetAnnotatedLocations(workspace, solution);
return(new TestLspServer(workspace));
}
public static ChangeSignatureTestState Create(
string markup,
string languageName,
ParseOptions parseOptions = null,
OptionsCollection options = null
)
{
var workspace = languageName switch
{
"XML" => TestWorkspace.Create(markup, composition: s_composition),
LanguageNames.CSharp
=> TestWorkspace.CreateCSharp(
markup,
composition: s_composition,
parseOptions: (CSharpParseOptions)parseOptions
),
LanguageNames.VisualBasic
=> TestWorkspace.CreateVisualBasic(
markup,
composition: s_composition,
parseOptions: parseOptions,
compilationOptions: new VisualBasicCompilationOptions(
OutputKind.DynamicallyLinkedLibrary
)
),
_ => throw new ArgumentException("Invalid language name.")
};
if (options != null)
{
workspace.ApplyOptions(options);
}
return(new ChangeSignatureTestState(workspace));
}
public static ExtractInterfaceTestState Create(string markup, string languageName, CompilationOptions compilationOptions)
{
var workspace = languageName == LanguageNames.CSharp
? TestWorkspace.CreateCSharp(markup, exportProvider: ExportProvider, compilationOptions: compilationOptions as CSharpCompilationOptions)
: TestWorkspace.CreateVisualBasic(markup, exportProvider: ExportProvider, compilationOptions: compilationOptions);
return(new ExtractInterfaceTestState(workspace));
}
public static ChangeSignatureTestState Create(string markup, string languageName, ParseOptions parseOptions = null)
{
var workspace = languageName == LanguageNames.CSharp
? TestWorkspace.CreateCSharp(markup, exportProvider: s_exportProvider, parseOptions: (CSharpParseOptions)parseOptions)
: TestWorkspace.CreateVisualBasic(markup, exportProvider: s_exportProvider, parseOptions: parseOptions, compilationOptions: new VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
return(new ChangeSignatureTestState(workspace));
}
public object FormatVisualBasic()
{
var path = Path.Combine(Path.GetFullPath(@"..\..\..\..\..\src\Compilers\VisualBasic\Portable\Generated"), Document + ".vb");
var text = File.ReadAllText(path);
using var workspace = TestWorkspace.CreateVisualBasic(text);
var document = workspace.CurrentSolution.GetDocument(workspace.Documents.First().Id);
return(Formatter.GetFormattedTextChanges(document.GetSyntaxRootSynchronously(CancellationToken.None), workspace));
}
private Task <TestLspServer> CreateTestLspServerAsync(string[] markups, string languageName)
{
var workspace = languageName switch
{
LanguageNames.CSharp => TestWorkspace.CreateCSharp(markups, composition: Composition),
LanguageNames.VisualBasic => TestWorkspace.CreateVisualBasic(markups, composition: Composition),
_ => throw new ArgumentException($"language name {languageName} is not valid for a test workspace"),
};
return(CreateTestLspServerAsync(workspace));
}
public object FormatVisualBasic()
{
var path = Path.Combine(Path.GetFullPath(@"..\..\..\..\..\src\Compilers\VisualBasic\Portable\Generated"), Document + ".vb");
var text = File.ReadAllText(path);
using var workspace = TestWorkspace.CreateVisualBasic(text);
var document = workspace.CurrentSolution.GetDocument(workspace.Documents.First().Id);
var root = document.GetSyntaxRootSynchronously(CancellationToken.None);
var options = workspace.Services.GetLanguageServices(LanguageNames.CSharp).GetRequiredService <ISyntaxFormattingService>().GetFormattingOptions(DictionaryAnalyzerConfigOptions.Empty);
return(Formatter.GetFormattedTextChanges(root, workspace.Services, options, CancellationToken.None));
}
private TestWorkspace CreateWorkspace(string language, string code, ParseOptions options = null)
{
var workspace = (language == LanguageNames.CSharp) ?
TestWorkspace.CreateCSharp(code, parseOptions: options, exportProvider: TestHostServices.CreateExportProvider()) :
TestWorkspace.CreateVisualBasic(code, parseOptions: options, exportProvider: TestHostServices.CreateExportProvider());
workspace.Options = workspace.Options.WithChangedOption(RemoteHostOptions.RemoteHostTest, true)
.WithChangedOption(SolutionCrawlerOptions.BackgroundAnalysisScopeOption, LanguageNames.CSharp, BackgroundAnalysisScope.FullSolution)
.WithChangedOption(SolutionCrawlerOptions.BackgroundAnalysisScopeOption, LanguageNames.VisualBasic, BackgroundAnalysisScope.FullSolution);
return(workspace);
}
private TestWorkspace CreateWorkspace(string language, string code, ParseOptions options = null)
{
var workspace = (language == LanguageNames.CSharp) ?
TestWorkspace.CreateCSharp(code, parseOptions: options, exportProvider: TestHostServices.SharedExportProvider) :
TestWorkspace.CreateVisualBasic(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 async Task VisualBasicLanguageServiceTest()
{
var code = @"Class Test
Sub Method()
End Sub
End Class";
using var workspace = TestWorkspace.CreateVisualBasic(code, composition: s_composition);
var results = await GetVsSearchResultsAsync(workspace, "met");
Assert.Equal("Method", Assert.Single(results).Name);
}
private static TestWorkspace CreateWorkspaceFromFile(string source, string language, string rootNamespace)
{
if (language == LanguageNames.CSharp)
{
return(TestWorkspace.CreateCSharp(source));
}
else
{
return(TestWorkspace.CreateVisualBasic(
source,
compilationOptions: new VisualBasic.VisualBasicCompilationOptions(
OutputKind.DynamicallyLinkedLibrary, rootNamespace: rootNamespace)));
}
}
private TestWorkspace CreateWorkspace(string language, string code, ParseOptions options = null)
{
var composition = EditorTestCompositions.EditorFeatures.AddParts(typeof(InProcRemoteHostClientProvider.Factory));
var workspace = (language == LanguageNames.CSharp) ?
TestWorkspace.CreateCSharp(code, parseOptions: options, composition: composition) :
TestWorkspace.CreateVisualBasic(code, parseOptions: options, composition: composition);
workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(workspace.Options
.WithChangedOption(SolutionCrawlerOptions.BackgroundAnalysisScopeOption, LanguageNames.CSharp, BackgroundAnalysisScope.FullSolution)
.WithChangedOption(SolutionCrawlerOptions.BackgroundAnalysisScopeOption, LanguageNames.VisualBasic, BackgroundAnalysisScope.FullSolution)));
return(workspace);
}
private static TestWorkspace CreateWorkspaceFromFile(string source, string language, string rootNamespace)
{
if (language == LanguageNames.CSharp)
{
return(TestWorkspace.CreateCSharp(source, composition: s_compositionWithMockDiagnosticUpdateSourceRegistrationService));
}
else
{
return(TestWorkspace.CreateVisualBasic(
source,
compilationOptions: new VisualBasic.VisualBasicCompilationOptions(
OutputKind.DynamicallyLinkedLibrary, rootNamespace: rootNamespace),
composition: s_compositionWithMockDiagnosticUpdateSourceRegistrationService));
}
}
public async Task OutliningTaggerTooltipText()
{
var code = @"Module Module1
Sub Main(args As String())
End Sub
End Module";
using var workspace = TestWorkspace.CreateVisualBasic(code, composition: EditorTestCompositions.EditorFeaturesWpf);
var tags = await GetTagsFromWorkspaceAsync(workspace);
var hints = tags.Select(x => x.GetCollapsedHintForm()).Cast <ViewHostingControl>().ToArray();
Assert.Equal("Sub Main(args As String())\r\nEnd Sub", hints[1].GetText_TestOnly()); // method
hints.Do(v => v.TextView_TestOnly.Close());
}
public static GenerateTypeTestState Create(
string initial,
string projectToBeModified,
string typeName,
string existingFileName,
string languageName)
{
var workspace = TestWorkspace.IsWorkspaceElement(initial)
? TestWorkspace.Create(initial, exportProvider: s_exportProvider)
: languageName == LanguageNames.CSharp
? TestWorkspace.CreateCSharp(initial, exportProvider: s_exportProvider)
: TestWorkspace.CreateVisualBasic(initial, exportProvider: s_exportProvider);
return(new GenerateTypeTestState(projectToBeModified, typeName, existingFileName, workspace));
}
public static ExtractInterfaceTestState Create(
string markup,
string languageName,
CompilationOptions compilationOptions = null,
ParseOptions parseOptions = null,
OptionsCollection options = null)
{
var workspace = languageName == LanguageNames.CSharp
? TestWorkspace.CreateCSharp(markup, composition: Composition, compilationOptions: compilationOptions, parseOptions: parseOptions)
: TestWorkspace.CreateVisualBasic(markup, composition: Composition, compilationOptions: compilationOptions, parseOptions: parseOptions);
options?.SetGlobalOptions(workspace.GlobalOptions);
return(new ExtractInterfaceTestState(workspace));
}
public async Task VisualBasicOutliningTagger()
{
var code =
@"Imports System
Namespace MyNamespace
#Region ""MyRegion""
Module M
Sub Main(args As String())
Dim x As Integer = 5
End Sub
End Module
#End Region
End Namespace";
using var workspace = TestWorkspace.CreateVisualBasic(
code,
composition: EditorTestCompositions.EditorFeaturesWpf
);
var tags = await GetTagsFromWorkspaceAsync(workspace);
Assert.Collection(
tags,
namespaceTag =>
{
Assert.False(namespaceTag.IsImplementation);
Assert.Equal(9, GetCollapsedHintLineCount(namespaceTag));
Assert.Equal("Namespace MyNamespace", GetHeaderText(namespaceTag));
},
regionTag =>
{
Assert.False(regionTag.IsImplementation);
Assert.Equal(7, GetCollapsedHintLineCount(regionTag));
Assert.Equal(@"#Region ""MyRegion""", GetHeaderText(regionTag));
},
moduleTag =>
{
Assert.False(moduleTag.IsImplementation);
Assert.Equal(5, GetCollapsedHintLineCount(moduleTag));
Assert.Equal("Module M", GetHeaderText(moduleTag));
},
methodTag =>
{
Assert.True(methodTag.IsImplementation);
Assert.Equal(3, GetCollapsedHintLineCount(methodTag));
Assert.Equal("Sub Main(args As String())", GetHeaderText(methodTag));
}
);
}
private Task <TestLspServer> CreateTestLspServerAsync(string[] markups, string[] sourceGeneratedMarkups, string languageName, LSP.ClientCapabilities?clientCapabilities, WellKnownLspServerKinds serverKind = WellKnownLspServerKinds.AlwaysActiveVSLspServer)
{
var exportProvider = Composition.ExportProviderFactory.CreateExportProvider();
var syntaxTreeConfigurationService = exportProvider.GetExportedValue <TestSyntaxTreeConfigurationService>();
syntaxTreeConfigurationService.EnableOpeningSourceGeneratedFilesInWorkspace = true;
var workspace = languageName switch
{
LanguageNames.CSharp => TestWorkspace.CreateCSharp(markups, sourceGeneratedMarkups, exportProvider: exportProvider),
LanguageNames.VisualBasic => TestWorkspace.CreateVisualBasic(markups, sourceGeneratedMarkups, exportProvider: exportProvider),
_ => throw new ArgumentException($"language name {languageName} is not valid for a test workspace"),
};
return(CreateTestLspServerAsync(workspace, clientCapabilities, serverKind));
}
public async Task VisualBasicLanguageServiceTest()
{
var code = @"Class Test
Sub Method()
End Sub
End Class";
using (var workspace = TestWorkspace.CreateVisualBasic(code))
{
var solution = workspace.CurrentSolution;
var results = await GetVsSearchResultsAsync(solution, WellKnownServiceHubServices.LanguageServer, "met");
Assert.Equal(1, results.Count);
Assert.Equal(1, results[0].Symbols.Length);
Assert.Equal("Method", results[0].Symbols[0].Name);
}
}
public static ExtractInterfaceTestState Create(
string markup,
string languageName,
CompilationOptions compilationOptions = null,
ParseOptions parseOptions = null,
OptionsCollection options = null)
{
var workspace = languageName == LanguageNames.CSharp
? TestWorkspace.CreateCSharp(markup, composition: Composition, compilationOptions: compilationOptions, parseOptions: parseOptions)
: TestWorkspace.CreateVisualBasic(markup, composition: Composition, compilationOptions: compilationOptions, parseOptions: parseOptions);
if (options != null)
{
foreach (var kvp in options)
{
workspace.SetOptions(workspace.Options.WithChangedOption(kvp.Key, kvp.Value));
}
}
return(new ExtractInterfaceTestState(workspace));
}
internal async Task TestWithMockedGenerateTypeDialog(
string initial,
string languageName,
string typeName,
string expected = null,
bool isMissing = false,
Accessibility accessibility = Accessibility.NotApplicable,
TypeKind typeKind = TypeKind.Class,
string projectName = null,
bool isNewFile = false,
string existingFilename = null,
ImmutableArray <string> newFileFolderContainers = default,
string fullFilePath = null,
string newFileName = null,
string assertClassName = null,
bool checkIfUsingsIncluded = false,
bool checkIfUsingsNotIncluded = false,
string expectedTextWithUsings = null,
string defaultNamespace = "",
bool areFoldersValidIdentifiers = true,
GenerateTypeDialogOptions assertGenerateTypeDialogOptions = null,
IList <TypeKindOptions> assertTypeKindPresent = null,
IList <TypeKindOptions> assertTypeKindAbsent = null,
bool isCancelled = false)
{
var workspace = TestWorkspace.IsWorkspaceElement(initial)
? TestWorkspace.Create(initial)
: languageName == LanguageNames.CSharp
? TestWorkspace.CreateCSharp(initial)
: TestWorkspace.CreateVisualBasic(initial);
var testOptions = new TestParameters();
var(diagnostics, actions, _) = await GetDiagnosticAndFixesAsync(workspace, testOptions);
using var testState = new GenerateTypeTestState(workspace, projectToBeModified: projectName, typeName, existingFilename);
// Initialize the viewModel values
testState.TestGenerateTypeOptionsService.SetGenerateTypeOptions(
accessibility: accessibility,
typeKind: typeKind,
typeName: testState.TypeName,
project: testState.ProjectToBeModified,
isNewFile: isNewFile,
newFileName: newFileName,
folders: newFileFolderContainers,
fullFilePath: fullFilePath,
existingDocument: testState.ExistingDocument,
areFoldersValidIdentifiers: areFoldersValidIdentifiers,
isCancelled: isCancelled);
testState.TestProjectManagementService.SetDefaultNamespace(
defaultNamespace: defaultNamespace);
var generateTypeDiagFixes = diagnostics.SingleOrDefault(df => GenerateTypeTestState.FixIds.Contains(df.Id));
if (isMissing)
{
Assert.Empty(actions);
return;
}
var fixActions = MassageActions(actions);
Assert.False(fixActions.IsDefault);
// Since the dialog option is always fed as the last CodeAction
var index = fixActions.Count() - 1;
var action = fixActions.ElementAt(index);
Assert.Equal(action.Title, FeaturesResources.Generate_new_type);
var operations = await action.GetOperationsAsync(CancellationToken.None);
Tuple <Solution, Solution> oldSolutionAndNewSolution = null;
if (!isNewFile)
{
oldSolutionAndNewSolution = await TestOperationsAsync(
testState.Workspace, expected, operations,
conflictSpans : ImmutableArray <TextSpan> .Empty,
renameSpans : ImmutableArray <TextSpan> .Empty,
warningSpans : ImmutableArray <TextSpan> .Empty,
navigationSpans : ImmutableArray <TextSpan> .Empty,
expectedChangedDocumentId : testState.ExistingDocument.Id);
}
else
{
oldSolutionAndNewSolution = await TestAddDocument(
testState.Workspace,
expected,
operations,
projectName != null,
testState.ProjectToBeModified.Id,
newFileFolderContainers,
newFileName);
}
if (checkIfUsingsIncluded)
{
Assert.NotNull(expectedTextWithUsings);
await TestOperationsAsync(testState.Workspace, expectedTextWithUsings, operations,
conflictSpans : ImmutableArray <TextSpan> .Empty,
renameSpans : ImmutableArray <TextSpan> .Empty,
warningSpans : ImmutableArray <TextSpan> .Empty,
navigationSpans : ImmutableArray <TextSpan> .Empty,
expectedChangedDocumentId : testState.InvocationDocument.Id);
}
if (checkIfUsingsNotIncluded)
{
var oldSolution = oldSolutionAndNewSolution.Item1;
var newSolution = oldSolutionAndNewSolution.Item2;
var changedDocumentIds = SolutionUtilities.GetChangedDocuments(oldSolution, newSolution);
Assert.False(changedDocumentIds.Contains(testState.InvocationDocument.Id));
}
// Added into a different project than the triggering project
if (projectName != null)
{
var appliedChanges = ApplyOperationsAndGetSolution(testState.Workspace, operations);
var newSolution = appliedChanges.Item2;
var triggeredProject = newSolution.GetProject(testState.TriggeredProject.Id);
// Make sure the Project reference is present
Assert.True(triggeredProject.ProjectReferences.Any(pr => pr.ProjectId == testState.ProjectToBeModified.Id));
}
// Assert Option Calculation
if (assertClassName != null)
{
Assert.True(assertClassName == testState.TestGenerateTypeOptionsService.ClassName);
}
if (assertGenerateTypeDialogOptions != null || assertTypeKindPresent != null || assertTypeKindAbsent != null)
{
var generateTypeDialogOptions = testState.TestGenerateTypeOptionsService.GenerateTypeDialogOptions;
if (assertGenerateTypeDialogOptions != null)
{
Assert.True(assertGenerateTypeDialogOptions.IsPublicOnlyAccessibility == generateTypeDialogOptions.IsPublicOnlyAccessibility);
Assert.True(assertGenerateTypeDialogOptions.TypeKindOptions == generateTypeDialogOptions.TypeKindOptions);
Assert.True(assertGenerateTypeDialogOptions.IsAttribute == generateTypeDialogOptions.IsAttribute);
}
if (assertTypeKindPresent != null)
{
foreach (var typeKindPresentEach in assertTypeKindPresent)
{
Assert.True((typeKindPresentEach & generateTypeDialogOptions.TypeKindOptions) != 0);
}
}
if (assertTypeKindAbsent != null)
{
foreach (var typeKindPresentEach in assertTypeKindAbsent)
{
Assert.True((typeKindPresentEach & generateTypeDialogOptions.TypeKindOptions) == 0);
}
}
}
}
private static TestWorkspace CreateWorkspaceFromFile(string file, bool isVisualBasic, ParseOptions parseOptions, CompilationOptions compilationOptions)
{
return(isVisualBasic ?
TestWorkspace.CreateVisualBasic(file, (VB.VisualBasicParseOptions)parseOptions, (VB.VisualBasicCompilationOptions)compilationOptions) :
TestWorkspace.CreateCSharp(file, (CS.CSharpParseOptions)parseOptions, (CS.CSharpCompilationOptions)compilationOptions));
}
public async Task VisualBasicOutliningTagger(
bool collapseRegionsWhenCollapsingToDefinitions,
bool showBlockStructureGuidesForDeclarationLevelConstructs,
bool showBlockStructureGuidesForCodeLevelConstructs)
{
var code = @"Imports System
Namespace MyNamespace
#Region ""MyRegion""
Module M
Sub Main(args As String())
If False Then
Return
End If
Dim x As Integer = 5
End Sub
End Module
#End Region
End Namespace";
using var workspace = TestWorkspace.CreateVisualBasic(code, composition: EditorTestCompositions.EditorFeaturesWpf);
workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(workspace.Options
.WithChangedOption(BlockStructureOptions.CollapseRegionsWhenCollapsingToDefinitions, LanguageNames.VisualBasic, collapseRegionsWhenCollapsingToDefinitions)
.WithChangedOption(BlockStructureOptions.ShowBlockStructureGuidesForDeclarationLevelConstructs, LanguageNames.VisualBasic, showBlockStructureGuidesForDeclarationLevelConstructs)
.WithChangedOption(BlockStructureOptions.ShowBlockStructureGuidesForCodeLevelConstructs, LanguageNames.VisualBasic, showBlockStructureGuidesForCodeLevelConstructs)));
var tags = await GetTagsFromWorkspaceAsync(workspace);
Assert.Collection(tags,
namespaceTag =>
{
Assert.False(namespaceTag.IsImplementation);
Assert.Equal(13, GetCollapsedHintLineCount(namespaceTag));
Assert.Equal(showBlockStructureGuidesForDeclarationLevelConstructs ? PredefinedStructureTagTypes.Namespace : PredefinedStructureTagTypes.Nonstructural, namespaceTag.Type);
Assert.Equal("Namespace MyNamespace", GetHeaderText(namespaceTag));
},
regionTag =>
{
Assert.Equal(collapseRegionsWhenCollapsingToDefinitions, regionTag.IsImplementation);
Assert.Equal(11, GetCollapsedHintLineCount(regionTag));
Assert.Equal(PredefinedStructureTagTypes.Nonstructural, regionTag.Type);
Assert.Equal(@"#Region ""MyRegion""", GetHeaderText(regionTag));
},
moduleTag =>
{
Assert.False(moduleTag.IsImplementation);
Assert.Equal(9, GetCollapsedHintLineCount(moduleTag));
Assert.Equal(showBlockStructureGuidesForDeclarationLevelConstructs ? PredefinedStructureTagTypes.Type : PredefinedStructureTagTypes.Nonstructural, moduleTag.Type);
Assert.Equal("Module M", GetHeaderText(moduleTag));
},
methodTag =>
{
Assert.True(methodTag.IsImplementation);
Assert.Equal(7, GetCollapsedHintLineCount(methodTag));
Assert.Equal(showBlockStructureGuidesForDeclarationLevelConstructs ? PredefinedStructureTagTypes.Member : PredefinedStructureTagTypes.Nonstructural, methodTag.Type);
Assert.Equal("Sub Main(args As String())", GetHeaderText(methodTag));
},
ifTag =>
{
Assert.False(ifTag.IsImplementation);
Assert.Equal(3, GetCollapsedHintLineCount(ifTag));
Assert.Equal(showBlockStructureGuidesForCodeLevelConstructs ? PredefinedStructureTagTypes.Conditional : PredefinedStructureTagTypes.Nonstructural, ifTag.Type);
Assert.Equal("If False Then", GetHeaderText(ifTag));
});
}
protected override TestWorkspace CreateWorkspace(string code, TestComposition composition) => TestWorkspace.CreateVisualBasic(code, composition: composition);
