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] SetUp()26 public void SetUp () 27 { 28 originalCulture = Thread.CurrentThread.CurrentCulture; 29 } 30 31 [TearDown] TearDown()32 public void TearDown () 33 { 34 Thread.CurrentThread.CurrentCulture = originalCulture; 35 } 36 37 [Test] Empty()38 public void Empty () 39 { 40 PropertyDescriptorCollection descriptors = PropertyDescriptorCollection.Empty; 41 Assert.AreEqual (0, descriptors.Count); 42 AssertReadOnly (descriptors, "Empty"); 43 } 44 45 [Test] Find()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] Find_Name_Null()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] IList()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] IList_Add_Null()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))] IList_Add_NoPropertyDescriptor()151 public void IList_Add_NoPropertyDescriptor () 152 { 153 IList list = ((IList) new PropertyDescriptorCollection (null)); 154 list.Add (5); 155 } 156 157 [Test] IDictionary()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))] IDictionary_Add_Null()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))] IDictionary_Add_NoPropertyDescriptor()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] Indexer2()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] Indexer2_Name_Null()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 ReadOnly()243 public void ReadOnly () 244 { 245 PropertyDescriptorCollection descriptors = new PropertyDescriptorCollection(null, true); 246 AssertReadOnly (descriptors, "ReadOnly"); 247 } 248 249 [Test] // Sort () Sort1()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 []) Sort2()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) Sort3()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) Sort4()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 AssertReadOnly(PropertyDescriptorCollection descriptors, string testCase)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 MockPropertyDescriptor(string name, object value)683 public MockPropertyDescriptor (string name, object value) : base (name, null) 684 { 685 _value = value; 686 } 687 CanResetValue(object component)688 public override bool CanResetValue (object component) 689 { 690 return true; 691 } 692 GetValue(object component)693 public override object GetValue (object component) 694 { 695 return _value; 696 } 697 ResetValue(object component)698 public override void ResetValue (object component) 699 { 700 _value = null; 701 } 702 SetValue(object component, object value)703 public override void SetValue (object component, object value) 704 { 705 _value = value; 706 } 707 ShouldSerializeValue(object component)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 { Compare(object x, object y)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 } 763