// ----------------------------------------------------------------------- // Copyright (c) Microsoft Corporation. All rights reserved. // ----------------------------------------------------------------------- using System; using System.Collections.Generic; using System.ComponentModel.Composition.UnitTesting; using System.ComponentModel.Composition.Factories; using System.Linq; using System.UnitTesting; using Microsoft.VisualStudio.TestTools.UnitTesting; namespace System.ComponentModel.Composition { [TestClass] public class CompositionResultOfTTest { [TestMethod] public void Constructor1_ShouldSetErrorsPropertyToEmptyEnumerable() { var result = new CompositionResult(); EnumerableAssert.IsEmpty(result.Errors); } [TestMethod] public void Constructor2_ShouldSetErrorsPropertyToEmptyEnumerable() { var result = new CompositionResult("Value"); EnumerableAssert.IsEmpty(result.Errors); } [TestMethod] public void Constructor3_NullAsErrorsArgument_ShouldSetErrorsPropertyToEmptyEnumerable() { var result = new CompositionResult((CompositionError[])null); EnumerableAssert.IsEmpty(result.Errors); } [TestMethod] public void Constructor4_NullAsErrorsArgument_ShouldSetErrorsPropertyToEmptyEnumerable() { var result = new CompositionResult((IEnumerable)null); EnumerableAssert.IsEmpty(result.Errors); } [TestMethod] public void Constructor5_NullAsErrorsArgument_ShouldSetErrorsPropertyToEmptyEnumerable() { var result = new CompositionResult("Value", (IEnumerable)null); EnumerableAssert.IsEmpty(result.Errors); } [TestMethod] public void Constructor3_EmptyAsErrorsArgument_ShouldSetErrorsPropertyToEmptyEnumerable() { var result = new CompositionResult(new CompositionError[0]); EnumerableAssert.IsEmpty(result.Errors); } [TestMethod] public void Constructor4_EmptyAsErrorsArgument_ShouldSetErrorsPropertyToEmptyEnumerable() { var result = new CompositionResult(Enumerable.Empty()); EnumerableAssert.IsEmpty(result.Errors); } [TestMethod] public void Constructor5_EmptyAsErrorsArgument_ShouldSetErrorsPropertyToEmptyEnumerable() { var result = new CompositionResult("Value", Enumerable.Empty()); EnumerableAssert.IsEmpty(result.Errors); } [TestMethod] public void Constructor3_ValuesAsErrorsArgument_ShouldSetErrorsProperty() { var errors = Expectations.GetCompositionErrors(); foreach (var e in errors) { var result = new CompositionResult(e.ToArray()); EnumerableAssert.AreEqual(e, result.Errors); } } [TestMethod] public void Constructor4_ValuesAsErrorsArgument_ShouldSetErrorsProperty() { var errors = Expectations.GetCompositionErrors(); foreach (var e in errors) { var result = new CompositionResult(e); EnumerableAssert.AreEqual(e, result.Errors); } } [TestMethod] public void Constructor5_ValuesAsErrorsArgument_ShouldSetErrorsProperty() { var errors = Expectations.GetCompositionErrors(); foreach (var e in errors) { var result = new CompositionResult("Value", e); EnumerableAssert.AreEqual(e, result.Errors); } } [TestMethod] public void Constructor1_ShouldSetSucceededPropertyToTrue() { var result = new CompositionResult(); Assert.IsTrue(result.Succeeded); } [TestMethod] public void Constructor2_ShouldSetSucceededPropertyToTrue() { var result = new CompositionResult("Value"); Assert.IsTrue(result.Succeeded); } [TestMethod] public void Constructor3_NullAsErrorsArgument_ShouldSetSucceededPropertyToTrue() { var result = new CompositionResult((CompositionError[])null); Assert.IsTrue(result.Succeeded); } [TestMethod] public void Constructor4_NullAsErrorsArgument_ShouldSetSucceededPropertyToTrue() { var result = new CompositionResult((IEnumerable)null); Assert.IsTrue(result.Succeeded); } [TestMethod] public void Constructor5_NullAsErrorsArgument_ShouldSetSucceededPropertyToTrue() { var result = new CompositionResult("Value", (IEnumerable)null); Assert.IsTrue(result.Succeeded); } [TestMethod] public void Constructor3_EmptyAsErrorsArgument_ShouldSetSucceededPropertyToTrue() { var result = new CompositionResult(new CompositionError[0]); Assert.IsTrue(result.Succeeded); } [TestMethod] public void Constructor4_EmptyAsErrorsArgument_ShouldSetSucceededPropertyToTrue() { var result = new CompositionResult(Enumerable.Empty()); Assert.IsTrue(result.Succeeded); } [TestMethod] public void Constructor5_EmptyAsErrorsArgument_ShouldSetSucceededPropertyToTrue() { var result = new CompositionResult("Value", Enumerable.Empty()); Assert.IsTrue(result.Succeeded); } [TestMethod] public void Constructor3_ValuesAsErrorsArgument_ShouldSetSucceededPropertyToTrueIfThereAreErrors() { var errors = Expectations.GetCompositionErrors(); foreach (var e in errors) { var result = new CompositionResult(e.ToArray()); if (e.Count() > 0) { Assert.IsFalse(result.Succeeded); } else { Assert.IsTrue(result.Succeeded); } } } [TestMethod] public void Constructor4_ValuesAsErrorsArgument_ShouldSetSucceededPropertyToTrueIfThereAreErrors() { var errors = Expectations.GetCompositionErrors(); foreach (var e in errors) { var result = new CompositionResult(e); if (e.Count() > 0) { Assert.IsFalse(result.Succeeded); } else { Assert.IsTrue(result.Succeeded); } } } [TestMethod] public void Constructor5_ValuesAsErrorsArgument_ShouldSetSucceededPropertyToTrueIfThereAreErrors() { var errors = Expectations.GetCompositionErrors(); foreach (var e in errors) { var result = new CompositionResult("Value", e); if (e.Count() > 0) { Assert.IsFalse(result.Succeeded); } else { Assert.IsTrue(result.Succeeded); } } } [TestMethod] public void ToResult_NullAsErrorsArgument_ShouldReturnResultWithEmptyErrorsProperty() { var result = CreateCompositionResult((IEnumerable)null); var copy = result.ToResult(); EnumerableAssert.IsEmpty(copy.Errors); } [TestMethod] public void ToResult_EmptyEnumerableAsErrorsArgument_ShouldReturnResultWithEmptyErrorsProperty() { var result = CreateCompositionResult(Enumerable.Empty()); var copy = result.ToResult(); EnumerableAssert.IsEmpty(copy.Errors); } [TestMethod] public void ToResult_ValueAsErrorsArgument_ShouldReturnResultWithErrorsPropertySet() { var expectations = Expectations.GetCompositionErrors(); foreach (var e in expectations) { var result = CreateCompositionResult(e); var copy = result.ToResult(); EnumerableAssert.AreSequenceSame(result.Errors, copy.Errors); } } [TestMethod] public void ToResultOfT_NullAsErrorsArgument_ShouldReturnResultWithEmptyErrorsProperty() { var result = CreateCompositionResult((IEnumerable)null); var copy = result.ToResult(); EnumerableAssert.IsEmpty(copy.Errors); } [TestMethod] public void ToResultOfT_EmptyEnumerableAsErrorsArgument_ShouldReturnResultWithEmptyErrorsProperty() { var result = CreateCompositionResult(Enumerable.Empty()); var copy = result.ToResult(); EnumerableAssert.IsEmpty(copy.Errors); } [TestMethod] public void ToResultOfT_ValueAsErrorsArgument_ShouldReturnResultWithErrorsPropertySet() { var expectations = Expectations.GetCompositionErrors(); foreach (var e in expectations) { var result = CreateCompositionResult(e); var copy = result.ToResult(); EnumerableAssert.AreSequenceSame(result.Errors, copy.Errors); } } [TestMethod] public void ToResultOfT_ReferenceValueAsValueArgument_ShouldReturnResultWithNullValueProperty() { var expectations = Expectations.GetObjectsReferenceTypes(); foreach (var e in expectations) { var result = CreateCompositionResult(e); var copy = result.ToResult(); Assert.IsNull(copy.Value); } } [TestMethod] public void ToResultOfT_ValueTypeValueAsValueArgument_ShouldReturnResultWithNullValueProperty() { var expectations = Expectations.GetObjectsValueTypes(); foreach (var e in expectations) { var result = CreateCompositionResult(e); var copy = result.ToResult(); Assert.IsNull(copy.Value); } } [TestMethod] public void Value_NullAsErrorsArgumentAndValueAsValueArgument_ShouldReturnValue() { var expectations = Expectations.GetObjectsReferenceTypes(); foreach (var e in expectations) { var result = CreateCompositionResult(e, (IEnumerable)null); Assert.AreEqual(e, result.Value); } } [TestMethod] public void Value_EmptyEnumerableAsErrorsArgumentAndValueAsValueArgument_ShouldReturnValue() { var expectations = Expectations.GetObjectsReferenceTypes(); foreach (var e in expectations) { var result = CreateCompositionResult(e, Enumerable.Empty()); Assert.AreEqual(e, result.Value); } } [TestMethod] public void Value_SingleValueAsErrorsArgument_ShouldThrowComposition() { var errorIds = Expectations.GetEnumValues(); foreach (var errorId in errorIds) { var result = CreateCompositionResult(errorId); CompositionAssert.ThrowsError((ErrorId)errorId, () => { var value = result.Value; }); } } [TestMethod] public void Value_TwoSameValuesAsErrorsArgument_ShouldThrowComposition() { var errorIds = Expectations.GetEnumValues(); foreach (var errorId in errorIds) { var result = CreateCompositionResult(errorId, errorId); CompositionAssert.ThrowsErrors((ErrorId)errorId, (ErrorId)errorId, () => { var value = result.Value; }); } } [TestMethod] public void Value_TwoDifferentValuesAsErrorsArgument_ShouldThrowComposition() { var errorIds1 = Expectations.GetEnumValues(); var errorIds2 = Expectations.GetEnumValues(); for (int i = 0; i < errorIds1.Count(); i++) { var errorId1 = errorIds1.ElementAt(i); var errorId2 = errorIds1.ElementAt(errorIds2.Count() - 1 - i); var result = CreateCompositionResult(errorId1, errorId2); CompositionAssert.ThrowsErrors((ErrorId)errorId1, (ErrorId)errorId2, () => { var value = result.Value; }); } } private CompositionResult CreateCompositionResult(params CompositionErrorId[] errorIds) { return new CompositionResult(errorIds.Select(id => { return ErrorFactory.Create(id); })); } private CompositionResult CreateCompositionResult(int count) { var expectations = Expectations.GetEnumValues(); List errors = new List(); foreach (var e in expectations.Take(count)) { errors.Add(ErrorFactory.Create(e)); } return CreateCompositionResult(errors); } private CompositionResult CreateCompositionResult(IEnumerable errors) { return new CompositionResult(errors); } private CompositionResult CreateCompositionResult(T value) { return new CompositionResult(value); } private CompositionResult CreateCompositionResult(T value, IEnumerable errors) { return new CompositionResult(value, errors); } } }