public void ImportCompletedTest()
{
var container = ContainerFactory.Create();
CompositionBatch batch = new CompositionBatch();
var entrypoint = new UpperCaseStringComponent();
batch.AddParts(new LowerCaseString("abc"), entrypoint);
container.Compose(batch);
batch = new CompositionBatch();
batch.AddParts(new object());
container.Compose(batch);
Assert.AreEqual(entrypoint.LowerCaseStrings.Count, 1);
Assert.AreEqual(entrypoint.ImportCompletedCallCount, 1);
Assert.AreEqual(entrypoint.UpperCaseStrings.Count, 1);
Assert.AreEqual(entrypoint.LowerCaseStrings[0].Value.String, "abc");
Assert.AreEqual(entrypoint.UpperCaseStrings[0], "ABC");
}
public void ImportCompletedWithRecomposing()
{
var container = ContainerFactory.Create();
CompositionBatch batch = new CompositionBatch();
var entrypoint = new UpperCaseStringComponent();
batch.AddParts(new LowerCaseString("abc"), entrypoint);
container.Compose(batch);
Assert.AreEqual(entrypoint.LowerCaseStrings.Count, 1);
Assert.AreEqual(entrypoint.ImportCompletedCallCount, 1);
Assert.AreEqual(entrypoint.UpperCaseStrings.Count, 1);
Assert.AreEqual(entrypoint.LowerCaseStrings[0].Value.String, "abc");
Assert.AreEqual(entrypoint.UpperCaseStrings[0], "ABC");
// Add another component to verify recomposing
batch = new CompositionBatch();
batch.AddParts(new LowerCaseString("def"));
container.Compose(batch);
Assert.AreEqual(entrypoint.LowerCaseStrings.Count, 2);
Assert.AreEqual(entrypoint.ImportCompletedCallCount, 2);
Assert.AreEqual(entrypoint.UpperCaseStrings.Count, 2);
Assert.AreEqual(entrypoint.LowerCaseStrings[1].Value.String, "def");
Assert.AreEqual(entrypoint.UpperCaseStrings[1], "DEF");
// Verify that adding a random component doesn't cause
// the OnImportsSatisfied to be called again.
batch = new CompositionBatch();
batch.AddParts(new object());
container.Compose(batch);
Assert.AreEqual(entrypoint.LowerCaseStrings.Count, 2);
Assert.AreEqual(entrypoint.ImportCompletedCallCount, 2);
Assert.AreEqual(entrypoint.UpperCaseStrings.Count, 2);
}
public void ImportCompletedBindChildIndirectlyThroughParentContainerBind()
{
var cat = CatalogFactory.CreateDefaultAttributed();
var parent = new CompositionContainer(cat);
CompositionBatch parentBatch = new CompositionBatch();
CompositionBatch childBatch = new CompositionBatch();
parentBatch.AddExportedValue<ICompositionService>(parent);
parent.Compose(parentBatch);
var child = new CompositionContainer(parent);
var parentImporter = new MyNotifyImportImporter(parent);
var childImporter = new MyNotifyImportImporter(child);
parentBatch = new CompositionBatch();
parentBatch.AddPart(parentImporter);
childBatch.AddParts(childImporter, new MyNotifyImportExporter());
parent.Compose(parentBatch);
child.Compose(childBatch);
Assert.AreEqual(1, parentImporter.ImportCompletedCallCount);
Assert.AreEqual(1, childImporter.ImportCompletedCallCount);
MyNotifyImportExporter parentExporter = parent.GetExportedValue<MyNotifyImportExporter>("MyNotifyImportExporter");
Assert.AreEqual(1, parentExporter.ImportCompletedCallCount);
MyNotifyImportExporter childExporter = child.GetExportedValue<MyNotifyImportExporter>("MyNotifyImportExporter");
Assert.AreEqual(1, childExporter.ImportCompletedCallCount);
}
public void ImportCompletedChildDoesnotNeedParentContainer()
{
var cat = CatalogFactory.CreateDefaultAttributed();
var parent = new CompositionContainer(cat);
CompositionBatch parentBatch = new CompositionBatch();
CompositionBatch childBatch = new CompositionBatch();
parentBatch.AddExportedValue<ICompositionService>(parent);
parent.Compose(parentBatch);
var child = new CompositionContainer(parent);
var parentImporter = new MyNotifyImportImporter(parent);
var childImporter = new MyNotifyImportImporter(child);
parentBatch = new CompositionBatch();
parentBatch.AddPart(parentImporter);
childBatch.AddParts(childImporter, new MyNotifyImportExporter());
child.Compose(childBatch);
Assert.AreEqual(0, parentImporter.ImportCompletedCallCount);
Assert.AreEqual(1, childImporter.ImportCompletedCallCount);
// Parent will become bound at this point.
MyNotifyImportExporter parentExporter = parent.GetExportedValue<MyNotifyImportExporter>("MyNotifyImportExporter");
parent.Compose(parentBatch);
Assert.AreEqual(1, parentImporter.ImportCompletedCallCount);
Assert.AreEqual(1, parentExporter.ImportCompletedCallCount);
MyNotifyImportExporter childExporter = child.GetExportedValue<MyNotifyImportExporter>("MyNotifyImportExporter");
Assert.AreEqual(1, childExporter.ImportCompletedCallCount);
}
public void ImportCompletedAddPartAndBindComponent()
{
var container = ContainerFactory.Create();
CompositionBatch batch = new CompositionBatch();
batch.AddParts(new CallbackImportNotify(delegate
{
batch = new CompositionBatch();
batch.AddPart(new object());
container.Compose(batch);
}));
container.Compose(batch);
}
public void ImportCompletedCalledAfterAllImportsAreFullyComposed()
{
int importSatisfationCount = 0;
var importer1 = new MyEventDrivenFullComposedNotifyImporter1();
var importer2 = new MyEventDrivenFullComposedNotifyImporter2();
Action<object, EventArgs> verificationAction = (object sender, EventArgs e) =>
{
Assert.IsTrue(importer1.AreAllImportsFullyComposed);
Assert.IsTrue(importer2.AreAllImportsFullyComposed);
++importSatisfationCount;
};
importer1.ImportsSatisfied += new EventHandler(verificationAction);
importer2.ImportsSatisfied += new EventHandler(verificationAction);
// importer1 added first
var batch = new CompositionBatch();
batch.AddParts(importer1, importer2);
var container = ContainerFactory.Create();
container.ComposeExportedValue<ICompositionService>(container);
container.Compose(batch);
Assert.AreEqual(2, importSatisfationCount);
// importer2 added first
importSatisfationCount = 0;
batch = new CompositionBatch();
batch.AddParts(importer2, importer1);
container = ContainerFactory.Create();
container.ComposeExportedValue<ICompositionService>(container);
container.Compose(batch);
Assert.AreEqual(2, importSatisfationCount);
}
public void ImportCompletedUsingSatisfyImportsOnce()
{
var container = ContainerFactory.Create();
CompositionBatch batch = new CompositionBatch();
var entrypoint = new UpperCaseStringComponent();
var entrypointPart = AttributedModelServices.CreatePart(entrypoint);
batch.AddParts(new LowerCaseString("abc"));
container.Compose(batch);
container.SatisfyImportsOnce(entrypointPart);
Assert.AreEqual(1, entrypoint.LowerCaseStrings.Count);
Assert.AreEqual(1, entrypoint.ImportCompletedCallCount);
Assert.AreEqual(1, entrypoint.UpperCaseStrings.Count);
Assert.AreEqual("abc", entrypoint.LowerCaseStrings[0].Value.String);
Assert.AreEqual("ABC", entrypoint.UpperCaseStrings[0]);
batch = new CompositionBatch();
batch.AddParts(new object());
container.Compose(batch);
container.SatisfyImportsOnce(entrypointPart);
Assert.AreEqual(1, entrypoint.LowerCaseStrings.Count);
Assert.AreEqual(1, entrypoint.ImportCompletedCallCount);
Assert.AreEqual(1, entrypoint.UpperCaseStrings.Count);
Assert.AreEqual("abc", entrypoint.LowerCaseStrings[0].Value.String);
Assert.AreEqual("ABC", entrypoint.UpperCaseStrings[0]);
batch.AddParts(new LowerCaseString("def"));
container.Compose(batch);
container.SatisfyImportsOnce(entrypointPart);
Assert.AreEqual(2, entrypoint.LowerCaseStrings.Count);
Assert.AreEqual(2, entrypoint.ImportCompletedCallCount);
Assert.AreEqual(2, entrypoint.UpperCaseStrings.Count);
Assert.AreEqual("abc", entrypoint.LowerCaseStrings[0].Value.String);
Assert.AreEqual("ABC", entrypoint.UpperCaseStrings[0]);
Assert.AreEqual("def", entrypoint.LowerCaseStrings[1].Value.String);
Assert.AreEqual("DEF", entrypoint.UpperCaseStrings[1]);
}
public void ThreadSafeCompositionContainer()
{
TypeCatalog catalog = new TypeCatalog(typeof(SimpleExporter));
CompositionContainer container = new CompositionContainer(catalog, true);
Int32Importer importer = new Int32Importer();
CompositionBatch batch = new CompositionBatch();
batch.AddParts(importer, new Int32Exporter(42));
container.Compose(batch);
Assert.IsNotNull(container.GetExportedValue<SimpleExporter>());
Assert.AreEqual(42, importer.Value, "Expected value imported from export");
container.Dispose();
}
public void ImportCollectionsFromContainerOnly()
{
var container = ContainerFactory.Create();
Importer importer = new Importer();
CompositionBatch batch = new CompositionBatch();
batch.AddParts(importer
, new ExporterDefault21()
, new ExporterDefault21(22)
, new ExporterDefault42()
, new ExporterDefault42(43));
container.Compose(batch);
importer.VerifyImport(21, 22, 42, 43);
}
public void ExceptionDuringNotify()
{
var container = CreateCompositionContainer();
CompositionBatch batch = new CompositionBatch();
batch.AddParts(new CallbackImportNotify(delegate
{
throw new InvalidOperationException();
}));
CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotActivate, // Cannot activate CallbackImportNotify because
ErrorId.ReflectionModel_PartOnImportsSatisfiedThrewException, // OnImportsSatisfied threw an exception
RetryMode.DoNotRetry, () =>
{
container.Compose(batch);
});
}
public void ComposeSimple()
{
var container = CreateCompositionContainer();
Int32Importer importer = new Int32Importer();
CompositionBatch batch = new CompositionBatch();
batch.AddParts(importer, new Int32Exporter(42));
container.Compose(batch);
Assert.AreEqual(42, importer.Value, "Expected value imported from export");
}
public void ComposeReentrantChildContainerDisposed()
{
var container = CreateCompositionContainer();
Int32Importer outerImporter = new Int32Importer();
Int32Importer innerImporter = new Int32Importer();
Int32Exporter exporter = new Int32Exporter(42);
CompositionBatch batch = new CompositionBatch();
batch.AddPart(exporter);
container.Compose(batch);
CallbackExecuteCodeDuringCompose callback = new CallbackExecuteCodeDuringCompose(() =>
{
using (CompositionContainer innerContainer = new CompositionContainer(container))
{
CompositionBatch nestedBatch = new CompositionBatch();
nestedBatch.AddPart(innerImporter);
innerContainer.Compose(nestedBatch);
}
Assert.AreEqual(42, innerImporter.Value, "Expected value imported from export");
});
batch = new CompositionBatch();
batch.AddParts(outerImporter, callback);
container.Compose(batch);
Assert.AreEqual(42, outerImporter.Value, "Expected value imported from export");
Assert.AreEqual(42, innerImporter.Value, "Expected value imported from export");
}
public void TryGetExportedValueWhileLockedForNotify()
{
var container = CreateCompositionContainer();
CompositionBatch batch = new CompositionBatch();
batch.AddParts(new CallbackImportNotify(delegate
{
container.GetExportedValueOrDefault<int>();
}));
container.Compose(batch);
}
public void TryComposeSimpleFail()
{
var container = CreateCompositionContainer();
Int32Importer importer = new Int32Importer();
CompositionBatch batch = new CompositionBatch();
batch.AddParts(importer);
CompositionAssert.ThrowsChangeRejectedError(ErrorId.ImportEngine_PartCannotSetImport, ErrorId.ImportEngine_ImportCardinalityMismatch, RetryMode.DoNotRetry, () =>
{
container.Compose(batch);
});
Assert.AreEqual(0, importer.Value, "Expected default value to remain");
}
public void ImportCollectionsFormContainerAndCatalog()
{
var cat = CatalogFactory.CreateDefaultAttributed();
var container = new CompositionContainer(cat);
Importer importer = new Importer();
CompositionBatch batch = new CompositionBatch();
batch.AddParts(importer
, new ExporterDefault21(22)
, new ExporterDefault42(43));
container.Compose(batch);
importer.VerifyImport(22, 43, 21, 42);
}
public void ImportCollectionsFromCatalogOnly()
{
var cat = CatalogFactory.CreateDefaultAttributed();
var container = new CompositionContainer(cat);
Importer importer = new Importer();
CompositionBatch batch = new CompositionBatch();
batch.AddParts(importer);
container.Compose(batch);
importer.VerifyImport(21, 42);
}
public void NeutralComposeWhileNotified()
{
var container = CreateCompositionContainer();
CompositionBatch batch = new CompositionBatch();
batch.AddParts(new CallbackImportNotify(delegate
{
// Is this really a supported scenario?
container.Compose(batch);
}));
container.Compose(batch);
}
public void DelayImportValueComComponent()
{
CTaskScheduler scheduler = new CTaskScheduler();
try
{
var container = ContainerFactory.Create();
var importer = new DelayImportComComponent();
CompositionBatch batch = new CompositionBatch();
batch.AddParts(importer);
batch.AddExportedValue<ITaskScheduler>("TaskScheduler", (ITaskScheduler)scheduler);
container.Compose(batch);
Assert.AreEqual(scheduler, importer.TaskScheduler.Value);
}
finally
{
Marshal.ReleaseComObject(scheduler);
}
}
