1 // -----------------------------------------------------------------------
\r
2 // Copyright (c) Microsoft Corporation. All rights reserved.
\r
3 // -----------------------------------------------------------------------
\r
5 using System.Collections;
\r
6 using System.Collections.Generic;
\r
7 using System.Collections.ObjectModel;
\r
8 using System.ComponentModel.Composition;
\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
16 namespace System.ComponentModel.Composition
\r
19 public class CompositionContainerCollectionTests
\r
21 public class SupportedImportCollectionAssignments<T>
\r
24 [ImportMany("Value")]
\r
25 public IEnumerable<T> IEnumerableOfTField;
\r
27 [ImportMany("Value")]
\r
28 public IEnumerable<object> IEnumerableOfObjectField;
\r
30 [ImportMany("Value")]
\r
31 public T[] ArrayOfTField;
\r
33 [ImportMany("Value")]
\r
34 public object[] ArrayOfObjectField;
\r
36 [ImportMany("Value")]
\r
37 public IEnumerable<T> IEnumerableOfTProperty { get; set; }
\r
39 [ImportMany("Value")]
\r
40 public IEnumerable<object> IEnumerableOfObjectProperty { get; set; }
\r
42 [ImportMany("Value")]
\r
43 public T[] ArrayOfTProperty { get; set; }
\r
45 [ImportMany("Value")]
\r
46 public object[] ArrayOfObjectProperty { get; set; }
\r
48 public void VerifyImports(params T[] expectedValues)
\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
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
65 public void ValidateSupportedImportCollectionAssignments()
\r
67 var container = ContainerFactory.Create();
\r
68 var batch = new CompositionBatch();
\r
70 var importer = new SupportedImportCollectionAssignments<int>();
\r
72 batch.AddPart(importer);
\r
73 batch.AddExportedValue("Value", 21);
\r
74 batch.AddExportedValue("Value", 32);
\r
75 batch.AddExportedValue("Value", 43);
\r
77 container.Compose(batch);
\r
79 importer.VerifyImports(21, 32, 43);
\r
82 public class SupportedImportCollectionMutation<T>
\r
84 public SupportedImportCollectionMutation()
\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
91 _iCollectionOfTReadOnlyProperty = new List<T>();
\r
92 _listOfTReadOnlyProperty = new List<T>();
\r
93 CollectionOfTProperty = new Collection<T>();
\r
94 _collectionOfTReadOnlyProperty = new Collection<T>();
\r
97 ObservableCollectionOfTReadOnlyField = new ObservableCollection<T>();
\r
98 _observableCollectionOfTReadOnlyProperty = new ObservableCollection<T>();
\r
99 #endif // !SILVERLIGHT
\r
102 [ImportMany("Value")]
\r
103 public readonly ICollection<T> ICollectionOfTReadOnlyField;
\r
105 [ImportMany("Value")]
\r
106 public List<T> ListOfTField;
\r
108 [ImportMany("Value")]
\r
109 public readonly List<T> ListOfTReadOnlyField;
\r
111 [ImportMany("Value")]
\r
112 public Collection<T> CollectionOfTField;
\r
114 [ImportMany("Value")]
\r
115 public Collection<object> CollectionOfObjectField;
\r
117 [ImportMany("Value")]
\r
118 public readonly Collection<T> CollectionOfTReadOnlyField;
\r
120 [ImportMany("Value")]
\r
121 public ICollection<T> ICollectionOfTReadOnlyProperty { get { return _iCollectionOfTReadOnlyProperty; } }
\r
122 private ICollection<T> _iCollectionOfTReadOnlyProperty;
\r
124 [ImportMany("Value")]
\r
125 public List<T> ListOfTProperty { get; set; }
\r
127 [ImportMany("Value")]
\r
128 public List<T> ListOfTReadOnlyProperty { get { return _listOfTReadOnlyProperty; } }
\r
129 private readonly List<T> _listOfTReadOnlyProperty;
\r
131 [ImportMany("Value")]
\r
132 public Collection<T> CollectionOfTProperty { get; set; }
\r
134 [ImportMany("Value")]
\r
135 public Collection<T> CollectionOfTReadOnlyProperty { get { return _collectionOfTReadOnlyProperty; } }
\r
136 private readonly Collection<T> _collectionOfTReadOnlyProperty;
\r
139 [ImportMany("Value")]
\r
140 public ObservableCollection<T> ObservableCollectionOfTField;
\r
142 [ImportMany("Value")]
\r
143 public readonly ObservableCollection<T> ObservableCollectionOfTReadOnlyField;
\r
145 [ImportMany("Value")]
\r
146 public ObservableCollection<T> ObservableCollectionOfTProperty { get; set; }
\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
153 public void VerifyImports(params T[] expectedValues)
\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
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
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
177 public void ValidateSupportedImportCollectionMutation()
\r
179 var container = ContainerFactory.Create();
\r
180 var batch = new CompositionBatch();
\r
182 var importer = new SupportedImportCollectionMutation<int>();
\r
184 batch.AddPart(importer);
\r
185 batch.AddExportedValue("Value", 21);
\r
186 batch.AddExportedValue("Value", 32);
\r
187 batch.AddExportedValue("Value", 43);
\r
189 container.Compose(batch);
\r
191 importer.VerifyImports(21, 32, 43);
\r
194 public class ImportCollectionNullValue
\r
196 [ImportMany("Value")]
\r
197 public List<int> NullValue { get; set; }
\r
200 public class NamelessImporter
\r
203 public int[] ReadWriteIList { get; set; }
\r
206 public Collection<Lazy<int>> ReadWriteMetadata { get; set; }
\r
209 public class NamelessExporter
\r
211 public NamelessExporter(int value)
\r
217 public int Value { get; set; }
\r
221 public void ImportCollectionsNameless()
\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
229 CompositionBatch batch = new CompositionBatch();
\r
230 batch.AddParts(importer, exporter42, exporter0);
\r
231 container.Compose(batch);
\r
233 EnumerableAssert.AreEqual(importer.ReadWriteIList, 42, 0);
\r
236 public class InvalidImporterReadOnlyEnumerable
\r
238 IEnumerable<int> readOnlyEnumerable = new List<int>();
\r
240 [ImportMany("Value")]
\r
241 public IEnumerable<int> ReadOnlyEnumerable
\r
245 return readOnlyEnumerable;
\r
251 public void ImportCollectionsExceptionReadOnlyEnumerable()
\r
253 ExpectedErrorOnPartActivate(new InvalidImporterReadOnlyEnumerable(),
\r
254 ErrorId.ReflectionModel_ImportCollectionNotWritable);
\r
257 public class ImporterWriteOnlyExportCollection
\r
259 [ImportMany("Value")]
\r
260 public Collection<Lazy<int>> WriteOnlyExportCollection
\r
262 set { PublicExportCollection = value; }
\r
265 public Collection<Lazy<int>> PublicExportCollection { get; set; }
\r
269 public void ImportCollections_WriteOnlyExportCollection()
\r
271 var container = ContainerFactory.Create();
\r
272 var batch = new CompositionBatch();
\r
274 var importer = new ImporterWriteOnlyExportCollection();
\r
276 List<int> values = new List<int>() { 21, 32, 43 };
\r
278 batch.AddPart(importer);
\r
279 values.ForEach(v => batch.AddExportedValue("Value", v));
\r
281 container.Compose(batch);
\r
283 EnumerableAssert.AreEqual(values, importer.PublicExportCollection.Select(export => export.Value));
\r
286 public class ImporterWriteOnlyIEnumerableOfT
\r
288 [ImportMany("Value")]
\r
289 public IEnumerable<int> WriteOnlyIEnumerable
\r
291 set { PublicIEnumerable = value; }
\r
294 public IEnumerable<int> PublicIEnumerable { get; set; }
\r
298 public void ImportCollections_WriteOnlyIEnumerableOfT()
\r
300 var container = ContainerFactory.Create();
\r
301 var batch = new CompositionBatch();
\r
303 var importer = new ImporterWriteOnlyIEnumerableOfT();
\r
305 List<int> values = new List<int>() { 21, 32, 43 };
\r
307 batch.AddPart(importer);
\r
308 values.ForEach(v => batch.AddExportedValue("Value", v));
\r
310 container.Compose(batch);
\r
312 EnumerableAssert.AreEqual(values, importer.PublicIEnumerable);
\r
315 public class ImporterWriteOnlyArray
\r
317 [ImportMany("Value")]
\r
318 public int[] WriteOnlyArray
\r
320 set { PublicArray = value; }
\r
323 public int[] PublicArray { get; set; }
\r
327 public void ImportCollections_WriteOnlyArray()
\r
329 var container = ContainerFactory.Create();
\r
330 var batch = new CompositionBatch();
\r
332 var importer = new ImporterWriteOnlyArray();
\r
334 List<int> values = new List<int>() { 21, 32, 43 };
\r
336 batch.AddPart(importer);
\r
337 values.ForEach(v => batch.AddExportedValue("Value", v));
\r
339 container.Compose(batch);
\r
341 EnumerableAssert.AreEqual(values, importer.PublicArray);
\r
344 public class InvalidImporterNonCollection
\r
347 public int Value { get; set; }
\r
351 public void ImportCollectionsExceptionNonCollection()
\r
353 ExpectedChangeRejectedErrorOnSetImport(new InvalidImporterNonCollection(),
\r
354 ErrorId.ImportEngine_ImportCardinalityMismatch);
\r
357 public class InvalidImporterNonAssignableCollection
\r
359 [ImportMany("Value", typeof(int))]
\r
360 public IEnumerable<string> StringCollection { get; set; }
\r
364 public void ImportCollectionsExceptionNonAssignableCollection()
\r
366 ExpectedErrorOnSetImport(new InvalidImporterNonAssignableCollection(),
\r
367 ErrorId.ReflectionModel_ImportNotAssignableFromExport);
\r
370 public class InvalidImporterNullReadOnlyICollection
\r
372 ICollection<int> readOnlyICollection = null;
\r
374 [ImportMany("Value")]
\r
375 public ICollection<int> Values { get { return readOnlyICollection; } }
\r
379 public void ImportCollectionsExceptionNullReadOnlyICollection()
\r
381 ExpectedErrorOnPartActivate(new InvalidImporterNullReadOnlyICollection(),
\r
382 ErrorId.ReflectionModel_ImportCollectionNull);
\r
385 public class ImporterWeakIEnumerable
\r
387 public ImporterWeakIEnumerable()
\r
389 ReadWriteEnumerable = new IntCollection();
\r
392 [ImportMany("Value")]
\r
393 public IntCollection ReadWriteEnumerable { get; set; }
\r
395 public class IntCollection : IEnumerable
\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
406 public void ImportCollectionsExceptionWeakCollectionNotSupportingICollectionOfT()
\r
408 ExpectedErrorOnPartActivate(new ImporterWeakIEnumerable(),
\r
409 ErrorId.ReflectionModel_ImportCollectionNotWritable);
\r
412 public class ImporterThrowsOnGetting
\r
414 [ImportMany("Value")]
\r
415 public List<int> Value
\r
419 throw new NotSupportedException();
\r
425 public void ImportCollectionsExceptionGettingValue()
\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
434 CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotActivate,
\r
435 ErrorId.ReflectionModel_ImportCollectionGetThrewException, RetryMode.DoNotRetry, () =>
\r
437 container.Compose(batch);
\r
441 public class CustomCollectionThrowsDuringConstruction : Collection<int>
\r
443 public CustomCollectionThrowsDuringConstruction()
\r
445 throw new NotSupportedException();
\r
449 public class ImportCustomCollectionThrowsDuringConstruction
\r
451 public ImportCustomCollectionThrowsDuringConstruction()
\r
455 [ImportMany("Value")]
\r
456 public CustomCollectionThrowsDuringConstruction Values { get; set; }
\r
460 public void ImportCollections_ImportTypeThrowsOnConstruction()
\r
462 ExpectedErrorOnPartActivate(new ImportCustomCollectionThrowsDuringConstruction(),
\r
463 ErrorId.ReflectionModel_ImportCollectionConstructionThrewException);
\r
466 public class CustomCollectionThrowsDuringClear : Collection<int>
\r
468 protected override void ClearItems()
\r
470 throw new NotSupportedException();
\r
474 public class ImportCustomCollectionThrowsDuringClear
\r
476 public ImportCustomCollectionThrowsDuringClear()
\r
480 [ImportMany("Value")]
\r
481 public CustomCollectionThrowsDuringClear Values { get; set; }
\r
485 public void ImportCollections_ImportTypeThrowsOnClear()
\r
487 ExpectedErrorOnPartActivate(new ImportCustomCollectionThrowsDuringClear(),
\r
488 ErrorId.ReflectionModel_ImportCollectionClearThrewException);
\r
491 public class CustomCollectionThrowsDuringAdd : Collection<int>
\r
493 protected override void InsertItem(int index, int item)
\r
495 throw new NotSupportedException();
\r
499 public class ImportCustomCollectionThrowsDuringAdd
\r
501 public ImportCustomCollectionThrowsDuringAdd()
\r
505 [ImportMany("Value")]
\r
506 public CustomCollectionThrowsDuringAdd Values { get; set; }
\r
510 public void ImportCollections_ImportTypeThrowsOnAdd()
\r
512 ExpectedErrorOnPartActivate(new ImportCustomCollectionThrowsDuringAdd(),
\r
513 ErrorId.ReflectionModel_ImportCollectionAddThrewException);
\r
516 public class CustomCollectionThrowsDuringIsReadOnly : ICollection<int>
\r
518 void ICollection<int>.Add(int item)
\r
520 throw new NotImplementedException();
\r
523 void ICollection<int>.Clear()
\r
525 throw new NotImplementedException();
\r
528 bool ICollection<int>.Contains(int item)
\r
530 throw new NotImplementedException();
\r
533 void ICollection<int>.CopyTo(int[] array, int arrayIndex)
\r
535 throw new NotImplementedException();
\r
538 int ICollection<int>.Count
\r
540 get { throw new NotImplementedException(); }
\r
543 bool ICollection<int>.IsReadOnly
\r
545 get { throw new NotSupportedException(); }
\r
548 bool ICollection<int>.Remove(int item)
\r
550 throw new NotImplementedException();
\r
553 IEnumerator<int> IEnumerable<int>.GetEnumerator()
\r
555 throw new NotImplementedException();
\r
558 IEnumerator IEnumerable.GetEnumerator()
\r
560 throw new NotImplementedException();
\r
564 public class ImportCustomCollectionThrowsDuringIsReadOnly
\r
566 public ImportCustomCollectionThrowsDuringIsReadOnly()
\r
568 Values = new CustomCollectionThrowsDuringIsReadOnly();
\r
571 [ImportMany("Value")]
\r
572 public CustomCollectionThrowsDuringIsReadOnly Values { get; set; }
\r
576 public void ImportCollections_ImportTypeThrowsOnIsReadOnly()
\r
578 ExpectedErrorOnPartActivate(new ImportCustomCollectionThrowsDuringIsReadOnly(),
\r
579 ErrorId.ReflectionModel_ImportCollectionIsReadOnlyThrewException);
\r
582 public class CollectionTypeWithNoIList<T> : ICollection<T>
\r
584 private int _count = 0;
\r
585 public CollectionTypeWithNoIList()
\r
590 public void Add(T item)
\r
596 public void Clear()
\r
601 public bool Contains(T item)
\r
603 throw new NotImplementedException();
\r
606 public void CopyTo(T[] array, int arrayIndex)
\r
608 throw new NotImplementedException();
\r
613 get { return this._count; }
\r
616 public bool IsReadOnly
\r
618 get { return false; }
\r
621 public bool Remove(T item)
\r
623 throw new NotImplementedException();
\r
626 public IEnumerator<T> GetEnumerator()
\r
628 throw new NotImplementedException();
\r
631 IEnumerator IEnumerable.GetEnumerator()
\r
633 throw new NotImplementedException();
\r
637 public class ImportCollectionWithNoIList
\r
639 [ImportMany("Value")]
\r
640 public CollectionTypeWithNoIList<int> Values { get; set; }
\r
644 public void ImportCollections_NoIList_ShouldWorkFine()
\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
653 container.Compose(batch);
\r
655 Assert.AreEqual(2, importer.Values.Count);
\r
658 public class CollectionWithMultipleInterfaces : ICollection<int>, ICollection<string>
\r
660 private int _count = 0;
\r
661 public CollectionWithMultipleInterfaces()
\r
666 #region ICollection<int> Members
\r
668 void ICollection<int>.Add(int item)
\r
670 throw new NotImplementedException();
\r
673 void ICollection<int>.Clear()
\r
675 throw new NotImplementedException();
\r
678 bool ICollection<int>.Contains(int item)
\r
680 throw new NotImplementedException();
\r
683 void ICollection<int>.CopyTo(int[] array, int arrayIndex)
\r
685 throw new NotImplementedException();
\r
688 int ICollection<int>.Count
\r
690 get { throw new NotImplementedException(); }
\r
693 bool ICollection<int>.IsReadOnly
\r
695 get { throw new NotImplementedException(); }
\r
698 bool ICollection<int>.Remove(int item)
\r
700 throw new NotImplementedException();
\r
703 IEnumerator<int> IEnumerable<int>.GetEnumerator()
\r
705 throw new NotImplementedException();
\r
710 #region IEnumerable Members
\r
712 IEnumerator IEnumerable.GetEnumerator()
\r
714 throw new NotImplementedException();
\r
719 #region ICollection<string> Members
\r
721 void ICollection<string>.Add(string item)
\r
723 throw new NotImplementedException();
\r
726 void ICollection<string>.Clear()
\r
728 throw new NotImplementedException();
\r
731 bool ICollection<string>.Contains(string item)
\r
733 throw new NotImplementedException();
\r
736 void ICollection<string>.CopyTo(string[] array, int arrayIndex)
\r
738 throw new NotImplementedException();
\r
741 int ICollection<string>.Count
\r
743 get { throw new NotImplementedException(); }
\r
746 bool ICollection<string>.IsReadOnly
\r
748 get { throw new NotImplementedException(); }
\r
751 bool ICollection<string>.Remove(string item)
\r
753 throw new NotImplementedException();
\r
756 IEnumerator<string> IEnumerable<string>.GetEnumerator()
\r
758 throw new NotImplementedException();
\r
764 public class ImportCollectionWithMultipleInterfaces
\r
766 [ImportMany("Value")]
\r
767 public CollectionWithMultipleInterfaces Values { get; set; }
\r
771 public void ImportCollections_MultipleICollections_ShouldCauseNotWriteable()
\r
773 ExpectedErrorOnPartActivate(new ImportCollectionWithMultipleInterfaces(),
\r
774 ErrorId.ReflectionModel_ImportCollectionNotWritable);
\r
777 public class ImportManyNonCollectionTypeString
\r
779 [ImportMany("Value")]
\r
780 public string Foo { get; set; }
\r
784 public void ImportManyOnNonCollectionTypeString_ShouldCauseNotWritable()
\r
786 ExpectedErrorOnPartActivate(new ImportManyNonCollectionTypeString(),
\r
787 ErrorId.ReflectionModel_ImportCollectionNotWritable);
\r
790 public class ImportManyNonCollectionTypeObject
\r
792 [ImportMany("Value")]
\r
793 public object Foo { get; set; }
\r
797 public void ImportManyOnNonCollectionTypeObject_ShouldCauseNotWritable()
\r
799 ExpectedErrorOnPartActivate(new ImportManyNonCollectionTypeObject(),
\r
800 ErrorId.ReflectionModel_ImportCollectionNotWritable);
\r
804 // SILVERLIGHT doesn't have SetEnvironmentVariable set in this test.
\r
805 public class ExportADictionaryObject
\r
808 public IDictionary<string, object> MyDictionary
\r
812 var dictionary = new Dictionary<string, object>();
\r
813 dictionary.Add("a", 42);
\r
814 dictionary.Add("b", "c");
\r
820 public class ImportADictionaryObject
\r
823 public IDictionary<string, object> MyDictionary { get; set; }
\r
827 public void ImportDictionaryAsSingleObject()
\r
829 // Set variable to ensure the hack is turned off.
\r
830 Environment.SetEnvironmentVariable("ONLY_ALLOW_IMPORTMANY", "1");
\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
837 batch.AddPart(importer);
\r
838 batch.AddPart(exporter);
\r
839 container.Compose(batch);
\r
841 Assert.AreEqual(2, importer.MyDictionary.Count);
\r
844 public class ExportACollectionObject
\r
847 public Collection<string> MyCollection
\r
851 var collection = new Collection<string>();
\r
852 collection.Add("a");
\r
853 collection.Add("b");
\r
859 public class ImportACollectionObject
\r
862 public Collection<string> MyCollection { get; set; }
\r
866 public void ImportCollectionAsSingleObject()
\r
868 // Set variable to ensure the hack is turned off.
\r
869 Environment.SetEnvironmentVariable("ONLY_ALLOW_IMPORTMANY", "1");
\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
876 batch.AddPart(importer);
\r
877 batch.AddPart(exporter);
\r
878 container.Compose(batch);
\r
880 Assert.AreEqual(2, importer.MyCollection.Count);
\r
884 public void ExpectedErrorOnPartActivate(object importer, ErrorId expectedErrorId)
\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
892 CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotActivate,
\r
893 expectedErrorId, RetryMode.DoNotRetry, () =>
\r
895 container.Compose(batch);
\r
899 public void ExpectedErrorOnSetImport(object importer, ErrorId expectedErrorId)
\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
907 CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotSetImport,
\r
908 expectedErrorId, RetryMode.DoNotRetry, () =>
\r
910 container.Compose(batch);
\r
914 public void ExpectedChangeRejectedErrorOnSetImport(object importer, ErrorId expectedErrorId)
\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
922 CompositionAssert.ThrowsChangeRejectedError(ErrorId.ImportEngine_PartCannotSetImport,
\r
923 expectedErrorId, RetryMode.DoNotRetry, () =>
\r
925 container.Compose(batch);
\r