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