diff options
Diffstat (limited to 'mcs/class/System.ComponentModel.Composition/Tests/ComponentModelUnitTest/System/ComponentModel/Composition/CompositionContainerCollectionTests.cs')
| -rw-r--r-- | mcs/class/System.ComponentModel.Composition/Tests/ComponentModelUnitTest/System/ComponentModel/Composition/CompositionContainerCollectionTests.cs | 929 |
1 files changed, 0 insertions, 929 deletions
diff --git a/mcs/class/System.ComponentModel.Composition/Tests/ComponentModelUnitTest/System/ComponentModel/Composition/CompositionContainerCollectionTests.cs b/mcs/class/System.ComponentModel.Composition/Tests/ComponentModelUnitTest/System/ComponentModel/Composition/CompositionContainerCollectionTests.cs deleted file mode 100644 index 1f4b0233ede..00000000000 --- a/mcs/class/System.ComponentModel.Composition/Tests/ComponentModelUnitTest/System/ComponentModel/Composition/CompositionContainerCollectionTests.cs +++ /dev/null @@ -1,929 +0,0 @@ -// -----------------------------------------------------------------------
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// -----------------------------------------------------------------------
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.ComponentModel.Composition;
-using System.Linq;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using System.ComponentModel.Composition.Factories;
-using System.UnitTesting;
-using System.ComponentModel.Composition.UnitTesting;
-using System.ComponentModel.Composition.Hosting;
-
-namespace System.ComponentModel.Composition
-{
- [TestClass]
- public class CompositionContainerCollectionTests
- {
- public class SupportedImportCollectionAssignments<T>
- {
- // Fields
- [ImportMany("Value")]
- public IEnumerable<T> IEnumerableOfTField;
-
- [ImportMany("Value")]
- public IEnumerable<object> IEnumerableOfObjectField;
-
- [ImportMany("Value")]
- public T[] ArrayOfTField;
-
- [ImportMany("Value")]
- public object[] ArrayOfObjectField;
-
- [ImportMany("Value")]
- public IEnumerable<T> IEnumerableOfTProperty { get; set; }
-
- [ImportMany("Value")]
- public IEnumerable<object> IEnumerableOfObjectProperty { get; set; }
-
- [ImportMany("Value")]
- public T[] ArrayOfTProperty { get; set; }
-
- [ImportMany("Value")]
- public object[] ArrayOfObjectProperty { get; set; }
-
- public void VerifyImports(params T[] expectedValues)
- {
- // Fields
- EnumerableAssert.AreEqual(IEnumerableOfTField, expectedValues);
- EnumerableAssert.AreEqual(IEnumerableOfObjectField, expectedValues.Cast<object>());
- EnumerableAssert.AreEqual(ArrayOfTField, expectedValues);
- EnumerableAssert.AreEqual(ArrayOfObjectField, expectedValues.Cast<object>());
-
- // Properties
- EnumerableAssert.AreEqual(IEnumerableOfTProperty, expectedValues);
- EnumerableAssert.AreEqual(IEnumerableOfObjectProperty, expectedValues.Cast<object>());
- EnumerableAssert.AreEqual(ArrayOfTProperty, expectedValues);
- EnumerableAssert.AreEqual(ArrayOfObjectProperty, expectedValues.Cast<object>());
- }
- }
-
- [TestMethod]
- public void ValidateSupportedImportCollectionAssignments()
- {
- var container = ContainerFactory.Create();
- var batch = new CompositionBatch();
-
- var importer = new SupportedImportCollectionAssignments<int>();
-
- batch.AddPart(importer);
- batch.AddExportedValue("Value", 21);
- batch.AddExportedValue("Value", 32);
- batch.AddExportedValue("Value", 43);
-
- container.Compose(batch);
-
- importer.VerifyImports(21, 32, 43);
- }
-
- public class SupportedImportCollectionMutation<T>
- {
- public SupportedImportCollectionMutation()
- {
- ICollectionOfTReadOnlyField = new List<T>();
- ListOfTReadOnlyField = new List<T>();
- CollectionOfTField = new Collection<T>();
- CollectionOfTReadOnlyField = new Collection<T>();
-
- _iCollectionOfTReadOnlyProperty = new List<T>();
- _listOfTReadOnlyProperty = new List<T>();
- CollectionOfTProperty = new Collection<T>();
- _collectionOfTReadOnlyProperty = new Collection<T>();
-
-#if !SILVERLIGHT
- ObservableCollectionOfTReadOnlyField = new ObservableCollection<T>();
- _observableCollectionOfTReadOnlyProperty = new ObservableCollection<T>();
-#endif // !SILVERLIGHT
- }
-
- [ImportMany("Value")]
- public readonly ICollection<T> ICollectionOfTReadOnlyField;
-
- [ImportMany("Value")]
- public List<T> ListOfTField;
-
- [ImportMany("Value")]
- public readonly List<T> ListOfTReadOnlyField;
-
- [ImportMany("Value")]
- public Collection<T> CollectionOfTField;
-
- [ImportMany("Value")]
- public Collection<object> CollectionOfObjectField;
-
- [ImportMany("Value")]
- public readonly Collection<T> CollectionOfTReadOnlyField;
-
- [ImportMany("Value")]
- public ICollection<T> ICollectionOfTReadOnlyProperty { get { return _iCollectionOfTReadOnlyProperty; } }
- private ICollection<T> _iCollectionOfTReadOnlyProperty;
-
- [ImportMany("Value")]
- public List<T> ListOfTProperty { get; set; }
-
- [ImportMany("Value")]
- public List<T> ListOfTReadOnlyProperty { get { return _listOfTReadOnlyProperty; } }
- private readonly List<T> _listOfTReadOnlyProperty;
-
- [ImportMany("Value")]
- public Collection<T> CollectionOfTProperty { get; set; }
-
- [ImportMany("Value")]
- public Collection<T> CollectionOfTReadOnlyProperty { get { return _collectionOfTReadOnlyProperty; } }
- private readonly Collection<T> _collectionOfTReadOnlyProperty;
-
-#if !SILVERLIGHT
- [ImportMany("Value")]
- public ObservableCollection<T> ObservableCollectionOfTField;
-
- [ImportMany("Value")]
- public readonly ObservableCollection<T> ObservableCollectionOfTReadOnlyField;
-
- [ImportMany("Value")]
- public ObservableCollection<T> ObservableCollectionOfTProperty { get; set; }
-
- [ImportMany("Value")]
- public ObservableCollection<T> ObservableCollectionOfTReadOnlyProperty { get { return _observableCollectionOfTReadOnlyProperty; } }
- private readonly ObservableCollection<T> _observableCollectionOfTReadOnlyProperty;
-#endif // !SILVERLIGHT
-
- public void VerifyImports(params T[] expectedValues)
- {
- EnumerableAssert.AreEqual(ICollectionOfTReadOnlyField, expectedValues);
- EnumerableAssert.AreEqual(ListOfTField, expectedValues);
- EnumerableAssert.AreEqual(ListOfTReadOnlyField, expectedValues);
- EnumerableAssert.AreEqual(CollectionOfTField, expectedValues);
- EnumerableAssert.AreEqual(CollectionOfTReadOnlyField, expectedValues);
-
- EnumerableAssert.AreEqual(ICollectionOfTReadOnlyProperty, expectedValues);
- EnumerableAssert.AreEqual(ListOfTProperty, expectedValues);
- EnumerableAssert.AreEqual(ListOfTReadOnlyProperty, expectedValues);
- EnumerableAssert.AreEqual(CollectionOfTProperty, expectedValues);
- EnumerableAssert.AreEqual(CollectionOfTReadOnlyProperty, expectedValues);
-
-#if !SILVERLIGHT
- EnumerableAssert.AreEqual(ObservableCollectionOfTField, expectedValues);
- EnumerableAssert.AreEqual(ObservableCollectionOfTReadOnlyField, expectedValues);
- EnumerableAssert.AreEqual(ObservableCollectionOfTProperty, expectedValues);
- EnumerableAssert.AreEqual(ObservableCollectionOfTReadOnlyProperty, expectedValues);
-#endif // !SILVERLIGHT
- }
- }
-
- [TestMethod]
- public void ValidateSupportedImportCollectionMutation()
- {
- var container = ContainerFactory.Create();
- var batch = new CompositionBatch();
-
- var importer = new SupportedImportCollectionMutation<int>();
-
- batch.AddPart(importer);
- batch.AddExportedValue("Value", 21);
- batch.AddExportedValue("Value", 32);
- batch.AddExportedValue("Value", 43);
-
- container.Compose(batch);
-
- importer.VerifyImports(21, 32, 43);
- }
-
- public class ImportCollectionNullValue
- {
- [ImportMany("Value")]
- public List<int> NullValue { get; set; }
- }
-
- public class NamelessImporter
- {
- [ImportMany]
- public int[] ReadWriteIList { get; set; }
-
- [ImportMany]
- public Collection<Lazy<int>> ReadWriteMetadata { get; set; }
- }
-
- public class NamelessExporter
- {
- public NamelessExporter(int value)
- {
- Value = value;
- }
-
- [Export]
- public int Value { get; set; }
- }
-
- [TestMethod]
- public void ImportCollectionsNameless()
- {
- // Verifing that the contract name gets the correct value
- var container = ContainerFactory.Create();
- NamelessImporter importer = new NamelessImporter();
- NamelessExporter exporter42 = new NamelessExporter(42);
- NamelessExporter exporter0 = new NamelessExporter(0);
-
- CompositionBatch batch = new CompositionBatch();
- batch.AddParts(importer, exporter42, exporter0);
- container.Compose(batch);
-
- EnumerableAssert.AreEqual(importer.ReadWriteIList, 42, 0);
- }
-
- public class InvalidImporterReadOnlyEnumerable
- {
- IEnumerable<int> readOnlyEnumerable = new List<int>();
-
- [ImportMany("Value")]
- public IEnumerable<int> ReadOnlyEnumerable
- {
- get
- {
- return readOnlyEnumerable;
- }
- }
- }
-
- [TestMethod]
- public void ImportCollectionsExceptionReadOnlyEnumerable()
- {
- ExpectedErrorOnPartActivate(new InvalidImporterReadOnlyEnumerable(),
- ErrorId.ReflectionModel_ImportCollectionNotWritable);
- }
-
- public class ImporterWriteOnlyExportCollection
- {
- [ImportMany("Value")]
- public Collection<Lazy<int>> WriteOnlyExportCollection
- {
- set { PublicExportCollection = value; }
- }
-
- public Collection<Lazy<int>> PublicExportCollection { get; set; }
- }
-
- [TestMethod]
- public void ImportCollections_WriteOnlyExportCollection()
- {
- var container = ContainerFactory.Create();
- var batch = new CompositionBatch();
-
- var importer = new ImporterWriteOnlyExportCollection();
-
- List<int> values = new List<int>() { 21, 32, 43 };
-
- batch.AddPart(importer);
- values.ForEach(v => batch.AddExportedValue("Value", v));
-
- container.Compose(batch);
-
- EnumerableAssert.AreEqual(values, importer.PublicExportCollection.Select(export => export.Value));
- }
-
- public class ImporterWriteOnlyIEnumerableOfT
- {
- [ImportMany("Value")]
- public IEnumerable<int> WriteOnlyIEnumerable
- {
- set { PublicIEnumerable = value; }
- }
-
- public IEnumerable<int> PublicIEnumerable { get; set; }
- }
-
- [TestMethod]
- public void ImportCollections_WriteOnlyIEnumerableOfT()
- {
- var container = ContainerFactory.Create();
- var batch = new CompositionBatch();
-
- var importer = new ImporterWriteOnlyIEnumerableOfT();
-
- List<int> values = new List<int>() { 21, 32, 43 };
-
- batch.AddPart(importer);
- values.ForEach(v => batch.AddExportedValue("Value", v));
-
- container.Compose(batch);
-
- EnumerableAssert.AreEqual(values, importer.PublicIEnumerable);
- }
-
- public class ImporterWriteOnlyArray
- {
- [ImportMany("Value")]
- public int[] WriteOnlyArray
- {
- set { PublicArray = value; }
- }
-
- public int[] PublicArray { get; set; }
- }
-
- [TestMethod]
- public void ImportCollections_WriteOnlyArray()
- {
- var container = ContainerFactory.Create();
- var batch = new CompositionBatch();
-
- var importer = new ImporterWriteOnlyArray();
-
- List<int> values = new List<int>() { 21, 32, 43 };
-
- batch.AddPart(importer);
- values.ForEach(v => batch.AddExportedValue("Value", v));
-
- container.Compose(batch);
-
- EnumerableAssert.AreEqual(values, importer.PublicArray);
- }
-
- public class InvalidImporterNonCollection
- {
- [Import("Value")]
- public int Value { get; set; }
- }
-
- [TestMethod]
- public void ImportCollectionsExceptionNonCollection()
- {
- ExpectedChangeRejectedErrorOnSetImport(new InvalidImporterNonCollection(),
- ErrorId.ImportEngine_ImportCardinalityMismatch);
- }
-
- public class InvalidImporterNonAssignableCollection
- {
- [ImportMany("Value", typeof(int))]
- public IEnumerable<string> StringCollection { get; set; }
- }
-
- [TestMethod]
- public void ImportCollectionsExceptionNonAssignableCollection()
- {
- ExpectedErrorOnSetImport(new InvalidImporterNonAssignableCollection(),
- ErrorId.ReflectionModel_ImportNotAssignableFromExport);
- }
-
- public class InvalidImporterNullReadOnlyICollection
- {
- ICollection<int> readOnlyICollection = null;
-
- [ImportMany("Value")]
- public ICollection<int> Values { get { return readOnlyICollection; } }
- }
-
- [TestMethod]
- public void ImportCollectionsExceptionNullReadOnlyICollection()
- {
- ExpectedErrorOnPartActivate(new InvalidImporterNullReadOnlyICollection(),
- ErrorId.ReflectionModel_ImportCollectionNull);
- }
-
- public class ImporterWeakIEnumerable
- {
- public ImporterWeakIEnumerable()
- {
- ReadWriteEnumerable = new IntCollection();
- }
-
- [ImportMany("Value")]
- public IntCollection ReadWriteEnumerable { get; set; }
-
- public class IntCollection : IEnumerable
- {
- List<int> ints = new List<int>();
- public void Add(int item) { ints.Add(item); }
- public void Clear() { ints.Clear(); }
- public bool Remove(int item) { return ints.Remove(item); }
- public IEnumerator GetEnumerator() { return ints.GetEnumerator(); }
- }
- }
-
- [TestMethod]
- public void ImportCollectionsExceptionWeakCollectionNotSupportingICollectionOfT()
- {
- ExpectedErrorOnPartActivate(new ImporterWeakIEnumerable(),
- ErrorId.ReflectionModel_ImportCollectionNotWritable);
- }
-
- public class ImporterThrowsOnGetting
- {
- [ImportMany("Value")]
- public List<int> Value
- {
- get
- {
- throw new NotSupportedException();
- }
- }
- }
-
- [TestMethod]
- public void ImportCollectionsExceptionGettingValue()
- {
- var container = ContainerFactory.Create();
- ImporterThrowsOnGetting importer = new ImporterThrowsOnGetting();
- CompositionBatch batch = new CompositionBatch();
- batch.AddPart(importer);
- batch.AddExportedValue("Value", 42);
- batch.AddExportedValue("Value", 0);
-
- CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotActivate,
- ErrorId.ReflectionModel_ImportCollectionGetThrewException, RetryMode.DoNotRetry, () =>
- {
- container.Compose(batch);
- });
- }
-
- public class CustomCollectionThrowsDuringConstruction : Collection<int>
- {
- public CustomCollectionThrowsDuringConstruction()
- {
- throw new NotSupportedException();
- }
- }
-
- public class ImportCustomCollectionThrowsDuringConstruction
- {
- public ImportCustomCollectionThrowsDuringConstruction()
- {
- }
-
- [ImportMany("Value")]
- public CustomCollectionThrowsDuringConstruction Values { get; set; }
- }
-
- [TestMethod]
- public void ImportCollections_ImportTypeThrowsOnConstruction()
- {
- ExpectedErrorOnPartActivate(new ImportCustomCollectionThrowsDuringConstruction(),
- ErrorId.ReflectionModel_ImportCollectionConstructionThrewException);
- }
-
- public class CustomCollectionThrowsDuringClear : Collection<int>
- {
- protected override void ClearItems()
- {
- throw new NotSupportedException();
- }
- }
-
- public class ImportCustomCollectionThrowsDuringClear
- {
- public ImportCustomCollectionThrowsDuringClear()
- {
- }
-
- [ImportMany("Value")]
- public CustomCollectionThrowsDuringClear Values { get; set; }
- }
-
- [TestMethod]
- public void ImportCollections_ImportTypeThrowsOnClear()
- {
- ExpectedErrorOnPartActivate(new ImportCustomCollectionThrowsDuringClear(),
- ErrorId.ReflectionModel_ImportCollectionClearThrewException);
- }
-
- public class CustomCollectionThrowsDuringAdd : Collection<int>
- {
- protected override void InsertItem(int index, int item)
- {
- throw new NotSupportedException();
- }
- }
-
- public class ImportCustomCollectionThrowsDuringAdd
- {
- public ImportCustomCollectionThrowsDuringAdd()
- {
- }
-
- [ImportMany("Value")]
- public CustomCollectionThrowsDuringAdd Values { get; set; }
- }
-
- [TestMethod]
- public void ImportCollections_ImportTypeThrowsOnAdd()
- {
- ExpectedErrorOnPartActivate(new ImportCustomCollectionThrowsDuringAdd(),
- ErrorId.ReflectionModel_ImportCollectionAddThrewException);
- }
-
- public class CustomCollectionThrowsDuringIsReadOnly : ICollection<int>
- {
- void ICollection<int>.Add(int item)
- {
- throw new NotImplementedException();
- }
-
- void ICollection<int>.Clear()
- {
- throw new NotImplementedException();
- }
-
- bool ICollection<int>.Contains(int item)
- {
- throw new NotImplementedException();
- }
-
- void ICollection<int>.CopyTo(int[] array, int arrayIndex)
- {
- throw new NotImplementedException();
- }
-
- int ICollection<int>.Count
- {
- get { throw new NotImplementedException(); }
- }
-
- bool ICollection<int>.IsReadOnly
- {
- get { throw new NotSupportedException(); }
- }
-
- bool ICollection<int>.Remove(int item)
- {
- throw new NotImplementedException();
- }
-
- IEnumerator<int> IEnumerable<int>.GetEnumerator()
- {
- throw new NotImplementedException();
- }
-
- IEnumerator IEnumerable.GetEnumerator()
- {
- throw new NotImplementedException();
- }
- }
-
- public class ImportCustomCollectionThrowsDuringIsReadOnly
- {
- public ImportCustomCollectionThrowsDuringIsReadOnly()
- {
- Values = new CustomCollectionThrowsDuringIsReadOnly();
- }
-
- [ImportMany("Value")]
- public CustomCollectionThrowsDuringIsReadOnly Values { get; set; }
- }
-
- [TestMethod]
- public void ImportCollections_ImportTypeThrowsOnIsReadOnly()
- {
- ExpectedErrorOnPartActivate(new ImportCustomCollectionThrowsDuringIsReadOnly(),
- ErrorId.ReflectionModel_ImportCollectionIsReadOnlyThrewException);
- }
-
- public class CollectionTypeWithNoIList<T> : ICollection<T>
- {
- private int _count = 0;
- public CollectionTypeWithNoIList()
- {
-
- }
-
- public void Add(T item)
- {
- // Do Nothing
- this._count++;
- }
-
- public void Clear()
- {
- // Do Nothings
- }
-
- public bool Contains(T item)
- {
- throw new NotImplementedException();
- }
-
- public void CopyTo(T[] array, int arrayIndex)
- {
- throw new NotImplementedException();
- }
-
- public int Count
- {
- get { return this._count; }
- }
-
- public bool IsReadOnly
- {
- get { return false; }
- }
-
- public bool Remove(T item)
- {
- throw new NotImplementedException();
- }
-
- public IEnumerator<T> GetEnumerator()
- {
- throw new NotImplementedException();
- }
-
- IEnumerator IEnumerable.GetEnumerator()
- {
- throw new NotImplementedException();
- }
- }
-
- public class ImportCollectionWithNoIList
- {
- [ImportMany("Value")]
- public CollectionTypeWithNoIList<int> Values { get; set; }
- }
-
- [TestMethod]
- public void ImportCollections_NoIList_ShouldWorkFine()
- {
- var container = ContainerFactory.Create();
- var batch = new CompositionBatch();
- var importer = new ImportCollectionWithNoIList();
- batch.AddPart(importer);
- batch.AddExportedValue("Value", 42);
- batch.AddExportedValue("Value", 0);
-
- container.Compose(batch);
-
- Assert.AreEqual(2, importer.Values.Count);
- }
-
- public class CollectionWithMultipleInterfaces : ICollection<int>, ICollection<string>
- {
- private int _count = 0;
- public CollectionWithMultipleInterfaces()
- {
-
- }
-
- #region ICollection<int> Members
-
- void ICollection<int>.Add(int item)
- {
- throw new NotImplementedException();
- }
-
- void ICollection<int>.Clear()
- {
- throw new NotImplementedException();
- }
-
- bool ICollection<int>.Contains(int item)
- {
- throw new NotImplementedException();
- }
-
- void ICollection<int>.CopyTo(int[] array, int arrayIndex)
- {
- throw new NotImplementedException();
- }
-
- int ICollection<int>.Count
- {
- get { throw new NotImplementedException(); }
- }
-
- bool ICollection<int>.IsReadOnly
- {
- get { throw new NotImplementedException(); }
- }
-
- bool ICollection<int>.Remove(int item)
- {
- throw new NotImplementedException();
- }
-
- IEnumerator<int> IEnumerable<int>.GetEnumerator()
- {
- throw new NotImplementedException();
- }
-
- #endregion
-
- #region IEnumerable Members
-
- IEnumerator IEnumerable.GetEnumerator()
- {
- throw new NotImplementedException();
- }
-
- #endregion
-
- #region ICollection<string> Members
-
- void ICollection<string>.Add(string item)
- {
- throw new NotImplementedException();
- }
-
- void ICollection<string>.Clear()
- {
- throw new NotImplementedException();
- }
-
- bool ICollection<string>.Contains(string item)
- {
- throw new NotImplementedException();
- }
-
- void ICollection<string>.CopyTo(string[] array, int arrayIndex)
- {
- throw new NotImplementedException();
- }
-
- int ICollection<string>.Count
- {
- get { throw new NotImplementedException(); }
- }
-
- bool ICollection<string>.IsReadOnly
- {
- get { throw new NotImplementedException(); }
- }
-
- bool ICollection<string>.Remove(string item)
- {
- throw new NotImplementedException();
- }
-
- IEnumerator<string> IEnumerable<string>.GetEnumerator()
- {
- throw new NotImplementedException();
- }
-
- #endregion
- }
-
- public class ImportCollectionWithMultipleInterfaces
- {
- [ImportMany("Value")]
- public CollectionWithMultipleInterfaces Values { get; set; }
- }
-
- [TestMethod]
- public void ImportCollections_MultipleICollections_ShouldCauseNotWriteable()
- {
- ExpectedErrorOnPartActivate(new ImportCollectionWithMultipleInterfaces(),
- ErrorId.ReflectionModel_ImportCollectionNotWritable);
- }
-
- public class ImportManyNonCollectionTypeString
- {
- [ImportMany("Value")]
- public string Foo { get; set; }
- }
-
- [TestMethod]
- public void ImportManyOnNonCollectionTypeString_ShouldCauseNotWritable()
- {
- ExpectedErrorOnPartActivate(new ImportManyNonCollectionTypeString(),
- ErrorId.ReflectionModel_ImportCollectionNotWritable);
- }
-
- public class ImportManyNonCollectionTypeObject
- {
- [ImportMany("Value")]
- public object Foo { get; set; }
- }
-
- [TestMethod]
- public void ImportManyOnNonCollectionTypeObject_ShouldCauseNotWritable()
- {
- ExpectedErrorOnPartActivate(new ImportManyNonCollectionTypeObject(),
- ErrorId.ReflectionModel_ImportCollectionNotWritable);
- }
-
-#if !SILVERLIGHT
- // SILVERLIGHT doesn't have SetEnvironmentVariable set in this test.
- public class ExportADictionaryObject
- {
- [Export]
- public IDictionary<string, object> MyDictionary
- {
- get
- {
- var dictionary = new Dictionary<string, object>();
- dictionary.Add("a", 42);
- dictionary.Add("b", "c");
- return dictionary;
- }
- }
- }
-
- public class ImportADictionaryObject
- {
- [Import]
- public IDictionary<string, object> MyDictionary { get; set; }
- }
-
- [TestMethod]
- public void ImportDictionaryAsSingleObject()
- {
- // Set variable to ensure the hack is turned off.
- Environment.SetEnvironmentVariable("ONLY_ALLOW_IMPORTMANY", "1");
-
- var container = ContainerFactory.Create();
- var batch = new CompositionBatch();
- var importer = new ImportADictionaryObject();
- var exporter = new ExportADictionaryObject();
-
- batch.AddPart(importer);
- batch.AddPart(exporter);
- container.Compose(batch);
-
- Assert.AreEqual(2, importer.MyDictionary.Count);
- }
-
- public class ExportACollectionObject
- {
- [Export]
- public Collection<string> MyCollection
- {
- get
- {
- var collection = new Collection<string>();
- collection.Add("a");
- collection.Add("b");
- return collection;
- }
- }
- }
-
- public class ImportACollectionObject
- {
- [Import]
- public Collection<string> MyCollection { get; set; }
- }
-
- [TestMethod]
- public void ImportCollectionAsSingleObject()
- {
- // Set variable to ensure the hack is turned off.
- Environment.SetEnvironmentVariable("ONLY_ALLOW_IMPORTMANY", "1");
-
- var container = ContainerFactory.Create();
- var batch = new CompositionBatch();
- var importer = new ImportACollectionObject();
- var exporter = new ExportACollectionObject();
-
- batch.AddPart(importer);
- batch.AddPart(exporter);
- container.Compose(batch);
-
- Assert.AreEqual(2, importer.MyCollection.Count);
- }
-#endif
-
- public void ExpectedErrorOnPartActivate(object importer, ErrorId expectedErrorId)
- {
- var container = ContainerFactory.Create();
- var batch = new CompositionBatch();
- batch.AddPart(importer);
- batch.AddExportedValue("Value", 42);
- batch.AddExportedValue("Value", 0);
-
- CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotActivate,
- expectedErrorId, RetryMode.DoNotRetry, () =>
- {
- container.Compose(batch);
- });
- }
-
- public void ExpectedErrorOnSetImport(object importer, ErrorId expectedErrorId)
- {
- var container = ContainerFactory.Create();
- var batch = new CompositionBatch();
- batch.AddPart(importer);
- batch.AddExportedValue("Value", 42);
- batch.AddExportedValue("Value", 0);
-
- CompositionAssert.ThrowsError(ErrorId.ImportEngine_PartCannotSetImport,
- expectedErrorId, RetryMode.DoNotRetry, () =>
- {
- container.Compose(batch);
- });
- }
-
- public void ExpectedChangeRejectedErrorOnSetImport(object importer, ErrorId expectedErrorId)
- {
- var container = ContainerFactory.Create();
- var batch = new CompositionBatch();
- batch.AddPart(importer);
- batch.AddExportedValue("Value", 42);
- batch.AddExportedValue("Value", 0);
-
- CompositionAssert.ThrowsChangeRejectedError(ErrorId.ImportEngine_PartCannotSetImport,
- expectedErrorId, RetryMode.DoNotRetry, () =>
- {
- container.Compose(batch);
- });
- }
- }
-}
|