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