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