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

   1 // -----------------------------------------------------------------------\r
   2 // Copyright (c) Microsoft Corporation.  All rights reserved.\r
   3 // -----------------------------------------------------------------------\r
   4 using System;\r
   5 using System.Linq;\r
   6 using System.UnitTesting;\r
   7 using System.ComponentModel.Composition.Hosting;\r
   8 using System.ComponentModel.Composition.Factories;\r
   9 using System.ComponentModel.Composition.Primitives;\r
  10 using System.ComponentModel.Composition.UnitTesting;\r
  11 using Microsoft.VisualStudio.TestTools.UnitTesting;\r
  12 \r
  13 #if !SILVERLIGHT\r
  14 using System.Runtime.Serialization;\r
  15 #endif\r
  16 \r
  17 namespace System.ComponentModel.Composition\r
  18 {\r
  19     [TestClass]\r
  20     public class CompositionErrorTests\r
  21     {\r
  22         [TestMethod]\r
  23         public void Constructor1_NullAsMessageArgument_ShouldSetMessagePropertyToEmptyString()\r
  24         {\r
  25             var error = new CompositionError((string)null);\r
  26 \r
  27             Assert.AreEqual("", error.Description);\r
  28         }\r
  29 \r
  30         [TestMethod]\r
  31         public void Constructor2_NullAsMessageArgument_ShouldSetMessagePropertyToEmptyString()\r
  32         {\r
  33             var error = new CompositionError((string)null, ElementFactory.Create());\r
  34 \r
  35             Assert.AreEqual("", error.Description);\r
  36         }\r
  37 \r
  38         [TestMethod]\r
  39         public void Constructor3_NullAsMessageArgument_ShouldSetMessagePropertyToEmptyString()\r
  40         {\r
  41             var error = new CompositionError((string)null, new Exception());\r
  42 \r
  43             Assert.AreEqual("", error.Description);\r
  44         }\r
  45 \r
  46         [TestMethod]\r
  47         public void Constructor4_NullAsMessageArgument_ShouldSetMessagePropertyToEmptyString()\r
  48         {\r
  49             var error = new CompositionError((string)null, ElementFactory.Create(), new Exception());\r
  50 \r
  51             Assert.AreEqual("", error.Description);\r
  52         }\r
  53 \r
  54         [TestMethod]\r
  55         public void Constructor5_NullAsMessageArgument_ShouldSetMessagePropertyToEmptyString()\r
  56         {\r
  57             var error = new CompositionError(CompositionErrorId.Unknown, (string)null, ElementFactory.Create(), new Exception());\r
  58 \r
  59             Assert.AreEqual("", error.Description);\r
  60         }\r
  61 \r
  62         [TestMethod]\r
  63         public void Constructor1_ValueAsMessageArgument_ShouldSetMessageProperty()\r
  64         {\r
  65             var expectations = Expectations.GetExceptionMessages();\r
  66 \r
  67             foreach (var e in expectations)\r
  68             {\r
  69                 var exception = new CompositionError(e);\r
  70 \r
  71                 Assert.AreEqual(e, exception.Description);\r
  72             }\r
  73         }\r
  74 \r
  75         [TestMethod]\r
  76         public void Constructor2_ValueAsMessageArgument_ShouldSetMessageProperty()\r
  77         {\r
  78             var expectations = Expectations.GetExceptionMessages();\r
  79 \r
  80             foreach (var e in expectations)\r
  81             {\r
  82                 var exception = new CompositionError(e, ElementFactory.Create());\r
  83 \r
  84                 Assert.AreEqual(e, exception.Description);\r
  85             }\r
  86         }\r
  87 \r
  88         [TestMethod]\r
  89         public void Constructor3_ValueAsMessageArgument_ShouldSetMessageProperty()\r
  90         {\r
  91             var expectations = Expectations.GetExceptionMessages();\r
  92 \r
  93             foreach (var e in expectations)\r
  94             {\r
  95                 var exception = new CompositionError(e, new Exception());\r
  96 \r
  97                 Assert.AreEqual(e, exception.Description);\r
  98             }\r
  99         }\r
 100 \r
 101         [TestMethod]\r
 102         public void Constructor4_ValueAsMessageArgument_ShouldSetMessageProperty()\r
 103         {\r
 104             var expectations = Expectations.GetExceptionMessages();\r
 105 \r
 106             foreach (var e in expectations)\r
 107             {\r
 108                 var exception = new CompositionError(e, ElementFactory.Create(), new Exception());\r
 109 \r
 110                 Assert.AreEqual(e, exception.Description);\r
 111             }\r
 112         }\r
 113 \r
 114         [TestMethod]\r
 115         public void Constructor5_ValueAsMessageArgument_ShouldSetMessageProperty()\r
 116         {\r
 117             var expectations = Expectations.GetExceptionMessages();\r
 118 \r
 119             foreach (var e in expectations)\r
 120             {\r
 121                 var exception = new CompositionError(CompositionErrorId.Unknown, e, ElementFactory.Create(), new Exception());\r
 122 \r
 123                 Assert.AreEqual(e, exception.Description);\r
 124             }\r
 125         }\r
 126 \r
 127         [TestMethod]\r
 128         public void Constructor1_ShouldSetExceptionPropertyToNull()\r
 129         {\r
 130             var error = new CompositionError("Description");\r
 131 \r
 132             Assert.IsNull(error.Exception);\r
 133         }\r
 134 \r
 135         [TestMethod]\r
 136         public void Constructor2_ShouldSetExceptionPropertyToNull()\r
 137         {\r
 138             var error = new CompositionError("Description", ElementFactory.Create());\r
 139 \r
 140             Assert.IsNull(error.Exception);\r
 141         }\r
 142 \r
 143         [TestMethod]\r
 144         public void Constructor3_NullAsExceptionArgument_ShouldSetExceptionPropertyToNull()\r
 145         {\r
 146             var error = new CompositionError("Description", (Exception)null);\r
 147 \r
 148             Assert.IsNull(error.Exception);\r
 149         }\r
 150 \r
 151         [TestMethod]\r
 152         public void Constructor4_NullAsExceptionArgument_ShouldSetExceptionPropertyToNull()\r
 153         {\r
 154             var error = new CompositionError("Description", ElementFactory.Create(), (Exception)null);\r
 155 \r
 156             Assert.IsNull(error.Exception);\r
 157         }\r
 158 \r
 159         [TestMethod]\r
 160         public void Constructor5_NullAsExceptionArgument_ShouldSetExceptionPropertyToNull()\r
 161         {\r
 162             var error = new CompositionError(CompositionErrorId.Unknown, "Description", ElementFactory.Create(), (Exception)null);\r
 163 \r
 164             Assert.IsNull(error.Exception);\r
 165         }\r
 166 \r
 167         [TestMethod]\r
 168         public void Constructor3_ValueAsExceptionArgument_ShouldSetExceptionProperty()\r
 169         {\r
 170             var expectations = Expectations.GetInnerExceptions();\r
 171 \r
 172             foreach (var e in expectations)\r
 173             {\r
 174                 var error = new CompositionError("Description", e);\r
 175 \r
 176                 Assert.AreSame(e, error.Exception);\r
 177             }\r
 178         }\r
 179 \r
 180         [TestMethod]\r
 181         public void Constructor4_ValueAsExceptionArgument_ShouldSetExceptionProperty()\r
 182         {\r
 183             var expectations = Expectations.GetInnerExceptions();\r
 184 \r
 185             foreach (var e in expectations)\r
 186             {\r
 187                 var error = new CompositionError("Description", ElementFactory.Create(), e);\r
 188 \r
 189                 Assert.AreSame(e, error.Exception);\r
 190             }\r
 191         }\r
 192 \r
 193         [TestMethod]\r
 194         public void Constructor5_ValueAsExceptionArgument_ShouldSetExceptionProperty()\r
 195         {\r
 196             var expectations = Expectations.GetInnerExceptions();\r
 197 \r
 198             foreach (var e in expectations)\r
 199             {\r
 200                 var error = new CompositionError(CompositionErrorId.Unknown, "Description", ElementFactory.Create(), e);\r
 201 \r
 202                 Assert.AreSame(e, error.Exception);\r
 203             }\r
 204         }\r
 205 \r
 206         [TestMethod]\r
 207         public void Constructor1_ShouldSetInnerExceptionPropertyToNull()\r
 208         {\r
 209             var error = new CompositionError("Description");\r
 210 \r
 211             Assert.IsNull(((ICompositionError)error).InnerException);\r
 212         }\r
 213 \r
 214         [TestMethod]\r
 215         public void Constructor2_ShouldSetInnerExceptionPropertyToNull()\r
 216         {\r
 217             var error = new CompositionError("Description", ElementFactory.Create());\r
 218 \r
 219             Assert.IsNull(((ICompositionError)error).InnerException);\r
 220         }\r
 221 \r
 222         [TestMethod]\r
 223         public void Constructor3_NullAsExceptionArgument_ShouldSetInnerExceptionPropertyToNull()\r
 224         {\r
 225             var error = new CompositionError("Description", (Exception)null);\r
 226 \r
 227             Assert.IsNull(((ICompositionError)error).InnerException);\r
 228         }\r
 229 \r
 230         [TestMethod]\r
 231         public void Constructor4_NullAsExceptionArgument_ShouldSetInnerExceptionPropertyToNull()\r
 232         {\r
 233             var error = new CompositionError("Description", ElementFactory.Create(), (Exception)null);\r
 234 \r
 235             Assert.IsNull(((ICompositionError)error).InnerException);\r
 236         }\r
 237 \r
 238         [TestMethod]\r
 239         public void Constructor5_NullAsExceptionArgument_ShouldSetInnerExceptionPropertyToNull()\r
 240         {\r
 241             var error = new CompositionError(CompositionErrorId.Unknown, "Description", ElementFactory.Create(), (Exception)null);\r
 242 \r
 243             Assert.IsNull(((ICompositionError)error).InnerException);\r
 244         }\r
 245 \r
 246         [TestMethod]\r
 247         public void Constructor3_ValueAsExceptionArgument_ShouldSetInnerExceptionProperty()\r
 248         {\r
 249             var expectations = Expectations.GetInnerExceptions();\r
 250 \r
 251             foreach (var e in expectations)\r
 252             {\r
 253                 var error = new CompositionError("Description", e);\r
 254 \r
 255                 Assert.AreSame(e, ((ICompositionError)error).InnerException);\r
 256             }\r
 257         }\r
 258 \r
 259         [TestMethod]\r
 260         public void Constructor4_ValueAsExceptionArgument_ShouldSetInnerExceptionProperty()\r
 261         {\r
 262             var expectations = Expectations.GetInnerExceptions();\r
 263 \r
 264             foreach (var e in expectations)\r
 265             {\r
 266                 var error = new CompositionError("Description", ElementFactory.Create(), e);\r
 267 \r
 268                 Assert.AreSame(e, ((ICompositionError)error).InnerException);\r
 269             }\r
 270         }\r
 271 \r
 272         [TestMethod]\r
 273         public void Constructor1_ShouldSetICompositionErrorIdPropertyToCompositionErrorIdUnknown()\r
 274         {\r
 275             var error = new CompositionError("Description");\r
 276 \r
 277             Assert.AreEqual(CompositionErrorId.Unknown, ((ICompositionError)error).Id);\r
 278         }\r
 279 \r
 280         [TestMethod]\r
 281         public void Constructor2_ShouldSetICompositionErrorIdPropertyToCompositionErrorIdUnknown()\r
 282         {\r
 283             var error = new CompositionError("Description", ElementFactory.Create());\r
 284 \r
 285             Assert.AreEqual(CompositionErrorId.Unknown, ((ICompositionError)error).Id);\r
 286         }\r
 287 \r
 288         [TestMethod]\r
 289         public void Constructor3_ShouldSetICompositionErrorIdPropertyToCompositionErrorIdUnknown()\r
 290         {\r
 291             var error = new CompositionError("Description", new Exception());\r
 292 \r
 293             Assert.AreEqual(CompositionErrorId.Unknown, ((ICompositionError)error).Id);\r
 294         }\r
 295 \r
 296         [TestMethod]\r
 297         public void Constructor4_ShouldSetICompositionErrorIdPropertyToCompositionErrorIdUnknown()\r
 298         {\r
 299             var error = new CompositionError("Description", ElementFactory.Create(), new Exception());\r
 300 \r
 301             Assert.AreEqual(CompositionErrorId.Unknown, ((ICompositionError)error).Id);\r
 302         }\r
 303 \r
 304         [TestMethod]\r
 305         public void Constructor5_ValueAsIdArgument_ShouldSetICompositionErrorIdProperty()\r
 306         {\r
 307             var expectations = Expectations.GetEnumValues<CompositionErrorId>();\r
 308 \r
 309             foreach (var e in expectations)\r
 310             {\r
 311                 var error = new CompositionError(e, "Description", ElementFactory.Create(), new Exception());\r
 312 \r
 313                 Assert.AreEqual(e, ((ICompositionError)error).Id);\r
 314             }\r
 315         }\r
 316 \r
 317         [TestMethod]\r
 318         public void Constructor1_ShouldSetElementPropertyToNull()\r
 319         {\r
 320             var exception = new CompositionError("Description");\r
 321 \r
 322             Assert.IsNull(exception.Element);\r
 323         }\r
 324 \r
 325         [TestMethod]\r
 326         public void Constructor2_NullAsElementArgument_ShouldSetElementPropertyToNull()\r
 327         {\r
 328             var exception = new CompositionError("Description", (ICompositionElement)null);\r
 329 \r
 330             Assert.IsNull(exception.Element);\r
 331         }\r
 332 \r
 333         [TestMethod]\r
 334         public void Constructor3_ShouldSetElementPropertyToNull()\r
 335         {\r
 336             var exception = new CompositionError("Description", new Exception());\r
 337 \r
 338             Assert.IsNull(exception.Element);\r
 339         }\r
 340 \r
 341         [TestMethod]\r
 342         public void Constructor4_NullAsElementArgument_ShouldSetElementPropertyToNull()\r
 343         {\r
 344             var exception = new CompositionError("Description", (ICompositionElement)null, new Exception());\r
 345 \r
 346             Assert.IsNull(exception.Element);\r
 347         }\r
 348 \r
 349         [TestMethod]\r
 350         public void Constructor5_NullAsElementArgument_ShouldSetElementPropertyToNull()\r
 351         {\r
 352             var exception = new CompositionError(CompositionErrorId.Unknown, "Description", (ICompositionElement)null, new Exception());\r
 353 \r
 354             Assert.IsNull(exception.Element);\r
 355         }\r
 356 \r
 357         [TestMethod]\r
 358         public void Constructor2_ValueAsElementArgument_ShouldSetElementProperty()\r
 359         {\r
 360             var expectations = Expectations.GetCompositionElements();\r
 361 \r
 362             foreach (var e in expectations)\r
 363             {\r
 364                 var exception = new CompositionError("Description", (ICompositionElement)e);\r
 365 \r
 366                 Assert.AreSame(e, exception.Element);\r
 367             }\r
 368         }\r
 369 \r
 370         [TestMethod]\r
 371         public void Constructor4_ValueAsElementArgument_ShouldSetElementProperty()\r
 372         {\r
 373             var expectations = Expectations.GetCompositionElements();\r
 374 \r
 375             foreach (var e in expectations)\r
 376             {\r
 377                 var exception = new CompositionError("Description", (ICompositionElement)e, new Exception());\r
 378 \r
 379                 Assert.AreSame(e, exception.Element);\r
 380             }\r
 381         }\r
 382 \r
 383         [TestMethod]\r
 384         public void Constructor5_ValueAsElementArgument_ShouldSetElementProperty()\r
 385         {\r
 386             var expectations = Expectations.GetCompositionElements();\r
 387 \r
 388             foreach (var e in expectations)\r
 389             {\r
 390                 var exception = new CompositionError(CompositionErrorId.Unknown, "Description", (ICompositionElement)e, new Exception());\r
 391 \r
 392                 Assert.AreSame(e, exception.Element);\r
 393             }\r
 394         }\r
 395 \r
 396         [TestMethod]\r
 397         public void ToString_ShouldReturnMessageProperty()\r
 398         {\r
 399             var expectations = Expectations.GetExceptionMessages();\r
 400 \r
 401             foreach (var e in expectations)\r
 402             {\r
 403                 var error = CreateCompositionError(e);\r
 404 \r
 405                 Assert.AreEqual(error.Description, error.ToString());\r
 406             }\r
 407         }        \r
 408 \r
 409 #if !SILVERLIGHT\r
 410 \r
 411         [TestMethod]\r
 412         public void ICompositionErrorId_CanBeSerialized()\r
 413         {\r
 414             var expectations = Expectations.GetEnumValues<CompositionErrorId>();\r
 415 \r
 416             foreach (var e in expectations)\r
 417             {\r
 418                 var error = (ICompositionError)CreateCompositionError(e);\r
 419 \r
 420                 var result = SerializationTestServices.RoundTrip(error);\r
 421 \r
 422                 Assert.AreEqual(error.Id, result.Id);\r
 423             }\r
 424         }\r
 425 \r
 426         [TestMethod]\r
 427         public void Exception_CanBeSerialized()\r
 428         {\r
 429             var expectations = Expectations.GetInnerExceptionsWithNull();\r
 430 \r
 431             foreach (var e in expectations)\r
 432             {\r
 433                 var error = CreateCompositionError(e);\r
 434 \r
 435                 var result = SerializationTestServices.RoundTrip(error);\r
 436 \r
 437                 ExtendedAssert.IsInstanceOfSameType(error.Exception, result.Exception);\r
 438             }\r
 439         }\r
 440 \r
 441         [TestMethod]\r
 442         public void Message_CanBeSerialized()\r
 443         {\r
 444             var expectations = Expectations.GetExceptionMessages();\r
 445 \r
 446             foreach (var e in expectations)\r
 447             {\r
 448                 var error = CreateCompositionError(e);\r
 449 \r
 450                 var result = SerializationTestServices.RoundTrip(error);\r
 451 \r
 452                 Assert.AreEqual(error.Description, result.Description);\r
 453             }\r
 454         }\r
 455 \r
 456 #endif\r
 457 \r
 458         private static CompositionError CreateCompositionError()\r
 459         {\r
 460             return CreateCompositionError(CompositionErrorId.Unknown, (string)null, (ICompositionElement)null, (Exception)null);\r
 461         }\r
 462 \r
 463         private static CompositionError CreateCompositionError(string message)\r
 464         {\r
 465             return CreateCompositionError(CompositionErrorId.Unknown, message, (ICompositionElement)null, (Exception)null);\r
 466         }\r
 467 \r
 468         private static CompositionError CreateCompositionError(CompositionErrorId id)\r
 469         {\r
 470             return CreateCompositionError(id, (string)null, (ICompositionElement)null, (Exception)null);\r
 471         }\r
 472 \r
 473         private static CompositionError CreateCompositionError(Exception exception)\r
 474         {\r
 475             return CreateCompositionError(CompositionErrorId.Unknown, (string)null, (ICompositionElement)null, exception);\r
 476         }\r
 477 \r
 478         private static CompositionError CreateCompositionError(ICompositionElement element)\r
 479         {\r
 480             return CreateCompositionError(CompositionErrorId.Unknown, (string)null, element, (Exception)null);\r
 481         }\r
 482 \r
 483         private static CompositionError CreateCompositionError(CompositionErrorId id, string message, ICompositionElement element, Exception exception)\r
 484         {\r
 485             return new CompositionError(id, message, element, exception);\r
 486         }\r
 487 \r
 488         private static CompositionError CreateCompositionError(params string[] messages)\r
 489         {\r
 490             CompositionError error = null;\r
 491             foreach (string message in messages.Reverse())\r
 492             {\r
 493                 CompositionException exception = null;\r
 494                 if (error != null)\r
 495                 {\r
 496                     exception = CreateCompositionException(error);\r
 497                 }\r
 498 \r
 499                 error = ErrorFactory.Create(message, exception);\r
 500             }\r
 501 \r
 502             return error;\r
 503         }\r
 504 \r
 505         private static CompositionError CreateCompositionErrorWithException(params string[] messages)\r
 506         {\r
 507             Exception innerException = null;\r
 508             foreach (string message in messages.Skip(1).Reverse())\r
 509             {\r
 510                 innerException = new Exception(message, innerException);\r
 511             }\r
 512 \r
 513             return new CompositionError(messages[0], innerException);\r
 514         }\r
 515 \r
 516         private static CompositionError CreateCompostionErrorWithCompositionException(string message1, string message2)\r
 517         {\r
 518             var exception = CreateCompositionException(new Exception(message2));\r
 519 \r
 520             return new CompositionError(message1, exception);\r
 521         }\r
 522 \r
 523         private static CompositionException CreateCompositionException(CompositionError error)\r
 524         {\r
 525             return new CompositionException(error);\r
 526         }\r
 527 \r
 528         private static CompositionException CreateCompositionException(Exception innerException)\r
 529         {\r
 530             return new CompositionException("Description", innerException, null);\r
 531         }\r
 532     }\r
 533 }