2 // System.ComponentModel.EventDescriptorCollection test cases
5 // Gert Driesen (drieseng@users.sourceforge.net)
7 // (c) 2008 Gert Driesen
11 using System.Collections;
12 using System.ComponentModel;
13 using System.Globalization;
14 using System.Threading;
15 using CategoryAttribute = System.ComponentModel.CategoryAttribute;
17 using NUnit.Framework;
19 namespace MonoTests.System.ComponentModel
22 public class EventDescriptorCollectionTests
24 private CultureInfo originalCulture;
29 originalCulture = Thread.CurrentThread.CurrentCulture;
33 public void TearDown ()
35 Thread.CurrentThread.CurrentCulture = originalCulture;
41 EventDescriptorCollection descriptors = EventDescriptorCollection.Empty;
42 Assert.AreEqual (0, descriptors.Count);
43 AssertReadOnly (descriptors, "Empty");
49 EventDescriptor descA = new MockEventDescriptor ("hehe_\u0061\u030a", null);
50 EventDescriptor descB = new MockEventDescriptor ("heh_\u00e5", null);
51 EventDescriptor descC = new MockEventDescriptor ("Foo", null);
52 EventDescriptor descD = new MockEventDescriptor ("FOo", null);
53 EventDescriptor descE = new MockEventDescriptor ("Aim", null);
54 EventDescriptor descF = new MockEventDescriptor ("Bar", null);
56 EventDescriptorCollection col = new EventDescriptorCollection (
57 new EventDescriptor [] { descA, descB, descC, descD, descE, descF });
60 Assert.IsNull (col.Find ("heh_\u0061\u030a", false), "#1");
61 Assert.IsNull (col.Find ("hehe_\u00e5", false), "#2");
63 Assert.AreSame (descB, col.Find ("heh_\u0061\u030a", false), "#1");
64 Assert.AreSame (descA, col.Find ("hehe_\u00e5", false), "#2");
66 Assert.AreSame (descA, col.Find ("hehe_\u0061\u030a", false), "#3");
67 Assert.AreSame (descB, col.Find ("heh_\u00e5", false), "#4");
68 Assert.IsNull (col.Find ("foo", false), "#5");
69 Assert.AreSame (descC, col.Find ("foo", true), "#6");
70 Assert.AreSame (descD, col.Find ("FOo", false), "#7");
71 Assert.AreSame (descC, col.Find ("FOo", true), "#8");
72 Assert.IsNull (col.Find ("fOo", false), "#9");
73 Assert.AreSame (descC, col.Find ("fOo", true), "#10");
74 Assert.IsNull (col.Find ("AIm", false), "#11");
75 Assert.AreSame (descE, col.Find ("AIm", true), "#12");
76 Assert.IsNull (col.Find ("AiM", false), "#13");
77 Assert.AreSame (descE, col.Find ("AiM", true), "#14");
78 Assert.AreSame (descE, col.Find ("Aim", false), "#15");
79 Assert.AreSame (descE, col.Find ("Aim", true), "#16");
83 public void Find_Key_Null ()
85 EventDescriptorCollection descriptors = new EventDescriptorCollection (
86 new EventDescriptor[] { new MockEventDescriptor ("A", "X"),
87 new MockEventDescriptor ("b", "Y")});
89 Assert.IsNull (descriptors.Find (null, false), "#1");
90 Assert.IsNull (descriptors.Find (null, true), "#2");
96 IList list = ((IList) new EventDescriptorCollection (null));
98 Assert.AreEqual (0, list.Count, "#1");
100 Assert.IsFalse (list.IsFixedSize, "#2");
102 Assert.IsTrue (list.IsFixedSize, "#2");
104 Assert.IsFalse (list.IsReadOnly, "#3");
105 Assert.IsFalse (list.IsSynchronized, "#4");
106 Assert.IsNull (list.SyncRoot, "#5");
110 public void IList_Add_Null ()
112 IList list = ((IList) new EventDescriptorCollection (null));
113 Assert.AreEqual (0, list.Count, "#1");
115 Assert.AreEqual (1, list.Count, "#2");
119 public void IList_Add_NoEventDescriptor ()
121 IList list = ((IList) new EventDescriptorCollection (null));
125 } catch (InvalidCastException) {
129 [Test] // this [String]
130 public void Indexer2 ()
132 EventDescriptor descA = new MockEventDescriptor ("hehe_\u0061\u030a", null);
133 EventDescriptor descB = new MockEventDescriptor ("heh_\u00e5", null);
134 EventDescriptor descC = new MockEventDescriptor ("Foo", null);
135 EventDescriptor descD = new MockEventDescriptor ("FOo", null);
136 EventDescriptor descE = new MockEventDescriptor ("Aim", null);
137 EventDescriptor descF = new MockEventDescriptor ("Bar", null);
139 EventDescriptorCollection col = new EventDescriptorCollection (
140 new EventDescriptor [] { descA, descB, descC, descD, descE, descF });
143 Assert.IsNull (col ["heh_\u0061\u030a"], "#1");
144 Assert.IsNull (col ["hehe_\u00e5"], "#2");
146 Assert.AreSame (descB, col ["heh_\u0061\u030a"], "#1");
147 Assert.AreSame (descA, col ["hehe_\u00e5"], "#2");
149 Assert.AreSame (descA, col ["hehe_\u0061\u030a"], "#3");
150 Assert.AreSame (descB, col ["heh_\u00e5"], "#4");
151 Assert.IsNull (col ["foo"], "#5");
152 Assert.AreSame (descD, col ["FOo"], "#6");
153 Assert.IsNull (col ["fOo"], "#7");
154 Assert.IsNull (col ["AIm"], "#8");
155 Assert.IsNull (col ["AiM"], "#9");
156 Assert.AreSame (descE, col ["Aim"], "#10");
157 Assert.IsNull (col [(string) null], "#11");
161 public void ReadOnly ()
163 EventDescriptorCollection descriptors = new EventDescriptorCollection (
164 (EventDescriptor []) null, true);
165 AssertReadOnly (descriptors, "ReadOnly");
172 EventDescriptorCollection descriptors;
173 EventDescriptorCollection sorted;
175 EventDescriptor descA = new MockEventDescriptor ("Foo", "B");
176 EventDescriptor descB = new MockEventDescriptor ("Aim", "C");
177 EventDescriptor descC = new MockEventDescriptor ("Bim", "A");
178 EventDescriptor descD = new MockEventDescriptor ("AIm", "E");
179 EventDescriptor descE = new MockEventDescriptor ("Boo", "D");
180 EventDescriptor descF = new MockEventDescriptor ("FOo", "F");
182 EventDescriptor [] props = new EventDescriptor [] {
183 descA, descB, descC, descD, descE, descF };
184 descriptors = new EventDescriptorCollection (props);
186 Assert.AreSame (descA, descriptors [0], "#A1");
187 Assert.AreSame (descB, descriptors [1], "#A2");
188 Assert.AreSame (descC, descriptors [2], "#A3");
189 Assert.AreSame (descD, descriptors [3], "#A4");
190 Assert.AreSame (descE, descriptors [4], "#A5");
191 Assert.AreSame (descF, descriptors [5], "#A6");
193 sorted = descriptors.Sort ();
195 Assert.AreSame (descA, descriptors [0], "#B1");
196 Assert.AreSame (descB, descriptors [1], "#B2");
197 Assert.AreSame (descC, descriptors [2], "#B3");
198 Assert.AreSame (descD, descriptors [3], "#B4");
199 Assert.AreSame (descE, descriptors [4], "#B5");
200 Assert.AreSame (descF, descriptors [5], "#B6");
202 Assert.AreSame (descB, sorted [0], "#C1");
203 Assert.AreSame (descD, sorted [1], "#C2");
204 Assert.AreSame (descC, sorted [2], "#C3");
205 Assert.AreSame (descE, sorted [3], "#C4");
206 Assert.AreSame (descA, sorted [4], "#C5");
207 Assert.AreSame (descF, sorted [5], "#C6");
210 [Test] // Sort (String [])
213 EventDescriptorCollection descriptors;
214 EventDescriptorCollection sorted;
216 EventDescriptor descA = new MockEventDescriptor ("Foo", "B");
217 EventDescriptor descB = new MockEventDescriptor ("Aim", "C");
218 EventDescriptor descC = new MockEventDescriptor ("Bim", "A");
219 EventDescriptor descD = new MockEventDescriptor ("AIm", "E");
220 EventDescriptor descE = new MockEventDescriptor ("Boo", "D");
221 EventDescriptor descF = new MockEventDescriptor ("FOo", "F");
223 EventDescriptor [] props = new EventDescriptor [] {
224 descA, descB, descC, descD, descE, descF };
225 descriptors = new EventDescriptorCollection (props);
227 Assert.AreSame (descA, descriptors [0], "#A1");
228 Assert.AreSame (descB, descriptors [1], "#A2");
229 Assert.AreSame (descC, descriptors [2], "#A3");
230 Assert.AreSame (descD, descriptors [3], "#A4");
231 Assert.AreSame (descE, descriptors [4], "#A5");
232 Assert.AreSame (descF, descriptors [5], "#A5");
234 sorted = descriptors.Sort (new string [] { "B", "Foo", null, "A", "Boo" });
236 Assert.AreSame (descA, descriptors [0], "#B1");
237 Assert.AreSame (descB, descriptors [1], "#B2");
238 Assert.AreSame (descC, descriptors [2], "#B3");
239 Assert.AreSame (descD, descriptors [3], "#B4");
240 Assert.AreSame (descE, descriptors [4], "#B5");
241 Assert.AreSame (descF, descriptors [5], "#B6");
243 Assert.AreSame (descA, sorted [0], "#C1");
244 Assert.AreSame (descE, sorted [1], "#C2");
245 Assert.AreSame (descB, sorted [2], "#C3");
246 Assert.AreSame (descD, sorted [3], "#C4");
247 Assert.AreSame (descC, sorted [4], "#C5");
248 Assert.AreSame (descF, sorted [5], "#C6");
250 sorted = descriptors.Sort ((string []) null);
252 Assert.AreSame (descA, descriptors [0], "#D1");
253 Assert.AreSame (descB, descriptors [1], "#D2");
254 Assert.AreSame (descC, descriptors [2], "#D3");
255 Assert.AreSame (descD, descriptors [3], "#D4");
256 Assert.AreSame (descE, descriptors [4], "#D5");
257 Assert.AreSame (descF, descriptors [5], "#D6");
259 Assert.AreSame (descB, sorted [0], "#E1");
260 Assert.AreSame (descD, sorted [1], "#E2");
261 Assert.AreSame (descC, sorted [2], "#E3");
262 Assert.AreSame (descE, sorted [3], "#E4");
263 Assert.AreSame (descA, sorted [4], "#E5");
264 Assert.AreSame (descF, sorted [5], "#E6");
267 [Test] // Sort (IComparer)
270 EventDescriptorCollection descriptors;
271 EventDescriptorCollection sorted;
273 EventDescriptor descA = new MockEventDescriptor ("Foo", "B");
274 EventDescriptor descB = new MockEventDescriptor ("Aim", "C");
275 EventDescriptor descC = new MockEventDescriptor ("Bim", "A");
276 EventDescriptor descD = new MockEventDescriptor ("AIm", "E");
277 EventDescriptor descE = new MockEventDescriptor ("Boo", "D");
278 EventDescriptor descF = new MockEventDescriptor ("FOo", "F");
280 EventDescriptor [] props = new EventDescriptor [] {
281 descA, descB, descC, descD, descE, descF };
282 descriptors = new EventDescriptorCollection (props);
284 Assert.AreSame (descA, descriptors [0], "#A1");
285 Assert.AreSame (descB, descriptors [1], "#A2");
286 Assert.AreSame (descC, descriptors [2], "#A3");
287 Assert.AreSame (descD, descriptors [3], "#A4");
288 Assert.AreSame (descE, descriptors [4], "#A5");
289 Assert.AreSame (descF, descriptors [5], "#A6");
291 sorted = descriptors.Sort (new CategoryComparer ());
293 Assert.AreSame (descA, descriptors [0], "#B1");
294 Assert.AreSame (descB, descriptors [1], "#B2");
295 Assert.AreSame (descC, descriptors [2], "#B3");
296 Assert.AreSame (descD, descriptors [3], "#B4");
297 Assert.AreSame (descE, descriptors [4], "#B5");
298 Assert.AreSame (descF, descriptors [5], "#B6");
300 Assert.AreSame (descC, sorted [0], "#C1");
301 Assert.AreSame (descA, sorted [1], "#C2");
302 Assert.AreSame (descB, sorted [2], "#C3");
303 Assert.AreSame (descE, sorted [3], "#C4");
304 Assert.AreSame (descD, sorted [4], "#C5");
305 Assert.AreSame (descF, sorted [5], "#C6");
307 sorted = descriptors.Sort ((Comparer) null);
309 Assert.AreSame (descA, descriptors [0], "#D1");
310 Assert.AreSame (descB, descriptors [1], "#D2");
311 Assert.AreSame (descC, descriptors [2], "#D3");
312 Assert.AreSame (descD, descriptors [3], "#D4");
313 Assert.AreSame (descE, descriptors [4], "#D5");
314 Assert.AreSame (descF, descriptors [5], "#D6");
316 Assert.AreSame (descB, sorted [0], "#E1");
317 Assert.AreSame (descD, sorted [1], "#E2");
318 Assert.AreSame (descC, sorted [2], "#E3");
319 Assert.AreSame (descE, sorted [3], "#E4");
320 Assert.AreSame (descA, sorted [4], "#E5");
321 Assert.AreSame (descF, sorted [5], "#E6");
324 [Test] // Sort (String [], IComparer)
327 EventDescriptorCollection descriptors;
328 EventDescriptorCollection sorted;
330 EventDescriptor descA = new MockEventDescriptor ("Foo", "B");
331 EventDescriptor descB = new MockEventDescriptor ("Aim", "C");
332 EventDescriptor descC = new MockEventDescriptor ("Bim", "A");
333 EventDescriptor descD = new MockEventDescriptor ("AIm", "E");
334 EventDescriptor descE = new MockEventDescriptor ("Boo", "D");
335 EventDescriptor descF = new MockEventDescriptor ("FOo", "F");
337 EventDescriptor [] props = new EventDescriptor [] {
338 descA, descB, descC, descD, descE, descF };
339 descriptors = new EventDescriptorCollection (props);
341 Assert.AreSame (descA, descriptors [0], "#A1");
342 Assert.AreSame (descB, descriptors [1], "#A2");
343 Assert.AreSame (descC, descriptors [2], "#A3");
344 Assert.AreSame (descD, descriptors [3], "#A4");
345 Assert.AreSame (descE, descriptors [4], "#A5");
346 Assert.AreSame (descF, descriptors [5], "#A6");
348 sorted = descriptors.Sort (new string [] { "B", "Foo", null, "A", "Boo" },
349 new CategoryComparer ());
351 Assert.AreSame (descA, descriptors [0], "#B1");
352 Assert.AreSame (descB, descriptors [1], "#B2");
353 Assert.AreSame (descC, descriptors [2], "#B3");
354 Assert.AreSame (descD, descriptors [3], "#B4");
355 Assert.AreSame (descE, descriptors [4], "#B5");
356 Assert.AreSame (descF, descriptors [5], "#B6");
358 Assert.AreSame (descA, sorted [0], "#C1");
359 Assert.AreSame (descE, sorted [1], "#C2");
360 Assert.AreSame (descC, sorted [2], "#C3");
361 Assert.AreSame (descB, sorted [3], "#C4");
362 Assert.AreSame (descD, sorted [4], "#C5");
363 Assert.AreSame (descF, sorted [5], "#C6");
365 sorted = descriptors.Sort ((string []) null, new CategoryComparer ());
367 Assert.AreSame (descA, descriptors [0], "#D1");
368 Assert.AreSame (descB, descriptors [1], "#D2");
369 Assert.AreSame (descC, descriptors [2], "#D3");
370 Assert.AreSame (descD, descriptors [3], "#D4");
371 Assert.AreSame (descE, descriptors [4], "#D5");
372 Assert.AreSame (descF, descriptors [5], "#D6");
374 Assert.AreSame (descC, sorted [0], "#E1");
375 Assert.AreSame (descA, sorted [1], "#E2");
376 Assert.AreSame (descB, sorted [2], "#E3");
377 Assert.AreSame (descE, sorted [3], "#E4");
378 Assert.AreSame (descD, sorted [4], "#E5");
379 Assert.AreSame (descF, sorted [5], "#E6");
381 sorted = descriptors.Sort (new string [] { "B", "Foo", null, "A", "Boo" },
384 Assert.AreSame (descA, descriptors [0], "#F1");
385 Assert.AreSame (descB, descriptors [1], "#F2");
386 Assert.AreSame (descC, descriptors [2], "#F3");
387 Assert.AreSame (descD, descriptors [3], "#F4");
388 Assert.AreSame (descE, descriptors [4], "#F5");
389 Assert.AreSame (descF, descriptors [5], "#F6");
391 Assert.AreSame (descA, sorted [0], "#G1");
392 Assert.AreSame (descE, sorted [1], "#G2");
393 Assert.AreSame (descB, sorted [2], "#G3");
394 Assert.AreSame (descD, sorted [3], "#G4");
395 Assert.AreSame (descC, sorted [4], "#G5");
396 Assert.AreSame (descF, sorted [5], "#G6");
398 sorted = descriptors.Sort ((string []) null, (Comparer) null);
400 Assert.AreSame (descA, descriptors [0], "#H1");
401 Assert.AreSame (descB, descriptors [1], "#H2");
402 Assert.AreSame (descC, descriptors [2], "#H3");
403 Assert.AreSame (descD, descriptors [3], "#H4");
404 Assert.AreSame (descE, descriptors [4], "#H5");
405 Assert.AreSame (descF, descriptors [5], "#H6");
407 Assert.AreSame (descB, sorted [0], "#I1");
408 Assert.AreSame (descD, sorted [1], "#I2");
409 Assert.AreSame (descC, sorted [2], "#I3");
410 Assert.AreSame (descE, sorted [3], "#I4");
411 Assert.AreSame (descA, sorted [4], "#I5");
412 Assert.AreSame (descF, sorted [5], "#I6");
415 private void AssertReadOnly (EventDescriptorCollection descriptors, string testCase)
417 MockEventDescriptor desc = new MockEventDescriptor (
421 descriptors.Add (desc);
422 Assert.Fail (testCase + "#1");
423 } catch (NotSupportedException) {
424 // read-only collection cannot be modified
427 // ensure read-only check if performed before value is checked
429 descriptors.Add (null);
430 Assert.Fail (testCase + "#2");
431 } catch (NotSupportedException) {
432 // read-only collection cannot be modified
436 descriptors.Clear ();
437 Assert.Fail (testCase + "#3");
438 } catch (NotSupportedException) {
439 // read-only collection cannot be modified
443 descriptors.Insert (0, desc);
444 Assert.Fail (testCase + "#4");
445 } catch (NotSupportedException) {
446 // read-only collection cannot be modified
449 // ensure read-only check if performed before value is checked
451 descriptors.Insert (0, null);
452 Assert.Fail (testCase + "#5");
453 } catch (NotSupportedException) {
454 // read-only collection cannot be modified
458 descriptors.Remove (desc);
459 Assert.Fail (testCase + "#6");
460 } catch (NotSupportedException) {
461 // read-only collection cannot be modified
464 // ensure read-only check if performed before value is checked
466 descriptors.Remove (null);
467 Assert.Fail (testCase + "#7");
468 } catch (NotSupportedException) {
469 // read-only collection cannot be modified
473 descriptors.RemoveAt (0);
474 Assert.Fail (testCase + "#8");
475 } catch (NotSupportedException) {
476 // read-only collection cannot be modified
479 IList list = (IList) descriptors;
480 Assert.IsTrue (((IList) descriptors).IsReadOnly, testCase + "#9");
482 Assert.IsTrue (((IList) descriptors).IsFixedSize, testCase + "#10");
484 Assert.IsFalse (((IList) descriptors).IsFixedSize, testCase + "#10");
489 Assert.Fail (testCase + "#11");
490 } catch (NotSupportedException) {
491 // read-only collection cannot be modified
494 // ensure read-only check if performed before value is checked
497 Assert.Fail (testCase + "#12");
498 } catch (NotSupportedException) {
499 // read-only collection cannot be modified
504 Assert.Fail (testCase + "#13");
505 } catch (NotSupportedException) {
506 // read-only collection cannot be modified
510 list.Insert (0, desc);
511 Assert.Fail (testCase + "#14");
512 } catch (NotSupportedException) {
513 // read-only collection cannot be modified
516 // ensure read-only check if performed before value is checked
518 list.Insert (0, null);
519 Assert.Fail (testCase + "#15");
520 } catch (NotSupportedException) {
521 // read-only collection cannot be modified
526 Assert.Fail (testCase + "#16");
527 } catch (NotSupportedException) {
528 // read-only collection cannot be modified
531 // ensure read-only check if performed before value is checked
534 Assert.Fail (testCase + "#17");
535 } catch (NotSupportedException) {
536 // read-only collection cannot be modified
541 Assert.Fail (testCase + "#18");
542 } catch (NotSupportedException) {
543 // read-only collection cannot be modified
548 Assert.Fail (testCase + "#19");
549 } catch (NotSupportedException) {
550 // read-only collection cannot be modified
553 // ensure read-only check if performed before value is checked
556 Assert.Fail (testCase + "#20");
557 } catch (NotSupportedException) {
558 // read-only collection cannot be modified
562 private class MockEventDescriptor : EventDescriptor
564 public MockEventDescriptor (string name, string category)
565 : base (name, new Attribute [] { new CategoryAttribute (category) })
569 public override Type ComponentType {
575 public override Type EventType {
581 public override bool IsMulticast {
587 public override void AddEventHandler (object component, Delegate value)
591 public override void RemoveEventHandler (object component, Delegate value)
596 class CategoryComparer : IComparer
598 public int Compare (object x, object y)
600 EventDescriptor descX = x as EventDescriptor;
601 EventDescriptor descY = y as EventDescriptor;
603 if (descX == null && descY == null)
610 return string.Compare (descX.Category, descY.Category, false, CultureInfo.CurrentCulture);