class/System.ComponentModel.Composition/Tests/ComponentModelUnitTest/System/ComponentModel/Composition/Hosting/CatalogExportProviderTests.cs

   1 // -----------------------------------------------------------------------
   2 // Copyright (c) Microsoft Corporation.  All rights reserved.
   3 // -----------------------------------------------------------------------
   4 using System;
   5 using System.Collections.Generic;
   6 using System.Diagnostics;
   7 using System.ComponentModel.Composition.Diagnostics;
   8 using System.ComponentModel.Composition.Factories;
   9 using System.ComponentModel.Composition.Hosting;
  10 using System.ComponentModel.Composition.Primitives;
  11 using System.Linq;
  12 using System.UnitTesting;
  13 using Microsoft.VisualStudio.TestTools.UnitTesting;
  14
  15 namespace System.ComponentModel.Composition
  16 {
  17     [TestClass]
  18     public class ComposablePartCatalogExportProviderTests
  19     {
  20         [TestMethod]
  21         public void Constructor_NullAsCatalogArgument_ShouldThrowArgumentNull()
  22         {
  23             ExceptionAssert.ThrowsArgument<ArgumentNullException>("catalog", () =>
  24             {
  25                 new CatalogExportProvider((ComposablePartCatalog)null);
  26             });
  27         }
  28
  29         [TestMethod]
  30         public void Constructor_ValueAsCatalogArgument_ShouldSetCatalogPropertyToEmpty()
  31         {
  32             var expectations = Expectations.GetCatalogs();
  33
  34             foreach (var e in expectations)
  35             {
  36                 var provider = new CatalogExportProvider(e);
  37
  38                 Assert.AreSame(e, provider.Catalog);
  39             }
  40         }
  41
  42         [TestMethod]
  43         public void Catalog_WhenDisposed_ShouldThrowObjectDisposed()
  44         {
  45             var provider = CreateCatalogExportProvider();
  46             provider.Dispose();
  47
  48             ExceptionAssert.ThrowsDisposed(provider, () =>
  49             {
  50                 var catalog = provider.Catalog;
  51             });
  52         }
  53
  54         [TestMethod]
  55         public void SourceProvider_NullAsValueArgument_ShouldThrowArgumentNull()
  56         {
  57             var provider = CreateCatalogExportProvider();
  58
  59             ExceptionAssert.ThrowsArgument<ArgumentNullException>("value", () =>
  60             {
  61                 provider.SourceProvider = null;
  62             });
  63         }
  64
  65         [TestMethod]
  66         public void GetExports_WhenRejectedDefinitionRequiredImportIsAdded_ShouldBeResurrected()
  67         {
  68             var part = PartFactory.CreateImporterExporter("Export", "Import");
  69
  70             var provider = CreateCatalogExportProvider(part);
  71             var sourceProvider = ExportProviderFactory.CreateRecomposable();
  72             provider.SourceProvider = sourceProvider;
  73
  74             var exports = provider.GetExports<object>("Export");
  75
  76             EnumerableAssert.IsEmpty(exports, "definition should have been rejected.");
  77
  78             // Resurrect the definition
  79             sourceProvider.AddExport("Import", new object());
  80
  81             exports = provider.GetExports<object>("Export");
  82
  83             Assert.AreEqual(1, exports.Count(), "definition should have been resurrected.");
  84         }
  85
  86         [TestMethod]
  87         public void GetExports_WhenMultipleRejectedDefinitionsRequiredImportsAreAdded_ShouldBeResurrected()
  88         {
  89             var part1 = PartFactory.CreateImporterExporter("Export", "Import");
  90             var part2 = PartFactory.CreateImporterExporter("Export", "Import");
  91
  92             var provider = CreateCatalogExportProvider(part1, part2);
  93             var sourceProvider = ExportProviderFactory.CreateRecomposable();
  94             provider.SourceProvider = sourceProvider;
  95
  96             var exports = provider.GetExports<object>("Export");
  97
  98             EnumerableAssert.IsEmpty(exports, "definition1 and definition2 should have been rejected.");
  99
 100             // Resurrect both definitions
 101             sourceProvider.AddExport("Import", new object());
 102
 103             exports = provider.GetExports<object>("Export");
 104
 105             Assert.AreEqual(2, exports.Count(), "definition1 and definition2 should have been resurrected.");
 106         }
 107
 108         [TestMethod]
 109         [WorkItem(743740)]
 110         public void GetExports_AfterResurrectedDefinitionHasBeenRemovedAndReaddedToCatalog_ShouldNotBeTreatedAsRejected()
 111         {
 112             var definition1 = PartDefinitionFactory.Create(PartFactory.CreateImporterExporter("Export", "Import"));
 113             var definition2 = PartDefinitionFactory.Create(PartFactory.CreateImporterExporter("Export", "Import"));
 114             var catalog = CatalogFactory.CreateMutable(definition1, definition2);
 115
 116             var provider = CreateCatalogExportProvider(catalog);
 117             var sourceProvider = ExportProviderFactory.CreateRecomposable();
 118             provider.SourceProvider = sourceProvider;
 119
 120             var exports = provider.GetExports<object>("Export");
 121
 122             EnumerableAssert.IsEmpty(exports, "definition1 and definition2 should have been rejected.");
 123
 124             // Resurrect both definitions
 125             sourceProvider.AddExport("Import", new object());
 126
 127             exports = provider.GetExports<object>("Export");
 128
 129             Assert.AreEqual(2, exports.Count(), "definition1 and definition2 should have been resurrected.");
 130
 131             catalog.RemoveDefinition(definition1);
 132
 133             exports = provider.GetExports<object>("Export");
 134             Assert.AreEqual(1, exports.Count(), "definition1 should have been removed.");
 135
 136             catalog.AddDefinition(definition1);
 137
 138             exports = provider.GetExports<object>("Export");
 139
 140             Assert.AreEqual(2, exports.Count(), "definition1 and definition2 should be both present.");
 141         }
 142
 143 #if !SILVERLIGHT
 144
 145         [TestMethod]
 146         public void GetExports_WhenDefinitionIsRejected_ShouldTraceWarning()
 147         {
 148             using (TraceContext context = new TraceContext(SourceLevels.Warning))
 149             {
 150                 var part = PartFactory.CreateImporterExporter("Export", "Import");
 151                 var provider = CreateCatalogExportProvider(part);
 152                 provider.SourceProvider = ExportProviderFactory.CreateRecomposable();
 153
 154                 ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>
 155                 {
 156                     provider.GetExport<object>("Export");
 157
 158                 });
 159
 160                 Assert.IsNotNull(context.LastTraceEvent);
 161                 Assert.AreEqual(context.LastTraceEvent.EventType, TraceEventType.Warning);
 162                 Assert.AreEqual(context.LastTraceEvent.Id, TraceId.Rejection_DefinitionRejected);
 163             }
 164         }
 165
 166         [TestMethod]
 167         public void GetExports_WhenDefinitionIsResurrected_ShouldTraceInformation()
 168         {
 169             using (TraceContext context = new TraceContext(SourceLevels.Information))
 170             {
 171                 var part = PartFactory.CreateImporterExporter("Export", "Import");
 172                 var sourceProvider = ExportProviderFactory.CreateRecomposable();
 173                 var provider = CreateCatalogExportProvider(part);
 174                 provider.SourceProvider = sourceProvider;
 175
 176                 ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>
 177                 {
 178                     provider.GetExport<object>("Export");
 179                 });
 180
 181                 // Add the required export to the source provider 'resurrect' the part
 182                 sourceProvider.AddExport("Import", "Value");
 183
 184                 provider.GetExport<object>("Export");
 185
 186                 Assert.IsNotNull(context.LastTraceEvent);
 187                 Assert.AreEqual(context.LastTraceEvent.EventType, TraceEventType.Information);
 188                 Assert.AreEqual(context.LastTraceEvent.Id, TraceId.Rejection_DefinitionResurrected);
 189             }
 190         }
 191
 192         [TestMethod]
 193         public void GetExports_WhenDefinitionsAreResurrected_ShouldTraceInformation()
 194         {
 195             using (TraceContext context = new TraceContext(SourceLevels.Information))
 196             {
 197                 var part1 = PartFactory.CreateImporterExporter("Export", "Import");
 198                 var part2 = PartFactory.CreateImporterExporter("Export", "Import");
 199
 200                 var sourceProvider = ExportProviderFactory.CreateRecomposable();
 201                 var provider = CreateCatalogExportProvider(part1, part2);
 202                 provider.SourceProvider = sourceProvider;
 203
 204                 EnumerableAssert.IsEmpty(provider.GetExports<object>("Export"));
 205
 206                 // Add the required export to the source provider 'resurrect' the part
 207                 sourceProvider.AddExport("Import", "Value");
 208
 209                 provider.GetExports<object>("Export");
 210
 211                 Assert.AreEqual(4, context.TraceEvents.Count);  // 2 for rejection, 2 for resurrection
 212                 Assert.AreEqual(context.TraceEvents[2].EventType, TraceEventType.Information);
 213                 Assert.AreEqual(context.TraceEvents[3].EventType, TraceEventType.Information);
 214                 Assert.AreEqual(context.TraceEvents[2].Id, TraceId.Rejection_DefinitionResurrected);
 215                 Assert.AreEqual(context.TraceEvents[3].Id, TraceId.Rejection_DefinitionResurrected);
 216             }
 217         }
 218 #endif
 219
 220         [TestMethod]
 221         [TestProperty("Type", "Integration")]
 222         public void BasicTest()
 223         {
 224             var catalog = CatalogFactory.CreateDefaultAttributed();
 225             var catalogExportProvider = new CatalogExportProvider(catalog);
 226             catalogExportProvider.SourceProvider = catalogExportProvider;
 227             var testName = AttributedModelServices.GetContractName(typeof(CatalogComponentTest));
 228             var testNameNonComponent = AttributedModelServices.GetContractName(typeof(CatalogComponentTestNonComponentPart));
 229             var testInterfaceName = AttributedModelServices.GetContractName(typeof(ICatalogComponentTest));
 230
 231             Assert.AreEqual(1, catalogExportProvider.GetExports(ImportFromContract(testName)).Count());
 232             Assert.AreEqual(0, catalogExportProvider.GetExports(ImportFromContract(testNameNonComponent)).Count());
 233
 234             var exports = catalogExportProvider.GetExports(ImportFromContract(testInterfaceName));
 235             Assert.AreEqual(2, exports.Count(), "There should be 2 of them");
 236
 237             foreach (var i in exports)
 238                 Assert.IsNotNull(i.Value, "Should get a value");
 239
 240         }
 241
 242         [TestMethod]
 243         [TestProperty("Type", "Integration")]
 244         public void BasicTestWithRequiredMetadata_NoTypeConstraint()
 245         {
 246             var catalog = CatalogFactory.CreateDefaultAttributed();
 247             var catalogExportProvider = new CatalogExportProvider(catalog);
 248             catalogExportProvider.SourceProvider = catalogExportProvider;
 249
 250             Assert.AreEqual(0, catalogExportProvider.GetExports(ImportFromContractAndMetadata("MyExporterWithNoFoo", new string[] { "Foo" }, new Type[] {typeof(object)})).Count());
 251
 252             Assert.AreEqual(1, catalogExportProvider.GetExports(ImportFromContractAndMetadata("MyExporterWithFoo", new string[] { "Foo" }, new Type[] { typeof(object) })).Count());
 253             Assert.AreEqual(0, catalogExportProvider.GetExports(ImportFromContractAndMetadata("MyExporterWithFoo", new string[] { "Foo", "Bar" }, new Type[] { typeof(object), typeof(object) })).Count());
 254
 255             Assert.AreEqual(0, catalogExportProvider.GetExports(ImportFromContractAndMetadata("MyExporterWithNoFoo", new string[] { "Foo" }, new Type[] { typeof(object) })).Count());
 256             Assert.AreEqual(1, catalogExportProvider.GetExports(ImportFromContractAndMetadata("MyExporterWithFoo", new string[] { "Foo" }, new Type[] { typeof(object) })).Count());
 257         }
 258
 259         [TestMethod]
 260         [TestProperty("Type", "Integration")]
 261         public void BasicTestWithRequiredMetadata_TypeConstraint()
 262         {
 263             var catalog = CatalogFactory.CreateDefaultAttributed();
 264             var catalogExportProvider = new CatalogExportProvider(catalog);
 265             catalogExportProvider.SourceProvider = catalogExportProvider;
 266
 267             Assert.AreEqual(0, catalogExportProvider.GetExports(ImportFromContractAndMetadata("MyExporterWithNoFoo", new string[] { "Foo" }, new Type[] { typeof(string) })).Count());
 268
 269             Assert.AreEqual(1, catalogExportProvider.GetExports(ImportFromContractAndMetadata("MyExporterWithFoo", new string[] { "Foo" }, new Type[] { typeof(string) })).Count());
 270             Assert.AreEqual(0, catalogExportProvider.GetExports(ImportFromContractAndMetadata("MyExporterWithFoo", new string[] { "Foo", "Bar" }, new Type[] { typeof(string), typeof(string) })).Count());
 271
 272             Assert.AreEqual(0, catalogExportProvider.GetExports(ImportFromContractAndMetadata("MyExporterWithNoFoo", new string[] { "Foo" }, new Type[] { typeof(string) })).Count());
 273             Assert.AreEqual(1, catalogExportProvider.GetExports(ImportFromContractAndMetadata("MyExporterWithFoo", new string[] { "Foo" }, new Type[] { typeof(string) })).Count());
 274         }
 275
 276
 277         [TestMethod]
 278         [TestProperty("Type", "Integration")]
 279         public void BasicTestWithRequiredMetadata_WrongTypeConstraint()
 280         {
 281             var catalog = CatalogFactory.CreateDefaultAttributed();
 282             var catalogExportProvider = new CatalogExportProvider(catalog);
 283             catalogExportProvider.SourceProvider = catalogExportProvider;
 284
 285             Assert.AreEqual(0, catalogExportProvider.GetExports(ImportFromContractAndMetadata("MyExporterWithNoFoo", new string[] { "Foo" }, new Type[] { typeof(int) })).Count());
 286
 287             Assert.AreEqual(0, catalogExportProvider.GetExports(ImportFromContractAndMetadata("MyExporterWithFoo", new string[] { "Foo" }, new Type[] { typeof(int) })).Count());
 288             Assert.AreEqual(0, catalogExportProvider.GetExports(ImportFromContractAndMetadata("MyExporterWithFoo", new string[] { "Foo", "Bar" }, new Type[] { typeof(int), typeof(int) })).Count());
 289
 290             Assert.AreEqual(0, catalogExportProvider.GetExports(ImportFromContractAndMetadata("MyExporterWithNoFoo", new string[] { "Foo" }, new Type[] { typeof(int) })).Count());
 291             Assert.AreEqual(0, catalogExportProvider.GetExports(ImportFromContractAndMetadata("MyExporterWithFoo", new string[] { "Foo" }, new Type[] { typeof(int) })).Count());
 292         }
 293
 294
 295         [TestMethod]
 296         [TestProperty("Type", "Integration")]
 297         public void ComponentCatalogResolverGetStaticExport()
 298         {
 299             var catalog = CatalogFactory.CreateDefaultAttributed();
 300             var catalogExportProvider = new CatalogExportProvider(catalog);
 301             catalogExportProvider.SourceProvider = catalogExportProvider;
 302
 303             var exports = catalogExportProvider.GetExports(ImportFromContract("StaticString"));
 304             Assert.AreEqual(1, exports.Count());
 305             Assert.AreEqual("StaticString", exports.First().Value);
 306         }
 307
 308         [TestMethod]
 309         [TestProperty("Type", "Integration")]
 310         public void ComponentCatalogResolverComponentCatalogExportReference()
 311         {
 312             var catalog = CatalogFactory.CreateDefaultAttributed();
 313             var catalogExportProvider = new CatalogExportProvider(catalog);
 314             catalogExportProvider.SourceProvider = catalogExportProvider;
 315
 316             var exports = catalogExportProvider.GetExports(ImportFromContract(AttributedModelServices.GetContractName(typeof(MyExporterWithValidMetadata))));
 317
 318             Assert.AreEqual(1, exports.Count());
 319
 320             var export = exports.First();
 321             Assert.AreEqual("world", export.Metadata["hello"]);
 322
 323             Assert.IsInstanceOfType(export.Value, typeof(MyExporterWithValidMetadata));
 324         }
 325
 326         [TestMethod]
 327         [TestProperty("Type", "Integration")]
 328         public void ValueTypeFromCatalog()
 329         {
 330             var catalog = CatalogFactory.CreateDefaultAttributed();
 331             var container = new CompositionContainer(catalog);
 332             int singletonResult = container.GetExportedValue<int>("{AssemblyCatalogResolver}SingletonValueType");
 333             Assert.AreEqual(17, singletonResult, "expecting value type resolved from catalog");
 334             int factoryResult = container.GetExportedValue<int>("{AssemblyCatalogResolver}FactoryValueType");
 335             Assert.AreEqual(18, factoryResult, "expecting value type resolved from catalog");
 336         }
 337
 338         [Export]
 339         [PartCreationPolicy(CreationPolicy.Any)]
 340         public class CreationPolicyAny
 341         {
 342
 343         }
 344
 345         [TestMethod]
 346         public void CreationPolicyAny_MultipleCallsReturnSameInstance()
 347         {
 348             var catalog = CatalogFactory.CreateAttributed(typeof (CreationPolicyAny));
 349             var provider = new CatalogExportProvider(catalog);
 350             provider.SourceProvider = ContainerFactory.Create();
 351
 352             var export = provider.GetExportedValue<CreationPolicyAny>();
 353
 354             for (int i = 0; i < 5; i++) // 5 is arbitrarily chosen
 355             {
 356                 var export1 = provider.GetExportedValue<CreationPolicyAny>();
 357
 358                 Assert.AreEqual(export, export1);
 359             }
 360         }
 361
 362         [Export]
 363         [PartCreationPolicy(CreationPolicy.Shared)]
 364         public class CreationPolicyShared
 365         {
 366
 367         }
 368
 369         [TestMethod]
 370         public void CreationPolicyShared_MultipleCallsReturnSameInstance()
 371         {
 372             var catalog = CatalogFactory.CreateAttributed(typeof(CreationPolicyShared));
 373             var provider = new CatalogExportProvider(catalog);
 374             provider.SourceProvider = ContainerFactory.Create();
 375
 376             var export = provider.GetExportedValue<CreationPolicyShared>();
 377
 378             for (int i = 0; i < 5; i++) // 5 is arbitrarily chosen
 379             {
 380                 var export1 = provider.GetExportedValue<CreationPolicyShared>();
 381
 382                 Assert.AreEqual(export, export1);
 383             }
 384         }
 385
 386         [Export]
 387         [PartCreationPolicy(CreationPolicy.NonShared)]
 388         public class CreationPolicyNonShared
 389         {
 390
 391         }
 392
 393         [TestMethod]
 394         public void CreationPolicyNonShared_MultipleCallsReturnsDifferentInstances()
 395         {
 396             var catalog = CatalogFactory.CreateAttributed(typeof(CreationPolicyNonShared));
 397             var provider = new CatalogExportProvider(catalog);
 398             provider.SourceProvider = ContainerFactory.Create();
 399
 400             List<CreationPolicyNonShared> list = new List<CreationPolicyNonShared>();
 401             var export = provider.GetExportedValue<CreationPolicyNonShared>();
 402             list.Add(export);
 403
 404             for (int i = 0; i < 5; i++) // 5 is arbitrarily chosen
 405             {
 406                 export = provider.GetExportedValue<CreationPolicyNonShared>();
 407
 408                 CollectionAssert.DoesNotContain(list, export);
 409                 list.Add(export);
 410             }
 411         }
 412
 413         [TestMethod]
 414         [WorkItem(684514)]
 415         public void GetExports_NoSourceProvider_ShouldThrowInvalidOperation()
 416         {
 417             var catalog = CatalogFactory.CreateAttributed();
 418             var provider = new CatalogExportProvider(catalog);
 419
 420             ExceptionAssert.Throws<InvalidOperationException>(() =>
 421                 provider.GetExports(ImportFromContract("Foo")));
 422         }
 423
 424         [TestMethod]
 425         [TestProperty("Type", "Integration")]
 426         [Ignore]
 427         [WorkItem(561310)]
 428         public void Recomposition_PartDefWithRecomposableImportIsRemoved_ExportsMatchingImportChanged_ShouldNotBeRecomposed()
 429         {
 430             string dependencyContractName = "dependency";
 431             var exportValue = new object();
 432
 433             var exporterPart = PartFactory.CreateExporter(dependencyContractName, exportValue);
 434             var importerPart = PartFactory.CreateImporter(dependencyContractName, true);
 435
 436             var exporterCatalog = CatalogFactory.Create(exporterPart);
 437             var importerCatalog = CatalogFactory.Create(importerPart);
 438
 439             var aggregateCatalog = CatalogFactory.CreateAggregateCatalog(importerCatalog, exporterCatalog);
 440
 441             var provider = new CatalogExportProvider(aggregateCatalog);
 442             provider.SourceProvider = provider;
 443
 444             var exports = provider.GetExports(importerPart.ImportDefinitions.Single());
 445             Assert.AreEqual(exportValue, importerPart.Value, "Importer was not composed");
 446
 447             aggregateCatalog.Catalogs.Remove(importerCatalog);
 448             aggregateCatalog.Catalogs.Remove(exporterCatalog);
 449
 450             Assert.AreEqual(exportValue, importerPart.Value, "Importer was unexpectedly recomposed");
 451         }
 452
 453         [TestMethod]
 454         [TestProperty("Type", "Integration")]
 455         [Ignore]
 456         [WorkItem(561310)]
 457         public void Recomposition_PartDefWithNonRecomposableImportIsRemoved_ExportsMatchingImportChanged_ShouldNotBeRejected()
 458         {
 459             string dependencyContractName = "dependency";
 460             var exportValue = new object();
 461
 462             var exporterPart = PartFactory.CreateExporter(dependencyContractName, exportValue);
 463             var importerPart = PartFactory.CreateImporter(dependencyContractName, false);
 464
 465             var exporterCatalog = CatalogFactory.Create(exporterPart);
 466             var importerCatalog = CatalogFactory.Create(importerPart);
 467
 468             var aggregateCatalog = CatalogFactory.CreateAggregateCatalog(importerCatalog, exporterCatalog);
 469
 470             var provider = new CatalogExportProvider(aggregateCatalog);
 471             provider.SourceProvider = provider;
 472
 473             var exports = provider.GetExports(importerPart.ImportDefinitions.Single());
 474             Assert.AreEqual(exportValue, importerPart.Value, "Importer was not composed");
 475
 476             aggregateCatalog.Catalogs.Remove(importerCatalog);
 477             aggregateCatalog.Catalogs.Remove(exporterCatalog);
 478
 479             Assert.AreEqual(exportValue, importerPart.Value, "Importer was unexpectedly recomposed");
 480         }
 481
 482         [TestMethod]
 483         public void CanBeCollectedAfterDispose()
 484         {
 485             AggregateExportProvider sourceExportProvider = new AggregateExportProvider();
 486             var catalog = new AggregateCatalog(CatalogFactory.CreateDefaultAttributed());
 487             var catalogExportProvider = new CatalogExportProvider(catalog);
 488             catalogExportProvider.SourceProvider = sourceExportProvider;
 489
 490             WeakReference weakCatalogExportProvider = new WeakReference(catalogExportProvider);
 491             catalogExportProvider.Dispose();
 492             catalogExportProvider = null;
 493
 494             GC.Collect();
 495             GC.WaitForPendingFinalizers();
 496
 497             Assert.IsFalse(weakCatalogExportProvider.IsAlive);
 498
 499             GC.KeepAlive(sourceExportProvider);
 500             GC.KeepAlive(catalog);
 501         }
 502
 503         [TestMethod]
 504         public void RemovingAndReAddingMultipleDefinitionsFromCatalog()
 505         {
 506             var fixedParts = new TypeCatalog(typeof(RootMultipleImporter), typeof(ExportedService));
 507             var changingParts = new TypeCatalog(typeof(Exporter1), typeof(Exporter2));
 508             var catalog = new AggregateCatalog();
 509             catalog.Catalogs.Add(fixedParts);
 510             catalog.Catalogs.Add(changingParts);
 511             var catalogExportProvider = new CatalogExportProvider(catalog);
 512             catalogExportProvider.SourceProvider = catalogExportProvider;
 513
 514             var root = catalogExportProvider.GetExport<RootMultipleImporter>().Value;
 515             Assert.AreEqual(2, root.Imports.Length);
 516
 517             catalog.Catalogs.Remove(changingParts);
 518             Assert.AreEqual(0, root.Imports.Length);
 519
 520             catalog.Catalogs.Add(changingParts);
 521             Assert.AreEqual(2, root.Imports.Length);
 522         }
 523
 524         [Export]
 525         public class RootMultipleImporter
 526         {
 527             [ImportMany(AllowRecomposition = true)]
 528             public IExportedInterface[] Imports { get; set; }
 529         }
 530         public interface IExportedInterface
 531         {
 532         }
 533         [Export(typeof(IExportedInterface))]
 534         public class Exporter1 : IExportedInterface
 535         {
 536             [Import]
 537             public ExportedService Service { get; set; }
 538         }
 539         [Export(typeof(IExportedInterface))]
 540         public class Exporter2 : IExportedInterface
 541         {
 542             [Import]
 543             public ExportedService Service { get; set; }
 544         }
 545         [Export]
 546         public class ExportedService
 547         {
 548         }
 549
 550
 551
 552         private static ImportDefinition ImportFromContract(string contractName)
 553         {
 554             return ImportDefinitionFactory.CreateDefault(contractName,
 555
 556                                                      ImportCardinality.ZeroOrMore,
 557                                                      false,
 558                                                      false);
 559         }
 560
 561         private static ImportDefinition ImportFromContractAndMetadata(string contractName, string[] metadataKeys, Type[] metadataValues)
 562         {
 563             Assert.AreEqual(metadataKeys.Length, metadataValues.Length);
 564             Dictionary<string, Type> requiredMetadata = new Dictionary<string, Type>();
 565             for (int i = 0; i < metadataKeys.Length; i++)
 566             {
 567                 requiredMetadata.Add(metadataKeys[i], metadataValues[i]);
 568             }
 569
 570             return new ContractBasedImportDefinition(contractName,
 571                                                      (string)null,
 572                                                      requiredMetadata,
 573                                                      ImportCardinality.ZeroOrMore,
 574                                                      false,
 575                                                      false,
 576                                                      CreationPolicy.Any);
 577         }
 578
 579         private static CatalogExportProvider CreateCatalogExportProvider()
 580         {
 581             return CreateCatalogExportProvider(CatalogFactory.Create());
 582         }
 583
 584         private static CatalogExportProvider CreateCatalogExportProvider(params ComposablePartDefinition[] definitions)
 585         {
 586             return CreateCatalogExportProvider(CatalogFactory.Create(definitions));
 587         }
 588
 589         private static CatalogExportProvider CreateCatalogExportProvider(params ComposablePart[] parts)
 590         {
 591             return CreateCatalogExportProvider(CatalogFactory.Create(parts));
 592         }
 593
 594         private static CatalogExportProvider CreateCatalogExportProvider(ComposablePartCatalog catalog)
 595         {
 596             return new CatalogExportProvider(catalog);
 597         }
 598     }
 599 }