PageRenderTime 61ms CodeModel.GetById 16ms RepoModel.GetById 1ms app.codeStats 0ms

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

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