public void GetOrCreate_ValidActivatorAfterInitialization_Success()
{
using (CompositionHost host = CompositionHost.CreateCompositionHost(new ExportDescriptorProvider[0]))
{
Assert.True(host.TryGetExport(new CompositionContract(typeof(CompositionContext)), out object export));
LifetimeContext context = Assert.IsType<LifetimeContext>(export);
CompositionOperation operation = null;
var value = new object();
object GetOrCreateActivate(LifetimeContext getOrCreateContext, CompositionOperation getOrCreateOperator)
{
Assert.Same(context, getOrCreateContext);
Assert.Same(operation, getOrCreateOperator);
return value;
}
object Activator(LifetimeContext activatorContext, CompositionOperation activatorOperation)
{
operation = activatorOperation;
Assert.Same(value, context.GetOrCreate(1, operation, GetOrCreateActivate));
return "Hi";
}
Assert.Equal("Hi", CompositionOperation.Run(context, Activator));
Assert.Same(value, context.GetOrCreate(1, operation, GetOrCreateActivate));
}
}
public void GetExport_OpenGenericExportFactoryWithMetadata_ThrowsIndexOutOfRangeException()
{
using (CompositionHost host = CompositionHost.CreateCompositionHost())
{
Assert.Throws <IndexOutOfRangeException>(() => host.TryGetExport(typeof(ExportFactory <,>), out object export));
}
}
public void Run_ValidContextAndAction_ReturnsExpected()
{
using (CompositionHost host = CompositionHost.CreateCompositionHost(new ExportDescriptorProvider[0]))
{
Assert.True(host.TryGetExport(new CompositionContract(typeof(CompositionContext)), out object export));
LifetimeContext context = Assert.IsType <LifetimeContext>(export);
var results = new List <string>();
void NonPrequisiteAction1() => results.Add("NonPrequisiteAction1");
void NonPrequisiteAction2() => results.Add("NonPrequisiteAction2");
void PostCompositionAction1() => results.Add("PostCompositionAction1");
void PostCompositionAction2() => results.Add("PostCompositionAction2");
object Activator(LifetimeContext activatorContext, CompositionOperation activatorOperation)
{
Assert.Same(context, activatorContext);
activatorOperation.AddNonPrerequisiteAction(NonPrequisiteAction1);
activatorOperation.AddNonPrerequisiteAction(NonPrequisiteAction2);
activatorOperation.AddPostCompositionAction(PostCompositionAction1);
activatorOperation.AddPostCompositionAction(PostCompositionAction2);
return("Hi");
}
Assert.Equal("Hi", CompositionOperation.Run(context, Activator));
Assert.Equal(new string[] { "NonPrequisiteAction1", "NonPrequisiteAction2", "PostCompositionAction1", "PostCompositionAction2" }, results);
}
}
public void GetExport_FailedDependency_ThrowsCompositionFailedException()
{
using (CompositionHost host = CompositionHost.CreateCompositionHost(new FailedDependency()))
{
Assert.Throws <CompositionFailedException>(() => host.TryGetExport(new CompositionContract(typeof(int)), out object export));
}
}
public void TryGetExport_NullContract_ThrowsArgumentNullException()
{
using (CompositionHost host = CompositionHost.CreateCompositionHost(new ExportDescriptorProvider[0]))
{
AssertExtensions.Throws <ArgumentNullException>("key", () => host.TryGetExport((CompositionContract)null, out object export));
}
}
public void GetExport_MultipleReturns_ThrowsCompositionFailedException()
{
using (CompositionHost host = CompositionHost.CreateCompositionHost(new MultiplePromises()))
{
Assert.Throws <CompositionFailedException>(() => host.TryGetExport(new CompositionContract(typeof(int)), out object export));
}
}
public void GetExport_NullProviderInProviders_ThrowsNullReferenceException()
{
using (CompositionHost host = CompositionHost.CreateCompositionHost(new ExportDescriptorProvider[] { null }))
{
Assert.Throws <NullReferenceException>(() => host.GetExport <int>());
}
}
public void GetExport_AbstractMetadata_ThrowsInvalidOperationException()
{
using (CompositionHost host = CompositionHost.CreateCompositionHost(new ExportDescriptorProvider[0]))
{
Assert.Throws <InvalidOperationException>(() => host.TryGetExport(typeof(Lazy <int, AbstractConstructor>), out object _));
}
}
public void GetExport_InvalidMetadata_ThrowsComposititionFailedException(Type type)
{
using (CompositionHost host = CompositionHost.CreateCompositionHost(new ExportDescriptorProvider[0]))
{
Assert.Throws <CompositionFailedException>(() => host.TryGetExport(type, out object _));
}
}
public void Dispose_MultipleTimes_Success()
{
CompositionHost host = CompositionHost.CreateCompositionHost(new ExportDescriptorProvider[0]);
host.Dispose();
host.Dispose();
}
public void GetExport_CompositionContextContract_ReturnsExpected()
{
using (CompositionHost host = CompositionHost.CreateCompositionHost(new ExportDescriptorProvider[0]))
{
Assert.True(host.TryGetExport(new CompositionContract(typeof(CompositionContext)), out object export));
Assert.IsType <LifetimeContext>(export);
}
}
public void GetExport_MultipleDependencies_ReturnsExpected()
{
using (CompositionHost host = CompositionHost.CreateCompositionHost(new MultipleDependency()))
{
Assert.True(host.TryGetExport(new CompositionContract(typeof(int)), out object export));
Assert.Equal("hi", export);
}
}
public void AddBoundInstance_NullInstance_ThrowsNullReferenceExceptionOnDisposal()
{
CompositionHost host = CompositionHost.CreateCompositionHost(new ExportDescriptorProvider[0]);
Assert.True(host.TryGetExport(new CompositionContract(typeof(CompositionContext)), out object export));
LifetimeContext context = Assert.IsType<LifetimeContext>(export);
context.AddBoundInstance(null);
Assert.Throws<NullReferenceException>(() => context.Dispose());
}
static void Main(string[] args)
{
using (var cc = CompositionHost.CreateCompositionHost(new BuildTimeCodeGeneration_ExportDescriptorProvider()))
{
var rh = cc.GetExport <RequestListener>();
rh.HandleRequest();
}
Console.ReadKey(true);
}
public void FindContextWithin_UnknownSharingBoundary_ThrowsCompositionFailedException()
{
using (CompositionHost host = CompositionHost.CreateCompositionHost(new ExportDescriptorProvider[0]))
{
Assert.True(host.TryGetExport(new CompositionContract(typeof(CompositionContext)), out object export));
LifetimeContext context = Assert.IsType<LifetimeContext>(export);
Assert.Throws<CompositionFailedException>(() => context.FindContextWithin("sharingBoundary"));
}
}
public void Run_NullActivator_ThrowsArgumentNullException()
{
using (CompositionHost host = CompositionHost.CreateCompositionHost(new ExportDescriptorProvider[0]))
{
Assert.True(host.TryGetExport(new CompositionContract(typeof(CompositionContext)), out object export));
LifetimeContext context = Assert.IsType <LifetimeContext>(export);
AssertExtensions.Throws <ArgumentNullException>("compositionRootActivator", () => CompositionOperation.Run(context, null));
}
}
public void FindContextWithin_NullSharingBoundary_ReturnsRoot()
{
using (CompositionHost host = CompositionHost.CreateCompositionHost(new ExportDescriptorProvider[0]))
{
Assert.True(host.TryGetExport(new CompositionContract(typeof(CompositionContext)), out object export));
LifetimeContext context = Assert.IsType<LifetimeContext>(export);
Assert.Same(context, context.FindContextWithin(null));
}
}
public void GetExport_LazyOrExportFactoryContractType_ReturnsExpected(Type type, Type[] expectedContractTypes)
{
var tracker = new TrackingProvider();
using (CompositionHost host = CompositionHost.CreateCompositionHost(tracker))
{
Assert.False(host.TryGetExport(type, out object export));
Assert.Equal(expectedContractTypes, tracker.Contracts.Select(c => c.ContractType));
}
}
public void ToString_NoParent_ReturnsExpected()
{
using (CompositionHost host = CompositionHost.CreateCompositionHost(new ExportDescriptorProvider[0]))
{
Assert.True(host.TryGetExport(new CompositionContract(typeof(CompositionContext)), out object export));
LifetimeContext context = Assert.IsType<LifetimeContext>(export);
Assert.Equal("Root Lifetime Context", context.ToString());
}
}
public void GetOrCreate_NullOperation_ThrowsNullReferenceException()
{
using (CompositionHost host = CompositionHost.CreateCompositionHost(new ExportDescriptorProvider[0]))
{
Assert.True(host.TryGetExport(new CompositionContract(typeof(CompositionContext)), out object export));
LifetimeContext context = Assert.IsType<LifetimeContext>(export);
Assert.Throws<NullReferenceException>(() => context.GetOrCreate(1, null, Activator));
}
}
public void AddBoundInstance_Disposed_ThrowsObjectDisposedException()
{
using (CompositionHost host = CompositionHost.CreateCompositionHost(new ExportDescriptorProvider[0]))
{
Assert.True(host.TryGetExport(new CompositionContract(typeof(CompositionContext)), out object export));
LifetimeContext context = Assert.IsType<LifetimeContext>(export);
context.Dispose();
Assert.Throws<ObjectDisposedException>(() => context.AddBoundInstance(null));
}
}
public void GetExport_ExportFactoryContractWithMetadataConstraints_ReturnsExpected(Type contractType, string[] sharingBoundaryNames, Type[] expectedTypes)
{
var tracker = new TrackingProvider();
using (CompositionHost host = CompositionHost.CreateCompositionHost(tracker))
{
var contract = new CompositionContract(contractType, "contractName", new Dictionary <string, object> {
{ "SharingBoundaryNames", sharingBoundaryNames }
});
Assert.False(host.TryGetExport(contract, out object export));
Assert.Equal(expectedTypes, tracker.Contracts.Select(c => c.ContractType));
}
}
public void GetExport_ImoportManyWithMetadataConstraints_ReturnsExpected(Type contractType, Type[] expectedTypes)
{
var tracker = new TrackingProvider();
using (CompositionHost host = CompositionHost.CreateCompositionHost(tracker))
{
var contract = new CompositionContract(contractType, "contractName", new Dictionary <string, object> {
{ "IsImportMany", true }
});
Assert.True(host.TryGetExport(contract, out object export));
Assert.Empty(Assert.IsAssignableFrom <Array>(export));
Assert.Equal(expectedTypes, tracker.Contracts.Select(c => c.ContractType));
}
}
public void GetOrCreate_NullActivator_ThrowsNullReferenceException()
{
using (CompositionHost host = CompositionHost.CreateCompositionHost(new ExportDescriptorProvider[0]))
{
Assert.True(host.TryGetExport(new CompositionContract(typeof(CompositionContext)), out object export));
LifetimeContext context = Assert.IsType<LifetimeContext>(export);
object Activator(LifetimeContext activatorContext, CompositionOperation activatorOperation)
{
Assert.Throws<NullReferenceException>(() => activatorContext.GetOrCreate(1, activatorOperation, null));
return "Hi";
}
Assert.Equal("Hi", CompositionOperation.Run(context, Activator));
}
}
public void AddPostCompositionAction_NullAction_ThrowsArgumentNullException()
{
object Activator(LifetimeContext context, CompositionOperation operation)
{
AssertExtensions.Throws <ArgumentNullException>("action", () => operation.AddPostCompositionAction(null));
return(null);
}
using (CompositionHost host = CompositionHost.CreateCompositionHost(new ExportDescriptorProvider[0]))
{
Assert.True(host.TryGetExport(new CompositionContract(typeof(CompositionContext)), out object export));
LifetimeContext context = Assert.IsType <LifetimeContext>(export);
CompositionOperation.Run(context, Activator);
}
}
public void AddBoundInstance_NonNullInstance_DisposesInstanceOnDisposal()
{
using (CompositionHost host = CompositionHost.CreateCompositionHost(new ExportDescriptorProvider[0]))
{
Assert.True(host.TryGetExport(new CompositionContract(typeof(CompositionContext)), out object export));
LifetimeContext context = Assert.IsType<LifetimeContext>(export);
var instance = new DisposableInstance();
context.AddBoundInstance(instance);
Assert.Equal(0, instance.CalledDisposed);
context.Dispose();
Assert.Equal(1, instance.CalledDisposed);
context.Dispose();
Assert.Equal(1, instance.CalledDisposed);
}
}
public void CreateCompositionHost_NullProvider_ThrowsArgumentNullException()
{
AssertExtensions.Throws <ArgumentNullException>("providers", () => CompositionHost.CreateCompositionHost(null));
AssertExtensions.Throws <ArgumentNullException>("providers", () => CompositionHost.CreateCompositionHost((IEnumerable <ExportDescriptorProvider>)null));
}
