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

   1 // -----------------------------------------------------------------------
   2 // Copyright (c) Microsoft Corporation.  All rights reserved.
   3 // -----------------------------------------------------------------------
   4 using System;
   5 using System.UnitTesting;
   6 using System.ComponentModel.Composition.Hosting;
   7 using System.ComponentModel.Composition.Primitives;
   8 using System.ComponentModel.Composition.Factories;
   9 using System.ComponentModel.Composition.UnitTesting;
  10 using Microsoft.VisualStudio.TestTools.UnitTesting;
  11
  12 #if !SILVERLIGHT
  13 using System.Runtime.Serialization;
  14 #endif
  15
  16 namespace System.ComponentModel.Composition
  17 {
  18     [TestClass]
  19     public class CompositionPartExceptionTests
  20     {
  21         [TestMethod]
  22         public void Constructor1_ShouldSetMessagePropertyToDefault()
  23         {
  24             var exception = new ComposablePartException();
  25
  26             ExceptionAssert.HasDefaultMessage(exception);
  27         }
  28
  29         [TestMethod]
  30         public void Constructor2_NullAsMessageArgument_ShouldSetMessagePropertyToDefault()
  31         {
  32             var exception = new ComposablePartException((string)null);
  33
  34             ExceptionAssert.HasDefaultMessage(exception);
  35         }
  36
  37         [TestMethod]
  38         public void Constructor3_NullAsMessageArgument_ShouldSetMessagePropertyToDefault()
  39         {
  40             var exception = new ComposablePartException((string)null, ElementFactory.Create());
  41
  42             ExceptionAssert.HasDefaultMessage(exception);
  43         }
  44
  45         [TestMethod]
  46         public void Constructor4_NullAsMessageArgument_ShouldSetMessagePropertyToDefault()
  47         {
  48             var exception = new ComposablePartException((string)null, new Exception());
  49
  50             ExceptionAssert.HasDefaultMessage(exception);
  51         }
  52
  53         [TestMethod]
  54         public void Constructor5_NullAsMessageArgument_ShouldSetMessagePropertyToDefault()
  55         {
  56             var exception = new ComposablePartException((string)null, ElementFactory.Create(), new Exception());
  57
  58             ExceptionAssert.HasDefaultMessage(exception);
  59         }
  60
  61         [TestMethod]
  62         public void Constructor6_NullAsMessageArgument_ShouldSetMessagePropertyToDefault()
  63         {
  64             var exception = new ComposablePartException(CompositionErrorId.Unknown, (string)null);
  65
  66             ExceptionAssert.HasDefaultMessage(exception);
  67         }
  68
  69         [TestMethod]
  70         public void Constructor7_NullAsMessageArgument_ShouldSetMessagePropertyToDefault()
  71         {
  72             var exception = new ComposablePartException(CompositionErrorId.Unknown, (string)null, new Exception());
  73
  74             ExceptionAssert.HasDefaultMessage(exception);
  75         }
  76
  77         [TestMethod]
  78         public void Constructor8_NullAsMessageArgument_ShouldSetMessagePropertyToDefault()
  79         {
  80             var exception = new ComposablePartException(CompositionErrorId.Unknown, (string)null, ElementFactory.Create());
  81
  82             ExceptionAssert.HasDefaultMessage(exception);
  83         }
  84
  85         [TestMethod]
  86         public void Constructor9_NullAsMessageArgument_ShouldSetMessagePropertyToDefault()
  87         {
  88             var exception = new ComposablePartException(CompositionErrorId.Unknown, (string)null, ElementFactory.Create(), new Exception());
  89
  90             ExceptionAssert.HasDefaultMessage(exception);
  91         }
  92
  93         [TestMethod]
  94         public void Constructor2_ValueAsMessageArgument_ShouldSetMessageProperty()
  95         {
  96             var expectations = Expectations.GetExceptionMessages();
  97
  98             foreach (var e in expectations)
  99             {
 100                 var exception = new ComposablePartException(e);
 101
 102                 Assert.AreEqual(e, exception.Message);
 103             }
 104         }
 105
 106         [TestMethod]
 107         public void Constructor3_ValueAsMessageArgument_ShouldSetMessageProperty()
 108         {
 109             var expectations = Expectations.GetExceptionMessages();
 110
 111             foreach (var e in expectations)
 112             {
 113                 var exception = new ComposablePartException(e, ElementFactory.Create());
 114
 115                 Assert.AreEqual(e, exception.Message);
 116             }
 117         }
 118
 119         [TestMethod]
 120         public void Constructor4_ValueAsMessageArgument_ShouldSetMessageProperty()
 121         {
 122             var expectations = Expectations.GetExceptionMessages();
 123
 124             foreach (var e in expectations)
 125             {
 126                 var exception = new ComposablePartException(e, new Exception());
 127
 128                 Assert.AreEqual(e, exception.Message);
 129             }
 130         }
 131
 132         [TestMethod]
 133         public void Constructor5_ValueAsMessageArgument_ShouldSetMessageProperty()
 134         {
 135             var expectations = Expectations.GetExceptionMessages();
 136
 137             foreach (var e in expectations)
 138             {
 139                 var exception = new ComposablePartException(e, ElementFactory.Create(), new Exception());
 140
 141                 Assert.AreEqual(e, exception.Message);
 142             }
 143         }
 144
 145         [TestMethod]
 146         public void Constructor6_ValueAsMessageArgument_ShouldSetMessageProperty()
 147         {
 148             var expectations = Expectations.GetExceptionMessages();
 149
 150             foreach (var e in expectations)
 151             {
 152                 var exception = new ComposablePartException(CompositionErrorId.Unknown, e);
 153
 154                 Assert.AreEqual(e, exception.Message);
 155             }
 156         }
 157
 158         [TestMethod]
 159         public void Constructor7_ValueAsMessageArgument_ShouldSetMessageProperty()
 160         {
 161             var expectations = Expectations.GetExceptionMessages();
 162
 163             foreach (var e in expectations)
 164             {
 165                 var exception = new ComposablePartException(CompositionErrorId.Unknown, e, new Exception());
 166
 167                 Assert.AreEqual(e, exception.Message);
 168             }
 169         }
 170
 171         [TestMethod]
 172         public void Constructor8_ValueAsMessageArgument_ShouldSetMessageProperty()
 173         {
 174             var expectations = Expectations.GetExceptionMessages();
 175
 176             foreach (var e in expectations)
 177             {
 178                 var exception = new ComposablePartException(CompositionErrorId.Unknown, e, ElementFactory.Create());
 179
 180                 Assert.AreEqual(e, exception.Message);
 181             }
 182         }
 183
 184         [TestMethod]
 185         public void Constructor9_ValueAsMessageArgument_ShouldSetMessageProperty()
 186         {
 187             var expectations = Expectations.GetExceptionMessages();
 188
 189             foreach (var e in expectations)
 190             {
 191                 var exception = new ComposablePartException(CompositionErrorId.Unknown, e, ElementFactory.Create(), new Exception());
 192
 193                 Assert.AreEqual(e, exception.Message);
 194             }
 195         }
 196
 197         [TestMethod]
 198         public void Constructor1_ShouldSetInnerExceptionPropertyToNull()
 199         {
 200             var exception = new ComposablePartException();
 201
 202             Assert.IsNull(exception.InnerException);
 203         }
 204
 205         [TestMethod]
 206         public void Constructor2_ShouldSetInnerExceptionPropertyToNull()
 207         {
 208             var exception = new ComposablePartException("Message");
 209
 210             Assert.IsNull(exception.InnerException);
 211         }
 212
 213         [TestMethod]
 214         public void Constructor3_ShouldSetInnerExceptionPropertyToNull()
 215         {
 216             var exception = new ComposablePartException("Message", ElementFactory.Create());
 217
 218             Assert.IsNull(exception.InnerException);
 219         }
 220
 221         [TestMethod]
 222         public void Constructor4_NullAsInnerExceptionArgument_ShouldSetInnerExceptionPropertyToNull()
 223         {
 224             var exception = new ComposablePartException("Message", (Exception)null);
 225
 226             Assert.IsNull(exception.InnerException);
 227         }
 228
 229         [TestMethod]
 230         public void Constructor5_NullAsInnerExceptionArgument_ShouldSetInnerExceptionPropertyToNull()
 231         {
 232             var exception = new ComposablePartException("Message", ElementFactory.Create(), (Exception)null);
 233
 234             Assert.IsNull(exception.InnerException);
 235         }
 236
 237         [TestMethod]
 238         public void Constructor6_ShouldSetInnerExceptionPropertyToNull()
 239         {
 240             var exception = new ComposablePartException(CompositionErrorId.Unknown, "Message");
 241
 242             Assert.IsNull(exception.InnerException);
 243         }
 244
 245         [TestMethod]
 246         public void Constructor7_NullAsInnerExceptionArgument_ShouldSetInnerExceptionPropertyToNull()
 247         {
 248             var exception = new ComposablePartException(CompositionErrorId.Unknown, "Message", (Exception)null);
 249
 250             Assert.IsNull(exception.InnerException);
 251         }
 252
 253         [TestMethod]
 254         public void Constructor8_ShouldSetInnerExceptionPropertyToNull()
 255         {
 256             var exception = new ComposablePartException(CompositionErrorId.Unknown, "Message", ElementFactory.Create());
 257
 258             Assert.IsNull(exception.InnerException);
 259         }
 260
 261         [TestMethod]
 262         public void Constructor9_NullAsInnerExceptionArgument_ShouldSetInnerExceptionPropertyToNull()
 263         {
 264             var exception = new ComposablePartException(CompositionErrorId.Unknown, "Message", ElementFactory.Create(), (Exception)null);
 265
 266             Assert.IsNull(exception.InnerException);
 267         }
 268
 269         [TestMethod]
 270         public void Constructor4_ValueAsInnerExceptionArgument_ShouldSetInnerExceptionProperty()
 271         {
 272             var expectations = Expectations.GetInnerExceptions();
 273
 274             foreach (var e in expectations)
 275             {
 276                 var exception = new ComposablePartException("Message", e);
 277
 278                 Assert.AreSame(e, exception.InnerException);
 279             }
 280         }
 281
 282         [TestMethod]
 283         public void Constructor5_ValueAsInnerExceptionArgument_ShouldSetInnerExceptionProperty()
 284         {
 285             var expectations = Expectations.GetInnerExceptions();
 286
 287             foreach (var e in expectations)
 288             {
 289                 var exception = new ComposablePartException("Message", ElementFactory.Create(), e);
 290
 291                 Assert.AreSame(e, exception.InnerException);
 292             }
 293         }
 294
 295         [TestMethod]
 296         public void Constructor7_ValueAsInnerExceptionArgument_ShouldSetInnerExceptionProperty()
 297         {
 298             var expectations = Expectations.GetInnerExceptions();
 299
 300             foreach (var e in expectations)
 301             {
 302                 var exception = new ComposablePartException(CompositionErrorId.Unknown, "Message", e);
 303
 304                 Assert.AreSame(e, exception.InnerException);
 305             }
 306         }
 307
 308         [TestMethod]
 309         public void Constructor9_ValueAsInnerExceptionArgument_ShouldSetInnerExceptionProperty()
 310         {
 311             var expectations = Expectations.GetInnerExceptions();
 312
 313             foreach (var e in expectations)
 314             {
 315                 var exception = new ComposablePartException(CompositionErrorId.Unknown, "Message", ElementFactory.Create(), e);
 316
 317                 Assert.AreSame(e, exception.InnerException);
 318             }
 319         }
 320
 321         [TestMethod]
 322         public void Constructor1_ShouldSetICompositionErrorIdPropertyToCompositionErrorIdUnknown()
 323         {
 324             var exception = (ICompositionError)new ComposablePartException();
 325
 326             Assert.AreEqual(CompositionErrorId.Unknown, exception.Id);
 327         }
 328
 329         [TestMethod]
 330         public void Constructor2_ShouldSetICompositionErrorIdPropertyToCompositionErrorIdUnknown()
 331         {
 332             var exception = (ICompositionError)new ComposablePartException("Message");
 333
 334             Assert.AreEqual(CompositionErrorId.Unknown, exception.Id);
 335         }
 336
 337         [TestMethod]
 338         public void Constructor3_ShouldSetICompositionErrorIdPropertyToCompositionErrorIdUnknown()
 339         {
 340             var exception = (ICompositionError)new ComposablePartException("Message", ElementFactory.Create());
 341
 342             Assert.AreEqual(CompositionErrorId.Unknown, exception.Id);
 343         }
 344
 345         [TestMethod]
 346         public void Constructor4_ShouldSetICompositionErrorIdPropertyToCompositionErrorIdUnknown()
 347         {
 348             var exception = (ICompositionError)new ComposablePartException("Message", new Exception());
 349
 350             Assert.AreEqual(CompositionErrorId.Unknown, exception.Id);
 351         }
 352
 353         [TestMethod]
 354         public void Constructor5_ShouldSetICompositionErrorIdPropertyToCompositionErrorIdUnknown()
 355         {
 356             var exception = (ICompositionError)new ComposablePartException("Message", ElementFactory.Create(), new Exception());
 357
 358             Assert.AreEqual(CompositionErrorId.Unknown, exception.Id);
 359         }
 360
 361         [TestMethod]
 362         public void Constructor6_ValueAsIdArgument_ShouldSetICompositionErrorIdProperty()
 363         {
 364             var expectations = Expectations.GetEnumValues<CompositionErrorId>();
 365
 366             foreach (var e in expectations)
 367             {
 368                 var exception = (ICompositionError)new ComposablePartException(e, "Message");
 369
 370                 Assert.AreEqual(e, exception.Id);
 371             }
 372         }
 373
 374         [TestMethod]
 375         public void Constructor7_ValueAsIdArgument_ShouldSetICompositionErrorIdProperty()
 376         {
 377             var expectations = Expectations.GetEnumValues<CompositionErrorId>();
 378
 379             foreach (var e in expectations)
 380             {
 381                 var exception = (ICompositionError)new ComposablePartException(e, "Message", new Exception());
 382
 383                 Assert.AreEqual(e, exception.Id);
 384             }
 385         }
 386
 387         [TestMethod]
 388         public void Constructor8_ValueAsIdArgument_ShouldSetICompositionErrorIdProperty()
 389         {
 390             var expectations = Expectations.GetEnumValues<CompositionErrorId>();
 391
 392             foreach (var e in expectations)
 393             {
 394                 var exception = (ICompositionError)new ComposablePartException(e, "Message", ElementFactory.Create());
 395
 396                 Assert.AreEqual(e, exception.Id);
 397             }
 398         }
 399
 400         [TestMethod]
 401         public void Constructor9_ValueAsIdArgument_ShouldSetICompositionErrorIdProperty()
 402         {
 403             var expectations = Expectations.GetEnumValues<CompositionErrorId>();
 404
 405             foreach (var e in expectations)
 406             {
 407                 var exception = (ICompositionError)new ComposablePartException(e, "Message", ElementFactory.Create(), new Exception());
 408
 409                 Assert.AreEqual(e, exception.Id);
 410             }
 411         }
 412
 413         [TestMethod]
 414         public void Constructor1_ShouldSetElementPropertyToNull()
 415         {
 416             var exception = new ComposablePartException();
 417
 418             Assert.IsNull(exception.Element);
 419         }
 420
 421         [TestMethod]
 422         public void Constructor2_ShouldSetElementPropertyToNull()
 423         {
 424             var exception = new ComposablePartException("Message");
 425
 426             Assert.IsNull(exception.Element);
 427         }
 428
 429         [TestMethod]
 430         public void Constructor3_NullAsElementArgument_ShouldSetElementPropertyToNull()
 431         {
 432             var exception = new ComposablePartException("Message", (ICompositionElement)null);
 433
 434             Assert.IsNull(exception.Element);
 435         }
 436
 437         [TestMethod]
 438         public void Constructor4_ShouldSetElementPropertyToNull()
 439         {
 440             var exception = new ComposablePartException("Message", new Exception());
 441
 442             Assert.IsNull(exception.Element);
 443         }
 444
 445         [TestMethod]
 446         public void Constructor5_NullAsElementArgument_ShouldSetElementPropertyToNull()
 447         {
 448             var exception = new ComposablePartException("Message", (ICompositionElement)null, new Exception());
 449
 450             Assert.IsNull(exception.Element);
 451         }
 452
 453         [TestMethod]
 454         public void Constructor6_ShouldSetElementPropertyToNull()
 455         {
 456             var exception = new ComposablePartException(CompositionErrorId.Unknown, "Message");
 457
 458             Assert.IsNull(exception.Element);
 459         }
 460
 461         [TestMethod]
 462         public void Constructor7_ShouldSetElementPropertyToNull()
 463         {
 464             var exception = new ComposablePartException(CompositionErrorId.Unknown, "Message", new Exception());
 465
 466             Assert.IsNull(exception.Element);
 467         }
 468
 469         [TestMethod]
 470         public void Constructor8_NullAsElementArgument_ShouldSetElementPropertyToNull()
 471         {
 472             var exception = new ComposablePartException(CompositionErrorId.Unknown, "Message", (ICompositionElement)null);
 473
 474             Assert.IsNull(exception.Element);
 475         }
 476
 477         [TestMethod]
 478         public void Constructor9_NullAsElementArgument_ShouldSetElementPropertyToNull()
 479         {
 480             var exception = new ComposablePartException(CompositionErrorId.Unknown, "Message", (ICompositionElement)null, new Exception());
 481
 482             Assert.IsNull(exception.Element);
 483         }
 484
 485         [TestMethod]
 486         public void Constructor3_ValueAsElementArgument_ShouldSetElementProperty()
 487         {
 488             var expectations = Expectations.GetCompositionElements();
 489
 490             foreach (var e in expectations)
 491             {
 492                 var exception = new ComposablePartException("Message", (ICompositionElement)e);
 493
 494                 Assert.AreSame(e, exception.Element);
 495             }
 496         }
 497
 498         [TestMethod]
 499         public void Constructor5_ValueAsElementArgument_ShouldSetElementProperty()
 500         {
 501             var expectations = Expectations.GetCompositionElements();
 502
 503             foreach (var e in expectations)
 504             {
 505                 var exception = new ComposablePartException("Message", (ICompositionElement)e, new Exception());
 506
 507                 Assert.AreSame(e, exception.Element);
 508             }
 509         }
 510
 511         [TestMethod]
 512         public void Constructor8_ValueAsElementArgument_ShouldSetElementProperty()
 513         {
 514             var expectations = Expectations.GetCompositionElements();
 515
 516             foreach (var e in expectations)
 517             {
 518                 var exception = new ComposablePartException(CompositionErrorId.Unknown, "Message", (ICompositionElement)e);
 519
 520                 Assert.AreSame(e, exception.Element);
 521             }
 522         }
 523
 524         [TestMethod]
 525         public void Constructor9_ValueAsElementArgument_ShouldSetElementProperty()
 526         {
 527             var expectations = Expectations.GetCompositionElements();
 528
 529             foreach (var e in expectations)
 530             {
 531                 var exception = new ComposablePartException(CompositionErrorId.Unknown, "Message", (ICompositionElement)e, new Exception());
 532
 533                 Assert.AreSame(e, exception.Element);
 534             }
 535         }
 536
 537 #if !SILVERLIGHT
 538
 539         [TestMethod]
 540         public void Constructor10_NullAsInfoArgument_ShouldThrowArgumentNull()
 541         {
 542             var context = new StreamingContext();
 543
 544             ExceptionAssert.ThrowsArgument<ArgumentNullException>("info", () =>
 545             {
 546                 SerializationTestServices.Create<ComposablePartException>((SerializationInfo)null, context);
 547             });
 548         }
 549
 550         [TestMethod]
 551         public void Constructor10_SerializationInfoWithMissingIdEntryAsInfoArgument_ShouldThrowSerialization()
 552         {
 553             var info = SerializationTestServices.CreateSerializationInfoRemovingMember<ComposablePartException>("Id");
 554             var context = new StreamingContext();
 555
 556             ExceptionAssert.ThrowsSerialization("Id", () =>
 557             {
 558                 SerializationTestServices.Create<ComposablePartException>(info, context);
 559             });
 560         }
 561
 562         [TestMethod]
 563         public void Constructor10_SerializationInfoWithMissingElementEntryAsInfoArgument_ShouldThrowSerialization()
 564         {
 565             var info = SerializationTestServices.CreateSerializationInfoRemovingMember<ComposablePartException>("Element");
 566             var context = new StreamingContext();
 567
 568             ExceptionAssert.ThrowsSerialization("Element", () =>
 569             {
 570                 SerializationTestServices.Create<ComposablePartException>(info, context);
 571             });
 572         }
 573
 574         [TestMethod]
 575         public void Constructor10_SerializationInfoWithWrongTypeForIdEntryAsInfoArgument_ShouldThrowInvalidCast()
 576         {
 577             var info = SerializationTestServices.CreateSerializationInfoReplacingMember<ComposablePartException>("Id", "InvalidValue");
 578             var context = new StreamingContext();
 579
 580             ExceptionAssert.Throws<InvalidCastException>(() =>
 581             {
 582                 SerializationTestServices.Create<ComposablePartException>(info, context);
 583             });
 584         }
 585
 586         [TestMethod]
 587         public void Constructor10_SerializationInfoWithWrongTypeForElementEntryAsInfoArgument_ShouldThrowInvalidCast()
 588         {
 589             var info = SerializationTestServices.CreateSerializationInfoReplacingMember<ComposablePartException>("Element", 10);
 590             var context = new StreamingContext();
 591
 592             ExceptionAssert.Throws<InvalidCastException>(() =>
 593             {
 594                 SerializationTestServices.Create<ComposablePartException>(info, context);
 595             });
 596         }
 597
 598         [TestMethod]
 599         public void Id_CanBeSerialized()
 600         {
 601             var expectations = Expectations.GetEnumValues<CompositionErrorId>();
 602
 603             foreach (var e in expectations)
 604             {
 605                 var exception = (ICompositionError)CreateComposablePartException(e);
 606
 607                 var result = (ICompositionError)SerializationTestServices.RoundTrip(exception);
 608
 609                 Assert.AreEqual(exception.Id, result.Id);
 610             }
 611         }
 612
 613         [TestMethod]
 614         public void Element_CanBeSerialized()
 615         {
 616             var expectations = Expectations.GetCompositionElementsWithNull();
 617
 618             foreach (var e in expectations)
 619             {
 620                 var exception = CreateComposablePartException(e);
 621
 622                 var result = SerializationTestServices.RoundTrip(exception);
 623
 624                 ElementAssert.AreEqual(exception.Element, result.Element);
 625             }
 626         }
 627
 628         [TestMethod]
 629         public void InnerException_CanBeSerialized()
 630         {
 631             var expectations = Expectations.GetInnerExceptions();
 632
 633             foreach (var e in expectations)
 634             {
 635                 var exception = CreateComposablePartException(e);
 636
 637                 var result = SerializationTestServices.RoundTrip(exception);
 638
 639                 ExtendedAssert.IsInstanceOfSameType(exception.InnerException, result.InnerException);
 640             }
 641         }
 642
 643         [TestMethod]
 644         public void Message_CanBeSerialized()
 645         {
 646             var expectations = Expectations.GetExceptionMessages();
 647
 648             foreach (var e in expectations)
 649             {
 650                 var exception = CreateComposablePartException(e);
 651
 652                 var result = SerializationTestServices.RoundTrip(exception);
 653
 654                 Assert.AreEqual(exception.Message, result.Message);
 655             }
 656         }
 657
 658 #endif
 659
 660         private static ComposablePartException CreateComposablePartException()
 661         {
 662             return CreateComposablePartException(CompositionErrorId.Unknown, (string)null, (ICompositionElement)null, (Exception)null);
 663         }
 664
 665         private static ComposablePartException CreateComposablePartException(string message)
 666         {
 667             return CreateComposablePartException(CompositionErrorId.Unknown, message, (ICompositionElement)null, (Exception)null);
 668         }
 669
 670         private static ComposablePartException CreateComposablePartException(CompositionErrorId id)
 671         {
 672             return CreateComposablePartException(CompositionErrorId.Unknown, (string)null, (ICompositionElement)null, (Exception)null);
 673         }
 674
 675         private static ComposablePartException CreateComposablePartException(ICompositionElement element)
 676         {
 677             return CreateComposablePartException(CompositionErrorId.Unknown, (string)null, element, (Exception)null);
 678         }
 679
 680         private static ComposablePartException CreateComposablePartException(Exception innerException)
 681         {
 682             return CreateComposablePartException(CompositionErrorId.Unknown, (string)null, (ICompositionElement)null, innerException);
 683         }
 684
 685         private static ComposablePartException CreateComposablePartException(CompositionErrorId id, string message, ICompositionElement element, Exception innerException)
 686         {
 687             return new ComposablePartException(id, message, element, innerException);
 688         }
 689     }
 690 }