public static async Task <ExtractInterfaceTestState> CreateAsync(string markup, string languageName, CompilationOptions compilationOptions)
{
var workspace = languageName == LanguageNames.CSharp
? await CSharpWorkspaceFactory.CreateWorkspaceFromFileAsync(markup, exportProvider : ExportProvider, compilationOptions : compilationOptions as CSharpCompilationOptions)
: await VisualBasicWorkspaceFactory.CreateWorkspaceFromFileAsync(markup, exportProvider : ExportProvider, compilationOptions : compilationOptions);
return(new ExtractInterfaceTestState(workspace));
}
public static async Task <ChangeSignatureTestState> CreateAsync(string markup, string languageName, ParseOptions parseOptions = null)
{
var workspace = languageName == LanguageNames.CSharp
? await CSharpWorkspaceFactory.CreateWorkspaceFromFileAsync(markup, exportProvider : s_exportProvider, parseOptions : (CSharpParseOptions)parseOptions)
: await VisualBasicWorkspaceFactory.CreateWorkspaceFromFileAsync(markup, exportProvider : s_exportProvider, parseOptions : parseOptions, compilationOptions : new VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
return(new ChangeSignatureTestState(workspace));
}
public GenerateTypeTestState(
string initial,
bool isLine,
string projectToBeModified,
string typeName,
string existingFileName,
string languageName)
: this(projectToBeModified, typeName, existingFileName, languageName == LanguageNames.CSharp
? isLine ? CSharpWorkspaceFactory.CreateWorkspaceFromFile(initial, exportProvider : s_exportProvider) : CSharpWorkspaceFactory.CreateWorkspace(initial, exportProvider : s_exportProvider)
: isLine ? VisualBasicWorkspaceFactory.CreateWorkspaceFromFile(initial, exportProvider : s_exportProvider) : VisualBasicWorkspaceFactory.CreateWorkspace(initial, exportProvider : s_exportProvider))
{
}
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 CSharpWorkspaceFactory.CreateWorkspaceFromFileAsync(initial, exportProvider : s_exportProvider) : await TestWorkspaceFactory.CreateWorkspaceAsync(initial, exportProvider : s_exportProvider)
: isLine ? await VisualBasicWorkspaceFactory.CreateWorkspaceFromFileAsync(initial, exportProvider : s_exportProvider) : await TestWorkspaceFactory.CreateWorkspaceAsync(initial, exportProvider : s_exportProvider);
return(new GenerateTypeTestState(projectToBeModified, typeName, existingFileName, workspace));
}
private static TestWorkspace CreateWorkspaceFromFile(string source, string language, string rootNamespace)
{
if (language == LanguageNames.CSharp)
{
return(CSharpWorkspaceFactory.CreateWorkspaceFromFile(source));
}
else
{
return(VisualBasicWorkspaceFactory.CreateWorkspaceFromFile(
source,
compilationOptions: new VisualBasic.VisualBasicCompilationOptions(
OutputKind.DynamicallyLinkedLibrary, rootNamespace: rootNamespace)));
}
}
public void OutliningTaggerTooltipText()
{
var code = new string[]
{
"Module Module1",
" Sub Main(args As String())",
" End Sub",
"End Module",
};
using (var workspace = VisualBasicWorkspaceFactory.CreateWorkspaceFromLines(code))
{
var tags = GetTagsFromWorkspace(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());
}
}
public void VisualBasicOutliningTagger()
{
var code = new string[]
{
"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 = VisualBasicWorkspaceFactory.CreateWorkspaceFromLines(code))
{
var tags = GetTagsFromWorkspace(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(5, hints[1].TextSnapshot.LineCount); // class
Assert.Equal(7, hints[2].TextSnapshot.LineCount); // region
Assert.Equal(3, hints[3].TextSnapshot.LineCount); // method
hints.Do(v => v.Close());
}
}
protected VisualBasicCodeFixActionsVerifier(VisualBasicWorkspaceFactory factory)
: base(factory)
{
}
public ChangeSignatureTestState(string markup, string languageName, ParseOptions parseOptions = null)
: this(languageName == LanguageNames.CSharp
? CSharpWorkspaceFactory.CreateWorkspaceFromFile(markup, exportProvider : s_exportProvider, parseOptions : (CSharpParseOptions)parseOptions)
: VisualBasicWorkspaceFactory.CreateWorkspaceFromFile(markup, exportProvider : s_exportProvider, parseOptions : parseOptions, compilationOptions : new VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary)))
{
}
private static async Task <TestWorkspace> CreateWorkspaceFromFileAsync(string file, bool isVisualBasic, ParseOptions parseOptions, CompilationOptions compilationOptions)
{
return(isVisualBasic ?
await VisualBasicWorkspaceFactory.CreateWorkspaceFromFileAsync(file, (VB.VisualBasicParseOptions) parseOptions, (VB.VisualBasicCompilationOptions) compilationOptions) :
await CSharpWorkspaceFactory.CreateWorkspaceFromFileAsync(file, (CS.CSharpParseOptions) parseOptions, (CS.CSharpCompilationOptions) compilationOptions));
}
private static TestWorkspace CreateWorkspaceFromFile(string file, bool isVisualBasic, ParseOptions parseOptions, CompilationOptions compilationOptions)
{
return(isVisualBasic ?
VisualBasicWorkspaceFactory.CreateWorkspaceFromFile(file, (VB.VisualBasicParseOptions)parseOptions, (VB.VisualBasicCompilationOptions)compilationOptions) :
CSharpWorkspaceFactory.CreateWorkspaceFromFile(file, (CS.CSharpParseOptions)parseOptions, (CS.CSharpCompilationOptions)compilationOptions));
}
public ExtractInterfaceTestState(string markup, string languageName, CompilationOptions compilationOptions)
: this(languageName == LanguageNames.CSharp
? CSharpWorkspaceFactory.CreateWorkspaceFromFile(markup, exportProvider : ExportProvider, compilationOptions : compilationOptions as CSharpCompilationOptions)
: VisualBasicWorkspaceFactory.CreateWorkspaceFromFile(markup, exportProvider : ExportProvider, compilationOptions : compilationOptions))
{
}
