class/System.ComponentModel.Composition/Tests/ComponentModelUnitTest/System/ComponentModel/Composition/CompositionResultOfTTest.cs

   1 // -----------------------------------------------------------------------
   2 // Copyright (c) Microsoft Corporation.  All rights reserved.
   3 // -----------------------------------------------------------------------
   4 using System;
   5 using System.Collections.Generic;
   6 using System.ComponentModel.Composition.UnitTesting;
   7 using System.ComponentModel.Composition.Factories;
   8 using System.Linq;
   9 using System.UnitTesting;
  10 using Microsoft.VisualStudio.TestTools.UnitTesting;
  11
  12 namespace System.ComponentModel.Composition
  13 {
  14     [TestClass]
  15     public class CompositionResultOfTTest
  16     {
  17         [TestMethod]
  18         public void Constructor1_ShouldSetErrorsPropertyToEmptyEnumerable()
  19         {
  20             var result = new CompositionResult<string>();
  21
  22             EnumerableAssert.IsEmpty(result.Errors);
  23         }
  24
  25         [TestMethod]
  26         public void Constructor2_ShouldSetErrorsPropertyToEmptyEnumerable()
  27         {
  28             var result = new CompositionResult<string>("Value");
  29
  30             EnumerableAssert.IsEmpty(result.Errors);
  31         }
  32
  33         [TestMethod]
  34         public void Constructor3_NullAsErrorsArgument_ShouldSetErrorsPropertyToEmptyEnumerable()
  35         {
  36             var result = new CompositionResult<string>((CompositionError[])null);
  37
  38             EnumerableAssert.IsEmpty(result.Errors);
  39         }
  40
  41         [TestMethod]
  42         public void Constructor4_NullAsErrorsArgument_ShouldSetErrorsPropertyToEmptyEnumerable()
  43         {
  44             var result = new CompositionResult<string>((IEnumerable<CompositionError>)null);
  45
  46             EnumerableAssert.IsEmpty(result.Errors);
  47         }
  48
  49         [TestMethod]
  50         public void Constructor5_NullAsErrorsArgument_ShouldSetErrorsPropertyToEmptyEnumerable()
  51         {
  52             var result = new CompositionResult<string>("Value", (IEnumerable<CompositionError>)null);
  53
  54             EnumerableAssert.IsEmpty(result.Errors);
  55         }
  56
  57         [TestMethod]
  58         public void Constructor3_EmptyAsErrorsArgument_ShouldSetErrorsPropertyToEmptyEnumerable()
  59         {
  60             var result = new CompositionResult<string>(new CompositionError[0]);
  61
  62             EnumerableAssert.IsEmpty(result.Errors);
  63         }
  64
  65         [TestMethod]
  66         public void Constructor4_EmptyAsErrorsArgument_ShouldSetErrorsPropertyToEmptyEnumerable()
  67         {
  68             var result = new CompositionResult<string>(Enumerable.Empty<CompositionError>());
  69
  70             EnumerableAssert.IsEmpty(result.Errors);
  71         }
  72
  73         [TestMethod]
  74         public void Constructor5_EmptyAsErrorsArgument_ShouldSetErrorsPropertyToEmptyEnumerable()
  75         {
  76             var result = new CompositionResult<string>("Value", Enumerable.Empty<CompositionError>());
  77
  78             EnumerableAssert.IsEmpty(result.Errors);
  79         }
  80
  81         [TestMethod]
  82         public void Constructor3_ValuesAsErrorsArgument_ShouldSetErrorsProperty()
  83         {
  84             var errors = Expectations.GetCompositionErrors();
  85
  86             foreach (var e in errors)
  87             {
  88                 var result = new CompositionResult<string>(e.ToArray());
  89
  90                 EnumerableAssert.AreEqual(e, result.Errors);
  91             }
  92         }
  93
  94         [TestMethod]
  95         public void Constructor4_ValuesAsErrorsArgument_ShouldSetErrorsProperty()
  96         {
  97             var errors = Expectations.GetCompositionErrors();
  98
  99             foreach (var e in errors)
 100             {
 101                 var result = new CompositionResult<string>(e);
 102
 103                 EnumerableAssert.AreEqual(e, result.Errors);
 104             }
 105         }
 106
 107         [TestMethod]
 108         public void Constructor5_ValuesAsErrorsArgument_ShouldSetErrorsProperty()
 109         {
 110             var errors = Expectations.GetCompositionErrors();
 111
 112             foreach (var e in errors)
 113             {
 114                 var result = new CompositionResult<string>("Value", e);
 115
 116                 EnumerableAssert.AreEqual(e, result.Errors);
 117             }
 118         }
 119
 120         [TestMethod]
 121         public void Constructor1_ShouldSetSucceededPropertyToTrue()
 122         {
 123             var result = new CompositionResult<string>();
 124
 125             Assert.IsTrue(result.Succeeded);
 126         }
 127
 128
 129         [TestMethod]
 130         public void Constructor2_ShouldSetSucceededPropertyToTrue()
 131         {
 132             var result = new CompositionResult<string>("Value");
 133
 134             Assert.IsTrue(result.Succeeded);
 135         }
 136
 137         [TestMethod]
 138         public void Constructor3_NullAsErrorsArgument_ShouldSetSucceededPropertyToTrue()
 139         {
 140             var result = new CompositionResult<string>((CompositionError[])null);
 141
 142             Assert.IsTrue(result.Succeeded);
 143         }
 144
 145         [TestMethod]
 146         public void Constructor4_NullAsErrorsArgument_ShouldSetSucceededPropertyToTrue()
 147         {
 148             var result = new CompositionResult<string>((IEnumerable<CompositionError>)null);
 149
 150             Assert.IsTrue(result.Succeeded);
 151         }
 152
 153         [TestMethod]
 154         public void Constructor5_NullAsErrorsArgument_ShouldSetSucceededPropertyToTrue()
 155         {
 156             var result = new CompositionResult<string>("Value", (IEnumerable<CompositionError>)null);
 157
 158             Assert.IsTrue(result.Succeeded);
 159         }
 160
 161         [TestMethod]
 162         public void Constructor3_EmptyAsErrorsArgument_ShouldSetSucceededPropertyToTrue()
 163         {
 164             var result = new CompositionResult<string>(new CompositionError[0]);
 165
 166             Assert.IsTrue(result.Succeeded);
 167         }
 168
 169         [TestMethod]
 170         public void Constructor4_EmptyAsErrorsArgument_ShouldSetSucceededPropertyToTrue()
 171         {
 172             var result = new CompositionResult<string>(Enumerable.Empty<CompositionError>());
 173
 174             Assert.IsTrue(result.Succeeded);
 175         }
 176
 177         [TestMethod]
 178         public void Constructor5_EmptyAsErrorsArgument_ShouldSetSucceededPropertyToTrue()
 179         {
 180             var result = new CompositionResult<string>("Value", Enumerable.Empty<CompositionError>());
 181
 182             Assert.IsTrue(result.Succeeded);
 183         }
 184
 185         [TestMethod]
 186         public void Constructor3_ValuesAsErrorsArgument_ShouldSetSucceededPropertyToTrueIfThereAreErrors()
 187         {
 188             var errors = Expectations.GetCompositionErrors();
 189
 190             foreach (var e in errors)
 191             {
 192                 var result = new CompositionResult<string>(e.ToArray());
 193
 194                 if (e.Count() > 0)
 195                 {
 196                     Assert.IsFalse(result.Succeeded);
 197                 }
 198                 else
 199                 {
 200                     Assert.IsTrue(result.Succeeded);
 201                 }
 202             }
 203         }
 204
 205         [TestMethod]
 206         public void Constructor4_ValuesAsErrorsArgument_ShouldSetSucceededPropertyToTrueIfThereAreErrors()
 207         {
 208             var errors = Expectations.GetCompositionErrors();
 209
 210             foreach (var e in errors)
 211             {
 212                 var result = new CompositionResult<string>(e);
 213
 214                 if (e.Count() > 0)
 215                 {
 216                     Assert.IsFalse(result.Succeeded);
 217                 }
 218                 else
 219                 {
 220                     Assert.IsTrue(result.Succeeded);
 221                 }
 222             }
 223         }
 224
 225         [TestMethod]
 226         public void Constructor5_ValuesAsErrorsArgument_ShouldSetSucceededPropertyToTrueIfThereAreErrors()
 227         {
 228             var errors = Expectations.GetCompositionErrors();
 229
 230             foreach (var e in errors)
 231             {
 232                 var result = new CompositionResult<string>("Value", e);
 233
 234                 if (e.Count() > 0)
 235                 {
 236                     Assert.IsFalse(result.Succeeded);
 237                 }
 238                 else
 239                 {
 240                     Assert.IsTrue(result.Succeeded);
 241                 }
 242             }
 243         }
 244
 245         [TestMethod]
 246         public void ToResult_NullAsErrorsArgument_ShouldReturnResultWithEmptyErrorsProperty()
 247         {
 248             var result = CreateCompositionResult<string>((IEnumerable<CompositionError>)null);
 249
 250             var copy = result.ToResult();
 251
 252             EnumerableAssert.IsEmpty(copy.Errors);
 253         }
 254
 255         [TestMethod]
 256         public void ToResult_EmptyEnumerableAsErrorsArgument_ShouldReturnResultWithEmptyErrorsProperty()
 257         {
 258             var result = CreateCompositionResult<string>(Enumerable.Empty<CompositionError>());
 259
 260             var copy = result.ToResult();
 261
 262             EnumerableAssert.IsEmpty(copy.Errors);
 263         }
 264
 265         [TestMethod]
 266         public void ToResult_ValueAsErrorsArgument_ShouldReturnResultWithErrorsPropertySet()
 267         {
 268             var expectations = Expectations.GetCompositionErrors();
 269
 270             foreach (var e in expectations)
 271             {
 272                 var result = CreateCompositionResult<string>(e);
 273
 274                 var copy = result.ToResult();
 275
 276                 EnumerableAssert.AreSequenceSame(result.Errors, copy.Errors);
 277             }
 278         }
 279
 280         [TestMethod]
 281         public void ToResultOfT_NullAsErrorsArgument_ShouldReturnResultWithEmptyErrorsProperty()
 282         {
 283             var result = CreateCompositionResult<string>((IEnumerable<CompositionError>)null);
 284
 285             var copy = result.ToResult<string>();
 286
 287             EnumerableAssert.IsEmpty(copy.Errors);
 288         }
 289
 290         [TestMethod]
 291         public void ToResultOfT_EmptyEnumerableAsErrorsArgument_ShouldReturnResultWithEmptyErrorsProperty()
 292         {
 293             var result = CreateCompositionResult<string>(Enumerable.Empty<CompositionError>());
 294
 295             var copy = result.ToResult<string>();
 296
 297             EnumerableAssert.IsEmpty(copy.Errors);
 298         }
 299
 300         [TestMethod]
 301         public void ToResultOfT_ValueAsErrorsArgument_ShouldReturnResultWithErrorsPropertySet()
 302         {
 303             var expectations = Expectations.GetCompositionErrors();
 304
 305             foreach (var e in expectations)
 306             {
 307                 var result = CreateCompositionResult<string>(e);
 308
 309                 var copy = result.ToResult<string>();
 310
 311                 EnumerableAssert.AreSequenceSame(result.Errors, copy.Errors);
 312             }
 313         }
 314
 315         [TestMethod]
 316         public void ToResultOfT_ReferenceValueAsValueArgument_ShouldReturnResultWithNullValueProperty()
 317         {
 318             var expectations = Expectations.GetObjectsReferenceTypes();
 319
 320             foreach (var e in expectations)
 321             {
 322                 var result = CreateCompositionResult<object>(e);
 323
 324                 var copy = result.ToResult<object>();
 325
 326                 Assert.IsNull(copy.Value);
 327             }
 328         }
 329
 330         [TestMethod]
 331         public void ToResultOfT_ValueTypeValueAsValueArgument_ShouldReturnResultWithNullValueProperty()
 332         {
 333             var expectations = Expectations.GetObjectsValueTypes();
 334
 335             foreach (var e in expectations)
 336             {
 337                 var result = CreateCompositionResult<ValueType>(e);
 338
 339                 var copy = result.ToResult<ValueType>();
 340
 341                 Assert.IsNull(copy.Value);
 342             }
 343         }
 344
 345         [TestMethod]
 346         public void Value_NullAsErrorsArgumentAndValueAsValueArgument_ShouldReturnValue()
 347         {
 348             var expectations = Expectations.GetObjectsReferenceTypes();
 349
 350             foreach (var e in expectations)
 351             {
 352                 var result = CreateCompositionResult<object>(e, (IEnumerable<CompositionError>)null);
 353
 354                 Assert.AreEqual(e, result.Value);
 355             }
 356         }
 357
 358         [TestMethod]
 359         public void Value_EmptyEnumerableAsErrorsArgumentAndValueAsValueArgument_ShouldReturnValue()
 360         {
 361             var expectations = Expectations.GetObjectsReferenceTypes();
 362
 363             foreach (var e in expectations)
 364             {
 365                 var result = CreateCompositionResult<object>(e, Enumerable.Empty<CompositionError>());
 366
 367                 Assert.AreEqual(e, result.Value);
 368             }
 369         }
 370
 371         [TestMethod]
 372         public void Value_SingleValueAsErrorsArgument_ShouldThrowComposition()
 373         {
 374             var errorIds = Expectations.GetEnumValues<CompositionErrorId>();
 375
 376             foreach (var errorId in errorIds)
 377             {
 378                 var result = CreateCompositionResult<string>(errorId);
 379
 380                 CompositionAssert.ThrowsError((ErrorId)errorId, () =>
 381                 {
 382                     var value = result.Value;
 383                 });
 384             }
 385         }
 386
 387         [TestMethod]
 388         public void Value_TwoSameValuesAsErrorsArgument_ShouldThrowComposition()
 389         {
 390             var errorIds = Expectations.GetEnumValues<CompositionErrorId>();
 391
 392             foreach (var errorId in errorIds)
 393             {
 394                 var result = CreateCompositionResult<string>(errorId, errorId);
 395
 396                 CompositionAssert.ThrowsErrors((ErrorId)errorId, (ErrorId)errorId, () =>
 397                 {
 398                     var value = result.Value;
 399                 });
 400             }
 401         }
 402
 403         [TestMethod]
 404         public void Value_TwoDifferentValuesAsErrorsArgument_ShouldThrowComposition()
 405         {
 406             var errorIds1 = Expectations.GetEnumValues<CompositionErrorId>();
 407             var errorIds2 = Expectations.GetEnumValues<CompositionErrorId>();
 408
 409             for (int i = 0; i < errorIds1.Count(); i++)
 410             {
 411                 var errorId1 = errorIds1.ElementAt(i);
 412                 var errorId2 = errorIds1.ElementAt(errorIds2.Count() - 1 - i);
 413
 414                 var result = CreateCompositionResult<string>(errorId1, errorId2);
 415
 416                 CompositionAssert.ThrowsErrors((ErrorId)errorId1, (ErrorId)errorId2, () =>
 417                 {
 418                     var value = result.Value;
 419                 });
 420             }
 421         }
 422
 423         private CompositionResult<T> CreateCompositionResult<T>(params CompositionErrorId[] errorIds)
 424         {
 425             return new CompositionResult<T>(errorIds.Select(id =>
 426             {
 427                 return ErrorFactory.Create(id);
 428             }));
 429         }
 430
 431         private CompositionResult<T> CreateCompositionResult<T>(int count)
 432         {
 433             var expectations = Expectations.GetEnumValues<CompositionErrorId>();
 434
 435             List<CompositionError> errors = new List<CompositionError>();
 436
 437             foreach (var e in expectations.Take(count))
 438             {
 439                 errors.Add(ErrorFactory.Create(e));
 440             }
 441
 442             return CreateCompositionResult<T>(errors);
 443         }
 444
 445         private CompositionResult<T> CreateCompositionResult<T>(IEnumerable<CompositionError> errors)
 446         {
 447             return new CompositionResult<T>(errors);
 448         }
 449
 450         private CompositionResult<T> CreateCompositionResult<T>(T value)
 451         {
 452             return new CompositionResult<T>(value);
 453         }
 454
 455         private CompositionResult<T> CreateCompositionResult<T>(T value, IEnumerable<CompositionError> errors)
 456         {
 457             return new CompositionResult<T>(value, errors);
 458         }
 459     }
 460 }