mcs/class/System.ComponentModel.Composition/Tests/ComponentModelUnitTest/System/ComponentModel/Composition/CompositionContainerImportTests.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.Factories;\r
   7 using System.ComponentModel.Composition.Hosting;\r
   8 using System.ComponentModel.Composition.Primitives;\r
   9 using System.ComponentModel.Composition.UnitTesting;\r
  10 using System.Linq;\r
  11 using System.Runtime.InteropServices;\r
  12 using System.UnitTesting;\r
  13 using Microsoft.VisualStudio.TestTools.UnitTesting;\r
  14 \r
  15 namespace System.ComponentModel.Composition\r
  16 {\r
  17     [TestClass]\r
  18     public class CompositionContainerImportTests\r
  19     {\r
  20         // Exporting collectin values is not supported\r
  21         [TestMethod]\r
  22         public void ImportValues()\r
  23         {\r
  24             var container = ContainerFactory.Create();\r
  25             Importer importer = new Importer();\r
  26             Exporter exporter42 = new Exporter(42);\r
  27 \r
  28             CompositionBatch batch = new CompositionBatch();\r
  29             batch.AddPart(importer);\r
  30             batch.AddPart(exporter42);\r
  31 \r
  32             CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotSetImport,\r
  33                                           ErrorId.ReflectionModel_ImportNotAssignableFromExport, RetryMode.DoNotRetry, () =>\r
  34             {\r
  35                 container.Compose(batch);\r
  36             });            \r
  37         }\r
  38 \r
  39         [TestMethod]\r
  40         public void ImportSingle()\r
  41         {\r
  42             var container = ContainerFactory.Create();\r
  43             var importer = new Int32Importer();\r
  44             var exporter = new Int32Exporter(42);\r
  45 \r
  46             CompositionBatch batch = new CompositionBatch();\r
  47             batch.AddPart(importer);\r
  48             batch.AddPart(exporter);\r
  49             container.Compose(batch);\r
  50 \r
  51             Assert.AreEqual(42, importer.Value, "Expecting value to be imported");\r
  52 \r
  53         }\r
  54 \r
  55         [TestMethod]\r
  56         public void ImportSingleFromInternal()\r
  57         {\r
  58             var container = ContainerFactory.Create();\r
  59             var importer = new Int32Importer();\r
  60             var exporter = new Int32ExporterInternal(42);\r
  61 \r
  62             CompositionBatch batch = new CompositionBatch();\r
  63             batch.AddPart(importer);\r
  64             batch.AddPart(exporter);\r
  65             container.Compose(batch);\r
  66 \r
  67             Assert.AreEqual(42, importer.Value, "Expecting value to be imported");\r
  68         }\r
  69 \r
  70         [TestMethod]\r
  71         public void ImportSingleToInternal()\r
  72         {\r
  73             var container = ContainerFactory.Create();\r
  74             var importer = new Int32ImporterInternal();\r
  75             var exporter = new Int32Exporter(42);\r
  76 \r
  77             CompositionBatch batch = new CompositionBatch();\r
  78             batch.AddPart(importer);\r
  79             batch.AddPart(exporter);\r
  80             container.Compose(batch);\r
  81 \r
  82             Assert.AreEqual(42, importer.Value, "Expecting value to be imported");\r
  83         }\r
  84 \r
  85         [TestMethod]\r
  86         public void ImportSingleIntoCollection()\r
  87         {\r
  88             var container = ContainerFactory.Create();\r
  89             var importer = new Int32CollectionImporter();\r
  90             var exporter = new Int32Exporter(42);\r
  91 \r
  92             CompositionBatch batch = new CompositionBatch();\r
  93             batch.AddPart(importer);\r
  94             batch.AddPart(exporter);\r
  95             container.Compose(batch);\r
  96 \r
  97             EnumerableAssert.AreEqual(importer.Values, 42);\r
  98         }\r
  99 \r
 100         [TestMethod]\r
 101         public void ImportValuesNameless()\r
 102         {\r
 103             var container = ContainerFactory.Create();\r
 104             ImporterNameless importer;\r
 105             ExporterNameless exporter42 = new ExporterNameless(42);\r
 106 \r
 107             CompositionBatch batch = new CompositionBatch();\r
 108             batch.AddPart(importer = new ImporterNameless());\r
 109             batch.AddPart(exporter42);\r
 110             container.Compose(batch);\r
 111 \r
 112             Assert.AreEqual(42, importer.ValueReadWrite);\r
 113             Assert.AreEqual(42, importer.MetadataReadWrite.Value);\r
 114         }\r
 115 \r
 116         [TestMethod]\r
 117         public void ImportValueExceptionMissing()\r
 118         {\r
 119             var container = ContainerFactory.Create();\r
 120             Importer importer;\r
 121 \r
 122             CompositionBatch batch = new CompositionBatch();\r
 123             batch.AddPart(importer = new Importer());\r
 124 \r
 125             CompositionAssert.ThrowsChangeRejectedError(ErrorId.ImportEngine_PartCannotSetImport,\r
 126                                           ErrorId.ImportEngine_ImportCardinalityMismatch, \r
 127                                           RetryMode.DoNotRetry, () =>\r
 128             {\r
 129                 container.Compose(batch);\r
 130             });\r
 131         }\r
 132 \r
 133         [TestMethod]\r
 134         public void ImportValueExceptionMultiple()\r
 135         {\r
 136             var container = ContainerFactory.Create();\r
 137             Importer importer = new Importer();\r
 138             Exporter exporter42 = new Exporter(42);\r
 139             Exporter exporter6 = new Exporter(6);\r
 140 \r
 141             CompositionBatch batch = new CompositionBatch();\r
 142             batch.AddPart(importer);\r
 143             batch.AddPart(exporter42);\r
 144             batch.AddPart(exporter6);\r
 145 \r
 146             CompositionAssert.ThrowsChangeRejectedError(ErrorId.ImportEngine_PartCannotSetImport,\r
 147                 RetryMode.DoNotRetry, () =>\r
 148             {\r
 149                 container.Compose(batch);\r
 150             });\r
 151         }\r
 152 \r
 153         [TestMethod]\r
 154         public void ImportValueExceptionSetterException()\r
 155         {\r
 156             var container = ContainerFactory.Create();\r
 157             ImporterInvalidSetterException importer = new ImporterInvalidSetterException();\r
 158             Exporter exporter42 = new Exporter(42);\r
 159 \r
 160             CompositionBatch batch = new CompositionBatch();\r
 161             batch.AddPart(importer);\r
 162             batch.AddPart(exporter42);\r
 163 \r
 164             CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotActivate,\r
 165                                           ErrorId.ReflectionModel_ImportThrewException, \r
 166                                           RetryMode.DoNotRetry, () =>\r
 167             {\r
 168                 container.Compose(batch);\r
 169             });\r
 170         }\r
 171 \r
 172         [TestMethod]\r
 173         public void ImportValueExceptionLazily()\r
 174         {\r
 175             var catalog = new AssemblyCatalog(typeof(ImportImporterInvalidSetterExceptionLazily).Assembly);\r
 176             var container = ContainerFactory.CreateWithAttributedCatalog(typeof(ImportImporterInvalidSetterExceptionLazily), typeof(ImporterInvalidSetterException));\r
 177             var invalidLazy = container.GetExportedValue<ImportImporterInvalidSetterExceptionLazily>();\r
 178 \r
 179             CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotGetExportedValue,\r
 180                                           ErrorId.ImportEngine_PartCannotActivate,\r
 181                                           ErrorId.ReflectionModel_ImportThrewException, RetryMode.DoNotRetry, () =>\r
 182             {\r
 183                 var value = invalidLazy.Value.Value;\r
 184             });\r
 185         }\r
 186 \r
 187 #if !SILVERLIGHT\r
 188 \r
 189         [TestMethod]\r
 190         public void ImportValueComComponent()\r
 191         {\r
 192             CTaskScheduler scheduler = new CTaskScheduler();\r
 193 \r
 194             try\r
 195             {\r
 196                 var container = ContainerFactory.Create();\r
 197                 var importer = new ImportComComponent();\r
 198 \r
 199                 CompositionBatch batch = new CompositionBatch();\r
 200                 batch.AddParts(importer);\r
 201                 batch.AddExportedValue<ITaskScheduler>("TaskScheduler", (ITaskScheduler)scheduler);\r
 202 \r
 203                 container.Compose(batch);\r
 204 \r
 205                 Assert.AreEqual(scheduler, importer.TaskScheduler);\r
 206             }\r
 207             finally\r
 208             {\r
 209                 Marshal.ReleaseComObject(scheduler);\r
 210             }\r
 211         }\r
 212 \r
 213         [TestMethod]\r
 214         public void DelayImportValueComComponent()\r
 215         {\r
 216             CTaskScheduler scheduler = new CTaskScheduler();\r
 217 \r
 218             try\r
 219             {\r
 220                 var container = ContainerFactory.Create();\r
 221                 var importer = new DelayImportComComponent();\r
 222 \r
 223                 CompositionBatch batch = new CompositionBatch();\r
 224                 batch.AddParts(importer);\r
 225                 batch.AddExportedValue<ITaskScheduler>("TaskScheduler", (ITaskScheduler)scheduler);\r
 226 \r
 227                 container.Compose(batch);\r
 228 \r
 229                 Assert.AreEqual(scheduler, importer.TaskScheduler.Value);\r
 230             }\r
 231             finally\r
 232             {\r
 233                 Marshal.ReleaseComObject(scheduler);\r
 234             }\r
 235         }\r
 236 #endif\r
 237        \r
 238         [TestMethod]\r
 239         [TestProperty("Type", "Integration")]\r
 240         public void OptionalImportsOfValueTypesAreBoundToDefaultWhenNotSatisfied()\r
 241         {\r
 242             var container = ContainerFactory.Create();\r
 243             var importer = new OptionalImport();\r
 244 \r
 245             CompositionBatch batch = new CompositionBatch();\r
 246             batch.AddPart(importer);\r
 247             container.Compose(batch);\r
 248 \r
 249             Assert.AreEqual(1, importer.ValueTypeSetCount);\r
 250             Assert.AreEqual(0, importer.ValueType);\r
 251         }\r
 252 \r
 253         [TestMethod]\r
 254         [TestProperty("Type", "Integration")]\r
 255         public void OptionalImportsOfNullableValueTypesAreBoundToDefaultWhenNotSatisfied()\r
 256         {\r
 257             var container = ContainerFactory.Create();\r
 258             var importer = new OptionalImport();\r
 259 \r
 260             CompositionBatch batch = new CompositionBatch();\r
 261             batch.AddPart(importer);\r
 262             container.Compose(batch);\r
 263 \r
 264             Assert.AreEqual(1, importer.NullableValueTypeSetCount);\r
 265             Assert.IsNull(importer.NullableValueType);\r
 266         }\r
 267 \r
 268         [TestMethod]\r
 269         [TestProperty("Type", "Integration")]\r
 270         public void OptionalImportsOfReferenceTypesAreBoundToDefaultWhenNotSatisfied()\r
 271         {\r
 272             var container = ContainerFactory.Create();\r
 273             var importer = new OptionalImport();\r
 274 \r
 275             CompositionBatch batch = new CompositionBatch();\r
 276             batch.AddPart(importer);\r
 277             container.Compose(batch);\r
 278 \r
 279             Assert.AreEqual(1, importer.ReferenceTypeSetCount);\r
 280             Assert.IsNull(importer.ReferenceType);\r
 281         }\r
 282 \r
 283         [TestMethod]\r
 284         [TestProperty("Type", "Integration")]\r
 285         public void OptionalImportsOfExportValueTypesAreBoundToDefaultWhenNotSatisfied()\r
 286         {\r
 287             var container = ContainerFactory.Create();\r
 288             var importer = new OptionalExport();\r
 289 \r
 290             CompositionBatch batch = new CompositionBatch();\r
 291             batch.AddPart(importer);\r
 292             container.Compose(batch);\r
 293 \r
 294             Assert.AreEqual(1, importer.ValueTypeSetCount);\r
 295             Assert.IsNull(importer.ValueType);\r
 296         }\r
 297 \r
 298         [TestMethod]\r
 299         [TestProperty("Type", "Integration")]\r
 300         public void OptionalImportsOfExportNullableValueTypesAreBoundToDefaultWhenNotSatisfied()\r
 301         {\r
 302             var container = ContainerFactory.Create();\r
 303             var importer = new OptionalExport();\r
 304 \r
 305             CompositionBatch batch = new CompositionBatch();\r
 306             batch.AddPart(importer);\r
 307             container.Compose(batch);\r
 308 \r
 309             Assert.AreEqual(1, importer.NullableValueTypeSetCount);\r
 310             Assert.IsNull(importer.NullableValueType);\r
 311         }\r
 312 \r
 313         [TestMethod]\r
 314         [TestProperty("Type", "Integration")]\r
 315         public void OptionalImportsOfExportReferenceTypesAreBoundToDefaultWhenNotSatisfied()\r
 316         {\r
 317             var container = ContainerFactory.Create();\r
 318             var importer = new OptionalExport();\r
 319 \r
 320             CompositionBatch batch = new CompositionBatch();\r
 321             batch.AddPart(importer);\r
 322             container.Compose(batch);\r
 323 \r
 324             Assert.AreEqual(1, importer.ReferenceTypeSetCount);\r
 325             Assert.IsNull(importer.ReferenceType);\r
 326         }\r
 327 \r
 328         [TestMethod]\r
 329         [TestProperty("Type", "Integration")]\r
 330         public void OptionalImportsOfValueTypesAreReboundToDefaultWhenExportIsRemoved()\r
 331         {\r
 332             var container = ContainerFactory.Create();\r
 333             var importer = new OptionalImport();\r
 334 \r
 335             CompositionBatch batch = new CompositionBatch();\r
 336             batch.AddPart(importer);\r
 337             var key = batch.AddExportedValue("ValueType", 10);\r
 338 \r
 339             container.Compose(batch);\r
 340 \r
 341             Assert.AreEqual(1, importer.ValueTypeSetCount);\r
 342             Assert.AreEqual(10, importer.ValueType);\r
 343 \r
 344             batch = new CompositionBatch();\r
 345             batch.RemovePart(key);\r
 346             container.Compose(batch);\r
 347 \r
 348             Assert.AreEqual(2, importer.ValueTypeSetCount);\r
 349             Assert.AreEqual(0, importer.ValueType);\r
 350         }\r
 351 \r
 352         [TestMethod]\r
 353         [TestProperty("Type", "Integration")]\r
 354         public void OptionalImportsOfNullableValueTypesAreReboundToDefaultWhenExportIsRemoved()\r
 355         {\r
 356             var container = ContainerFactory.Create();\r
 357             var importer = new OptionalImport();\r
 358 \r
 359             CompositionBatch batch = new CompositionBatch();\r
 360             batch.AddPart(importer);\r
 361             var key = batch.AddExportedValue<int?>("NullableValueType", 10);\r
 362 \r
 363             container.Compose(batch);\r
 364             Assert.AreEqual(1, importer.NullableValueTypeSetCount);\r
 365             Assert.AreEqual(10, importer.NullableValueType);\r
 366 \r
 367             batch = new CompositionBatch();\r
 368             batch.RemovePart(key);\r
 369             container.Compose(batch);\r
 370 \r
 371             Assert.AreEqual(2, importer.NullableValueTypeSetCount);\r
 372             Assert.IsNull(importer.NullableValueType);\r
 373         }\r
 374 \r
 375         [TestMethod]\r
 376         [TestProperty("Type", "Integration")]\r
 377         public void OptionalImportsOfReferenceTypesAreReboundToDefaultWhenExportIsRemoved()\r
 378         {\r
 379             var container = ContainerFactory.Create();\r
 380             var importer = new OptionalImport();\r
 381 \r
 382             CompositionBatch batch = new CompositionBatch();\r
 383             batch.AddPart(importer);\r
 384             var key = batch.AddExportedValue("ReferenceType", "Bar");\r
 385 \r
 386             container.Compose(batch);\r
 387             Assert.AreEqual(1, importer.ReferenceTypeSetCount);\r
 388             Assert.AreEqual("Bar", importer.ReferenceType);\r
 389 \r
 390             batch = new CompositionBatch();\r
 391             batch.RemovePart(key);\r
 392             container.Compose(batch);\r
 393 \r
 394             Assert.AreEqual(2, importer.ReferenceTypeSetCount);\r
 395             Assert.IsNull(importer.ReferenceType);\r
 396         }\r
 397 \r
 398         [TestMethod]\r
 399         [TestProperty("Type", "Integration")]\r
 400         public void OptionalImportsOfExportValueTypesAreReboundToDefaultWhenExportIsRemoved()\r
 401         {\r
 402             var container = ContainerFactory.Create();\r
 403             var importer = new OptionalExport();\r
 404 \r
 405             CompositionBatch batch = new CompositionBatch();\r
 406             batch.AddPart(importer);\r
 407             var key = batch.AddExportedValue("ValueType", 10);\r
 408 \r
 409             container.Compose(batch);\r
 410 \r
 411             Assert.AreEqual(1, importer.ValueTypeSetCount);\r
 412             Assert.AreEqual(10, importer.ValueType.Value);\r
 413 \r
 414             batch = new CompositionBatch();\r
 415             batch.RemovePart(key);\r
 416             container.Compose(batch);\r
 417 \r
 418             Assert.AreEqual(2, importer.ValueTypeSetCount);\r
 419             Assert.IsNull(importer.ValueType);\r
 420         }\r
 421 \r
 422         [TestMethod]\r
 423         [TestProperty("Type", "Integration")]\r
 424         public void OptionalImportsOfExportNullableValueTypesAreReboundToDefaultWhenExportIsRemoved()\r
 425         {\r
 426             var container = ContainerFactory.Create();\r
 427             var importer = new OptionalExport();\r
 428 \r
 429             CompositionBatch batch = new CompositionBatch();\r
 430             batch.AddPart(importer);\r
 431             var key = batch.AddExportedValue<int?>("NullableValueType", 10);\r
 432 \r
 433             container.Compose(batch);\r
 434             Assert.AreEqual(1, importer.NullableValueTypeSetCount);\r
 435             Assert.AreEqual(10, importer.NullableValueType.Value);\r
 436 \r
 437             batch = new CompositionBatch();\r
 438             batch.RemovePart(key);\r
 439             container.Compose(batch);\r
 440 \r
 441             Assert.AreEqual(2, importer.NullableValueTypeSetCount);\r
 442             Assert.IsNull(importer.NullableValueType);\r
 443         }\r
 444 \r
 445         [TestMethod]\r
 446         [TestProperty("Type", "Integration")]\r
 447         public void OptionalImportsOfExportReferenceTypesAreReboundToDefaultWhenExportIsRemoved()\r
 448         {\r
 449             var container = ContainerFactory.Create();\r
 450             var importer = new OptionalExport();\r
 451 \r
 452             CompositionBatch batch = new CompositionBatch();\r
 453             batch.AddPart(importer);\r
 454             var key = batch.AddExportedValue("ReferenceType", "Bar");\r
 455 \r
 456             container.Compose(batch);\r
 457             Assert.AreEqual(1, importer.ReferenceTypeSetCount);\r
 458             Assert.AreEqual("Bar", importer.ReferenceType.Value);\r
 459 \r
 460             batch = new CompositionBatch();\r
 461             batch.RemovePart(key);\r
 462             container.Compose(batch);\r
 463 \r
 464             Assert.AreEqual(2, importer.ReferenceTypeSetCount);\r
 465             Assert.IsNull(importer.ReferenceType);\r
 466         }\r
 467 \r
 468         public class OptionalImport\r
 469         {\r
 470             public int ValueTypeSetCount;\r
 471             public int NullableValueTypeSetCount;\r
 472             public int ReferenceTypeSetCount;\r
 473 \r
 474             private int _valueType;\r
 475             private int? _nullableValueType;\r
 476             private string _referenceType;\r
 477 \r
 478             [Import("ValueType", AllowDefault = true, AllowRecomposition = true)]\r
 479             public int ValueType\r
 480             {\r
 481                 get { return _valueType; }\r
 482                 set\r
 483                 {\r
 484                     ValueTypeSetCount++;\r
 485                     _valueType = value;\r
 486                 }\r
 487             }\r
 488 \r
 489             [Import("NullableValueType", AllowDefault = true, AllowRecomposition = true)]\r
 490             public int? NullableValueType\r
 491             {\r
 492                 get { return _nullableValueType; }\r
 493                 set\r
 494                 {\r
 495                     NullableValueTypeSetCount++;\r
 496                     _nullableValueType = value;\r
 497                 }\r
 498             }\r
 499 \r
 500             [Import("ReferenceType", AllowDefault = true, AllowRecomposition = true)]\r
 501             public string ReferenceType\r
 502             {\r
 503                 get { return _referenceType; }\r
 504                 set \r
 505                 {\r
 506                     ReferenceTypeSetCount++;\r
 507                     _referenceType = value; \r
 508                 }\r
 509             }\r
 510         }\r
 511 \r
 512         public class OptionalExport\r
 513         {\r
 514             public int ValueTypeSetCount;\r
 515             public int NullableValueTypeSetCount;\r
 516             public int ReferenceTypeSetCount;\r
 517 \r
 518             private Lazy<int> _valueType;\r
 519             private Lazy<int?> _nullableValueType;\r
 520             private Lazy<string> _referenceType;\r
 521 \r
 522             [Import("ValueType", AllowDefault = true, AllowRecomposition = true)]\r
 523             public Lazy<int> ValueType\r
 524             {\r
 525                 get { return _valueType; }\r
 526                 set\r
 527                 {\r
 528                     ValueTypeSetCount++;\r
 529                     _valueType = value;\r
 530                 }\r
 531             }\r
 532 \r
 533             [Import("NullableValueType", AllowDefault = true, AllowRecomposition = true)]\r
 534             public Lazy<int?> NullableValueType\r
 535             {\r
 536                 get { return _nullableValueType; }\r
 537                 set\r
 538                 {\r
 539                     NullableValueTypeSetCount++;\r
 540                     _nullableValueType = value;\r
 541                 }\r
 542             }\r
 543 \r
 544             [Import("ReferenceType", AllowDefault = true, AllowRecomposition = true)]\r
 545             public Lazy<string> ReferenceType\r
 546             {\r
 547                 get { return _referenceType; }\r
 548                 set\r
 549                 {\r
 550                     ReferenceTypeSetCount++;\r
 551                     _referenceType = value;\r
 552                 }\r
 553             }\r
 554         }\r
 555 \r
 556         private class DelayDuckImporter\r
 557         {\r
 558             [Import("Duck")]\r
 559             public Lazy<IDuck> Duck\r
 560             {\r
 561                 get;\r
 562                 set;\r
 563             }\r
 564         }\r
 565 \r
 566         private class DuckImporter\r
 567         {\r
 568             [Import("Duck")]\r
 569             public IDuck Duck\r
 570             {\r
 571                 get;\r
 572                 set;\r
 573             }\r
 574         }\r
 575 \r
 576         public class QuackLikeADuck\r
 577         {\r
 578             public virtual string Quack()\r
 579             {\r
 580                 return "Quack";\r
 581             }\r
 582         }\r
 583 \r
 584         public interface IDuck\r
 585         {\r
 586             string Quack();            \r
 587         }\r
 588 \r
 589         #if !SILVERLIGHT\r
 590 \r
 591         [ComImport]\r
 592         [Guid("148BD52A-A2AB-11CE-B11F-00AA00530503")]\r
 593         private class CTaskScheduler\r
 594         {   // This interface doesn't implement \r
 595             // ITaskScheduler deliberately\r
 596         }\r
 597 \r
 598         [Guid("148BD527-A2AB-11CE-B11F-00AA00530503")]\r
 599         [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]\r
 600         private interface ITaskScheduler\r
 601         {\r
 602             void FakeMethod();\r
 603         }\r
 604 \r
 605         private class ImportComComponent\r
 606         {\r
 607             [Import("TaskScheduler")]\r
 608             public ITaskScheduler TaskScheduler\r
 609             {\r
 610                 get;\r
 611                 set;\r
 612             }\r
 613         }\r
 614 \r
 615         private class DelayImportComComponent\r
 616         {\r
 617             [Import("TaskScheduler")]\r
 618             public Lazy<ITaskScheduler> TaskScheduler\r
 619             {\r
 620                 get;\r
 621                 set;\r
 622             }\r
 623         }\r
 624 \r
 625 #endif\r
 626 \r
 627         public class Importer\r
 628         {\r
 629             public Importer()\r
 630             {\r
 631             }\r
 632 \r
 633             [Import("Value")]\r
 634             public int ValueReadWrite { get; set; }\r
 635 \r
 636             [ImportMany("Value")]\r
 637             public IList<int> SingleValueCollectionReadWrite { get; set; }\r
 638 \r
 639             [Import("EmptyValue", AllowDefault = true)]\r
 640             public int ValueEmptyOptional { get; set; }\r
 641 \r
 642             [ImportMany("CollectionValue", typeof(IList<int>))]\r
 643             public IList<int> ValueCollection { get; set; }\r
 644 \r
 645         }\r
 646 \r
 647         public class ImporterNameless\r
 648         {\r
 649 \r
 650             public ImporterNameless()\r
 651             {\r
 652             }\r
 653 \r
 654             [Import]\r
 655             public int ValueReadWrite { get; set; }\r
 656 \r
 657             [Import]\r
 658             public Lazy<int> MetadataReadWrite { get; set; }\r
 659 \r
 660         }\r
 661 \r
 662         public class ImporterInvalidWrongType\r
 663         {\r
 664             [Import("Value")]\r
 665             public DateTime ValueReadWrite { get; set; }\r
 666         }\r
 667 \r
 668         [Export]\r
 669         public class ImporterInvalidSetterException\r
 670         {\r
 671             [ImportMany("Value")]\r
 672             public IEnumerable<int> ValueReadWrite { get { return null; } set { throw new InvalidOperationException(); } }\r
 673         }\r
 674 \r
 675         [Export]\r
 676         public class ImportImporterInvalidSetterExceptionLazily\r
 677         {\r
 678             [Import]\r
 679             public Lazy<ImporterInvalidSetterException> Value { get; set; }\r
 680         }\r
 681 \r
 682 \r
 683         [PartNotDiscoverable]\r
 684         public class Exporter\r
 685         {\r
 686             List<int> collectionValue = new List<int>();\r
 687 \r
 688             public Exporter(int value)\r
 689             {\r
 690                 Value = value;\r
 691             }\r
 692 \r
 693             [Export("Value")]\r
 694             public int Value { get; set; }\r
 695 \r
 696 \r
 697             [Export("CollectionValue")]\r
 698             public IList<int> CollectionValue { get { return collectionValue; } }\r
 699 \r
 700         }\r
 701 \r
 702         public class ExporterNameless\r
 703         {\r
 704 \r
 705             public ExporterNameless(int value)\r
 706             {\r
 707                 Value = value;\r
 708             }\r
 709 \r
 710             [Export]\r
 711             public int Value { get; set; }\r
 712 \r
 713         }\r
 714 \r
 715         public class ExportsString\r
 716         {\r
 717             [Export]\r
 718             public string ExportedString = "Test";\r
 719         }\r
 720 \r
 721         public class ExportsInvalidListOfExportOfString\r
 722         {\r
 723             [Export(typeof(List<Lazy<string>>))]\r
 724             public string ExportedString = "Test";\r
 725         }\r
 726 \r
 727         public class ExportsValidListOfExportOfString\r
 728         {\r
 729             [Export(typeof(List<Lazy<string>>))]\r
 730             public List<Lazy<string>> ExportedString = new List<Lazy<string>>();\r
 731         }\r
 732 \r
 733         [Export]\r
 734         public class ImportsListOfExportOfString\r
 735         {\r
 736             [Import(AllowDefault = true)]\r
 737             public List<Lazy<string>> ExportedList { get; set; }\r
 738         }\r
 739 \r
 740         [TestMethod]\r
 741         public void ImportListOfExportWithOnlySingleElementsAvailable_ShouldNotFindExport()\r
 742         {\r
 743             var container = ContainerFactory.CreateWithAttributedCatalog(typeof(ExportsString), typeof(ImportsListOfExportOfString));\r
 744             var importer = container.GetExportedValue<ImportsListOfExportOfString>();\r
 745             Assert.IsNull(importer.ExportedList);\r
 746 \r
 747             var part = AttributedModelServices.CreatePartDefinition(typeof(ImportsListOfExportOfString), null);\r
 748             var contract = AttributedModelServices.GetContractName(typeof(List<Lazy<string>>));\r
 749             Assert.AreEqual(contract, ((ContractBasedImportDefinition)part.ImportDefinitions.First()).ContractName);\r
 750         }\r
 751 \r
 752         [TestMethod]\r
 753         public void ImportListOfExportWithInvalidCollectionAvailable_ShouldThrowMismatch()\r
 754         {\r
 755             var container = ContainerFactory.CreateWithAttributedCatalog(typeof(ExportsInvalidListOfExportOfString), typeof(ImportsListOfExportOfString));\r
 756 \r
 757             CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotGetExportedValue, () =>\r
 758                 container.GetExportedValue<ImportsListOfExportOfString>());\r
 759         }\r
 760 \r
 761         [TestMethod]\r
 762         public void ImportListOfExportWithValidCollectionAvailable_ShouldSatisfyImport()\r
 763         {\r
 764             var container = ContainerFactory.CreateWithAttributedCatalog(typeof(ExportsValidListOfExportOfString), typeof(ImportsListOfExportOfString));\r
 765             var importer = container.GetExportedValue<ImportsListOfExportOfString>();\r
 766             Assert.AreEqual(0, importer.ExportedList.Count);\r
 767         }\r
 768     }\r
 769 }\r