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

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