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

   1 // -----------------------------------------------------------------------\r
   2 // Copyright (c) Microsoft Corporation.  All rights reserved.\r
   3 // -----------------------------------------------------------------------\r
   4 using System;\r
   5 using System.Collections.Generic;\r
   6 using System.ComponentModel.Composition;\r
   7 using System.Linq;\r
   8 using System.Linq.Expressions;\r
   9 using System.Runtime.Serialization;\r
  10 using Microsoft.VisualStudio.TestTools.UnitTesting;\r
  11 using System.ComponentModel.Composition.Factories;\r
  12 using System.UnitTesting;\r
  13 using System.ComponentModel.Composition.AttributedModel;\r
  14 using System.ComponentModel.Composition.Hosting;\r
  15 using System.ComponentModel.Composition.Primitives;\r
  16 using System.ComponentModel.Composition.UnitTesting;\r
  17 \r
  18 namespace System.ComponentModel.Composition\r
  19 {\r
  20     [TestClass]\r
  21     public class CompositionContainerTests\r
  22     {\r
  23         [TestMethod]\r
  24         public void Constructor2_ArrayWithNullElementAsProvidersArgument_ShouldThrowArgumentException()\r
  25         {\r
  26             ExceptionAssert.ThrowsArgument<ArgumentException>("providers", () =>\r
  27             {\r
  28                 new CompositionContainer(new ExportProvider[] { null });\r
  29             });\r
  30         }\r
  31 \r
  32         [TestMethod]\r
  33         public void Constructor3_ArrayWithNullElementAsProvidersArgument_ShouldThrowArgumentException()\r
  34         {\r
  35             var catalog = CatalogFactory.Create();\r
  36 \r
  37             ExceptionAssert.ThrowsArgument<ArgumentException>("providers", () =>\r
  38             {\r
  39                 new CompositionContainer(catalog, new ExportProvider[] { null });\r
  40             });\r
  41         }\r
  42 \r
  43         [TestMethod]\r
  44         public void Constructor2_ArrayAsProvidersArgument_ShouldNotAllowModificationAfterConstruction()\r
  45         {\r
  46             var providers = new ExportProvider[] { ExportProviderFactory.Create() };\r
  47             var container = new CompositionContainer(providers);\r
  48 \r
  49             providers[0] = null;\r
  50 \r
  51             Assert.IsNotNull(container.Providers[0]);\r
  52         }\r
  53 \r
  54         [TestMethod]\r
  55         public void Constructor3_ArrayAsProvidersArgument_ShouldNotAllowModificationAfterConstruction()\r
  56         {\r
  57             var providers = new ExportProvider[] { ExportProviderFactory.Create() };\r
  58             var container = new CompositionContainer(CatalogFactory.Create(), providers);\r
  59 \r
  60             providers[0] = null;\r
  61 \r
  62             Assert.IsNotNull(container.Providers[0]);\r
  63         }\r
  64 \r
  65         [TestMethod]\r
  66         public void Constructor1_ShouldSetProvidersPropertyToEmptyCollection()\r
  67         {\r
  68             var container = new CompositionContainer();\r
  69 \r
  70             EnumerableAssert.IsEmpty(container.Providers);\r
  71         }\r
  72 \r
  73         [TestMethod]\r
  74         public void Constructor2_EmptyArrayAsProvidersArgument_ShouldSetProvidersPropertyToEmpty()\r
  75         {\r
  76             var container = new CompositionContainer(new ExportProvider[0]);\r
  77 \r
  78             EnumerableAssert.IsEmpty(container.Providers);\r
  79         }\r
  80 \r
  81         [TestMethod]\r
  82         public void Constructor3_EmptyArrayAsProvidersArgument_ShouldSetProvidersPropertyToEmpty()\r
  83         {\r
  84             var container = new CompositionContainer(CatalogFactory.Create(), new ExportProvider[0]);\r
  85 \r
  86             EnumerableAssert.IsEmpty(container.Providers);\r
  87         }\r
  88 \r
  89         [TestMethod]\r
  90         public void Constructor1_ShouldSetCatalogPropertyToNull()\r
  91         {\r
  92             var container = new CompositionContainer();\r
  93 \r
  94             Assert.IsNull(container.Catalog);\r
  95         }\r
  96 \r
  97         [TestMethod]\r
  98         public void Constructor2_ShouldSetCatalogPropertyToNull()\r
  99         {\r
 100             var container = new CompositionContainer(new ExportProvider[0]);\r
 101 \r
 102             Assert.IsNull(container.Catalog);\r
 103         }\r
 104 \r
 105         [TestMethod]\r
 106         public void Constructor3_NullAsCatalogArgument_ShouldSetCatalogPropertyToNull()\r
 107         {\r
 108             var container = new CompositionContainer((ComposablePartCatalog)null, new ExportProvider[0]);\r
 109 \r
 110             Assert.IsNull(container.Catalog);\r
 111         }\r
 112 \r
 113         [TestMethod]\r
 114         public void Constructor3_ValueAsCatalogArgument_ShouldSetCatalogProperty()\r
 115         {\r
 116             var expectations = Expectations.GetCatalogs();\r
 117 \r
 118             foreach (var e in expectations)\r
 119             {\r
 120                 var container = new CompositionContainer(e, new ExportProvider[0]);\r
 121 \r
 122                 Assert.AreSame(e, container.Catalog);\r
 123             }\r
 124         }\r
 125 \r
 126         [TestMethod]\r
 127         public void Catalog_WhenDisposed_ShouldThrowObjectDisposed()\r
 128         {\r
 129             var container = CreateCompositionContainer();\r
 130             container.Dispose();\r
 131 \r
 132             ExceptionAssert.ThrowsDisposed(container, () =>\r
 133             {\r
 134                 var catalog = container.Catalog;\r
 135             });\r
 136         }\r
 137 \r
 138         [TestMethod]\r
 139         public void Providers_WhenDisposed_ShouldThrowObjectDisposed()\r
 140         {\r
 141             var container = CreateCompositionContainer();\r
 142             container.Dispose();\r
 143 \r
 144             ExceptionAssert.ThrowsDisposed(container, () =>\r
 145             {\r
 146                 var providers = container.Providers;\r
 147             });\r
 148         }\r
 149 \r
 150         [TestMethod]\r
 151         [Ignore]\r
 152         [WorkItem(579990)]  // NullReferenceException\r
 153         public void ExportsChanged_Add_WhenDisposed_ShouldThrowObjectDisposed()\r
 154         {\r
 155             var container = CreateCompositionContainer();\r
 156             container.Dispose();\r
 157 \r
 158             ExceptionAssert.ThrowsDisposed(container, () =>\r
 159             {\r
 160                 container.ExportsChanged += (o, s) => { };\r
 161             });\r
 162         }\r
 163 \r
 164         [TestMethod]\r
 165         [Ignore]\r
 166         [WorkItem(579990)] // NullReferenceException\r
 167         public void ExportsChanged_Remove_WhenDisposed_ShouldThrowObjectDisposed()\r
 168         {\r
 169             var container = CreateCompositionContainer();\r
 170             container.Dispose();\r
 171 \r
 172             ExceptionAssert.ThrowsDisposed(container, () =>\r
 173             {\r
 174                 container.ExportsChanged -= (o, s) => { };\r
 175             });\r
 176         }\r
 177 \r
 178         [TestMethod]\r
 179         public void AddPart1_ImportOnlyPart_ShouldNotGetGarbageCollected()\r
 180         {\r
 181             var container = CreateCompositionContainer();\r
 182 \r
 183             var import = PartFactory.CreateImporter("Value", ImportCardinality.ZeroOrMore);\r
 184 \r
 185             CompositionBatch batch = new CompositionBatch();\r
 186             batch.AddPart(import);\r
 187             container.Compose(batch);\r
 188 \r
 189             var weakRef = new WeakReference(import);\r
 190             import = null;\r
 191 \r
 192             GC.Collect();\r
 193             GC.WaitForPendingFinalizers();\r
 194 \r
 195             Assert.IsNotNull(weakRef.Target, "Import only part should not have been collected!");\r
 196 \r
 197             GC.KeepAlive(container);\r
 198         }\r
 199 \r
 200         [TestMethod]\r
 201         public void Compose_WhenContainerDisposed_ShouldThrowObjectDisposed()\r
 202         {\r
 203             var container = CreateCompositionContainer();\r
 204             container.Dispose();\r
 205 \r
 206             CompositionBatch batch = new CompositionBatch();\r
 207             ExceptionAssert.ThrowsDisposed(container, () =>\r
 208             {\r
 209                 container.Compose(batch);\r
 210             });\r
 211         }\r
 212 \r
 213         [TestMethod]\r
 214         public void GetExportOfT1_WhenContainerDisposed_ShouldThrowObjectDisposed()\r
 215         {\r
 216             var container = CreateCompositionContainer();\r
 217             container.Dispose();\r
 218 \r
 219             ExceptionAssert.ThrowsDisposed(container, () =>\r
 220             {\r
 221                 container.GetExport<string>();\r
 222             });\r
 223         }\r
 224 \r
 225         [TestMethod]\r
 226         public void GetExportOfT2_WhenContainerDisposed_ShouldThrowObjectDisposed()\r
 227         {\r
 228             var container = CreateCompositionContainer();\r
 229             container.Dispose();\r
 230 \r
 231             ExceptionAssert.ThrowsDisposed(container, () =>\r
 232             {\r
 233                 container.GetExport<string>("Contract");\r
 234             });\r
 235         }\r
 236 \r
 237         [TestMethod]\r
 238         public void GetExportOfTTMetadataView1_WhenContainerDisposed_ShouldThrowObjectDisposed()\r
 239         {\r
 240             var container = CreateCompositionContainer();\r
 241             container.Dispose();\r
 242 \r
 243             ExceptionAssert.ThrowsDisposed(container, () =>\r
 244             {\r
 245                 container.GetExport<string, object>();\r
 246             });\r
 247         }\r
 248 \r
 249         [TestMethod]\r
 250         public void GetExportOfTTMetadataView2_WhenContainerDisposed_ShouldThrowObjectDisposed()\r
 251         {\r
 252             var container = CreateCompositionContainer();\r
 253             container.Dispose();\r
 254 \r
 255             ExceptionAssert.ThrowsDisposed(container, () =>\r
 256             {\r
 257                 container.GetExport<string, object>("Contract");\r
 258             });\r
 259         }\r
 260 \r
 261         [TestMethod]\r
 262         public void GetExports1_WhenContainerDisposed_ShouldThrowObjectDisposed()\r
 263         {\r
 264             var container = CreateCompositionContainer();\r
 265             container.Dispose();\r
 266 \r
 267             var definition = ImportDefinitionFactory.Create();\r
 268             ExceptionAssert.ThrowsDisposed(container, () =>\r
 269             {\r
 270                 container.GetExports(definition);\r
 271             });\r
 272         }\r
 273 \r
 274         [TestMethod]\r
 275         public void GetExports2_WhenContainerDisposed_ShouldThrowObjectDisposed()\r
 276         {\r
 277             var container = CreateCompositionContainer();\r
 278             container.Dispose();\r
 279 \r
 280             ExceptionAssert.ThrowsDisposed(container, () =>\r
 281             {\r
 282                 container.GetExports(typeof(string), typeof(object), "Contract");\r
 283             });\r
 284         }\r
 285 \r
 286         [TestMethod]\r
 287         public void GetExportsOfT1_WhenContainerDisposed_ShouldThrowObjectDisposed()\r
 288         {\r
 289             var container = CreateCompositionContainer();\r
 290             container.Dispose();\r
 291 \r
 292             ExceptionAssert.ThrowsDisposed(container, () =>\r
 293             {\r
 294                 container.GetExports<string>();\r
 295             });\r
 296         }\r
 297 \r
 298         [TestMethod]\r
 299         public void GetExportsOfT2_WhenContainerDisposed_ShouldThrowObjectDisposed()\r
 300         {\r
 301             var container = CreateCompositionContainer();\r
 302             container.Dispose();\r
 303 \r
 304             ExceptionAssert.ThrowsDisposed(container, () =>\r
 305             {\r
 306                 container.GetExports<string>("Contract");\r
 307             });\r
 308         }\r
 309 \r
 310         [TestMethod]\r
 311         public void GetExportsOfTTMetadataView1_WhenContainerDisposed_ShouldThrowObjectDisposed()\r
 312         {\r
 313             var container = CreateCompositionContainer();\r
 314             container.Dispose();\r
 315 \r
 316             ExceptionAssert.ThrowsDisposed(container, () =>\r
 317             {\r
 318                 container.GetExports<string, object>();\r
 319             });\r
 320         }\r
 321 \r
 322         [TestMethod]\r
 323         public void GetExportsOfTTMetadataView2_WhenContainerDisposed_ShouldThrowObjectDisposed()\r
 324         {\r
 325             var container = CreateCompositionContainer();\r
 326             container.Dispose();\r
 327 \r
 328             ExceptionAssert.ThrowsDisposed(container, () =>\r
 329             {\r
 330                 container.GetExports<string, object>("Contract");\r
 331             });\r
 332         }\r
 333 \r
 334         [TestMethod]\r
 335         public void GetExportedValueOfT1_WhenContainerDisposed_ShouldThrowObjectDisposed()\r
 336         {\r
 337             var container = CreateCompositionContainer();\r
 338             container.Dispose();\r
 339 \r
 340             ExceptionAssert.ThrowsDisposed(container, () =>\r
 341             {\r
 342                 container.GetExportedValue<string>();\r
 343             });\r
 344         }\r
 345 \r
 346 \r
 347         [TestMethod]\r
 348         public void GetExportedValueOfT2_WhenContainerDisposed_ShouldThrowObjectDisposed()\r
 349         {\r
 350             var container = CreateCompositionContainer();\r
 351             container.Dispose();\r
 352 \r
 353             ExceptionAssert.ThrowsDisposed(container, () =>\r
 354             {\r
 355                 container.GetExportedValue<string>("Contract");\r
 356             });\r
 357         }\r
 358 \r
 359         [TestMethod]\r
 360         public void GetExportedValueOrDefaultOfT1_WhenContainerDisposed_ShouldThrowObjectDisposed()\r
 361         {\r
 362             var container = CreateCompositionContainer();\r
 363             container.Dispose();\r
 364 \r
 365             ExceptionAssert.ThrowsDisposed(container, () =>\r
 366             {\r
 367                 container.GetExportedValueOrDefault<string>();\r
 368             });\r
 369         }\r
 370 \r
 371         [TestMethod]\r
 372         public void GetExportedValueOrDefaultOfT2_WhenContainerDisposed_ShouldThrowObjectDisposed()\r
 373         {\r
 374             var container = CreateCompositionContainer();\r
 375             container.Dispose();\r
 376 \r
 377             ExceptionAssert.ThrowsDisposed(container, () =>\r
 378             {\r
 379                 container.GetExportedValueOrDefault<string>("Contract");\r
 380             });\r
 381         }\r
 382 \r
 383         [TestMethod]\r
 384         public void GetExportedValuesOfT1_WhenContainerDisposed_ShouldThrowObjectDisposed()\r
 385         {\r
 386             var container = CreateCompositionContainer();\r
 387             container.Dispose();\r
 388 \r
 389             ExceptionAssert.ThrowsDisposed(container, () =>\r
 390             {\r
 391                 container.GetExportedValues<string>();\r
 392             });\r
 393         }\r
 394 \r
 395         [TestMethod]\r
 396         public void GetExportedValuesOfT2_WhenContainerDisposed_ShouldThrowObjectDisposed()\r
 397         {\r
 398             var container = CreateCompositionContainer();\r
 399             container.Dispose();\r
 400 \r
 401             ExceptionAssert.ThrowsDisposed(container, () =>\r
 402             {\r
 403                 container.GetExportedValues<string>("Contract");\r
 404             });\r
 405         }\r
 406 \r
 407         [TestMethod]\r
 408         public void GetExports1_NullAsImportDefinitionArgument_ShouldThrowArgumentNull()\r
 409         {\r
 410             var container = CreateCompositionContainer();\r
 411 \r
 412             ExceptionAssert.ThrowsArgument<ArgumentNullException>("definition", () =>\r
 413             {\r
 414                 container.GetExports((ImportDefinition)null);\r
 415             });\r
 416         }\r
 417 \r
 418         [TestMethod]\r
 419         public void GetExports2_NullAsTypeArgument_ShouldThrowArgumentNull()\r
 420         {\r
 421             var container = CreateCompositionContainer();\r
 422 \r
 423             ExceptionAssert.ThrowsArgument<ArgumentNullException>("type", () =>\r
 424             {\r
 425                 container.GetExports((Type)null, typeof(string), "ContractName");\r
 426             });\r
 427         }\r
 428 \r
 429         [TestMethod]\r
 430         public void GetExportOfT1_AskingForContractThatDoesNotExist_ShouldThrowCardinalityMismatch()\r
 431         {\r
 432             var container = CreateCompositionContainer();\r
 433 \r
 434             ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>\r
 435             {\r
 436                 container.GetExport<string>();\r
 437             });\r
 438         }\r
 439 \r
 440         [TestMethod]\r
 441         public void GetExportOfT2_AskingForContractThatDoesNotExist_ShouldThrowCardinalityMismatch()\r
 442         {\r
 443             var container = CreateCompositionContainer();\r
 444 \r
 445             ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>\r
 446             {\r
 447                 container.GetExport<string>("Contract");\r
 448             });\r
 449         }\r
 450 \r
 451         [TestMethod]\r
 452         public void GetExportOfTTMetadataView1_AskingForContractThatDoesNotExist_ShouldThrowCardinalityMismatch()\r
 453         {\r
 454             var container = CreateCompositionContainer();\r
 455 \r
 456             ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>\r
 457             {\r
 458                 container.GetExport<string, object>();\r
 459             });\r
 460         }\r
 461 \r
 462         [TestMethod]\r
 463         public void GetExportOfTTMetadataView2_AskingForContractThatDoesNotExist_ShouldThrowCardinalityMismatch()\r
 464         {\r
 465             var container = CreateCompositionContainer();\r
 466 \r
 467             ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>\r
 468             {\r
 469                 container.GetExport<string, object>("Contract");\r
 470             });\r
 471         }\r
 472 \r
 473         [TestMethod]\r
 474         public void GetExports1_DefinitionAskingForExactlyOneContractThatDoesNotExist_ShouldThrowCardinalityMismatch()\r
 475         {\r
 476             var container = CreateCompositionContainer();\r
 477 \r
 478             var definition = ImportDefinitionFactory.Create("Contract", ImportCardinality.ExactlyOne);\r
 479 \r
 480             ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>\r
 481             {\r
 482                 container.GetExports(definition);\r
 483             });\r
 484         }\r
 485 \r
 486         [TestMethod]\r
 487         public void GetExports1_DefinitionAskingForExactlyZeroOrOneContractThatDoesNotExist_ShouldReturnEmpty()\r
 488         {\r
 489             var container = CreateCompositionContainer();\r
 490 \r
 491             var definition = ImportDefinitionFactory.Create("Contract", ImportCardinality.ZeroOrOne);\r
 492 \r
 493             var exports = container.GetExports(definition);\r
 494 \r
 495             EnumerableAssert.IsEmpty(exports);\r
 496         }\r
 497 \r
 498         [TestMethod]\r
 499         public void GetExports1_DefinitionAskingForExactlyZeroOrMoreContractThatDoesNotExist_ShouldReturnEmpty()\r
 500         {\r
 501             var container = CreateCompositionContainer();\r
 502 \r
 503             var definition = ImportDefinitionFactory.Create("Contract", ImportCardinality.ZeroOrMore);\r
 504 \r
 505             var exports = container.GetExports(definition);\r
 506 \r
 507             EnumerableAssert.IsEmpty(exports);\r
 508         }\r
 509 \r
 510         [TestMethod]\r
 511         public void GetExports2_AskingForContractThatDoesNotExist_ShouldReturnNoExports()\r
 512         {\r
 513             var container = CreateCompositionContainer();\r
 514 \r
 515             var exports = container.GetExports(typeof(string), (Type)null, "Contract");\r
 516 \r
 517             EnumerableAssert.IsEmpty(exports);\r
 518         }\r
 519 \r
 520         [TestMethod]\r
 521         public void GetExportsOfT1_AskingForContractThatDoesNotExist_ShouldReturnEmpty()\r
 522         {\r
 523             var container = CreateCompositionContainer();\r
 524 \r
 525             var exports = container.GetExports<string>();\r
 526 \r
 527             EnumerableAssert.IsEmpty(exports);\r
 528         }\r
 529 \r
 530         [TestMethod]\r
 531         public void GetExportsOfT2_AskingForContractThatDoesNotExist_ShouldReturnEmpty()\r
 532         {\r
 533             var container = CreateCompositionContainer();\r
 534 \r
 535             var exports = container.GetExports<string>("Contract");\r
 536 \r
 537             EnumerableAssert.IsEmpty(exports);\r
 538         }\r
 539 \r
 540         [TestMethod]\r
 541         public void GetExportsOfTTMetadataView1_AskingForContractThatDoesNotExist_ShouldReturnEmpty()\r
 542         {\r
 543             var container = CreateCompositionContainer();\r
 544 \r
 545             var exports = container.GetExports<string, object>();\r
 546 \r
 547             EnumerableAssert.IsEmpty(exports);\r
 548         }\r
 549 \r
 550         [TestMethod]\r
 551         public void GetExportsOfTTMetadataView2_AskingForContractThatDoesNotExist_ShouldReturnEmpty()\r
 552         {\r
 553             var container = CreateCompositionContainer();\r
 554 \r
 555             var exports = container.GetExports<string, object>("Contract");\r
 556 \r
 557             EnumerableAssert.IsEmpty(exports);\r
 558         }\r
 559 \r
 560         [TestMethod]\r
 561         public void GetExportedValueOfT1_AskingForContractThatDoesNotExist_ShouldThrowCardinalityMismatch()\r
 562         {\r
 563             var container = CreateCompositionContainer();\r
 564 \r
 565             ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>\r
 566             {\r
 567                 container.GetExportedValue<string>();\r
 568             });\r
 569         }\r
 570 \r
 571         [TestMethod]\r
 572         public void GetExportedValueOfT2_AskingForContractThatDoesNotExist_ShouldThrowCardinalityMismatch()\r
 573         {\r
 574             var container = CreateCompositionContainer();\r
 575 \r
 576             ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>\r
 577             {\r
 578                 container.GetExportedValue<string>("Contract");\r
 579             });\r
 580         }\r
 581 \r
 582         [TestMethod]\r
 583         public void GetExportedValueOrDefaultOfT1_AskingForStringContractThatDoesNotExist_ShouldReturnNull()\r
 584         {\r
 585             var container = CreateCompositionContainer();\r
 586 \r
 587             var exportedValue = container.GetExportedValueOrDefault<string>();\r
 588 \r
 589             Assert.IsNull(exportedValue);\r
 590         }\r
 591 \r
 592         [TestMethod]\r
 593         public void GetExportedValueOrDefaultOfT2_AskingForStringContractThatDoesNotExist_ShouldReturnNull()\r
 594         {\r
 595             var container = CreateCompositionContainer();\r
 596 \r
 597             var exportedValue = container.GetExportedValueOrDefault<string>("Contract");\r
 598 \r
 599             Assert.IsNull(exportedValue);\r
 600         }\r
 601 \r
 602         [TestMethod]\r
 603         public void GetExportedValueOrDefaultOfT1_AskingForInt32ContractThatDoesNotExist_ShouldReturnZero()\r
 604         {\r
 605             var container = CreateCompositionContainer();\r
 606 \r
 607             var exportedValue = container.GetExportedValueOrDefault<int>();\r
 608 \r
 609             Assert.AreEqual(0, exportedValue);\r
 610         }\r
 611 \r
 612         [TestMethod]\r
 613         public void GetExportedValueOrDefaultOfT2_AskingForInt32ContractThatDoesNotExist_ShouldReturnZero()\r
 614         {\r
 615             var container = CreateCompositionContainer();\r
 616 \r
 617             var exportedValue = container.GetExportedValueOrDefault<int>("Contract");\r
 618 \r
 619             Assert.AreEqual(0, exportedValue);\r
 620         }\r
 621 \r
 622         [TestMethod]\r
 623         public void GetExportedValuesOfT1_AskingForContractThatDoesNotExist_ShouldReturnEmpty()\r
 624         {\r
 625             var container = CreateCompositionContainer();\r
 626 \r
 627             var exports = container.GetExportedValues<string>();\r
 628 \r
 629             EnumerableAssert.IsEmpty(exports);\r
 630         }\r
 631 \r
 632         [TestMethod]\r
 633         public void GetExportedValuesOfT2_AskingForContractThatDoesNotExist_ShouldReturnEmpty()\r
 634         {\r
 635             var container = CreateCompositionContainer();\r
 636 \r
 637             var exports = container.GetExports<string>("Contract");\r
 638 \r
 639             EnumerableAssert.IsEmpty(exports);\r
 640         }\r
 641 \r
 642         [TestMethod]\r
 643         public void GetExportOfT1_AskingForContractWithOneExport_ShouldReturnExport()\r
 644         {\r
 645             var container = ContainerFactory.Create(new MicroExport(ContractFromType(typeof(String)), "Value"));\r
 646 \r
 647             var export = container.GetExport<string>();\r
 648 \r
 649             Assert.AreEqual("Value", export.Value);\r
 650         }\r
 651 \r
 652         [TestMethod]\r
 653         public void GetExportOfT2_AskingForContractWithOneExport_ShouldReturnExport()\r
 654         {\r
 655             var container = ContainerFactory.Create(new MicroExport("Contract", "Value"));\r
 656 \r
 657             var export = container.GetExport<string>("Contract");\r
 658 \r
 659             Assert.AreEqual("Value", export.Value);\r
 660         }\r
 661 \r
 662         [TestMethod]\r
 663         public void GetExportOfTTMetadataView1_AskingForContractWithOneExport_ShouldReturnExport()\r
 664         {\r
 665             var container = ContainerFactory.Create(new MicroExport(ContractFromType(typeof(String)), "Value"));\r
 666 \r
 667             var export = container.GetExport<string, object>();\r
 668 \r
 669             Assert.AreEqual("Value", export.Value);\r
 670         }\r
 671 \r
 672         [TestMethod]\r
 673         public void GetExportOfTTMetadataView2_AskingForContractWithOneExport_ShouldReturnExport()\r
 674         {\r
 675             var container = ContainerFactory.Create(new MicroExport("Contract", "Value"));\r
 676 \r
 677             var export = container.GetExport<string, object>("Contract");\r
 678 \r
 679             Assert.AreEqual("Value", export.Value);\r
 680         }\r
 681 \r
 682         [TestMethod]\r
 683         public void GetExports1_AskingForExactlyOneContractWithOneExport_ShouldReturnExport()\r
 684         {\r
 685             var container = ContainerFactory.Create(new MicroExport("Contract", "Value"));\r
 686 \r
 687             var definition = ImportDefinitionFactory.Create("Contract", ImportCardinality.ExactlyOne);\r
 688 \r
 689             var exports = container.GetExports(definition);\r
 690 \r
 691             ExportsAssert.AreEqual(exports, "Value");\r
 692         }\r
 693 \r
 694         [TestMethod]\r
 695         public void GetExports1_AskingForZeroOrOneContractWithOneExport_ShouldReturnExport()\r
 696         {\r
 697             var container = ContainerFactory.Create(new MicroExport("Contract", "Value"));\r
 698 \r
 699             var definition = ImportDefinitionFactory.Create("Contract", ImportCardinality.ZeroOrOne);\r
 700 \r
 701             var exports = container.GetExports(definition);\r
 702 \r
 703             ExportsAssert.AreEqual(exports, "Value");\r
 704         }\r
 705 \r
 706         [TestMethod]\r
 707         public void GetExports1_AskingForZeroOrMoreContractWithOneExport_ShouldReturnExport()\r
 708         {\r
 709             var container = ContainerFactory.Create(new MicroExport("Contract", "Value"));\r
 710 \r
 711             var definition = ImportDefinitionFactory.Create("Contract", ImportCardinality.ZeroOrMore);\r
 712 \r
 713             var exports = container.GetExports(definition);\r
 714 \r
 715             ExportsAssert.AreEqual(exports, "Value");\r
 716         }\r
 717 \r
 718         [TestMethod]\r
 719         public void GetExports2_AskingForContractWithOneExport_ShouldReturnOneExport()\r
 720         {\r
 721             var container = ContainerFactory.Create(new MicroExport("Contract", "Value"));\r
 722 \r
 723             var exports = container.GetExports(typeof(string), (Type)null, "Contract");\r
 724 \r
 725             ExportsAssert.AreEqual(exports, "Value");\r
 726         }\r
 727 \r
 728         [TestMethod]\r
 729         public void GetExportsOfT1_AskingForContractWithOneExport_ShouldReturnOneExport()\r
 730         {\r
 731             var container = ContainerFactory.Create(new MicroExport(typeof(string), "Value"));\r
 732 \r
 733             var exports = container.GetExports<string>();\r
 734 \r
 735             ExportsAssert.AreEqual(exports, "Value");\r
 736         }\r
 737 \r
 738         [TestMethod]\r
 739         public void GetExportsOfT2_AskingForContractWithOneExport_ShouldReturnOneExport()\r
 740         {\r
 741             var container = ContainerFactory.Create(new MicroExport("Contract", "Value"));\r
 742 \r
 743             var exports = container.GetExports<string>("Contract");\r
 744 \r
 745             ExportsAssert.AreEqual(exports, "Value");\r
 746         }\r
 747 \r
 748         [TestMethod]\r
 749         public void GetExportsOfTTMetadataView1_AskingForContractWithOneExport_ShouldReturnOneExport()\r
 750         {\r
 751             var container = ContainerFactory.Create(new MicroExport(typeof(string), "Value"));\r
 752 \r
 753             var exports = container.GetExports<string, object>();\r
 754 \r
 755             ExportsAssert.AreEqual(exports, "Value");\r
 756         }\r
 757 \r
 758         [TestMethod]\r
 759         public void GetExportsOfTTMetadataView2_AskingForContractWithOneExport_ShouldReturnOneExport()\r
 760         {\r
 761             var container = ContainerFactory.Create(new MicroExport("Contract", "Value"));\r
 762 \r
 763             var exports = container.GetExports<string, object>("Contract");\r
 764 \r
 765             ExportsAssert.AreEqual(exports, "Value");\r
 766         }\r
 767 \r
 768         [TestMethod]\r
 769         public void GetExportedValueOfT1_AskingForContractWithOneExport_ShouldReturnExport()\r
 770         {\r
 771             var container = ContainerFactory.Create(new MicroExport(typeof(string), "Value"));\r
 772 \r
 773             var exportedValue = container.GetExportedValue<string>();\r
 774 \r
 775             Assert.AreEqual("Value", exportedValue);\r
 776         }\r
 777 \r
 778         [TestMethod]\r
 779         public void GetExportedValueOfT2_AskingForContractWithOneExport_ShouldReturnExport()\r
 780         {\r
 781             var container = ContainerFactory.Create(new MicroExport("Contract", "Value"));\r
 782 \r
 783             var exportedValue = container.GetExportedValue<string>("Contract");\r
 784 \r
 785             Assert.AreEqual("Value", exportedValue);\r
 786         }\r
 787 \r
 788         [TestMethod]\r
 789         public void GetExportedValueOrDefaultOfT1_AskingForContractWithOneExport_ShouldReturnExport()\r
 790         {\r
 791             var container = ContainerFactory.Create(new MicroExport(typeof(string), "Value"));\r
 792 \r
 793             var exportedValue = container.GetExportedValueOrDefault<string>();\r
 794 \r
 795             Assert.AreEqual("Value", exportedValue);\r
 796         }\r
 797 \r
 798         [TestMethod]\r
 799         public void GetExportedValueOrDefaultOfT2_AskingForContractWithOneExport_ShouldReturnExport()\r
 800         {\r
 801             var container = ContainerFactory.Create(new MicroExport("Contract", "Value"));\r
 802 \r
 803             var exportedValue = container.GetExportedValueOrDefault<string>("Contract");\r
 804 \r
 805             Assert.AreEqual("Value", exportedValue);\r
 806         }\r
 807 \r
 808         [TestMethod]\r
 809         public void GetExportedValuesOfT1_AskingForContractWithOneExport_ShouldReturnOneExport()\r
 810         {\r
 811             var container = ContainerFactory.Create(new MicroExport(typeof(string), "Value"));\r
 812 \r
 813             var exportedValues = container.GetExportedValues<string>();\r
 814             \r
 815             EnumerableAssert.AreEqual(exportedValues, "Value");            \r
 816         }\r
 817 \r
 818         [TestMethod]\r
 819         public void GetExportedValuesOfT2_AskingForContractWithOneExport_ShouldReturnOneExport()\r
 820         {\r
 821             var container = ContainerFactory.Create(new MicroExport("Contract", "Value"));\r
 822 \r
 823             var exportedValues = container.GetExportedValues<string>("Contract");\r
 824 \r
 825             EnumerableAssert.AreEqual(exportedValues, "Value");\r
 826         }\r
 827 \r
 828         [TestMethod]\r
 829         public void GetExportOfT1_AskingForContractWithMultipleExports_ShouldThrowCardinalityMismatch()\r
 830         {\r
 831             var container = ContainerFactory.Create(new MicroExport(ContractFromType(typeof(String)), "Value1", "Value2"));\r
 832 \r
 833             ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>\r
 834              {\r
 835                  container.GetExport<string>();\r
 836              });\r
 837         }\r
 838 \r
 839         [TestMethod]\r
 840         public void GetExportOfT2_AskingForContractWithMultipleExports_ShouldThrowCardinalityMismatch()\r
 841         {\r
 842             var container = ContainerFactory.Create(new MicroExport("Contract", "Value1", "Value2"));\r
 843 \r
 844             ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>\r
 845              {\r
 846                  container.GetExport<string>("Contract");\r
 847              });\r
 848         }\r
 849 \r
 850         [TestMethod]\r
 851         public void GetExportOfTTMetadataView1_AskingForContractWithMultipleExports_ShouldThrowCardinalityMismatch()\r
 852         {\r
 853             var container = ContainerFactory.Create(new MicroExport(ContractFromType(typeof(String)), "Value1", "Value2"));\r
 854 \r
 855             ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>\r
 856             {\r
 857                 container.GetExport<string, object>();\r
 858             });\r
 859         }\r
 860 \r
 861         [TestMethod]\r
 862         public void GetExportOfTTMetadataView2_AskingForContractWithMultipleExports_ShouldThrowCardinalityMismatch()\r
 863         {\r
 864             var container = ContainerFactory.Create(new MicroExport("Contract", "Value1", "Value2"));\r
 865 \r
 866             ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>\r
 867             {\r
 868                 container.GetExport<string, object>("Contract");\r
 869             });\r
 870         }\r
 871 \r
 872         [TestMethod]\r
 873         public void GetExports1_AskingForExactlyOneContractWithMultipleExports_ShouldThrowCardinalityMismatch()\r
 874         {\r
 875             var container = ContainerFactory.Create(new MicroExport("Contract", "Value1", "Value2"));\r
 876 \r
 877             var definition = ImportDefinitionFactory.Create("Contract", ImportCardinality.ExactlyOne);\r
 878 \r
 879             ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>\r
 880             {\r
 881                 container.GetExports(definition);\r
 882             });\r
 883         }\r
 884 \r
 885         [TestMethod]\r
 886         public void GetExports1_AskingForZeroOrOneContractWithMultipleExports_ShouldReturnZero()\r
 887         {\r
 888             var container = ContainerFactory.Create(new MicroExport("Contract", "Value1", "Value2"));\r
 889 \r
 890             var definition = ImportDefinitionFactory.Create("Contract", ImportCardinality.ZeroOrOne);\r
 891 \r
 892             Assert.AreEqual(0, container.GetExports(definition).Count());\r
 893         }\r
 894 \r
 895         [TestMethod]\r
 896         public void GetExports1_AskingForZeroOrMoreContractWithMultipleExports_ShouldReturnMultipleExports()\r
 897         {\r
 898             var container = ContainerFactory.Create(new MicroExport("Contract", "Value1", "Value2"));\r
 899 \r
 900             var definition = ImportDefinitionFactory.Create("Contract", ImportCardinality.ZeroOrMore);\r
 901 \r
 902             var exports = container.GetExports(definition);\r
 903 \r
 904             ExportsAssert.AreEqual(exports, "Value1", "Value2");\r
 905         }\r
 906 \r
 907         [TestMethod]\r
 908         public void GetExports2_AskingForContractWithMultipleExports_ShouldReturnMultipleExports()\r
 909         {\r
 910             var container = ContainerFactory.Create(new MicroExport("Contract", "Value1", "Value2"));\r
 911 \r
 912             var exports = container.GetExports(typeof(string), (Type)null, "Contract");\r
 913 \r
 914             ExportsAssert.AreEqual(exports, "Value1", "Value2");\r
 915         }\r
 916 \r
 917         [TestMethod]\r
 918         public void GetExportsOfT1_AskingForContractWithMultipleExports_ShouldReturnMultipleExports()\r
 919         {\r
 920             var container = ContainerFactory.Create(new MicroExport(typeof(String), "Value1", "Value2"));\r
 921 \r
 922             var exports = container.GetExports<string>();\r
 923 \r
 924             ExportsAssert.AreEqual(exports, "Value1", "Value2");\r
 925         }\r
 926 \r
 927         [TestMethod]\r
 928         public void GetExportsOfT2_AskingForContractWithMultipleExports_ShouldReturnMultipleExports()\r
 929         {\r
 930             var container = ContainerFactory.Create(new MicroExport("Contract", "Value1", "Value2"));\r
 931 \r
 932             var exports = container.GetExports<string>("Contract");\r
 933 \r
 934             ExportsAssert.AreEqual(exports, "Value1", "Value2");\r
 935         }\r
 936 \r
 937         [TestMethod]\r
 938         public void GetExportsOfTTMetadataView1_AskingForContractWithMultipleExports_ShouldReturnMultipleExports()\r
 939         {\r
 940             var container = ContainerFactory.Create(new MicroExport(typeof(string), "Value1", "Value2"));\r
 941 \r
 942             var exports = container.GetExports<string, object>();\r
 943 \r
 944             ExportsAssert.AreEqual(exports, "Value1", "Value2");\r
 945         }\r
 946 \r
 947         [TestMethod]\r
 948         public void GetExportsOfTTMetadataView2_AskingForContractWithMultipleExports_ShouldReturnMultipleExports()\r
 949         {\r
 950             var container = ContainerFactory.Create(new MicroExport("Contract", "Value1", "Value2"));\r
 951 \r
 952             var exports = container.GetExports<string, object>("Contract");\r
 953 \r
 954             ExportsAssert.AreEqual(exports, "Value1", "Value2");\r
 955         }\r
 956 \r
 957         [TestMethod]\r
 958         public void GetExportedValueOfT1_AskingForContractWithMultipleExports_ShouldThrowCardinalityMismatch()\r
 959         {\r
 960             var container = ContainerFactory.Create(new MicroExport(typeof(string), "Value1", "Value2"));\r
 961 \r
 962             ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>\r
 963             {\r
 964                  container.GetExportedValue<string>();\r
 965             });\r
 966         }\r
 967 \r
 968         [TestMethod]\r
 969         public void GetExportedValueOfT2_AskingForContractWithMultipleExports_ShouldThrowCardinalityMismatch()\r
 970         {\r
 971             var container = ContainerFactory.Create(new MicroExport("Contract", "Value1", "Value2"));\r
 972 \r
 973             ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>\r
 974             {\r
 975                  container.GetExportedValue<string>("Contract");\r
 976             });\r
 977         }\r
 978 \r
 979         [TestMethod]\r
 980         public void GetExportedValueOrDefaultOfT1_AskingForContractWithMultipleExports_ShouldReturnZero()\r
 981         {\r
 982             var container = ContainerFactory.Create(new MicroExport(typeof(string), "Value1", "Value2"));\r
 983 \r
 984             Assert.IsNull(container.GetExportedValueOrDefault<string>());\r
 985         }\r
 986 \r
 987         [TestMethod]\r
 988         public void GetExportedValueOrDefaultOfT2_AskingForContractWithMultipleExports_ShouldReturnZero()\r
 989         {\r
 990             var container = ContainerFactory.Create(new MicroExport("Contract", "Value1", "Value2"));\r
 991 \r
 992             Assert.IsNull(container.GetExportedValueOrDefault<string>("Contract"));\r
 993         }\r
 994 \r
 995         [TestMethod]\r
 996         public void GetExportedValuesOfT1_AskingForContractWithMultipleExports_ShouldReturnMultipleExports()\r
 997         {\r
 998             var container = ContainerFactory.Create(new MicroExport(typeof(string), "Value1", "Value2"));\r
 999 \r
1000             var exportedValues = container.GetExportedValues<string>();\r
1001 \r
1002             EnumerableAssert.AreEqual(exportedValues, "Value1", "Value2");\r
1003         }\r
1004 \r
1005         [TestMethod]\r
1006         public void GetExportedValuesOfT2_AskingForContractWithMultipleExports_ShouldReturnMultipleExports()\r
1007         {\r
1008             var container = ContainerFactory.Create(new MicroExport("Contract", typeof(string), "Value1", "Value2"));\r
1009 \r
1010             var exportedValues = container.GetExportedValues<string>("Contract");\r
1011 \r
1012             EnumerableAssert.AreEqual(exportedValues, "Value1", "Value2");\r
1013         }\r
1014 \r
1015         [TestMethod]\r
1016         public void GetExports1_AskingForExactlyOneAndAll_ShouldThrowCardinalityMismatch()\r
1017         {\r
1018             var container = ContainerFactory.Create(new MicroExport("Contract1", "Value1", "Value2", "Value3"),\r
1019                                                     new MicroExport("Contract2", "Value4", "Value5", "Value6"));\r
1020 \r
1021             var definition = ImportDefinitionFactory.Create(import => true, ImportCardinality.ExactlyOne);\r
1022 \r
1023             ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>\r
1024             {\r
1025                 container.GetExports(definition);\r
1026             });\r
1027         }\r
1028 \r
1029         [TestMethod]\r
1030         public void GetExports1_AskingForZeroOrOneAndAll_ShouldReturnZero()\r
1031         {\r
1032             var container = ContainerFactory.Create(new MicroExport("Contract1", "Value1", "Value2", "Value3"),\r
1033                                                     new MicroExport("Contract2", "Value4", "Value5", "Value6"));\r
1034 \r
1035             var definition = ImportDefinitionFactory.Create(import => true, ImportCardinality.ZeroOrOne);\r
1036 \r
1037             Assert.AreEqual(0, container.GetExports(definition).Count());\r
1038         }\r
1039 \r
1040         [TestMethod]\r
1041         public void GetExports1_AskingForZeroOrMoreAndAll_ShouldReturnAll()\r
1042         {\r
1043             var container = ContainerFactory.Create(new MicroExport("Contract1", "Value1", "Value2", "Value3"),\r
1044                                                     new MicroExport("Contract2", "Value4", "Value5", "Value6"));\r
1045 \r
1046             var definition = ImportDefinitionFactory.Create(import => true, ImportCardinality.ZeroOrMore);\r
1047 \r
1048             var exports = container.GetExports(definition);\r
1049 \r
1050             ExportsAssert.AreEqual(exports, "Value1", "Value2", "Value3",\r
1051                                             "Value4", "Value5", "Value6");\r
1052         }\r
1053 \r
1054         [TestMethod]\r
1055         public void GetExportOfT1_StringAsTTypeArgumentAskingForContractWithOneObjectExport_ShouldThrowContractMismatch()\r
1056         {\r
1057             var container = ContainerFactory.Create(new MicroExport(typeof(string), new object()));\r
1058 \r
1059             var export = container.GetExport<string>();\r
1060 \r
1061             ExceptionAssert.Throws<CompositionContractMismatchException>(() =>\r
1062             {\r
1063                 var value = export.Value;\r
1064             });\r
1065         }\r
1066 \r
1067         [TestMethod]\r
1068         public void GetExportOfT2_StringAsTTypeArgumentAskingForContractWithOneObjectExport_ShouldThrowContractMismatch()\r
1069         {\r
1070             var container = ContainerFactory.Create(new MicroExport("Contract", typeof(string), new object()));\r
1071 \r
1072             var export = container.GetExport<string>("Contract");\r
1073 \r
1074             ExceptionAssert.Throws<CompositionContractMismatchException>(() =>\r
1075             {\r
1076                 var value = export.Value;\r
1077             });\r
1078         }\r
1079 \r
1080         [TestMethod]\r
1081         public void GetExportOfTTMetadataView1_StringAsTTypeArgumentAskingForContractWithOneObjectExport_ShouldThrowContractMismatch()\r
1082         {\r
1083             var container = ContainerFactory.Create(new MicroExport(typeof(string), new object()));\r
1084 \r
1085             var export = container.GetExport<string, object>();\r
1086 \r
1087             ExceptionAssert.Throws<CompositionContractMismatchException>(() =>\r
1088             {\r
1089                 var value = export.Value;\r
1090             });\r
1091         }\r
1092 \r
1093         [TestMethod]\r
1094         public void GetExportOfTTMetadataView2_StringAsTTypeArgumentAskingForContractWithOneObjectExport_ShouldThrowContractMismatch()\r
1095         {\r
1096             var container = ContainerFactory.Create(new MicroExport("Contract", typeof(string), new object()));\r
1097 \r
1098             var export = container.GetExport<string, object>("Contract");\r
1099 \r
1100             ExceptionAssert.Throws<CompositionContractMismatchException>(() =>\r
1101             {\r
1102                 var value = export.Value;\r
1103             });\r
1104         }\r
1105 \r
1106         [TestMethod]\r
1107         public void GetExports2_StringAsTTypeArgumentAskingForContractWithOneObjectExport_ShouldThrowContractMismatch()\r
1108         {\r
1109             var container = ContainerFactory.Create(new MicroExport("Contract", typeof(string), new object()));\r
1110 \r
1111             var exports = container.GetExports(typeof(string), (Type)null, "Contract");\r
1112 \r
1113             Assert.AreEqual(1, exports.Count());\r
1114 \r
1115             var export = exports.ElementAt(0);\r
1116 \r
1117             ExceptionAssert.Throws<CompositionContractMismatchException>(() =>\r
1118             {\r
1119                 var value = export.Value;\r
1120             });\r
1121         }\r
1122 \r
1123         [TestMethod]\r
1124         public void GetExportsOfT1_StringAsTTypeArgumentAskingForContractWithOneObjectExport_ShouldThrowContractMismatch()\r
1125         {\r
1126             var container = ContainerFactory.Create(new MicroExport(typeof(string), new object()));\r
1127 \r
1128             var exports = container.GetExports<string>();\r
1129 \r
1130             Assert.AreEqual(1, exports.Count());\r
1131 \r
1132             var export = exports.ElementAt(0);\r
1133 \r
1134             ExceptionAssert.Throws<CompositionContractMismatchException>(() =>\r
1135             {\r
1136                 var value = export.Value;\r
1137             });\r
1138         }\r
1139 \r
1140         [TestMethod]\r
1141         public void GetExportsOfT2_StringAsTTypeArgumentAskingForContractWithOneObjectExport_ShouldThrowContractMismatch()\r
1142         {\r
1143             var container = ContainerFactory.Create(new MicroExport("Contract", typeof(string), new object()));\r
1144 \r
1145             var exports = container.GetExports<string>("Contract");\r
1146 \r
1147             Assert.AreEqual(1, exports.Count());\r
1148 \r
1149             var export = exports.ElementAt(0);\r
1150 \r
1151             ExceptionAssert.Throws<CompositionContractMismatchException>(() =>\r
1152             {\r
1153                 var value = export.Value;\r
1154             });\r
1155         }\r
1156 \r
1157         [TestMethod]\r
1158         public void GetExportsOfTTMetadataView1_StringAsTTypeArgumentAskingForContractWithOneObjectExport_ShouldThrowContractMismatch()\r
1159         {\r
1160             var container = ContainerFactory.Create(new MicroExport(typeof(string), new object()));\r
1161 \r
1162             var exports = container.GetExports<string, object>();\r
1163 \r
1164             Assert.AreEqual(1, exports.Count());\r
1165 \r
1166             var export = exports.ElementAt(0);\r
1167 \r
1168             ExceptionAssert.Throws<CompositionContractMismatchException>(() =>\r
1169             {\r
1170                 var value = export.Value;\r
1171             });\r
1172         }\r
1173 \r
1174         [TestMethod]\r
1175         public void GetExportsOfTTMetadataView2_StringAsTTypeArgumentAskingForContractWithOneObjectExport_ShouldThrowContractMismatch()\r
1176         {\r
1177             var container = ContainerFactory.Create(new MicroExport("Contract", typeof(string), new object()));\r
1178 \r
1179             var exports = container.GetExports<string, object>("Contract");\r
1180 \r
1181             Assert.AreEqual(1, exports.Count());\r
1182 \r
1183             var export = exports.ElementAt(0);\r
1184 \r
1185             ExceptionAssert.Throws<CompositionContractMismatchException>(() =>\r
1186             {\r
1187                 var value = export.Value;\r
1188             });\r
1189         }\r
1190 \r
1191         [TestMethod]\r
1192         public void GetExportedValueOfT1_StringAsTTypeArgumentAskingForContractWithObjectExport_ShouldThrowContractMismatch()\r
1193         {\r
1194             var container = ContainerFactory.Create(new MicroExport(typeof(string), new object()));\r
1195 \r
1196             ExceptionAssert.Throws<CompositionContractMismatchException>(() =>\r
1197             {\r
1198                 container.GetExportedValue<string>();\r
1199             });\r
1200         }\r
1201 \r
1202         [TestMethod]\r
1203         public void GetExportedValueOfT2_StringAsTTypeArgumentAskingForContractWithObjectExport_ShouldThrowContractMismatch()\r
1204         {\r
1205             var container = ContainerFactory.Create(new MicroExport("Contract", typeof(string), new object()));\r
1206 \r
1207             ExceptionAssert.Throws<CompositionContractMismatchException>(() =>\r
1208             {\r
1209                 container.GetExportedValue<string>("Contract");\r
1210             });\r
1211         }\r
1212 \r
1213         [TestMethod]\r
1214         public void GetExportedValueOrDefaultOfT1_StringAsTTypeArgumentAskingForContractWithObjectExport_ShouldThrowContractMismatch()\r
1215         {\r
1216             var container = ContainerFactory.Create(new MicroExport(typeof(string), new object()));\r
1217 \r
1218             ExceptionAssert.Throws<CompositionContractMismatchException>(() =>\r
1219             {\r
1220                 container.GetExportedValueOrDefault<string>();\r
1221             });\r
1222         }\r
1223 \r
1224         [TestMethod]\r
1225         public void GetExportedValueOrDefaultOfT2_StringAsTTypeArgumentAskingForContractWithObjectExport_ShouldThrowContractMismatch()\r
1226         {\r
1227             var container = ContainerFactory.Create(new MicroExport("Contract", typeof(string), new object()));\r
1228 \r
1229             ExceptionAssert.Throws<CompositionContractMismatchException>(() =>\r
1230             {\r
1231                 container.GetExportedValueOrDefault<string>("Contract");\r
1232             });\r
1233         }\r
1234 \r
1235         [TestMethod]\r
1236         public void GetExportedValuesOfT1_StringAsTTypeArgumentAskingForContractWithOneObjectExport_ShouldThrowContractMismatch()\r
1237         {\r
1238             var container = ContainerFactory.Create(new MicroExport(typeof(string), new object()));\r
1239 \r
1240             ExceptionAssert.Throws<CompositionContractMismatchException>(() =>\r
1241             {\r
1242                 container.GetExportedValues<string>();\r
1243             });\r
1244         }\r
1245 \r
1246         [TestMethod]\r
1247         public void GetExportedValuesOfT2_StringAsTTypeArgumentAskingForContractWithOneObjectExport_ShouldThrowContractMismatch()\r
1248         {\r
1249             var container = ContainerFactory.Create(new MicroExport("Contract", typeof(string), new object()));\r
1250 \r
1251             ExceptionAssert.Throws<CompositionContractMismatchException>(() =>\r
1252             {\r
1253                 container.GetExportedValues<string>("Contract");\r
1254             });\r
1255         }\r
1256 \r
1257 \r
1258         [TestMethod]\r
1259         public void GetExportOfT1_AskingForContractFromChildWithExportInParentContainer_ShouldReturnExport()\r
1260         {\r
1261             var parent = ContainerFactory.Create(new MicroExport(typeof(string), "Parent"));\r
1262             var child = ContainerFactory.Create(parent);\r
1263 \r
1264             var export = child.GetExport<string>();\r
1265 \r
1266             Assert.AreEqual("Parent", export.Value);\r
1267         }\r
1268 \r
1269         [TestMethod]\r
1270         public void GetExportOfT2_AskingForContractFromChildWithExportInParentContainer_ShouldReturnExport()\r
1271         {\r
1272             var parent = ContainerFactory.Create(new MicroExport("Contract", "Parent"));\r
1273             var child = ContainerFactory.Create(parent);\r
1274 \r
1275             var export = child.GetExport<string>("Contract");\r
1276 \r
1277             Assert.AreEqual("Parent", export.Value);\r
1278         }\r
1279 \r
1280         [TestMethod]\r
1281         public void GetExportOfTTMetadataView1_AskingForContractFromChildWithExportInParentContainer_ShouldReturnExport()\r
1282         {\r
1283             var parent = ContainerFactory.Create(new MicroExport(typeof(string), "Parent"));\r
1284             var child = ContainerFactory.Create(parent);\r
1285 \r
1286             var export = child.GetExport<string, object>();\r
1287 \r
1288             Assert.AreEqual("Parent", export.Value);\r
1289         }\r
1290 \r
1291         [TestMethod]\r
1292         public void GetExportOfTTMetadataView2_AskingForContractFromChildWithExportInParentContainer_ShouldReturnExport()\r
1293         {\r
1294             var parent = ContainerFactory.Create(new MicroExport("Contract", "Parent"));\r
1295             var child = ContainerFactory.Create(parent);\r
1296 \r
1297             var export = child.GetExport<string, object>("Contract");\r
1298 \r
1299             Assert.AreEqual("Parent", export.Value);\r
1300         }\r
1301 \r
1302         [TestMethod]\r
1303         public void GetExports1_AskingForExactlyOneContractFromChildWithExportInParentContainer_ShouldReturnExport()\r
1304         {\r
1305             var parent = ContainerFactory.Create(new MicroExport("Contract", "Parent"));\r
1306             var child = ContainerFactory.Create(parent);\r
1307 \r
1308             var definition = ImportDefinitionFactory.Create("Contract", ImportCardinality.ExactlyOne);\r
1309 \r
1310             var exports = child.GetExports(definition);\r
1311 \r
1312             ExportsAssert.AreEqual(exports, "Parent");\r
1313         }\r
1314 \r
1315         [TestMethod]\r
1316         public void GetExports1_AskingForZeroOrOneContractFromChildWithExportInParentContainer_ShouldReturnExport()\r
1317         {\r
1318             var parent = ContainerFactory.Create(new MicroExport("Contract", "Parent"));\r
1319             var child = ContainerFactory.Create(parent);\r
1320 \r
1321             var definition = ImportDefinitionFactory.Create("Contract", ImportCardinality.ZeroOrOne);\r
1322 \r
1323             var exports = child.GetExports(definition);\r
1324 \r
1325             ExportsAssert.AreEqual(exports, "Parent");\r
1326         }\r
1327 \r
1328         [TestMethod]\r
1329         public void GetExports1_AskingForZeroOrMoreContractFromChildWithExportInParentContainer_ShouldReturnExport()\r
1330         {\r
1331             var parent = ContainerFactory.Create(new MicroExport("Contract", "Parent"));\r
1332             var child = ContainerFactory.Create(parent);\r
1333 \r
1334             var definition = ImportDefinitionFactory.Create("Contract", ImportCardinality.ZeroOrMore);\r
1335 \r
1336             var exports = child.GetExports(definition);\r
1337 \r
1338             ExportsAssert.AreEqual(exports, "Parent");\r
1339         }\r
1340 \r
1341         [TestMethod]\r
1342         public void GetExports2_AskingForContractFromChildWithExportInParentContainer_ShouldReturnExport()\r
1343         {\r
1344             var parent = ContainerFactory.Create(new MicroExport("Contract", "Parent"));\r
1345             var child = ContainerFactory.Create(parent);\r
1346 \r
1347             var exports = child.GetExports(typeof(string), (Type)null, "Contract");\r
1348 \r
1349             ExportsAssert.AreEqual(exports, "Parent");\r
1350         }\r
1351 \r
1352         [TestMethod]\r
1353         public void GetExportsOfT1_AskingForContractFromChildWithExportInParentContainer_ShouldReturnExport()\r
1354         {\r
1355             var parent = ContainerFactory.Create(new MicroExport(typeof(string), "Parent"));\r
1356             var child = ContainerFactory.Create(parent);\r
1357 \r
1358             var exports = child.GetExports<string>();\r
1359 \r
1360             ExportsAssert.AreEqual(exports, "Parent");\r
1361         }\r
1362 \r
1363         [TestMethod]\r
1364         public void GetExportsOfT2_AskingForContractFromChildWithExportInParentContainer_ShouldReturnExport()\r
1365         {\r
1366             var parent = ContainerFactory.Create(new MicroExport("Contract", "Parent"));\r
1367             var child = ContainerFactory.Create(parent);\r
1368 \r
1369             var exports = child.GetExports<string>("Contract");\r
1370 \r
1371             ExportsAssert.AreEqual(exports, "Parent");\r
1372         }\r
1373 \r
1374         [TestMethod]\r
1375         public void GetExportsOfTTMetadataView1_AskingForContractFromChildWithExportInParentContainer_ShouldReturnExport()\r
1376         {\r
1377             var parent = ContainerFactory.Create(new MicroExport(typeof(string), "Parent"));\r
1378             var child = ContainerFactory.Create(parent);\r
1379 \r
1380             var exports = child.GetExports<string, object>();\r
1381 \r
1382             ExportsAssert.AreEqual(exports, "Parent");\r
1383         }\r
1384 \r
1385         [TestMethod]\r
1386         public void GetExportsOfTTMetadataView2_AskingForContractFromChildWithExportInParentContainer_ShouldReturnExport()\r
1387         {\r
1388             var parent = ContainerFactory.Create(new MicroExport("Contract", "Parent"));\r
1389             var child = ContainerFactory.Create(parent);\r
1390 \r
1391             var exports = child.GetExports<string, object>("Contract");\r
1392 \r
1393             ExportsAssert.AreEqual(exports, "Parent");            \r
1394         }\r
1395 \r
1396         [TestMethod]\r
1397         public void GetExportedValueOfT1_AskingForContractFromChildWithExportInParentContainer_ShouldReturnExport()\r
1398         {\r
1399             var parent = ContainerFactory.Create(new MicroExport(typeof(string), "Parent"));\r
1400             var child = ContainerFactory.Create(parent);\r
1401 \r
1402             var exportedValue = child.GetExportedValue<string>();\r
1403 \r
1404             Assert.AreEqual("Parent", exportedValue);\r
1405         }\r
1406 \r
1407         [TestMethod]\r
1408         public void GetExportedValueOfT2_AskingForContractFromChildWithExportInParentContainer_ShouldReturnExport()\r
1409         {\r
1410             var parent = ContainerFactory.Create(new MicroExport("Contract", "Parent"));\r
1411             var child = ContainerFactory.Create(parent);\r
1412 \r
1413             var exportedValue = child.GetExportedValue<string>("Contract");\r
1414 \r
1415             Assert.AreEqual("Parent", exportedValue);\r
1416         }\r
1417 \r
1418         [TestMethod]\r
1419         public void GetExportedValueOrDefaultOfT1_AskingForContractFromChildWithExportInParentContainer_ShouldReturnExport()\r
1420         {\r
1421             var parent = ContainerFactory.Create(new MicroExport(typeof(string), "Parent"));\r
1422             var child = ContainerFactory.Create(parent);\r
1423 \r
1424             var exportedValue = child.GetExportedValueOrDefault<string>();\r
1425 \r
1426             Assert.AreEqual("Parent", exportedValue);\r
1427         }\r
1428 \r
1429         [TestMethod]\r
1430         public void GetExportedValueOrDefaultOfT2_AskingForContractFromChildWithExportInParentContainer_ShouldReturnExport()\r
1431         {\r
1432             var parent = ContainerFactory.Create(new MicroExport("Contract", "Parent"));\r
1433             var child = ContainerFactory.Create(parent);\r
1434 \r
1435             var exportedValue = child.GetExportedValueOrDefault<string>("Contract");\r
1436 \r
1437             Assert.AreEqual("Parent", exportedValue);\r
1438         }\r
1439 \r
1440         [TestMethod]\r
1441         public void GetExportedValuesOfT1_AskingForContractFromChildWithExportInParentContainer_ShouldReturnExport()\r
1442         {\r
1443             var parent = ContainerFactory.Create(new MicroExport(typeof(string), "Parent"));\r
1444             var child = ContainerFactory.Create(parent);\r
1445 \r
1446             var exportedValues = child.GetExportedValues<string>();\r
1447 \r
1448             EnumerableAssert.AreEqual(exportedValues, "Parent");\r
1449         }\r
1450 \r
1451         [TestMethod]\r
1452         public void GetExportedValuesOfT2_AskingForContractFromChildWithExportInParentContainer_ShouldReturnExport()\r
1453         {\r
1454             var parent = ContainerFactory.Create(new MicroExport("Contract", "Parent"));\r
1455             var child = ContainerFactory.Create(parent);\r
1456 \r
1457             var exportedValues = child.GetExportedValues<string>("Contract");\r
1458 \r
1459             EnumerableAssert.AreEqual(exportedValues, "Parent");\r
1460         }\r
1461 \r
1462         [TestMethod]\r
1463         public void GetExportOfT1_AskingForContractWithExportInBothParentAndChildContainers_ShouldReturnChildExport()\r
1464         {\r
1465             var parent = ContainerFactory.Create(new MicroExport(typeof(string), "Parent"));\r
1466             var child = ContainerFactory.Create(parent, new MicroExport(typeof(string), "Child"));\r
1467 \r
1468             var export = child.GetExport<string>();\r
1469 \r
1470             Assert.AreEqual("Child", export.Value);\r
1471         }\r
1472 \r
1473         [TestMethod]\r
1474         public void GetExportOfT2_AskingForContractWithExportInBothParentAndChildContainers_ShouldReturnChildExport()\r
1475         {\r
1476             var parent = ContainerFactory.Create(new MicroExport("Contract", "Parent"));\r
1477             var child = ContainerFactory.Create(parent, new MicroExport("Contract", "Child"));\r
1478 \r
1479             var export = child.GetExport<string>("Contract");\r
1480 \r
1481             Assert.AreEqual("Child", export.Value);\r
1482         }\r
1483 \r
1484         [TestMethod]\r
1485         public void GetExportOfTTMetadataView1_AskingForContractWithExportInBothParentAndChildContainers_ShouldReturnChildExport()\r
1486         {\r
1487             var parent = ContainerFactory.Create(new MicroExport(typeof(string), "Parent"));\r
1488             var child = ContainerFactory.Create(parent, new MicroExport(typeof(string), "Child"));\r
1489 \r
1490             var export = child.GetExport<string, object>();\r
1491 \r
1492             Assert.AreEqual("Child", export.Value);\r
1493         }\r
1494 \r
1495         [TestMethod]\r
1496         public void GetExportOfTTMetadataView2_AskingForContractWithExportInBothParentAndChildContainers_ShouldReturnChildExport()\r
1497         {\r
1498             var parent = ContainerFactory.Create(new MicroExport("Contract", "Parent"));\r
1499             var child = ContainerFactory.Create(parent, new MicroExport("Contract", "Child"));\r
1500 \r
1501             var export = child.GetExport<string, object>("Contract");\r
1502 \r
1503             Assert.AreEqual("Child", export.Value);\r
1504         }\r
1505 \r
1506         [TestMethod]\r
1507         public void GetExports1_AskingForExactlyOneContractWithExportInBothParentAndChildContainers_ShouldReturnChildExport()\r
1508         {\r
1509             var parent = ContainerFactory.Create(new MicroExport("Contract", "Parent"));\r
1510             var child = ContainerFactory.Create(parent, new MicroExport("Contract", "Child"));\r
1511 \r
1512             var definition = ImportDefinitionFactory.Create("Contract", ImportCardinality.ExactlyOne);\r
1513 \r
1514             var exports = child.GetExports(definition);\r
1515 \r
1516             ExportsAssert.AreEqual(exports, "Child");\r
1517         }\r
1518 \r
1519         [TestMethod]\r
1520         public void GetExports1_AskingForZeroOrOneContractWithExportInBothParentAndChildContainers_ShouldReturnChildExport()\r
1521         {\r
1522             var parent = ContainerFactory.Create(new MicroExport("Contract", "Parent"));\r
1523             var child = ContainerFactory.Create(parent, new MicroExport("Contract", "Child"));\r
1524 \r
1525             var definition = ImportDefinitionFactory.Create("Contract", ImportCardinality.ZeroOrOne);\r
1526 \r
1527             var exports = child.GetExports(definition);\r
1528 \r
1529             ExportsAssert.AreEqual(exports, "Child");\r
1530         }\r
1531 \r
1532         [TestMethod]\r
1533         public void GetExports1_AskingForZeroOrMoreContractWithExportInBothParentAndChildContainers_ShouldReturnBothExports()\r
1534         {\r
1535             var parent = ContainerFactory.Create(new MicroExport("Contract", "Parent"));\r
1536             var child = ContainerFactory.Create(parent, new MicroExport("Contract", "Child"));\r
1537 \r
1538             var definition = ImportDefinitionFactory.Create("Contract", ImportCardinality.ZeroOrMore);\r
1539 \r
1540             var exports = child.GetExports(definition);\r
1541 \r
1542             ExportsAssert.AreEqual(exports, "Child", "Parent");\r
1543         }\r
1544 \r
1545         [TestMethod]\r
1546         public void GetExports2_AskingForContractWithExportInBothParentAndChildContainers_ShouldReturnBothExports()\r
1547         {\r
1548             var parent = ContainerFactory.Create(new MicroExport("Contract", "Parent"));\r
1549             var child = ContainerFactory.Create(parent, new MicroExport("Contract", "Child"));\r
1550 \r
1551             var exports = child.GetExports(typeof(string), (Type)null, "Contract");\r
1552 \r
1553             ExportsAssert.AreEqual(exports, "Child", "Parent");\r
1554         }\r
1555 \r
1556         [TestMethod]\r
1557         public void GetExportsOfT1_AskingForContractWithExportInBothParentAndChildContainers_ShouldReturnBothExports()\r
1558         {\r
1559             var parent = ContainerFactory.Create(new MicroExport(typeof(string), "Parent"));\r
1560             var child = ContainerFactory.Create(parent, new MicroExport(typeof(string), "Child"));\r
1561 \r
1562             var exports = child.GetExports<string>();\r
1563 \r
1564             ExportsAssert.AreEqual(exports, "Child", "Parent");\r
1565         }\r
1566 \r
1567         [TestMethod]\r
1568         public void GetExportsOfT2_AskingForContractWithExportInBothParentAndChildContainers_ShouldReturnBothExports()\r
1569         {\r
1570             var parent = ContainerFactory.Create(new MicroExport("Contract", "Parent"));\r
1571             var child = ContainerFactory.Create(parent, new MicroExport("Contract", "Child"));\r
1572 \r
1573             var exports = child.GetExports<string>("Contract");\r
1574 \r
1575             ExportsAssert.AreEqual(exports, "Child", "Parent");\r
1576         }\r
1577 \r
1578         [TestMethod]\r
1579         public void GetExportsOfTTMetadataView1_AskingForContractWithExportInBothParentAndChildContainers_ShouldReturnBothExports()\r
1580         {\r
1581             var parent = ContainerFactory.Create(new MicroExport(typeof(string), "Parent"));\r
1582             var child = ContainerFactory.Create(parent, new MicroExport(typeof(string), "Child"));\r
1583 \r
1584 \r
1585             var exports = child.GetExports<string, object>();\r
1586 \r
1587             ExportsAssert.AreEqual(exports, "Child", "Parent");\r
1588         }\r
1589 \r
1590         [TestMethod]\r
1591         public void GetExportsOfTTMetadataView2_AskingForContractWithExportInBothParentAndChildContainers_ShouldReturnBothExports()\r
1592         {\r
1593             var parent = ContainerFactory.Create(new MicroExport("Contract", "Parent"));\r
1594             var child = ContainerFactory.Create(parent, new MicroExport("Contract", "Child"));\r
1595 \r
1596             var exports = child.GetExports<string, object>("Contract");\r
1597 \r
1598             ExportsAssert.AreEqual(exports, "Child", "Parent");\r
1599         }\r
1600 \r
1601         [TestMethod]\r
1602         public void GetExportedValueOfT1_AskingForContractWithExportInBothParentAndChildContainers_ShouldReturnChildExport()\r
1603         {\r
1604             var parent = ContainerFactory.Create(new MicroExport(typeof(string), "Parent"));\r
1605             var child = ContainerFactory.Create(parent, new MicroExport(typeof(string), "Child"));\r
1606 \r
1607             var exportedValue = child.GetExportedValue<string>();\r
1608 \r
1609             Assert.AreEqual("Child", exportedValue);\r
1610         }\r
1611 \r
1612         [TestMethod]\r
1613         public void GetExportedValueOfT2_AskingForContractWithExportInBothParentAndChildContainers_ShouldReturnChildExport()\r
1614         {\r
1615             var parent = ContainerFactory.Create(new MicroExport("Contract", "Parent"));\r
1616             var child = ContainerFactory.Create(parent, new MicroExport("Contract", "Child"));\r
1617 \r
1618             var exportedValue = child.GetExportedValue<string>("Contract");\r
1619 \r
1620             Assert.AreEqual("Child", exportedValue);\r
1621         }\r
1622 \r
1623         [TestMethod]\r
1624         public void GetExportedValueOrDefaultOfT1_AskingForContractWithExportInBothParentAndChildContainers_ShouldReturnChildExport()\r
1625         {\r
1626             var parent = ContainerFactory.Create(new MicroExport(typeof(string), "Parent"));\r
1627             var child = ContainerFactory.Create(parent, new MicroExport(typeof(string), "Child"));\r
1628 \r
1629             var exportedValue = child.GetExportedValueOrDefault<string>();\r
1630 \r
1631             Assert.AreEqual("Child", exportedValue);\r
1632         }\r
1633 \r
1634         [TestMethod]\r
1635         public void GetExportedValueOrDefaultOfT2_AskingForContractWithExportInBothParentAndChildContainers_ShouldReturnChildExport()\r
1636         {\r
1637             var parent = ContainerFactory.Create(new MicroExport("Contract", "Parent"));\r
1638             var child = ContainerFactory.Create(parent, new MicroExport("Contract", "Child"));\r
1639 \r
1640             var exportedValue = child.GetExportedValueOrDefault<string>("Contract");\r
1641 \r
1642             Assert.AreEqual("Child", exportedValue);\r
1643         }\r
1644 \r
1645         [TestMethod]\r
1646         public void GetExportedValuesOfT1_AskingForContractWithExportInBothParentAndChildContainers_ShouldReturnBothExports()\r
1647         {\r
1648             var parent = ContainerFactory.Create(new MicroExport(typeof(string), "Parent"));\r
1649             var child = ContainerFactory.Create(parent, new MicroExport(typeof(string), "Child"));\r
1650 \r
1651             var exportedValues = child.GetExportedValues<string>();\r
1652 \r
1653             EnumerableAssert.AreEqual(exportedValues, "Child", "Parent");\r
1654         }\r
1655 \r
1656         [TestMethod]\r
1657         public void GetExportedValuesOfT2_AskingForContractWithExportInBothParentAndChildContainers_ShouldReturnBothExports()\r
1658         {\r
1659             var parent = ContainerFactory.Create(new MicroExport("Contract", "Parent"));\r
1660             var child = ContainerFactory.Create(parent, new MicroExport("Contract", "Child"));\r
1661 \r
1662             var exportedValues = child.GetExportedValues<string>("Contract");\r
1663 \r
1664             EnumerableAssert.AreEqual(exportedValues, "Child", "Parent");\r
1665         }\r
1666 \r
1667         [TestMethod]\r
1668         public void GetExportOfTTMetadataView1_TypeAsMetadataViewTypeArgument_IsUsedAsMetadataConstraint()\r
1669         {\r
1670             var metadata = new Dictionary<string, object>();\r
1671             metadata.Add("Metadata1", "MetadataValue1");\r
1672             metadata.Add("Metadata2", "MetadataValue2");\r
1673             metadata.Add("Metadata3", "MetadataValue3");\r
1674 \r
1675             var container = ContainerFactory.Create(new MicroExport("Another",      metadata, "Value1"),\r
1676                                                     new MicroExport(typeof(string), metadata, "Value1"),\r
1677                                                     new MicroExport(typeof(string),           "Value2"));\r
1678 \r
1679             var export = container.GetExport<string, IMetadataView>();\r
1680             var metadataExport = (Lazy<string, IMetadataView>)export;\r
1681 \r
1682             Assert.AreEqual("Value1", metadataExport.Value);\r
1683             Assert.AreEqual("MetadataValue1", metadataExport.Metadata.Metadata1);\r
1684             Assert.AreEqual("MetadataValue2", metadataExport.Metadata.Metadata2);\r
1685             Assert.AreEqual("MetadataValue3", metadataExport.Metadata.Metadata3);\r
1686         }\r
1687 \r
1688         [TestMethod]\r
1689         public void GetExportOfTTMetadataView2_TypeAsMetadataViewTypeArgument_IsUsedAsMetadataConstraint()\r
1690         {\r
1691             var metadata = new Dictionary<string, object>();\r
1692             metadata.Add("Metadata1", "MetadataValue1");\r
1693             metadata.Add("Metadata2", "MetadataValue2");\r
1694             metadata.Add("Metadata3", "MetadataValue3");\r
1695 \r
1696             var container = ContainerFactory.Create(new MicroExport("Another", metadata, "Value1"),\r
1697                                                                      new MicroExport("Contract", metadata, "Value1"),\r
1698                                                                      new MicroExport("Contract", "Value2"));\r
1699 \r
1700             var export = container.GetExport<string, IMetadataView>("Contract");\r
1701             var metadataExport = (Lazy<string, IMetadataView>)export;\r
1702 \r
1703             Assert.AreEqual("Value1", metadataExport.Value);\r
1704             Assert.AreEqual("MetadataValue1", metadataExport.Metadata.Metadata1);\r
1705             Assert.AreEqual("MetadataValue2", metadataExport.Metadata.Metadata2);\r
1706             Assert.AreEqual("MetadataValue3", metadataExport.Metadata.Metadata3);\r
1707         }\r
1708 \r
1709         [TestMethod]\r
1710         public void GetExports1_TypeAsMetadataViewTypeArgument_IsUsedAsMetadataConstraint()\r
1711         {\r
1712             var metadata = new Dictionary<string, object>();\r
1713             metadata.Add("Metadata1", "MetadataValue1");\r
1714             metadata.Add("Metadata2", "MetadataValue2");\r
1715             metadata.Add("Metadata3", "MetadataValue3");\r
1716 \r
1717             var container = ContainerFactory.Create(new MicroExport("Another", metadata, "Value1"),\r
1718                                                                      new MicroExport("Contract", metadata, "Value1"),\r
1719                                                                      new MicroExport("Contract", "Value2"));\r
1720 \r
1721             var definition = ImportDefinitionFactory.Create(\r
1722                 "Contract",\r
1723                 new Dictionary<string, Type> { { "Metadata1", typeof(object) }, { "Metadata2", typeof(object) }, { "Metadata3", typeof(object) } }\r
1724                 );\r
1725 \r
1726             var exports = container.GetExports(definition);\r
1727 \r
1728             Assert.AreEqual(1, exports.Count());\r
1729 \r
1730             var export = exports.First();\r
1731 \r
1732             Assert.AreEqual("Value1", export.Value);\r
1733             EnumerableAssert.AreEqual(metadata, export.Metadata);\r
1734         }\r
1735 \r
1736         [TestMethod]\r
1737         public void GetExports2_TypeAsMetadataViewTypeArgument_IsUsedAsMetadataConstraint()\r
1738         {\r
1739             var metadata = new Dictionary<string, object>();\r
1740             metadata.Add("Metadata1", "MetadataValue1");\r
1741             metadata.Add("Metadata2", "MetadataValue2");\r
1742             metadata.Add("Metadata3", "MetadataValue3");\r
1743 \r
1744             var container = ContainerFactory.Create(new MicroExport("Another", metadata, "Value1"),\r
1745                                                                      new MicroExport("Contract", metadata, "Value1"),\r
1746                                                                      new MicroExport("Contract", "Value2"));\r
1747 \r
1748             var exports = container.GetExports(typeof(string), typeof(IMetadataView), "Contract");\r
1749 \r
1750             Assert.AreEqual(1, exports.Count());\r
1751 \r
1752             var export = exports.First();\r
1753             IMetadataView exportMetadata = export.Metadata as IMetadataView;\r
1754 \r
1755             Assert.AreEqual("Value1", export.Value);\r
1756             Assert.IsNotNull(exportMetadata);\r
1757 \r
1758             Assert.AreEqual("MetadataValue1", exportMetadata.Metadata1);\r
1759             Assert.AreEqual("MetadataValue2", exportMetadata.Metadata2);\r
1760             Assert.AreEqual("MetadataValue3", exportMetadata.Metadata3);\r
1761         }\r
1762 \r
1763         [TestMethod]\r
1764         public void GetExportsOfTTMetadataView1_TypeAsMetadataViewTypeArgument_IsUsedAsMetadataConstraint()\r
1765         {\r
1766             var metadata = new Dictionary<string, object>();\r
1767             metadata.Add("Metadata1", "MetadataValue1");\r
1768             metadata.Add("Metadata2", "MetadataValue2");\r
1769             metadata.Add("Metadata3", "MetadataValue3");\r
1770 \r
1771             var container = ContainerFactory.Create(new MicroExport("Another", metadata, "Value1"),\r
1772                                                                      new MicroExport(typeof(string), metadata, "Value1"),\r
1773                                                                      new MicroExport(typeof(string), "Value2"));\r
1774 \r
1775             var exports = container.GetExports<string, IMetadataView>();\r
1776 \r
1777             Assert.AreEqual(1, exports.Count());\r
1778 \r
1779             var export = (Lazy<string, IMetadataView>)exports.First();\r
1780 \r
1781             Assert.AreEqual("Value1", export.Value);\r
1782             Assert.AreEqual("MetadataValue1", export.Metadata.Metadata1);\r
1783             Assert.AreEqual("MetadataValue2", export.Metadata.Metadata2);\r
1784             Assert.AreEqual("MetadataValue3", export.Metadata.Metadata3);\r
1785         }\r
1786 \r
1787         [TestMethod]\r
1788         public void GetExportsOfTTMetadataView2_TypeAsMetadataViewTypeArgument_IsUsedAsMetadataConstraint()\r
1789         {\r
1790             var metadata = new Dictionary<string, object>();\r
1791             metadata.Add("Metadata1", "MetadataValue1");\r
1792             metadata.Add("Metadata2", "MetadataValue2");\r
1793             metadata.Add("Metadata3", "MetadataValue3");\r
1794 \r
1795             var container = ContainerFactory.Create(new MicroExport("Another", metadata, "Value1"),\r
1796                                                                      new MicroExport("Contract", metadata, "Value1"),\r
1797                                                                      new MicroExport("Contract", "Value2"));\r
1798 \r
1799             var exports = container.GetExports<string, IMetadataView>("Contract");\r
1800 \r
1801             Assert.AreEqual(1, exports.Count());\r
1802 \r
1803             var export = (Lazy<string, IMetadataView>)exports.First();\r
1804 \r
1805             Assert.AreEqual("Value1", export.Value);\r
1806             Assert.AreEqual("MetadataValue1", export.Metadata.Metadata1);\r
1807             Assert.AreEqual("MetadataValue2", export.Metadata.Metadata2);\r
1808             Assert.AreEqual("MetadataValue3", export.Metadata.Metadata3);\r
1809         }\r
1810 \r
1811 \r
1812         [TestMethod]\r
1813         public void GetExports1_AskingForExactlyOneAndAllWhenContainerEmpty_ShouldThrowCardinalityMismatch()\r
1814         {\r
1815             var container = CreateCompositionContainer();\r
1816 \r
1817             var definition = ImportDefinitionFactory.Create(export => true, ImportCardinality.ExactlyOne);\r
1818 \r
1819             ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>\r
1820             {\r
1821                 container.GetExports(definition);\r
1822             });\r
1823         }\r
1824 \r
1825         [TestMethod]\r
1826         public void GetExports1_AskingForZeroOrOneAndAllWhenContainerEmpty_ShouldReturnEmpty()\r
1827         {\r
1828             var container = CreateCompositionContainer();\r
1829 \r
1830             var definition = ImportDefinitionFactory.Create(export => true, ImportCardinality.ZeroOrOne);\r
1831 \r
1832             var exports = container.GetExports(definition);\r
1833 \r
1834             EnumerableAssert.IsEmpty(exports);\r
1835         }\r
1836 \r
1837         [TestMethod]\r
1838         public void GetExports1_AskingForExactlyOneAndAllWhenContainerEmpty_ShouldReturnEmpty()\r
1839         {\r
1840             var container = CreateCompositionContainer();\r
1841 \r
1842             var definition = ImportDefinitionFactory.Create(export => true, ImportCardinality.ZeroOrMore);\r
1843 \r
1844             var exports = container.GetExports(definition);\r
1845 \r
1846             EnumerableAssert.IsEmpty(exports);\r
1847         }\r
1848 \r
1849         [TestMethod]\r
1850         [Ignore]\r
1851         [WorkItem(465976)]\r
1852         public void RemovePart_PartNotInContainerAsPartArgument_ShouldNotCauseImportsToBeRebound()\r
1853         {\r
1854             const string contractName = "Contract";\r
1855 \r
1856             var exporter = PartFactory.CreateExporter(new MicroExport(contractName, 1));\r
1857             var importer = PartFactory.CreateImporter(contractName);\r
1858             var container = ContainerFactory.Create(exporter, importer);\r
1859 \r
1860 \r
1861             Assert.AreEqual(1, importer.Value);\r
1862             Assert.AreEqual(1, importer.ImportSatisfiedCount);\r
1863 \r
1864             var doesNotExistInContainer = PartFactory.CreateExporter(new MicroExport(contractName, 2));\r
1865 \r
1866             CompositionBatch batch = new CompositionBatch();\r
1867             batch.RemovePart(doesNotExistInContainer);\r
1868             container.Compose(batch);\r
1869 \r
1870             Assert.AreEqual(1, importer.ImportSatisfiedCount);\r
1871         }\r
1872 \r
1873         [TestMethod]\r
1874         [Ignore]\r
1875         [WorkItem(436847)]\r
1876         public void RemovePart_PartInContainerQueueAsPartArgument_ShouldNotLeavePartInContainer()\r
1877         {\r
1878             const string contractName = "Contract";\r
1879 \r
1880             var exporter = PartFactory.CreateExporter(new MicroExport(contractName, 1));\r
1881             var importer = PartFactory.CreateImporter(contractName);\r
1882             var container = ContainerFactory.Create(exporter, importer);\r
1883 \r
1884             CompositionBatch batch = new CompositionBatch();\r
1885             batch.RemovePart(exporter);\r
1886             container.Compose(batch);\r
1887 \r
1888             Assert.IsNull(importer.Value);\r
1889             Assert.AreEqual(2, importer.ImportSatisfiedCount);\r
1890         }\r
1891 \r
1892         [TestMethod]\r
1893         public void RemovePart_PartAlreadyRemovedAsPartArgument_ShouldNotThrow()\r
1894         {\r
1895             var exporter = PartFactory.CreateExporter(new MicroExport("Contract", 1));\r
1896             var container = ContainerFactory.Create(exporter);\r
1897 \r
1898             Assert.AreEqual(1, container.GetExportedValue<int>("Contract"));\r
1899 \r
1900             CompositionBatch batch = new CompositionBatch();\r
1901             batch.RemovePart(exporter);\r
1902             container.Compose(batch);\r
1903 \r
1904             Assert.IsFalse(container.IsPresent("Contract"));\r
1905 \r
1906             batch = new CompositionBatch();\r
1907             batch.RemovePart(exporter);\r
1908             container.Compose(batch);\r
1909 \r
1910             Assert.IsFalse(container.IsPresent("Contract"));\r
1911         }\r
1912 \r
1913         [TestMethod]\r
1914         public void TryComposeSimple()\r
1915         {\r
1916             var container = CreateCompositionContainer();\r
1917             Int32Importer importer = new Int32Importer();\r
1918 \r
1919             CompositionBatch batch = new CompositionBatch();\r
1920             batch.AddParts(importer, new Int32Exporter(42));\r
1921             container.Compose(batch);\r
1922 \r
1923             Assert.AreEqual(42, importer.Value, "Expected value imported from export");\r
1924         }\r
1925 \r
1926         [TestMethod]\r
1927         public void TryComposeSimpleFail()\r
1928         {\r
1929             var container = CreateCompositionContainer();\r
1930             Int32Importer importer = new Int32Importer();\r
1931 \r
1932             CompositionBatch batch = new CompositionBatch();\r
1933             batch.AddParts(importer);\r
1934 \r
1935             CompositionAssert.ThrowsChangeRejectedError(ErrorId.ImportEngine_PartCannotSetImport, ErrorId.ImportEngine_ImportCardinalityMismatch, RetryMode.DoNotRetry, () =>\r
1936             {\r
1937                 container.Compose(batch);\r
1938             });\r
1939 \r
1940             Assert.AreEqual(0, importer.Value, "Expected default value to remain");\r
1941         }\r
1942 \r
1943         [TestMethod]\r
1944         public void ComposeDisposableChildContainer()\r
1945         {\r
1946             var outerContainer = CreateCompositionContainer();\r
1947             Int32Importer outerImporter = new Int32Importer();\r
1948 \r
1949             CompositionBatch outerBatch = new CompositionBatch();\r
1950             var key = outerBatch.AddExportedValue("Value", 42);\r
1951             outerBatch.AddPart(outerImporter);\r
1952             outerContainer.Compose(outerBatch);\r
1953             Assert.AreEqual(42, outerImporter.Value, "Expected value imported from export");\r
1954 \r
1955             Int32Importer innerImporter = new Int32Importer();\r
1956             var innerContainer = new CompositionContainer(outerContainer);\r
1957             CompositionBatch innerBatch = new CompositionBatch();\r
1958             innerBatch.AddPart(innerImporter);\r
1959 \r
1960             innerContainer.Compose(innerBatch);\r
1961             Assert.AreEqual(42, innerImporter.Value, "Expected value imported from export");\r
1962             Assert.AreEqual(42, outerImporter.Value, "Expected value imported from export");\r
1963 \r
1964             outerBatch = new CompositionBatch();\r
1965             outerBatch.RemovePart(key);\r
1966             key = outerBatch.AddExportedValue("Value", -5);\r
1967             outerContainer.Compose(outerBatch);\r
1968             Assert.AreEqual(-5, innerImporter.Value, "Expected update value imported from export");\r
1969             Assert.AreEqual(-5, outerImporter.Value, "Expected updated value imported from export");\r
1970 \r
1971             innerContainer.Dispose();\r
1972             outerBatch = new CompositionBatch();\r
1973             outerBatch.RemovePart(key);\r
1974             key = outerBatch.AddExportedValue("Value", 500);\r
1975             outerContainer.Compose(outerBatch);\r
1976             Assert.AreEqual(500, outerImporter.Value, "Expected updated value imported from export");\r
1977             Assert.AreEqual(-5, innerImporter.Value, "Expected value not updated");\r
1978         }\r
1979 \r
1980         [TestMethod]\r
1981         public void RemoveValueTest()\r
1982         {\r
1983             var container = CreateCompositionContainer();\r
1984             CompositionBatch batch = new CompositionBatch();\r
1985 \r
1986             var key = batch.AddExportedValue("foo", "hello");\r
1987             container.Compose(batch);\r
1988             var result = container.GetExportedValue<string>("foo");\r
1989             Assert.AreEqual("hello", result, "Should get the correct value");\r
1990 \r
1991             batch = new CompositionBatch();\r
1992             batch.RemovePart(key);\r
1993             container.Compose(batch);\r
1994 \r
1995             Assert.IsFalse(container.IsPresent("foo"));\r
1996 \r
1997             batch = new CompositionBatch();\r
1998             batch.RemovePart(key);        // Remove should be idempotent\r
1999             container.Compose(batch);\r
2000         }\r
2001 \r
2002         [TestMethod]\r
2003         [TestProperty("Type", "Integration")]\r
2004         public void OptionalImportsOfValueTypeBoundToDefaultValueShouldNotAffectAvailableValues()\r
2005         {\r
2006             var container = CreateCompositionContainer();\r
2007             var importer = new OptionalImporter();\r
2008 \r
2009             CompositionBatch batch = new CompositionBatch();\r
2010             batch.AddPart(importer);\r
2011             container.Compose(batch);\r
2012 \r
2013             Assert.AreEqual(0, importer.ValueType);\r
2014 \r
2015             ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>\r
2016             {\r
2017                 container.GetExportedValue<int>("ValueType");\r
2018             });\r
2019         }\r
2020 \r
2021         [TestMethod]\r
2022         [TestProperty("Type", "Integration")]\r
2023         public void OptionalImportsOfNullableValueTypeBoundToDefaultValueShouldNotAffectAvailableValues()\r
2024         {\r
2025             var container = CreateCompositionContainer();\r
2026             var importer = new OptionalImporter();\r
2027 \r
2028             CompositionBatch batch = new CompositionBatch();\r
2029             batch.AddPart(importer);\r
2030             container.Compose(batch);\r
2031 \r
2032             Assert.IsNull(importer.NullableValueType);\r
2033 \r
2034             ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>\r
2035             {\r
2036                 container.GetExportedValue<int>("NullableValueType");\r
2037             });\r
2038         }\r
2039 \r
2040         [TestMethod]\r
2041         [TestProperty("Type", "Integration")]\r
2042         public void OptionalImportsOfReferenceTypeBoundToDefaultValueShouldNotAffectAvailableValues()\r
2043         {\r
2044             var container = CreateCompositionContainer();\r
2045             var importer = new OptionalImporter();\r
2046 \r
2047             CompositionBatch batch = new CompositionBatch();\r
2048             batch.AddPart(importer);\r
2049             container.Compose(batch);\r
2050 \r
2051             Assert.IsNull(importer.ReferenceType);\r
2052 \r
2053             ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>\r
2054             {\r
2055                 container.GetExportedValue<int>("ReferenceType");\r
2056             });            \r
2057         }\r
2058 \r
2059         [TestMethod]\r
2060         public void ExportsChanged_ExportNothing_ShouldNotFireExportsChanged()\r
2061         {\r
2062             var container = CreateCompositionContainer();\r
2063 \r
2064             container.ExportsChanged += (sender, args) =>\r
2065             {\r
2066                 Assert.Fail("Event should not be fired!");\r
2067             };\r
2068 \r
2069             CompositionBatch batch = new CompositionBatch();\r
2070             container.Compose(batch);\r
2071         }\r
2072 \r
2073         [TestMethod]\r
2074         public void ExportsChanged_ExportAdded_ShouldFireExportsChanged()\r
2075         {\r
2076             var container = CreateCompositionContainer();\r
2077             IEnumerable<string> changedNames = null;\r
2078 \r
2079             container.ExportsChanged += (sender, args) =>\r
2080             {\r
2081                 Assert.AreSame(container, sender);\r
2082                 Assert.IsNull(changedNames, "Ensure this event only fires once!");\r
2083                 Assert.IsNotNull(args.AddedExports);\r
2084                 Assert.IsNotNull(args.RemovedExports);\r
2085                 Assert.IsNotNull(args.ChangedContractNames);\r
2086                 changedNames = args.ChangedContractNames;\r
2087             };\r
2088 \r
2089             CompositionBatch batch = new CompositionBatch();\r
2090             batch.AddExportedValue("MyExport", new object());\r
2091             container.Compose(batch);\r
2092 \r
2093             EnumerableAssert.AreEqual(changedNames, "MyExport");\r
2094         }\r
2095 \r
2096         [TestMethod]\r
2097         public void ExportsChanged_ExportRemoved_ShouldFireExportsChanged()\r
2098         {\r
2099             var container = CreateCompositionContainer();\r
2100             IEnumerable<string> changedNames = null;\r
2101 \r
2102             CompositionBatch batch = new CompositionBatch();\r
2103             var part = batch.AddExportedValue("MyExport", new object());\r
2104             container.Compose(batch);\r
2105 \r
2106             container.ExportsChanged += (sender, args) =>\r
2107             {\r
2108                 Assert.AreSame(container, sender);\r
2109                 Assert.IsNull(changedNames, "Ensure this event only fires once!");\r
2110                 Assert.IsNotNull(args.AddedExports);\r
2111                 Assert.IsNotNull(args.RemovedExports);\r
2112                 Assert.IsNotNull(args.ChangedContractNames);\r
2113                 changedNames = args.ChangedContractNames;\r
2114             };\r
2115 \r
2116             batch = new CompositionBatch();\r
2117             batch.RemovePart(part);\r
2118             container.Compose(batch);\r
2119 \r
2120             EnumerableAssert.AreEqual(changedNames, "MyExport");\r
2121         }\r
2122 \r
2123         [TestMethod]\r
2124         public void ExportsChanged_ExportAddAnother_ShouldFireExportsChanged()\r
2125         {\r
2126             var container = CreateCompositionContainer();\r
2127             IEnumerable<string> changedNames = null;\r
2128 \r
2129             CompositionBatch batch = new CompositionBatch();\r
2130             batch.AddExportedValue("MyExport", new object());\r
2131             container.Compose(batch);\r
2132 \r
2133             container.ExportsChanged += (sender, args) =>\r
2134             {\r
2135                 Assert.AreSame(container, sender);\r
2136                 Assert.IsNull(changedNames, "Ensure this event only fires once!");\r
2137                 Assert.IsNotNull(args.AddedExports);\r
2138                 Assert.IsNotNull(args.RemovedExports);\r
2139                 Assert.IsNotNull(args.ChangedContractNames);\r
2140                 changedNames = args.ChangedContractNames;\r
2141             };\r
2142 \r
2143             batch = new CompositionBatch();\r
2144             // Adding another should cause an update.\r
2145             batch.AddExportedValue("MyExport", new object());\r
2146             container.Compose(batch);\r
2147 \r
2148 \r
2149             EnumerableAssert.AreEqual(changedNames, "MyExport");\r
2150         }\r
2151 \r
2152         [TestMethod]\r
2153         public void ExportsChanged_AddExportOnParent_ShouldFireExportsChangedOnBoth()\r
2154         {\r
2155             var parent = CreateCompositionContainer();\r
2156             var child = new CompositionContainer(parent);\r
2157 \r
2158             IEnumerable<string> parentNames = null;\r
2159             parent.ExportsChanged += (sender, args) =>\r
2160             {\r
2161                 Assert.AreSame(parent, sender);\r
2162                 parentNames = args.ChangedContractNames;\r
2163             };\r
2164 \r
2165             IEnumerable<string> childNames = null;\r
2166             child.ExportsChanged += (sender, args) =>\r
2167             {\r
2168                 Assert.AreSame(child, sender);\r
2169                 childNames = args.ChangedContractNames;\r
2170             };\r
2171 \r
2172             CompositionBatch batch = new CompositionBatch();\r
2173             batch.AddExportedValue("MyExport", new object());\r
2174             parent.Compose(batch);\r
2175 \r
2176             EnumerableAssert.AreEqual(parentNames, "MyExport");\r
2177             EnumerableAssert.AreEqual(childNames, "MyExport");\r
2178         }\r
2179 \r
2180 \r
2181         [TestMethod]\r
2182         public void ExportsChanged_AddExportOnChild_ShouldFireExportsChangedOnChildOnly()\r
2183         {\r
2184             var parent = CreateCompositionContainer();\r
2185             var child = new CompositionContainer(parent);\r
2186 \r
2187             parent.ExportsChanged += (sender, args) =>\r
2188             {\r
2189                 Assert.Fail("Should not fire on parent container!!");\r
2190             };\r
2191 \r
2192             IEnumerable<string> childNames = null;\r
2193             child.ExportsChanged += (sender, args) =>\r
2194             {\r
2195                 Assert.AreSame(child, sender);\r
2196                 childNames = args.ChangedContractNames;\r
2197             };\r
2198 \r
2199             CompositionBatch batch = new CompositionBatch();\r
2200             batch.AddExportedValue("MyExport2", new object());\r
2201             child.Compose(batch);\r
2202 \r
2203             EnumerableAssert.AreEqual(childNames, "MyExport2");\r
2204         }\r
2205 \r
2206 \r
2207         [TestMethod]\r
2208         public void Dispose_BeforeCompose_CanBeCallMultipleTimes()\r
2209         {\r
2210             var container = ContainerFactory.Create(PartFactory.Create(), PartFactory.Create());\r
2211             container.Dispose();\r
2212             container.Dispose();\r
2213             container.Dispose();\r
2214         }\r
2215 \r
2216         [TestMethod]\r
2217         public void Dispose_AfterCompose_CanBeCallMultipleTimes()\r
2218         {\r
2219             var container = ContainerFactory.Create(PartFactory.Create(), PartFactory.Create());\r
2220             container.Dispose();\r
2221             container.Dispose();\r
2222             container.Dispose();\r
2223         }\r
2224 \r
2225         [TestMethod]\r
2226         public void Dispose_CallsGCSuppressFinalize()\r
2227         {\r
2228             bool finalizerCalled = false;\r
2229 \r
2230             var container = ContainerFactory.CreateDisposable(disposing =>\r
2231             {\r
2232                 if (!disposing)\r
2233                 {\r
2234                     finalizerCalled = true;\r
2235                 }\r
2236 \r
2237             });\r
2238 \r
2239             container.Dispose();\r
2240 \r
2241             GC.Collect();\r
2242             GC.WaitForPendingFinalizers();\r
2243             GC.Collect();\r
2244 \r
2245             Assert.IsFalse(finalizerCalled);\r
2246         }\r
2247 \r
2248         [TestMethod]\r
2249         public void Dispose_CallsDisposeBoolWithTrue()\r
2250         {\r
2251             var container = ContainerFactory.CreateDisposable(disposing =>\r
2252             {\r
2253                 Assert.IsTrue(disposing);\r
2254             });\r
2255 \r
2256             container.Dispose();\r
2257         }\r
2258 \r
2259         [TestMethod]\r
2260         public void Dispose_CallsDisposeBoolOnce()\r
2261         {\r
2262             int disposeCount = 0;\r
2263 \r
2264             var container = ContainerFactory.CreateDisposable(disposing =>\r
2265             {\r
2266                 disposeCount++;\r
2267             });\r
2268 \r
2269             container.Dispose();\r
2270 \r
2271             Assert.AreEqual(1, disposeCount);\r
2272         }\r
2273 \r
2274         [TestMethod]\r
2275         public void Dispose_ContainerAsExportedValue_CanBeDisposed()\r
2276         {\r
2277             using (var container = CreateCompositionContainer())\r
2278             {\r
2279                 CompositionBatch batch = new CompositionBatch();\r
2280                 batch.AddExportedValue<ICompositionService>(container);\r
2281                 container.Compose(batch);\r
2282             }\r
2283         }\r
2284 \r
2285         [TestMethod]\r
2286         public void Dispose_ContainerAsPart_CanBeDisposed()\r
2287         {   // Tests that when we re-enter CompositionContainer.Dispose, that we don't\r
2288             // stack overflow.\r
2289 \r
2290             using (var container = CreateCompositionContainer())\r
2291             {\r
2292                 var part = PartFactory.CreateExporter(new MicroExport(typeof(ICompositionService), container));\r
2293                 CompositionBatch batch = new CompositionBatch();\r
2294                 batch.AddPart(part);\r
2295                 container.Compose(batch);\r
2296 \r
2297                 Assert.AreSame(container, container.GetExportedValue<ICompositionService>());\r
2298             }\r
2299         }\r
2300 \r
2301         [TestMethod]\r
2302         public void ICompositionService_ShouldNotBeImplicitlyExported()\r
2303         {\r
2304             var container = CreateCompositionContainer();\r
2305 \r
2306             Assert.IsFalse(container.IsPresent<ICompositionService>());\r
2307         }\r
2308 \r
2309         [TestMethod]\r
2310         public void CompositionContainer_ShouldNotBeImplicitlyExported()\r
2311         {\r
2312             var container = CreateCompositionContainer();\r
2313 \r
2314             Assert.IsFalse(container.IsPresent<CompositionContainer>());\r
2315         }\r
2316 \r
2317         [TestMethod]\r
2318         public void ICompositionService_ShouldNotBeImplicitlyImported()\r
2319         {\r
2320             var importer = PartFactory.CreateImporter<ICompositionService>();\r
2321             var container = ContainerFactory.Create(importer);\r
2322 \r
2323             Assert.IsNull(importer.Value);\r
2324         }\r
2325 \r
2326         [TestMethod]\r
2327         public void CompositionContainer_ShouldNotBeImplicitlyImported()\r
2328         {\r
2329             var importer = PartFactory.CreateImporter<CompositionContainer>();\r
2330             var container = ContainerFactory.Create(importer);\r
2331 \r
2332             Assert.IsNull(importer.Value);\r
2333         }\r
2334 \r
2335         [TestMethod]\r
2336         public void ICompositionService_CanBeExported()\r
2337         {\r
2338             var container = CreateCompositionContainer();\r
2339             CompositionBatch batch = new CompositionBatch();\r
2340             batch.AddExportedValue<ICompositionService>(container);\r
2341             container.Compose(batch);\r
2342 \r
2343             Assert.AreSame(container, container.GetExportedValue<ICompositionService>());\r
2344         }\r
2345 \r
2346         [TestMethod]\r
2347         public void CompositionContainer_CanBeExported()\r
2348         {\r
2349             var container = CreateCompositionContainer();\r
2350             CompositionBatch batch = new CompositionBatch();\r
2351             batch.AddExportedValue<CompositionContainer>(container);\r
2352             container.Compose(batch);\r
2353 \r
2354             Assert.AreSame(container, container.GetExportedValue<CompositionContainer>());\r
2355         }\r
2356 \r
2357         [TestMethod]\r
2358         public void ReleaseExport_Null_ShouldThrowArugmentNull()\r
2359         {\r
2360             var container = CreateCompositionContainer();\r
2361 \r
2362             ExceptionAssert.ThrowsArgument<ArgumentNullException>("export", \r
2363                 () => container.ReleaseExport(null));\r
2364         }\r
2365 \r
2366         [TestMethod]\r
2367         public void ReleaseExports_Null_ShouldThrowArgumentNull()\r
2368         {\r
2369             var container = CreateCompositionContainer();\r
2370 \r
2371             ExceptionAssert.ThrowsArgument<ArgumentNullException>("exports",\r
2372                 () => container.ReleaseExports(null));\r
2373         }\r
2374 \r
2375         [TestMethod]\r
2376         public void ReleaseExports_ElementNull_ShouldThrowArgument()\r
2377         {\r
2378             var container = CreateCompositionContainer();\r
2379 \r
2380             ExceptionAssert.ThrowsArgument<ArgumentException>("exports",\r
2381                 () => container.ReleaseExports(new Export[] { null }));\r
2382         }\r
2383 \r
2384         public class OptionalImporter\r
2385         {\r
2386             [Import("ValueType", AllowDefault = true)]\r
2387             public int ValueType\r
2388             {\r
2389                 get;\r
2390                 set;\r
2391             }\r
2392 \r
2393             [Import("NullableValueType", AllowDefault = true)]\r
2394             public int? NullableValueType\r
2395             {\r
2396                 get;\r
2397                 set;\r
2398             }\r
2399 \r
2400             [Import("ReferenceType", AllowDefault = true)]\r
2401             public string ReferenceType\r
2402             {\r
2403                 get;\r
2404                 set;\r
2405             }\r
2406         }\r
2407 \r
2408         public class ExportSimpleIntWithException\r
2409         {\r
2410             [Export("SimpleInt")]\r
2411             public int SimpleInt { get { throw new NotImplementedException(); } }\r
2412         }\r
2413 \r
2414         [TestMethod]\r
2415         public void TryGetValueWithCatalogVerifyExecptionDuringGet()\r
2416         {\r
2417             var cat = CatalogFactory.CreateDefaultAttributed();\r
2418             var container = new CompositionContainer(cat);\r
2419 \r
2420             CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotGetExportedValue, ErrorId.ReflectionModel_ExportThrewException, () =>\r
2421             {\r
2422                 container.GetExportedValue<int>("SimpleInt");\r
2423             });\r
2424         }\r
2425 \r
2426         [TestMethod]\r
2427         public void TryGetExportedValueWhileLockedForNotify()\r
2428         {\r
2429             var container = CreateCompositionContainer();\r
2430             CompositionBatch batch = new CompositionBatch();\r
2431             batch.AddParts(new CallbackImportNotify(delegate\r
2432             {\r
2433                 container.GetExportedValueOrDefault<int>();\r
2434             }));\r
2435 \r
2436             container.Compose(batch);\r
2437         }\r
2438 \r
2439         [TestMethod]\r
2440         public void RawExportTests()\r
2441         {\r
2442             var container = CreateCompositionContainer();\r
2443 \r
2444             CompositionBatch batch = new CompositionBatch();\r
2445             batch.AddExportedValue("foo", 1);\r
2446             container.Compose(batch);\r
2447 \r
2448             Lazy<int> export = container.GetExport<int>("foo");\r
2449 \r
2450             Assert.AreEqual(1, export.Value, "Should be the value I put in...");\r
2451         }\r
2452 \r
2453         [TestMethod]\r
2454         [Ignore]\r
2455         [WorkItem(468388)]\r
2456         public void ContainerXGetXTest()\r
2457         {\r
2458             CompositionContainer container = CreateCompositionContainer();\r
2459             CompositionBatch batch = new CompositionBatch();\r
2460             batch.AddPart(new MyExporterWithNoFoo());\r
2461             container.Compose(batch);\r
2462             ContainerXGetExportBoundValue(container);\r
2463         }\r
2464 \r
2465         [TestMethod]\r
2466         [Ignore]\r
2467         [WorkItem(468388)]\r
2468         public void ContainerXGetXByComponentCatalogTest()\r
2469         {\r
2470             CompositionContainer container = ContainerFactory.CreateWithDefaultAttributedCatalog();\r
2471             ContainerXGetExportBoundValue(container);\r
2472         }\r
2473 \r
2474         private void ContainerXGetExportBoundValue(CompositionContainer container)\r
2475         {\r
2476             Assert.Fail("This scenario (required metadata warnings) no longer works, see 468388");\r
2477 \r
2478             //string[] required = new string[] { "Foo" };\r
2479             //string[] RequiredMetadataNotFound = new string[] { CompositionIssueId.RequiredMetadataNotFound, CompositionIssueId.CardinalityMismatch };\r
2480             //container.TryGetExport<MyExporterWithNoFoo>().VerifyFailure(CompositionIssueId.CardinalityMismatch);\r
2481             //container.TryGetExport<MyExporterWithNoFoo>(required).VerifyFailure(CompositionIssueId.CardinalityMismatch);\r
2482             //container.TryGetExport<MyExporterWithNoFoo>("MyExporterWithNoFoo").VerifySuccess();\r
2483             //container.TryGetExport<MyExporterWithNoFoo>("MyExporterWithNoFoo", required).VerifyFailure(RequiredMetadataNotFound);\r
2484             //container.TryGetExports<MyExporterWithNoFoo>().VerifyFailure(CompositionIssueId.CardinalityMismatch);\r
2485             //container.TryGetExports<MyExporterWithNoFoo>(required).VerifyFailure(CompositionIssueId.CardinalityMismatch);\r
2486             //container.TryGetExports<MyExporterWithNoFoo>("MyExporterWithNoFoo").VerifySuccess();\r
2487             //container.TryGetExports<MyExporterWithNoFoo>("MyExporterWithNoFoo", required).VerifyFailure(RequiredMetadataNotFound);\r
2488             //container.TryGetExportedValue<MyExporterWithNoFoo>().VerifyFailure(CompositionIssueId.CardinalityMismatch);\r
2489             //container.TryGetExportedValue<MyExporterWithNoFoo>(required).VerifyFailure(CompositionIssueId.CardinalityMismatch);\r
2490             //container.TryGetExportedValue<MyExporterWithNoFoo>("MyExporterWithNoFoo").VerifySuccess();\r
2491             //container.TryGetExportedValue<MyExporterWithNoFoo>("MyExporterWithNoFoo", required).VerifyFailure(RequiredMetadataNotFound);\r
2492             //container.TryGetExportedValues<MyExporterWithNoFoo>().VerifyFailure(CompositionIssueId.CardinalityMismatch);\r
2493             //container.TryGetExportedValues<MyExporterWithNoFoo>(required).VerifyFailure(CompositionIssueId.CardinalityMismatch);\r
2494             //container.TryGetExportedValues<MyExporterWithNoFoo>("MyExporterWithNoFoo").VerifySuccess();\r
2495             //container.TryGetExportedValues<MyExporterWithNoFoo>("MyExporterWithNoFoo", required).VerifyFailure(RequiredMetadataNotFound);\r
2496 \r
2497             ExceptionAssert.Throws<ImportCardinalityMismatchException>(() => container.GetExportedValue<MyExporterWithNoFoo>());\r
2498             Assert.IsNotNull(container.GetExportedValue<MyExporterWithNoFoo>("MyExporterWithNoFoo"));\r
2499         }\r
2500 \r
2501         [Export("MyExporterWithNoFoo")]\r
2502         public class MyExporterWithNoFoo\r
2503         {\r
2504         }\r
2505 \r
2506         [Export("MyExporterWithFoo")]\r
2507         [ExportMetadata("Foo", "Foo value")]\r
2508         public class MyExporterWithFoo\r
2509         {\r
2510         }\r
2511 \r
2512         [Export("MyExporterWithFooBar")]\r
2513         [ExportMetadata("Foo", "Foo value")]\r
2514         [ExportMetadata("Bar", "Bar value")]\r
2515         public class MyExporterWithFooBar\r
2516         {\r
2517         }\r
2518 \r
2519 #if !SILVERLIGHT\r
2520         // Silverlight doesn't support strongly typed metadata\r
2521         [TestMethod]\r
2522         public void ConverterExportTests()\r
2523         {\r
2524             var container = CreateCompositionContainer();\r
2525             CompositionBatch batch = new CompositionBatch();\r
2526             batch.AddExportedValue("foo", 1);\r
2527             container.Compose(batch);\r
2528 \r
2529             var export = container.GetExport<int, IDictionary<string, object>>("foo");\r
2530             Assert.AreEqual(1, export.Value, "Should be the value I put in...");\r
2531             Assert.IsNotNull(export.Metadata, "Should have metadata (as an object)");\r
2532         }\r
2533 \r
2534 #endif //!SILVERLIGHT\r
2535 \r
2536         [TestMethod]\r
2537         public void RemoveFromWrongContainerTest()\r
2538         {\r
2539             CompositionContainer d1 = CreateCompositionContainer();\r
2540             CompositionContainer d2 = CreateCompositionContainer();\r
2541 \r
2542             CompositionBatch batch1 = new CompositionBatch();\r
2543             var valueKey = batch1.AddExportedValue("a", 1);\r
2544             d1.Compose(batch1);\r
2545 \r
2546             CompositionBatch batch2 = new CompositionBatch();\r
2547             batch2.RemovePart(valueKey);\r
2548             // removing entry from wrong container, shoudl be a no-op\r
2549             d2.Compose(batch2);\r
2550         }\r
2551 \r
2552         [TestMethod]\r
2553         [TestProperty("Type", "Integration")]\r
2554         public void AddPartSimple()\r
2555         {\r
2556             var container = CreateCompositionContainer();\r
2557             var importer = new Int32Importer();\r
2558             CompositionBatch batch = new CompositionBatch();\r
2559             batch.AddPart(importer);\r
2560             batch.AddPart(new Int32Exporter(42));\r
2561             container.Compose(batch);\r
2562 \r
2563             Assert.AreEqual(42, importer.Value, "Expected value imported from export");\r
2564         }\r
2565 \r
2566         [TestMethod]\r
2567         [TestProperty("Type", "Integration")]\r
2568         public void AddPart()\r
2569         {\r
2570             var container = CreateCompositionContainer();\r
2571             Int32Importer importer = new Int32Importer();\r
2572             CompositionBatch batch = new CompositionBatch();\r
2573             batch.AddPart(AttributedModelServices.CreatePart(importer));\r
2574             batch.AddPart(new Int32Exporter(42));\r
2575             container.Compose(batch);\r
2576 \r
2577             Assert.AreEqual(42, importer.Value, "Expected value imported from export");\r
2578         }\r
2579 \r
2580         [TestMethod]\r
2581         public void ComposeReentrantChildContainerDisposed()\r
2582         {\r
2583             var container = CreateCompositionContainer();\r
2584             Int32Importer outerImporter = new Int32Importer();\r
2585             Int32Importer innerImporter = new Int32Importer();\r
2586             Int32Exporter exporter = new Int32Exporter(42);\r
2587             CompositionBatch batch = new CompositionBatch();\r
2588             batch.AddPart(exporter);\r
2589             container.Compose(batch);\r
2590             CallbackExecuteCodeDuringCompose callback = new CallbackExecuteCodeDuringCompose(() =>\r
2591             {\r
2592                 using (CompositionContainer innerContainer = new CompositionContainer(container))\r
2593                 {\r
2594                     CompositionBatch nestedBatch = new CompositionBatch();\r
2595                     nestedBatch.AddPart(innerImporter);\r
2596                     innerContainer.Compose(nestedBatch);\r
2597                 }\r
2598                 Assert.AreEqual(42, innerImporter.Value, "Expected value imported from export");\r
2599             });\r
2600 \r
2601             batch = new CompositionBatch();\r
2602             batch.AddParts(outerImporter, callback);\r
2603             container.Compose(batch);\r
2604 \r
2605             Assert.AreEqual(42, outerImporter.Value, "Expected value imported from export");\r
2606             Assert.AreEqual(42, innerImporter.Value, "Expected value imported from export");\r
2607         }\r
2608 \r
2609         [TestMethod]\r
2610         public void ComposeSimple()\r
2611         {\r
2612             var container = CreateCompositionContainer();\r
2613             Int32Importer importer = new Int32Importer();\r
2614 \r
2615             CompositionBatch batch = new CompositionBatch();\r
2616             batch.AddParts(importer, new Int32Exporter(42));\r
2617             container.Compose(batch);\r
2618 \r
2619             Assert.AreEqual(42, importer.Value, "Expected value imported from export");\r
2620         }\r
2621 \r
2622         [TestMethod]\r
2623         public void ComposeSimpleFail()\r
2624         {\r
2625             var container = CreateCompositionContainer();\r
2626             Int32Importer importer = new Int32Importer();\r
2627 \r
2628             CompositionBatch batch = new CompositionBatch();\r
2629             batch.AddPart(importer);\r
2630 \r
2631             CompositionAssert.ThrowsChangeRejectedError(ErrorId.ImportEngine_PartCannotSetImport,          // Cannot set Int32Importer.Value because\r
2632                                           ErrorId.ImportEngine_ImportCardinalityMismatch,    // No exports are present that match contract\r
2633                                           RetryMode.DoNotRetry, () =>\r
2634             {\r
2635                 container.Compose(batch);\r
2636             });\r
2637         }\r
2638 \r
2639         [TestMethod]\r
2640         public void ExceptionDuringNotify()\r
2641         {\r
2642             var container = CreateCompositionContainer();\r
2643             CompositionBatch batch = new CompositionBatch();\r
2644             batch.AddParts(new CallbackImportNotify(delegate\r
2645             {\r
2646                 throw new InvalidOperationException();\r
2647             }));\r
2648 \r
2649             CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotActivate,              // Cannot activate CallbackImportNotify because\r
2650                                           ErrorId.ReflectionModel_PartOnImportsSatisfiedThrewException, // OnImportsSatisfied threw an exception\r
2651                                           RetryMode.DoNotRetry, () =>\r
2652             {\r
2653                 container.Compose(batch);\r
2654             });\r
2655         }\r
2656 \r
2657         [TestMethod]\r
2658         public void NeutralComposeWhileNotified()\r
2659         {\r
2660             var container = CreateCompositionContainer();\r
2661             CompositionBatch batch = new CompositionBatch();\r
2662             batch.AddParts(new CallbackImportNotify(delegate\r
2663             {\r
2664                 // Is this really a supported scenario?\r
2665                 container.Compose(batch);\r
2666             }));\r
2667 \r
2668             container.Compose(batch);\r
2669         }\r
2670         public class PartWithReentrantCompose : ComposablePart\r
2671         {\r
2672             private CompositionContainer _container;\r
2673 \r
2674             public PartWithReentrantCompose(CompositionContainer container)\r
2675             {\r
2676                 this._container = container;\r
2677             }\r
2678 \r
2679             public override IEnumerable<ExportDefinition> ExportDefinitions\r
2680             {\r
2681                 get\r
2682                 {\r
2683                     this._container.ComposeExportedValue<string>("ExportedString");\r
2684                     return Enumerable.Empty<ExportDefinition>();\r
2685                 }\r
2686             }\r
2687 \r
2688             public override IEnumerable<ImportDefinition> ImportDefinitions\r
2689             {\r
2690                 get\r
2691                 {\r
2692                     return Enumerable.Empty<ImportDefinition>();\r
2693                 }\r
2694             }\r
2695 \r
2696             public override object GetExportedValue(ExportDefinition definition)\r
2697             {\r
2698                 throw new NotImplementedException();\r
2699             }\r
2700 \r
2701             public override void SetImport(ImportDefinition definition, IEnumerable<Export> exports)\r
2702             {\r
2703                 throw new NotImplementedException();\r
2704             }\r
2705         }\r
2706 \r
2707         [Export]\r
2708         public class SimpleExporter\r
2709         {\r
2710 \r
2711         }\r
2712 \r
2713         [TestMethod]\r
2714         public void ThreadSafeCompositionContainer()\r
2715         {\r
2716             TypeCatalog catalog = new TypeCatalog(typeof(SimpleExporter));\r
2717 \r
2718             CompositionContainer container = new CompositionContainer(catalog, true);\r
2719             Int32Importer importer = new Int32Importer();\r
2720 \r
2721             CompositionBatch batch = new CompositionBatch();\r
2722             batch.AddParts(importer, new Int32Exporter(42));\r
2723             container.Compose(batch);\r
2724 \r
2725             Assert.IsNotNull(container.GetExportedValue<SimpleExporter>());\r
2726             Assert.AreEqual(42, importer.Value, "Expected value imported from export");\r
2727 \r
2728             container.Dispose();\r
2729 \r
2730         }\r
2731 \r
2732         [TestMethod]\r
2733         public void ReentrantencyDisabledWhileComposing()\r
2734         {\r
2735             var container = CreateCompositionContainer();\r
2736             CompositionBatch batch = new CompositionBatch();\r
2737 \r
2738             batch.AddPart(new PartWithReentrantCompose(container));\r
2739 \r
2740             ExceptionAssert.Throws<InvalidOperationException>(() =>\r
2741                 container.Compose(batch));\r
2742         }\r
2743         private static Expression<Func<ExportDefinition, bool>> ConstraintFromContract(string contractName)\r
2744         {\r
2745             return ConstraintFactory.Create(contractName);\r
2746         }\r
2747 \r
2748         private static string ContractFromType(Type type)\r
2749         {\r
2750             return AttributedModelServices.GetContractName(type);\r
2751         }\r
2752 \r
2753         private static CompositionContainer CreateCompositionContainer()\r
2754         {\r
2755             return new CompositionContainer();\r
2756         }\r
2757 \r
2758         public interface IMetadataView\r
2759         {\r
2760             string Metadata1\r
2761             {\r
2762                 get;\r
2763             }\r
2764 \r
2765             string Metadata2\r
2766             {\r
2767                 get;\r
2768             }\r
2769 \r
2770             string Metadata3\r
2771             {\r
2772                 get;\r
2773             }\r
2774         }\r
2775 \r
2776         [TestMethod]\r
2777         public void ComposeExportedValueOfT_NullStringAsExportedValueArgument_VerifyCanPullOnValue()\r
2778         {\r
2779             var container = CreateCompositionContainer();\r
2780 \r
2781             var expectation = (string)null;\r
2782             container.ComposeExportedValue<string>(expectation);\r
2783             var actualValue = container.GetExportedValue<string>();\r
2784 \r
2785             Assert.AreEqual(expectation, actualValue);\r
2786         }\r
2787 \r
2788         [TestMethod]\r
2789         public void ComposeExportedValueOfT_StringAsExportedValueArgument_VerifyCanPullOnValue()\r
2790         {\r
2791             var expectations = new List<string>();\r
2792             expectations.Add((string)null);\r
2793             expectations.Add(String.Empty);\r
2794             expectations.Add("Value");\r
2795 \r
2796             foreach (var expectation in expectations)\r
2797             {\r
2798                 var container = CreateCompositionContainer();\r
2799                 container.ComposeExportedValue<string>(expectation);\r
2800                 var actualValue = container.GetExportedValue<string>();\r
2801 \r
2802                 Assert.AreEqual(expectation, actualValue);\r
2803             }\r
2804         }\r
2805 \r
2806         [TestMethod]\r
2807         public void ComposeExportedValueOfT_StringAsIEnumerableOfCharAsExportedValueArgument_VerifyCanPullOnValue()\r
2808         {\r
2809             var expectations = new List<string>();\r
2810             expectations.Add((string)null);\r
2811             expectations.Add(String.Empty);\r
2812             expectations.Add("Value");\r
2813 \r
2814             foreach (var expectation in expectations)\r
2815             {\r
2816                 var container = CreateCompositionContainer();\r
2817                 container.ComposeExportedValue<IEnumerable<char>>(expectation);\r
2818                 var actualValue = container.GetExportedValue<IEnumerable<char>>();\r
2819 \r
2820                 Assert.AreEqual(expectation, actualValue);\r
2821             }\r
2822         }\r
2823             \r
2824         [TestMethod]\r
2825         public void ComposeExportedValueOfT_ObjectAsExportedValueArgument_VerifyCanPullOnValue()\r
2826         {\r
2827             var expectations = new List<object>();\r
2828             expectations.Add((string)null);\r
2829             expectations.Add(String.Empty);\r
2830             expectations.Add("Value");\r
2831             expectations.Add(42);\r
2832             expectations.Add(new object());\r
2833 \r
2834             foreach (var expectation in expectations)\r
2835             {\r
2836                 var container = CreateCompositionContainer();\r
2837                 container.ComposeExportedValue<object>(expectation);\r
2838                 var actualValue = container.GetExportedValue<object>();\r
2839 \r
2840                 Assert.AreEqual(expectation, actualValue);\r
2841             }\r
2842         }\r
2843 \r
2844         [TestMethod]\r
2845         public void ComposeExportedValueOfT_ExportedValue_ExportedUnderDefaultContractName()\r
2846         {\r
2847             string expectedContractName = AttributedModelServices.GetContractName(typeof(string));\r
2848             var container = CreateCompositionContainer();\r
2849             container.ComposeExportedValue<string>("Value");\r
2850 \r
2851             var importDefinition = new ImportDefinition(ed => true, null, ImportCardinality.ZeroOrMore, false, false);\r
2852             var exports = container.GetExports(importDefinition);\r
2853             Assert.AreEqual(1, exports.Count());\r
2854             Assert.AreEqual(expectedContractName, exports.Single().Definition.ContractName);\r
2855         }\r
2856 \r
2857         [TestMethod]\r
2858         public void ComposeExportedValueOfT_ExportedValue_ExportContainsEmptyMetadata()\r
2859         {\r
2860             var container = CreateCompositionContainer();\r
2861             container.ComposeExportedValue<string>("Value");\r
2862 \r
2863             var importDefinition = new ImportDefinition(ed => true, null, ImportCardinality.ZeroOrMore, false, false);\r
2864             var exports = container.GetExports(importDefinition);\r
2865             Assert.AreEqual(1, exports.Count());\r
2866             Assert.AreEqual(1, exports.Single().Metadata.Count);  // contains type identity\r
2867         }\r
2868 \r
2869         [TestMethod]\r
2870         public void ComposeExportedValueOfT_ExportedValue_LazyContainsEmptyMetadata()\r
2871         {\r
2872             var container = CreateCompositionContainer();\r
2873             container.ComposeExportedValue<string>("Value");\r
2874 \r
2875             var lazy = container.GetExport<string, IDictionary<string, object>>();\r
2876             Assert.AreEqual(1, lazy.Metadata.Count);  // contains type identity\r
2877         }\r
2878 \r
2879         [TestMethod]\r
2880         public void ComposeExportedValueOfT_ExportedValue_ImportsAreNotDiscovered()\r
2881         {\r
2882             var container = CreateCompositionContainer();\r
2883             var importer = new PartWithRequiredImport();\r
2884 \r
2885             container.ComposeExportedValue<object>(importer);\r
2886 \r
2887             var importDefinition = new ImportDefinition(ed => true, null, ImportCardinality.ZeroOrMore, false, false);\r
2888             var exports = container.GetExports(importDefinition);\r
2889             Assert.AreEqual(1, exports.Count());  // we only get one if the import was not discovered since the import is not satisfied\r
2890         }\r
2891 \r
2892         [TestMethod]\r
2893         public void ComposeExportedValueOfT_NullAsContractName_ThrowsArgumentNullException()\r
2894         {\r
2895             var container = CreateCompositionContainer();\r
2896             ExceptionAssert.ThrowsArgument<ArgumentNullException>("contractName", () =>\r
2897                 container.ComposeExportedValue<string>((string)null, "Value"));\r
2898         }\r
2899 \r
2900         [TestMethod]\r
2901         public void ComposeExportedValueOfT_EmptyStringAsContractName_ThrowsArgumentException()\r
2902         {\r
2903             var container = CreateCompositionContainer();\r
2904             ExceptionAssert.ThrowsArgument<ArgumentException>("contractName", () =>\r
2905                 container.ComposeExportedValue<string>(String.Empty, "Value"));\r
2906         }\r
2907 \r
2908         [TestMethod]\r
2909         public void ComposeExportedValueOfT_ValidContractName_ValidExportedValue_VerifyCanPullOnValue()\r
2910         {\r
2911             var expectations = new List<Tuple<string, string>>();\r
2912             expectations.Add(new Tuple<string, string>(" ", (string)null));\r
2913             expectations.Add(new Tuple<string, string>(" ", String.Empty));\r
2914             expectations.Add(new Tuple<string, string>(" ", "Value"));\r
2915             expectations.Add(new Tuple<string, string>("ContractName", (string)null));\r
2916             expectations.Add(new Tuple<string, string>("ContractName", String.Empty));\r
2917             expectations.Add(new Tuple<string, string>("ContractName", "Value"));\r
2918 \r
2919             foreach (var expectation in expectations)\r
2920             {\r
2921                 var container = CreateCompositionContainer();\r
2922                 container.ComposeExportedValue<string>(expectation.Item1, expectation.Item2);\r
2923                 var actualValue = container.GetExportedValue<string>(expectation.Item1);\r
2924 \r
2925                 Assert.AreEqual(expectation.Item2, actualValue);\r
2926 \r
2927                 ExceptionAssert.Throws<ImportCardinalityMismatchException>(() =>\r
2928                     container.GetExportedValue<string>());\r
2929             }\r
2930         }\r
2931 \r
2932         [TestMethod]\r
2933         public void ComposeExportedValueOfT_ValidContractName_ExportedValue_ExportedUnderSpecifiedContractName()\r
2934         {\r
2935             string expectedContractName = "ContractName";\r
2936             var container = CreateCompositionContainer();\r
2937             container.ComposeExportedValue<string>(expectedContractName, "Value");\r
2938 \r
2939             var importDefinition = new ImportDefinition(ed => true, null, ImportCardinality.ZeroOrMore, false, false);\r
2940             var exports = container.GetExports(importDefinition);\r
2941             Assert.AreEqual(1, exports.Count());\r
2942             Assert.AreEqual(expectedContractName, exports.Single().Definition.ContractName);\r
2943         }\r
2944 \r
2945         [TestMethod]\r
2946         [Ignore]\r
2947         [WorkItem(812029)]\r
2948         public void ComposeExportedValueOfT_ValidContractName_ExportedValue_ExportContainsEmptyMetadata()\r
2949         {\r
2950             string expectedContractName = "ContractName";\r
2951             var container = CreateCompositionContainer();\r
2952             container.ComposeExportedValue<string>(expectedContractName, "Value");\r
2953 \r
2954             var importDefinition = new ImportDefinition(ed => ed.ContractName == expectedContractName, null, ImportCardinality.ZeroOrMore, false, false);\r
2955             var exports = container.GetExports(importDefinition);\r
2956             Assert.AreEqual(1, exports.Count());\r
2957             Assert.AreEqual(1, exports.Single().Metadata.Count); // contains type identity\r
2958         }\r
2959 \r
2960         [TestMethod]\r
2961         public void ComposeExportedValueOfT_ValidContractName_ExportedValue_ImportsAreNotDiscovered()\r
2962         {\r
2963             var container = CreateCompositionContainer();\r
2964             var importer = new PartWithRequiredImport();\r
2965 \r
2966             container.ComposeExportedValue<object>("ContractName", importer);\r
2967 \r
2968             var importDefinition = new ImportDefinition(ed => true, null, ImportCardinality.ZeroOrMore, false, false);\r
2969             var exports = container.GetExports(importDefinition);\r
2970             Assert.AreEqual(1, exports.Count());  // we only get one if the import was not discovered since the import is not satisfied\r
2971         }\r
2972 \r
2973         [TestMethod]\r
2974         public void TestExportedValueCachesNullValue()\r
2975         {\r
2976             var container = ContainerFactory.Create();\r
2977             var exporter = new ExportsMutableProperty();\r
2978             exporter.Property = null;\r
2979             container.ComposeParts(exporter);\r
2980             Assert.IsNull(container.GetExportedValue<string>("Property"));\r
2981             exporter.Property = "Value1";\r
2982             // Exported value should have been cached and so it shouldn't change\r
2983             Assert.IsNull(container.GetExportedValue<string>("Property"));\r
2984         }\r
2985         public class ExportsMutableProperty\r
2986         {\r
2987             [Export("Property")]\r
2988             public string Property { get; set; }\r
2989         }\r
2990 \r
2991 \r
2992         public class PartWithRequiredImport\r
2993         {\r
2994             [Import]\r
2995             public object Import { get; set; }\r
2996         }\r
2997     }\r
2998 }\r