internal static async Task <RunSummary> RunMultiEngineTest(CompositionEngines attributesVersion, Type[] parts, Func <IContainer, Task <RunSummary> > test, ITestOutputHelper output)
{
Requires.NotNull(output, nameof(output));
var totalSummary = new RunSummary();
if (attributesVersion.HasFlag(CompositionEngines.V1))
{
totalSummary.Aggregate(await test(CreateContainerV1(parts)));
}
if (attributesVersion.HasFlag(CompositionEngines.V3EmulatingV1))
{
totalSummary.Aggregate(await test(await CreateContainerV3Async(parts, CompositionEngines.V1, output)));
}
if (attributesVersion.HasFlag(CompositionEngines.V2))
{
totalSummary.Aggregate(await test(CreateContainerV2(parts)));
}
if (attributesVersion.HasFlag(CompositionEngines.V3EmulatingV2))
{
totalSummary.Aggregate(await test(await CreateContainerV3Async(parts, CompositionEngines.V2, output)));
}
if (attributesVersion.HasFlag(CompositionEngines.V3EmulatingV1AndV2AtOnce))
{
totalSummary.Aggregate(await test(await CreateContainerV3Async(parts, CompositionEngines.V1 | CompositionEngines.V2, output)));
}
return(totalSummary);
}
private async Task <RunSummary> RunMultiEngineTestAsync(CompositionEngines attributesVersion, Type[] parts, IReadOnlyList <string> assemblies, Func <IContainer, Task <RunSummary> > test)
{
try
{
parts = parts ?? new Type[0];
var loadedAssemblies = assemblies != null?assemblies.Select(Assembly.Load).ToImmutableList() : ImmutableList <Assembly> .Empty;
if (attributesVersion.HasFlag(CompositionEngines.V1))
{
return(await test(TestUtilities.CreateContainerV1(loadedAssemblies, parts)));
}
if (attributesVersion.HasFlag(CompositionEngines.V2))
{
return(await test(TestUtilities.CreateContainerV2(loadedAssemblies, parts)));
}
throw new InvalidOperationException();
}
catch (Exception ex)
{
var t = new XunitTest(this.TestCase, this.DisplayName);
if (!this.MessageBus.QueueMessage(new TestFailed(t, 0, null, ex)))
{
this.CancellationTokenSource.Cancel();
}
return(new RunSummary {
Total = 1, Failed = 1
});
}
}
public MefFactAttribute(CompositionEngines compositionVersions, params string[] assemblies)
: this(compositionVersions)
{
Requires.NotNull(assemblies, nameof(assemblies));
this.Assemblies = assemblies.ToImmutableList();
}
public MefFactAttribute(CompositionEngines compositionVersions, params Type[] parts)
: this(compositionVersions)
{
Requires.NotNull(parts, nameof(parts));
this.Parts = parts;
this.Assemblies = ImmutableList <string> .Empty;
}
public Mef3TestCaseRunner(IXunitTestCase testCase, string displayName, string?skipReason, object[] constructorArguments, IMessageBus messageBus, ExceptionAggregator aggregator, CancellationTokenSource cancellationTokenSource, CompositionConfiguration configuration, CompositionEngines compositionVersions)
: base(testCase, displayName, skipReason, constructorArguments, null, messageBus, aggregator, cancellationTokenSource)
{
Requires.NotNull(configuration, nameof(configuration));
this.configuration = configuration;
this.compositionVersions = compositionVersions;
}
public override void Deserialize(IXunitSerializationInfo data)
{
base.Deserialize(data);
this.parts = data.GetValue <Type[]>(nameof(this.parts));
this.assemblies = data.GetValue <string[]>(nameof(this.assemblies));
this.compositionVersions = data.GetValue <CompositionEngines>(nameof(this.compositionVersions));
this.noCompatGoal = data.GetValue <bool>(nameof(this.noCompatGoal));
this.invalidConfiguration = data.GetValue <bool>(nameof(this.invalidConfiguration));
}
public MefFactAttribute(CompositionEngines compositionVersions, string newLineSeparatedAssemblyNames, params Type[] parts)
: this(compositionVersions, parts)
{
Requires.NotNullOrEmpty(newLineSeparatedAssemblyNames, nameof(newLineSeparatedAssemblyNames));
this.Assemblies = newLineSeparatedAssemblyNames
.Split(new char[] { '\n', '\r' }, StringSplitOptions.RemoveEmptyEntries)
.Select(l => l.Trim())
.Where(l => !string.IsNullOrEmpty(l))
.ToImmutableList();
}
public LegacyMefTestCaseRunner(IXunitTestCase testCase, string displayName, string skipReason, object[] constructorArguments, IMessageBus messageBus, ExceptionAggregator aggregator, CancellationTokenSource cancellationTokenSource, CompositionEngines engineVersion, Type[] parts, IReadOnlyList <string> assemblies, bool invalidConfiguration)
: base(testCase, displayName, skipReason, constructorArguments, null, new TestResultInverter(messageBus, invalidConfiguration), aggregator, cancellationTokenSource)
{
Requires.Argument(parts != null || assemblies != null, "parts ?? assemblies", "Either parameter must be non-null.");
this.engineVersion = engineVersion;
this.parts = parts;
this.assemblies = assemblies;
this.DisplayName = engineVersion.ToString();
this.invalidConfiguration = invalidConfiguration;
}
public Mef3DiscoveryTestCaseRunner(IXunitTestCase testCase, string displayName, string skipReason, object[] constructorArguments, IMessageBus messageBus, ExceptionAggregator aggregator, CancellationTokenSource cancellationTokenSource, CompositionEngines compositionEngines, Type[] parts, IReadOnlyList <string> assemblyNames, bool expectInvalidConfiguration)
: base(testCase, displayName, skipReason, constructorArguments, null, messageBus, aggregator, cancellationTokenSource)
{
Requires.NotNull(testCase, nameof(testCase));
Requires.NotNull(parts, nameof(parts));
Requires.NotNull(assemblyNames, nameof(assemblyNames));
this.compositionVersions = compositionEngines;
this.assemblyNames = assemblyNames;
this.parts = parts;
this.expectInvalidConfiguration = expectInvalidConfiguration;
}
public MefFactTestCase(IMessageSink diagnosticMessageSink, TestMethodDisplay defaultMethodDisplay, ITestMethod testMethod, IAttributeInfo factAttributeInfo)
: base(diagnosticMessageSink, defaultMethodDisplay, testMethod)
{
var factAttribute = MefFactAttribute.Instantiate(factAttributeInfo);
this.SkipReason = factAttribute.Skip;
this.parts = factAttribute.Parts;
this.assemblies = factAttribute.Assemblies;
this.compositionVersions = factAttribute.CompositionVersions;
this.noCompatGoal = factAttribute.NoCompatGoal;
this.invalidConfiguration = factAttribute.InvalidConfiguration;
}
private static PartDiscovery GetDiscoveryService(CompositionEngines attributesDiscovery)
{
var discovery = new List <PartDiscovery>(2);
if (attributesDiscovery.HasFlag(CompositionEngines.V1))
{
discovery.Add(V1Discovery);
}
if (attributesDiscovery.HasFlag(CompositionEngines.V2))
{
var v2Discovery = attributesDiscovery.HasFlag(CompositionEngines.V3NonPublicSupport)
? V2DiscoveryWithNonPublics
: V2Discovery;
discovery.Add(v2Discovery);
}
return(PartDiscovery.Combine(discovery.ToArray()));
}
public MefFactTestCase(IMessageSink diagnosticMessageSink, TestMethodDisplay defaultMethodDisplay, ITestMethod testMethod, IAttributeInfo factAttributeInfo)
: base(diagnosticMessageSink, defaultMethodDisplay, testMethod)
{
var factAttribute = MefFactAttribute.Instantiate(factAttributeInfo);
this.SkipReason = factAttribute.Skip;
this.parts = factAttribute.Parts;
this.assemblies = factAttribute.Assemblies;
this.compositionVersions = factAttribute.CompositionVersions;
this.noCompatGoal = factAttribute.NoCompatGoal;
this.invalidConfiguration = factAttribute.InvalidConfiguration;
if (this.Traits.ContainsKey(Tests.Traits.SkipOnMono) && TestUtilities.IsOnMono)
{
this.SkipReason = this.SkipReason ?? "Test marked as skipped on Mono runtime due to unsupported feature: " + string.Join(", ", this.Traits[Tests.Traits.SkipOnMono]);
}
if (this.Traits.ContainsKey(Tests.Traits.SkipOnCoreCLR) && TestUtilities.IsOnCoreCLR)
{
this.SkipReason = this.SkipReason ?? "Test marked as skipped on CoreCLR runtime due to unsupported feature: " + string.Join(", ", this.Traits[Tests.Traits.SkipOnCoreCLR]);
}
}
public MefFactAttribute(CompositionEngines compositionVersions)
{
this.CompositionVersions = compositionVersions;
}
private static async Task <IContainer> CreateContainerV3Async(ComposableCatalog catalog, CompositionEngines options, ITestOutputHelper output)
{
Requires.NotNull(catalog, nameof(catalog));
Requires.NotNull(output, nameof(output));
var catalogWithCompositionService = catalog
.WithCompositionService();
var configuration = CompositionConfiguration.Create(catalogWithCompositionService);
if (!options.HasFlag(CompositionEngines.V3AllowConfigurationWithErrors))
{
configuration.ThrowOnErrors();
}
#if DGML
string dgmlFile = System.IO.Path.GetTempFileName() + ".dgml";
configuration.CreateDgml().Save(dgmlFile);
output.WriteLine("DGML saved to: " + dgmlFile);
#endif
var container = await configuration.CreateContainerAsync(output);
return(new V3ContainerWrapper(container, configuration));
}
internal static async Task <CompositionConfiguration> CreateConfigurationAsync(CompositionEngines attributesDiscovery, params Type[] parts)
{
PartDiscovery discovery = GetDiscoveryService(attributesDiscovery);
var assemblyParts = await discovery.CreatePartsAsync(parts);
var catalog = EmptyCatalog.AddParts(assemblyParts);
return(CompositionConfiguration.Create(catalog));
}
internal static async Task <IContainer> CreateContainerV3Async(IReadOnlyList <Assembly> assemblies, CompositionEngines attributesDiscovery, ITestOutputHelper output, Type[] parts = null)
{
PartDiscovery discovery = GetDiscoveryService(attributesDiscovery);
var assemblyParts = await discovery.CreatePartsAsync(assemblies);
var catalog = EmptyCatalog.AddParts(assemblyParts);
if (parts != null && parts.Length != 0)
{
var typeCatalog = EmptyCatalog.AddParts(await discovery.CreatePartsAsync(parts));
catalog = EmptyCatalog.AddParts(catalog.Parts.Concat(typeCatalog.Parts));
}
return(await CreateContainerV3Async(catalog, attributesDiscovery, output));
}
internal static Task <IContainer> CreateContainerV3Async(Type[] parts, CompositionEngines attributesDiscovery, ITestOutputHelper output)
{
return(CreateContainerV3Async(default(IReadOnlyList <Assembly>), attributesDiscovery, output, parts));
}
