mcs/class/System.Drawing/Test/System.Drawing/TestSystemBrushes.cs

   1 // Tests for System.Drawing.SystemBrushes.cs
   2 //
   3 // Author: Ravindra (rkumar@novell.com)
   4 //
   5
   6 //
   7 // Copyright (C) 2004 Novell, Inc (http://www.novell.com)
   8 //
   9 // Permission is hereby granted, free of charge, to any person obtaining
  10 // a copy of this software and associated documentation files (the
  11 // "Software"), to deal in the Software without restriction, including
  12 // without limitation the rights to use, copy, modify, merge, publish,
  13 // distribute, sublicense, and/or sell copies of the Software, and to
  14 // permit persons to whom the Software is furnished to do so, subject to
  15 // the following conditions:
  16 //
  17 // The above copyright notice and this permission notice shall be
  18 // included in all copies or substantial portions of the Software.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27 //
  28
  29
  30 using NUnit.Framework;
  31 using System;
  32 using System.Drawing;
  33
  34 namespace MonoTests.System.Drawing
  35 {
  36         [TestFixture]
  37         public class SystemBrushesTest : Assertion
  38         {
  39                 [TearDown]
  40                 public void TearDown () {}
  41
  42                 [SetUp]
  43                 public void SetUp () {}
  44
  45                 [Test]
  46                 public void TestActiveBorder ()
  47                 {
  48                         SolidBrush brush;
  49                         brush = (SolidBrush) SystemBrushes.ActiveBorder;
  50                         Assert ("P1#1", brush.Color.IsSystemColor);
  51                         AssertEquals ("P1#2", SystemColors.ActiveBorder, brush.Color);
  52
  53                         try {
  54                                 brush.Color = Color.Red;
  55                                 Fail ("P1#3: must throw ArgumentException");
  56                         } catch (Exception e) {
  57                                 Assert ("P1#3", e is ArgumentException);
  58                         }
  59
  60                         try {
  61                                 brush.Color = SystemColors.ActiveBorder;
  62                                 Fail ("P1#4: must throw ArgumentException");
  63                         } catch (Exception e) {
  64                                 Assert ("P1#4", e is ArgumentException);
  65                         }
  66
  67                         try {
  68                                 brush.Dispose();
  69                                 Fail ("P1#5: must throw ArgumentException");
  70                         } catch (Exception e) {
  71                                 Assert ("P1#5", e is ArgumentException);
  72                         }
  73                 }
  74
  75                 [Test]
  76                 public void TestActiveCaption ()
  77                 {
  78                         SolidBrush brush;
  79                         brush = (SolidBrush) SystemBrushes.ActiveCaption;
  80                         Assert ("P2#1", brush.Color.IsSystemColor);
  81                         AssertEquals ("P2#2", SystemColors.ActiveCaption, brush.Color);
  82
  83                         try {
  84                                 brush.Color = Color.Red;
  85                                 Fail ("P2#3: must throw ArgumentException");
  86                         } catch (Exception e) {
  87                                 Assert ("P2#3", e is ArgumentException);
  88                         }
  89
  90                         try {
  91                                 brush.Color = SystemColors.ActiveCaption;
  92                                 Fail ("P2#4: must throw ArgumentException");
  93                         } catch (Exception e) {
  94                                 Assert ("P2#4", e is ArgumentException);
  95                         }
  96
  97                         try {
  98                                 brush.Dispose();
  99                                 Fail ("P2#5: must throw ArgumentException");
 100                         } catch (Exception e) {
 101                                 Assert ("P2#5", e is ArgumentException);
 102                         }
 103
 104                 }
 105
 106                 [Test]
 107                 public void TestActiveCaptionText ()
 108                 {
 109                         SolidBrush brush;
 110                         brush = (SolidBrush) SystemBrushes.ActiveCaptionText;
 111                         Assert ("P3#1", brush.Color.IsSystemColor);
 112                         AssertEquals ("P3#2", SystemColors.ActiveCaptionText, brush.Color);
 113
 114                         try {
 115                                 brush.Color = Color.Red;
 116                                 Fail ("P3#3: must throw ArgumentException");
 117                         } catch (Exception e) {
 118                                 Assert ("P3#3", e is ArgumentException);
 119                         }
 120
 121                         try {
 122                                 brush.Color = SystemColors.ActiveCaptionText;
 123                                 Fail ("P3#4: must throw ArgumentException");
 124                         } catch (Exception e) {
 125                                 Assert ("P3#4", e is ArgumentException);
 126                         }
 127
 128                         try {
 129                                 brush.Dispose();
 130                                 Fail ("P3#5: must throw ArgumentException");
 131                         } catch (Exception e) {
 132                                 Assert ("P3#5", e is ArgumentException);
 133                         }
 134                 }
 135
 136                 [Test]
 137                 public void TestAppWorkspace ()
 138                 {
 139                         SolidBrush brush;
 140                         brush = (SolidBrush) SystemBrushes.AppWorkspace;
 141                         Assert ("P4#1", brush.Color.IsSystemColor);
 142                         AssertEquals ("P4#2", SystemColors.AppWorkspace, brush.Color);
 143
 144                         try {
 145                                 brush.Color = Color.Red;
 146                                 Fail ("P4#3: must throw ArgumentException");
 147                         } catch (Exception e) {
 148                                 Assert ("P4#3", e is ArgumentException);
 149                         }
 150
 151                         try {
 152                                 brush.Color = SystemColors.AppWorkspace;
 153                                 Fail ("P4#4: must throw ArgumentException");
 154                         } catch (Exception e) {
 155                                 Assert ("P4#4", e is ArgumentException);
 156                         }
 157
 158                         try {
 159                                 brush.Dispose();
 160                                 Fail ("P4#5: must throw ArgumentException");
 161                         } catch (Exception e) {
 162                                 Assert ("P4#5", e is ArgumentException);
 163                         }
 164                 }
 165
 166                 [Test]
 167                 public void TestControl ()
 168                 {
 169                         SolidBrush brush;
 170                         brush = (SolidBrush) SystemBrushes.Control;
 171                         Assert ("P5#1", brush.Color.IsSystemColor);
 172                         AssertEquals ("P5#2", SystemColors.Control, brush.Color);
 173
 174                         try {
 175                                 brush.Color = Color.Red;
 176                                 Fail ("P5#3: must throw ArgumentException");
 177                         } catch (Exception e) {
 178                                 Assert ("P5#3", e is ArgumentException);
 179                         }
 180
 181                         try {
 182                                 brush.Color = SystemColors.Control;
 183                                 Fail ("P5#4: must throw ArgumentException");
 184                         } catch (Exception e) {
 185                                 Assert ("P5#4", e is ArgumentException);
 186                         }
 187
 188                         try {
 189                                 brush.Dispose();
 190                                 Fail ("P5#5: must throw ArgumentException");
 191                         } catch (Exception e) {
 192                                 Assert ("P5#5", e is ArgumentException);
 193                         }
 194
 195                 }
 196
 197                 [Test]
 198                 public void TestControlDark ()
 199                 {
 200                         SolidBrush brush;
 201                         brush = (SolidBrush) SystemBrushes.ControlDark;
 202                         Assert ("P6#1", brush.Color.IsSystemColor);
 203                         AssertEquals ("P6#2", SystemColors.ControlDark, brush.Color);
 204
 205                         try {
 206                                 brush.Color = Color.Red;
 207                                 Fail ("P6#3: must throw ArgumentException");
 208                         } catch (Exception e) {
 209                                 Assert ("P6#3", e is ArgumentException);
 210                         }
 211
 212                         try {
 213                                 brush.Color = SystemColors.ControlDark;
 214                                 Fail ("P6#4: must throw ArgumentException");
 215                         } catch (Exception e) {
 216                                 Assert ("P6#4", e is ArgumentException);
 217                         }
 218
 219                         try {
 220                                 brush.Dispose();
 221                                 Fail ("P6#5: must throw ArgumentException");
 222                         } catch (Exception e) {
 223                                 Assert ("P6#5", e is ArgumentException);
 224                         }
 225                 }
 226
 227                 [Test]
 228                 public void TestControlDarkDark ()
 229                 {
 230                         SolidBrush brush;
 231                         brush = (SolidBrush) SystemBrushes.ControlDarkDark;
 232                         Assert ("P7#1", brush.Color.IsSystemColor);
 233                         AssertEquals ("P7#2", SystemColors.ControlDarkDark, brush.Color);
 234
 235                         try {
 236                                 brush.Color = Color.Red;
 237                                 Fail ("P7#3: must throw ArgumentException");
 238                         } catch (Exception e) {
 239                                 Assert ("P7#3", e is ArgumentException);
 240                         }
 241
 242                         try {
 243                                 brush.Color = SystemColors.ControlDarkDark;
 244                                 Fail ("P7#4: must throw ArgumentException");
 245                         } catch (Exception e) {
 246                                 Assert ("P7#4", e is ArgumentException);
 247                         }
 248
 249                         try {
 250                                 brush.Dispose();
 251                                 Fail ("P7#5: must throw ArgumentException");
 252                         } catch (Exception e) {
 253                                 Assert ("P7#5", e is ArgumentException);
 254                         }
 255                 }
 256
 257                 [Test]
 258                 public void TestControlLight ()
 259                 {
 260                         SolidBrush brush;
 261                         brush = (SolidBrush) SystemBrushes.ControlLight;
 262                         Assert ("P8#1", brush.Color.IsSystemColor);
 263                         AssertEquals ("P8#2", SystemColors.ControlLight, brush.Color);
 264
 265                         try {
 266                                 brush.Color = Color.Red;
 267                                 Fail ("P8#3: must throw ArgumentException");
 268                         } catch (Exception e) {
 269                                 Assert ("P8#3", e is ArgumentException);
 270                         }
 271
 272                         try {
 273                                 brush.Color = SystemColors.ControlLight;
 274                                 Fail ("P8#4: must throw ArgumentException");
 275                         } catch (Exception e) {
 276                                 Assert ("P8#4", e is ArgumentException);
 277                         }
 278
 279                         try {
 280                                 brush.Dispose();
 281                                 Fail ("P8#5: must throw ArgumentException");
 282                         } catch (Exception e) {
 283                                 Assert ("P8#5", e is ArgumentException);
 284                         }
 285                 }
 286
 287                 [Test]
 288                 public void TestControlLightLight ()
 289                 {
 290                         SolidBrush brush;
 291                         brush = (SolidBrush) SystemBrushes.ControlLightLight;
 292                         Assert ("P9#1", brush.Color.IsSystemColor);
 293                         AssertEquals ("P9#2", SystemColors.ControlLightLight, brush.Color);
 294
 295                         try {
 296                                 brush.Color = Color.Red;
 297                                 Fail ("P9#3: must throw ArgumentException");
 298                         } catch (Exception e) {
 299                                 Assert ("P9#3", e is ArgumentException);
 300                         }
 301
 302                         try {
 303                                 brush.Color = SystemColors.ControlLightLight;
 304                                 Fail ("P9#4: must throw ArgumentException");
 305                         } catch (Exception e) {
 306                                 Assert ("P9#4", e is ArgumentException);
 307                         }
 308
 309                         try {
 310                                 brush.Dispose();
 311                                 Fail ("P9#5: must throw ArgumentException");
 312                         } catch (Exception e) {
 313                                 Assert ("P9#5", e is ArgumentException);
 314                         }
 315                 }
 316
 317                 [Test]
 318                 public void TestControlText ()
 319                 {
 320                         SolidBrush brush;
 321                         brush = (SolidBrush) SystemBrushes.ControlText;
 322                         Assert ("P10#1", brush.Color.IsSystemColor);
 323                         AssertEquals ("P10#2", SystemColors.ControlText, brush.Color);
 324
 325                         try {
 326                                 brush.Color = Color.Red;
 327                                 Fail ("P10#3: must throw ArgumentException");
 328                         } catch (Exception e) {
 329                                 Assert ("P10#3", e is ArgumentException);
 330                         }
 331
 332                         try {
 333                                 brush.Color = SystemColors.ControlText;
 334                                 Fail ("P10#4: must throw ArgumentException");
 335                         } catch (Exception e) {
 336                                 Assert ("P10#4", e is ArgumentException);
 337                         }
 338
 339                         try {
 340                                 brush.Dispose();
 341                                 Fail ("P10#5: must throw ArgumentException");
 342                         } catch (Exception e) {
 343                                 Assert ("P10#5", e is ArgumentException);
 344                         }
 345                 }
 346
 347
 348                 [Test]
 349                 public void TestDesktop ()
 350                 {
 351                         SolidBrush brush;
 352                         brush = (SolidBrush) SystemBrushes.Desktop;
 353                         Assert ("P11#1", brush.Color.IsSystemColor);
 354                         AssertEquals ("P11#2", SystemColors.Desktop, brush.Color);
 355
 356                         try {
 357                                 brush.Color = Color.Red;
 358                                 Fail ("P11#3: must throw ArgumentException");
 359                         } catch (Exception e) {
 360                                 Assert ("P11#3", e is ArgumentException);
 361                         }
 362
 363                         try {
 364                                 brush.Color = SystemColors.Desktop;
 365                                 Fail ("P11#4: must throw ArgumentException");
 366                         } catch (Exception e) {
 367                                 Assert ("P11#4", e is ArgumentException);
 368                         }
 369
 370                         try {
 371                                 brush.Dispose();
 372                                 Fail ("P11#5: must throw ArgumentException");
 373                         } catch (Exception e) {
 374                                 Assert ("P11#5", e is ArgumentException);
 375                         }
 376                 }
 377
 378                 [Test]
 379                 public void TestHighlight ()
 380                 {
 381                         SolidBrush brush;
 382                         brush = (SolidBrush) SystemBrushes.Highlight;
 383                         Assert ("P12#1", brush.Color.IsSystemColor);
 384                         AssertEquals ("P12#2", SystemColors.Highlight, brush.Color);
 385
 386                         try {
 387                                 brush.Color = Color.Red;
 388                                 Fail ("P12#3: must throw ArgumentException");
 389                         } catch (Exception e) {
 390                                 Assert ("P12#3", e is ArgumentException);
 391                         }
 392
 393                         try {
 394                                 brush.Color = SystemColors.Highlight;
 395                                 Fail ("P12#4: must throw ArgumentException");
 396                         } catch (Exception e) {
 397                                 Assert ("P12#4", e is ArgumentException);
 398                         }
 399
 400                         try {
 401                                 brush.Dispose();
 402                                 Fail ("P12#5: must throw ArgumentException");
 403                         } catch (Exception e) {
 404                                 Assert ("P12#5", e is ArgumentException);
 405                         }
 406                 }
 407
 408                 [Test]
 409                 public void TestHighlightText ()
 410                 {
 411                         SolidBrush brush;
 412                         brush = (SolidBrush) SystemBrushes.HighlightText;
 413                         Assert ("P13#1", brush.Color.IsSystemColor);
 414                         AssertEquals ("P13#2", SystemColors.HighlightText, brush.Color);
 415
 416                         try {
 417                                 brush.Color = Color.Red;
 418                                 Fail ("P13#3: must throw ArgumentException");
 419                         } catch (Exception e) {
 420                                 Assert ("P13#3", e is ArgumentException);
 421                         }
 422
 423                         try {
 424                                 brush.Color = SystemColors.HighlightText;
 425                                 Fail ("P13#4: must throw ArgumentException");
 426                         } catch (Exception e) {
 427                                 Assert ("P13#4", e is ArgumentException);
 428                         }
 429
 430                         try {
 431                                 brush.Dispose();
 432                                 Fail ("P13#5: must throw ArgumentException");
 433                         } catch (Exception e) {
 434                                 Assert ("P13#5", e is ArgumentException);
 435                         }
 436                 }
 437
 438                 [Test]
 439                 public void TestHotTrack ()
 440                 {
 441                         SolidBrush brush;
 442                         brush = (SolidBrush) SystemBrushes.HotTrack;
 443                         Assert ("P14#1", brush.Color.IsSystemColor);
 444                         AssertEquals ("P14#2", SystemColors.HotTrack, brush.Color);
 445
 446                         try {
 447                                 brush.Color = Color.Red;
 448                                 Fail ("P14#3: must throw ArgumentException");
 449                         } catch (Exception e) {
 450                                 Assert ("P14#3", e is ArgumentException);
 451                         }
 452
 453                         try {
 454                                 brush.Color = SystemColors.HotTrack;
 455                                 Fail ("P14#4: must throw ArgumentException");
 456                         } catch (Exception e) {
 457                                 Assert ("P14#4", e is ArgumentException);
 458                         }
 459
 460                         try {
 461                                 brush.Dispose();
 462                                 Fail ("P14#5: must throw ArgumentException");
 463                         } catch (Exception e) {
 464                                 Assert ("P14#5", e is ArgumentException);
 465                         }
 466                 }
 467
 468                 [Test]
 469                 public void TestInactiveBorder ()
 470                 {
 471                         SolidBrush brush;
 472                         brush = (SolidBrush) SystemBrushes.InactiveBorder;
 473                         Assert ("P15#1", brush.Color.IsSystemColor);
 474                         AssertEquals ("P15#2", SystemColors.InactiveBorder, brush.Color);
 475
 476                         try {
 477                                 brush.Color = Color.Red;
 478                                 Fail ("P15#3: must throw ArgumentException");
 479                         } catch (Exception e) {
 480                                 Assert ("P15#3", e is ArgumentException);
 481                         }
 482
 483                         try {
 484                                 brush.Color = SystemColors.InactiveBorder;
 485                                 Fail ("P15#4: must throw ArgumentException");
 486                         } catch (Exception e) {
 487                                 Assert ("P15#4", e is ArgumentException);
 488                         }
 489
 490                         try {
 491                                 brush.Dispose();
 492                                 Fail ("P15#5: must throw ArgumentException");
 493                         } catch (Exception e) {
 494                                 Assert ("P15#5", e is ArgumentException);
 495                         }
 496                 }
 497
 498                 [Test]
 499                 public void TestInactiveCaption ()
 500                 {
 501                         SolidBrush brush;
 502                         brush = (SolidBrush) SystemBrushes.InactiveCaption;
 503                         Assert ("P16#1", brush.Color.IsSystemColor);
 504                         AssertEquals ("P16#2", SystemColors.InactiveCaption, brush.Color);
 505
 506                         try {
 507                                 brush.Color = Color.Red;
 508                                 Fail ("P16#3: must throw ArgumentException");
 509                         } catch (Exception e) {
 510                                 Assert ("P16#3", e is ArgumentException);
 511                         }
 512
 513                         try {
 514                                 brush.Color = SystemColors.InactiveCaption;
 515                                 Fail ("P16#4: must throw ArgumentException");
 516                         } catch (Exception e) {
 517                                 Assert ("P16#4", e is ArgumentException);
 518                         }
 519
 520                         try {
 521                                 brush.Dispose();
 522                                 Fail ("P16#5: must throw ArgumentException");
 523                         } catch (Exception e) {
 524                                 Assert ("P16#5", e is ArgumentException);
 525                         }
 526                 }
 527
 528                 [Test]
 529                 public void TestInfo ()
 530                 {
 531                         SolidBrush brush;
 532                         brush = (SolidBrush) SystemBrushes.Info;
 533                         Assert ("P17#1", brush.Color.IsSystemColor);
 534                         AssertEquals ("P17#2", SystemColors.Info, brush.Color);
 535
 536                         try {
 537                                 brush.Color = Color.Red;
 538                                 Fail ("P17#3: must throw ArgumentException");
 539                         } catch (Exception e) {
 540                                 Assert ("P17#3", e is ArgumentException);
 541                         }
 542
 543                         try {
 544                                 brush.Color = SystemColors.Info;
 545                                 Fail ("P17#4: must throw ArgumentException");
 546                         } catch (Exception e) {
 547                                 Assert ("P17#4", e is ArgumentException);
 548                         }
 549
 550                         try {
 551                                 brush.Dispose();
 552                                 Fail ("P17#5: must throw ArgumentException");
 553                         } catch (Exception e) {
 554                                 Assert ("P17#5", e is ArgumentException);
 555                         }
 556                 }
 557
 558                 [Test]
 559                 public void TestMenu ()
 560                 {
 561                         SolidBrush brush;
 562                         brush = (SolidBrush) SystemBrushes.Menu;
 563                         Assert ("P18#1", brush.Color.IsSystemColor);
 564                         AssertEquals ("P18#2", SystemColors.Menu, brush.Color);
 565
 566                         try {
 567                                 brush.Color = Color.Red;
 568                                 Fail ("P18#3: must throw ArgumentException");
 569                         } catch (Exception e) {
 570                                 Assert ("P18#3", e is ArgumentException);
 571                         }
 572
 573                         try {
 574                                 brush.Color = SystemColors.Menu;
 575                                 Fail ("P18#4: must throw ArgumentException");
 576                         } catch (Exception e) {
 577                                 Assert ("P18#4", e is ArgumentException);
 578                         }
 579
 580                         try {
 581                                 brush.Dispose();
 582                                 Fail ("P18#5: must throw ArgumentException");
 583                         } catch (Exception e) {
 584                                 Assert ("P18#5", e is ArgumentException);
 585                         }
 586                 }
 587
 588                 [Test]
 589                 public void TestScrollBar ()
 590                 {
 591                         SolidBrush brush;
 592                         brush = (SolidBrush) SystemBrushes.ScrollBar;
 593                         Assert ("P19#1", brush.Color.IsSystemColor);
 594                         AssertEquals ("P19#2", SystemColors.ScrollBar, brush.Color);
 595
 596                         try {
 597                                 brush.Color = Color.Red;
 598                                 Fail ("P19#3: must throw ArgumentException");
 599                         } catch (Exception e) {
 600                                 Assert ("P19#3", e is ArgumentException);
 601                         }
 602
 603                         try {
 604                                 brush.Color = SystemColors.ScrollBar;
 605                                 Fail ("P19#4: must throw ArgumentException");
 606                         } catch (Exception e) {
 607                                 Assert ("P19#4", e is ArgumentException);
 608                         }
 609
 610                         try {
 611                                 brush.Dispose();
 612                                 Fail ("P19#5: must throw ArgumentException");
 613                         } catch (Exception e) {
 614                                 Assert ("P19#5", e is ArgumentException);
 615                         }
 616                 }
 617
 618                 [Test]
 619                 public void TestWindow ()
 620                 {
 621                         SolidBrush brush;
 622                         brush = (SolidBrush) SystemBrushes.Window;
 623                         Assert ("P20#1", brush.Color.IsSystemColor);
 624                         AssertEquals ("P20#2", SystemColors.Window, brush.Color);
 625
 626                         try {
 627                                 brush.Color = Color.Red;
 628                                 Fail ("P20#3: must throw ArgumentException");
 629                         } catch (Exception e) {
 630                                 Assert ("P20#3", e is ArgumentException);
 631                         }
 632
 633                         try {
 634                                 brush.Color = SystemColors.Window;
 635                                 Fail ("P20#4: must throw ArgumentException");
 636                         } catch (Exception e) {
 637                                 Assert ("P20#4", e is ArgumentException);
 638                         }
 639
 640                         try {
 641                                 brush.Dispose();
 642                                 Fail ("P20#5: must throw ArgumentException");
 643                         } catch (Exception e) {
 644                                 Assert ("P20#5", e is ArgumentException);
 645                         }
 646                 }
 647
 648                 [Test]
 649                 public void TestWindowText ()
 650                 {
 651                         SolidBrush brush;
 652                         brush = (SolidBrush) SystemBrushes.WindowText;
 653                         Assert ("P21#1", brush.Color.IsSystemColor);
 654                         AssertEquals ("P21#2", SystemColors.WindowText, brush.Color);
 655
 656                         try {
 657                                 brush.Color = Color.Red;
 658                                 Fail ("P21#3: must throw ArgumentException");
 659                         } catch (Exception e) {
 660                                 Assert ("P21#3", e is ArgumentException);
 661                         }
 662
 663                         try {
 664                                 brush.Color = SystemColors.WindowText;
 665                                 Fail ("P21#4: must throw ArgumentException");
 666                         } catch (Exception e) {
 667                                 Assert ("P21#4", e is ArgumentException);
 668                         }
 669
 670                         try {
 671                                 brush.Dispose();
 672                                 Fail ("P21#5: must throw ArgumentException");
 673                         } catch (Exception e) {
 674                                 Assert ("P21#5", e is ArgumentException);
 675                         }
 676                 }
 677
 678                 [Test]
 679                 public void TestFromSystemColor ()
 680                 {
 681                         SolidBrush brush;
 682
 683                         brush = (SolidBrush) SystemBrushes.FromSystemColor (SystemColors.Menu);
 684                         AssertEquals ("M1#1", SystemColors.Menu, brush.Color);
 685
 686                         try {
 687                                 brush.Color = Color.Red;
 688                                 Fail ("M1#2: must throw ArgumentException");
 689                         } catch (Exception e) {
 690                                 Assert ("M1#2", e is ArgumentException);
 691                         }
 692
 693                         try {
 694                                 brush.Color = SystemColors.Menu;
 695                                 Fail ("M1#3: must throw ArgumentException");
 696                         } catch (Exception e) {
 697                                 Assert ("M1#3", e is ArgumentException);
 698                         }
 699
 700                         try {
 701                                 brush.Dispose();
 702                                 Fail ("M1#4: must throw ArgumentException");
 703                         } catch (Exception e) {
 704                                 Assert ("M1#4", e is ArgumentException);
 705                         }
 706
 707
 708                         try {
 709                                 brush = (SolidBrush) SystemBrushes.FromSystemColor (Color.Red);
 710                                 Fail ("M2#1: must throw ArgumentException");
 711                         } catch (Exception e) {
 712                                 Assert ("M2#1", e is ArgumentException);
 713                         }
 714                 }
 715         }
 716 }