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

   1 // -----------------------------------------------------------------------\r
   2 // Copyright (c) Microsoft Corporation.  All rights reserved.\r
   3 // -----------------------------------------------------------------------\r
   4 using System;\r
   5 using System.Collections;\r
   6 using System.Collections.Generic;\r
   7 using System.Collections.ObjectModel;\r
   8 using System.ComponentModel.Composition;\r
   9 using System.Linq;\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.UnitTesting;\r
  14 using System.ComponentModel.Composition.Hosting;\r
  15 \r
  16 namespace System.ComponentModel.Composition\r
  17 {\r
  18     [TestClass]\r
  19     public class CompositionContainerCollectionTests\r
  20     {\r
  21         public class SupportedImportCollectionAssignments<T>\r
  22         {\r
  23             // Fields\r
  24             [ImportMany("Value")]\r
  25             public IEnumerable<T> IEnumerableOfTField;\r
  26 \r
  27             [ImportMany("Value")]\r
  28             public IEnumerable<object> IEnumerableOfObjectField;\r
  29 \r
  30             [ImportMany("Value")]\r
  31             public T[] ArrayOfTField;\r
  32 \r
  33             [ImportMany("Value")]\r
  34             public object[] ArrayOfObjectField;\r
  35 \r
  36             [ImportMany("Value")]\r
  37             public IEnumerable<T> IEnumerableOfTProperty { get; set; }\r
  38 \r
  39             [ImportMany("Value")]\r
  40             public IEnumerable<object> IEnumerableOfObjectProperty { get; set; }\r
  41 \r
  42             [ImportMany("Value")]\r
  43             public T[] ArrayOfTProperty { get; set; }\r
  44 \r
  45             [ImportMany("Value")]\r
  46             public object[] ArrayOfObjectProperty { get; set; }\r
  47             \r
  48             public void VerifyImports(params T[] expectedValues)\r
  49             {\r
  50                 // Fields\r
  51                 EnumerableAssert.AreEqual(IEnumerableOfTField, expectedValues);\r
  52                 EnumerableAssert.AreEqual(IEnumerableOfObjectField, expectedValues.Cast<object>());\r
  53                 EnumerableAssert.AreEqual(ArrayOfTField, expectedValues);\r
  54                 EnumerableAssert.AreEqual(ArrayOfObjectField, expectedValues.Cast<object>());\r
  55 \r
  56                 // Properties\r
  57                 EnumerableAssert.AreEqual(IEnumerableOfTProperty, expectedValues);\r
  58                 EnumerableAssert.AreEqual(IEnumerableOfObjectProperty, expectedValues.Cast<object>());\r
  59                 EnumerableAssert.AreEqual(ArrayOfTProperty, expectedValues);\r
  60                 EnumerableAssert.AreEqual(ArrayOfObjectProperty, expectedValues.Cast<object>());\r
  61             }\r
  62         }\r
  63 \r
  64         [TestMethod]\r
  65         public void ValidateSupportedImportCollectionAssignments()\r
  66         {\r
  67             var container = ContainerFactory.Create();\r
  68             var batch = new CompositionBatch();\r
  69 \r
  70             var importer = new SupportedImportCollectionAssignments<int>();\r
  71 \r
  72             batch.AddPart(importer);\r
  73             batch.AddExportedValue("Value", 21);\r
  74             batch.AddExportedValue("Value", 32);\r
  75             batch.AddExportedValue("Value", 43);\r
  76 \r
  77             container.Compose(batch);\r
  78 \r
  79             importer.VerifyImports(21, 32, 43);\r
  80         }\r
  81 \r
  82         public class SupportedImportCollectionMutation<T>\r
  83         {\r
  84             public SupportedImportCollectionMutation()\r
  85             {\r
  86                 ICollectionOfTReadOnlyField = new List<T>();\r
  87                 ListOfTReadOnlyField = new List<T>();\r
  88                 CollectionOfTField = new Collection<T>();\r
  89                 CollectionOfTReadOnlyField = new Collection<T>();\r
  90 \r
  91                 _iCollectionOfTReadOnlyProperty = new List<T>();\r
  92                 _listOfTReadOnlyProperty = new List<T>();\r
  93                 CollectionOfTProperty = new Collection<T>();\r
  94                 _collectionOfTReadOnlyProperty = new Collection<T>();\r
  95 \r
  96 #if !SILVERLIGHT\r
  97                 ObservableCollectionOfTReadOnlyField = new ObservableCollection<T>();\r
  98                 _observableCollectionOfTReadOnlyProperty = new ObservableCollection<T>();\r
  99 #endif // !SILVERLIGHT\r
 100             }\r
 101 \r
 102             [ImportMany("Value")]\r
 103             public readonly ICollection<T> ICollectionOfTReadOnlyField;\r
 104 \r
 105             [ImportMany("Value")]\r
 106             public List<T> ListOfTField;\r
 107 \r
 108             [ImportMany("Value")]\r
 109             public readonly List<T> ListOfTReadOnlyField;\r
 110 \r
 111             [ImportMany("Value")]\r
 112             public Collection<T> CollectionOfTField;\r
 113             \r
 114             [ImportMany("Value")]\r
 115             public Collection<object> CollectionOfObjectField;\r
 116 \r
 117             [ImportMany("Value")]\r
 118             public readonly Collection<T> CollectionOfTReadOnlyField;\r
 119 \r
 120             [ImportMany("Value")]\r
 121             public ICollection<T> ICollectionOfTReadOnlyProperty { get { return _iCollectionOfTReadOnlyProperty; } }\r
 122             private ICollection<T> _iCollectionOfTReadOnlyProperty;\r
 123 \r
 124             [ImportMany("Value")]\r
 125             public List<T> ListOfTProperty { get; set; }\r
 126 \r
 127             [ImportMany("Value")]\r
 128             public List<T> ListOfTReadOnlyProperty { get { return _listOfTReadOnlyProperty; } }\r
 129             private readonly List<T> _listOfTReadOnlyProperty;\r
 130 \r
 131             [ImportMany("Value")]\r
 132             public Collection<T> CollectionOfTProperty { get; set; }\r
 133 \r
 134             [ImportMany("Value")]\r
 135             public Collection<T> CollectionOfTReadOnlyProperty { get { return _collectionOfTReadOnlyProperty; } }\r
 136             private readonly Collection<T> _collectionOfTReadOnlyProperty;\r
 137 \r
 138 #if !SILVERLIGHT\r
 139             [ImportMany("Value")]\r
 140             public ObservableCollection<T> ObservableCollectionOfTField;\r
 141 \r
 142             [ImportMany("Value")]\r
 143             public readonly ObservableCollection<T> ObservableCollectionOfTReadOnlyField;\r
 144 \r
 145             [ImportMany("Value")]\r
 146             public ObservableCollection<T> ObservableCollectionOfTProperty { get; set; }\r
 147 \r
 148             [ImportMany("Value")]\r
 149             public ObservableCollection<T> ObservableCollectionOfTReadOnlyProperty { get { return _observableCollectionOfTReadOnlyProperty; } }\r
 150             private readonly ObservableCollection<T> _observableCollectionOfTReadOnlyProperty;\r
 151 #endif // !SILVERLIGHT\r
 152 \r
 153             public void VerifyImports(params T[] expectedValues)\r
 154             {\r
 155                 EnumerableAssert.AreEqual(ICollectionOfTReadOnlyField, expectedValues);\r
 156                 EnumerableAssert.AreEqual(ListOfTField, expectedValues);\r
 157                 EnumerableAssert.AreEqual(ListOfTReadOnlyField, expectedValues);\r
 158                 EnumerableAssert.AreEqual(CollectionOfTField, expectedValues);\r
 159                 EnumerableAssert.AreEqual(CollectionOfTReadOnlyField, expectedValues);\r
 160 \r
 161                 EnumerableAssert.AreEqual(ICollectionOfTReadOnlyProperty, expectedValues);\r
 162                 EnumerableAssert.AreEqual(ListOfTProperty, expectedValues);\r
 163                 EnumerableAssert.AreEqual(ListOfTReadOnlyProperty, expectedValues);\r
 164                 EnumerableAssert.AreEqual(CollectionOfTProperty, expectedValues);\r
 165                 EnumerableAssert.AreEqual(CollectionOfTReadOnlyProperty, expectedValues);\r
 166                 \r
 167 #if !SILVERLIGHT\r
 168                 EnumerableAssert.AreEqual(ObservableCollectionOfTField, expectedValues);\r
 169                 EnumerableAssert.AreEqual(ObservableCollectionOfTReadOnlyField, expectedValues);\r
 170                 EnumerableAssert.AreEqual(ObservableCollectionOfTProperty, expectedValues);\r
 171                 EnumerableAssert.AreEqual(ObservableCollectionOfTReadOnlyProperty, expectedValues);\r
 172 #endif // !SILVERLIGHT\r
 173             }\r
 174         }\r
 175 \r
 176         [TestMethod]\r
 177         public void ValidateSupportedImportCollectionMutation()\r
 178         {\r
 179             var container = ContainerFactory.Create();\r
 180             var batch = new CompositionBatch();\r
 181 \r
 182             var importer = new SupportedImportCollectionMutation<int>();\r
 183 \r
 184             batch.AddPart(importer);\r
 185             batch.AddExportedValue("Value", 21);\r
 186             batch.AddExportedValue("Value", 32);\r
 187             batch.AddExportedValue("Value", 43);\r
 188 \r
 189             container.Compose(batch);\r
 190 \r
 191             importer.VerifyImports(21, 32, 43);\r
 192         }\r
 193 \r
 194         public class ImportCollectionNullValue\r
 195         {\r
 196             [ImportMany("Value")]\r
 197             public List<int> NullValue { get; set; }\r
 198         }\r
 199 \r
 200         public class NamelessImporter\r
 201         {\r
 202             [ImportMany]\r
 203             public int[] ReadWriteIList { get; set; }\r
 204 \r
 205             [ImportMany]\r
 206             public Collection<Lazy<int>> ReadWriteMetadata { get; set; }\r
 207         }\r
 208 \r
 209         public class NamelessExporter\r
 210         {\r
 211             public NamelessExporter(int value)\r
 212             {\r
 213                 Value = value;\r
 214             }\r
 215 \r
 216             [Export]\r
 217             public int Value { get; set; }\r
 218         }\r
 219 \r
 220         [TestMethod]\r
 221         public void ImportCollectionsNameless()\r
 222         {\r
 223             // Verifing that the contract name gets the correct value\r
 224             var container = ContainerFactory.Create();\r
 225             NamelessImporter importer = new NamelessImporter();\r
 226             NamelessExporter exporter42 = new NamelessExporter(42);\r
 227             NamelessExporter exporter0 = new NamelessExporter(0);\r
 228 \r
 229             CompositionBatch batch = new CompositionBatch();\r
 230             batch.AddParts(importer, exporter42, exporter0);\r
 231             container.Compose(batch);\r
 232 \r
 233             EnumerableAssert.AreEqual(importer.ReadWriteIList, 42, 0);\r
 234         }\r
 235 \r
 236         public class InvalidImporterReadOnlyEnumerable\r
 237         {\r
 238             IEnumerable<int> readOnlyEnumerable = new List<int>();\r
 239 \r
 240             [ImportMany("Value")]\r
 241             public IEnumerable<int> ReadOnlyEnumerable\r
 242             {\r
 243                 get\r
 244                 {\r
 245                     return readOnlyEnumerable;\r
 246                 }\r
 247             }\r
 248         }\r
 249 \r
 250         [TestMethod]\r
 251         public void ImportCollectionsExceptionReadOnlyEnumerable()\r
 252         {\r
 253             ExpectedErrorOnPartActivate(new InvalidImporterReadOnlyEnumerable(),\r
 254                 ErrorId.ReflectionModel_ImportCollectionNotWritable);  \r
 255         }\r
 256 \r
 257         public class ImporterWriteOnlyExportCollection\r
 258         {\r
 259             [ImportMany("Value")]\r
 260             public Collection<Lazy<int>> WriteOnlyExportCollection\r
 261             {\r
 262                 set { PublicExportCollection = value; }\r
 263             }\r
 264 \r
 265             public Collection<Lazy<int>> PublicExportCollection { get; set; }\r
 266         }\r
 267 \r
 268         [TestMethod]\r
 269         public void ImportCollections_WriteOnlyExportCollection()\r
 270         {\r
 271             var container = ContainerFactory.Create();\r
 272             var batch = new CompositionBatch();\r
 273 \r
 274             var importer = new ImporterWriteOnlyExportCollection();\r
 275 \r
 276             List<int> values = new List<int>() { 21, 32, 43 };\r
 277 \r
 278             batch.AddPart(importer);\r
 279             values.ForEach(v => batch.AddExportedValue("Value", v));\r
 280 \r
 281             container.Compose(batch);\r
 282 \r
 283             EnumerableAssert.AreEqual(values, importer.PublicExportCollection.Select(export => export.Value));            \r
 284         }\r
 285 \r
 286         public class ImporterWriteOnlyIEnumerableOfT\r
 287         {\r
 288             [ImportMany("Value")]\r
 289             public IEnumerable<int> WriteOnlyIEnumerable\r
 290             {\r
 291                 set { PublicIEnumerable = value; }\r
 292             }\r
 293 \r
 294             public IEnumerable<int> PublicIEnumerable { get; set; }\r
 295         }\r
 296 \r
 297         [TestMethod]\r
 298         public void ImportCollections_WriteOnlyIEnumerableOfT()\r
 299         {\r
 300             var container = ContainerFactory.Create();\r
 301             var batch = new CompositionBatch();\r
 302 \r
 303             var importer = new ImporterWriteOnlyIEnumerableOfT();\r
 304 \r
 305             List<int> values = new List<int>() { 21, 32, 43 };\r
 306 \r
 307             batch.AddPart(importer);\r
 308             values.ForEach(v => batch.AddExportedValue("Value", v));\r
 309 \r
 310             container.Compose(batch);\r
 311 \r
 312             EnumerableAssert.AreEqual(values, importer.PublicIEnumerable);\r
 313         }\r
 314 \r
 315         public class ImporterWriteOnlyArray\r
 316         {\r
 317             [ImportMany("Value")]\r
 318             public int[] WriteOnlyArray\r
 319             {\r
 320                 set { PublicArray = value; }\r
 321             }\r
 322 \r
 323             public int[] PublicArray { get; set; }\r
 324         }\r
 325 \r
 326         [TestMethod]\r
 327         public void ImportCollections_WriteOnlyArray()\r
 328         {\r
 329             var container = ContainerFactory.Create();\r
 330             var batch = new CompositionBatch();\r
 331 \r
 332             var importer = new ImporterWriteOnlyArray();\r
 333 \r
 334             List<int> values = new List<int>() { 21, 32, 43 };\r
 335 \r
 336             batch.AddPart(importer);\r
 337             values.ForEach(v => batch.AddExportedValue("Value", v));\r
 338 \r
 339             container.Compose(batch);\r
 340 \r
 341             EnumerableAssert.AreEqual(values, importer.PublicArray);\r
 342         }\r
 343 \r
 344         public class InvalidImporterNonCollection\r
 345         {\r
 346             [Import("Value")]\r
 347             public int Value { get; set; }\r
 348         }\r
 349 \r
 350         [TestMethod]\r
 351         public void ImportCollectionsExceptionNonCollection()\r
 352         {\r
 353             ExpectedChangeRejectedErrorOnSetImport(new InvalidImporterNonCollection(),\r
 354                 ErrorId.ImportEngine_ImportCardinalityMismatch);\r
 355         }\r
 356 \r
 357         public class InvalidImporterNonAssignableCollection\r
 358         {\r
 359             [ImportMany("Value", typeof(int))]\r
 360             public IEnumerable<string> StringCollection { get; set; }\r
 361         }\r
 362 \r
 363         [TestMethod]\r
 364         public void ImportCollectionsExceptionNonAssignableCollection()\r
 365         {\r
 366             ExpectedErrorOnSetImport(new InvalidImporterNonAssignableCollection(),\r
 367                 ErrorId.ReflectionModel_ImportNotAssignableFromExport);  \r
 368         }\r
 369 \r
 370         public class InvalidImporterNullReadOnlyICollection\r
 371         {\r
 372             ICollection<int> readOnlyICollection = null;\r
 373 \r
 374             [ImportMany("Value")]\r
 375             public ICollection<int> Values { get { return readOnlyICollection; } }\r
 376         }\r
 377 \r
 378         [TestMethod]\r
 379         public void ImportCollectionsExceptionNullReadOnlyICollection()\r
 380         {\r
 381             ExpectedErrorOnPartActivate(new InvalidImporterNullReadOnlyICollection(),\r
 382                 ErrorId.ReflectionModel_ImportCollectionNull);   \r
 383         }\r
 384 \r
 385         public class ImporterWeakIEnumerable\r
 386         {\r
 387             public ImporterWeakIEnumerable()\r
 388             {\r
 389                 ReadWriteEnumerable = new IntCollection();\r
 390             }\r
 391 \r
 392             [ImportMany("Value")]\r
 393             public IntCollection ReadWriteEnumerable { get; set; }\r
 394 \r
 395             public class IntCollection : IEnumerable\r
 396             {\r
 397                 List<int> ints = new List<int>();\r
 398                 public void Add(int item) { ints.Add(item); }\r
 399                 public void Clear() { ints.Clear(); }\r
 400                 public bool Remove(int item) { return ints.Remove(item); }\r
 401                 public IEnumerator GetEnumerator() { return ints.GetEnumerator(); }\r
 402             }\r
 403         }\r
 404 \r
 405         [TestMethod]\r
 406         public void ImportCollectionsExceptionWeakCollectionNotSupportingICollectionOfT()\r
 407         {\r
 408             ExpectedErrorOnPartActivate(new ImporterWeakIEnumerable(),\r
 409                 ErrorId.ReflectionModel_ImportCollectionNotWritable);\r
 410         }\r
 411 \r
 412         public class ImporterThrowsOnGetting\r
 413         {\r
 414             [ImportMany("Value")]\r
 415             public List<int> Value\r
 416             {\r
 417                 get\r
 418                 {\r
 419                     throw new NotSupportedException();\r
 420                 }\r
 421             }\r
 422         }\r
 423 \r
 424         [TestMethod]\r
 425         public void ImportCollectionsExceptionGettingValue()\r
 426         {\r
 427             var container = ContainerFactory.Create();\r
 428             ImporterThrowsOnGetting importer = new ImporterThrowsOnGetting();\r
 429             CompositionBatch batch = new CompositionBatch();\r
 430             batch.AddPart(importer);\r
 431             batch.AddExportedValue("Value", 42);\r
 432             batch.AddExportedValue("Value", 0);\r
 433 \r
 434             CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotActivate,\r
 435                                           ErrorId.ReflectionModel_ImportCollectionGetThrewException, RetryMode.DoNotRetry, () =>\r
 436                                           {\r
 437                                               container.Compose(batch);\r
 438                                           });\r
 439         }\r
 440 \r
 441         public class CustomCollectionThrowsDuringConstruction : Collection<int>\r
 442         {\r
 443             public CustomCollectionThrowsDuringConstruction()\r
 444             {\r
 445                 throw new NotSupportedException();\r
 446             }\r
 447         }\r
 448 \r
 449         public class ImportCustomCollectionThrowsDuringConstruction\r
 450         {\r
 451             public ImportCustomCollectionThrowsDuringConstruction()\r
 452             {\r
 453             }\r
 454 \r
 455             [ImportMany("Value")]\r
 456             public CustomCollectionThrowsDuringConstruction Values { get; set; }\r
 457         }\r
 458 \r
 459         [TestMethod]\r
 460         public void ImportCollections_ImportTypeThrowsOnConstruction()\r
 461         {\r
 462             ExpectedErrorOnPartActivate(new ImportCustomCollectionThrowsDuringConstruction(),\r
 463                 ErrorId.ReflectionModel_ImportCollectionConstructionThrewException);\r
 464         }\r
 465 \r
 466         public class CustomCollectionThrowsDuringClear : Collection<int>\r
 467         {\r
 468             protected override void ClearItems()\r
 469             {\r
 470                 throw new NotSupportedException();\r
 471             }\r
 472         }\r
 473 \r
 474         public class ImportCustomCollectionThrowsDuringClear\r
 475         {\r
 476             public ImportCustomCollectionThrowsDuringClear()\r
 477             {\r
 478             }\r
 479 \r
 480             [ImportMany("Value")]\r
 481             public CustomCollectionThrowsDuringClear Values { get; set; }\r
 482         }\r
 483 \r
 484         [TestMethod]\r
 485         public void ImportCollections_ImportTypeThrowsOnClear()\r
 486         {\r
 487             ExpectedErrorOnPartActivate(new ImportCustomCollectionThrowsDuringClear(),\r
 488                 ErrorId.ReflectionModel_ImportCollectionClearThrewException);\r
 489         }\r
 490 \r
 491         public class CustomCollectionThrowsDuringAdd : Collection<int>\r
 492         {\r
 493             protected override void InsertItem(int index, int item)\r
 494             {\r
 495                 throw new NotSupportedException();\r
 496             }\r
 497         }\r
 498 \r
 499         public class ImportCustomCollectionThrowsDuringAdd\r
 500         {\r
 501             public ImportCustomCollectionThrowsDuringAdd()\r
 502             {\r
 503             }\r
 504 \r
 505             [ImportMany("Value")]\r
 506             public CustomCollectionThrowsDuringAdd Values { get; set; }\r
 507         }\r
 508 \r
 509         [TestMethod]\r
 510         public void ImportCollections_ImportTypeThrowsOnAdd()\r
 511         {\r
 512             ExpectedErrorOnPartActivate(new ImportCustomCollectionThrowsDuringAdd(),\r
 513                 ErrorId.ReflectionModel_ImportCollectionAddThrewException);\r
 514         }\r
 515 \r
 516         public class CustomCollectionThrowsDuringIsReadOnly : ICollection<int>\r
 517         {\r
 518             void ICollection<int>.Add(int item)\r
 519             {\r
 520                 throw new NotImplementedException();\r
 521             }\r
 522 \r
 523             void ICollection<int>.Clear()\r
 524             {\r
 525                 throw new NotImplementedException();\r
 526             }\r
 527 \r
 528             bool ICollection<int>.Contains(int item)\r
 529             {\r
 530                 throw new NotImplementedException();\r
 531             }\r
 532 \r
 533             void ICollection<int>.CopyTo(int[] array, int arrayIndex)\r
 534             {\r
 535                 throw new NotImplementedException();\r
 536             }\r
 537 \r
 538             int ICollection<int>.Count\r
 539             {\r
 540                 get { throw new NotImplementedException(); }\r
 541             }\r
 542 \r
 543             bool ICollection<int>.IsReadOnly\r
 544             {\r
 545                 get { throw new NotSupportedException(); }\r
 546             }\r
 547 \r
 548             bool ICollection<int>.Remove(int item)\r
 549             {\r
 550                 throw new NotImplementedException();\r
 551             }\r
 552 \r
 553             IEnumerator<int> IEnumerable<int>.GetEnumerator()\r
 554             {\r
 555                 throw new NotImplementedException();\r
 556             }\r
 557 \r
 558             IEnumerator IEnumerable.GetEnumerator()\r
 559             {\r
 560                 throw new NotImplementedException();\r
 561             }\r
 562         }\r
 563 \r
 564         public class ImportCustomCollectionThrowsDuringIsReadOnly\r
 565         {\r
 566             public ImportCustomCollectionThrowsDuringIsReadOnly()\r
 567             {\r
 568                 Values = new CustomCollectionThrowsDuringIsReadOnly();\r
 569             }\r
 570 \r
 571             [ImportMany("Value")]\r
 572             public CustomCollectionThrowsDuringIsReadOnly Values { get; set; }\r
 573         }\r
 574 \r
 575         [TestMethod]\r
 576         public void ImportCollections_ImportTypeThrowsOnIsReadOnly()\r
 577         {\r
 578             ExpectedErrorOnPartActivate(new ImportCustomCollectionThrowsDuringIsReadOnly(),\r
 579                 ErrorId.ReflectionModel_ImportCollectionIsReadOnlyThrewException);\r
 580         }\r
 581 \r
 582         public class CollectionTypeWithNoIList<T> : ICollection<T>\r
 583         {\r
 584             private int _count = 0;\r
 585             public CollectionTypeWithNoIList()\r
 586             {\r
 587                 \r
 588             }\r
 589 \r
 590             public void Add(T item)\r
 591             {\r
 592                 // Do Nothing\r
 593                 this._count++;\r
 594             }\r
 595 \r
 596             public void Clear()\r
 597             {\r
 598                 // Do Nothings\r
 599             }\r
 600 \r
 601             public bool Contains(T item)\r
 602             {\r
 603                 throw new NotImplementedException();\r
 604             }\r
 605 \r
 606             public void CopyTo(T[] array, int arrayIndex)\r
 607             {\r
 608                 throw new NotImplementedException();\r
 609             }\r
 610 \r
 611             public int Count\r
 612             {\r
 613                 get { return this._count; }\r
 614             }\r
 615 \r
 616             public bool IsReadOnly\r
 617             {\r
 618                 get { return false; }\r
 619             }\r
 620 \r
 621             public bool Remove(T item)\r
 622             {\r
 623                 throw new NotImplementedException();\r
 624             }\r
 625 \r
 626             public IEnumerator<T> GetEnumerator()\r
 627             {\r
 628                 throw new NotImplementedException();\r
 629             }\r
 630 \r
 631             IEnumerator IEnumerable.GetEnumerator()\r
 632             {\r
 633                 throw new NotImplementedException();\r
 634             }\r
 635         }\r
 636 \r
 637         public class ImportCollectionWithNoIList\r
 638         {\r
 639             [ImportMany("Value")]\r
 640             public CollectionTypeWithNoIList<int> Values { get; set; }\r
 641         }\r
 642 \r
 643         [TestMethod]\r
 644         public void ImportCollections_NoIList_ShouldWorkFine()\r
 645         {\r
 646             var container = ContainerFactory.Create();\r
 647             var batch = new CompositionBatch();\r
 648             var importer = new ImportCollectionWithNoIList();\r
 649             batch.AddPart(importer);\r
 650             batch.AddExportedValue("Value", 42);\r
 651             batch.AddExportedValue("Value", 0);\r
 652 \r
 653             container.Compose(batch);\r
 654 \r
 655             Assert.AreEqual(2, importer.Values.Count);\r
 656         }\r
 657 \r
 658         public class CollectionWithMultipleInterfaces :  ICollection<int>, ICollection<string>\r
 659         {\r
 660             private int _count = 0;\r
 661             public CollectionWithMultipleInterfaces()\r
 662             {\r
 663 \r
 664             }\r
 665 \r
 666             #region ICollection<int> Members\r
 667 \r
 668             void ICollection<int>.Add(int item)\r
 669             {\r
 670                 throw new NotImplementedException();\r
 671             }\r
 672 \r
 673             void ICollection<int>.Clear()\r
 674             {\r
 675                 throw new NotImplementedException();\r
 676             }\r
 677 \r
 678             bool ICollection<int>.Contains(int item)\r
 679             {\r
 680                 throw new NotImplementedException();\r
 681             }\r
 682 \r
 683             void ICollection<int>.CopyTo(int[] array, int arrayIndex)\r
 684             {\r
 685                 throw new NotImplementedException();\r
 686             }\r
 687 \r
 688             int ICollection<int>.Count\r
 689             {\r
 690                 get { throw new NotImplementedException(); }\r
 691             }\r
 692 \r
 693             bool ICollection<int>.IsReadOnly\r
 694             {\r
 695                 get { throw new NotImplementedException(); }\r
 696             }\r
 697 \r
 698             bool ICollection<int>.Remove(int item)\r
 699             {\r
 700                 throw new NotImplementedException();\r
 701             }\r
 702 \r
 703             IEnumerator<int> IEnumerable<int>.GetEnumerator()\r
 704             {\r
 705                 throw new NotImplementedException();\r
 706             }\r
 707 \r
 708             #endregion\r
 709 \r
 710             #region IEnumerable Members\r
 711 \r
 712             IEnumerator IEnumerable.GetEnumerator()\r
 713             {\r
 714                 throw new NotImplementedException();\r
 715             }\r
 716 \r
 717             #endregion\r
 718 \r
 719             #region ICollection<string> Members\r
 720 \r
 721             void ICollection<string>.Add(string item)\r
 722             {\r
 723                 throw new NotImplementedException();\r
 724             }\r
 725 \r
 726             void ICollection<string>.Clear()\r
 727             {\r
 728                 throw new NotImplementedException();\r
 729             }\r
 730 \r
 731             bool ICollection<string>.Contains(string item)\r
 732             {\r
 733                 throw new NotImplementedException();\r
 734             }\r
 735 \r
 736             void ICollection<string>.CopyTo(string[] array, int arrayIndex)\r
 737             {\r
 738                 throw new NotImplementedException();\r
 739             }\r
 740 \r
 741             int ICollection<string>.Count\r
 742             {\r
 743                 get { throw new NotImplementedException(); }\r
 744             }\r
 745 \r
 746             bool ICollection<string>.IsReadOnly\r
 747             {\r
 748                 get { throw new NotImplementedException(); }\r
 749             }\r
 750 \r
 751             bool ICollection<string>.Remove(string item)\r
 752             {\r
 753                 throw new NotImplementedException();\r
 754             }\r
 755 \r
 756             IEnumerator<string> IEnumerable<string>.GetEnumerator()\r
 757             {\r
 758                 throw new NotImplementedException();\r
 759             }\r
 760 \r
 761             #endregion\r
 762         }\r
 763 \r
 764         public class ImportCollectionWithMultipleInterfaces\r
 765         {\r
 766             [ImportMany("Value")]\r
 767             public CollectionWithMultipleInterfaces Values { get; set; }\r
 768         }\r
 769         \r
 770         [TestMethod]\r
 771         public void ImportCollections_MultipleICollections_ShouldCauseNotWriteable()\r
 772         {\r
 773             ExpectedErrorOnPartActivate(new ImportCollectionWithMultipleInterfaces(),\r
 774                 ErrorId.ReflectionModel_ImportCollectionNotWritable);\r
 775         }\r
 776 \r
 777         public class ImportManyNonCollectionTypeString\r
 778         {\r
 779             [ImportMany("Value")]\r
 780             public string Foo { get; set; }\r
 781         }\r
 782 \r
 783         [TestMethod]\r
 784         public void ImportManyOnNonCollectionTypeString_ShouldCauseNotWritable()\r
 785         {\r
 786             ExpectedErrorOnPartActivate(new ImportManyNonCollectionTypeString(),\r
 787                 ErrorId.ReflectionModel_ImportCollectionNotWritable);\r
 788         }\r
 789 \r
 790         public class ImportManyNonCollectionTypeObject\r
 791         {\r
 792             [ImportMany("Value")]\r
 793             public object Foo { get; set; }\r
 794         }\r
 795 \r
 796         [TestMethod]\r
 797         public void ImportManyOnNonCollectionTypeObject_ShouldCauseNotWritable()\r
 798         {\r
 799             ExpectedErrorOnPartActivate(new ImportManyNonCollectionTypeObject(),\r
 800                 ErrorId.ReflectionModel_ImportCollectionNotWritable);\r
 801         }\r
 802 \r
 803 #if !SILVERLIGHT \r
 804         // SILVERLIGHT doesn't have SetEnvironmentVariable set in this test.\r
 805         public class ExportADictionaryObject\r
 806         {\r
 807             [Export]\r
 808             public IDictionary<string, object> MyDictionary\r
 809             {\r
 810                 get\r
 811                 {\r
 812                     var dictionary = new Dictionary<string, object>();\r
 813                     dictionary.Add("a", 42);\r
 814                     dictionary.Add("b", "c");\r
 815                     return dictionary;\r
 816                 }\r
 817             }\r
 818         }\r
 819 \r
 820         public class ImportADictionaryObject\r
 821         {\r
 822             [Import]\r
 823             public IDictionary<string, object> MyDictionary { get; set; }\r
 824         }\r
 825 \r
 826         [TestMethod]\r
 827         public void ImportDictionaryAsSingleObject()\r
 828         {\r
 829             // Set variable to ensure the hack is turned off.\r
 830             Environment.SetEnvironmentVariable("ONLY_ALLOW_IMPORTMANY", "1");\r
 831 \r
 832             var container = ContainerFactory.Create();\r
 833             var batch = new CompositionBatch();\r
 834             var importer = new ImportADictionaryObject();\r
 835             var exporter = new ExportADictionaryObject();\r
 836 \r
 837             batch.AddPart(importer);\r
 838             batch.AddPart(exporter);\r
 839             container.Compose(batch);\r
 840 \r
 841             Assert.AreEqual(2, importer.MyDictionary.Count);\r
 842         }\r
 843 \r
 844         public class ExportACollectionObject\r
 845         {\r
 846             [Export]\r
 847             public Collection<string> MyCollection\r
 848             {\r
 849                 get\r
 850                 {\r
 851                     var collection = new Collection<string>();\r
 852                     collection.Add("a");\r
 853                     collection.Add("b");\r
 854                     return collection;\r
 855                 }\r
 856             }\r
 857         }\r
 858 \r
 859         public class ImportACollectionObject\r
 860         {\r
 861             [Import]\r
 862             public Collection<string> MyCollection { get; set; }\r
 863         }\r
 864 \r
 865         [TestMethod]\r
 866         public void ImportCollectionAsSingleObject()\r
 867         {\r
 868             // Set variable to ensure the hack is turned off.\r
 869             Environment.SetEnvironmentVariable("ONLY_ALLOW_IMPORTMANY", "1");\r
 870 \r
 871             var container = ContainerFactory.Create();\r
 872             var batch = new CompositionBatch();\r
 873             var importer = new ImportACollectionObject();\r
 874             var exporter = new ExportACollectionObject();\r
 875 \r
 876             batch.AddPart(importer);\r
 877             batch.AddPart(exporter);\r
 878             container.Compose(batch);\r
 879 \r
 880             Assert.AreEqual(2, importer.MyCollection.Count);\r
 881         }\r
 882 #endif\r
 883 \r
 884         public void ExpectedErrorOnPartActivate(object importer, ErrorId expectedErrorId)\r
 885         {\r
 886             var container = ContainerFactory.Create();\r
 887             var batch = new CompositionBatch();\r
 888             batch.AddPart(importer);\r
 889             batch.AddExportedValue("Value", 42);\r
 890             batch.AddExportedValue("Value", 0);\r
 891 \r
 892             CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotActivate,\r
 893               expectedErrorId, RetryMode.DoNotRetry, () =>\r
 894               {\r
 895                   container.Compose(batch);\r
 896               });\r
 897         }\r
 898 \r
 899         public void ExpectedErrorOnSetImport(object importer, ErrorId expectedErrorId)\r
 900         {\r
 901             var container = ContainerFactory.Create();\r
 902             var batch = new CompositionBatch();\r
 903             batch.AddPart(importer);\r
 904             batch.AddExportedValue("Value", 42);\r
 905             batch.AddExportedValue("Value", 0);\r
 906 \r
 907             CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotSetImport,\r
 908               expectedErrorId, RetryMode.DoNotRetry, () =>\r
 909               {\r
 910                   container.Compose(batch);\r
 911               });\r
 912         }\r
 913 \r
 914         public void ExpectedChangeRejectedErrorOnSetImport(object importer, ErrorId expectedErrorId)\r
 915         {\r
 916             var container = ContainerFactory.Create();\r
 917             var batch = new CompositionBatch();\r
 918             batch.AddPart(importer);\r
 919             batch.AddExportedValue("Value", 42);\r
 920             batch.AddExportedValue("Value", 0);\r
 921 \r
 922             CompositionAssert.ThrowsChangeRejectedError(ErrorId.ImportEngine_PartCannotSetImport,\r
 923               expectedErrorId, RetryMode.DoNotRetry, () =>\r
 924               {\r
 925                   container.Compose(batch);\r
 926               });\r
 927         }\r
 928     }\r
 929 }\r