public static Task<TestWorkspace> CreateWorkspaceFromFilesAsync(
string[] files,
CSharpParseOptions[] parseOptions = null,
CSharpCompilationOptions compilationOptions = null,
ExportProvider exportProvider = null)
{
return CreateWorkspaceFromFilesAsync(LanguageNames.CSharp, compilationOptions, parseOptions, files, exportProvider);
}
public static Task<TestWorkspace> CreateWorkspaceFromLinesAsync(
string[] lines,
ExportProvider exportProvider,
string[] metadataReferences = null)
{
var file = lines.Join(Environment.NewLine);
return CreateWorkspaceFromFileAsync(file, exportProvider: exportProvider, metadataReferences: metadataReferences);
}
public static IWpfTextView CreateView(
string contentType,
ExportProvider exportProvider,
params string[] lines)
{
var buffer = CreateBuffer(contentType, exportProvider, lines);
return exportProvider.GetExportedValue<ITextEditorFactoryService>().CreateTextView(buffer);
}
/// <param name="files">Can pass in multiple file contents with individual source kind: files will be named test1.vb, test2.vbx, etc.</param>
public static Task<TestWorkspace> CreateWorkspaceFromFilesAsync(
string[] files,
ParseOptions[] parseOptions = null,
CompilationOptions compilationOptions = null,
ExportProvider exportProvider = null)
{
return TestWorkspaceFactory.CreateWorkspaceFromFilesAsync(LanguageNames.VisualBasic, compilationOptions, parseOptions, files, exportProvider);
}
static VisualStudioTestExportProvider()
{
PartCatalog =
TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(
MinimalTestExportProvider.CreateAssemblyCatalog(typeof(CSharpCodeModelService).Assembly));
ExportProvider = MinimalTestExportProvider.CreateExportProvider(PartCatalog);
}
/// <param name="content">Can pass in multiple file contents: files will be named test1.cs, test2.cs, etc.</param>
/// <param name="parseOptions">Parse the source code in interactive mode</param>
public static TestWorkspace CreateWorkspaceFromFile(
string file,
CSharpParseOptions parseOptions = null,
CSharpCompilationOptions compilationOptions = null,
ExportProvider exportProvider = null,
string[] metadataReferences = null)
{
return CreateWorkspaceFromFiles(new[] { file }, parseOptions, compilationOptions, exportProvider, metadataReferences);
}
public static Task<TestWorkspace> CreateWorkspaceFromFileAsync(
string file,
ParseOptions parseOptions = null,
CompilationOptions compilationOptions = null,
ExportProvider exportProvider = null,
string[] metadataReferences = null)
{
return CreateWorkspaceFromFilesAsync(new[] { file }, parseOptions, compilationOptions, exportProvider, metadataReferences);
}
/// <param name="files">Can pass in multiple file contents: files will be named test1.cs, test2.cs, etc.</param>
public static TestWorkspace CreateWorkspaceFromFiles(
string[] files,
CSharpParseOptions parseOptions = null,
CSharpCompilationOptions compilationOptions = null,
ExportProvider exportProvider = null,
string[] metadataReferences = null)
{
return CreateWorkspaceFromFiles(LanguageNames.CSharp, compilationOptions, parseOptions, files, exportProvider, metadataReferences);
}
/// <param name="files">Can pass in multiple file contents: files will be named test1.vb, test2.vb, etc. and additional metadata references</param>
public static TestWorkspace CreateWorkspaceFromFiles(
string[] files,
ParseOptions parseOptions = null,
CompilationOptions compilationOptions = null,
ExportProvider exportProvider = null,
string[] metadataReferences = null)
{
return TestWorkspaceFactory.CreateWorkspaceFromFiles(LanguageNames.VisualBasic, compilationOptions, parseOptions, files, exportProvider, metadataReferences);
}
public static Task<TestWorkspace> CreateWorkspaceFromLinesAsync(
string[] lines,
CSharpParseOptions parseOptions = null,
CSharpCompilationOptions compilationOptions = null,
ExportProvider exportProvider = null)
{
var file = lines.Join(Environment.NewLine);
return CreateWorkspaceFromFileAsync(file, parseOptions, compilationOptions, exportProvider);
}
public static TestWorkspace CreateWorkspace(
XElement workspaceElement,
bool completed = true,
bool openDocuments = true,
ExportProvider exportProvider = null,
string workspaceKind = null)
{
return CreateWorkspaceAsync(workspaceElement, completed, openDocuments, exportProvider, workspaceKind).WaitAndGetResult(CancellationToken.None);
}
/// <summary>
/// The add.
/// </summary>
/// <param name="provider">
/// The provider.
/// </param>
public void Add(ExportProvider provider)
{
Contract.Requires<ArgumentNullException>(provider != null, "provider");
lock (_providers)
{
_providers.Add(provider);
provider.ExportsChanged += OnExportsChanged;
}
}
public static ITextBuffer CreateBuffer(
string contentType,
ExportProvider exportProvider,
params string[] lines)
{
var text = LinesToFullText(lines);
var intContentType = exportProvider.GetExportedValue<IContentTypeRegistryService>().GetContentType(contentType);
var buffer = exportProvider.GetExportedValue<ITextBufferFactoryService>().CreateTextBuffer(intContentType);
buffer.Replace(new Span(0, 0), text);
return buffer;
}
public static IWpfTextView CreateView(
string contentType,
ExportProvider exportProvider,
params string[] lines)
{
TestWorkspace.ResetThreadAffinity();
WpfTestCase.RequireWpfFact($"Creates an IWpfTextView through {nameof(EditorFactory)}.{nameof(CreateView)}");
var buffer = CreateBuffer(contentType, exportProvider, lines);
return exportProvider.GetExportedValue<ITextEditorFactoryService>().CreateTextView(buffer);
}
private static TestHostProject CreateProject(
XElement workspaceElement,
XElement projectElement,
ExportProvider exportProvider,
TestWorkspace workspace,
Dictionary<XElement, string> projectElementToAssemblyName,
Dictionary<XElement, string> documentElementToFilePath,
Dictionary<string, ITextBuffer> filePathToTextBufferMap,
ref int projectId,
ref int documentId)
{
var language = GetLanguage(workspace, projectElement);
var assemblyName = GetAssemblyName(workspace, projectElement, ref projectId);
projectElementToAssemblyName.Add(projectElement, assemblyName);
string filePath;
if (projectElement.Attribute(FilePathAttributeName) != null)
{
filePath = projectElement.Attribute(FilePathAttributeName).Value;
if (string.Compare(filePath, NullFilePath, StringComparison.Ordinal) == 0)
{
// allow explicit null file path
filePath = null;
}
}
else
{
filePath = assemblyName +
(language == LanguageNames.CSharp ? ".csproj" :
language == LanguageNames.VisualBasic ? ".vbproj" : ("." + language));
}
var contentTypeRegistryService = exportProvider.GetExportedValue<IContentTypeRegistryService>();
var languageServices = workspace.Services.GetLanguageServices(language);
var compilationOptions = CreateCompilationOptions(workspace, projectElement, language);
var parseOptions = GetParseOptions(projectElement, language, languageServices);
var references = CreateReferenceList(workspace, projectElement);
var analyzers = CreateAnalyzerList(workspace, projectElement);
var documents = new List<TestHostDocument>();
var documentElements = projectElement.Elements(DocumentElementName).ToList();
foreach (var documentElement in documentElements)
{
var document = CreateDocument(
workspace,
workspaceElement,
documentElement,
language,
exportProvider,
languageServices,
filePathToTextBufferMap,
ref documentId);
documents.Add(document);
documentElementToFilePath.Add(documentElement, document.FilePath);
}
return new TestHostProject(languageServices, compilationOptions, parseOptions, assemblyName, references, documents, filePath: filePath, analyzerReferences: analyzers);
}
public static TestWorkspace Create(string xmlDefinition, bool openDocuments = false, ExportProvider exportProvider = null, TestComposition composition = null) => Create(XElement.Parse(xmlDefinition), openDocuments, exportProvider, composition);
/// <inheritdoc cref="Microsoft.CodeAnalysis.Testing.ExportProviderExtensions.AsCompositionContext" /> public static CompositionContext AsCompositionContext(this ExportProvider exportProvider) => new CompositionContextShim(exportProvider);
public TestWorkspace GetWorkspace(ExportProvider exportProvider = null)
{
_workspace = _workspace ?? CreateWorkspace(exportProvider);
return(_workspace);
}
/// <summary>
/// Initialization of the package; this method is called right after the package is sited, so this is the place
/// where you can put all the initialization code that rely on services provided by VisualStudio.
/// </summary>
protected override async Task InitializeAsync(CancellationToken token, IProgress <ServiceProgressData> progress)
{
try
{
_componentModel = await GetServiceAsync <SComponentModel, IComponentModel>();
CredentialsStore = _componentModel.GetService <ICredentialsStore>();
ExportProvider mefExportProvider = _componentModel.DefaultExportProvider;
_shellUtilsLazy = mefExportProvider.GetExport <IShellUtils>();
_gcpOutputWindowLazy = mefExportProvider.GetExport <IGcpOutputWindow>();
_processService = mefExportProvider.GetExport <IProcessService>();
_statusbarService = mefExportProvider.GetExport <IStatusbarService>();
_userPromptService = mefExportProvider.GetExport <IUserPromptService>();
_dataSourceFactory = mefExportProvider.GetExport <IDataSourceFactory>();
Dte = await GetServiceAsync <SDTE, DTE2>();
// Remember the package.
Instance = this;
// Activity log utils, to aid in debugging.
IVsActivityLog activityLog = await GetServiceAsync <SVsActivityLog, IVsActivityLog>();
await activityLog.LogInfoAsync("Starting Google Cloud Tools.");
// Register the command handlers.
await Task.WhenAll(
CloudExplorerCommand.InitializeAsync(this, token),
ManageAccountsCommand.InitializeAsync(this, token),
PublishProjectMainMenuCommand.InitializeAsync(this, token),
PublishProjectContextMenuCommand.InitializeAsync(this, token),
LogsViewerToolWindowCommand.InitializeAsync(this, token),
GenerateConfigurationContextMenuCommand.InitializeAsync(this, token),
ErrorReportingToolWindowCommand.InitializeAsync(this, token));
// Update the installation status of the package.
await CheckInstallationStatusAsync();
// Ensure the commands UI state is updated when the GCP project changes.
CredentialsStore.CurrentProjectIdChanged += (o, e) => ShellUtils.InvalidateCommandsState();
// With this setting we allow more concurrent connections from each HttpClient instance created
// in the process. This will allow all GCP API services to have more concurrent connections with
// GCP servers. The first benefit of this is that we can upload more concurrent files to GCS.
ServicePointManager.DefaultConnectionLimit = MaximumConcurrentConnections;
IVsRegisterUIFactories registerUIFactories =
await GetServiceAsync <SVsUIFactory, IVsRegisterUIFactories>();
var controlFactory = _componentModel.GetService <GcpMenuBarControlFactory>();
await registerUIFactories.RegisterUIFactoryAsync(controlFactory, token);
}
catch (Exception e)
{
IVsActivityLog activityLog = await GetServiceAsync <SVsActivityLog, IVsActivityLog>();
await activityLog.LogErrorAsync(e.Message);
await activityLog.LogErrorAsync(e.StackTrace);
}
}
internal static TestWorkspace CreateWorkspaceFromFiles(
string language,
CompilationOptions compilationOptions,
ParseOptions parseOptions,
string[] files,
ExportProvider exportProvider,
string[] metadataReferences = null,
string workspaceKind = null,
string extension = null,
bool commonReferences = true)
{
var documentElements = new List<XElement>();
var index = 1;
if (extension == null)
{
extension = language == LanguageNames.CSharp
? CSharpExtension
: VisualBasicExtension;
}
foreach (var file in files)
{
documentElements.Add(CreateDocumentElement(file, "test" + index++ + extension, parseOptions));
}
metadataReferences = metadataReferences ?? SpecializedCollections.EmptyArray<string>();
foreach (var reference in metadataReferences)
{
documentElements.Add(CreateMetadataReference(reference));
}
var workspaceElement = CreateWorkspaceElement(
CreateProjectElement(compilationOptions?.ModuleName ?? "Test", language, commonReferences, parseOptions, compilationOptions, documentElements));
return CreateWorkspace(workspaceElement, exportProvider: exportProvider, workspaceKind: workspaceKind);
}
private string GetListenerTrace(ExportProvider provider)
{
var sb = new StringBuilder();
var workspaceWaiter = GetListeners(provider).First(l => l.Metadata.FeatureName == FeatureAttribute.Workspace).Value as TestAsynchronousOperationListener;
sb.AppendLine("workspace");
sb.AppendLine(workspaceWaiter.Trace());
var solutionCrawlerWaiter = GetListeners(provider).First(l => l.Metadata.FeatureName == FeatureAttribute.SolutionCrawler).Value as TestAsynchronousOperationListener;
sb.AppendLine("solutionCrawler");
sb.AppendLine(solutionCrawlerWaiter.Trace());
return sb.ToString();
}
public static ITextBuffer CreateBuffer(
ExportProvider exportProvider,
params string[] lines)
{
return(CreateBuffer("text", exportProvider, lines));
}
public App()
{
var cmdArgs = Environment.GetCommandLineArgs().Skip(1);
App.CommandLineArguments = new CommandLineArguments(cmdArgs);
if ((App.CommandLineArguments.SingleInstance ?? true) && !MiscSettingsPanel.CurrentMiscSettings.AllowMultipleInstances)
{
cmdArgs = cmdArgs.Select(FullyQualifyPath);
string message = string.Join(Environment.NewLine, cmdArgs);
if (SendToPreviousInstance("ILSpy:\r\n" + message, !App.CommandLineArguments.NoActivate))
{
Environment.Exit(0);
}
}
InitializeComponent();
if (!System.Diagnostics.Debugger.IsAttached)
{
AppDomain.CurrentDomain.UnhandledException += ShowErrorBox;
Dispatcher.CurrentDispatcher.UnhandledException += Dispatcher_UnhandledException;
}
TaskScheduler.UnobservedTaskException += DotNet40_UnobservedTaskException;
// Cannot show MessageBox here, because WPF would crash with a XamlParseException
// Remember and show exceptions in text output, once MainWindow is properly initialized
try {
// Set up VS MEF. For now, only do MEF1 part discovery, since that was in use before.
// To support both MEF1 and MEF2 parts, just change this to:
// var discovery = PartDiscovery.Combine(new AttributedPartDiscoveryV1(Resolver.DefaultInstance),
// new AttributedPartDiscovery(Resolver.DefaultInstance));
var discovery = new AttributedPartDiscoveryV1(Resolver.DefaultInstance);
var catalog = ComposableCatalog.Create(Resolver.DefaultInstance);
var pluginDir = Path.GetDirectoryName(typeof(App).Module.FullyQualifiedName);
if (pluginDir != null)
{
foreach (var plugin in Directory.GetFiles(pluginDir, "*.Plugin.dll"))
{
var name = Path.GetFileNameWithoutExtension(plugin);
try {
var asm = Assembly.Load(name);
var parts = discovery.CreatePartsAsync(asm).GetAwaiter().GetResult();
catalog = catalog.AddParts(parts);
} catch (Exception ex) {
StartupExceptions.Add(new ExceptionData {
Exception = ex, PluginName = name
});
}
}
}
// Add the built-in parts
catalog = catalog.AddParts(discovery.CreatePartsAsync(Assembly.GetExecutingAssembly()).GetAwaiter().GetResult());
// If/When the project switches to .NET Standard/Core, this will be needed to allow metadata interfaces (as opposed
// to metadata classes). When running on .NET Framework, it's automatic.
// catalog.WithDesktopSupport();
// If/When any part needs to import ICompositionService, this will be needed:
// catalog.WithCompositionService();
var config = CompositionConfiguration.Create(catalog);
exportProviderFactory = config.CreateExportProviderFactory();
exportProvider = exportProviderFactory.CreateExportProvider();
// This throws exceptions for composition failures. Alternatively, the configuration's CompositionErrors property
// could be used to log the errors directly. Used at the end so that it does not prevent the export provider setup.
config.ThrowOnErrors();
} catch (Exception ex) {
StartupExceptions.Add(new ExceptionData {
Exception = ex
});
}
Languages.Initialize(exportProvider);
EventManager.RegisterClassHandler(typeof(Window),
Hyperlink.RequestNavigateEvent,
new RequestNavigateEventHandler(Window_RequestNavigate));
ILSpyTraceListener.Install();
}
public ExportProviderMefHostServices(ExportProvider exportProvider)
: base(new ContainerConfiguration().CreateContainer())
{
_mefV1HostServices = MefV1HostServices.Create(exportProvider.AsExportProvider());
}
/// <summary>
/// This can use input files with an (optionally) annotated span 'Selection' and a cursor position ($$),
/// and use it to create a selected span in the TextView.
///
/// For instance, the following will create a TextView that has a multiline selection with the cursor at the end.
///
/// Sub Goo
/// {|Selection:SomeMethodCall()
/// AnotherMethodCall()$$|}
/// End Sub
///
/// You can use multiple selection spans to create box selections.
///
/// Sub Goo
/// {|Selection:$$box|}11111
/// {|Selection:sel|}111
/// {|Selection:ect|}1
/// {|Selection:ion|}1111111
/// End Sub
/// </summary>
public AbstractCommandHandlerTestState(
XElement workspaceElement,
ExportProvider exportProvider,
string workspaceKind)
{
this.Workspace = TestWorkspace.CreateWorkspace(
workspaceElement,
exportProvider: exportProvider,
workspaceKind: workspaceKind);
var cursorDocument = this.Workspace.Documents.First(d => d.CursorPosition.HasValue);
_textView = cursorDocument.GetTextView();
_subjectBuffer = cursorDocument.GetTextBuffer();
if (cursorDocument.AnnotatedSpans.TryGetValue("Selection", out var selectionSpanList))
{
var firstSpan = selectionSpanList.First();
var lastSpan = selectionSpanList.Last();
var cursorPosition = cursorDocument.CursorPosition.Value;
Assert.True(cursorPosition == firstSpan.Start || cursorPosition == firstSpan.End ||
cursorPosition == lastSpan.Start || cursorPosition == lastSpan.End,
"cursorPosition wasn't at an endpoint of the 'Selection' annotated span");
_textView.Selection.Mode = selectionSpanList.Length > 1
? TextSelectionMode.Box
: TextSelectionMode.Stream;
SnapshotPoint boxSelectionStart, boxSelectionEnd;
bool isReversed;
if (cursorPosition == firstSpan.Start || cursorPosition == lastSpan.End)
{
// Top-left and bottom-right corners used as anchor points.
boxSelectionStart = new SnapshotPoint(_subjectBuffer.CurrentSnapshot, firstSpan.Start);
boxSelectionEnd = new SnapshotPoint(_subjectBuffer.CurrentSnapshot, lastSpan.End);
isReversed = cursorPosition == firstSpan.Start;
}
else
{
// Top-right and bottom-left corners used as anchor points.
boxSelectionStart = new SnapshotPoint(_subjectBuffer.CurrentSnapshot, firstSpan.End);
boxSelectionEnd = new SnapshotPoint(_subjectBuffer.CurrentSnapshot, lastSpan.Start);
isReversed = cursorPosition == firstSpan.End;
}
_textView.Selection.Select(
new SnapshotSpan(boxSelectionStart, boxSelectionEnd),
isReversed: isReversed);
}
else
{
_textView.Caret.MoveTo(
new SnapshotPoint(
_textView.TextBuffer.CurrentSnapshot,
cursorDocument.CursorPosition.Value));
}
this.EditorOperations = GetService <IEditorOperationsFactoryService>().GetEditorOperations(_textView);
this.UndoHistoryRegistry = GetService <ITextUndoHistoryRegistry>();
}
private async Task DoExport(bool pickDestination)
{
if (_report.IsBusy)
{
return;
}
string selectedReport = cbReport.SelectedItem as string;
if (string.IsNullOrEmpty(selectedReport))
{
return;
}
if (cbExportFilter.SelectedIndex < 0 || cbExportFilter.SelectedIndex >= _report.SupportedExportProviders.Length)
{
return;
}
ReportItem ri = tbReportFile.SelectedItem as ReportItem;
if (ri == null || (ri.File == null && ri.Caption == c_Browse))
{
return;
}
// load report
try
{
if (ri.File == null && ri.Caption == c_Builtin)
{
// load from resource stream
Assembly asm = typeof(ExportPage).GetTypeInfo().Assembly;
using (Stream stream = asm.GetManifestResourceStream("FlexReportSamples.Resources.FlexCommonTasks_UWP.flxr"))
_report.Load(stream, selectedReport);
}
else
{
await _report.LoadAsync(ri.File, selectedReport);
}
}
catch (Exception ex)
{
MessageDialog md = new MessageDialog(string.Format(Strings.FailedToLoadFmt, selectedReport, ex.Message), "Error");
await md.ShowAsync();
return;
}
// prepare ExportFilter object
ExportProvider ep = _report.SupportedExportProviders[cbExportFilter.SelectedIndex];
ExportFilter ef = ep.NewExporter() as ExportFilter;
ef.UseZipForMultipleFiles = cbUseZipForMultipleFiles.IsChecked.Value;
//
if ((ef is BmpFilter || ef is JpegFilter || ef is PngFilter || ef is GifFilter))
{
// these export filters produce more than one file during export
// ask for directory in this case
string defFileName = selectedReport + "." + ep.DefaultExtension + ".zip";
if (cbUseZipForMultipleFiles.IsChecked == true)
{
if (pickDestination)
{
// ask for zip file
FileSavePicker fsp = new FileSavePicker();
fsp.DefaultFileExtension = ".zip";
fsp.FileTypeChoices.Add(Strings.ZipFiles, new string[] { ".zip" });
fsp.SuggestedFileName = defFileName;
ef.StorageFile = await fsp.PickSaveFileAsync();
if (ef.StorageFile == null)
{
return;
}
}
else
{
// use file in temp folder
ef.StorageFile = await ApplicationData.Current.TemporaryFolder.CreateFileAsync(defFileName, CreationCollisionOption.ReplaceExisting);
}
}
else
{
if (pickDestination)
{
FolderPicker fp = new FolderPicker();
fp.FileTypeFilter.Add("." + ep.DefaultExtension);
fp.FileTypeFilter.Add(".zip");
ef.StorageFolder = await fp.PickSingleFolderAsync();
if (ef.StorageFolder == null)
{
// user cancels an export
return;
}
}
else
{
ef.StorageFolder = await ApplicationData.Current.TemporaryFolder.CreateFolderAsync(selectedReport, CreationCollisionOption.OpenIfExists);
}
}
}
else
{
string defFileName = selectedReport + "." + ep.DefaultExtension;
if (pickDestination)
{
// ask for file
FileSavePicker fsp = new FileSavePicker();
fsp.DefaultFileExtension = "." + ep.DefaultExtension;
fsp.FileTypeChoices.Add(ep.FormatName + " (." + ep.DefaultExtension + ")", new string[] { "." + ep.DefaultExtension });
fsp.FileTypeChoices.Add(Strings.ZipFiles, new string[] { ".zip" });
fsp.SuggestedFileName = defFileName;
ef.StorageFile = await fsp.PickSaveFileAsync();
if (ef.StorageFile == null)
{
return;
}
}
else
{
// use file in temp folder
ef.StorageFile = await ApplicationData.Current.TemporaryFolder.CreateFileAsync(defFileName, CreationCollisionOption.ReplaceExisting);
}
}
try
{
await _report.RenderToFilterAsync(ef);
//_report.RenderToFilter(ef);
await ShowPreview(ef);
}
catch (Exception ex)
{
MessageDialog md = new MessageDialog(string.Format(Strings.FailedToExportFmt, selectedReport, ex.Message), "Error");
await md.ShowAsync();
return;
}
}
public CompositionContextShim(ExportProvider exportProvider) => _exportProvider = exportProvider;
public static TestWorkspace CreateWorkspace(string xmlDefinition, bool completed = true, bool openDocuments = true, ExportProvider exportProvider = null)
{
return CreateWorkspace(XElement.Parse(xmlDefinition), completed, openDocuments, exportProvider);
}
protected override TestWorkspace CreateWorkspace(string content, ExportProvider exportProvider)
=> TestWorkspace.CreateCSharp(content, exportProvider: exportProvider);
public static IWpfTextView CreateView(
ExportProvider exportProvider,
params string[] lines)
{
return(CreateView("text", exportProvider, lines));
}
private static IEnumerable<Lazy<IAsynchronousOperationListener, FeatureMetadata>> GetListeners(ExportProvider provider)
{
return provider.GetExports<IAsynchronousOperationListener, FeatureMetadata>();
}
public static IWpfTextView CreateView(
ExportProvider exportProvider,
ITextBuffer buffer)
{
return(exportProvider.GetExportedValue <ITextEditorFactoryService>().CreateTextView(buffer));
}
/// <summary>
/// Tries to resolve.
/// </summary>
/// <param name="appServer">The application server.</param>
/// <param name="exportProvider">The export provider.</param>
/// <param name="result">The result.</param>
/// <returns></returns>
protected override bool TryResolve(IAppServer appServer, ExportProvider exportProvider, out List <TTarget> result)
{
result = default(List <TTarget>);
var config = appServer.Config;
var logger = appServer.Logger;
var factories = exportProvider.GetExports <TTarget, TMetadata>();
if (Required)
{
if (factories == null || !factories.Any())
{
logger.ErrorFormat("No factory for {0} defined.", typeof(TTarget).FullName);
return(false);
}
}
var configValue = ConfigSelector(config);
var configFactories = ("" + configValue).Split(",;|".ToArray(), StringSplitOptions.RemoveEmptyEntries);
if (configFactories.Length == 0)
{
if (Required)
{
logger.ErrorFormat("No selected {0} configured.", typeof(TTarget).FullName);
return(false);
}
return(true);
}
var finalFactories = new List <TTarget>(configFactories.Length);
foreach (var c in configFactories)
{
var lazyFactory = factories.FirstOrDefault(x => MetadataNameEqual(x.Metadata, c));
if (lazyFactory == null)
{
logger.ErrorFormat("No desired {0} '{1}' was found", typeof(TTarget).FullName, c);
return(false);
}
var factory = lazyFactory.Value;
if (!PrepareResult(factory, appServer, lazyFactory.Metadata))
{
return(false);
}
finalFactories.Add(factory);
}
if (!finalFactories.Any())
{
if (Required)
{
logger.ErrorFormat("No available factory of {0} was not found!", typeof(TTarget).FullName);
return(false);
}
return(true);
}
result = finalFactories;
return(true);
}
public MockServiceProvider(ExportProvider exportProvider)
{
_componentModel = new MockComponentModel(exportProvider);
}
private static TestHostDocument CreateDocument(
TestWorkspace workspace,
XElement workspaceElement,
XElement documentElement,
ExportProvider exportProvider,
HostLanguageServices languageServiceProvider,
IDocumentServiceProvider documentServiceProvider,
ref int documentId)
{
var isLinkFileAttribute = documentElement.Attribute(IsLinkFileAttributeName);
var isLinkFile = isLinkFileAttribute != null && ((bool?)isLinkFileAttribute).HasValue && ((bool?)isLinkFileAttribute).Value;
if (isLinkFile)
{
// This is a linked file. Use the filePath and markup from the referenced document.
var originalAssemblyName = documentElement.Attribute(LinkAssemblyNameAttributeName)?.Value;
var originalProjectName = documentElement.Attribute(LinkProjectNameAttributeName)?.Value;
if (originalAssemblyName == null && originalProjectName == null)
{
throw new ArgumentException($"Linked files must specify either a {LinkAssemblyNameAttributeName} or {LinkProjectNameAttributeName}");
}
var originalProject = workspaceElement.Elements(ProjectElementName).FirstOrDefault(p =>
{
if (originalAssemblyName != null)
{
return(p.Attribute(AssemblyNameAttributeName)?.Value == originalAssemblyName);
}
else
{
return(p.Attribute(ProjectNameAttribute)?.Value == originalProjectName);
}
});
if (originalProject == null)
{
if (originalProjectName != null)
{
throw new ArgumentException($"Linked file's {LinkProjectNameAttributeName} '{originalProjectName}' project not found.");
}
else
{
throw new ArgumentException($"Linked file's {LinkAssemblyNameAttributeName} '{originalAssemblyName}' project not found.");
}
}
var originalDocumentPath = documentElement.Attribute(LinkFilePathAttributeName)?.Value;
if (originalDocumentPath == null)
{
throw new ArgumentException($"Linked files must specify a {LinkFilePathAttributeName}");
}
documentElement = originalProject.Elements(DocumentElementName).FirstOrDefault(d =>
{
return(d.Attribute(FilePathAttributeName)?.Value == originalDocumentPath);
});
if (documentElement == null)
{
throw new ArgumentException($"Linked file's LinkFilePath '{originalDocumentPath}' file not found.");
}
}
var markupCode = documentElement.NormalizedValue();
var fileName = GetFileName(workspace, documentElement, ref documentId);
var folders = GetFolders(documentElement);
var optionsElement = documentElement.Element(ParseOptionsElementName);
// TODO: Allow these to be specified.
var codeKind = SourceCodeKind.Regular;
if (optionsElement != null)
{
var attr = optionsElement.Attribute(KindAttributeName);
codeKind = attr == null
? SourceCodeKind.Regular
: (SourceCodeKind)Enum.Parse(typeof(SourceCodeKind), attr.Value);
}
TestFileMarkupParser.GetPositionAndSpans(markupCode,
out var code, out int?cursorPosition, out ImmutableDictionary <string, ImmutableArray <TextSpan> > spans);
var testDocumentServiceProvider = GetDocumentServiceProvider(documentElement);
if (documentServiceProvider == null)
{
documentServiceProvider = testDocumentServiceProvider;
}
else if (testDocumentServiceProvider != null)
{
AssertEx.Fail($"The document attributes on file {fileName} conflicted");
}
return(new TestHostDocument(
exportProvider, languageServiceProvider, code, fileName, fileName, cursorPosition, spans, codeKind, folders, isLinkFile, documentServiceProvider));
}
public ExportProviderMefHostServices(ExportProvider exportProvider)
: base(new ContainerConfiguration().CreateContainer())
{
_vsHostServices = VisualStudioMefHostServices.Create(exportProvider);
}
private static IList <TestHostProject> CreateSubmissions(
TestWorkspace workspace,
IEnumerable <XElement> submissionElements,
ExportProvider exportProvider)
{
var submissions = new List <TestHostProject>();
var submissionIndex = 0;
foreach (var submissionElement in submissionElements)
{
var submissionName = "Submission" + (submissionIndex++);
var languageName = GetLanguage(workspace, submissionElement);
// The document
var markupCode = submissionElement.NormalizedValue();
string code;
int? cursorPosition;
IDictionary <string, IList <TextSpan> > spans;
MarkupTestFile.GetPositionAndSpans(markupCode, out code, out cursorPosition, out spans);
var languageServices = workspace.Services.GetLanguageServices(languageName);
var contentTypeLanguageService = languageServices.GetService <IContentTypeLanguageService>();
var contentType = contentTypeLanguageService.GetDefaultContentType();
var textBuffer = EditorFactory.CreateBuffer(contentType.TypeName, exportProvider, code);
// The project
var document = new TestHostDocument(exportProvider, languageServices, textBuffer, submissionName, cursorPosition, spans, SourceCodeKind.Interactive);
var documents = new List <TestHostDocument> {
document
};
if (languageName == NoCompilationConstants.LanguageName)
{
submissions.Add(
new TestHostProject(
languageServices,
compilationOptions: null,
parseOptions: null,
assemblyName: submissionName,
references: null,
documents: documents,
isSubmission: true));
continue;
}
var syntaxFactory = languageServices.GetService <ISyntaxTreeFactoryService>();
var compilationFactory = languageServices.GetService <ICompilationFactoryService>();
var compilationOptions = compilationFactory.GetDefaultCompilationOptions().WithOutputKind(OutputKind.DynamicallyLinkedLibrary);
var parseOptions = syntaxFactory.GetDefaultParseOptions().WithKind(SourceCodeKind.Interactive);
var references = CreateCommonReferences(workspace, submissionElement);
var project = new TestHostProject(
languageServices,
compilationOptions,
parseOptions,
submissionName,
references,
documents,
isSubmission: true);
submissions.Add(project);
}
return(submissions);
}
public MockServiceProvider(ExportProvider exportProvider)
{
_componentModel = new MockComponentModel(exportProvider);
}
private static TestHostProject CreateProject(
XElement workspaceElement,
XElement projectElement,
ExportProvider exportProvider,
TestWorkspace workspace,
Dictionary <XElement, string> projectElementToAssemblyName,
Dictionary <XElement, string> documentElementToFilePath,
Dictionary <string, ITextBuffer> filePathToTextBufferMap,
ref int projectId,
ref int documentId)
{
var language = GetLanguage(workspace, projectElement);
var assemblyName = GetAssemblyName(workspace, projectElement, ref projectId);
projectElementToAssemblyName.Add(projectElement, assemblyName);
string filePath;
if (projectElement.Attribute(FilePathAttributeName) != null)
{
filePath = projectElement.Attribute(FilePathAttributeName).Value;
if (string.Compare(filePath, NullFilePath, StringComparison.Ordinal) == 0)
{
// allow explicit null file path
filePath = null;
}
}
else
{
filePath = assemblyName +
(language == LanguageNames.CSharp ? ".csproj" :
language == LanguageNames.VisualBasic ? ".vbproj" : ("." + language));
}
var contentTypeRegistryService = exportProvider.GetExportedValue <IContentTypeRegistryService>();
var languageServices = workspace.Services.GetLanguageServices(language);
var compilationOptions = CreateCompilationOptions(workspace, projectElement, language);
var parseOptions = GetParseOptions(projectElement, language, languageServices);
var references = CreateReferenceList(workspace, projectElement);
var analyzers = CreateAnalyzerList(workspace, projectElement);
var documents = new List <TestHostDocument>();
var documentElements = projectElement.Elements(DocumentElementName).ToList();
foreach (var documentElement in documentElements)
{
var document = CreateDocument(
workspace,
workspaceElement,
documentElement,
language,
exportProvider,
languageServices,
filePathToTextBufferMap,
ref documentId);
documents.Add(document);
documentElementToFilePath.Add(documentElement, document.FilePath);
}
return(new TestHostProject(languageServices, compilationOptions, parseOptions, assemblyName, references, documents, filePath: filePath, analyzerReferences: analyzers));
}
private static IEnumerable <Lazy <IAsynchronousOperationListener, FeatureMetadata> > GetListeners(ExportProvider provider)
{
return(provider.GetExports <IAsynchronousOperationListener, FeatureMetadata>());
}
private void WaitWaiter(ExportProvider provider)
{
var workspasceWaiter = GetListeners(provider).First(l => l.Metadata.FeatureName == FeatureAttribute.Workspace).Value as IAsynchronousOperationWaiter;
workspasceWaiter.CreateWaitTask().PumpingWait();
var solutionCrawlerWaiter = GetListeners(provider).First(l => l.Metadata.FeatureName == FeatureAttribute.SolutionCrawler).Value as IAsynchronousOperationWaiter;
solutionCrawlerWaiter.CreateWaitTask().PumpingWait();
}
public TestHostDocument(string text = "", string displayName = "", SourceCodeKind sourceCodeKind = SourceCodeKind.Regular, DocumentId id = null)
{
_exportProvider = TestExportProvider.ExportProviderWithCSharpAndVisualBasic;
_id = id;
_initialText = text;
_name = displayName;
_sourceCodeKind = sourceCodeKind;
_loader = new TestDocumentLoader(this);
}
private static TestHostDocument CreateDocument(
TestWorkspace workspace,
XElement workspaceElement,
XElement documentElement,
string language,
ExportProvider exportProvider,
HostLanguageServices languageServiceProvider,
Dictionary <string, ITextBuffer> filePathToTextBufferMap,
ref int documentId)
{
string markupCode;
string filePath;
var isLinkFileAttribute = documentElement.Attribute(IsLinkFileAttributeName);
bool isLinkFile = isLinkFileAttribute != null && ((bool?)isLinkFileAttribute).HasValue && ((bool?)isLinkFileAttribute).Value;
if (isLinkFile)
{
// This is a linked file. Use the filePath and markup from the referenced document.
var originalProjectName = documentElement.Attribute(LinkAssemblyNameAttributeName);
var originalDocumentPath = documentElement.Attribute(LinkFilePathAttributeName);
if (originalProjectName == null || originalDocumentPath == null)
{
throw new ArgumentException("Linked file specified without LinkAssemblyName or LinkFilePath.");
}
var originalProjectNameStr = originalProjectName.Value;
var originalDocumentPathStr = originalDocumentPath.Value;
var originalProject = workspaceElement.Elements(ProjectElementName).First(p =>
{
var assemblyName = p.Attribute(AssemblyNameAttributeName);
return(assemblyName != null && assemblyName.Value == originalProjectNameStr);
});
if (originalProject == null)
{
throw new ArgumentException("Linked file's LinkAssemblyName '{0}' project not found.", originalProjectNameStr);
}
var originalDocument = originalProject.Elements(DocumentElementName).First(d =>
{
var documentPath = d.Attribute(FilePathAttributeName);
return(documentPath != null && documentPath.Value == originalDocumentPathStr);
});
if (originalDocument == null)
{
throw new ArgumentException("Linked file's LinkFilePath '{0}' file not found.", originalDocumentPathStr);
}
markupCode = originalDocument.NormalizedValue();
filePath = GetFilePath(workspace, originalDocument, ref documentId);
}
else
{
markupCode = documentElement.NormalizedValue();
filePath = GetFilePath(workspace, documentElement, ref documentId);
}
var folders = GetFolders(documentElement);
var optionsElement = documentElement.Element(ParseOptionsElementName);
// TODO: Allow these to be specified.
var codeKind = SourceCodeKind.Regular;
if (optionsElement != null)
{
var attr = optionsElement.Attribute(KindAttributeName);
codeKind = attr == null
? SourceCodeKind.Regular
: (SourceCodeKind)Enum.Parse(typeof(SourceCodeKind), attr.Value);
}
var contentTypeLanguageService = languageServiceProvider.GetService <IContentTypeLanguageService>();
var contentType = contentTypeLanguageService.GetDefaultContentType();
string code;
int? cursorPosition;
IDictionary <string, IList <TextSpan> > spans;
MarkupTestFile.GetPositionAndSpans(markupCode, out code, out cursorPosition, out spans);
// For linked files, use the same ITextBuffer for all linked documents
ITextBuffer textBuffer;
if (!filePathToTextBufferMap.TryGetValue(filePath, out textBuffer))
{
textBuffer = EditorFactory.CreateBuffer(contentType.TypeName, exportProvider, code);
filePathToTextBufferMap.Add(filePath, textBuffer);
}
return(new TestHostDocument(exportProvider, languageServiceProvider, textBuffer, filePath, cursorPosition, spans, codeKind, folders, isLinkFile));
}
private static TestHostProject CreateProject(
XElement workspaceElement,
XElement projectElement,
ExportProvider exportProvider,
TestWorkspace workspace,
IDocumentServiceProvider documentServiceProvider,
ref int projectId,
ref int documentId)
{
AssertNoChildText(projectElement);
var language = GetLanguage(workspace, projectElement);
var assemblyName = GetAssemblyName(workspace, projectElement, ref projectId);
string filePath;
var projectName = projectElement.Attribute(ProjectNameAttribute)?.Value ?? assemblyName;
if (projectElement.Attribute(FilePathAttributeName) != null)
{
filePath = projectElement.Attribute(FilePathAttributeName).Value;
if (string.Compare(filePath, NullFilePath, StringComparison.Ordinal) == 0)
{
// allow explicit null file path
filePath = null;
}
}
else
{
filePath = projectName +
(language == LanguageNames.CSharp ? ".csproj" :
language == LanguageNames.VisualBasic ? ".vbproj" : ("." + language));
}
var languageServices = workspace.Services.GetLanguageServices(language);
var parseOptions = GetParseOptions(projectElement, language, languageServices);
var compilationOptions = CreateCompilationOptions(workspace, projectElement, language, parseOptions);
var rootNamespace = GetRootNamespace(workspace, compilationOptions, projectElement);
var references = CreateReferenceList(workspace, projectElement);
var analyzers = CreateAnalyzerList(projectElement);
var documents = new List <TestHostDocument>();
var documentElements = projectElement.Elements(DocumentElementName).ToList();
foreach (var documentElement in documentElements)
{
var document = CreateDocument(
workspace,
workspaceElement,
documentElement,
exportProvider,
languageServices,
documentServiceProvider,
ref documentId);
documents.Add(document);
}
foreach (var sourceGeneratedDocumentElement in projectElement.Elements(DocumentFromSourceGeneratorElementName))
{
var name = GetFileName(workspace, sourceGeneratedDocumentElement, ref documentId);
var markupCode = sourceGeneratedDocumentElement.NormalizedValue();
MarkupTestFile.GetPositionAndSpans(markupCode,
out var code, out var cursorPosition, out IDictionary <string, ImmutableArray <TextSpan> > spans);
var documentFilePath = typeof(SingleFileTestGenerator).Assembly.GetName().Name + '\\' + typeof(SingleFileTestGenerator).FullName + '\\' + name;
var document = new TestHostDocument(exportProvider, languageServices, code, name, documentFilePath, cursorPosition, spans, isSourceGenerated: true);
documents.Add(document);
analyzers.Add(new TestGeneratorReference(new SingleFileTestGenerator(code, name)));
}
var additionalDocuments = new List <TestHostDocument>();
var additionalDocumentElements = projectElement.Elements(AdditionalDocumentElementName).ToList();
foreach (var additionalDocumentElement in additionalDocumentElements)
{
var document = CreateDocument(
workspace,
workspaceElement,
additionalDocumentElement,
exportProvider,
languageServices,
documentServiceProvider,
ref documentId);
additionalDocuments.Add(document);
}
var analyzerConfigDocuments = new List <TestHostDocument>();
var analyzerConfigElements = projectElement.Elements(AnalyzerConfigDocumentElementName).ToList();
foreach (var analyzerConfigElement in analyzerConfigElements)
{
var document = CreateDocument(
workspace,
workspaceElement,
analyzerConfigElement,
exportProvider,
languageServices,
documentServiceProvider,
ref documentId);
analyzerConfigDocuments.Add(document);
}
return(new TestHostProject(languageServices, compilationOptions, parseOptions, assemblyName, projectName, references, documents, additionalDocuments, analyzerConfigDocuments, filePath: filePath, analyzerReferences: analyzers, defaultNamespace: rootNamespace));
}
internal TestHostDocument(
ExportProvider exportProvider,
HostLanguageServices languageServiceProvider,
ITextBuffer textBuffer,
string filePath,
int? cursorPosition,
IDictionary<string, IList<TextSpan>> spans,
SourceCodeKind sourceCodeKind = SourceCodeKind.Regular,
IReadOnlyList<string> folders = null,
bool isLinkFile = false)
{
Contract.ThrowIfNull(textBuffer);
Contract.ThrowIfNull(filePath);
_exportProvider = exportProvider;
_languageServiceProvider = languageServiceProvider;
this.TextBuffer = textBuffer;
this.InitialTextSnapshot = textBuffer.CurrentSnapshot;
_filePath = filePath;
_folders = folders;
_name = filePath;
this.CursorPosition = cursorPosition;
_sourceCodeKind = sourceCodeKind;
this.IsLinkFile = isLinkFile;
this.SelectedSpans = new List<TextSpan>();
if (spans.ContainsKey(string.Empty))
{
this.SelectedSpans = spans[string.Empty];
}
this.AnnotatedSpans = new Dictionary<string, IList<TextSpan>>();
foreach (var namedSpanList in spans.Where(s => s.Key != string.Empty))
{
this.AnnotatedSpans.Add(namedSpanList);
}
_loader = new TestDocumentLoader(this);
}
public static TestWorkspace CreateWorkspace(string xmlDefinition, bool completed = true, bool openDocuments = true, ExportProvider exportProvider = null)
{
return(CreateWorkspace(XElement.Parse(xmlDefinition), completed, openDocuments, exportProvider));
}
private static IList<TestHostProject> CreateSubmissions(
TestWorkspace workspace,
IEnumerable<XElement> submissionElements,
ExportProvider exportProvider)
{
var submissions = new List<TestHostProject>();
var submissionIndex = 0;
foreach (var submissionElement in submissionElements)
{
var submissionName = "Submission" + (submissionIndex++);
var languageName = GetLanguage(workspace, submissionElement);
// The document
var markupCode = submissionElement.NormalizedValue();
string code;
int? cursorPosition;
IDictionary<string, IList<TextSpan>> spans;
MarkupTestFile.GetPositionAndSpans(markupCode, out code, out cursorPosition, out spans);
var languageServices = workspace.Services.GetLanguageServices(languageName);
var contentTypeLanguageService = languageServices.GetService<IContentTypeLanguageService>();
var contentType = contentTypeLanguageService.GetDefaultContentType();
var textBuffer = EditorFactory.CreateBuffer(contentType.TypeName, exportProvider, code);
// The project
var document = new TestHostDocument(exportProvider, languageServices, textBuffer, submissionName, cursorPosition, spans, SourceCodeKind.Script);
var documents = new List<TestHostDocument> { document };
if (languageName == NoCompilationConstants.LanguageName)
{
submissions.Add(
new TestHostProject(
languageServices,
compilationOptions: null,
parseOptions: null,
assemblyName: submissionName,
references: null,
documents: documents,
isSubmission: true));
continue;
}
var syntaxFactory = languageServices.GetService<ISyntaxTreeFactoryService>();
var compilationFactory = languageServices.GetService<ICompilationFactoryService>();
var compilationOptions = compilationFactory.GetDefaultCompilationOptions().WithOutputKind(OutputKind.DynamicallyLinkedLibrary);
var parseOptions = syntaxFactory.GetDefaultParseOptions().WithKind(SourceCodeKind.Script);
var references = CreateCommonReferences(workspace, submissionElement);
var project = new TestHostProject(
languageServices,
compilationOptions,
parseOptions,
submissionName,
references,
documents,
isSubmission: true);
submissions.Add(project);
}
return submissions;
}
public static TestWorkspace CreateWorkspace(
XElement workspaceElement,
bool completed = true,
bool openDocuments = true,
ExportProvider exportProvider = null,
string workspaceKind = null)
{
SynchronizationContext.SetSynchronizationContext(new DispatcherSynchronizationContext());
if (workspaceElement.Name != WorkspaceElementName)
{
throw new ArgumentException();
}
exportProvider = exportProvider ?? TestExportProvider.ExportProviderWithCSharpAndVisualBasic;
var workspace = new TestWorkspace(exportProvider, workspaceKind);
var projectMap = new Dictionary <string, TestHostProject>();
var documentElementToFilePath = new Dictionary <XElement, string>();
var projectElementToAssemblyName = new Dictionary <XElement, string>();
var filePathToTextBufferMap = new Dictionary <string, ITextBuffer>();
int projectIdentifier = 0;
int documentIdentifier = 0;
foreach (var projectElement in workspaceElement.Elements(ProjectElementName))
{
var project = CreateProject(
workspaceElement,
projectElement,
exportProvider,
workspace,
projectElementToAssemblyName,
documentElementToFilePath,
filePathToTextBufferMap,
ref projectIdentifier,
ref documentIdentifier);
Assert.False(projectMap.ContainsKey(project.AssemblyName));
projectMap.Add(project.AssemblyName, project);
workspace.Projects.Add(project);
}
var documentFilePaths = new HashSet <string>();
foreach (var project in projectMap.Values)
{
foreach (var document in project.Documents)
{
Assert.True(document.IsLinkFile || documentFilePaths.Add(document.FilePath));
}
}
var submissions = CreateSubmissions(workspace, workspaceElement.Elements(SubmissionElementName), exportProvider);
foreach (var submission in submissions)
{
projectMap.Add(submission.AssemblyName, submission);
}
var solution = new TestHostSolution(projectMap.Values.ToArray());
workspace.AddTestSolution(solution);
foreach (var projectElement in workspaceElement.Elements(ProjectElementName))
{
foreach (var projectReference in projectElement.Elements(ProjectReferenceElementName))
{
var fromName = projectElementToAssemblyName[projectElement];
var toName = projectReference.Value;
var fromProject = projectMap[fromName];
var toProject = projectMap[toName];
var aliases = projectReference.Attributes(AliasAttributeName).Select(a => a.Value).ToImmutableArray();
workspace.OnProjectReferenceAdded(fromProject.Id, new ProjectReference(toProject.Id, aliases.Any() ? aliases : default(ImmutableArray <string>)));
}
}
for (int i = 1; i < submissions.Count; i++)
{
if (submissions[i].CompilationOptions == null)
{
continue;
}
for (int j = i - 1; j >= 0; j--)
{
if (submissions[j].CompilationOptions != null)
{
workspace.OnProjectReferenceAdded(submissions[i].Id, new ProjectReference(submissions[j].Id));
break;
}
}
}
foreach (var project in projectMap.Values)
{
foreach (var document in project.Documents)
{
if (openDocuments)
{
workspace.OnDocumentOpened(document.Id, document.GetOpenTextContainer(), isCurrentContext: !document.IsLinkFile);
}
workspace.Documents.Add(document);
}
}
return(workspace);
}
private static TestHostDocument CreateDocument(
TestWorkspace workspace,
XElement workspaceElement,
XElement documentElement,
string language,
ExportProvider exportProvider,
HostLanguageServices languageServiceProvider,
Dictionary<string, ITextBuffer> filePathToTextBufferMap,
ref int documentId)
{
string markupCode;
string filePath;
var isLinkFileAttribute = documentElement.Attribute(IsLinkFileAttributeName);
bool isLinkFile = isLinkFileAttribute != null && ((bool?)isLinkFileAttribute).HasValue && ((bool?)isLinkFileAttribute).Value;
if (isLinkFile)
{
// This is a linked file. Use the filePath and markup from the referenced document.
var originalProjectName = documentElement.Attribute(LinkAssemblyNameAttributeName);
var originalDocumentPath = documentElement.Attribute(LinkFilePathAttributeName);
if (originalProjectName == null || originalDocumentPath == null)
{
throw new ArgumentException("Linked file specified without LinkAssemblyName or LinkFilePath.");
}
var originalProjectNameStr = originalProjectName.Value;
var originalDocumentPathStr = originalDocumentPath.Value;
var originalProject = workspaceElement.Elements(ProjectElementName).First(p =>
{
var assemblyName = p.Attribute(AssemblyNameAttributeName);
return assemblyName != null && assemblyName.Value == originalProjectNameStr;
});
if (originalProject == null)
{
throw new ArgumentException("Linked file's LinkAssemblyName '{0}' project not found.", originalProjectNameStr);
}
var originalDocument = originalProject.Elements(DocumentElementName).First(d =>
{
var documentPath = d.Attribute(FilePathAttributeName);
return documentPath != null && documentPath.Value == originalDocumentPathStr;
});
if (originalDocument == null)
{
throw new ArgumentException("Linked file's LinkFilePath '{0}' file not found.", originalDocumentPathStr);
}
markupCode = originalDocument.NormalizedValue();
filePath = GetFilePath(workspace, originalDocument, ref documentId);
}
else
{
markupCode = documentElement.NormalizedValue();
filePath = GetFilePath(workspace, documentElement, ref documentId);
}
var folders = GetFolders(documentElement);
var optionsElement = documentElement.Element(ParseOptionsElementName);
// TODO: Allow these to be specified.
var codeKind = SourceCodeKind.Regular;
if (optionsElement != null)
{
var attr = optionsElement.Attribute(KindAttributeName);
codeKind = attr == null
? SourceCodeKind.Regular
: (SourceCodeKind)Enum.Parse(typeof(SourceCodeKind), attr.Value);
}
var contentTypeLanguageService = languageServiceProvider.GetService<IContentTypeLanguageService>();
var contentType = contentTypeLanguageService.GetDefaultContentType();
string code;
int? cursorPosition;
IDictionary<string, IList<TextSpan>> spans;
MarkupTestFile.GetPositionAndSpans(markupCode, out code, out cursorPosition, out spans);
// For linked files, use the same ITextBuffer for all linked documents
ITextBuffer textBuffer;
if (!filePathToTextBufferMap.TryGetValue(filePath, out textBuffer))
{
textBuffer = EditorFactory.CreateBuffer(contentType.TypeName, exportProvider, code);
filePathToTextBufferMap.Add(filePath, textBuffer);
}
return new TestHostDocument(exportProvider, languageServiceProvider, textBuffer, filePath, cursorPosition, spans, codeKind, folders, isLinkFile);
}
private VisualStudioMefHostServices(ExportProvider exportProvider)
{
Contract.ThrowIfNull(exportProvider);
_exportProvider = exportProvider;
}
public static TestWorkspace CreateWorkspace(
XElement workspaceElement,
bool completed = true,
bool openDocuments = true,
ExportProvider exportProvider = null,
string workspaceKind = null)
{
if (workspaceElement.Name != WorkspaceElementName)
{
throw new ArgumentException();
}
exportProvider = exportProvider ?? TestExportProvider.ExportProviderWithCSharpAndVisualBasic;
var workspace = new TestWorkspace(exportProvider, workspaceKind);
var projectMap = new Dictionary<string, TestHostProject>();
var documentElementToFilePath = new Dictionary<XElement, string>();
var projectElementToAssemblyName = new Dictionary<XElement, string>();
var filePathToTextBufferMap = new Dictionary<string, ITextBuffer>();
int projectIdentifier = 0;
int documentIdentifier = 0;
foreach (var projectElement in workspaceElement.Elements(ProjectElementName))
{
var project = CreateProject(
workspaceElement,
projectElement,
exportProvider,
workspace,
projectElementToAssemblyName,
documentElementToFilePath,
filePathToTextBufferMap,
ref projectIdentifier,
ref documentIdentifier);
Assert.False(projectMap.ContainsKey(project.AssemblyName));
projectMap.Add(project.AssemblyName, project);
workspace.Projects.Add(project);
}
var documentFilePaths = new HashSet<string>();
foreach (var project in projectMap.Values)
{
foreach (var document in project.Documents)
{
Assert.True(document.IsLinkFile || documentFilePaths.Add(document.FilePath));
}
}
var submissions = CreateSubmissions(workspace, workspaceElement.Elements(SubmissionElementName), exportProvider);
foreach (var submission in submissions)
{
projectMap.Add(submission.AssemblyName, submission);
}
var solution = new TestHostSolution(projectMap.Values.ToArray());
workspace.AddTestSolution(solution);
foreach (var projectElement in workspaceElement.Elements(ProjectElementName))
{
foreach (var projectReference in projectElement.Elements(ProjectReferenceElementName))
{
var fromName = projectElementToAssemblyName[projectElement];
var toName = projectReference.Value;
var fromProject = projectMap[fromName];
var toProject = projectMap[toName];
var aliases = projectReference.Attributes(AliasAttributeName).Select(a => a.Value).ToImmutableArray();
workspace.OnProjectReferenceAdded(fromProject.Id, new ProjectReference(toProject.Id, aliases.Any() ? aliases : default(ImmutableArray<string>)));
}
}
for (int i = 1; i < submissions.Count; i++)
{
if (submissions[i].CompilationOptions == null)
{
continue;
}
for (int j = i - 1; j >= 0; j--)
{
if (submissions[j].CompilationOptions != null)
{
workspace.OnProjectReferenceAdded(submissions[i].Id, new ProjectReference(submissions[j].Id));
break;
}
}
}
foreach (var project in projectMap.Values)
{
foreach (var document in project.Documents)
{
if (openDocuments)
{
workspace.OnDocumentOpened(document.Id, document.GetOpenTextContainer(), isCurrentContext: !document.IsLinkFile);
}
workspace.Documents.Add(document);
}
}
return workspace;
}
public static VisualStudioMefHostServices Create(ExportProvider exportProvider) => new(exportProvider);
public static Task<TestWorkspace> CreateVisualBasicAsync(
string[] files,
ParseOptions parseOptions = null,
CompilationOptions compilationOptions = null,
ExportProvider exportProvider = null,
string[] metadataReferences = null)
{
return CreateAsync(LanguageNames.VisualBasic, compilationOptions, parseOptions, files, exportProvider, metadataReferences);
}
public TServiceInterface GetService <TServiceInterface>()
{
return(ExportProvider.GetExportedValue <TServiceInterface>());
}
private async Task WaitWaiterAsync(ExportProvider provider)
{
var workspaceWaiter = GetListeners(provider).First(l => l.Metadata.FeatureName == FeatureAttribute.Workspace).Value as IAsynchronousOperationWaiter;
await workspaceWaiter.CreateWaitTask();
var solutionCrawlerWaiter = GetListeners(provider).First(l => l.Metadata.FeatureName == FeatureAttribute.SolutionCrawler).Value as IAsynchronousOperationWaiter;
await solutionCrawlerWaiter.CreateWaitTask();
}
private static IList <TestHostProject> CreateSubmissions(
TestWorkspace workspace,
IEnumerable <XElement> submissionElements,
ExportProvider exportProvider)
{
var submissions = new List <TestHostProject>();
var submissionIndex = 0;
foreach (var submissionElement in submissionElements)
{
var submissionName = "Submission" + (submissionIndex++);
var languageName = GetLanguage(workspace, submissionElement);
// The document
var markupCode = submissionElement.NormalizedValue();
MarkupTestFile.GetPositionAndSpans(markupCode,
out var code, out var cursorPosition, out IDictionary <string, ImmutableArray <TextSpan> > spans);
var languageServices = workspace.Services.GetLanguageServices(languageName);
// The project
var document = new TestHostDocument(exportProvider, languageServices, code, submissionName, cursorPosition, spans, SourceCodeKind.Script);
var documents = new List <TestHostDocument> {
document
};
if (languageName == NoCompilationConstants.LanguageName)
{
submissions.Add(
new TestHostProject(
languageServices,
compilationOptions: null,
parseOptions: null,
assemblyName: submissionName,
projectName: submissionName,
references: null,
documents: documents,
isSubmission: true));
continue;
}
var metadataService = workspace.Services.GetService <IMetadataService>();
var metadataResolver = RuntimeMetadataReferenceResolver.CreateCurrentPlatformResolver(fileReferenceProvider: metadataService.GetReference);
var syntaxFactory = languageServices.GetService <ISyntaxTreeFactoryService>();
var compilationFactory = languageServices.GetService <ICompilationFactoryService>();
var compilationOptions = compilationFactory.GetDefaultCompilationOptions()
.WithOutputKind(OutputKind.DynamicallyLinkedLibrary)
.WithMetadataReferenceResolver(metadataResolver);
var parseOptions = syntaxFactory.GetDefaultParseOptions().WithKind(SourceCodeKind.Script);
var references = CreateCommonReferences(workspace, submissionElement);
var project = new TestHostProject(
languageServices,
compilationOptions,
parseOptions,
submissionName,
submissionName,
references,
documents,
isSubmission: true);
submissions.Add(project);
}
return(submissions);
}
private static Task<TestWorkspace> CreateTestWorkspaceAsync(string code, string languageName, ExportProvider exportProvider = null)
{
var xml = string.Format(@"
<Workspace>
<Project Language=""{0}"" CommonReferences=""true"">
<Document>{1}</Document>
</Project>
</Workspace>", languageName, code);
return TestWorkspace.CreateAsync(xml, exportProvider: exportProvider);
}
protected abstract TestWorkspace CreateWorkspace(ExportProvider exportProvider);
internal static TestWorkspace CreateWorkspaceFromFiles(
string language,
CompilationOptions compilationOptions,
ParseOptions[] parseOptions,
string[] files,
ExportProvider exportProvider)
{
Contract.Requires(parseOptions == null || (files.Length == parseOptions.Length), "Please specify a parse option for each file.");
var documentElements = new List<XElement>();
var index = 1;
var extension = "";
for (int i = 0; i < files.Length; i++)
{
if (language == LanguageNames.CSharp)
{
extension = parseOptions[i].Kind == SourceCodeKind.Regular
? CSharpExtension
: CSharpScriptExtension;
}
else if (language == LanguageNames.VisualBasic)
{
extension = parseOptions[i].Kind == SourceCodeKind.Regular
? VisualBasicExtension
: VisualBasicScriptExtension;
}
else
{
extension = language;
}
documentElements.Add(CreateDocumentElement(files[i], "test" + index++ + extension, parseOptions == null ? null : parseOptions[i]));
}
var workspaceElement = CreateWorkspaceElement(
CreateProjectElement("Test", language, true, parseOptions.FirstOrDefault(), compilationOptions, documentElements));
return CreateWorkspace(workspaceElement, exportProvider: exportProvider);
}
protected virtual bool Setup(IServerConfig config, ExportProvider exportProvider)
{
return(true);
}
