public ExportProvider GetOrCreateExportProvider()
{
if (!Enabled)
{
// The [UseExportProvider] attribute on tests ensures that the pre- and post-conditions of methods
// in this type are met during test conditions.
throw new InvalidOperationException($"{nameof(ExportProviderCache)} may only be used from tests marked with {nameof(UseExportProviderAttribute)}");
}
var expectedCatalog = Interlocked.CompareExchange(ref _expectedCatalog, _catalog, null) ?? _catalog;
RequireForSingleExportProvider(expectedCatalog == _catalog);
var expected = _expectedProviderForCatalog;
if (expected == null)
{
expected = _exportProviderFactory.CreateExportProvider();
expected = Interlocked.CompareExchange(ref _expectedProviderForCatalog, expected, null) ?? expected;
Interlocked.CompareExchange(ref _currentExportProvider, expected, null);
}
var exportProvider = _currentExportProvider;
RequireForSingleExportProvider(exportProvider == expected);
return(exportProvider);
}
public ExportProvider GetOrCreateExportProvider()
{
if (!Enabled)
{
// The [UseExportProvider] attribute on tests ensures that the pre- and post-conditions of methods
// in this type are met during test conditions.
throw new InvalidOperationException($"{nameof(ExportProviderCache)} may only be used from tests marked with {nameof(UseExportProviderAttribute)}");
}
var expectedCatalog = Interlocked.CompareExchange(ref _scope.ExpectedCatalog, _catalog, null) ?? _catalog;
RequireForSingleExportProvider(expectedCatalog == _catalog);
var expected = _scope.ExpectedProviderForCatalog;
if (expected == null)
{
foreach (var errorCollection in _configuration.CompositionErrors)
{
foreach (var error in errorCollection)
{
foreach (var part in error.Parts)
{
foreach (var pair in part.SatisfyingExports)
{
var(importBinding, exportBindings) = (pair.Key, pair.Value);
if (exportBindings.Count <= 1)
{
// Ignore composition errors for missing parts
continue;
}
if (importBinding.ImportDefinition.Cardinality != ImportCardinality.ZeroOrMore)
{
// This failure occurs when a binding fails because multiple exports were
// provided but only a single one (at most) is expected. This typically occurs
// when a test ExportProvider is created with a mock implementation without
// first removing a value provided by default.
throw new InvalidOperationException(
"Failed to construct the MEF catalog for testing. Multiple exports were found for a part for which only one export is expected:" + Environment.NewLine
+ error.Message);
}
}
}
}
}
expected = _exportProviderFactory.CreateExportProvider();
expected = Interlocked.CompareExchange(ref _scope.ExpectedProviderForCatalog, expected, null) ?? expected;
Interlocked.CompareExchange(ref _scope.CurrentExportProvider, expected, null);
}
var exportProvider = _scope.CurrentExportProvider;
RequireForSingleExportProvider(exportProvider == expected);
return(exportProvider !);
}
private static async Task InitializeMef()
{
// 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 = await discovery.CreatePartsAsync(asm);
catalog = catalog.AddParts(parts);
}
catch (Exception ex)
{
StartupExceptions.Add(new ExceptionData {
Exception = ex, PluginName = name
});
}
}
}
// Add the built-in parts
var createdParts = await discovery.CreatePartsAsync(Assembly.GetExecutingAssembly());
catalog = catalog.AddParts(createdParts);
// 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
});
}
}
public static EncapsulateFieldTestState Create(string markup)
{
var exportProvider = s_exportProviderFactory.CreateExportProvider();
var workspace = TestWorkspace.CreateCSharp(markup, exportProvider: exportProvider);
workspace.Options = workspace.Options
.WithChangedOption(CSharpCodeStyleOptions.PreferExpressionBodiedAccessors, CSharpCodeStyleOptions.NeverWithSilentEnforcement)
.WithChangedOption(CSharpCodeStyleOptions.PreferExpressionBodiedProperties, CSharpCodeStyleOptions.NeverWithSilentEnforcement);
return(new EncapsulateFieldTestState(workspace));
}
private async Task TestAsync(string markup, string expectedText)
{
using var workspace = TestWorkspace.CreateCSharp(markup, exportProvider: s_exportProviderFactory.CreateExportProvider());
var caret = workspace.Documents.First().CursorPosition;
var service = Assert.IsType <CSharpHelpContextService>(workspace.Services.GetLanguageServices(LanguageNames.CSharp).GetService <IHelpContextService>());
var actualText = await service.GetHelpTermAsync(workspace.CurrentSolution.Projects.First().Documents.First(), workspace.Documents.First().SelectedSpans.First(), CancellationToken.None);
Assert.Equal(expectedText, actualText);
}
private async Task <ExportProvider> Compose(object parentInstance)
{
ExportProvider exportProvider = null;
PartDiscovery discovery = PartDiscovery.Combine(
new AttributedPartDiscovery(Resolver.DefaultInstance),
new AttributedPartDiscoveryV1(Resolver.DefaultInstance)); // ".NET MEF" attributes (System.ComponentModel.Composition)
Assembly parentAssembly = parentInstance.GetType().Assembly;
string parentLocation = parentAssembly.Location;
string assemblyPath = parentLocation;
assemblyPath = assemblyPath.Substring(0, assemblyPath.LastIndexOf('\\'));
Helpers desktopBridgeHelper = new Helpers();
List <string> assemblies = new[] { parentLocation }
.Concat(
Directory.EnumerateFiles(assemblyPath, "*.dll", SearchOption.TopDirectoryOnly)
.Where(_ => _.Contains("NUnit3GUI")))
.ToList();
DiscoveredParts discoveredParts = await discovery.CreatePartsAsync(assemblies);
discoveredParts.ThrowOnErrors();
ComposableCatalog catalog = ComposableCatalog.Create(Resolver.DefaultInstance)
.AddParts(discoveredParts)
.WithCompositionService();
CompositionConfiguration config = CompositionConfiguration.Create(catalog);
config.ThrowOnErrors();
IExportProviderFactory epf = config.CreateExportProviderFactory();
exportProvider = epf.CreateExportProvider();
ICompositionService service = exportProvider.GetExportedValue <ICompositionService>();
service.SatisfyImportsOnce(parentInstance);
return(exportProvider);
}
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).Result;
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()).Result);
// 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();
}
protected TestWorkspace CreateWorkspaceFromFile(string initialMarkup, TestParameters parameters, IExportProviderFactory exportProviderFactory) => TestWorkspace.CreateCSharp(initialMarkup, parameters.parseOptions, parameters.compilationOptions, exportProvider: exportProviderFactory.CreateExportProvider());
protected override ExportProvider GetExportProvider() => s_exportProviderFactory.CreateExportProvider();
/// <summary>
/// Creates a new MEF container, initialized with all the assemblies
/// specified in the constructor.
/// </summary>
/// <returns>A task whose result is the <see cref="ExportProvider"/>.</returns>
public async Task <ExportProvider> CreateExportProviderAsync()
{
IExportProviderFactory exportProviderFactory = await this.exportProviderFactory.GetValueAsync().ConfigureAwait(false);
return(exportProviderFactory.CreateExportProvider());
}
/// <summary>
/// Creates an export provider which represents a unique container of values.
/// You can create as many of these as you want,
/// typicall each test has its own Host, and an application has a single Host.
/// </summary>
internal Host(IExportProviderFactory epf)
{
_exportProvider = epf.CreateExportProvider();
}
public async Task AnalyzeDocumentAsync_InsignificantChangesInMethodBody()
{
var source1 = @"
class C
{
public static void Main()
{
// comment
System.Console.WriteLine(1);
}
}
";
var source2 = @"
class C
{
public static void Main()
{
System.Console.WriteLine(1);
}
}
";
using var workspace = TestWorkspace.CreateCSharp(source1, exportProvider: s_exportProviderFactoryWithTestActiveStatementSpanTracker.CreateExportProvider());
var oldSolution = workspace.CurrentSolution;
var oldProject = oldSolution.Projects.Single();
var oldDocument = oldProject.Documents.Single();
var oldText = await oldDocument.GetTextAsync();
var oldSyntaxRoot = await oldDocument.GetSyntaxRootAsync();
var documentId = oldDocument.Id;
var newSolution = workspace.CurrentSolution.WithDocumentText(documentId, SourceText.From(source2));
var newDocument = newSolution.GetDocument(documentId);
var newText = await newDocument.GetTextAsync();
var newSyntaxRoot = await newDocument.GetSyntaxRootAsync();
const string oldStatementSource = "System.Console.WriteLine(1);";
var oldStatementPosition = source1.IndexOf(oldStatementSource, StringComparison.Ordinal);
var oldStatementTextSpan = new TextSpan(oldStatementPosition, oldStatementSource.Length);
var oldStatementSpan = oldText.Lines.GetLinePositionSpan(oldStatementTextSpan);
var oldStatementSyntax = oldSyntaxRoot.FindNode(oldStatementTextSpan);
var baseActiveStatements = ImmutableArray.Create(ActiveStatementsDescription.CreateActiveStatement(ActiveStatementFlags.IsLeafFrame, oldStatementSpan, DocumentId.CreateNewId(ProjectId.CreateNewId())));
var spanTracker = Assert.IsType <TestActiveStatementSpanTracker>(workspace.Services.GetRequiredService <IActiveStatementSpanTrackerFactory>().GetOrCreateActiveStatementSpanTracker());
var analyzer = new CSharpEditAndContinueAnalyzer(spanTracker);
var result = await analyzer.AnalyzeDocumentAsync(oldDocument, baseActiveStatements, newDocument, CancellationToken.None);
Assert.True(result.HasChanges);
Assert.True(result.SemanticEdits[0].PreserveLocalVariables);
var syntaxMap = result.SemanticEdits[0].SyntaxMap;
var newStatementSpan = result.ActiveStatements[0].Span;
var newStatementTextSpan = newText.Lines.GetTextSpan(newStatementSpan);
var newStatementSyntax = newSyntaxRoot.FindNode(newStatementTextSpan);
var oldStatementSyntaxMapped = syntaxMap(newStatementSyntax);
Assert.Same(oldStatementSyntax, oldStatementSyntaxMapped);
}