mcs/class/System.ComponentModel.Composition/Tests/ComponentModelUnitTest/System/ComponentModel/Composition/CompositionExceptionTests.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.Globalization;\r
   9 using System.IO;\r
  10 using System.Linq;\r
  11 using System.Reflection;\r
  12 using System.Security;\r
  13 using System.Security.Permissions;\r
  14 using System.Text;\r
  15 using System.ComponentModel.Composition.Primitives;\r
  16 using System.UnitTesting;\r
  17 using Microsoft.Internal;\r
  18 using Microsoft.VisualStudio.TestTools.UnitTesting;\r
  19 \r
  20 #if !SILVERLIGHT\r
  21 using System.Runtime.Serialization;\r
  22 using System.Security.Policy;\r
  23 #endif\r
  24 \r
  25 namespace System.ComponentModel.Composition\r
  26 {\r
  27     [TestClass][Serializable]\r
  28     public class CompositionExceptionTests\r
  29     {\r
  30 #if !SILVERLIGHT\r
  31         public delegate void Work(int index);\r
  32 \r
  33         public class Worker : MarshalByRefObject\r
  34         {\r
  35             public static ExpectationCollection<IEnumerable<CompositionError>, string> expectations = new ExpectationCollection<IEnumerable<CompositionError>, string>();\r
  36             static Worker()\r
  37             {\r
  38                 expectations.Add(ErrorFactory.CreateFromDsl("Error"), "1<Separator> Error");\r
  39                 expectations.Add(ErrorFactory.CreateFromDsl("Error|Error"), "1<Separator> Error|2<Separator> Error");\r
  40                 expectations.Add(ErrorFactory.CreateFromDsl("Error|Error|Error"), "1<Separator> Error|2<Separator> Error|3<Separator> Error");\r
  41                 expectations.Add(ErrorFactory.CreateFromDsl("Error(Error)"), "1<Separator> Error|<Prefix>Error");\r
  42                 expectations.Add(ErrorFactory.CreateFromDsl("Error(Error|Error)"), "1<Separator> Error|<Prefix>Error|2<Separator> Error|<Prefix>Error");\r
  43                 expectations.Add(ErrorFactory.CreateFromDsl("Error(Error|Error|Error)"), "1<Separator> Error|<Prefix>Error|2<Separator> Error|<Prefix>Error|3<Separator> Error|<Prefix>Error");\r
  44                 expectations.Add(ErrorFactory.CreateFromDsl("Error(Error(Exception))"), "1<Separator> Exception|<Prefix>Error|<Prefix>Error");\r
  45                 expectations.Add(ErrorFactory.CreateFromDsl("Error(Error|Exception)"), "1<Separator> Error|<Prefix>Error|2<Separator> Exception|<Prefix>Error");\r
  46                 expectations.Add(ErrorFactory.CreateFromDsl("Error(Exception)"), "1<Separator> Exception|<Prefix>Error");\r
  47                 expectations.Add(ErrorFactory.CreateFromDsl("Error(Exception(Exception))"), "1<Separator> Exception|<Prefix>Exception|<Prefix>Error");\r
  48                 expectations.Add(ErrorFactory.CreateFromDsl("Error(Error(Exception)|Error)"), "1<Separator> Exception|<Prefix>Error|<Prefix>Error|2<Separator> Error|<Prefix>Error");\r
  49             }\r
  50 \r
  51             public Work Action;\r
  52 \r
  53             internal void DoWork(int index)\r
  54             {\r
  55                 Action(index);\r
  56             }\r
  57 \r
  58         }\r
  59 \r
  60 #endif\r
  61 \r
  62         [TestMethod]\r
  63         public void Constructor1_ShouldSetMessagePropertyToDefault()\r
  64         {\r
  65             var exception = new CompositionException();\r
  66 \r
  67             ExceptionAssert.HasDefaultMessage(exception);\r
  68         }\r
  69 \r
  70         [TestMethod]\r
  71         public void Constructor2_NullAsMessageArgument_ShouldSetMessagePropertyToDefault()\r
  72         {\r
  73             var exception = new CompositionException((string)null);\r
  74 \r
  75             ExceptionAssert.HasDefaultMessage(exception);\r
  76         }\r
  77 \r
  78         [TestMethod]\r
  79         public void Constructor3_EmptyEnumerableAsErrorsArgument_ShouldSetMessagePropertyToDefault()\r
  80         {\r
  81             var exception = new CompositionException(Enumerable.Empty<CompositionError>());\r
  82 \r
  83             ExceptionAssert.HasDefaultMessage(exception);\r
  84         }\r
  85 \r
  86         [TestMethod]\r
  87         public void Constructor4_NullAsMessageArgument_ShouldSetMessagePropertyToDefault()\r
  88         {\r
  89             var exception = new CompositionException((string)null, new Exception());\r
  90 \r
  91             ExceptionAssert.HasDefaultMessage(exception);\r
  92         }\r
  93 \r
  94         [TestMethod]\r
  95         public void Constructor5_NullAsMessageArgument_ShouldSetMessagePropertyToDefault()\r
  96         {\r
  97             var exception = new CompositionException((string)null, new Exception(), Enumerable.Empty<CompositionError>());\r
  98 \r
  99             ExceptionAssert.HasDefaultMessage(exception);\r
 100         }\r
 101 \r
 102         [TestMethod]\r
 103         public void Constructor2_ValueAsMessageArgument_ShouldSetMessageProperty()\r
 104         {\r
 105             var expectations = Expectations.GetExceptionMessages();\r
 106 \r
 107             foreach (var e in expectations)\r
 108             {\r
 109                 var exception = new CompositionException(e);\r
 110 \r
 111                 Assert.AreEqual(e, exception.Message);\r
 112             }\r
 113         }\r
 114 \r
 115         [TestMethod]\r
 116         public void Constructor4_ValueAsMessageArgument_ShouldSetMessageProperty()\r
 117         {\r
 118             var expectations = Expectations.GetExceptionMessages();\r
 119 \r
 120             foreach (var e in expectations)\r
 121             {\r
 122                 var exception = new CompositionException(e, new Exception());\r
 123 \r
 124                 Assert.AreEqual(e, exception.Message);\r
 125             }\r
 126         }\r
 127 \r
 128         [TestMethod]\r
 129         public void Constructor5_ValueAsMessageArgument_ShouldSetMessageProperty()\r
 130         {\r
 131             var expectations = Expectations.GetExceptionMessages();\r
 132 \r
 133             foreach (var e in expectations)\r
 134             {\r
 135                 var exception = new CompositionException(e, new Exception(), Enumerable.Empty<CompositionError>());\r
 136 \r
 137                 Assert.AreEqual(e, exception.Message);\r
 138             }\r
 139         }\r
 140 \r
 141         [TestMethod]\r
 142         public void Constructor1_ShouldSetInnerExceptionPropertyToNull()\r
 143         {\r
 144             var exception = new CompositionException();\r
 145 \r
 146             Assert.IsNull(exception.InnerException);\r
 147         }\r
 148 \r
 149         [TestMethod]\r
 150         public void Constructor2_ShouldSetInnerExceptionPropertyToNull()\r
 151         {\r
 152             var exception = new CompositionException("Message");\r
 153 \r
 154             Assert.IsNull(exception.InnerException);\r
 155         }\r
 156 \r
 157         [TestMethod]\r
 158         public void Constructor3_ShouldSetInnerExceptionPropertyToNull()\r
 159         {\r
 160             var exception = new CompositionException(Enumerable.Empty<CompositionError>());\r
 161 \r
 162             Assert.IsNull(exception.InnerException);\r
 163         }\r
 164 \r
 165         [TestMethod]\r
 166         public void Constructor4_NullAsInnerExceptionArgument_ShouldSetInnerExceptionPropertyToNull()\r
 167         {\r
 168             var exception = new CompositionException("Message", (Exception)null);\r
 169 \r
 170             Assert.IsNull(exception.InnerException);\r
 171         }\r
 172 \r
 173         [TestMethod]\r
 174         public void Constructor5_NullAsInnerExceptionArgument_ShouldSetInnerExceptionPropertyToNull()\r
 175         {\r
 176             var exception = new CompositionException("Message", (Exception)null, Enumerable.Empty<CompositionError>());\r
 177 \r
 178             Assert.IsNull(exception.InnerException);\r
 179         }\r
 180 \r
 181         [TestMethod]\r
 182         public void Constructor4_ValueAsInnerExceptionArgument_ShouldSetInnerExceptionProperty()\r
 183         {\r
 184             var expectations = Expectations.GetInnerExceptions();\r
 185 \r
 186             foreach (var e in expectations)\r
 187             {\r
 188                 var exception = new CompositionException("Message", e);\r
 189 \r
 190                 Assert.AreSame(e, exception.InnerException);\r
 191             }\r
 192         }\r
 193 \r
 194         [TestMethod]\r
 195         public void Constructor5_ValueAsInnerExceptionArgument_ShouldSetInnerExceptionProperty()\r
 196         {\r
 197             var expectations = Expectations.GetInnerExceptions();\r
 198 \r
 199             foreach (var e in expectations)\r
 200             {\r
 201                 var exception = new CompositionException("Message", e, Enumerable.Empty<CompositionError>());\r
 202 \r
 203                 Assert.AreSame(e, exception.InnerException);\r
 204             }\r
 205         }\r
 206 \r
 207         [TestMethod]\r
 208         public void Constructor2_ArrayWithNullAsErrorsArgument_ShouldThrowArgument()\r
 209         {\r
 210             var errors = new CompositionError[] { null };\r
 211 \r
 212             ExceptionAssert.ThrowsArgument<ArgumentException>("errors", () =>\r
 213             {\r
 214                 new CompositionException(errors);\r
 215             });\r
 216         }\r
 217 \r
 218         [TestMethod]\r
 219         public void Constructor5_ArrayWithNullAsErrorsArgument_ShouldThrowArgument()\r
 220         {\r
 221             var errors = new CompositionError[] { null };\r
 222 \r
 223             ExceptionAssert.ThrowsArgument<ArgumentException>("errors", () =>\r
 224             {\r
 225                 new CompositionException("Message", new Exception(), errors);\r
 226             });\r
 227         }\r
 228 \r
 229         [TestMethod]\r
 230         public void Constructor1_ShouldSetErrorsPropertyToEmpty()\r
 231         {\r
 232             var exception = new CompositionException();\r
 233 \r
 234             EnumerableAssert.IsEmpty(exception.Errors);\r
 235         }\r
 236 \r
 237         [TestMethod]\r
 238         public void Constructor2_NullAsErrorsArgument_ShouldSetErrorsPropertyToEmptyEnumerable()\r
 239         {\r
 240             var exception = new CompositionException((IEnumerable<CompositionError>)null);\r
 241 \r
 242             EnumerableAssert.IsEmpty(exception.Errors);\r
 243         }\r
 244 \r
 245         [TestMethod]\r
 246         public void Constructor2_EmptyEnumerableAsErrorsArgument_ShouldSetErrorsPropertyToEmptyEnumerable()\r
 247         {\r
 248             var exception = new CompositionException(Enumerable.Empty<CompositionError>());\r
 249 \r
 250             EnumerableAssert.IsEmpty(exception.Errors);\r
 251         }\r
 252 \r
 253         [TestMethod]\r
 254         public void Constructor2_ValueAsErrorsArgument_ShouldSetErrorsProperty()\r
 255         {\r
 256             var expectations = Expectations.GetCompositionErrors();\r
 257 \r
 258             foreach (var e in expectations)\r
 259             {\r
 260                 var exception = new CompositionException(e);\r
 261 \r
 262                 EnumerableAssert.AreSequenceSame(e, exception.Errors);\r
 263             }\r
 264         }\r
 265 \r
 266         [TestMethod]\r
 267         public void Constructor2_ArrayAsAsErrorsArgument_ShouldNotAllowModificationAfterConstruction()\r
 268         {\r
 269             var error = CreateCompositionError();\r
 270             var errors = new CompositionError[] { error };\r
 271 \r
 272             var exception = new CompositionException(errors);\r
 273 \r
 274             errors[0] = null;\r
 275 \r
 276             EnumerableAssert.AreEqual(exception.Errors, error);\r
 277         }\r
 278 \r
 279         [TestMethod]\r
 280         public void Constructor3_ShouldSetErrorsPropertyToEmpty()\r
 281         {\r
 282             var exception = new CompositionException();\r
 283 \r
 284             EnumerableAssert.IsEmpty(exception.Errors);\r
 285         }\r
 286 \r
 287         [TestMethod]\r
 288         public void Constructor4_ShouldSetErrorsPropertyToEmptyEnumerable()\r
 289         {\r
 290             var exception = new CompositionException("Message", new Exception());\r
 291 \r
 292             EnumerableAssert.IsEmpty(exception.Errors);\r
 293         }\r
 294 \r
 295         [TestMethod]\r
 296         public void Constructor5_NullAsErrorsArgument_ShouldSetErrorsPropertyToEmptyEnumerable()\r
 297         {\r
 298             var exception = new CompositionException("Message", new Exception(), (IEnumerable<CompositionError>)null);\r
 299 \r
 300             EnumerableAssert.IsEmpty(exception.Errors);\r
 301         }\r
 302 \r
 303         [TestMethod]\r
 304         public void Constructor5_EmptyEnumerableAsErrorsArgument_ShouldSetErrorsPropertyToEmptyEnumerable()\r
 305         {\r
 306             var exception = new CompositionException("Message", new Exception(), Enumerable.Empty<CompositionError>());\r
 307 \r
 308             EnumerableAssert.IsEmpty(exception.Errors);\r
 309         }\r
 310 \r
 311         [TestMethod]\r
 312         public void Constructor5_ValueAsErrorsArgument_ShouldSetErrorsProperty()\r
 313         {\r
 314             var expectations = Expectations.GetCompositionErrors();\r
 315 \r
 316             foreach (var e in expectations)\r
 317             {\r
 318                 var exception = new CompositionException("Message", new Exception(), e);\r
 319 \r
 320                 EnumerableAssert.AreSequenceSame(e, exception.Errors);\r
 321             }\r
 322         }\r
 323 \r
 324         [TestMethod]\r
 325         public void Constructor5_ArrayAsAsErrorsArgument_ShouldNotAllowModificationAfterConstruction()\r
 326         {\r
 327             var error = CreateCompositionError();\r
 328             var errors = new CompositionError[] { error };\r
 329 \r
 330             var exception = new CompositionException("Message", new Exception(), errors);\r
 331 \r
 332             errors[0] = null;\r
 333 \r
 334             EnumerableAssert.AreEqual(exception.Errors, error);\r
 335         }\r
 336 \r
 337         [TestMethod]\r
 338         public void Message_ShouldIncludeElementGraph()\r
 339         {\r
 340             var expectations = new ExpectationCollection<CompositionError, string>();\r
 341             CompositionError error = null;\r
 342 \r
 343             error = CreateCompositionErrorWithElementChain(1);\r
 344             expectations.Add(error, GetElementGraphString(error));\r
 345 \r
 346             error = CreateCompositionErrorWithElementChain(2);\r
 347             expectations.Add(error, GetElementGraphString(error));\r
 348 \r
 349             error = CreateCompositionErrorWithElementChain(3);\r
 350             expectations.Add(error, GetElementGraphString(error));\r
 351 \r
 352             error = CreateCompositionErrorWithElementChain(10);\r
 353             expectations.Add(error, GetElementGraphString(error));\r
 354 \r
 355 \r
 356             foreach (var e in expectations)\r
 357             {\r
 358                 var exception = CreateCompositionException(new CompositionError[] { e.Input });\r
 359 \r
 360                 string result = exception.ToString();\r
 361                 string expected = FixMessage(e.Output);\r
 362                 StringAssert.Contains(result, expected);\r
 363             }\r
 364         }\r
 365 \r
 366 #if !SILVERLIGHT && CLR40\r
 367         [TestMethod]\r
 368         public void Message_ShouldIncludeElementGraphAccrossAppDomain()\r
 369         {\r
 370             PermissionSet ps = new PermissionSet(PermissionState.None);\r
 371             ps.AddPermission(new SecurityPermission(SecurityPermissionFlag.Execution));\r
 372             ps.AddPermission(new ReflectionPermission(ReflectionPermissionFlag.MemberAccess));\r
 373 \r
 374             //Create a new sandboxed domain \r
 375             AppDomainSetup setup = AppDomain.CurrentDomain.SetupInformation;\r
 376             AppDomain newDomain = AppDomain.CreateDomain("test domain", null, setup, ps);\r
 377 \r
 378             Worker remoteWorker = (Worker)newDomain.CreateInstanceAndUnwrap(\r
 379                 Assembly.GetExecutingAssembly().FullName,\r
 380                 typeof(Worker).FullName);\r
 381 \r
 382             var expectationIndex = new int[] { 1, 2, 3, 10};\r
 383 \r
 384             var expectations = new ExpectationCollection<CompositionError, string>();\r
 385             CompositionError error = null;\r
 386 \r
 387             error = CreateCompositionErrorWithElementChain(1);\r
 388             expectations.Add(error, GetElementGraphString(error));\r
 389 \r
 390             error = CreateCompositionErrorWithElementChain(2);\r
 391             expectations.Add(error, GetElementGraphString(error));\r
 392 \r
 393             error = CreateCompositionErrorWithElementChain(3);\r
 394             expectations.Add(error, GetElementGraphString(error));\r
 395 \r
 396             error = CreateCompositionErrorWithElementChain(10);\r
 397             expectations.Add(error, GetElementGraphString(error));\r
 398 \r
 399             int index = 0;\r
 400             foreach (var e in expectations)\r
 401             {\r
 402                 try\r
 403                 {\r
 404                     remoteWorker.Action = (int x) => \r
 405                     {\r
 406                         var lclExpectations = new ExpectationCollection<CompositionError, string>();\r
 407 \r
 408                         var lclError = CreateCompositionErrorWithElementChain(x);\r
 409                         lclExpectations.Add(lclError, GetElementGraphString(lclError));\r
 410 \r
 411                         var ce =  CreateCompositionException(new CompositionError[] { lclExpectations[0].Input });\r
 412                         throw ce;\r
 413                     };\r
 414                     remoteWorker.DoWork(expectationIndex[index]);\r
 415                 }\r
 416                 catch (CompositionException compositionException)\r
 417                 {\r
 418                     string result = compositionException.ToString();\r
 419                     string expected = FixMessage(e.Output);\r
 420                     StringAssert.Contains(result, expected);\r
 421                 }\r
 422                 catch (Exception exception)\r
 423                 {\r
 424                     Assert.Fail(exception.ToString());\r
 425                 }\r
 426                 ++index;\r
 427             }\r
 428         }\r
 429 #endif\r
 430         [TestMethod]\r
 431         public void Message_ShouldIncludeErrors()\r
 432         { \r
 433             var expectations = new ExpectationCollection<IEnumerable<CompositionError>, string>();\r
 434             expectations.Add(ErrorFactory.CreateFromDsl("Error"),                           "1<Separator> Error");\r
 435             expectations.Add(ErrorFactory.CreateFromDsl("Error|Error"),                     "1<Separator> Error|2<Separator> Error");\r
 436             expectations.Add(ErrorFactory.CreateFromDsl("Error|Error|Error"),               "1<Separator> Error|2<Separator> Error|3<Separator> Error");\r
 437             expectations.Add(ErrorFactory.CreateFromDsl("Error(Error)"),                    "1<Separator> Error|<Prefix>Error");\r
 438             expectations.Add(ErrorFactory.CreateFromDsl("Error(Error|Error)"),              "1<Separator> Error|<Prefix>Error|2<Separator> Error|<Prefix>Error");\r
 439             expectations.Add(ErrorFactory.CreateFromDsl("Error(Error|Error|Error)"),        "1<Separator> Error|<Prefix>Error|2<Separator> Error|<Prefix>Error|3<Separator> Error|<Prefix>Error");\r
 440             expectations.Add(ErrorFactory.CreateFromDsl("Error(Error(Exception))"),         "1<Separator> Exception|<Prefix>Error|<Prefix>Error");\r
 441             expectations.Add(ErrorFactory.CreateFromDsl("Error(Error|Exception)"),          "1<Separator> Error|<Prefix>Error|2<Separator> Exception|<Prefix>Error");\r
 442             expectations.Add(ErrorFactory.CreateFromDsl("Error(Exception)"),                "1<Separator> Exception|<Prefix>Error");\r
 443             expectations.Add(ErrorFactory.CreateFromDsl("Error(Exception(Exception))"),     "1<Separator> Exception|<Prefix>Exception|<Prefix>Error");\r
 444             expectations.Add(ErrorFactory.CreateFromDsl("Error(Error(Exception)|Error)"),   "1<Separator> Exception|<Prefix>Error|<Prefix>Error|2<Separator> Error|<Prefix>Error");\r
 445 \r
 446             foreach (var e in expectations)\r
 447             {\r
 448                 var exception = CreateCompositionException(e.Input);\r
 449 \r
 450                 AssertMessage(exception, e.Output.Split('|'));\r
 451             }\r
 452         }\r
 453 \r
 454 #if !SILVERLIGHT && CLR40\r
 455         [TestMethod]\r
 456         public void Message_ShouldIncludeErrorsAccrossAppDomain()\r
 457         {\r
 458             PermissionSet ps = new PermissionSet(PermissionState.None);\r
 459             ps.AddPermission(new SecurityPermission(SecurityPermissionFlag.Execution));\r
 460             ps.AddPermission(new ReflectionPermission(ReflectionPermissionFlag.MemberAccess));\r
 461 \r
 462             //Create a new sandboxed domain \r
 463             AppDomainSetup setup = AppDomain.CurrentDomain.SetupInformation;\r
 464             AppDomain newDomain = AppDomain.CreateDomain("test domain", null, setup, ps);\r
 465 \r
 466             Worker remoteWorker = (Worker)newDomain.CreateInstanceAndUnwrap(\r
 467                 Assembly.GetExecutingAssembly().FullName,\r
 468                 typeof(Worker).FullName);\r
 469 \r
 470             int index = 0;\r
 471             foreach (var expectation in Worker.expectations)\r
 472             {\r
 473                 try\r
 474                 {\r
 475                     remoteWorker.Action = (int x) => \r
 476                     {\r
 477                         Exception e = CreateCompositionException(Worker.expectations[x].Input);\r
 478                         throw e;\r
 479                     };\r
 480 \r
 481                     remoteWorker.DoWork(index);\r
 482                 }\r
 483                 catch(CompositionException e)\r
 484                 {\r
 485                     AssertMessage(e, expectation.Output.Split('|'));\r
 486                 }\r
 487                 catch(Exception e)\r
 488                 {\r
 489                     Assert.Fail(e.ToString());\r
 490                 }\r
 491                 ++index;\r
 492             }\r
 493         }\r
 494 #endif\r
 495         [TestMethod]\r
 496         public void Messsage_ShouldIncludeCountOfRootCauses()\r
 497         {\r
 498             var expectations = new ExpectationCollection<IEnumerable<CompositionError>, int>();\r
 499             expectations.Add(ErrorFactory.CreateFromDsl("Error"),                            1);\r
 500             expectations.Add(ErrorFactory.CreateFromDsl("Error|Error"),                      2);\r
 501             expectations.Add(ErrorFactory.CreateFromDsl("Error|Error|Error"),                3);\r
 502             expectations.Add(ErrorFactory.CreateFromDsl("Error(Error)"),                     1);\r
 503             expectations.Add(ErrorFactory.CreateFromDsl("Error(Error)|Error(Error)"),        2);\r
 504             expectations.Add(ErrorFactory.CreateFromDsl("Error(Error|Error)"),               2);\r
 505             expectations.Add(ErrorFactory.CreateFromDsl("Error(Error|Error|Exception)"),     3);\r
 506             \r
 507             foreach (var e in expectations)\r
 508             {\r
 509                 var exception = CreateCompositionException(e.Input);\r
 510 \r
 511                 AssertMessage(exception, e.Output, CultureInfo.CurrentCulture);\r
 512             }\r
 513         }\r
 514 \r
 515         [TestMethod]\r
 516         public void Message_ShouldFormatCountOfRootCausesUsingTheCurrentCulture()\r
 517         {\r
 518             var cultures = Expectations.GetCulturesForFormatting();\r
 519 \r
 520             foreach (var culture in cultures)\r
 521             {\r
 522                 using (new CurrentCultureContext(culture))\r
 523                 {\r
 524                     var errors = CreateCompositionErrors(1000);\r
 525                     var exception = CreateCompositionException(errors);\r
 526                     AssertMessage(exception, 1000, culture);\r
 527 \r
 528                     errors = CreateCompositionErrors(1);\r
 529                     exception = CreateCompositionException(errors);\r
 530                     AssertMessage(exception, 1, culture);\r
 531                 }\r
 532             }\r
 533         }\r
 534 \r
 535 #if !SILVERLIGHT && CLR40\r
 536 \r
 537         [TestMethod]\r
 538         public void Message_CanBeSerialized()\r
 539         {\r
 540             var expectations = Expectations.GetExceptionMessages();\r
 541 \r
 542             foreach (var e in expectations)\r
 543             {\r
 544                 var exception = CreateCompositionException(e);\r
 545 \r
 546                 var result = SerializationTestServices.RoundTrip(exception);\r
 547 \r
 548                 Assert.AreEqual(exception.Message, result.Message);\r
 549             }\r
 550         }\r
 551 \r
 552         [TestMethod]\r
 553         public void Errors_CanBeSerialized()\r
 554         {\r
 555             var expectations = Expectations.GetCompositionErrors();\r
 556 \r
 557             foreach (var e in expectations)\r
 558             {\r
 559                 var exception = CreateCompositionException(e);\r
 560 \r
 561                 var result = SerializationTestServices.RoundTrip(exception);\r
 562 \r
 563                 EnumerableAssert.AreSequenceEqual(exception.Errors, result.Errors, (index, expected, actual) =>\r
 564                 {\r
 565                     CompositionAssert.AreEqual(expected, actual);\r
 566                 });\r
 567             }\r
 568         }\r
 569 \r
 570 #endif\r
 571         private string GetElementGraphString(CompositionError error)\r
 572         {\r
 573             StringBuilder writer = new StringBuilder();\r
 574             ICompositionElement element = error.Element;\r
 575             writer.AppendFormat(CultureInfo.CurrentCulture, Strings.CompositionException_ElementPrefix, element.DisplayName);\r
 576 \r
 577             while ((element = element.Origin) != null)\r
 578             {\r
 579                 writer.AppendFormat(CultureInfo.CurrentCulture, Strings.CompositionException_OriginFormat, Strings.CompositionException_OriginSeparator, element.DisplayName);\r
 580             }\r
 581 \r
 582             return writer.ToString();\r
 583         }\r
 584 \r
 585         private void AssertMessage(CompositionException exception, int rootCauseCount, CultureInfo culture)\r
 586         {\r
 587             using (StringReader reader = new StringReader(exception.Message))\r
 588             {\r
 589                 string line = reader.ReadLine();\r
 590 \r
 591                 if (rootCauseCount == 1)\r
 592                 {\r
 593                     Assert.IsTrue(line.Contains(Strings.CompositionException_SingleErrorWithSinglePath));\r
 594                 }\r
 595                 else\r
 596                 {\r
 597                     Assert.IsTrue(\r
 598                         line.Contains(string.Format(CultureInfo.CurrentCulture, Strings.CompositionException_SingleErrorWithMultiplePaths, rootCauseCount)) ||\r
 599                         line.Contains(string.Format(CultureInfo.CurrentCulture, Strings.CompositionException_MultipleErrorsWithMultiplePaths, rootCauseCount))\r
 600                         );\r
 601                 }\r
 602             }\r
 603         }\r
 604 \r
 605         private void AssertMessage(CompositionException exception, string[] expected)\r
 606         {\r
 607             using (StringReader reader = new StringReader(exception.Message))\r
 608             {\r
 609                 // Skip header\r
 610                 reader.ReadLine();\r
 611 \r
 612                 foreach (string expect in expected)\r
 613                 {\r
 614                     // Skip blank line\r
 615                     reader.ReadLine();\r
 616                     Assert.AreEqual(FixMessage(expect), reader.ReadLine());\r
 617                 }\r
 618             }\r
 619         }\r
 620 \r
 621         private string FixMessage(string expect)\r
 622         {\r
 623             string fixedPrefix = expect.Replace("<Prefix>", Strings.CompositionException_ErrorPrefix + " ");\r
 624             string fixedSeparator = fixedPrefix.Replace("<Separator>", Strings.CompositionException_PathsCountSeparator);\r
 625             return fixedSeparator.Replace("<OriginSeparator>", Strings.CompositionException_OriginSeparator);\r
 626         }\r
 627 \r
 628         private static CompositionError CreateCompositionError()\r
 629         {\r
 630             return CreateCompositionError("Description");\r
 631         }\r
 632 \r
 633         private static CompositionError CreateCompositionError(string message)\r
 634         {\r
 635             return new CompositionError(message);\r
 636         }\r
 637 \r
 638         private static CompositionError CreateCompositionErrorWithElementChain(int count)\r
 639         {\r
 640             return new CompositionError("Description", ElementFactory.CreateChain(count));\r
 641         }\r
 642 \r
 643         private static CompositionError[] CreateCompositionErrors(int count)\r
 644         {\r
 645             CompositionError[] errors = new CompositionError[count];\r
 646 \r
 647             for (int i = 0; i < count; i++)\r
 648             {\r
 649                 errors[i] = CreateCompositionError("Description" + (i + 1));\r
 650             }\r
 651 \r
 652             return errors;\r
 653         }\r
 654 \r
 655         private static CompositionException CreateCompositionException()\r
 656         {\r
 657             return CreateCompositionException((string)null, (Exception)null, (IEnumerable<CompositionError>)null);\r
 658         }\r
 659 \r
 660         private static CompositionException CreateCompositionException(string message)\r
 661         {\r
 662             return CreateCompositionException(message, (Exception)null, (IEnumerable<CompositionError>)null);\r
 663         }\r
 664 \r
 665         private static CompositionException CreateCompositionException(IEnumerable<CompositionError> errors)\r
 666         {\r
 667             return CreateCompositionException((string)null, (Exception)null, errors);\r
 668         }\r
 669 \r
 670         private static CompositionException CreateCompositionException(Exception innerException)\r
 671         {\r
 672             return CreateCompositionException((string)null, innerException, (IEnumerable<CompositionError>)null);\r
 673         }\r
 674 \r
 675         private static CompositionException CreateCompositionException(string message, Exception innerException, IEnumerable<CompositionError> errors)\r
 676         {\r
 677             return new CompositionException(message, innerException, errors);\r
 678         }\r
 679     }\r
 680 }\r