public RInteractiveWorkflowCommandTest(RComponentsMefCatalogFixture catalog, TestMethodFixture testMethod) { _testMethod = testMethod.MethodInfo; _exportProvider = catalog.CreateExportProvider(); _workflow = _exportProvider.GetExportedValue <IRInteractiveWorkflowProvider>().GetOrCreate(); _componentContainerFactory = _exportProvider.GetExportedValue <IInteractiveWindowComponentContainerFactory>(); }
public void When_querying_for_order_processor_the_order_processor_is_created() { var orderProcessor = ExportProvider.GetExportedValue <OrderProcessor>(); Assert.That(orderProcessor, Is.Not.Null); Assert.That(orderProcessor.OrderRepository, Is.Not.Null); }
protected override void OnStartup(StartupEventArgs e) { base.OnStartup(e); var assembly = GetType().Assembly; _kernel.BindExports(assembly, typeof(Infrastructure.Properties.AssemblyKey).Assembly, typeof(Model.Properties.AssemblyKey).Assembly, typeof(Translators.Properties.AssemblyKey).Assembly, typeof(View.Properties.AssemblyKey).Assembly); IExportProvider exportProvider = new ExportProvider(_kernel); _kernel.Bind <IExportProvider>().ToConstant(exportProvider); Resources.MergedDictionaries.Add(TomsToolbox.Wpf.Styles.WpfStyles.GetDefaultStyles()); Resources.MergedDictionaries.Add(DataTemplateManager.CreateDynamicDataTemplates(exportProvider)); exportProvider.GetExportedValues <IService>().ForEach(service => service.Start()); var tracer = exportProvider.GetExportedValue <ITracer>(); tracer.WriteLine("Started"); tracer.WriteLine(ResXManager.Properties.Resources.IntroMessage); tracer.WriteLine(ResXManager.Properties.Resources.AssemblyLocation, Path.GetDirectoryName(assembly.Location) ?? "unknown"); tracer.WriteLine(ResXManager.Properties.Resources.Version, new AssemblyName(assembly.FullName).Version ?? new Version()); VisualComposition.Error += (_, args) => tracer.TraceError(args.Text); MainWindow = exportProvider.GetExportedValue <MainWindow>(); MainWindow.Show(); }
internal void SetProject(TestHostProject project) { _project = project; if (this.Id == null) { _id = DocumentId.CreateNewId(project.Id, this.Name); } else { Contract.ThrowIfFalse(project.Id == this.Id.ProjectId); } if (_languageServiceProvider == null) { _languageServiceProvider = project.LanguageServiceProvider; } if (this.TextBuffer == null) { var contentTypeService = _languageServiceProvider.GetService <IContentTypeLanguageService>(); var contentType = contentTypeService.GetDefaultContentType(); this.TextBuffer = _exportProvider.GetExportedValue <ITextBufferFactoryService>().CreateTextBuffer(_initialText, contentType); this.InitialTextSnapshot = this.TextBuffer.CurrentSnapshot; } }
protected override async void OnStartup(StartupEventArgs e) { ExportProvider provider = null; try { provider = await Compose(this); } catch (Exception exception) { Console.WriteLine(exception); Current.Shutdown(-1); return; } IExportProvider providerImp = provider.GetExportedValue <IExportProvider>(); PropertyInfo pi = typeof(ExportProviderImp).GetProperty("Provider"); pi.SetValue(providerImp, provider, null); IMainWindowViewModel mainWindowViewModel = provider.GetExportedValue <IMainWindowViewModel>(); this.MainWindow = new MainWindow() { DataContext = mainWindowViewModel }; this.MainWindow.Show(); }
private void DumpKeyboard() { var keyBindingService = _exportProvider.GetExportedValue <IKeyBindingService>(); var folder = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), @"VsVim"); try { Directory.CreateDirectory(folder); } catch { // Don't care if it throws, just want to make sure the folder exists } var filePath = Path.Combine(folder, "keyboard.txt"); using (var streamWriter = new StreamWriter(filePath, append: false, encoding: Encoding.Unicode)) { keyBindingService.DumpKeyboard(streamWriter); } var message = $"Keyboard data dumped to: {filePath}"; PrintToCommandWindow(message); }
static UrlToImageSourceConverter() { ExportProvider provider = (ExportProvider)Application.Current.Resources[Consts.IocResource]; _userInfoService = _userInfoService ?? provider.GetExportedValue <IUserInformationService>(); _proxyResolver = _proxyResolver ?? provider.GetExportedValue <IProxyResolver>(); }
public async Task InstallAndUninstallPackageSpecifiedLib() { var interactiveWindowComponentContainerFactory = _exportProvider.GetExportedValue <IInteractiveWindowComponentContainerFactory>(); using (await UIThreadHelper.Instance.Invoke(() => _workflow.GetOrCreateVisualComponent(interactiveWindowComponentContainerFactory))) { _workflow.ActiveWindow.Should().NotBeNull(); _workflow.RSession.IsHostRunning.Should().BeTrue(); using (var eval = await _workflow.RSession.BeginEvaluationAsync()) { await SetLocalRepoAsync(eval, _repo1Path); } _workflow.Packages.InstallPackage(TestPackages.RtvsLib1Description.Package, _libPath); WaitForReplDoneExecuting(); WaitForPackageInstalled(_libPath, TestPackages.RtvsLib1Description.Package); using (var eval = await _workflow.RSession.BeginEvaluationAsync()) { await SetLocalLibsAsync(eval, _libPath); } var installed = await _workflow.Packages.GetInstalledPackagesAsync(); ValidateRtvslib1Installed(installed, _libPath); _workflow.Packages.UninstallPackage(TestPackages.RtvsLib1Description.Package, _libPath); WaitForReplDoneExecuting(); installed = await _workflow.Packages.GetInstalledPackagesAsync(); installed.Should().NotContain(pkg => pkg.Package == TestPackages.RtvsLib1Description.Package && pkg.LibPath == _libPath.ToRPath()); } }
public T Resolve <T>() { if (container == null) { throw new InvalidOperationException("Container not initialized"); } return(container.GetExportedValue <T>()); }
protected override void Initialize() { base.Initialize(); _componentModel = (IComponentModel)GetService(typeof(SComponentModel)); _exportProvider = _componentModel.DefaultExportProvider; _vim = _exportProvider.GetExportedValue <IVim>(); _vsAdapter = _exportProvider.GetExportedValue <IVsAdapter>(); }
public PlotIntegrationTest(RComponentsMefCatalogFixture catalog, TestMethodFixture testMethod, TestFilesFixture testFiles) { _exportProvider = catalog.CreateExportProvider(); _workflowProvider = _exportProvider.GetExportedValue <TestRInteractiveWorkflowProvider>(); _workflow = _exportProvider.GetExportedValue <IRInteractiveWorkflowProvider>().GetOrCreate(); _componentContainerFactory = _exportProvider.GetExportedValue <IInteractiveWindowComponentContainerFactory>(); _testMethod = testMethod.MethodInfo; _testFiles = testFiles; }
public RHistoryViewModelTest(RComponentsMefCatalogFixture catalog, ContainerHostMethodFixture containerHost) { _containerHost = containerHost; _exportProvider = catalog.CreateExportProvider(); _history = _exportProvider.GetExportedValue <IRInteractiveWorkflowProvider>().GetOrCreate().History; var containerFactory = _exportProvider.GetExportedValue <IRHistoryVisualComponentContainerFactory>(); _historyVisualComponent = UIThreadHelper.Instance.Invoke(() => _history.GetOrCreateVisualComponent(containerFactory)); }
public VisualStudioWorkspaceImpl(ExportProvider exportProvider) : base( MefV1HostServices.Create(exportProvider), backgroundWork: WorkspaceBackgroundWork.ParseAndCompile) { _textBufferCloneService = exportProvider.GetExportedValue <ITextBufferCloneService>(); _textBufferFactoryService = exportProvider.GetExportedValue <ITextBufferFactoryService>(); _textBufferFactoryService.TextBufferCreated += AddTextBufferCloneServiceToBuffer; exportProvider.GetExportedValue <PrimaryWorkspace>().Register(this); }
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; }
// Test only public StreamingFindUsagesPresenter( ExportProvider exportProvider) : this( exportProvider.GetExportedValue <IMSBuildEditorHost> (), exportProvider.GetExportedValue <SVsServiceProvider> (), exportProvider.GetExportedValue <IEditorFormatMapService> (), exportProvider.GetExportedValue <IClassificationFormatMapService> (), exportProvider.GetExportedValue <IClassificationTypeRegistryService> (), exportProvider.GetExportedValues <ITableColumnDefinition> ()) { }
public RInteractiveEvaluatorTest(RComponentsMefCatalogFixture catalog) { _exportProvider = catalog.CreateExportProvider(); var settings = _exportProvider.GetExportedValue <IRSettings>(); settings.RCodePage = 1252; _workflowProvider = _exportProvider.GetExportedValue <IRInteractiveWorkflowProvider>(); _interactiveWindowComponentContainerFactory = _exportProvider.GetExportedValue <IInteractiveWindowComponentContainerFactory>(); }
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); }
// Test only public StreamingFindUsagesPresenter( Workspace workspace, ExportProvider exportProvider) : this(workspace, exportProvider.GetExportedValue <IThreadingContext>(), exportProvider.GetExportedValue <Shell.SVsServiceProvider>(), exportProvider.GetExportedValue <ClassificationTypeMap>(), exportProvider.GetExportedValue <IEditorFormatMapService>(), exportProvider.GetExportedValue <IClassificationFormatMapService>(), exportProvider.GetExportedValues <ITableColumnDefinition>()) { }
public Host() { var assembly = GetType().Assembly; _kernel.BindExports(assembly, typeof(Infrastructure.Properties.AssemblyKey).Assembly, typeof(Model.Properties.AssemblyKey).Assembly); IExportProvider exportProvider = new ExportProvider(_kernel); ResourceManager = exportProvider.GetExportedValue <ResourceManager>(); ResourceManager.BeginEditing += ResourceManager_BeginEditing; Configuration = exportProvider.GetExportedValue <Configuration>(); }
private async Task CreateDatabaseIndexesAsync() { var db = exportProvider.GetExportedValue <UCenterDatabaseContext>(); await db.Accounts.CreateIndexIfNotExistAsync( Builders <AccountEntity> .IndexKeys.Ascending("AccountName"), new CreateIndexOptions() { Name = "AccountName_IDX" }, CancellationToken.None); await db.Accounts.CreateIndexIfNotExistAsync( Builders <AccountEntity> .IndexKeys.Ascending("Email"), new CreateIndexOptions() { Name = "Email_IDX" }, CancellationToken.None); await db.Accounts.CreateIndexIfNotExistAsync( Builders <AccountEntity> .IndexKeys.Ascending("Phone"), new CreateIndexOptions() { Name = "Phone_IDX" }, CancellationToken.None); }
public RPackageManagerViewModelTest(RComponentsMefCatalogFixture catalog, TestMethodFixture testMethod, TestFilesFixture testFiles) { _exportProvider = catalog.CreateExportProvider(); _workflow = _exportProvider.GetExportedValue <TestRInteractiveWorkflowProvider>().GetOrCreate(); _testMethod = testMethod.MethodInfo; _testFiles = testFiles; }
public static void WriteLine([NotNull] this ExportProvider exportProvider, [Localizable(false)][NotNull] string message) { Contract.Requires(exportProvider != null); Contract.Requires(message != null); exportProvider.GetExportedValue <ITracer>().WriteLine(message); }
/// <summary> /// Implements Interfaces, allowing the specification of an export provider. /// </summary> /// <param name="node"></param> /// <param name="exports"></param> /// <returns></returns> static IEnumerable <T> Interfaces <T>(this XObject node, ExportProvider exports) { Contract.Requires <ArgumentNullException>(node != null); Contract.Requires <ArgumentNullException>(exports != null); return(node.AnnotationOrCreate <ExtensionQuery <T> >(() => exports.GetExportedValue <ExtensionQuery <T> >())); }
public async Task Initialize() { if (_initialized) { return; } var discovery = PartDiscovery.Combine(new AttributedPartDiscoveryV1(Resolver.DefaultInstance)); var catalog = ComposableCatalog.Create(Resolver.DefaultInstance) .AddParts(await discovery.CreatePartsAsync(Assembly.GetExecutingAssembly())) .AddParts(await discovery.CreatePartsAsync(Assembly.GetCallingAssembly())) .AddParts(await discovery.CreatePartsAsync(Assembly.GetEntryAssembly())) .AddParts(await discovery.CreatePartsAsync(_directoryCatalog.Assemblies)) .WithCompositionService(); // Makes an ICompositionService export available to MEF parts to import // Assemble the parts into a valid graph. var config = CompositionConfiguration.Create(catalog); // Prepare an ExportProvider factory based on this graph. Factory = config.CreateExportProviderFactory(); // Create an export provider, which represents a unique container of values. ExportProvider = Factory.CreateExportProvider(); CompositionService = ExportProvider.GetExportedValue <ICompositionService>(); _initialized = true; }
protected override void OnStartup(StartupEventArgs e) { base.OnStartup(e); // modern styling Resources.MergedDictionaries.Add(WpfStyles.GetDefaultStyles()); Resources.RegisterDefaultWindowStyle(); // setup visual composition infrastructure, using Ninject _kernel.BindExports(GetType().Assembly); IExportProvider exportProvider = new ExportProvider(_kernel); _kernel.Bind <IExportProvider>().ToConstant(exportProvider); // setup global export provider locator for XAML ExportProviderLocator.Register(exportProvider); // register all controls tagged as data templates var dynamicDataTemplates = DataTemplateManager.CreateDynamicDataTemplates(exportProvider); Resources.MergedDictionaries.Add(dynamicDataTemplates); MainWindow = exportProvider.GetExportedValue <MainWindow>(); MainWindow.Show(); }
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; } 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 async void MoveToResource(object?sender, EventArgs?e) { await EnsureLoadedAsync().ConfigureAwait(false); await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); try { var entry = await ExportProvider.GetExportedValue <IRefactorings>().MoveToResourceAsync().ConfigureAwait(true); if (entry == null) { return; } if (!Properties.Settings.Default.MoveToResourceOpenInResXManager) { return; } ShowToolWindow(); ExportProvider.GetExportedValue <IVsixShellViewModel>().SelectEntry(entry); } catch (Exception ex) { Tracer.TraceError(ex.ToString()); } }
public static TSettings Initialize <TSettings>(ExportProvider exportProvider, params ISettingsValueProvider[] providers) { var settings = exportProvider.GetExportedValue <TSettings>(); var properties = typeof(TSettings).GetProperties(BindingFlags.Instance | BindingFlags.Public); foreach (var provider in providers) { properties.AsParallel() .ForAll(prop => { string name = null; var attr = prop.GetCustomAttribute <SettingAttribute>(); if (attr != null) { name = attr.SettingName; } else { name = prop.Name; } var pair = provider.SettingValues.FirstOrDefault(s => s.Name == name); if (pair != null) { prop.SetValue(settings, Convert.ChangeType(pair.Value, prop.PropertyType)); } }); } return(settings); }
#pragma warning disable VSTHRD100 // Avoid async void methods private async void MoveToResource(object?sender, EventArgs?e) #pragma warning restore VSTHRD100 // Avoid async void methods { FindToolWindow(); if (!Microsoft.VisualStudio.Shell.ThreadHelper.CheckAccess()) { await Microsoft.VisualStudio.Shell.ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); } try { var entry = await ExportProvider.GetExportedValue <IRefactorings>().MoveToResourceAsync(Dte.ActiveDocument).ConfigureAwait(true); if (entry == null) { return; } if (!Properties.Settings.Default.MoveToResourceOpenInResXManager) { return; } ExportProvider.GetExportedValue <VsixShellViewModel>().SelectEntry(entry); } catch (Exception ex) { Tracer.TraceError(ex.ToString()); } }
private async void ShowSelectedResourceFiles(object?sender, EventArgs?e) { try { var selectedResourceEntities = (await GetSelectedResourceEntitiesAsync().ConfigureAwait(false))?.Distinct().ToArray(); if (selectedResourceEntities == null) { return; } await JoinableTaskFactory.SwitchToMainThreadAsync(); // if we open the window the first time, make sure it does not select all entities by default. var settings = View.Properties.Settings.Default; settings.AreAllFilesSelected = false; settings.ResourceFilter = string.Empty; var selectedEntities = ExportProvider.GetExportedValue <ResourceViewModel>().SelectedEntities; selectedEntities.Clear(); selectedEntities.AddRange(selectedResourceEntities); ShowToolWindow(); } catch (Exception ex) { Tracer.TraceError("ShowSelectedResourceFiles failed: " + ex); } }
public IWpfTextView GetTextView() { if (_textView == null) { WpfTestRunner.RequireWpfFact($"Creates an {nameof(IWpfTextView)} through {nameof(TestHostDocument)}.{nameof(GetTextView)}"); var factory = _exportProvider.GetExportedValue <ITextEditorFactoryService>(); // Every default role but outlining. Starting in 15.2, the editor // OutliningManager imports JoinableTaskContext in a way that's // difficult to satisfy in our unit tests. Since we don't directly // depend on it, just disable it var roles = factory.CreateTextViewRoleSet(_roles); _textView = factory.CreateTextView(this.GetTextBuffer(), roles); if (this.CursorPosition.HasValue) { _textView.Caret.MoveTo(new SnapshotPoint(_textView.TextSnapshot, CursorPosition.Value)); } else if (this.SelectedSpans.IsSingle()) { var span = this.SelectedSpans.Single(); _textView.Selection.Select(new SnapshotSpan(_textView.TextSnapshot, new Span(span.Start, span.Length)), false); } } return(_textView); }
public static IWpfTextView CreateView( string contentType, ExportProvider exportProvider, params string[] lines) { var buffer = CreateBuffer(contentType, exportProvider, lines); return exportProvider.GetExportedValue<ITextEditorFactoryService>().CreateTextView(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); }
public static IWpfTextView CreateView( ExportProvider exportProvider, ITextBuffer buffer) { 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); }