1 // -----------------------------------------------------------------------
\r
2 // Copyright (c) Microsoft Corporation. All rights reserved.
\r
3 // -----------------------------------------------------------------------
\r
5 using System.Collections.Generic;
\r
6 using System.ComponentModel.Composition.UnitTesting;
\r
7 using System.ComponentModel.Composition.Factories;
\r
9 using System.UnitTesting;
\r
10 using Microsoft.VisualStudio.TestTools.UnitTesting;
\r
12 namespace System.ComponentModel.Composition
\r
15 public class CompositionResultOfTTest
\r
18 public void Constructor1_ShouldSetErrorsPropertyToEmptyEnumerable()
\r
20 var result = new CompositionResult<string>();
\r
22 EnumerableAssert.IsEmpty(result.Errors);
\r
26 public void Constructor2_ShouldSetErrorsPropertyToEmptyEnumerable()
\r
28 var result = new CompositionResult<string>("Value");
\r
30 EnumerableAssert.IsEmpty(result.Errors);
\r
34 public void Constructor3_NullAsErrorsArgument_ShouldSetErrorsPropertyToEmptyEnumerable()
\r
36 var result = new CompositionResult<string>((CompositionError[])null);
\r
38 EnumerableAssert.IsEmpty(result.Errors);
\r
42 public void Constructor4_NullAsErrorsArgument_ShouldSetErrorsPropertyToEmptyEnumerable()
\r
44 var result = new CompositionResult<string>((IEnumerable<CompositionError>)null);
\r
46 EnumerableAssert.IsEmpty(result.Errors);
\r
50 public void Constructor5_NullAsErrorsArgument_ShouldSetErrorsPropertyToEmptyEnumerable()
\r
52 var result = new CompositionResult<string>("Value", (IEnumerable<CompositionError>)null);
\r
54 EnumerableAssert.IsEmpty(result.Errors);
\r
58 public void Constructor3_EmptyAsErrorsArgument_ShouldSetErrorsPropertyToEmptyEnumerable()
\r
60 var result = new CompositionResult<string>(new CompositionError[0]);
\r
62 EnumerableAssert.IsEmpty(result.Errors);
\r
66 public void Constructor4_EmptyAsErrorsArgument_ShouldSetErrorsPropertyToEmptyEnumerable()
\r
68 var result = new CompositionResult<string>(Enumerable.Empty<CompositionError>());
\r
70 EnumerableAssert.IsEmpty(result.Errors);
\r
74 public void Constructor5_EmptyAsErrorsArgument_ShouldSetErrorsPropertyToEmptyEnumerable()
\r
76 var result = new CompositionResult<string>("Value", Enumerable.Empty<CompositionError>());
\r
78 EnumerableAssert.IsEmpty(result.Errors);
\r
82 public void Constructor3_ValuesAsErrorsArgument_ShouldSetErrorsProperty()
\r
84 var errors = Expectations.GetCompositionErrors();
\r
86 foreach (var e in errors)
\r
88 var result = new CompositionResult<string>(e.ToArray());
\r
90 EnumerableAssert.AreEqual(e, result.Errors);
\r
95 public void Constructor4_ValuesAsErrorsArgument_ShouldSetErrorsProperty()
\r
97 var errors = Expectations.GetCompositionErrors();
\r
99 foreach (var e in errors)
\r
101 var result = new CompositionResult<string>(e);
\r
103 EnumerableAssert.AreEqual(e, result.Errors);
\r
108 public void Constructor5_ValuesAsErrorsArgument_ShouldSetErrorsProperty()
\r
110 var errors = Expectations.GetCompositionErrors();
\r
112 foreach (var e in errors)
\r
114 var result = new CompositionResult<string>("Value", e);
\r
116 EnumerableAssert.AreEqual(e, result.Errors);
\r
121 public void Constructor1_ShouldSetSucceededPropertyToTrue()
\r
123 var result = new CompositionResult<string>();
\r
125 Assert.IsTrue(result.Succeeded);
\r
130 public void Constructor2_ShouldSetSucceededPropertyToTrue()
\r
132 var result = new CompositionResult<string>("Value");
\r
134 Assert.IsTrue(result.Succeeded);
\r
138 public void Constructor3_NullAsErrorsArgument_ShouldSetSucceededPropertyToTrue()
\r
140 var result = new CompositionResult<string>((CompositionError[])null);
\r
142 Assert.IsTrue(result.Succeeded);
\r
146 public void Constructor4_NullAsErrorsArgument_ShouldSetSucceededPropertyToTrue()
\r
148 var result = new CompositionResult<string>((IEnumerable<CompositionError>)null);
\r
150 Assert.IsTrue(result.Succeeded);
\r
154 public void Constructor5_NullAsErrorsArgument_ShouldSetSucceededPropertyToTrue()
\r
156 var result = new CompositionResult<string>("Value", (IEnumerable<CompositionError>)null);
\r
158 Assert.IsTrue(result.Succeeded);
\r
162 public void Constructor3_EmptyAsErrorsArgument_ShouldSetSucceededPropertyToTrue()
\r
164 var result = new CompositionResult<string>(new CompositionError[0]);
\r
166 Assert.IsTrue(result.Succeeded);
\r
170 public void Constructor4_EmptyAsErrorsArgument_ShouldSetSucceededPropertyToTrue()
\r
172 var result = new CompositionResult<string>(Enumerable.Empty<CompositionError>());
\r
174 Assert.IsTrue(result.Succeeded);
\r
178 public void Constructor5_EmptyAsErrorsArgument_ShouldSetSucceededPropertyToTrue()
\r
180 var result = new CompositionResult<string>("Value", Enumerable.Empty<CompositionError>());
\r
182 Assert.IsTrue(result.Succeeded);
\r
186 public void Constructor3_ValuesAsErrorsArgument_ShouldSetSucceededPropertyToTrueIfThereAreErrors()
\r
188 var errors = Expectations.GetCompositionErrors();
\r
190 foreach (var e in errors)
\r
192 var result = new CompositionResult<string>(e.ToArray());
\r
196 Assert.IsFalse(result.Succeeded);
\r
200 Assert.IsTrue(result.Succeeded);
\r
206 public void Constructor4_ValuesAsErrorsArgument_ShouldSetSucceededPropertyToTrueIfThereAreErrors()
\r
208 var errors = Expectations.GetCompositionErrors();
\r
210 foreach (var e in errors)
\r
212 var result = new CompositionResult<string>(e);
\r
216 Assert.IsFalse(result.Succeeded);
\r
220 Assert.IsTrue(result.Succeeded);
\r
226 public void Constructor5_ValuesAsErrorsArgument_ShouldSetSucceededPropertyToTrueIfThereAreErrors()
\r
228 var errors = Expectations.GetCompositionErrors();
\r
230 foreach (var e in errors)
\r
232 var result = new CompositionResult<string>("Value", e);
\r
236 Assert.IsFalse(result.Succeeded);
\r
240 Assert.IsTrue(result.Succeeded);
\r
246 public void ToResult_NullAsErrorsArgument_ShouldReturnResultWithEmptyErrorsProperty()
\r
248 var result = CreateCompositionResult<string>((IEnumerable<CompositionError>)null);
\r
250 var copy = result.ToResult();
\r
252 EnumerableAssert.IsEmpty(copy.Errors);
\r
256 public void ToResult_EmptyEnumerableAsErrorsArgument_ShouldReturnResultWithEmptyErrorsProperty()
\r
258 var result = CreateCompositionResult<string>(Enumerable.Empty<CompositionError>());
\r
260 var copy = result.ToResult();
\r
262 EnumerableAssert.IsEmpty(copy.Errors);
\r
266 public void ToResult_ValueAsErrorsArgument_ShouldReturnResultWithErrorsPropertySet()
\r
268 var expectations = Expectations.GetCompositionErrors();
\r
270 foreach (var e in expectations)
\r
272 var result = CreateCompositionResult<string>(e);
\r
274 var copy = result.ToResult();
\r
276 EnumerableAssert.AreSequenceSame(result.Errors, copy.Errors);
\r
281 public void ToResultOfT_NullAsErrorsArgument_ShouldReturnResultWithEmptyErrorsProperty()
\r
283 var result = CreateCompositionResult<string>((IEnumerable<CompositionError>)null);
\r
285 var copy = result.ToResult<string>();
\r
287 EnumerableAssert.IsEmpty(copy.Errors);
\r
291 public void ToResultOfT_EmptyEnumerableAsErrorsArgument_ShouldReturnResultWithEmptyErrorsProperty()
\r
293 var result = CreateCompositionResult<string>(Enumerable.Empty<CompositionError>());
\r
295 var copy = result.ToResult<string>();
\r
297 EnumerableAssert.IsEmpty(copy.Errors);
\r
301 public void ToResultOfT_ValueAsErrorsArgument_ShouldReturnResultWithErrorsPropertySet()
\r
303 var expectations = Expectations.GetCompositionErrors();
\r
305 foreach (var e in expectations)
\r
307 var result = CreateCompositionResult<string>(e);
\r
309 var copy = result.ToResult<string>();
\r
311 EnumerableAssert.AreSequenceSame(result.Errors, copy.Errors);
\r
316 public void ToResultOfT_ReferenceValueAsValueArgument_ShouldReturnResultWithNullValueProperty()
\r
318 var expectations = Expectations.GetObjectsReferenceTypes();
\r
320 foreach (var e in expectations)
\r
322 var result = CreateCompositionResult<object>(e);
\r
324 var copy = result.ToResult<object>();
\r
326 Assert.IsNull(copy.Value);
\r
331 public void ToResultOfT_ValueTypeValueAsValueArgument_ShouldReturnResultWithNullValueProperty()
\r
333 var expectations = Expectations.GetObjectsValueTypes();
\r
335 foreach (var e in expectations)
\r
337 var result = CreateCompositionResult<ValueType>(e);
\r
339 var copy = result.ToResult<ValueType>();
\r
341 Assert.IsNull(copy.Value);
\r
346 public void Value_NullAsErrorsArgumentAndValueAsValueArgument_ShouldReturnValue()
\r
348 var expectations = Expectations.GetObjectsReferenceTypes();
\r
350 foreach (var e in expectations)
\r
352 var result = CreateCompositionResult<object>(e, (IEnumerable<CompositionError>)null);
\r
354 Assert.AreEqual(e, result.Value);
\r
359 public void Value_EmptyEnumerableAsErrorsArgumentAndValueAsValueArgument_ShouldReturnValue()
\r
361 var expectations = Expectations.GetObjectsReferenceTypes();
\r
363 foreach (var e in expectations)
\r
365 var result = CreateCompositionResult<object>(e, Enumerable.Empty<CompositionError>());
\r
367 Assert.AreEqual(e, result.Value);
\r
372 public void Value_SingleValueAsErrorsArgument_ShouldThrowComposition()
\r
374 var errorIds = Expectations.GetEnumValues<CompositionErrorId>();
\r
376 foreach (var errorId in errorIds)
\r
378 var result = CreateCompositionResult<string>(errorId);
\r
380 CompositionAssert.ThrowsError((ErrorId)errorId, () =>
\r
382 var value = result.Value;
\r
388 public void Value_TwoSameValuesAsErrorsArgument_ShouldThrowComposition()
\r
390 var errorIds = Expectations.GetEnumValues<CompositionErrorId>();
\r
392 foreach (var errorId in errorIds)
\r
394 var result = CreateCompositionResult<string>(errorId, errorId);
\r
396 CompositionAssert.ThrowsErrors((ErrorId)errorId, (ErrorId)errorId, () =>
\r
398 var value = result.Value;
\r
404 public void Value_TwoDifferentValuesAsErrorsArgument_ShouldThrowComposition()
\r
406 var errorIds1 = Expectations.GetEnumValues<CompositionErrorId>();
\r
407 var errorIds2 = Expectations.GetEnumValues<CompositionErrorId>();
\r
409 for (int i = 0; i < errorIds1.Count(); i++)
\r
411 var errorId1 = errorIds1.ElementAt(i);
\r
412 var errorId2 = errorIds1.ElementAt(errorIds2.Count() - 1 - i);
\r
414 var result = CreateCompositionResult<string>(errorId1, errorId2);
\r
416 CompositionAssert.ThrowsErrors((ErrorId)errorId1, (ErrorId)errorId2, () =>
\r
418 var value = result.Value;
\r
423 private CompositionResult<T> CreateCompositionResult<T>(params CompositionErrorId[] errorIds)
\r
425 return new CompositionResult<T>(errorIds.Select(id =>
\r
427 return ErrorFactory.Create(id);
\r
431 private CompositionResult<T> CreateCompositionResult<T>(int count)
\r
433 var expectations = Expectations.GetEnumValues<CompositionErrorId>();
\r
435 List<CompositionError> errors = new List<CompositionError>();
\r
437 foreach (var e in expectations.Take(count))
\r
439 errors.Add(ErrorFactory.Create(e));
\r
442 return CreateCompositionResult<T>(errors);
\r
445 private CompositionResult<T> CreateCompositionResult<T>(IEnumerable<CompositionError> errors)
\r
447 return new CompositionResult<T>(errors);
\r
450 private CompositionResult<T> CreateCompositionResult<T>(T value)
\r
452 return new CompositionResult<T>(value);
\r
455 private CompositionResult<T> CreateCompositionResult<T>(T value, IEnumerable<CompositionError> errors)
\r
457 return new CompositionResult<T>(value, errors);
\r