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

   1 //
   2 // System.ComponentModel.PropertyDescriptorCollection test cases
   3 //
   4 // Authors:
   5 //      Gert Driesen (drieseng@users.sourceforge.net)
   6 //
   7 // (c) 2005 Novell, Inc. (http://www.ximian.com)
   8 //
   9
  10 using System;
  11 using System.Collections;
  12 using System.ComponentModel;
  13 using System.Globalization;
  14 using System.Threading;
  15
  16 using NUnit.Framework;
  17
  18 namespace MonoTests.System.ComponentModel
  19 {
  20         [TestFixture]
  21         public class PropertyDescriptorCollectionTests
  22         {
  23                 private CultureInfo originalCulture;
  24
  25                 [SetUp]
  26                 public void SetUp ()
  27                 {
  28                         originalCulture = Thread.CurrentThread.CurrentCulture;
  29                 }
  30
  31                 [TearDown]
  32                 public void TearDown ()
  33                 {
  34                         Thread.CurrentThread.CurrentCulture = originalCulture;
  35                 }
  36
  37                 [Test]
  38                 public void Empty ()
  39                 {
  40                         PropertyDescriptorCollection descriptors = PropertyDescriptorCollection.Empty;
  41                         Assert.AreEqual (0, descriptors.Count);
  42                         AssertReadOnly (descriptors, "Empty");
  43                 }
  44
  45                 [Test]
  46                 public void Find ()
  47                 {
  48                         PropertyDescriptor descA = new MockPropertyDescriptor ("hehe_\u0061\u030a", 2);
  49                         PropertyDescriptor descB = new MockPropertyDescriptor ("heh_\u00e5", 3);
  50                         PropertyDescriptor descC = new MockPropertyDescriptor ("Foo", 5);
  51                         PropertyDescriptor descD = new MockPropertyDescriptor ("FOo", 6);
  52                         PropertyDescriptor descE = new MockPropertyDescriptor ("Aim", 1);
  53                         PropertyDescriptor descF = new MockPropertyDescriptor ("Bar", 4);
  54
  55                         PropertyDescriptorCollection col = new PropertyDescriptorCollection (
  56                                 new PropertyDescriptor [] { descA, descB, descC, descD, descE, descF });
  57
  58                         Assert.IsNull (col.Find ("heh_\u0061\u030a", false), "#1");
  59                         Assert.IsNull (col.Find ("hehe_\u00e5", false), "#2");
  60                         Assert.AreSame (descA, col.Find ("hehe_\u0061\u030a", false), "#3");
  61                         Assert.AreSame (descB, col.Find ("heh_\u00e5", false), "#4");
  62                         Assert.IsNull (col.Find ("foo", false), "#5");
  63                         Assert.AreSame (descC, col.Find ("foo", true), "#6");
  64                         Assert.AreSame (descD, col.Find ("FOo", false), "#7");
  65                         Assert.AreSame (descC, col.Find ("FOo", true), "#8");
  66                         Assert.IsNull (col.Find ("fOo", false), "#9");
  67                         Assert.AreSame (descC, col.Find ("fOo", true), "#10");
  68                         Assert.IsNull (col.Find ("AIm", false), "#11");
  69                         Assert.AreSame (descE, col.Find ("AIm", true), "#12");
  70                         Assert.IsNull (col.Find ("AiM", false), "#13");
  71                         Assert.AreSame (descE, col.Find ("AiM", true), "#14");
  72                         Assert.AreSame (descE, col.Find ("Aim", false), "#15");
  73                         Assert.AreSame (descE, col.Find ("Aim", true), "#16");
  74                 }
  75
  76                 [Test]
  77                 public void Find_Name_Null ()
  78                 {
  79                         PropertyDescriptorCollection descriptors;
  80
  81                         descriptors = new PropertyDescriptorCollection (
  82                                 new PropertyDescriptor[] { new MockPropertyDescriptor ("A", 1),
  83                                         new MockPropertyDescriptor ("b", 2)});
  84
  85                         try {
  86                                 descriptors.Find (null, false);
  87                                 Assert.Fail ("#A1");
  88                         } catch (ArgumentNullException ex) {
  89                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
  90                                 Assert.IsNull (ex.InnerException, "#A3");
  91                                 Assert.IsNotNull (ex.Message, "#A4");
  92                                 Assert.IsNotNull (ex.ParamName, "#A5");
  93                         }
  94
  95                         try {
  96                                 descriptors.Find (null, true);
  97                                 Assert.Fail ("#B1");
  98                         } catch (ArgumentNullException ex) {
  99                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
 100                                 Assert.IsNull (ex.InnerException, "#B3");
 101                                 Assert.IsNotNull (ex.Message, "#B4");
 102                                 Assert.IsNotNull (ex.ParamName, "#B5");
 103                         }
 104
 105                         descriptors = PropertyDescriptorCollection.Empty;
 106
 107                         try {
 108                                 descriptors.Find (null, false);
 109                                 Assert.Fail ("#C1");
 110                         } catch (ArgumentNullException ex) {
 111                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#C2");
 112                                 Assert.IsNull (ex.InnerException, "#C3");
 113                                 Assert.IsNotNull (ex.Message, "#C4");
 114                                 Assert.IsNotNull (ex.ParamName, "#C5");
 115                         }
 116
 117                         try {
 118                                 descriptors.Find (null, true);
 119                                 Assert.Fail ("#D1");
 120                         } catch (ArgumentNullException ex) {
 121                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#D2");
 122                                 Assert.IsNull (ex.InnerException, "#D3");
 123                                 Assert.IsNotNull (ex.Message, "#D4");
 124                                 Assert.IsNotNull (ex.ParamName, "#D5");
 125                         }
 126                 }
 127
 128                 [Test]
 129                 public void IList ()
 130                 {
 131                         IList list = ((IList) new PropertyDescriptorCollection (null));
 132
 133                         Assert.AreEqual (0, list.Count, "#1");
 134                         Assert.IsFalse (list.IsFixedSize, "#2");
 135                         Assert.IsFalse (list.IsReadOnly, "#3");
 136                         Assert.IsFalse (list.IsSynchronized, "#4");
 137                         Assert.IsNull (list.SyncRoot, "#5");
 138                 }
 139
 140                 [Test]
 141                 public void IList_Add_Null ()
 142                 {
 143                         IList list = ((IList) new PropertyDescriptorCollection (null));
 144                         Assert.AreEqual (0, list.Count, "#1");
 145                         list.Add (null);
 146                         Assert.AreEqual (1, list.Count, "#2");
 147                 }
 148
 149                 [Test]
 150                 [ExpectedException (typeof (InvalidCastException))]
 151                 public void IList_Add_NoPropertyDescriptor ()
 152                 {
 153                         IList list = ((IList) new PropertyDescriptorCollection (null));
 154                         list.Add (5);
 155                 }
 156
 157                 [Test]
 158                 public void IDictionary ()
 159                 {
 160                         IDictionary dictionary = ((IDictionary) new PropertyDescriptorCollection (null));
 161
 162                         Assert.AreEqual (0, dictionary.Count, "#1");
 163                         Assert.IsFalse (dictionary.IsFixedSize, "#2");
 164                         Assert.IsFalse (dictionary.IsReadOnly, "#3");
 165                         Assert.IsFalse (dictionary.IsSynchronized, "#4");
 166                         Assert.IsNull (dictionary.SyncRoot, "#5");
 167                 }
 168
 169
 170                 [Test]
 171                 [ExpectedException (typeof(ArgumentException))]
 172                 public void IDictionary_Add_Null ()
 173                 {
 174                         IDictionary dictionary = ((IDictionary) new PropertyDescriptorCollection (null));
 175                         dictionary.Add ("whatever", null);
 176                 }
 177
 178                 [Test]
 179                 [ExpectedException (typeof (ArgumentException))]
 180                 public void IDictionary_Add_NoPropertyDescriptor ()
 181                 {
 182                         IDictionary dictionary = ((IDictionary) new PropertyDescriptorCollection (null));
 183                         dictionary.Add ("whatever", 5);
 184                 }
 185
 186                 [Test] // this [String]
 187                 public void Indexer2 ()
 188                 {
 189                         PropertyDescriptor descA = new MockPropertyDescriptor ("hehe_\u0061\u030a", 2);
 190                         PropertyDescriptor descB = new MockPropertyDescriptor ("heh_\u00e5", 3);
 191                         PropertyDescriptor descC = new MockPropertyDescriptor ("Foo", 5);
 192                         PropertyDescriptor descD = new MockPropertyDescriptor ("FOo", 6);
 193                         PropertyDescriptor descE = new MockPropertyDescriptor ("Aim", 1);
 194                         PropertyDescriptor descF = new MockPropertyDescriptor ("Bar", 4);
 195
 196                         PropertyDescriptorCollection col = new PropertyDescriptorCollection (
 197                                 new PropertyDescriptor [] { descA, descB, descC, descD, descE, descF });
 198
 199                         Assert.IsNull (col ["heh_\u0061\u030a"], "#1");
 200                         Assert.IsNull (col ["hehe_\u00e5"], "#2");
 201                         Assert.AreSame (descA, col ["hehe_\u0061\u030a"], "#3");
 202                         Assert.AreSame (descB, col ["heh_\u00e5"], "#4");
 203                         Assert.IsNull (col ["foo"], "#5");
 204                         Assert.AreSame (descD, col ["FOo"], "#6");
 205                         Assert.IsNull (col ["fOo"], "#7");
 206                         Assert.IsNull (col ["AIm"], "#8");
 207                         Assert.IsNull (col ["AiM"], "#9");
 208                         Assert.AreSame (descE, col ["Aim"], "#10");
 209                 }
 210
 211                 [Test]
 212                 public void Indexer2_Name_Null ()
 213                 {
 214                         PropertyDescriptorCollection descriptors;
 215
 216                         descriptors = new PropertyDescriptorCollection (
 217                                 new PropertyDescriptor [] { new MockPropertyDescriptor ("A", 1),
 218                                         new MockPropertyDescriptor ("b", 2)});
 219
 220                         try {
 221                                 PropertyDescriptor desc = descriptors [(string) null];
 222                                 Assert.Fail ("#A1:" + desc);
 223                         } catch (ArgumentNullException ex) {
 224                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 225                                 Assert.IsNull (ex.InnerException, "#A3");
 226                                 Assert.IsNotNull (ex.Message, "#A4");
 227                                 Assert.IsNotNull (ex.ParamName, "#A5");
 228                         }
 229
 230                         descriptors = PropertyDescriptorCollection.Empty;
 231
 232                         try {
 233                                 PropertyDescriptor desc = descriptors [(string) null];
 234                                 Assert.Fail ("#B1:" + desc);
 235                         } catch (ArgumentNullException ex) {
 236                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
 237                                 Assert.IsNull (ex.InnerException, "#B3");
 238                                 Assert.IsNotNull (ex.Message, "#B4");
 239                                 Assert.IsNotNull (ex.ParamName, "#B5");
 240                         }
 241                 }
 242
 243                 public void ReadOnly ()
 244                 {
 245                         PropertyDescriptorCollection descriptors = new PropertyDescriptorCollection(null, true);
 246                         AssertReadOnly (descriptors, "ReadOnly");
 247                 }
 248
 249                 [Test] // Sort ()
 250                 public void Sort1 ()
 251                 {
 252                         PropertyDescriptorCollection descriptors;
 253                         PropertyDescriptorCollection sorted;
 254
 255                         PropertyDescriptor descA = new MockPropertyDescriptor("Foo", 2);
 256                         PropertyDescriptor descB = new MockPropertyDescriptor ("Aim", 3);
 257                         PropertyDescriptor descC = new MockPropertyDescriptor ("Bim", 1);
 258                         PropertyDescriptor descD = new MockPropertyDescriptor("AIm", 5);
 259                         PropertyDescriptor descE = new MockPropertyDescriptor("Boo", 4);
 260                         PropertyDescriptor descF = new MockPropertyDescriptor ("FOo", 6);
 261
 262                         PropertyDescriptor [] props = new  PropertyDescriptor [] {
 263                                 descA, descB, descC, descD, descE, descF };
 264                         descriptors = new PropertyDescriptorCollection (props);
 265
 266                         Assert.AreSame (descA, descriptors [0], "#A1");
 267                         Assert.AreSame (descB, descriptors [1], "#A2");
 268                         Assert.AreSame (descC, descriptors [2], "#A3");
 269                         Assert.AreSame (descD, descriptors [3], "#A4");
 270                         Assert.AreSame (descE, descriptors [4], "#A5");
 271                         Assert.AreSame (descF, descriptors [5], "#A6");
 272
 273                         sorted = descriptors.Sort ();
 274
 275                         Assert.AreSame (descA, descriptors [0], "#B1");
 276                         Assert.AreSame (descB, descriptors [1], "#B2");
 277                         Assert.AreSame (descC, descriptors [2], "#B3");
 278                         Assert.AreSame (descD, descriptors [3], "#B4");
 279                         Assert.AreSame (descE, descriptors [4], "#B5");
 280                         Assert.AreSame (descF, descriptors [5], "#B6");
 281
 282                         Assert.AreSame (descB, sorted [0], "#C1");
 283                         Assert.AreSame (descD, sorted [1], "#C2");
 284                         Assert.AreSame (descC, sorted [2], "#C3");
 285                         Assert.AreSame (descE, sorted [3], "#C4");
 286                         Assert.AreSame (descA, sorted [4], "#C5");
 287                         Assert.AreSame (descF, sorted [5], "#C6");
 288                 }
 289
 290                 [Test] // Sort (String [])
 291                 public void Sort2 ()
 292                 {
 293                         PropertyDescriptorCollection descriptors;
 294                         PropertyDescriptorCollection sorted;
 295
 296                         PropertyDescriptor descA = new MockPropertyDescriptor ("Foo", 2);
 297                         PropertyDescriptor descB = new MockPropertyDescriptor ("Aim", 3);
 298                         PropertyDescriptor descC = new MockPropertyDescriptor ("Bim", 1);
 299                         PropertyDescriptor descD = new MockPropertyDescriptor ("AIm", 5);
 300                         PropertyDescriptor descE = new MockPropertyDescriptor ("Boo", 4);
 301                         PropertyDescriptor descF = new MockPropertyDescriptor ("FOo", 6);
 302
 303                         PropertyDescriptor [] props = new PropertyDescriptor [] {
 304                                 descA, descB, descC, descD, descE, descF };
 305                         descriptors = new PropertyDescriptorCollection (props);
 306
 307                         Assert.AreSame (descA, descriptors [0], "#A1");
 308                         Assert.AreSame (descB, descriptors [1], "#A2");
 309                         Assert.AreSame (descC, descriptors [2], "#A3");
 310                         Assert.AreSame (descD, descriptors [3], "#A4");
 311                         Assert.AreSame (descE, descriptors [4], "#A5");
 312                         Assert.AreSame (descF, descriptors [5], "#A5");
 313
 314                         sorted = descriptors.Sort (new string [] { "B", "Foo", null, "A", "Boo" });
 315
 316                         Assert.AreSame (descA, descriptors [0], "#B1");
 317                         Assert.AreSame (descB, descriptors [1], "#B2");
 318                         Assert.AreSame (descC, descriptors [2], "#B3");
 319                         Assert.AreSame (descD, descriptors [3], "#B4");
 320                         Assert.AreSame (descE, descriptors [4], "#B5");
 321                         Assert.AreSame (descF, descriptors [5], "#B6");
 322
 323                         Assert.AreSame (descA, sorted [0], "#C1");
 324                         Assert.AreSame (descE, sorted [1], "#C2");
 325                         Assert.AreSame (descB, sorted [2], "#C3");
 326                         Assert.AreSame (descD, sorted [3], "#C4");
 327                         Assert.AreSame (descC, sorted [4], "#C5");
 328                         Assert.AreSame (descF, sorted [5], "#C6");
 329
 330                         sorted = descriptors.Sort ((string []) null);
 331
 332                         Assert.AreSame (descA, descriptors [0], "#D1");
 333                         Assert.AreSame (descB, descriptors [1], "#D2");
 334                         Assert.AreSame (descC, descriptors [2], "#D3");
 335                         Assert.AreSame (descD, descriptors [3], "#D4");
 336                         Assert.AreSame (descE, descriptors [4], "#D5");
 337                         Assert.AreSame (descF, descriptors [5], "#D6");
 338
 339                         Assert.AreSame (descB, sorted [0], "#E1");
 340                         Assert.AreSame (descD, sorted [1], "#E2");
 341                         Assert.AreSame (descC, sorted [2], "#E3");
 342                         Assert.AreSame (descE, sorted [3], "#E4");
 343                         Assert.AreSame (descA, sorted [4], "#E5");
 344                         Assert.AreSame (descF, sorted [5], "#E6");
 345                 }
 346
 347                 [Test] // Sort (IComparer)
 348                 public void Sort3 ()
 349                 {
 350                         PropertyDescriptorCollection descriptors;
 351                         PropertyDescriptorCollection sorted;
 352
 353                         PropertyDescriptor descA = new MockPropertyDescriptor ("Foo", 2);
 354                         PropertyDescriptor descB = new MockPropertyDescriptor ("Aim", 3);
 355                         PropertyDescriptor descC = new MockPropertyDescriptor ("Bim", 1);
 356                         PropertyDescriptor descD = new MockPropertyDescriptor ("AIm", 5);
 357                         PropertyDescriptor descE = new MockPropertyDescriptor ("Boo", 4);
 358                         PropertyDescriptor descF = new MockPropertyDescriptor ("FOo", 6);
 359
 360                         PropertyDescriptor [] props = new PropertyDescriptor [] {
 361                                 descA, descB, descC, descD, descE, descF };
 362                         descriptors = new PropertyDescriptorCollection (props);
 363
 364                         Assert.AreSame (descA, descriptors [0], "#A1");
 365                         Assert.AreSame (descB, descriptors [1], "#A2");
 366                         Assert.AreSame (descC, descriptors [2], "#A3");
 367                         Assert.AreSame (descD, descriptors [3], "#A4");
 368                         Assert.AreSame (descE, descriptors [4], "#A5");
 369                         Assert.AreSame (descF, descriptors [5], "#A6");
 370
 371                         sorted = descriptors.Sort (new ComparableComparer ());
 372
 373                         Assert.AreSame (descA, descriptors [0], "#B1");
 374                         Assert.AreSame (descB, descriptors [1], "#B2");
 375                         Assert.AreSame (descC, descriptors [2], "#B3");
 376                         Assert.AreSame (descD, descriptors [3], "#B4");
 377                         Assert.AreSame (descE, descriptors [4], "#B5");
 378                         Assert.AreSame (descF, descriptors [5], "#B6");
 379
 380                         Assert.AreSame (descC, sorted [0], "#C1");
 381                         Assert.AreSame (descA, sorted [1], "#C2");
 382                         Assert.AreSame (descB, sorted [2], "#C3");
 383                         Assert.AreSame (descE, sorted [3], "#C4");
 384                         Assert.AreSame (descD, sorted [4], "#C5");
 385                         Assert.AreSame (descF, sorted [5], "#C6");
 386
 387                         sorted = descriptors.Sort ((Comparer) null);
 388
 389                         Assert.AreSame (descA, descriptors [0], "#D1");
 390                         Assert.AreSame (descB, descriptors [1], "#D2");
 391                         Assert.AreSame (descC, descriptors [2], "#D3");
 392                         Assert.AreSame (descD, descriptors [3], "#D4");
 393                         Assert.AreSame (descE, descriptors [4], "#D5");
 394                         Assert.AreSame (descF, descriptors [5], "#D6");
 395
 396                         Assert.AreSame (descB, sorted [0], "#E1");
 397                         Assert.AreSame (descD, sorted [1], "#E2");
 398                         Assert.AreSame (descC, sorted [2], "#E3");
 399                         Assert.AreSame (descE, sorted [3], "#E4");
 400                         Assert.AreSame (descA, sorted [4], "#E5");
 401                         Assert.AreSame (descF, sorted [5], "#E6");
 402                 }
 403
 404                 [Test] // Sort (String [], IComparer)
 405                 public void Sort4 ()
 406                 {
 407                         PropertyDescriptorCollection descriptors;
 408                         PropertyDescriptorCollection sorted;
 409
 410                         PropertyDescriptor descA = new MockPropertyDescriptor ("Foo", 2);
 411                         PropertyDescriptor descB = new MockPropertyDescriptor ("Aim", 3);
 412                         PropertyDescriptor descC = new MockPropertyDescriptor ("Bim", 1);
 413                         PropertyDescriptor descD = new MockPropertyDescriptor ("AIm", 5);
 414                         PropertyDescriptor descE = new MockPropertyDescriptor ("Boo", 4);
 415                         PropertyDescriptor descF = new MockPropertyDescriptor ("FOo", 6);
 416
 417                         PropertyDescriptor [] props = new PropertyDescriptor [] {
 418                                 descA, descB, descC, descD, descE, descF };
 419                         descriptors = new PropertyDescriptorCollection (props);
 420
 421                         Assert.AreSame (descA, descriptors [0], "#A1");
 422                         Assert.AreSame (descB, descriptors [1], "#A2");
 423                         Assert.AreSame (descC, descriptors [2], "#A3");
 424                         Assert.AreSame (descD, descriptors [3], "#A4");
 425                         Assert.AreSame (descE, descriptors [4], "#A5");
 426                         Assert.AreSame (descF, descriptors [5], "#A6");
 427
 428                         sorted = descriptors.Sort (new string [] { "B", "Foo", null, "A", "Boo" },
 429                                 new ComparableComparer ());
 430
 431                         Assert.AreSame (descA, descriptors [0], "#B1");
 432                         Assert.AreSame (descB, descriptors [1], "#B2");
 433                         Assert.AreSame (descC, descriptors [2], "#B3");
 434                         Assert.AreSame (descD, descriptors [3], "#B4");
 435                         Assert.AreSame (descE, descriptors [4], "#B5");
 436                         Assert.AreSame (descF, descriptors [5], "#B6");
 437
 438                         Assert.AreSame (descA, sorted [0], "#C1");
 439                         Assert.AreSame (descE, sorted [1], "#C2");
 440                         Assert.AreSame (descC, sorted [2], "#C3");
 441                         Assert.AreSame (descB, sorted [3], "#C4");
 442                         Assert.AreSame (descD, sorted [4], "#C5");
 443                         Assert.AreSame (descF, sorted [5], "#C6");
 444
 445                         sorted = descriptors.Sort ((string []) null, new ComparableComparer ());
 446
 447                         Assert.AreSame (descA, descriptors [0], "#D1");
 448                         Assert.AreSame (descB, descriptors [1], "#D2");
 449                         Assert.AreSame (descC, descriptors [2], "#D3");
 450                         Assert.AreSame (descD, descriptors [3], "#D4");
 451                         Assert.AreSame (descE, descriptors [4], "#D5");
 452                         Assert.AreSame (descF, descriptors [5], "#D6");
 453
 454                         Assert.AreSame (descC, sorted [0], "#E1");
 455                         Assert.AreSame (descA, sorted [1], "#E2");
 456                         Assert.AreSame (descB, sorted [2], "#E3");
 457                         Assert.AreSame (descE, sorted [3], "#E4");
 458                         Assert.AreSame (descD, sorted [4], "#E5");
 459                         Assert.AreSame (descF, sorted [5], "#E6");
 460
 461                         sorted = descriptors.Sort (new string [] { "B", "Foo", null, "A", "Boo" },
 462                                 (Comparer) null);
 463
 464                         Assert.AreSame (descA, descriptors [0], "#F1");
 465                         Assert.AreSame (descB, descriptors [1], "#F2");
 466                         Assert.AreSame (descC, descriptors [2], "#F3");
 467                         Assert.AreSame (descD, descriptors [3], "#F4");
 468                         Assert.AreSame (descE, descriptors [4], "#F5");
 469                         Assert.AreSame (descF, descriptors [5], "#F6");
 470
 471                         Assert.AreSame (descA, sorted [0], "#G1");
 472                         Assert.AreSame (descE, sorted [1], "#G2");
 473                         Assert.AreSame (descB, sorted [2], "#G3");
 474                         Assert.AreSame (descD, sorted [3], "#G4");
 475                         Assert.AreSame (descC, sorted [4], "#G5");
 476                         Assert.AreSame (descF, sorted [5], "#G6");
 477
 478                         sorted = descriptors.Sort ((string []) null, (Comparer) null);
 479
 480                         Assert.AreSame (descA, descriptors [0], "#H1");
 481                         Assert.AreSame (descB, descriptors [1], "#H2");
 482                         Assert.AreSame (descC, descriptors [2], "#H3");
 483                         Assert.AreSame (descD, descriptors [3], "#H4");
 484                         Assert.AreSame (descE, descriptors [4], "#H5");
 485                         Assert.AreSame (descF, descriptors [5], "#H6");
 486
 487                         Assert.AreSame (descB, sorted [0], "#I1");
 488                         Assert.AreSame (descD, sorted [1], "#I2");
 489                         Assert.AreSame (descC, sorted [2], "#I3");
 490                         Assert.AreSame (descE, sorted [3], "#I4");
 491                         Assert.AreSame (descA, sorted [4], "#I5");
 492                         Assert.AreSame (descF, sorted [5], "#I6");
 493                 }
 494
 495                 private void AssertReadOnly (PropertyDescriptorCollection descriptors, string testCase)
 496                 {
 497                         MockPropertyDescriptor mockPropertyDescr = new MockPropertyDescriptor (
 498                                 "Date", DateTime.Now);
 499
 500                         try {
 501                                 descriptors.Add (mockPropertyDescr);
 502                                 Assert.Fail (testCase + "#1");
 503                         } catch (NotSupportedException) {
 504                                 // read-only collection cannot be modified
 505                         }
 506
 507                         // ensure read-only check if performed before value is checked
 508                         try {
 509                                 descriptors.Add (null);
 510                                 Assert.Fail (testCase + "#2");
 511                         } catch (NotSupportedException) {
 512                                 // read-only collection cannot be modified
 513                         }
 514
 515                         try {
 516                                 descriptors.Clear ();
 517                                 Assert.Fail (testCase + "#3");
 518                         } catch (NotSupportedException) {
 519                                 // read-only collection cannot be modified
 520                         }
 521
 522                         try {
 523                                 descriptors.Insert (0, mockPropertyDescr);
 524                                 Assert.Fail (testCase + "#4");
 525                         } catch (NotSupportedException) {
 526                                 // read-only collection cannot be modified
 527                         }
 528
 529                         // ensure read-only check if performed before value is checked
 530                         try {
 531                                 descriptors.Insert (0, null);
 532                                 Assert.Fail (testCase + "#5");
 533                         } catch (NotSupportedException) {
 534                                 // read-only collection cannot be modified
 535                         }
 536
 537                         try {
 538                                 descriptors.Remove (mockPropertyDescr);
 539                                 Assert.Fail (testCase + "#6");
 540                         } catch (NotSupportedException) {
 541                                 // read-only collection cannot be modified
 542                         }
 543
 544                         // ensure read-only check if performed before value is checked
 545                         try {
 546                                 descriptors.Remove (null);
 547                                 Assert.Fail (testCase + "#7");
 548                         } catch (NotSupportedException) {
 549                                 // read-only collection cannot be modified
 550                         }
 551
 552                         try {
 553                                 descriptors.RemoveAt (0);
 554                                 Assert.Fail (testCase + "#8");
 555                         } catch (NotSupportedException) {
 556                                 // read-only collection cannot be modified
 557                         }
 558
 559                         IList list = (IList) descriptors;
 560                         Assert.IsTrue (((IList) descriptors).IsReadOnly, testCase + "#9");
 561                         Assert.IsTrue (((IList) descriptors).IsFixedSize, testCase + "#10");
 562
 563                         try {
 564                                 list.Add (mockPropertyDescr);
 565                                 Assert.Fail (testCase + "#11");
 566                         } catch (NotSupportedException) {
 567                                 // read-only collection cannot be modified
 568                         }
 569
 570                         // ensure read-only check if performed before value is checked
 571                         try {
 572                                 list.Add (null);
 573                                 Assert.Fail (testCase + "#12");
 574                         } catch (NotSupportedException) {
 575                                 // read-only collection cannot be modified
 576                         }
 577
 578                         try {
 579                                 list.Clear ();
 580                                 Assert.Fail (testCase + "#13");
 581                         } catch (NotSupportedException) {
 582                                 // read-only collection cannot be modified
 583                         }
 584
 585                         try {
 586                                 list.Insert (0, mockPropertyDescr);
 587                                 Assert.Fail (testCase + "#14");
 588                         } catch (NotSupportedException) {
 589                                 // read-only collection cannot be modified
 590                         }
 591
 592                         // ensure read-only check if performed before value is checked
 593                         try {
 594                                 list.Insert (0, null);
 595                                 Assert.Fail (testCase + "#15");
 596                         } catch (NotSupportedException) {
 597                                 // read-only collection cannot be modified
 598                         }
 599
 600                         try {
 601                                 list.Remove (mockPropertyDescr);
 602                                 Assert.Fail (testCase + "#16");
 603                         } catch (NotSupportedException) {
 604                                 // read-only collection cannot be modified
 605                         }
 606
 607                         // ensure read-only check if performed before value is checked
 608                         try {
 609                                 list.Remove (null);
 610                                 Assert.Fail (testCase + "#17");
 611                         } catch (NotSupportedException) {
 612                                 // read-only collection cannot be modified
 613                         }
 614
 615                         try {
 616                                 list.RemoveAt (0);
 617                                 Assert.Fail (testCase + "#18");
 618                         } catch (NotSupportedException) {
 619                                 // read-only collection cannot be modified
 620                         }
 621
 622                         try {
 623                                 list[0] = mockPropertyDescr;
 624                                 Assert.Fail (testCase + "#19");
 625                         } catch (NotSupportedException) {
 626                                 // read-only collection cannot be modified
 627                         }
 628
 629                         // ensure read-only check if performed before value is checked
 630                         try {
 631                                 list[0] = null;
 632                                 Assert.Fail (testCase + "#20");
 633                         } catch (NotSupportedException) {
 634                                 // read-only collection cannot be modified
 635                         }
 636
 637                         IDictionary dictionary = (IDictionary) descriptors;
 638                         Assert.IsTrue (dictionary.IsReadOnly, testCase + "#21");
 639                         Assert.IsTrue (dictionary.IsFixedSize, testCase + "#22");
 640
 641                         try {
 642                                 dictionary.Add ("test", mockPropertyDescr);
 643                                 Assert.Fail (testCase + "#23");
 644                         } catch (NotSupportedException) {
 645                                 // read-only collection cannot be modified
 646                         }
 647
 648                         // value is checked before read-only check
 649                         try {
 650                                 dictionary.Add ("test", null);
 651                                 Assert.Fail (testCase + "#24");
 652                         } catch (ArgumentException) {
 653                                 // read-only collection cannot be modified
 654                         }
 655
 656                         try {
 657                                 dictionary.Clear ();
 658                                 Assert.Fail (testCase + "#25");
 659                         } catch (NotSupportedException) {
 660                                 // read-only collection cannot be modified
 661                         }
 662
 663                         try {
 664                                 dictionary[0] = mockPropertyDescr;
 665                                 Assert.Fail (testCase + "#26");
 666                         } catch (NotSupportedException) {
 667                                 // read-only collection cannot be modified
 668                         }
 669
 670                         // ensure read-only check if performed before value is checked
 671                         try {
 672                                 dictionary[0] = null;
 673                                 Assert.Fail (testCase + "#27");
 674                         } catch (NotSupportedException) {
 675                                 // read-only collection cannot be modified
 676                         }
 677                 }
 678
 679                 private class MockPropertyDescriptor : PropertyDescriptor
 680                 {
 681                         private object _value;
 682
 683                         public MockPropertyDescriptor (string name, object value) : base (name, null)
 684                         {
 685                                 _value = value;
 686                         }
 687
 688                         public override bool CanResetValue (object component)
 689                         {
 690                                 return true;
 691                         }
 692
 693                         public override object GetValue (object component)
 694                         {
 695                                 return _value;
 696                         }
 697
 698                         public override void ResetValue (object component)
 699                         {
 700                                 _value = null;
 701                         }
 702
 703                         public override void SetValue (object component, object value)
 704                         {
 705                                 _value = value;
 706                         }
 707
 708                         public override bool ShouldSerializeValue (object component)
 709                         {
 710                                 return false;
 711                         }
 712
 713                         public override Type ComponentType {
 714                                 get {
 715                                         if (_value != null) {
 716                                                 return _value.GetType ();
 717                                         }
 718                                         return null;
 719                                 }
 720                         }
 721
 722                         public override bool IsReadOnly {
 723                                 get {
 724                                         return false;
 725                                 }
 726                         }
 727
 728                         public override Type PropertyType {
 729                                 get {
 730                                         return ComponentType;
 731                                 }
 732                         }
 733                 }
 734
 735                 class ComparableComparer : IComparer
 736                 {
 737                         public int Compare (object x, object y)
 738                         {
 739                                 PropertyDescriptor descX = x as PropertyDescriptor;
 740                                 PropertyDescriptor descY = y as PropertyDescriptor;
 741
 742                                 if (descX == null && descY == null)
 743                                         return 0;
 744                                 if (descX == null)
 745                                         return -1;
 746                                 if (descY == null)
 747                                         return 1;
 748
 749                                 IComparable compX = descX.GetValue (null) as IComparable;
 750                                 IComparable compY = descY.GetValue (null) as IComparable;
 751
 752                                 if (compX == null && compY == null)
 753                                         return 0;
 754                                 if (compX == null)
 755                                         return -1;
 756                                 if (compY == null)
 757                                         return 1;
 758                                 return compX.CompareTo (compY);
 759                         }
 760                 }
 761         }
 762 }