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