/mcs/class/System.ComponentModel.Composition/Tests/ComponentModelUnitTest/System/ComponentModel/Composition/CompositionContainerTests.cs

Large files files are truncated, but you can click here to view the full file

// -----------------------------------------------------------------------

// Copyright (c) Microsoft Corporation.  All rights reserved.

// -----------------------------------------------------------------------

using System;

using System.Collections.Generic;

using System.ComponentModel.Composition;

using System.Linq;

using System.Linq.Expressions;

using System.Runtime.Serialization;

using Microsoft.VisualStudio.TestTools.UnitTesting;

using System.ComponentModel.Composition.Factories;

using System.UnitTesting;

using System.ComponentModel.Composition.AttributedModel;

using System.ComponentModel.Composition.Hosting;

using System.ComponentModel.Composition.Primitives;

using System.ComponentModel.Composition.UnitTesting;



namespace System.ComponentModel.Composition

{

    [TestClass]

    public class CompositionContainerTests

    {

        [TestMethod]

        public void Constructor2_ArrayWithNullElementAsProvidersArgument_ShouldThrowArgumentException()

        {

            ExceptionAssert.ThrowsArgument<ArgumentException>("providers", () =>

            {

                new CompositionContainer(new ExportProvider[] { null });

            });

        }



        [TestMethod]

        public void Constructor3_ArrayWithNullElementAsProvidersArgument_ShouldThrowArgumentException()

        {

            var catalog = CatalogFactory.Create();



            ExceptionAssert.ThrowsArgument<ArgumentException>("providers", () =>

            {

                new CompositionContainer(catalog, new ExportProvider[] { null });

            });

        }



        [TestMethod]

        public void Constructor2_ArrayAsProvidersArgument_ShouldNotAllowModificationAfterConstruction()

        {

            var providers = new ExportProvider[] { ExportProviderFactory.Create() };

            var container = new CompositionContainer(providers);



            providers[0] = null;



            Assert.IsNotNull(container.Providers[0]);

        }



        [TestMethod]

        public void Constructor3_ArrayAsProvidersArgument_ShouldNotAllowModificationAfterConstruction()

        {

            var providers = new ExportProvider[] { ExportProviderFactory.Create() };

            var container = new CompositionContainer(CatalogFactory.Create(), providers);



            providers[0] = null;



            Assert.IsNotNull(container.Providers[0]);

        }



        [TestMethod]

        public void Constructor1_ShouldSetProvidersPropertyToEmptyCollection()

        {

            var container = new CompositionContainer();



            EnumerableAssert.IsEmpty(container.Providers);

        }



        [TestMethod]

        public void Constructor2_EmptyArrayAsProvidersArgument_ShouldSetProvidersPropertyToEmpty()

        {

            var container = new CompositionContainer(new ExportProvider[0]);



            EnumerableAssert.IsEmpty(container.Providers);

        }



        [TestMethod]

        public void Constructor3_EmptyArrayAsProvidersArgument_ShouldSetProvidersPropertyToEmpty()

        {

            var container = new CompositionContainer(CatalogFactory.Create(), new ExportProvider[0]);



            EnumerableAssert.IsEmpty(container.Providers);

        }



        [TestMethod]

        public void Constructor1_ShouldSetCatalogPropertyToNull()

        {

            var container = new CompositionContainer();



            Assert.IsNull(container.Catalog);

        }



        [TestMethod]

        public void Constructor2_ShouldSetCatalogPropertyToNull()

        {

            var container = new CompositionContainer(new ExportProvider[0]);



            Assert.IsNull(container.Catalog);

        }



        [TestMethod]

        public void Constructor3_NullAsCatalogArgument_ShouldSetCatalogPropertyToNull()

        {

            var container = new CompositionContainer((ComposablePartCatalog)null, new ExportProvider[0]);



            Assert.IsNull(container.Catalog);

        }



        [TestMethod]

        public void Constructor3_ValueAsCatalogArgument_ShouldSetCatalogProperty()

        {

            var expectations = Expectations.GetCatalogs();



            foreach (var e in expectations)

            {

                var container = new CompositionContainer(e, new ExportProvider[0]);



                Assert.AreSame(e, container.Catalog);

            }

        }



        [TestMethod]

        public void Catalog_WhenDisposed_ShouldThrowObjectDisposed()

        {

            var container = CreateCompositionContainer();

            container.Dispose();



            ExceptionAssert.ThrowsDisposed(container, () =>

            {

                var catalog = container.Catalog;

            });

        }



        [TestMethod]

        public void Providers_WhenDisposed_ShouldThrowObjectDisposed()

        {

            var container = CreateCompositionContainer();

            container.Dispose();



            ExceptionAssert.ThrowsDisposed(container, () =>

            {

                var providers = container.Providers;

            });

        }



        [TestMethod]

        [Ignore]

        [WorkItem(579990)]  // NullReferenceException

        public void ExportsChanged_Add_WhenDisposed_ShouldThrowObjectDisposed()

        {

            var container = CreateCompositionContainer();

            container.Dispose();



            ExceptionAssert.ThrowsDisposed(container, () =>

            {

                container.ExportsChanged += (o, s) => { };

            });

        }



        [TestMethod]

        [Ignore]

        [WorkItem(579990)] // NullReferenceException

        public void ExportsChanged_Remove_WhenDisposed_ShouldThrowObjectDisposed()

        {

            var container = CreateCompositionContainer();

            container.Dispose();



            ExceptionAssert.ThrowsDisposed(container, () =>

            {

                container.ExportsChanged -= (o, s) => { };

            });

        }



        [TestMethod]

        public void AddPart1_ImportOnlyPart_ShouldNotGetGarbageCollected()

        {

            var container = CreateCompositionContainer();



            var import = PartFactory.CreateImporter("Value", ImportCardinality.ZeroOrMore);



            CompositionBatch batch = new CompositionBatch();

            batch.AddPart(import);

            container.Compose(batch);



            var weakRef = new WeakReference(import);

            import = null;



            GC.Collect();

            GC.WaitForPendingFinalizers();



            Assert.IsNotNull(weakRef.Target, "Import only part should not have been collected!");



            GC.KeepAlive(container);

        }



        [TestMethod]

        public void Compose_WhenContainerDisposed_ShouldThrowObjectDisposed()

        {

            var container = CreateCompositionContainer();

            container.Dispose();



            CompositionBatch batch = new CompositionBatch();

            ExceptionAssert.ThrowsDisposed(container, () =>

            {

                container.Compose(batch);

            });

        }



        [TestMethod]

        public void GetExportOfT1_WhenContainerDisposed_ShouldThrowObjectDisposed()

        {

            var container = CreateCompositionContainer();

            container.Dispose();



            ExceptionAssert.ThrowsDisposed(container, () =>

            {

                container.GetExport<string>();

            });

        }



        [TestMethod]

        public void GetExportOfT2_WhenContainerDisposed_ShouldThrowObjectDisposed()

        {

            var container = CreateCompositionContainer();

            container.Dispose();



            ExceptionAssert.ThrowsDisposed(container, () =>

            {

                container.GetExport<string>("Contract");

            });

        }



        [TestMethod]

        public void GetExportOfTTMetadataView1_WhenContainerDisposed_ShouldThrowObjectDisposed()

        {

            var container = CreateCompositionContainer();

            container.Dispose();



            ExceptionAssert.ThrowsDisposed(container, () =>

            {

                container.GetExport<string, object>();

            });

        }



        [TestMethod]

        public void GetExportOfTTMetadataView2_WhenContainerDisposed_ShouldThrowObjectDisposed()

        {

            var container = CreateCompositionContainer();

            container.Dispose();



            ExceptionAssert.ThrowsDisposed(container, () =>

            {

                container.GetExport<string, object>("Contract");

            });

        }



        [TestMethod]

        public void GetExports1_WhenContainerDisposed_ShouldThrowObjectDisposed()

        {

            var container = CreateCompositionContainer();

            container.Dispose();



            var definition = ImportDefinitionFactory.Create();

            ExceptionAssert.ThrowsDisposed(container, () =>

            {

                container.GetExports(definition);

            });

        }



        [TestMethod]

        public void GetExports2_WhenContainerDisposed_ShouldThrowObjectDisposed()

        {

            var container = CreateCompositionContainer();

            container.Dispose();



            ExceptionAssert.ThrowsDisposed(container, () =>

            {

                container.GetExports(typeof(string), typeof(object), "Contract");

            });

        }



        [TestMethod]

        public void GetExportsOfT1_WhenContainerDisposed_ShouldThrowObjectDisposed()

        {

            var container = CreateCompositionContainer();

            container.Dispose();



            ExceptionAssert.ThrowsDisposed(container, () =>

            {

                container.GetExports<string>();

            });

        }



        [TestMethod]

        public void GetExportsOfT2_WhenContainerDisposed_ShouldThrowObjectDisposed()

        {

            var container = CreateCompositionContainer();

            container.Dispose();



            ExceptionAssert.ThrowsDisposed(container, () =>

            {

                container.GetExports<string>("Contract");

            });

        }



        [TestMethod]

        public void GetExportsOfTTMetadataView1_WhenContainerDisposed_ShouldThrowObjectDisposed()

        {

            var container = CreateCompositionContainer();

            container.Dispose();



            ExceptionAssert.ThrowsDisposed(container, () =>

            {

                container.GetExports<string, object>();

            });

        }



        [TestMethod]

        public void GetExportsOfTTMetadataView2_WhenContainerDisposed_ShouldThrowObjectDisposed()

        {

            var container = CreateCompositionContainer();

            container.Dispose();



            ExceptionAssert.ThrowsDisposed(container, () =>

            {

                container.GetExports<string, object>("Contract");

            });

        }



        [TestMethod]

        public void GetExportedValueOfT1_WhenContainerDisposed_ShouldThrowObjectDisposed()

        {

            var container = CreateCompositionContainer();

            container.Dispose();



            ExceptionAssert.ThrowsDisposed(container, () =>

            {

                container.GetExportedValue<string>();

            });

        }





        [TestMethod]

        public void GetExportedValueOfT2_WhenContainerDisposed_ShouldThrowObjectDisposed()

        {

            var container = CreateCompositionContainer();

            container.Dispose();



            ExceptionAssert.ThrowsDisposed(container, () =>

            {

                container.GetExportedValue<string>("Contract");

            });

        }



        [TestMethod]

        public void GetExportedValueOrDefaultOfT1_WhenContainerDisposed_ShouldThrowObjectDisposed()

        {

            var container = CreateCompositionContainer();

            container.Dispose();



            ExceptionAssert.ThrowsDisposed(container, () =>

            {

                container.GetExportedValueOrDefault<string>();

            });

        }



        [TestMethod]

        public void GetExportedValueOrDefaultOfT2_WhenContainerDisposed_ShouldThrowObjectDisposed()

        {

            var container = CreateCompositionContainer();

            container.Dispose();



            ExceptionAssert.ThrowsDisposed(container, () =>

            {

                container.GetExportedValueOrDefault<string>("Contract");

            });

        }



        [TestMethod]

        public void GetExportedValuesOfT1_WhenContainerDisposed_ShouldThrowObjectDisposed()

        {

            var container = CreateCompositionContainer();

            container.Dispose();



            ExceptionAssert.ThrowsDisposed(container, () =>

            {

                container.GetExportedValues<string>();

            });

        }



        [TestMethod]

        public void GetExportedValuesOfT2_WhenContainerDisposed_ShouldThrowObjectDisposed()

        {

            var container = CreateCompositionContainer();

            container.Dispose();



            ExceptionAssert.ThrowsDisposed(container, () =>

            {

                container.GetExportedValues<string>("Contract");

            });

        }



        [TestMethod]

        public void GetExports1_NullAsImportDefinitionArgument_ShouldThrowArgumentNull()

        {

            var container = CreateCompositionContainer();



            ExceptionAssert.ThrowsArgument<ArgumentNullException>("definition", () =>

            {

                container.GetExports((ImportDefinition)null);

            });

        }



        [TestMethod]

        public void GetExports2_NullAsTypeArgument_ShouldThrowArgumentNull()

        {

            var container = CreateCompositionContainer();



            ExceptionAssert.ThrowsArgument<ArgumentNullException>("type", () =>

            {

                container.GetExports((Type)null, typeof(string), "ContractName");

            });

        }



        [TestMethod]

        public void GetExportOfT1_AskingForContractThatDoesNotExist_ShouldThrowCardinalityMismatch()

        {

            var container = CreateCompositionContainer();



            ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>

            {

                container.GetExport<string>();

            });

        }



        [TestMethod]

        public void GetExportOfT2_AskingForContractThatDoesNotExist_ShouldThrowCardinalityMismatch()

        {

            var container = CreateCompositionContainer();



            ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>

            {

                container.GetExport<string>("Contract");

            });

        }



        [TestMethod]

        public void GetExportOfTTMetadataView1_AskingForContractThatDoesNotExist_ShouldThrowCardinalityMismatch()

        {

            var container = CreateCompositionContainer();



            ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>

            {

                container.GetExport<string, object>();

            });

        }



        [TestMethod]

        public void GetExportOfTTMetadataView2_AskingForContractThatDoesNotExist_ShouldThrowCardinalityMismatch()

        {

            var container = CreateCompositionContainer();



            ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>

            {

                container.GetExport<string, object>("Contract");

            });

        }



        [TestMethod]

        public void GetExports1_DefinitionAskingForExactlyOneContractThatDoesNotExist_ShouldThrowCardinalityMismatch()

        {

            var container = CreateCompositionContainer();



            var definition = ImportDefinitionFactory.Create("Contract", ImportCardinality.ExactlyOne);



            ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>

            {

                container.GetExports(definition);

            });

        }



        [TestMethod]

        public void GetExports1_DefinitionAskingForExactlyZeroOrOneContractThatDoesNotExist_ShouldReturnEmpty()

        {

            var container = CreateCompositionContainer();



            var definition = ImportDefinitionFactory.Create("Contract", ImportCardinality.ZeroOrOne);



            var exports = container.GetExports(definition);



            EnumerableAssert.IsEmpty(exports);

        }



        [TestMethod]

        public void GetExports1_DefinitionAskingForExactlyZeroOrMoreContractThatDoesNotExist_ShouldReturnEmpty()

        {

            var container = CreateCompositionContainer();



            var definition = ImportDefinitionFactory.Create("Contract", ImportCardinality.ZeroOrMore);



            var exports = container.GetExports(definition);



            EnumerableAssert.IsEmpty(exports);

        }



        [TestMethod]

        public void GetExports2_AskingForContractThatDoesNotExist_ShouldReturnNoExports()

        {

            var container = CreateCompositionContainer();



            var exports = container.GetExports(typeof(string), (Type)null, "Contract");



            EnumerableAssert.IsEmpty(exports);

        }



        [TestMethod]

        public void GetExportsOfT1_AskingForContractThatDoesNotExist_ShouldReturnEmpty()

        {

            var container = CreateCompositionContainer();



            var exports = container.GetExports<string>();



            EnumerableAssert.IsEmpty(exports);

        }



        [TestMethod]

        public void GetExportsOfT2_AskingForContractThatDoesNotExist_ShouldReturnEmpty()

        {

            var container = CreateCompositionContainer();



            var exports = container.GetExports<string>("Contract");



            EnumerableAssert.IsEmpty(exports);

        }



        [TestMethod]

        public void GetExportsOfTTMetadataView1_AskingForContractThatDoesNotExist_ShouldReturnEmpty()

        {

            var container = CreateCompositionContainer();



            var exports = container.GetExports<string, object>();



            EnumerableAssert.IsEmpty(exports);

        }



        [TestMethod]

        public void GetExportsOfTTMetadataView2_AskingForContractThatDoesNotExist_ShouldReturnEmpty()

        {

            var container = CreateCompositionContainer();



            var exports = container.GetExports<string, object>("Contract");



            EnumerableAssert.IsEmpty(exports);

        }



        [TestMethod]

        public void GetExportedValueOfT1_AskingForContractThatDoesNotExist_ShouldThrowCardinalityMismatch()

        {

            var container = CreateCompositionContainer();



            ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>

            {

                container.GetExportedValue<string>();

            });

        }



        [TestMethod]

        public void GetExportedValueOfT2_AskingForContractThatDoesNotExist_ShouldThrowCardinalityMismatch()

        {

            var container = CreateCompositionContainer();



            ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>

            {

                container.GetExportedValue<string>("Contract");

            });

        }



        [TestMethod]

        public void GetExportedValueOrDefaultOfT1_AskingForStringContractThatDoesNotExist_ShouldReturnNull()

        {

            var container = CreateCompositionContainer();



            var exportedValue = container.GetExportedValueOrDefault<string>();



            Assert.IsNull(exportedValue);

        }



        [TestMethod]

        public void GetExportedValueOrDefaultOfT2_AskingForStringContractThatDoesNotExist_ShouldReturnNull()

        {

            var container = CreateCompositionContainer();



            var exportedValue = container.GetExportedValueOrDefault<string>("Contract");



            Assert.IsNull(exportedValue);

        }



        [TestMethod]

        public void GetExportedValueOrDefaultOfT1_AskingForInt32ContractThatDoesNotExist_ShouldReturnZero()

        {

            var container = CreateCompositionContainer();



            var exportedValue = container.GetExportedValueOrDefault<int>();



            Assert.AreEqual(0, exportedValue);

        }



        [TestMethod]

        public void GetExportedValueOrDefaultOfT2_AskingForInt32ContractThatDoesNotExist_ShouldReturnZero()

        {

            var container = CreateCompositionContainer();



            var exportedValue = container.GetExportedValueOrDefault<int>("Contract");



            Assert.AreEqual(0, exportedValue);

        }



        [TestMethod]

        public void GetExportedValuesOfT1_AskingForContractThatDoesNotExist_ShouldReturnEmpty()

        {

            var container = CreateCompositionContainer();



            var exports = container.GetExportedValues<string>();



            EnumerableAssert.IsEmpty(exports);

        }



        [TestMethod]

        public void GetExportedValuesOfT2_AskingForContractThatDoesNotExist_ShouldReturnEmpty()

        {

            var container = CreateCompositionContainer();



            var exports = container.GetExports<string>("Contract");



            EnumerableAssert.IsEmpty(exports);

        }



        [TestMethod]

        public void GetExportOfT1_AskingForContractWithOneExport_ShouldReturnExport()

        {

            var container = ContainerFactory.Create(new MicroExport(ContractFromType(typeof(String)), "Value"));



            var export = container.GetExport<string>();



            Assert.AreEqual("Value", export.Value);

        }



        [TestMethod]

        public void GetExportOfT2_AskingForContractWithOneExport_ShouldReturnExport()

        {

            var container = ContainerFactory.Create(new MicroExport("Contract", "Value"));



            var export = container.GetExport<string>("Contract");



            Assert.AreEqual("Value", export.Value);

        }



        [TestMethod]

        public void GetExportOfTTMetadataView1_AskingForContractWithOneExport_ShouldReturnExport()

        {

            var container = ContainerFactory.Create(new MicroExport(ContractFromType(typeof(String)), "Value"));



            var export = container.GetExport<string, object>();



            Assert.AreEqual("Value", export.Value);

        }



        [TestMethod]

        public void GetExportOfTTMetadataView2_AskingForContractWithOneExport_ShouldReturnExport()

        {

            var container = ContainerFactory.Create(new MicroExport("Contract", "Value"));



            var export = container.GetExport<string, object>("Contract");



            Assert.AreEqual("Value", export.Value);

        }



        [TestMethod]

        public void GetExports1_AskingForExactlyOneContractWithOneExport_ShouldReturnExport()

        {

            var container = ContainerFactory.Create(new MicroExport("Contract", "Value"));



            var definition = ImportDefinitionFactory.Create("Contract", ImportCardinality.ExactlyOne);



            var exports = container.GetExports(definition);



            ExportsAssert.AreEqual(exports, "Value");

        }



        [TestMethod]

        public void GetExports1_AskingForZeroOrOneContractWithOneExport_ShouldReturnExport()

        {

            var container = ContainerFactory.Create(new MicroExport("Contract", "Value"));



            var definition = ImportDefinitionFactory.Create("Contract", ImportCardinality.ZeroOrOne);



            var exports = container.GetExports(definition);



            ExportsAssert.AreEqual(exports, "Value");

        }



        [TestMethod]

        public void GetExports1_AskingForZeroOrMoreContractWithOneExport_ShouldReturnExport()

        {

            var container = ContainerFactory.Create(new MicroExport("Contract", "Value"));



            var definition = ImportDefinitionFactory.Create("Contract", ImportCardinality.ZeroOrMore);



            var exports = container.GetExports(definition);



            ExportsAssert.AreEqual(exports, "Value");

        }



        [TestMethod]

        public void GetExports2_AskingForContractWithOneExport_ShouldReturnOneExport()

        {

            var container = ContainerFactory.Create(new MicroExport("Contract", "Value"));



            var exports = container.GetExports(typeof(string), (Type)null, "Contract");



            ExportsAssert.AreEqual(exports, "Value");

        }



        [TestMethod]

        public void GetExportsOfT1_AskingForContractWithOneExport_ShouldReturnOneExport()

        {

            var container = ContainerFactory.Create(new MicroExport(typeof(string), "Value"));



            var exports = container.GetExports<string>();



            ExportsAssert.AreEqual(exports, "Value");

        }



        [TestMethod]

        public void GetExportsOfT2_AskingForContractWithOneExport_ShouldReturnOneExport()

        {

            var container = ContainerFactory.Create(new MicroExport("Contract", "Value"));



            var exports = container.GetExports<string>("Contract");



            ExportsAssert.AreEqual(exports, "Value");

        }



        [TestMethod]

        public void GetExportsOfTTMetadataView1_AskingForContractWithOneExport_ShouldReturnOneExport()

        {

            var container = ContainerFactory.Create(new MicroExport(typeof(string), "Value"));



            var exports = container.GetExports<string, object>();



            ExportsAssert.AreEqual(exports, "Value");

        }



        [TestMethod]

        public void GetExportsOfTTMetadataView2_AskingForContractWithOneExport_ShouldReturnOneExport()

        {

            var container = ContainerFactory.Create(new MicroExport("Contract", "Value"));



            var exports = container.GetExports<string, object>("Contract");



            ExportsAssert.AreEqual(exports, "Value");

        }



        [TestMethod]

        public void GetExportedValueOfT1_AskingForContractWithOneExport_ShouldReturnExport()

        {

            var container = ContainerFactory.Create(new MicroExport(typeof(string), "Value"));



            var exportedValue = container.GetExportedValue<string>();



            Assert.AreEqual("Value", exportedValue);

        }



        [TestMethod]

        public void GetExportedValueOfT2_AskingForContractWithOneExport_ShouldReturnExport()

        {

            var container = ContainerFactory.Create(new MicroExport("Contract", "Value"));



            var exportedValue = container.GetExportedValue<string>("Contract");



            Assert.AreEqual("Value", exportedValue);

        }



        [TestMethod]

        public void GetExportedValueOrDefaultOfT1_AskingForContractWithOneExport_ShouldReturnExport()

        {

            var container = ContainerFactory.Create(new MicroExport(typeof(string), "Value"));



            var exportedValue = container.GetExportedValueOrDefault<string>();



            Assert.AreEqual("Value", exportedValue);

        }



        [TestMethod]

        public void GetExportedValueOrDefaultOfT2_AskingForContractWithOneExport_ShouldReturnExport()

        {

            var container = ContainerFactory.Create(new MicroExport("Contract", "Value"));



            var exportedValue = container.GetExportedValueOrDefault<string>("Contract");



            Assert.AreEqual("Value", exportedValue);

        }



        [TestMethod]

        public void GetExportedValuesOfT1_AskingForContractWithOneExport_ShouldReturnOneExport()

        {

            var container = ContainerFactory.Create(new MicroExport(typeof(string), "Value"));



            var exportedValues = container.GetExportedValues<string>();

            

            EnumerableAssert.AreEqual(exportedValues, "Value");            

        }



        [TestMethod]

        public void GetExportedValuesOfT2_AskingForContractWithOneExport_ShouldReturnOneExport()

        {

            var container = ContainerFactory.Create(new MicroExport("Contract", "Value"));



            var exportedValues = container.GetExportedValues<string>("Contract");



            EnumerableAssert.AreEqual(exportedValues, "Value");

        }



        [TestMethod]

        public void GetExportOfT1_AskingForContractWithMultipleExports_ShouldThrowCardinalityMismatch()

        {

            var container = ContainerFactory.Create(new MicroExport(ContractFromType(typeof(String)), "Value1", "Value2"));



            ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>

             {

                 container.GetExport<string>();

             });

        }



        [TestMethod]

        public void GetExportOfT2_AskingForContractWithMultipleExports_ShouldThrowCardinalityMismatch()

        {

            var container = ContainerFactory.Create(new MicroExport("Contract", "Value1", "Value2"));



            ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>

             {

                 container.GetExport<string>("Contract");

             });

        }



        [TestMethod]

        public void GetExportOfTTMetadataView1_AskingForContractWithMultipleExports_ShouldThrowCardinalityMismatch()

        {

            var container = ContainerFactory.Create(new MicroExport(ContractFromType(typeof(String)), "Value1", "Value2"));



            ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>

            {

                container.GetExport<string, object>();

            });

        }



        [TestMethod]

        public void GetExportOfTTMetadataView2_AskingForContractWithMultipleExports_ShouldThrowCardinalityMismatch()

        {

            var container = ContainerFactory.Create(new MicroExport("Contract", "Value1", "Value2"));



            ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>

            {

                container.GetExport<string, object>("Contract");

            });

        }



        [TestMethod]

        public void GetExports1_AskingForExactlyOneContractWithMultipleExports_ShouldThrowCardinalityMismatch()

        {

            var container = ContainerFactory.Create(new MicroExport("Contract", "Value1", "Value2"));



            var definition = ImportDefinitionFactory.Create("Contract", ImportCardinality.ExactlyOne);



            ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>

            {

                container.GetExports(definition);

            });

        }



        [TestMethod]

        public void GetExports1_AskingForZeroOrOneContractWithMultipleExports_ShouldReturnZero()

        {

            var container = ContainerFactory.Create(new MicroExport("Contract", "Value1", "Value2"));



            var definition = ImportDefinitionFactory.Create("Contract", ImportCardinality.ZeroOrOne);



            Assert.AreEqual(0, container.GetExports(definition).Count());

        }



        [TestMethod]

        public void GetExports1_AskingForZeroOrMoreContractWithMultipleExports_ShouldReturnMultipleExports()

        {

            var container = ContainerFactory.Create(new MicroExport("Contract", "Value1", "Value2"));



            var definition = ImportDefinitionFactory.Create("Contract", ImportCardinality.ZeroOrMore);



            var exports = container.GetExports(definition);



            ExportsAssert.AreEqual(exports, "Value1", "Value2");

        }



        [TestMethod]

        public void GetExports2_AskingForContractWithMultipleExports_ShouldReturnMultipleExports()

        {

            var container = ContainerFactory.Create(new MicroExport("Contract", "Value1", "Value2"));



            var exports = container.GetExports(typeof(string), (Type)null, "Contract");



            ExportsAssert.AreEqual(exports, "Value1", "Value2");

        }



        [TestMethod]

        public void GetExportsOfT1_AskingForContractWithMultipleExports_ShouldReturnMultipleExports()

        {

            var container = ContainerFactory.Create(new MicroExport(typeof(String), "Value1", "Value2"));



            var exports = container.GetExports<string>();



            ExportsAssert.AreEqual(exports, "Value1", "Value2");

        }



        [TestMethod]

        public void GetExportsOfT2_AskingForContractWithMultipleExports_ShouldReturnMultipleExports()

        {

            var container = ContainerFactory.Create(new MicroExport("Contract", "Value1", "Value2"));



            var exports = container.GetExports<string>("Contract");



            ExportsAssert.AreEqual(exports, "Value1", "Value2");

        }



        [TestMethod]

        public void GetExportsOfTTMetadataView1_AskingForContractWithMultipleExports_ShouldReturnMultipleExports()

        {

            var container = ContainerFactory.Create(new MicroExport(typeof(string), "Value1", "Value2"));



            var exports = container.GetExports<string, object>();



            ExportsAssert.AreEqual(exports, "Value1", "Value2");

        }



        [TestMethod]

        public void GetExportsOfTTMetadataView2_AskingForContractWithMultipleExports_ShouldReturnMultipleExports()

        {

            var container = ContainerFactory.Create(new MicroExport("Contract", "Value1", "Value2"));



            var exports = container.GetExports<string, object>("Contract");



            ExportsAssert.AreEqual(exports, "Value1", "Value2");

        }



        [TestMethod]

        public void GetExportedValueOfT1_AskingForContractWithMultipleExports_ShouldThrowCardinalityMismatch()

        {

            var container = ContainerFactory.Create(new MicroExport(typeof(string), "Value1", "Value2"));



            ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>

            {

                 container.GetExportedValue<string>();

            });

        }



        [TestMethod]

        public void GetExportedValueOfT2_AskingForContractWithMultipleExports_ShouldThrowCardinalityMismatch()

        {

            var container = ContainerFactory.Create(new MicroExport("Contract", "Value1", "Value2"));



            ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>

            {

                 container.GetExportedValue<string>("Contract");

            });

        }



        [TestMethod]

        public void GetExportedValueOrDefaultOfT1_AskingForContractWithMultipleExports_ShouldReturnZero()

        {

            var container = ContainerFactory.Create(new MicroExport(typeof(string), "Value1", "Value2"));



            Assert.IsNull(container.GetExportedValueOrDefault<string>());

        }



        [TestMethod]

        public void GetExportedValueOrDefaultOfT2_AskingForContractWithMultipleExports_ShouldReturnZero()

        {

            var container = ContainerFactory.Create(new MicroExport("Contract", "Value1", "Value2"));



            Assert.IsNull(container.GetExportedValueOrDefault<string>("Contract"));

        }



        [TestMethod]

        public void GetExportedValuesOfT1_AskingForContractWithMultipleExports_ShouldReturnMultipleExports()

        {

            var container = ContainerFactory.Create(new MicroExport(typeof(string), "Value1", "Value2"));



            var exportedValues = container.GetExportedValues<string>();



            EnumerableAssert.AreEqual(exportedValues, "Value1", "Value2");

        }



        [TestMethod]

        public void GetExportedValuesOfT2_AskingForContractWithMultipleExports_ShouldReturnMultipleExports()

        {

            var container = ContainerFactory.Create(new MicroExport("Contract", typeof(string), "Value1", "Value2"));



            var exportedValues = container.GetExportedValues<string>("Contract");



            EnumerableAssert.AreEqual(exportedValues, "Value1", "Value2");

        }



        [TestMethod]

        public void GetExports1_AskingForExactlyOneAndAll_ShouldThrowCardinalityMismatch()

        {

            var container = ContainerFactory.Create(new MicroExport("Contract1", "Value1", "Value2", "Value3"),

                                                    new MicroExport("Contract2", "Value4", "Value5", "Value6"));



            var definition = ImportDefinitionFactory.Create(import => true, ImportCardinality.ExactlyOne);



            ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>

            {

                container.GetExports(definition);

            });

        }



        [TestMethod]

        public void GetExports1_AskingForZeroOrOneAndAll_ShouldReturnZero()

        {

            var container = ContainerFactory.Create(new MicroExport("Contract1", "Value1", "Value2", "Value3"),

                                                    new MicroExport("Contract2", "Value4", "Value5", "Value6"));



            var definition = ImportDefinitionFactory.Create(import => true, ImportCardinality.ZeroOrOne);



            Assert.AreEqual(0, container.GetExports(definition).Count());

        }



        [TestMethod]

        public void GetExports1_AskingForZeroOrMoreAndAll_ShouldReturnAll()

        {

            var container = ContainerFactory.Create(new MicroExport("Contract1", "Value1", "Value2", "Value3"),

                                                    new MicroExport("Contract2", "Value4", "Value5", "Value6"));



            var definition = ImportDefinitionFactory.Create(import => true, ImportCardinality.ZeroOrMore);



            var exports = container.GetExports(definition);



            ExportsAssert.AreEqual(exports, "Value1", "Value2", "Value3",

                                            "Value4", "Value5", "Value6");

        }



        [TestMethod]

        public void GetExportOfT1_StringAsTTypeArgumentAskingForContractWithOneObjectExport_ShouldThrowContractMismatch()

        {

            var container = ContainerFactory.Create(new MicroExport(typeof(string), new object()));



            var export = container.GetExport<string>();



            ExceptionAssert.Throws<CompositionContractMismatchException>(() =>

            {

                var value = export.Value;

            });

        }



        [TestMethod]

        public void GetExportOfT2_StringAsTTypeArgumentAskingForContractWithOneObjectExport_ShouldThrowContractMismatch()

        {

            var container = ContainerFactory.Create(new MicroExport("Contract", typeof(string), new object()));



            var export = container.GetExport<string>("Contract");



            ExceptionAssert.Throws<CompositionContractMismatchException>(() =>

            {

                var value = export.Value;

            });

        }



        [TestMethod]

        public void GetExportOfTTMetadataView1_StringAsTTypeArgumentAskingForContractWithOneObjectExport_ShouldThrowContractMismatch()

        {

            var container = ContainerFactory.Create(new MicroExport(typeof(string), new object()));



            var export = container.GetExport<string, object>();



            ExceptionAssert.Throws<CompositionContractMismatchException>(() =>

            {

                var value = export.Value;

            });

        }



        [TestMethod]

        public void GetExportOfTTMetadataView2_StringAsTTypeArgumentAskingForContractWithOneObjectExport_ShouldThrowContractMismatch()

        {

            var container = ContainerFactory.Create(new MicroExport("Contract", typeof(string), new object()));



            var export = container.GetExport<string, object>("Contract");



            ExceptionAssert.Throws<CompositionContractMismatchException>(() =>

            {

                var value = export.Value;

            });

        }



        [TestMethod]

        public void GetExports2_StringAsTTypeArgumentAskingForContractWithOneObjectExport_ShouldThrowContractMismatch()

        {

            var container = ContainerFactory.Create(new MicroExport("Contract", typeof(string), new object()));



            var exports = container.GetExports(typeof(string), (Type)null, "Contract");



            Assert.AreEqual(1, exports.Count());



            var export = exports.ElementAt(0);



            ExceptionAssert.Throws<CompositionContractMismatchException>(() =>

            {

                var value = export.Value;

            });

        }



        [TestMethod]

        public void GetExportsOfT1_StringAsTTypeArgumentAskingForContractWithOneObjectExport_ShouldThrowContractMismatch()

        {

            var container = ContainerFactory.Create(new MicroExport(typeof(string), new object()));



            var exports = container.GetExports<string>();



            Assert.AreEqual(1, exports.Count());



            var export = exports.ElementAt(0);



            ExceptionAssert.Throws<CompositionContractMismatchException>(() =>

            {

                var value = export.Value;

            });

        }



        [TestMethod]

        public void GetExportsOfT2_StringAsTTypeArgumentAskingForContractWithOneObjectExport_ShouldThrowContractMismatch()

        {

            var container = ContainerFactory.Create(new MicroExport("Contract", typeof(string), new object()));



            var exports = container.GetExports<string>("Contract");



            Assert.AreEqual(1, exports.Count());



            var export = exports.ElementAt(0);



            ExceptionAssert.Throws<CompositionContractMismatchException>(() =>

            {

                var value = export.Value;

            });

        }



        [TestMethod]

        public void GetExportsOfTTMetadataView1_StringAsTTypeArgumentAskingForContractWithOneObjectExport_ShouldThrowContractMismatch()

        {

            var container = ContainerFactory.Create(new MicroExport(typeof(string), new object()));



            var exports = container.GetExports<string, object>();



            Assert.AreEqual(1, exports.Count());



            var export = exports.ElementAt(0);



            ExceptionAssert.Throws<CompositionContractMismatchException>(() =>

            {

                var value = export.Value;

            });

        }



        [TestMethod]

        public void GetExportsOfTTMetadataView2_StringAsTTypeArgumentAskingForContractWithOneObjectExport_ShouldThrowContractMismatch()

        {

            var container = ContainerFactory.Create(new MicroExport("Contract", typeof(string), new object()));



            var exports = container.GetExports<string, object>("Contract");



            Assert.AreEqual(1, exports.Count());



            var export = exports.ElementAt(0);



            ExceptionAssert.Throws<CompositionContractMismatchException>(() =>

            {

                var value = export.Value;

            });

        }



        [TestMethod]

        public void GetExportedValueOfT1_StringAsTTypeArgumentAskingForContractWithObjectExport_ShouldThrowContractMismatch()

        {

            var container = ContainerFactory.Create(new MicroExport(typeof(string), new object()));



            ExceptionAssert.Throws<CompositionContractMismatchException>(() =>

            {

                container.GetExportedValue<string>();

            });

        }



        [TestMethod]

        public void GetExportedValueOfT2_StringAsTTypeArgumentAskingForContractWithObjectExport_ShouldThrowContractMismatch()

        {

            var container = ContainerFactory.Create(new MicroExport("Contract", typeof(string), new object()));



            ExceptionAssert.Throws<CompositionContractMismatchException>(() =>

            {

                container.GetExportedValue<string>("Contract");

            });

        }



        [TestMethod]

        public void GetExportedValueOrDefaultOfT1_StringAsTTypeArgumentAskingForContractWithObjectExport_ShouldThrowContractMismatch()

        {

            var container = ContainerFactory.Create(new MicroExport(typeof(string), new object()));



            ExceptionAssert.Throws<CompositionContractMismatchException>(() =>

            {

                container.GetExportedValueOrDefault<string>();

            });

        }



        [TestMethod]

        public void GetExportedValueOrDefaultOfT2_StringAsTTypeArgumentAskingForContractWithObjectExport_ShouldThrowContractMismatch()

        {

            var container = ContainerFactory.Create(new MicroExport("Contract", typeof(string), new object()));



            ExceptionAssert.Throws<CompositionContractMismatchException>(() =>

            {

                container.GetExportedValueOrDefault<string>("Contract");

            });

        }



        [TestMethod]

        public void GetExportedValuesOfT1_StringAsTTypeArgumentAskingForContractWithOneObjectExport_ShouldThrowContractMismatch()

        {

            var container = ContainerFactory.Create(new MicroExport(typeof(string), new object()));



            ExceptionAssert.Throws<CompositionContractMismatchException>(() =>

            {

                container.GetExportedValues<string>();

            });

        }



        [TestMethod]

        public void GetExportedValuesOfT2_StringAsTTypeArgumentAskingForContractWithOneObjectExport_ShouldThrowContractMismatch()

        {

            var container = ContainerFactory.Create(new MicroExport("Contract", typeof(string), new object()));



            ExceptionAssert.Throws<CompositionContractMismatchException>(() =>

            {

                container.GetExportedValues<string>("Contract");

            });

        }





        [TestMethod]

        public void GetExportOfT1_AskingForContractFromChildWithExportInParentContainer_ShouldReturnExport()

        {

            var parent = ContainerFactory.Create(new MicroExport(typeof(string), "Parent"));

            var child = ContainerFactory.Create(parent);



            var export = child.GetExport<string>();



            Assert.AreEqual("Parent", export.Value);

        }



        [TestMethod]

        public void GetExportOfT2_AskingForContractFromChildWithExportInParentContainer_ShouldReturnExport()

        {

            var parent = ContainerFactory.Create(new MicroExport("Contract", "Parent"));

            var child = ContainerFactory.Create(parent);



            var export = child.GetExport<string>("Contract");



            Assert.AreEqual("Parent", export.Value);

        }



        [TestMethod]

        public void GetExportOfTTMetadataView1_AskingForContractFromChildWithExportInParentContainer_ShouldReturnExport()

        {

            var parent = ContainerFactory.Create(new MicroExport(typeof(string), "Parent"));

            var child = ContainerFactory.Create(parent);



            var export = child.GetExport<string, object>();



            Assert.AreEqual("Parent", export.Value);

        }



        [TestMethod]

        public void GetExportOfTTMetadataView2_AskingForContractFromChildWithExportInParentContainer_ShouldReturnExport()

        {

            var parent = ContainerFactory.Create(new MicroExport("Contract", "Parent"));

            var child = ContainerFactory.Create(parent);



            var export = child.GetExport<string, object>("Contract");



            Assert.AreEqual("Parent", export.Value);

        }



        [TestMethod]

        public void GetExports1_AskingForExactlyOneContractFromChildWithExportInParentContainer_ShouldReturnExport()

        {

            var parent = ContainerFactory.Create(new MicroExport("Contract", "Parent"));

            var child = ContainerFactory.Create(parent);



            var definition = ImportDefinitionFactory.Create("Contract", ImportCardinality.ExactlyOne);



            var exports = child.GetExports(definition);



            ExportsAssert.AreEqual(exports, "Parent");

        }



        [TestMethod]

        public void GetExports1_AskingForZeroOrOneContractFromChildWithExportInParentContainer_ShouldReturnExport()

        {

            var parent = ContainerFactory.Create(new MicroExport("Contract", "Parent"));

            var child = ContainerFactory.Create(parent);



            var definition = ImportDefinitionFactory.Create("Contract", ImportCardinality.ZeroOrOne);



            var exports = child.GetExports(definition);



            ExportsAssert.AreEqual(exports, "Parent");

        }



        [TestMethod]

        public void GetExports1_AskingForZeroOrMoreContractFromChildWithExportInParentContainer_ShouldReturnExport()

        {

            var parent = ContainerFactory.Create(new MicroExport("Contract", "Parent"));

            var child = ContainerFactory.Create(parent);



            var definition = ImportDefinitionFactory.Create("Contract", ImportCardinality.ZeroOrMore);



            var exports = child.GetExports(definition);



            ExportsAssert.AreEqual(exports, "Parent");

        }



        [TestMethod]

        public void GetExports2_AskingForContractFromChildWithExportInParentContainer_ShouldReturnExport()

        {

            var parent = ContainerFactory.Create(new MicroExport("Contract", "Parent"));

            var child = ContainerFactory.Create(parent);



            var exports = child.GetExports(typeof(string), (Type)null, "Contract");



            ExportsAssert.AreEqual(exports, "Parent");

        }



        [TestMethod]

        public void GetExportsOfT1_AskingForContractFromChildWithExportInParentContainer_ShouldReturnExport()

        {

            var parent = ContainerFactory.Create(new MicroExport(typeof(string), "Parent"));

            var child = ContainerFactory.Create(parent);



            var exports = child.GetExports<string>();



            ExportsAsse…

Large files files are truncated, but you can click here to view the full file