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);
}
