public static ComposableCatalog GetCSharpAndVisualBasicAssemblyCatalog() { return(ExportProviderCache.GetOrCreateAssemblyCatalog( GetNeutralAndCSharpAndVisualBasicTypes().Select(t => t.Assembly).Distinct(), ExportProviderCache.CreateResolver()) .WithParts(MinimalTestExportProvider.GetEditorAssemblyCatalog()) .WithDefaultFakes()); }
public void ExtractInterfaceCommandDisabledInSubmission() { var exportProvider = ExportProviderCache .GetOrCreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(typeof(InteractiveSupportsFeatureService.InteractiveTextBufferSupportsFeatureService))) .CreateExportProvider(); using var workspace = TestWorkspace.Create(XElement.Parse(@" <Workspace> <Submission Language=""C#"" CommonReferences=""true""> public class $$C { public void M() { } } </Submission> </Workspace> "), workspaceKind: WorkspaceKind.Interactive, exportProvider: exportProvider); // Force initialization. workspace.GetOpenDocumentIds().Select(id => workspace.GetTestDocument(id).GetTextView()).ToList(); var textView = workspace.Documents.Single().GetTextView(); var handler = new ExtractInterfaceCommandHandler(exportProvider.GetExportedValue <IThreadingContext>()); var state = handler.GetCommandState(new ExtractInterfaceCommandArgs(textView, textView.TextBuffer)); Assert.True(state.IsUnspecified); }
private static IExportProviderFactory CreateExportProviderFactory() { var catalog = TestExportProvider.GetCSharpAndVisualBasicAssemblyCatalog() .WithParts(ExportProviderCache.GetOrCreateAssemblyCatalog(new[] { typeof(EditorServicesUtil).Assembly }, ExportProviderCache.CreateResolver())); return(ExportProviderCache.GetOrCreateExportProviderFactory(catalog)); }
public void SetProperty_MaxSupportedLangVersion_NotSet() { var catalog = TestEnvironment.s_exportCatalog.Value .WithParts( typeof(CSharpParseOptionsChangingService)); var factory = ExportProviderCache.GetOrCreateExportProviderFactory(catalog); using var environment = new TestEnvironment(exportProviderFactory: factory); var hierarchy = environment.CreateHierarchy("CSharpProject", "Bin", projectRefPath: null, projectCapabilities: "CSharp"); var storage = Assert.IsAssignableFrom <IVsBuildPropertyStorage>(hierarchy); _ = CSharpHelpers.CreateCSharpProject(environment, "Test", hierarchy); var project = environment.Workspace.CurrentSolution.Projects.Single(); var oldParseOptions = (CSharpParseOptions)project.ParseOptions; const LanguageVersion attemptedVersion = LanguageVersion.CSharp8; var canApply = environment.Workspace.CanApplyParseOptionChange( oldParseOptions, oldParseOptions.WithLanguageVersion(attemptedVersion), project); Assert.True(canApply); }
internal static Lazy <IDynamicFileInfoProvider, FileExtensionsMetadata> GetDynamicFileInfoProvider() { var catalog = ExportProviderCache.CreateTypeCatalog(new Type[] { typeof(TestDynamicFileInfoProvider) }); var factory = ExportProviderCache.GetOrCreateExportProviderFactory(catalog); return(factory.CreateExportProvider().GetExport <IDynamicFileInfoProvider, FileExtensionsMetadata>()); }
static VisualStudioTestExportProvider() { Factory = ExportProviderCache.GetOrCreateExportProviderFactory( TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic .WithParts(ExportProviderCache.GetOrCreateAssemblyCatalog(typeof(CSharpCodeModelService).Assembly)) .WithPart(typeof(LanguageServices.UnitTests.VisualStudioTestExportProvider.MockWorkspaceEventListenerProvider))); }
public async Task MoveToNamespace_WithoutOptionsService() { var code = @"namespace A[||] { class MyClass { void Method() { } } }"; var exportProviderWithoutOptionsService = ExportProviderCache.GetOrCreateExportProviderFactory( TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithoutPartsOfType(typeof(IMoveToNamespaceOptionsService))); using (var workspace = CreateWorkspaceFromFile(code, new TestParameters(), exportProviderWithoutOptionsService)) using (var testState = new TestState(workspace)) { Assert.Null(testState.TestMoveToNamespaceOptionsService); var actions = await testState.MoveToNamespaceService.GetCodeActionsAsync( testState.InvocationDocument, testState.TestInvocationDocument.SelectedSpans.Single(), CancellationToken.None); Assert.Empty(actions); } }
protected static async Task AssertCodeCleanupResult(string expected, string code, bool systemUsingsFirst = true, bool separateUsingGroups = false) { var exportProvider = ExportProviderCache .GetOrCreateExportProviderFactory( TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(typeof(CodeCleanupAnalyzerProviderService))) .CreateExportProvider(); using var workspace = TestWorkspace.CreateCSharp(code, exportProvider: exportProvider); workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(workspace.Options .WithChangedOption(GenerationOptions.PlaceSystemNamespaceFirst, LanguageNames.CSharp, systemUsingsFirst) .WithChangedOption(GenerationOptions.SeparateImportDirectiveGroups, LanguageNames.CSharp, separateUsingGroups))); // register this workspace to solution crawler so that analyzer service associate itself with given workspace var incrementalAnalyzerProvider = workspace.ExportProvider.GetExportedValue <IDiagnosticAnalyzerService>() as IIncrementalAnalyzerProvider; incrementalAnalyzerProvider.CreateIncrementalAnalyzer(workspace); var hostdoc = workspace.Documents.Single(); var document = workspace.CurrentSolution.GetDocument(hostdoc.Id); var codeCleanupService = document.GetLanguageService <ICodeCleanupService>(); var enabledDiagnostics = codeCleanupService.GetAllDiagnostics(); var newDoc = await codeCleanupService.CleanupAsync( document, enabledDiagnostics, new ProgressTracker(), CancellationToken.None); var actual = await newDoc.GetTextAsync(); Assert.Equal(expected, actual.ToString()); }
protected static async Task AssertCodeCleanupResult(string expected, string code) { var exportProvider = ExportProviderCache .GetOrCreateExportProviderFactory( TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(typeof(CodeCleanupAnalyzerProviderService))) .CreateExportProvider(); using (var workspace = TestWorkspace.CreateCSharp(code, exportProvider: exportProvider)) { // register this workspace to solution crawler so that analyzer service associate itself with given workspace var incrementalAnalyzerProvider = workspace.ExportProvider.GetExportedValue <IDiagnosticAnalyzerService>() as IIncrementalAnalyzerProvider; incrementalAnalyzerProvider.CreateIncrementalAnalyzer(workspace); var hostdoc = workspace.Documents.Single(); var document = workspace.CurrentSolution.GetDocument(hostdoc.Id); var codeCleanupService = document.GetLanguageService <ICodeCleanupService>(); var enabledDiagnostics = codeCleanupService.GetAllDiagnostics(); var newDoc = await codeCleanupService.CleanupAsync( document, enabledDiagnostics, new ProgressTracker(), CancellationToken.None); var actual = await newDoc.GetTextAsync(); Assert.Equal(expected, actual.ToString()); } }
public Validator( string[] markedSource, ImmutableArray <ActiveStatementDebugInfo> activeStatements, ImmutableDictionary <ActiveMethodId, ImmutableArray <NonRemappableRegion> > nonRemappableRegions = null, Func <Solution, Solution> adjustSolution = null, CommittedSolution.DocumentState initialState = CommittedSolution.DocumentState.MatchesBuildOutput) { var exportProviderFactory = ExportProviderCache.GetOrCreateExportProviderFactory( TestExportProvider.MinimumCatalogWithCSharpAndVisualBasic.WithPart(typeof(CSharpEditAndContinueAnalyzer)).WithPart(typeof(DummyLanguageService))); var exportProvider = exportProviderFactory.CreateExportProvider(); Workspace = TestWorkspace.CreateCSharp(ActiveStatementsDescription.ClearTags(markedSource), exportProvider: exportProvider, openDocuments: true); if (adjustSolution != null) { Workspace.ChangeSolution(adjustSolution(Workspace.CurrentSolution)); } var mockDebuggeModuleProvider = new Mock <IDebuggeeModuleMetadataProvider>(); var mockCompilationOutputsProvider = new Func <Project, CompilationOutputs>(_ => new MockCompilationOutputs(Guid.NewGuid())); var debuggingSession = new DebuggingSession(Workspace, mockDebuggeModuleProvider.Object, mockCompilationOutputsProvider); if (initialState != CommittedSolution.DocumentState.None) { EditAndContinueWorkspaceServiceTests.SetDocumentsState(debuggingSession, Workspace.CurrentSolution, initialState); } debuggingSession.Test_SetNonRemappableRegions(nonRemappableRegions ?? ImmutableDictionary <ActiveMethodId, ImmutableArray <NonRemappableRegion> > .Empty); var telemetry = new EditSessionTelemetry(); EditSession = new EditSession(debuggingSession, telemetry, cancellationToken => Task.FromResult(activeStatements)); }
public void EncapsulateFieldCommandDisabledInSubmission() { var exportProvider = ExportProviderCache .GetOrCreateExportProviderFactory( TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(typeof(InteractiveSupportsFeatureService.InteractiveTextBufferSupportsFeatureService))) .CreateExportProvider(); using (var workspace = TestWorkspace.Create(XElement.Parse(@" <Workspace> <Submission Language=""C#"" CommonReferences=""true""> class C { object $$goo; } </Submission> </Workspace> "), workspaceKind: WorkspaceKind.Interactive, exportProvider: exportProvider)) { // Force initialization. workspace.GetOpenDocumentIds().Select(id => workspace.GetTestDocument(id).GetTextView()).ToList(); var textView = workspace.Documents.Single().GetTextView(); var handler = new EncapsulateFieldCommandHandler(workspace.GetService <ITextBufferUndoManagerProvider>(), workspace.ExportProvider.GetExportedValue <IAsynchronousOperationListenerProvider>()); var state = handler.GetCommandState(new EncapsulateFieldCommandArgs(textView, textView.TextBuffer)); Assert.True(state.IsUnspecified); } }
public void ChangeSignatureCommandDisabledInSubmission() { var exportProvider = ExportProviderCache .GetOrCreateExportProviderFactory( TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(typeof(InteractiveDocumentSupportsFeatureService))) .CreateExportProvider(); using (var workspace = TestWorkspace.Create(XElement.Parse(@" <Workspace> <Submission Language=""C#"" CommonReferences=""true""> class C { void M$$(int x) { } } </Submission> </Workspace> "), workspaceKind: WorkspaceKind.Interactive, exportProvider: exportProvider)) { // Force initialization. workspace.GetOpenDocumentIds().Select(id => workspace.GetTestDocument(id).GetTextView()).ToList(); var textView = workspace.Documents.Single().GetTextView(); var handler = new CSharpChangeSignatureCommandHandler(); var state = handler.GetCommandState(new RemoveParametersCommandArgs(textView, textView.TextBuffer)); Assert.True(state.IsUnspecified); state = handler.GetCommandState(new ReorderParametersCommandArgs(textView, textView.TextBuffer)); Assert.True(state.IsUnspecified); } }
private static IExportProviderFactory CreateExportProviderFactory() { var assemblies = TestExportProvider .GetCSharpAndVisualBasicAssemblies() .Concat(new[] { typeof(EditorServicesUtil).Assembly }); return(ExportProviderCache.GetOrCreateExportProviderFactory(ExportProviderCache.GetOrCreateAssemblyCatalog(assemblies, ExportProviderCache.CreateResolver()))); }
protected virtual ExportProvider GetExportProvider() { var requestHelperTypes = DesktopTestHelpers.GetAllTypesImplementingGivenInterface( typeof(IRequestHandler).Assembly, typeof(IRequestHandler)); var exportProviderFactory = ExportProviderCache.GetOrCreateExportProviderFactory( TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic .WithPart(typeof(LanguageServerProtocol)) .WithParts(requestHelperTypes)); return(exportProviderFactory.CreateExportProvider()); }
static ExportProvider GetExportProvider(AbstractKeywordHighlighterTests self) { IExportProviderFactory factory; lock (_specificHighlighterExportProviderFactories) { factory = _specificHighlighterExportProviderFactories.GetOrAdd( self.GetType(), type => ExportProviderCache.GetOrCreateExportProviderFactory(self.GetExportCatalog())); } return(factory.CreateExportProvider()); }
internal static ExportProvider GetExportProvider(IList <Type> excludedTypes, ComposableCatalog extraParts) { excludedTypes = excludedTypes ?? Type.EmptyTypes; if (excludedTypes.Count == 0 && (extraParts == null || extraParts.Parts.Count == 0)) { return(TestExportProvider.ExportProviderFactoryWithCSharpAndVisualBasic.CreateExportProvider()); } var baseCatalog = TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic; var filteredCatalog = baseCatalog.WithoutPartsOfTypes(excludedTypes); return(ExportProviderCache.GetOrCreateExportProviderFactory(filteredCatalog.WithParts(extraParts)).CreateExportProvider()); }
private static ExportProvider GetExportProvider(bool useMinimumCatalog, ComposableCatalog extraParts) { if (extraParts == null || extraParts.Parts.Count == 0) { return(useMinimumCatalog ? TestExportProvider.MinimumExportProviderFactoryWithCSharpAndVisualBasic.CreateExportProvider() : TestExportProvider.ExportProviderFactoryWithCSharpAndVisualBasic.CreateExportProvider()); } var baseCatalog = useMinimumCatalog ? TestExportProvider.MinimumCatalogWithCSharpAndVisualBasic : TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic; return(ExportProviderCache.GetOrCreateExportProviderFactory(baseCatalog.WithParts(extraParts)).CreateExportProvider()); }
protected override ExportProvider GetExportProvider() { // Get all the liveshare request handlers in this assembly. var liveShareRequestHelperTypes = DesktopTestHelpers.GetAllTypesImplementingGivenInterface( typeof(LoadHandler).Assembly, typeof(ILspRequestHandler)); // Get all of the roslyn request helpers in M.CA.LanguageServer var roslynRequestHelperTypes = DesktopTestHelpers.GetAllTypesImplementingGivenInterface( typeof(RoslynHandlers.IRequestHandler).Assembly, typeof(RoslynHandlers.IRequestHandler)); var exportProviderFactory = ExportProviderCache.GetOrCreateExportProviderFactory( TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic .WithPart(typeof(MockDocumentNavigationServiceFactory)) .WithParts(liveShareRequestHelperTypes) .WithParts(roslynRequestHelperTypes)); return(exportProviderFactory.CreateExportProvider()); }
private static async Task VerifyRefactoringDisabledAsync <T>() where T : CodeRefactoringProvider { var exportProvider = ExportProviderCache.GetOrCreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithPart(typeof(T))).CreateExportProvider(); using var workspace = TestWorkspace.CreateCSharp(@"class Program {}", exportProvider: exportProvider); var refactoringService = workspace.GetService <ICodeRefactoringService>(); var codeRefactoring = exportProvider.GetExportedValues <CodeRefactoringProvider>().OfType <T>().Single(); var project = workspace.CurrentSolution.Projects.Single(); var document = project.Documents.Single(); var extensionManager = document.Project.Solution.Workspace.Services.GetService <IExtensionManager>() as EditorLayerExtensionManager.ExtensionManager; var result = await refactoringService.GetRefactoringsAsync(document, TextSpan.FromBounds(0, 0), CancellationToken.None); Assert.True(extensionManager.IsDisabled(codeRefactoring)); Assert.False(extensionManager.IsIgnored(codeRefactoring)); }
public void OrderingOfEditorConfigMaintained() { using var tempRoot = new TempRoot(); var tempDirectory = tempRoot.CreateDirectory(); // Write out an .editorconfig. We'll write out 100 random GUIDs var expectedKeysInOrder = new List <string>(); using (var writer = new StreamWriter(tempDirectory.CreateFile(".editorconfig").Path)) { writer.WriteLine("root = true"); writer.WriteLine("[*.cs]"); for (int i = 0; i < 100; i++) { var key = Guid.NewGuid().ToString(); expectedKeysInOrder.Add(key); writer.WriteLine($"{key} = value"); } } // Create a workspace with a file in that path var codingConventionsCatalog = ExportProviderCache.GetOrCreateAssemblyCatalog(typeof(ICodingConventionsManager).Assembly).WithPart(typeof(MockFileWatcher)); var exportProvider = ExportProviderCache.GetOrCreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithParts(codingConventionsCatalog)).CreateExportProvider(); using var workspace = TestWorkspace.CreateWorkspace( new XElement("Workspace", new XElement("Project", new XAttribute("Language", "C#"), new XElement("Document", new XAttribute("FilePath", tempDirectory.CreateFile("Test.cs").Path)))), exportProvider: exportProvider); var document = workspace.CurrentSolution.Projects.Single().Documents.Single(); var providerFactory = workspace.ExportProvider.GetExportedValues <IDocumentOptionsProviderFactory>().OfType <LegacyEditorConfigDocumentOptionsProviderFactory>().Single(); var provider = providerFactory.TryCreate(workspace); var option = new Option <List <string> >(nameof(LegacyEditorConfigDocumentOptionsProviderTests), nameof(OrderingOfEditorConfigMaintained), null, new[] { new KeysReturningStorageLocation() }); var optionKey = new OptionKey(option); // Fetch the underlying option order with a "option" that returns the keys provider.GetOptionsForDocumentAsync(document, CancellationToken.None).Result.TryGetDocumentOption(optionKey, workspace.Options, out object actualKeysInOrderObject); var actualKeysInOrder = Assert.IsAssignableFrom <IEnumerable <string> >(actualKeysInOrderObject); Assert.Equal(expectedKeysInOrder, actualKeysInOrder); }
public static ComposableCatalog GetEditorAssemblyCatalog() { var assemblies = new[] { // EDITOR // Microsoft.VisualStudio.Platform.VSEditor.dll: Assembly.LoadFrom("Microsoft.VisualStudio.Platform.VSEditor.dll"), // Microsoft.VisualStudio.Text.Logic.dll: // Must include this because several editor options are actually stored as exported information // on this DLL. Including most importantly, the tab size information. typeof(Microsoft.VisualStudio.Text.Editor.DefaultOptions).Assembly, // Microsoft.VisualStudio.Text.UI.dll: // Include this DLL to get several more EditorOptions including WordWrapStyle. typeof(Microsoft.VisualStudio.Text.Editor.WordWrapStyle).Assembly, // Microsoft.VisualStudio.Text.UI.Wpf.dll: // Include this DLL to get more EditorOptions values. typeof(Microsoft.VisualStudio.Text.Editor.HighlightCurrentLineOption).Assembly, // BasicUndo.dll: // Include this DLL to satisfy ITextUndoHistoryRegistry typeof(BasicUndo.IBasicUndoHistory).Assembly, // Microsoft.VisualStudio.Language.StandardClassification.dll: typeof(Microsoft.VisualStudio.Language.StandardClassification.PredefinedClassificationTypeNames).Assembly, // Microsoft.VisualStudio.Language typeof(Microsoft.VisualStudio.Language.Intellisense.AsyncCompletion.IAsyncCompletionBroker).Assembly, // Microsoft.VisualStudio.CoreUtility typeof(Microsoft.VisualStudio.Utilities.IFeatureServiceFactory).Assembly, // Microsoft.VisualStudio.Text.Internal typeof(Microsoft.VisualStudio.Text.Utilities.IExperimentationServiceInternal).Assembly, }; // Consider removing the internal service from the output: https://github.com/dotnet/roslyn/issues/30249 return(ExportProviderCache.GetOrCreateAssemblyCatalog(assemblies, ExportProviderCache.CreateResolver()) .WithPart(typeof(TestExperimentationServiceInternal))); }
public async Task UpdaterService() { var exportProvider = ExportProviderCache .GetOrCreateExportProviderFactory(ServiceTestExportProvider.CreateAssemblyCatalog() .WithParts(typeof(InProcRemoteHostClientProvider.Factory), typeof(CSharpOptionsSerializationService))) .CreateExportProvider(); using var workspace = new AdhocWorkspace(TestHostServices.CreateHostServices(exportProvider)); var options = workspace.CurrentSolution.Options .WithChangedOption(RemoteHostOptions.SolutionChecksumMonitorBackOffTimeSpanInMS, 1) .WithChangedOption(RemoteTestHostOptions.RemoteHostTest, true); workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(options)); var listenerProvider = exportProvider.GetExportedValue <AsynchronousOperationListenerProvider>(); var checksumUpdater = new SolutionChecksumUpdater(workspace, listenerProvider, CancellationToken.None); var service = workspace.Services.GetRequiredService <IRemoteHostClientProvider>(); // make sure client is ready using var client = await service.TryGetRemoteHostClientAsync(CancellationToken.None); // add solution, change document workspace.AddSolution(SolutionInfo.Create(SolutionId.CreateNewId(), VersionStamp.Default)); var project = workspace.AddProject("proj", LanguageNames.CSharp); var document = workspace.AddDocument(project.Id, "doc.cs", SourceText.From("code")); workspace.ApplyTextChanges(document.Id, new[] { new TextChange(new TextSpan(0, 1), "abc") }, CancellationToken.None); // wait for listener var workspaceListener = listenerProvider.GetWaiter(FeatureAttribute.Workspace); await workspaceListener.ExpeditedWaitAsync(); var listener = listenerProvider.GetWaiter(FeatureAttribute.SolutionChecksumUpdater); await listener.ExpeditedWaitAsync(); // checksum should already exist Assert.True(workspace.CurrentSolution.State.TryGetStateChecksums(out _)); checksumUpdater.Shutdown(); }
public void SetProperty_MaxSupportedLangVersion(LanguageVersion?maxSupportedLangVersion) { var catalog = TestEnvironment.s_exportCatalog.Value .WithParts( typeof(CSharpParseOptionsChangingService)); var factory = ExportProviderCache.GetOrCreateExportProviderFactory(catalog); using var environment = new TestEnvironment(exportProviderFactory: factory); var hierarchy = environment.CreateHierarchy("CSharpProject", "Bin", projectRefPath: null, projectCapabilities: "CSharp"); var storage = Assert.IsAssignableFrom <IVsBuildPropertyStorage>(hierarchy); Assert.True(ErrorHandler.Succeeded( storage.SetPropertyValue( "MaxSupportedLangVersion", null, (uint)_PersistStorageType.PST_PROJECT_FILE, maxSupportedLangVersion?.ToDisplayString()))); _ = CSharpHelpers.CreateCSharpProject(environment, "Test", hierarchy); var project = environment.Workspace.CurrentSolution.Projects.Single(); var oldParseOptions = (CSharpParseOptions)project.ParseOptions; const LanguageVersion attemptedVersion = LanguageVersion.CSharp8; var canApply = environment.Workspace.CanApplyParseOptionChange( oldParseOptions, oldParseOptions.WithLanguageVersion(attemptedVersion), project); if (maxSupportedLangVersion.HasValue) { Assert.Equal(attemptedVersion <= maxSupportedLangVersion.Value, canApply); } else { Assert.True(canApply); } }
private static ExportProvider GetExportProvider() => ExportProviderCache .GetOrCreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic) .CreateExportProvider();
private static ComposableCatalog GetExtraParts() { return(ExportProviderCache.CreateTypeCatalog(new[] { typeof(EventHookupCommandHandler), typeof(EventHookupSessionManager) })); }
public static ComposableCatalog CreateAssemblyCatalog() { return(ExportProviderCache.GetOrCreateAssemblyCatalog(GetLanguageNeutralTypes().Select(t => t.Assembly).Distinct(), ExportProviderCache.CreateResolver()) .WithParts(MinimalTestExportProvider.GetEditorAssemblyCatalog())); }
protected override ExportProvider GetExportProvider() { return(ExportProviderCache .GetOrCreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithPart(typeof(TestExperimentationService))) .CreateExportProvider()); }
private static ComposableCatalog CreateAssemblyCatalogWithCSharpAndVisualBasic() { return(ExportProviderCache .GetOrCreateAssemblyCatalog(GetCSharpAndVisualBasicAssemblies(), ExportProviderCache.CreateResolver()) .WithCompositionService()); }
public static ExportProvider CreateMinimalExportProvider() { return(ExportProviderCache .GetOrCreateExportProviderFactory(ServiceTestExportProvider.CreateAssemblyCatalog().WithPart(typeof(InProcRemoteHostClientFactory))) .CreateExportProvider()); }
public static ExportProvider CreateExportProvider() { return(ExportProviderCache .GetOrCreateExportProviderFactory(TestExportProvider.EntireAssemblyCatalogWithCSharpAndVisualBasic.WithPart(typeof(InProcRemoteHostClientFactory))) .CreateExportProvider()); }