mcs/class/System/Test/System.ComponentModel/EventDescriptorCollectionTests.cs

   1 //
   2 // System.ComponentModel.EventDescriptorCollection test cases
   3 //
   4 // Authors:
   5 //      Gert Driesen (drieseng@users.sourceforge.net)
   6 //
   7 // (c) 2008 Gert Driesen
   8 //
   9
  10 using System;
  11 using System.Collections;
  12 using System.ComponentModel;
  13 using System.Globalization;
  14 using System.Threading;
  15 using CategoryAttribute = System.ComponentModel.CategoryAttribute;
  16
  17 using NUnit.Framework;
  18
  19 namespace MonoTests.System.ComponentModel
  20 {
  21         [TestFixture]
  22         public class EventDescriptorCollectionTests
  23         {
  24                 private CultureInfo originalCulture;
  25
  26                 [SetUp]
  27                 public void SetUp ()
  28                 {
  29                         originalCulture = Thread.CurrentThread.CurrentCulture;
  30                 }
  31
  32                 [TearDown]
  33                 public void TearDown ()
  34                 {
  35                         Thread.CurrentThread.CurrentCulture = originalCulture;
  36                 }
  37
  38                 [Test]
  39                 public void Empty ()
  40                 {
  41                         EventDescriptorCollection descriptors = EventDescriptorCollection.Empty;
  42                         Assert.AreEqual (0, descriptors.Count);
  43                         AssertReadOnly (descriptors, "Empty");
  44                 }
  45
  46                 [Test]
  47                 public void Find ()
  48                 {
  49                         EventDescriptor descA = new MockEventDescriptor ("hehe_\u0061\u030a", null);
  50                         EventDescriptor descB = new MockEventDescriptor ("heh_\u00e5", null);
  51                         EventDescriptor descC = new MockEventDescriptor ("Foo", null);
  52                         EventDescriptor descD = new MockEventDescriptor ("FOo", null);
  53                         EventDescriptor descE = new MockEventDescriptor ("Aim", null);
  54                         EventDescriptor descF = new MockEventDescriptor ("Bar", null);
  55
  56                         EventDescriptorCollection col = new EventDescriptorCollection (
  57                                 new EventDescriptor [] { descA, descB, descC, descD, descE, descF });
  58
  59                         Assert.IsNull (col.Find ("heh_\u0061\u030a", false), "#1");
  60                         Assert.IsNull (col.Find ("hehe_\u00e5", false), "#2");
  61                         Assert.AreSame (descA, col.Find ("hehe_\u0061\u030a", false), "#3");
  62                         Assert.AreSame (descB, col.Find ("heh_\u00e5", false), "#4");
  63                         Assert.IsNull (col.Find ("foo", false), "#5");
  64                         Assert.AreSame (descC, col.Find ("foo", true), "#6");
  65                         Assert.AreSame (descD, col.Find ("FOo", false), "#7");
  66                         Assert.AreSame (descC, col.Find ("FOo", true), "#8");
  67                         Assert.IsNull (col.Find ("fOo", false), "#9");
  68                         Assert.AreSame (descC, col.Find ("fOo", true), "#10");
  69                         Assert.IsNull (col.Find ("AIm", false), "#11");
  70                         Assert.AreSame (descE, col.Find ("AIm", true), "#12");
  71                         Assert.IsNull (col.Find ("AiM", false), "#13");
  72                         Assert.AreSame (descE, col.Find ("AiM", true), "#14");
  73                         Assert.AreSame (descE, col.Find ("Aim", false), "#15");
  74                         Assert.AreSame (descE, col.Find ("Aim", true), "#16");
  75                 }
  76
  77                 [Test]
  78                 public void Find_Key_Null ()
  79                 {
  80                         EventDescriptorCollection descriptors = new EventDescriptorCollection (
  81                                 new EventDescriptor[] { new MockEventDescriptor ("A", "X"),
  82                                         new MockEventDescriptor ("b", "Y")});
  83
  84                         Assert.IsNull (descriptors.Find (null, false), "#1");
  85                         Assert.IsNull (descriptors.Find (null, true), "#2");
  86                 }
  87
  88                 [Test]
  89                 public void IList ()
  90                 {
  91                         IList list = ((IList) new EventDescriptorCollection (null));
  92
  93                         Assert.AreEqual (0, list.Count, "#1");
  94                         Assert.IsFalse (list.IsFixedSize, "#2");
  95                         Assert.IsFalse (list.IsReadOnly, "#3");
  96                         Assert.IsFalse (list.IsSynchronized, "#4");
  97                         Assert.IsNull (list.SyncRoot, "#5");
  98                 }
  99
 100                 [Test]
 101                 public void IList_Add_Null ()
 102                 {
 103                         IList list = ((IList) new EventDescriptorCollection (null));
 104                         Assert.AreEqual (0, list.Count, "#1");
 105                         list.Add (null);
 106                         Assert.AreEqual (1, list.Count, "#2");
 107                 }
 108
 109                 [Test]
 110                 public void IList_Add_NoEventDescriptor ()
 111                 {
 112                         IList list = ((IList) new EventDescriptorCollection (null));
 113                         try {
 114                                 list.Add (5);
 115                                 Assert.Fail ("#1");
 116                         } catch (InvalidCastException) {
 117                         }
 118                 }
 119
 120                 [Test] // this [String]
 121                 public void Indexer2 ()
 122                 {
 123                         EventDescriptor descA = new MockEventDescriptor ("hehe_\u0061\u030a", null);
 124                         EventDescriptor descB = new MockEventDescriptor ("heh_\u00e5", null);
 125                         EventDescriptor descC = new MockEventDescriptor ("Foo", null);
 126                         EventDescriptor descD = new MockEventDescriptor ("FOo", null);
 127                         EventDescriptor descE = new MockEventDescriptor ("Aim", null);
 128                         EventDescriptor descF = new MockEventDescriptor ("Bar", null);
 129
 130                         EventDescriptorCollection col = new EventDescriptorCollection (
 131                                 new EventDescriptor [] { descA, descB, descC, descD, descE, descF });
 132
 133                         Assert.IsNull (col ["heh_\u0061\u030a"], "#1");
 134                         Assert.IsNull (col ["hehe_\u00e5"], "#2");
 135                         Assert.AreSame (descA, col ["hehe_\u0061\u030a"], "#3");
 136                         Assert.AreSame (descB, col ["heh_\u00e5"], "#4");
 137                         Assert.IsNull (col ["foo"], "#5");
 138                         Assert.AreSame (descD, col ["FOo"], "#6");
 139                         Assert.IsNull (col ["fOo"], "#7");
 140                         Assert.IsNull (col ["AIm"], "#8");
 141                         Assert.IsNull (col ["AiM"], "#9");
 142                         Assert.AreSame (descE, col ["Aim"], "#10");
 143                         Assert.IsNull (col [(string) null], "#11");
 144                 }
 145
 146                 public void ReadOnly ()
 147                 {
 148                         EventDescriptorCollection descriptors = new EventDescriptorCollection (
 149                                 (EventDescriptor []) null, true);
 150                         AssertReadOnly (descriptors, "ReadOnly");
 151                 }
 152
 153                 [Test] // Sort ()
 154                 public void Sort1 ()
 155                 {
 156                         EventDescriptorCollection descriptors;
 157                         EventDescriptorCollection sorted;
 158
 159                         EventDescriptor descA = new MockEventDescriptor ("Foo", "B");
 160                         EventDescriptor descB = new MockEventDescriptor ("Aim", "C");
 161                         EventDescriptor descC = new MockEventDescriptor ("Bim", "A");
 162                         EventDescriptor descD = new MockEventDescriptor ("AIm", "E");
 163                         EventDescriptor descE = new MockEventDescriptor ("Boo", "D");
 164                         EventDescriptor descF = new MockEventDescriptor ("FOo", "F");
 165
 166                         EventDescriptor [] props = new EventDescriptor [] {
 167                                 descA, descB, descC, descD, descE, descF };
 168                         descriptors = new EventDescriptorCollection (props);
 169
 170                         Assert.AreSame (descA, descriptors [0], "#A1");
 171                         Assert.AreSame (descB, descriptors [1], "#A2");
 172                         Assert.AreSame (descC, descriptors [2], "#A3");
 173                         Assert.AreSame (descD, descriptors [3], "#A4");
 174                         Assert.AreSame (descE, descriptors [4], "#A5");
 175                         Assert.AreSame (descF, descriptors [5], "#A6");
 176
 177                         sorted = descriptors.Sort ();
 178
 179                         Assert.AreSame (descA, descriptors [0], "#B1");
 180                         Assert.AreSame (descB, descriptors [1], "#B2");
 181                         Assert.AreSame (descC, descriptors [2], "#B3");
 182                         Assert.AreSame (descD, descriptors [3], "#B4");
 183                         Assert.AreSame (descE, descriptors [4], "#B5");
 184                         Assert.AreSame (descF, descriptors [5], "#B6");
 185
 186                         Assert.AreSame (descB, sorted [0], "#C1");
 187                         Assert.AreSame (descD, sorted [1], "#C2");
 188                         Assert.AreSame (descC, sorted [2], "#C3");
 189                         Assert.AreSame (descE, sorted [3], "#C4");
 190                         Assert.AreSame (descA, sorted [4], "#C5");
 191                         Assert.AreSame (descF, sorted [5], "#C6");
 192                 }
 193
 194                 [Test] // Sort (String [])
 195                 public void Sort2 ()
 196                 {
 197                         EventDescriptorCollection descriptors;
 198                         EventDescriptorCollection sorted;
 199
 200                         EventDescriptor descA = new MockEventDescriptor ("Foo", "B");
 201                         EventDescriptor descB = new MockEventDescriptor ("Aim", "C");
 202                         EventDescriptor descC = new MockEventDescriptor ("Bim", "A");
 203                         EventDescriptor descD = new MockEventDescriptor ("AIm", "E");
 204                         EventDescriptor descE = new MockEventDescriptor ("Boo", "D");
 205                         EventDescriptor descF = new MockEventDescriptor ("FOo", "F");
 206
 207                         EventDescriptor [] props = new EventDescriptor [] {
 208                                 descA, descB, descC, descD, descE, descF };
 209                         descriptors = new EventDescriptorCollection (props);
 210
 211                         Assert.AreSame (descA, descriptors [0], "#A1");
 212                         Assert.AreSame (descB, descriptors [1], "#A2");
 213                         Assert.AreSame (descC, descriptors [2], "#A3");
 214                         Assert.AreSame (descD, descriptors [3], "#A4");
 215                         Assert.AreSame (descE, descriptors [4], "#A5");
 216                         Assert.AreSame (descF, descriptors [5], "#A5");
 217
 218                         sorted = descriptors.Sort (new string [] { "B", "Foo", null, "A", "Boo" });
 219
 220                         Assert.AreSame (descA, descriptors [0], "#B1");
 221                         Assert.AreSame (descB, descriptors [1], "#B2");
 222                         Assert.AreSame (descC, descriptors [2], "#B3");
 223                         Assert.AreSame (descD, descriptors [3], "#B4");
 224                         Assert.AreSame (descE, descriptors [4], "#B5");
 225                         Assert.AreSame (descF, descriptors [5], "#B6");
 226
 227                         Assert.AreSame (descA, sorted [0], "#C1");
 228                         Assert.AreSame (descE, sorted [1], "#C2");
 229                         Assert.AreSame (descB, sorted [2], "#C3");
 230                         Assert.AreSame (descD, sorted [3], "#C4");
 231                         Assert.AreSame (descC, sorted [4], "#C5");
 232                         Assert.AreSame (descF, sorted [5], "#C6");
 233
 234                         sorted = descriptors.Sort ((string []) null);
 235
 236                         Assert.AreSame (descA, descriptors [0], "#D1");
 237                         Assert.AreSame (descB, descriptors [1], "#D2");
 238                         Assert.AreSame (descC, descriptors [2], "#D3");
 239                         Assert.AreSame (descD, descriptors [3], "#D4");
 240                         Assert.AreSame (descE, descriptors [4], "#D5");
 241                         Assert.AreSame (descF, descriptors [5], "#D6");
 242
 243                         Assert.AreSame (descB, sorted [0], "#E1");
 244                         Assert.AreSame (descD, sorted [1], "#E2");
 245                         Assert.AreSame (descC, sorted [2], "#E3");
 246                         Assert.AreSame (descE, sorted [3], "#E4");
 247                         Assert.AreSame (descA, sorted [4], "#E5");
 248                         Assert.AreSame (descF, sorted [5], "#E6");
 249                 }
 250
 251                 [Test] // Sort (IComparer)
 252                 public void Sort3 ()
 253                 {
 254                         EventDescriptorCollection descriptors;
 255                         EventDescriptorCollection sorted;
 256
 257                         EventDescriptor descA = new MockEventDescriptor ("Foo", "B");
 258                         EventDescriptor descB = new MockEventDescriptor ("Aim", "C");
 259                         EventDescriptor descC = new MockEventDescriptor ("Bim", "A");
 260                         EventDescriptor descD = new MockEventDescriptor ("AIm", "E");
 261                         EventDescriptor descE = new MockEventDescriptor ("Boo", "D");
 262                         EventDescriptor descF = new MockEventDescriptor ("FOo", "F");
 263
 264                         EventDescriptor [] props = new EventDescriptor [] {
 265                                 descA, descB, descC, descD, descE, descF };
 266                         descriptors = new EventDescriptorCollection (props);
 267
 268                         Assert.AreSame (descA, descriptors [0], "#A1");
 269                         Assert.AreSame (descB, descriptors [1], "#A2");
 270                         Assert.AreSame (descC, descriptors [2], "#A3");
 271                         Assert.AreSame (descD, descriptors [3], "#A4");
 272                         Assert.AreSame (descE, descriptors [4], "#A5");
 273                         Assert.AreSame (descF, descriptors [5], "#A6");
 274
 275                         sorted = descriptors.Sort (new CategoryComparer ());
 276
 277                         Assert.AreSame (descA, descriptors [0], "#B1");
 278                         Assert.AreSame (descB, descriptors [1], "#B2");
 279                         Assert.AreSame (descC, descriptors [2], "#B3");
 280                         Assert.AreSame (descD, descriptors [3], "#B4");
 281                         Assert.AreSame (descE, descriptors [4], "#B5");
 282                         Assert.AreSame (descF, descriptors [5], "#B6");
 283
 284                         Assert.AreSame (descC, sorted [0], "#C1");
 285                         Assert.AreSame (descA, sorted [1], "#C2");
 286                         Assert.AreSame (descB, sorted [2], "#C3");
 287                         Assert.AreSame (descE, sorted [3], "#C4");
 288                         Assert.AreSame (descD, sorted [4], "#C5");
 289                         Assert.AreSame (descF, sorted [5], "#C6");
 290
 291                         sorted = descriptors.Sort ((Comparer) null);
 292
 293                         Assert.AreSame (descA, descriptors [0], "#D1");
 294                         Assert.AreSame (descB, descriptors [1], "#D2");
 295                         Assert.AreSame (descC, descriptors [2], "#D3");
 296                         Assert.AreSame (descD, descriptors [3], "#D4");
 297                         Assert.AreSame (descE, descriptors [4], "#D5");
 298                         Assert.AreSame (descF, descriptors [5], "#D6");
 299
 300                         Assert.AreSame (descB, sorted [0], "#E1");
 301                         Assert.AreSame (descD, sorted [1], "#E2");
 302                         Assert.AreSame (descC, sorted [2], "#E3");
 303                         Assert.AreSame (descE, sorted [3], "#E4");
 304                         Assert.AreSame (descA, sorted [4], "#E5");
 305                         Assert.AreSame (descF, sorted [5], "#E6");
 306                 }
 307
 308                 [Test] // Sort (String [], IComparer)
 309                 public void Sort4 ()
 310                 {
 311                         EventDescriptorCollection descriptors;
 312                         EventDescriptorCollection sorted;
 313
 314                         EventDescriptor descA = new MockEventDescriptor ("Foo", "B");
 315                         EventDescriptor descB = new MockEventDescriptor ("Aim", "C");
 316                         EventDescriptor descC = new MockEventDescriptor ("Bim", "A");
 317                         EventDescriptor descD = new MockEventDescriptor ("AIm", "E");
 318                         EventDescriptor descE = new MockEventDescriptor ("Boo", "D");
 319                         EventDescriptor descF = new MockEventDescriptor ("FOo", "F");
 320
 321                         EventDescriptor [] props = new EventDescriptor [] {
 322                                 descA, descB, descC, descD, descE, descF };
 323                         descriptors = new EventDescriptorCollection (props);
 324
 325                         Assert.AreSame (descA, descriptors [0], "#A1");
 326                         Assert.AreSame (descB, descriptors [1], "#A2");
 327                         Assert.AreSame (descC, descriptors [2], "#A3");
 328                         Assert.AreSame (descD, descriptors [3], "#A4");
 329                         Assert.AreSame (descE, descriptors [4], "#A5");
 330                         Assert.AreSame (descF, descriptors [5], "#A6");
 331
 332                         sorted = descriptors.Sort (new string [] { "B", "Foo", null, "A", "Boo" },
 333                                 new CategoryComparer ());
 334
 335                         Assert.AreSame (descA, descriptors [0], "#B1");
 336                         Assert.AreSame (descB, descriptors [1], "#B2");
 337                         Assert.AreSame (descC, descriptors [2], "#B3");
 338                         Assert.AreSame (descD, descriptors [3], "#B4");
 339                         Assert.AreSame (descE, descriptors [4], "#B5");
 340                         Assert.AreSame (descF, descriptors [5], "#B6");
 341
 342                         Assert.AreSame (descA, sorted [0], "#C1");
 343                         Assert.AreSame (descE, sorted [1], "#C2");
 344                         Assert.AreSame (descC, sorted [2], "#C3");
 345                         Assert.AreSame (descB, sorted [3], "#C4");
 346                         Assert.AreSame (descD, sorted [4], "#C5");
 347                         Assert.AreSame (descF, sorted [5], "#C6");
 348
 349                         sorted = descriptors.Sort ((string []) null, new CategoryComparer ());
 350
 351                         Assert.AreSame (descA, descriptors [0], "#D1");
 352                         Assert.AreSame (descB, descriptors [1], "#D2");
 353                         Assert.AreSame (descC, descriptors [2], "#D3");
 354                         Assert.AreSame (descD, descriptors [3], "#D4");
 355                         Assert.AreSame (descE, descriptors [4], "#D5");
 356                         Assert.AreSame (descF, descriptors [5], "#D6");
 357
 358                         Assert.AreSame (descC, sorted [0], "#E1");
 359                         Assert.AreSame (descA, sorted [1], "#E2");
 360                         Assert.AreSame (descB, sorted [2], "#E3");
 361                         Assert.AreSame (descE, sorted [3], "#E4");
 362                         Assert.AreSame (descD, sorted [4], "#E5");
 363                         Assert.AreSame (descF, sorted [5], "#E6");
 364
 365                         sorted = descriptors.Sort (new string [] { "B", "Foo", null, "A", "Boo" },
 366                                 (Comparer) null);
 367
 368                         Assert.AreSame (descA, descriptors [0], "#F1");
 369                         Assert.AreSame (descB, descriptors [1], "#F2");
 370                         Assert.AreSame (descC, descriptors [2], "#F3");
 371                         Assert.AreSame (descD, descriptors [3], "#F4");
 372                         Assert.AreSame (descE, descriptors [4], "#F5");
 373                         Assert.AreSame (descF, descriptors [5], "#F6");
 374
 375                         Assert.AreSame (descA, sorted [0], "#G1");
 376                         Assert.AreSame (descE, sorted [1], "#G2");
 377                         Assert.AreSame (descB, sorted [2], "#G3");
 378                         Assert.AreSame (descD, sorted [3], "#G4");
 379                         Assert.AreSame (descC, sorted [4], "#G5");
 380                         Assert.AreSame (descF, sorted [5], "#G6");
 381
 382                         sorted = descriptors.Sort ((string []) null, (Comparer) null);
 383
 384                         Assert.AreSame (descA, descriptors [0], "#H1");
 385                         Assert.AreSame (descB, descriptors [1], "#H2");
 386                         Assert.AreSame (descC, descriptors [2], "#H3");
 387                         Assert.AreSame (descD, descriptors [3], "#H4");
 388                         Assert.AreSame (descE, descriptors [4], "#H5");
 389                         Assert.AreSame (descF, descriptors [5], "#H6");
 390
 391                         Assert.AreSame (descB, sorted [0], "#I1");
 392                         Assert.AreSame (descD, sorted [1], "#I2");
 393                         Assert.AreSame (descC, sorted [2], "#I3");
 394                         Assert.AreSame (descE, sorted [3], "#I4");
 395                         Assert.AreSame (descA, sorted [4], "#I5");
 396                         Assert.AreSame (descF, sorted [5], "#I6");
 397                 }
 398
 399                 private void AssertReadOnly (EventDescriptorCollection descriptors, string testCase)
 400                 {
 401                         MockEventDescriptor desc = new MockEventDescriptor (
 402                                 "Date", "NOW");
 403
 404                         try {
 405                                 descriptors.Add (desc);
 406                                 Assert.Fail (testCase + "#1");
 407                         } catch (NotSupportedException) {
 408                                 // read-only collection cannot be modified
 409                         }
 410
 411                         // ensure read-only check if performed before value is checked
 412                         try {
 413                                 descriptors.Add (null);
 414                                 Assert.Fail (testCase + "#2");
 415                         } catch (NotSupportedException) {
 416                                 // read-only collection cannot be modified
 417                         }
 418
 419                         try {
 420                                 descriptors.Clear ();
 421                                 Assert.Fail (testCase + "#3");
 422                         } catch (NotSupportedException) {
 423                                 // read-only collection cannot be modified
 424                         }
 425
 426                         try {
 427                                 descriptors.Insert (0, desc);
 428                                 Assert.Fail (testCase + "#4");
 429                         } catch (NotSupportedException) {
 430                                 // read-only collection cannot be modified
 431                         }
 432
 433                         // ensure read-only check if performed before value is checked
 434                         try {
 435                                 descriptors.Insert (0, null);
 436                                 Assert.Fail (testCase + "#5");
 437                         } catch (NotSupportedException) {
 438                                 // read-only collection cannot be modified
 439                         }
 440
 441                         try {
 442                                 descriptors.Remove (desc);
 443                                 Assert.Fail (testCase + "#6");
 444                         } catch (NotSupportedException) {
 445                                 // read-only collection cannot be modified
 446                         }
 447
 448                         // ensure read-only check if performed before value is checked
 449                         try {
 450                                 descriptors.Remove (null);
 451                                 Assert.Fail (testCase + "#7");
 452                         } catch (NotSupportedException) {
 453                                 // read-only collection cannot be modified
 454                         }
 455
 456                         try {
 457                                 descriptors.RemoveAt (0);
 458                                 Assert.Fail (testCase + "#8");
 459                         } catch (NotSupportedException) {
 460                                 // read-only collection cannot be modified
 461                         }
 462
 463                         IList list = (IList) descriptors;
 464                         Assert.IsTrue (((IList) descriptors).IsReadOnly, testCase + "#9");
 465                         Assert.IsTrue (((IList) descriptors).IsFixedSize, testCase + "#10");
 466
 467                         try {
 468                                 list.Add (desc);
 469                                 Assert.Fail (testCase + "#11");
 470                         } catch (NotSupportedException) {
 471                                 // read-only collection cannot be modified
 472                         }
 473
 474                         // ensure read-only check if performed before value is checked
 475                         try {
 476                                 list.Add (null);
 477                                 Assert.Fail (testCase + "#12");
 478                         } catch (NotSupportedException) {
 479                                 // read-only collection cannot be modified
 480                         }
 481
 482                         try {
 483                                 list.Clear ();
 484                                 Assert.Fail (testCase + "#13");
 485                         } catch (NotSupportedException) {
 486                                 // read-only collection cannot be modified
 487                         }
 488
 489                         try {
 490                                 list.Insert (0, desc);
 491                                 Assert.Fail (testCase + "#14");
 492                         } catch (NotSupportedException) {
 493                                 // read-only collection cannot be modified
 494                         }
 495
 496                         // ensure read-only check if performed before value is checked
 497                         try {
 498                                 list.Insert (0, null);
 499                                 Assert.Fail (testCase + "#15");
 500                         } catch (NotSupportedException) {
 501                                 // read-only collection cannot be modified
 502                         }
 503
 504                         try {
 505                                 list.Remove (desc);
 506                                 Assert.Fail (testCase + "#16");
 507                         } catch (NotSupportedException) {
 508                                 // read-only collection cannot be modified
 509                         }
 510
 511                         // ensure read-only check if performed before value is checked
 512                         try {
 513                                 list.Remove (null);
 514                                 Assert.Fail (testCase + "#17");
 515                         } catch (NotSupportedException) {
 516                                 // read-only collection cannot be modified
 517                         }
 518
 519                         try {
 520                                 list.RemoveAt (0);
 521                                 Assert.Fail (testCase + "#18");
 522                         } catch (NotSupportedException) {
 523                                 // read-only collection cannot be modified
 524                         }
 525
 526                         try {
 527                                 list[0] = desc;
 528                                 Assert.Fail (testCase + "#19");
 529                         } catch (NotSupportedException) {
 530                                 // read-only collection cannot be modified
 531                         }
 532
 533                         // ensure read-only check if performed before value is checked
 534                         try {
 535                                 list[0] = null;
 536                                 Assert.Fail (testCase + "#20");
 537                         } catch (NotSupportedException) {
 538                                 // read-only collection cannot be modified
 539                         }
 540                 }
 541
 542                 private class MockEventDescriptor : EventDescriptor
 543                 {
 544                         public MockEventDescriptor (string name, string category)
 545                                 : base (name, new Attribute [] { new CategoryAttribute (category) })
 546                         {
 547                         }
 548
 549                         public override Type ComponentType {
 550                                 get {
 551                                         return null;
 552                                 }
 553                         }
 554
 555                         public override Type EventType {
 556                                 get {
 557                                         return null;
 558                                 }
 559                         }
 560
 561                         public override bool IsMulticast {
 562                                 get {
 563                                         return false;
 564                                 }
 565                         }
 566
 567                         public override void AddEventHandler (object component, Delegate value)
 568                         {
 569                         }
 570
 571                         public override void RemoveEventHandler (object component, Delegate value)
 572                         {
 573                         }
 574                 }
 575
 576                 class CategoryComparer : IComparer
 577                 {
 578                         public int Compare (object x, object y)
 579                         {
 580                                 EventDescriptor descX = x as EventDescriptor;
 581                                 EventDescriptor descY = y as EventDescriptor;
 582
 583                                 if (descX == null && descY == null)
 584                                         return 0;
 585                                 if (descX == null)
 586                                         return -1;
 587                                 if (descY == null)
 588                                         return 1;
 589
 590                                 return string.Compare (descX.Category, descY.Category, false, CultureInfo.CurrentCulture);
 591                         }
 592                 }
 593         }
 594 }