2 // System.ComponentModel.EnumConverter test cases
5 // Gert Driesen (drieseng@users.sourceforge.net)
7 // (c) 2007 Gert Driesen
11 using System.ComponentModel;
12 using System.ComponentModel.Design.Serialization;
13 using System.Globalization;
14 using System.Reflection;
16 using NUnit.Framework;
18 namespace MonoTests.System.ComponentModel
21 public class EnumConverterTests
24 public void CanConvertFrom ()
26 EnumConverter converter = new EnumConverter (typeof (E));
27 Assert.IsTrue (converter.CanConvertFrom (typeof (string)), "#A1");
28 Assert.IsFalse (converter.CanConvertFrom (typeof (Enum)), "#A2");
29 Assert.IsFalse (converter.CanConvertFrom (typeof (object)), "#A3");
30 Assert.IsFalse (converter.CanConvertFrom (typeof (int)), "#A4");
31 Assert.IsTrue (converter.CanConvertFrom (typeof (InstanceDescriptor)), "#A5");
32 Assert.IsFalse (converter.CanConvertFrom (typeof (string [])), "#A6");
34 Assert.IsTrue (converter.CanConvertFrom (typeof (Enum [])), "#A7");
36 Assert.IsFalse (converter.CanConvertFrom (typeof (Enum [])), "#A7");
39 converter = new EnumConverter (typeof (E2));
40 Assert.IsTrue (converter.CanConvertFrom (typeof (string)), "#B1");
41 Assert.IsFalse (converter.CanConvertFrom (typeof (Enum)), "#B2");
42 Assert.IsFalse (converter.CanConvertFrom (typeof (object)), "#B3");
43 Assert.IsFalse (converter.CanConvertFrom (typeof (int)), "#B4");
44 Assert.IsTrue (converter.CanConvertFrom (typeof (InstanceDescriptor)), "#B5");
45 Assert.IsFalse (converter.CanConvertFrom (typeof (string [])), "#B6");
47 Assert.IsTrue (converter.CanConvertFrom (typeof (Enum [])), "#B7");
49 Assert.IsFalse (converter.CanConvertFrom (typeof (Enum [])), "#B7");
54 public void CanConvertTo ()
56 EnumConverter converter = new EnumConverter (typeof (E));
57 Assert.IsTrue (converter.CanConvertTo (typeof (string)), "#A1");
58 Assert.IsFalse (converter.CanConvertTo (typeof (Enum)), "#A2");
59 Assert.IsFalse (converter.CanConvertTo (typeof (object)), "#A3");
60 Assert.IsFalse (converter.CanConvertTo (typeof (int)), "#A4");
61 Assert.IsTrue (converter.CanConvertTo (typeof (InstanceDescriptor)), "#A5");
62 Assert.IsFalse (converter.CanConvertTo (typeof (string [])), "#A6");
64 Assert.IsTrue (converter.CanConvertTo (typeof (Enum [])), "#A7");
66 Assert.IsFalse (converter.CanConvertTo (typeof (Enum [])), "#A7");
69 converter = new EnumConverter (typeof (E2));
70 Assert.IsTrue (converter.CanConvertTo (typeof (string)), "#B1");
71 Assert.IsFalse (converter.CanConvertTo (typeof (Enum)), "#B2");
72 Assert.IsFalse (converter.CanConvertTo (typeof (object)), "#B3");
73 Assert.IsFalse (converter.CanConvertTo (typeof (object)), "#B4");
74 Assert.IsTrue (converter.CanConvertTo (typeof (InstanceDescriptor)), "#B5");
75 Assert.IsFalse (converter.CanConvertTo (typeof (string [])), "#B6");
77 Assert.IsTrue (converter.CanConvertTo (typeof (Enum [])), "#B7");
79 Assert.IsFalse (converter.CanConvertTo (typeof (Enum [])), "#B7");
84 public void ConvertFrom_Null ()
86 EnumConverter converter = new EnumConverter (typeof (E));
88 converter.ConvertFrom (null, CultureInfo.InvariantCulture, null);
90 } catch (NotSupportedException ex) {
91 // EnumConverter cannot convert from (null)
92 Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#2");
93 Assert.IsNull (ex.InnerException, "#3");
94 Assert.IsNotNull (ex.Message, "#4");
95 Assert.IsTrue (ex.Message.IndexOf (typeof (EnumConverter).Name) != -1, "#5");
96 Assert.IsTrue (ex.Message.IndexOf ("(null)") != -1, "#6");
102 public void ConvertFrom_EnumArray ()
104 EnumConverter converter = new EnumConverter (typeof (E));
105 Assert.AreEqual (E.Aa, converter.ConvertFrom (null,
106 CultureInfo.InvariantCulture,
107 (Enum []) new Enum [] { E.Aa }), "#A1");
108 Assert.AreEqual ((E) 8, converter.ConvertFrom (null,
109 CultureInfo.InvariantCulture,
110 (Enum []) new Enum [] { E.Aa, E2.Dd }), "#A2");
111 Assert.AreEqual ((E) 958, converter.ConvertFrom (null,
112 CultureInfo.InvariantCulture,
113 (Enum []) new Enum [] { (E2) 444, (E) 666 }), "#A3");
114 Assert.AreEqual ((E) 0, converter.ConvertFrom (null,
115 CultureInfo.InvariantCulture,
116 (Enum []) new Enum [0]), "#A4");
118 converter = new EnumConverter (typeof (E2));
119 Assert.AreEqual ((E2) 0, converter.ConvertFrom (null,
120 CultureInfo.InvariantCulture,
121 (Enum []) new Enum [] { E.Aa }), "#B1");
122 Assert.AreEqual (E2.Dd, converter.ConvertFrom (null,
123 CultureInfo.InvariantCulture,
124 (Enum []) new Enum [] { E.Aa, E2.Dd }), "#B2");
125 Assert.AreEqual ((E2) 958, converter.ConvertFrom (null,
126 CultureInfo.InvariantCulture,
127 (Enum []) new Enum [] { (E2) 444, (E) 666 }), "#B3");
128 Assert.AreEqual ((E2) 0, converter.ConvertFrom (null,
129 CultureInfo.InvariantCulture,
130 (Enum []) new Enum [0]), "#B4");
131 Assert.AreEqual (E2.Bb | E2.Dd, converter.ConvertFrom (null,
132 CultureInfo.InvariantCulture,
133 (Enum []) new Enum [] { E2.Bb, E2.Dd }), "#B5");
138 public void ConvertFrom_String ()
140 EnumConverter converter = new EnumConverter (typeof (E));
141 Assert.AreEqual (E.Bb, converter.ConvertFrom (null, CultureInfo.InvariantCulture, "Bb"), "#A1");
142 Assert.AreEqual (E.Cc, converter.ConvertFrom (null, CultureInfo.InvariantCulture, "2"), "#A2");
143 Assert.AreEqual (E.Bb, converter.ConvertFrom (null, CultureInfo.InvariantCulture, " Bb "), "#A3");
144 Assert.AreEqual (E.Dd, converter.ConvertFrom (null, CultureInfo.InvariantCulture, " 3 "), "#A4");
145 Assert.AreEqual ((E) 666, converter.ConvertFrom (null, CultureInfo.InvariantCulture, "666"), "#A5");
146 Assert.AreEqual (E.Dd, converter.ConvertFrom (null, CultureInfo.InvariantCulture, "Bb,Dd"), "#A6");
147 Assert.AreEqual (E.Dd, converter.ConvertFrom (null, CultureInfo.InvariantCulture, "Dd,Bb"), "#A7");
148 Assert.AreEqual (E.Bb, converter.ConvertFrom (null, CultureInfo.InvariantCulture, "Aa,Bb"), "#A8");
151 converter.ConvertFrom (null, CultureInfo.InvariantCulture, string.Empty);
154 } catch (FormatException ex) {
155 // is not a valid value for E
156 Assert.AreEqual (typeof (FormatException), ex.GetType (), "#B2");
157 Assert.IsNotNull (ex.InnerException, "#B3");
158 Assert.AreEqual (typeof (ArgumentException), ex.InnerException.GetType (), "#B4");
159 Assert.IsNotNull (ex.Message, "#B5");
160 Assert.IsTrue (ex.Message.IndexOf ("E") != -1, "#B6");
162 // Must specify valid information for parsing in the string
163 ArgumentException inner = (ArgumentException) ex.InnerException;
164 Assert.IsNull (inner.InnerException, "#B7");
165 Assert.IsNotNull (inner.Message, "#B8");
168 } catch (ArgumentException ex) {
169 // Must specify valid information for parsing in the string
170 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
171 Assert.IsNull (ex.InnerException, "#B3");
172 Assert.IsNotNull (ex.Message, "#B4");
177 converter.ConvertFrom (null, CultureInfo.InvariantCulture, "YY");
180 } catch (FormatException ex) {
181 // YY is not a valid value for E
182 Assert.AreEqual (typeof (FormatException), ex.GetType (), "#C2");
183 Assert.IsNotNull (ex.InnerException, "#C3");
184 Assert.AreEqual (typeof (ArgumentException), ex.InnerException.GetType (), "#C4");
185 Assert.IsNotNull (ex.Message, "#C5");
186 Assert.IsTrue (ex.Message.IndexOf ("YY") != -1, "#C6");
187 Assert.IsTrue (ex.Message.IndexOf ("E") != -1, "#C7");
189 // Requested value YY was not found
190 ArgumentException inner = (ArgumentException) ex.InnerException;
191 //Assert.IsNull (inner.InnerException, "#C8");
192 Assert.IsNotNull (inner.Message, "#C9");
193 Assert.IsTrue (inner.Message.IndexOf ("YY") != -1, "#C10");
194 Assert.IsNull (inner.ParamName, "#C11");
197 } catch (ArgumentException ex) {
198 // Requested value YY was not found
199 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
200 //Assert.IsNull (ex.InnerException, "#C3");
201 Assert.IsNotNull (ex.Message, "#C4");
202 Assert.IsTrue (ex.Message.IndexOf ("YY") != -1, "#C5");
203 Assert.IsNull (ex.ParamName, "#C6");
210 [NUnit.Framework.Category("NotWorking")]
212 public void ConvertFrom_String_Flags ()
214 EnumConverter converter = new EnumConverter (typeof (E2));
215 Assert.AreEqual (E2.Cc, converter.ConvertFrom (null, CultureInfo.InvariantCulture, "Cc"), "#B1");
216 Assert.AreEqual (E2.Dd, converter.ConvertFrom (null, CultureInfo.InvariantCulture, "8"), "#B2");
217 Assert.AreEqual (E2.Cc | E2.Dd, converter.ConvertFrom (null, CultureInfo.InvariantCulture, "Cc,Dd"), "#B3");
218 Assert.AreEqual (E2.Aa | E2.Bb, converter.ConvertFrom (null, CultureInfo.InvariantCulture, "3"), "#B4");
219 Assert.AreEqual (E2.Bb | E2.Cc, converter.ConvertFrom (null, CultureInfo.InvariantCulture, "2,4"), "#B5");
220 Assert.AreEqual (E2.Aa | E2.Dd, converter.ConvertFrom (null, CultureInfo.InvariantCulture, " 1 , 8 "), "#B5");
221 Assert.AreEqual ((E2) 666, converter.ConvertFrom (null, CultureInfo.InvariantCulture, "666"), "#B6");
222 Assert.AreEqual (E2.Cc | E2.Dd, converter.ConvertFrom (null, CultureInfo.InvariantCulture, " Dd , Cc "), "#B7");
223 Assert.AreEqual (E2.Bb, converter.ConvertFrom (null, CultureInfo.InvariantCulture, " Bb "), "#B8");
224 Assert.AreEqual (E2.Aa | E2.Bb, converter.ConvertFrom (null, CultureInfo.InvariantCulture, " 3 "), "#B9");
227 converter.ConvertFrom (null, CultureInfo.InvariantCulture, string.Empty);
230 } catch (FormatException ex) {
231 // is not a valid value for E2
232 Assert.AreEqual (typeof (FormatException), ex.GetType (), "#B2");
233 Assert.IsNotNull (ex.InnerException, "#B3");
234 Assert.AreEqual (typeof (ArgumentException), ex.InnerException.GetType (), "#B4");
235 Assert.IsNotNull (ex.Message, "#B5");
236 Assert.IsTrue (ex.Message.IndexOf ("E2") != -1, "#B6");
238 // Must specify valid information for parsing in the string
239 ArgumentException inner = (ArgumentException) ex.InnerException;
240 Assert.IsNull (inner.InnerException, "#B7");
241 Assert.IsNotNull (inner.Message, "#B8");
244 } catch (ArgumentException ex) {
245 // Must specify valid information for parsing in the string
246 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
247 Assert.IsNull (ex.InnerException, "#B3");
248 Assert.IsNotNull (ex.Message, "#B4");
253 converter.ConvertFrom (null, CultureInfo.InvariantCulture, "Aa Bb");
256 } catch (FormatException ex) {
257 // Aa Bb is not a valid value for E2
258 Assert.AreEqual (typeof (FormatException), ex.GetType (), "#C2");
259 Assert.IsNotNull (ex.InnerException, "#C3");
260 Assert.AreEqual (typeof (ArgumentException), ex.InnerException.GetType (), "#C4");
261 Assert.IsNotNull (ex.Message, "#C5");
262 Assert.IsTrue (ex.Message.IndexOf ("Aa Bb") != -1, "#C6");
263 Assert.IsTrue (ex.Message.IndexOf ("E2") != -1, "#C7");
265 // Requested value Aa Bb was not found
266 ArgumentException inner = (ArgumentException) ex.InnerException;
267 Assert.IsNotNull (inner.Message, "#C9");
268 Assert.IsTrue (inner.Message.IndexOf ("Aa Bb") != -1, "#C10");
269 Assert.IsNull (inner.ParamName, "#C11");
272 } catch (ArgumentException ex) {
273 // Requested value Aa Bb was not found
274 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
275 Assert.IsNotNull (ex.Message, "#C3");
276 Assert.IsTrue (ex.Message.IndexOf ("Aa Bb") != -1, "#C4");
277 Assert.IsNull (ex.ParamName, "#C5");
282 converter.ConvertFrom (null, CultureInfo.InvariantCulture, "2,");
285 } catch (FormatException ex) {
286 // 2, is not a valid value for E2
287 Assert.AreEqual (typeof (FormatException), ex.GetType (), "#D2");
288 Assert.IsNotNull (ex.InnerException, "#D3");
289 Assert.AreEqual (typeof (ArgumentException), ex.InnerException.GetType (), "#D4");
290 Assert.IsNotNull (ex.Message, "#D5");
291 Assert.IsTrue (ex.Message.IndexOf ("2,") != -1, "#D6");
292 Assert.IsTrue (ex.Message.IndexOf ("E2") != -1, "#D7");
294 // Must specify valid information for parsing in the string
295 ArgumentException inner = (ArgumentException) ex.InnerException;
296 Assert.IsNull (inner.InnerException, "#D8");
297 Assert.IsNotNull (inner.Message, "#D9");
298 Assert.IsFalse (inner.Message.IndexOf ("2,") != -1, "#D10");
301 } catch (ArgumentException ex) {
302 // Must specify valid information for parsing in the string
303 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#D2");
304 Assert.IsNull (ex.InnerException, "#D3");
305 Assert.IsNotNull (ex.Message, "#D4");
306 Assert.IsFalse (ex.Message.IndexOf ("2,") != -1, "#D5");
313 public void ConvertTo_EnumArray ()
316 EnumConverter converter = new EnumConverter (typeof (E));
318 enums = converter.ConvertTo (null, CultureInfo.InvariantCulture,
319 E.Bb, typeof (Enum [])) as Enum [];
320 Assert.IsNotNull (enums, "#A1");
321 Assert.AreEqual (1, enums.Length, "#A2");
322 Assert.AreEqual (typeof (E), enums [0].GetType (), "#A3");
323 Assert.AreEqual (E.Bb, enums [0], "#A4");
325 enums = converter.ConvertTo (null, CultureInfo.InvariantCulture,
326 2, typeof (Enum [])) as Enum [];
327 Assert.IsNotNull (enums, "#B1");
328 Assert.AreEqual (1, enums.Length, "#B2");
329 Assert.AreEqual (typeof (E), enums [0].GetType (), "#B3");
330 Assert.AreEqual (E.Cc, enums [0], "#B4");
333 enums = converter.ConvertTo (null, CultureInfo.InvariantCulture,
334 "2", typeof (Enum [])) as Enum [];
336 } catch (ArgumentException ex) {
337 // The value passed in must be an enum base or an
338 // underlying type for an enum, such as an Int32
339 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
340 Assert.IsNull (ex.InnerException, "#C3");
341 Assert.IsNotNull (ex.Message, "#C4");
342 Assert.IsNotNull (ex.ParamName, "#C5");
343 Assert.AreEqual ("value", ex.ParamName, "#C6");
347 converter.ConvertTo (null, CultureInfo.InvariantCulture,
348 null, typeof (Enum []));
350 } catch (NotSupportedException ex) {
351 // 'EnumConverter' is unable to convert '(null)'
352 // to 'System.Enum[]'
353 Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#D2");
354 Assert.IsNull (ex.InnerException, "#D3");
355 Assert.IsNotNull (ex.Message, "#D4");
356 Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (EnumConverter).Name + "'") != -1, "#D5");
357 Assert.IsTrue (ex.Message.IndexOf ("'(null)'") != -1, "#D6");
358 Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (Enum []).FullName + "'") != -1, "#D7");
362 converter.ConvertTo (null, CultureInfo.InvariantCulture,
363 "Cc", typeof (Enum []));
365 } catch (ArgumentException ex) {
366 // The value passed in must be an enum base or an
367 // underlying type for an enum, such as an Int32
368 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#E2");
369 Assert.IsNull (ex.InnerException, "#E3");
370 Assert.IsNotNull (ex.Message, "#E4");
371 Assert.IsNotNull (ex.ParamName, "#E5");
372 Assert.AreEqual ("value", ex.ParamName, "#E6");
377 public void ConvertTo_EnumArray_Flags ()
380 EnumConverter converter = new EnumConverter (typeof (E2));
382 enums = converter.ConvertTo (null, CultureInfo.InvariantCulture,
383 E.Bb, typeof (Enum [])) as Enum [];
384 Assert.IsNotNull (enums, "#A1");
385 Assert.AreEqual (1, enums.Length, "#A2");
386 Assert.AreEqual (typeof (E2), enums [0].GetType (), "#A3");
387 Assert.AreEqual (E2.Aa, enums [0], "#A4");
389 enums = converter.ConvertTo (null, CultureInfo.InvariantCulture,
390 E2.Bb, typeof (Enum [])) as Enum [];
391 Assert.IsNotNull (enums, "#B1");
392 Assert.AreEqual (1, enums.Length, "#B2");
393 Assert.AreEqual (typeof (E2), enums [0].GetType (), "#B3");
394 Assert.AreEqual (E2.Bb, enums [0], "#B4");
396 enums = converter.ConvertTo (null, CultureInfo.InvariantCulture,
397 (E2) 0, typeof (Enum [])) as Enum [];
398 Assert.IsNotNull (enums, "#C1");
399 Assert.AreEqual (0, enums.Length, "#C2");
401 enums = converter.ConvertTo (null, CultureInfo.InvariantCulture,
402 (E2) 18, typeof (Enum [])) as Enum [];
403 Assert.IsNotNull (enums, "#D1");
404 Assert.AreEqual (2, enums.Length, "#D2");
405 Assert.AreEqual (typeof (E2), enums [0].GetType (), "#D3");
406 Assert.AreEqual (E2.Bb, enums [0], "#D4");
407 Assert.AreEqual (typeof (E2), enums [1].GetType (), "#D5");
408 Assert.AreEqual ((E2) 16, enums [1], "#D6");
411 enums = converter.ConvertTo (null, CultureInfo.InvariantCulture,
412 5, typeof (Enum [])) as Enum [];
414 } catch (InvalidCastException ex) {
415 // Unable to cast object of type 'System.Int32'
416 // to type 'System.Enum'
417 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#E2");
418 Assert.IsNull (ex.InnerException, "#E3");
419 Assert.IsNotNull (ex.Message, "#E4");
423 enums = converter.ConvertTo (null, CultureInfo.InvariantCulture,
424 "2", typeof (Enum [])) as Enum [];
426 } catch (InvalidCastException ex) {
427 // Unable to cast object of type 'System.String'
428 // to type 'System.Enum'
429 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#F2");
430 Assert.IsNull (ex.InnerException, "#F3");
431 Assert.IsNotNull (ex.Message, "#F4");
435 converter.ConvertTo (null, CultureInfo.InvariantCulture,
436 null, typeof (Enum []));
438 } catch (NotSupportedException ex) {
439 // 'EnumConverter' is unable to convert '(null)'
440 // to 'System.Enum[]'
441 Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#G2");
442 Assert.IsNull (ex.InnerException, "#G3");
443 Assert.IsNotNull (ex.Message, "#G4");
444 Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (EnumConverter).Name + "'") != -1, "#G5");
445 Assert.IsTrue (ex.Message.IndexOf ("'(null)'") != -1, "#G6");
446 Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (Enum []).FullName + "'") != -1, "#G7");
450 converter.ConvertTo (null, CultureInfo.InvariantCulture,
451 "Bb,Cc", typeof (Enum []));
453 } catch (InvalidCastException ex) {
454 // Unable to cast object of type 'System.String'
455 // to type 'System.Enum'
456 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#H2");
457 Assert.IsNull (ex.InnerException, "#H3");
458 Assert.IsNotNull (ex.Message, "#H4");
462 converter.ConvertTo (null, CultureInfo.InvariantCulture,
463 "2,4", typeof (Enum []));
465 } catch (InvalidCastException ex) {
466 // Unable to cast object of type 'System.String'
467 // to type 'System.Enum'
468 Assert.AreEqual (typeof (InvalidCastException), ex.GetType (), "#I2");
469 Assert.IsNull (ex.InnerException, "#I3");
470 Assert.IsNotNull (ex.Message, "#I4");
473 converter = new EnumConverter (typeof (F2));
475 enums = converter.ConvertTo (null, CultureInfo.InvariantCulture,
476 (F2) 15, typeof (Enum [])) as Enum [];
477 Assert.IsNotNull (enums, "#J1");
478 Assert.AreEqual (3, enums.Length, "#J2");
479 Assert.AreEqual (typeof (F2), enums [0].GetType (), "#J3");
480 Assert.AreEqual (F2.Bb, enums [0], "#J4");
481 Assert.AreEqual (typeof (F2), enums [1].GetType (), "#J5");
482 Assert.AreEqual (F2.Dd, enums [1], "#J6");
483 Assert.AreEqual (typeof (F2), enums [2].GetType (), "#J5");
484 Assert.AreEqual ((F2) 5, enums [2], "#J6");
489 public void ConvertTo_InstanceDescriptor ()
491 InstanceDescriptor idesc;
493 EnumConverter converter = new EnumConverter (typeof (E));
495 idesc = converter.ConvertTo (null, CultureInfo.InvariantCulture,
496 E.Bb, typeof (InstanceDescriptor)) as InstanceDescriptor;
497 Assert.IsNotNull (idesc, "#A1");
498 Assert.IsNotNull (idesc.Arguments, "#A2");
499 Assert.AreEqual (0, idesc.Arguments.Count, "#A3");
500 Assert.AreEqual (typeof (object []), idesc.Arguments.GetType (), "#A4");
501 Assert.IsTrue (idesc.IsComplete, "#A5");
502 fi = idesc.MemberInfo as FieldInfo;
503 Assert.IsNotNull (fi, "#A6");
504 Assert.AreEqual (typeof (E), fi.DeclaringType, "#A7");
505 Assert.AreEqual (typeof (E), fi.FieldType, "#A8");
506 Assert.IsTrue (fi.IsStatic, "#A9");
507 Assert.AreEqual ("Bb", fi.Name, "#A10");
508 Assert.AreEqual (E.Bb, fi.GetValue (null), "#A11");
511 idesc = converter.ConvertTo (null, CultureInfo.InvariantCulture,
512 "2", typeof (InstanceDescriptor)) as InstanceDescriptor;
513 Assert.IsNotNull (idesc, "#B1");
514 Assert.IsNotNull (idesc.Arguments, "#B2");
515 Assert.AreEqual (0, idesc.Arguments.Count, "#B3");
516 Assert.AreEqual (typeof (object []), idesc.Arguments.GetType (), "#B4");
517 Assert.IsTrue (idesc.IsComplete, "#B5");
518 fi = idesc.MemberInfo as FieldInfo;
519 Assert.IsNotNull (fi, "#B6");
520 Assert.AreEqual (typeof (E), fi.DeclaringType, "#B7");
521 Assert.AreEqual (typeof (E), fi.FieldType, "#B8");
522 Assert.IsTrue (fi.IsStatic, "#B9");
523 Assert.AreEqual ("Cc", fi.Name, "#B10");
524 Assert.AreEqual (E.Cc, fi.GetValue (null), "#B11");
527 idesc = converter.ConvertTo (null, CultureInfo.InvariantCulture,
528 2, typeof (InstanceDescriptor)) as InstanceDescriptor;
529 Assert.IsNotNull (idesc, "#C1");
530 Assert.IsNotNull (idesc.Arguments, "#C2");
531 Assert.AreEqual (0, idesc.Arguments.Count, "#C3");
532 Assert.AreEqual (typeof (object []), idesc.Arguments.GetType (), "#C4");
533 Assert.IsTrue (idesc.IsComplete, "#C5");
534 fi = idesc.MemberInfo as FieldInfo;
535 Assert.IsNotNull (fi, "#C6");
536 Assert.AreEqual (typeof (E), fi.DeclaringType, "#C7");
537 Assert.AreEqual (typeof (E), fi.FieldType, "#C8");
538 Assert.IsTrue (fi.IsStatic, "#C9");
539 Assert.AreEqual ("Cc", fi.Name, "#C10");
540 Assert.AreEqual (E.Cc, fi.GetValue (null), "#C11");
542 idesc = converter.ConvertTo (null, CultureInfo.InvariantCulture,
543 (E) 2, typeof (InstanceDescriptor)) as InstanceDescriptor;
544 Assert.IsNotNull (idesc, "#D1");
545 Assert.IsNotNull (idesc.Arguments, "#D2");
546 Assert.AreEqual (0, idesc.Arguments.Count, "#D3");
547 Assert.AreEqual (typeof (object []), idesc.Arguments.GetType (), "#D4");
548 Assert.IsTrue (idesc.IsComplete, "#D5");
549 fi = idesc.MemberInfo as FieldInfo;
550 Assert.IsNotNull (fi, "#D6");
551 Assert.AreEqual (typeof (E), fi.DeclaringType, "#D7");
552 Assert.AreEqual (typeof (E), fi.FieldType, "#D8");
553 Assert.IsTrue (fi.IsStatic, "#D9");
554 Assert.AreEqual ("Cc", fi.Name, "#D10");
555 Assert.AreEqual (E.Cc, fi.GetValue (null), "#D11");
558 converter.ConvertTo (null, CultureInfo.InvariantCulture,
559 null, typeof (InstanceDescriptor));
561 } catch (NotSupportedException ex) {
562 // 'EnumConverter' is unable to convert '(null)'
563 // to 'System.ComponentModel.Design.Serialization.InstanceDescriptor'
564 Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#E2");
565 Assert.IsNull (ex.InnerException, "#E3");
566 Assert.IsNotNull (ex.Message, "#E4");
567 Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (EnumConverter).Name + "'") != -1, "#E5");
568 Assert.IsTrue (ex.Message.IndexOf ("'(null)'") != -1, "#E6");
569 Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (InstanceDescriptor).FullName + "'") != -1, "#E7");
573 converter.ConvertTo (null, CultureInfo.InvariantCulture,
574 "5", typeof (InstanceDescriptor));
576 } catch (ArgumentException ex) {
577 // The value '5' is not a valid value for the enum 'E'
578 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#F2");
579 Assert.IsNull (ex.InnerException, "#F3");
580 Assert.IsNotNull (ex.Message, "#F4");
581 Assert.IsTrue (ex.Message.IndexOf ("'5'") != -1, "#F5");
582 Assert.IsTrue (ex.Message.IndexOf ("'E'") != -1, "#F6");
583 Assert.IsNull (ex.ParamName, "#F7");
587 converter.ConvertTo (null, CultureInfo.InvariantCulture,
588 "Cc", typeof (InstanceDescriptor));
590 } catch (FormatException ex) {
591 // Input string was not in a correct format
592 Assert.AreEqual (typeof (FormatException), ex.GetType (), "#G2");
593 Assert.IsNull (ex.InnerException, "#G3");
594 Assert.IsNotNull (ex.Message, "#G4");
598 converter.ConvertTo (null, CultureInfo.InvariantCulture,
599 (E) 666, typeof (InstanceDescriptor));
601 } catch (ArgumentException ex) {
602 // The value '666' is not a valid value for the enum 'E'
603 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#F2");
604 Assert.IsNull (ex.InnerException, "#F3");
605 Assert.IsNotNull (ex.Message, "#F4");
606 Assert.IsTrue (ex.Message.IndexOf ("'666'") != -1, "#F5");
607 Assert.IsTrue (ex.Message.IndexOf ("'E'") != -1, "#F6");
608 Assert.IsNull (ex.ParamName, "#F7");
613 public void ConvertTo_InstanceDescriptor_Flags ()
615 InstanceDescriptor idesc;
618 ParameterInfo [] parameters;
620 EnumConverter converter = new EnumConverter (typeof (E2));
622 idesc = converter.ConvertTo (null, CultureInfo.InvariantCulture,
623 E2.Bb, typeof (InstanceDescriptor)) as InstanceDescriptor;
624 Assert.IsNotNull (idesc, "#A1");
625 Assert.IsNotNull (idesc.Arguments, "#A2");
626 Assert.AreEqual (0, idesc.Arguments.Count, "#A3");
627 Assert.AreEqual (typeof (object []), idesc.Arguments.GetType (), "#A4");
628 Assert.IsTrue (idesc.IsComplete, "#A5");
629 fi = idesc.MemberInfo as FieldInfo;
630 Assert.IsNotNull (fi, "#A6");
631 Assert.AreEqual (typeof (E2), fi.DeclaringType, "#A7");
632 Assert.AreEqual (typeof (E2), fi.FieldType, "#A8");
633 Assert.IsTrue (fi.IsStatic, "#A9");
634 Assert.AreEqual ("Bb", fi.Name, "#A10");
635 Assert.AreEqual (E2.Bb, fi.GetValue (null), "#A11");
637 idesc = converter.ConvertTo (null, CultureInfo.InvariantCulture,
638 E.Bb, typeof (InstanceDescriptor)) as InstanceDescriptor;
639 Assert.IsNotNull (idesc, "#B1");
640 Assert.IsNotNull (idesc.Arguments, "#B2");
641 Assert.AreEqual (0, idesc.Arguments.Count, "#B3");
642 Assert.AreEqual (typeof (object []), idesc.Arguments.GetType (), "#B4");
643 Assert.IsTrue (idesc.IsComplete, "#B5");
644 fi = idesc.MemberInfo as FieldInfo;
645 Assert.IsNotNull (fi, "#B6");
646 Assert.AreEqual (typeof (E2), fi.DeclaringType, "#B7");
647 Assert.AreEqual (typeof (E2), fi.FieldType, "#B8");
648 Assert.IsTrue (fi.IsStatic, "#B9");
649 Assert.AreEqual ("Aa", fi.Name, "#B10");
650 Assert.AreEqual (E2.Aa, fi.GetValue (null), "#B11");
652 idesc = converter.ConvertTo (null, CultureInfo.InvariantCulture,
653 E2.Bb | E2.Dd, typeof (InstanceDescriptor))
654 as InstanceDescriptor;
655 Assert.IsNotNull (idesc, "#C1");
656 Assert.IsNotNull (idesc.Arguments, "#C2");
657 Assert.AreEqual (2, idesc.Arguments.Count, "#C3");
658 Assert.AreEqual (typeof (object []), idesc.Arguments.GetType (), "#C4");
659 arguments = (object []) idesc.Arguments;
660 Assert.AreEqual (typeof (E2), arguments [0], "#C5");
661 Assert.AreEqual (typeof (int), arguments [1].GetType (), "#C6");
662 Assert.AreEqual (10, arguments [1], "#C7");
663 Assert.IsTrue (idesc.IsComplete, "#C8");
664 mi = idesc.MemberInfo as MethodInfo;
665 Assert.IsNotNull (mi, "#C9");
666 Assert.AreEqual ("ToObject", mi.Name, "#C10");
667 Assert.AreEqual (typeof (Enum), mi.DeclaringType, "#C11");
668 parameters = mi.GetParameters ();
669 Assert.AreEqual (2, parameters.Length, "#C12");
670 Assert.AreEqual (typeof (Type), parameters [0].ParameterType, "#C13");
671 Assert.AreEqual (typeof (int), parameters [1].ParameterType, "#C14");
673 idesc = converter.ConvertTo (null, CultureInfo.InvariantCulture,
674 "5", typeof (InstanceDescriptor)) as InstanceDescriptor;
675 Assert.IsNotNull (idesc, "#D1");
676 Assert.IsNotNull (idesc.Arguments, "#D2");
677 Assert.AreEqual (2, idesc.Arguments.Count, "#D3");
678 Assert.AreEqual (typeof (object []), idesc.Arguments.GetType (), "#D4");
679 arguments = (object []) idesc.Arguments;
680 Assert.AreEqual (typeof (E2), arguments [0], "#D5");
681 Assert.AreEqual (typeof (int), arguments [1].GetType (), "#D6");
682 Assert.AreEqual (5, arguments [1], "#D7");
683 Assert.IsTrue (idesc.IsComplete, "#D8");
684 mi = idesc.MemberInfo as MethodInfo;
685 Assert.IsNotNull (mi, "#D9");
686 Assert.AreEqual ("ToObject", mi.Name, "#D10");
687 Assert.AreEqual (typeof (Enum), mi.DeclaringType, "#D11");
688 parameters = mi.GetParameters ();
689 Assert.AreEqual (2, parameters.Length, "#D12");
690 Assert.AreEqual (typeof (Type), parameters [0].ParameterType, "#D13");
691 Assert.AreEqual (typeof (int), parameters [1].ParameterType, "#D14");
693 idesc = converter.ConvertTo (null, CultureInfo.InvariantCulture,
694 3, typeof (InstanceDescriptor)) as InstanceDescriptor;
695 Assert.IsNotNull (idesc, "#E1");
696 Assert.IsNotNull (idesc.Arguments, "#E2");
697 Assert.AreEqual (2, idesc.Arguments.Count, "#E3");
698 Assert.AreEqual (typeof (object []), idesc.Arguments.GetType (), "#E4");
699 arguments = (object []) idesc.Arguments;
700 Assert.AreEqual (typeof (E2), arguments [0], "#E5");
701 Assert.AreEqual (typeof (int), arguments [1].GetType (), "#E6");
702 Assert.AreEqual (3, arguments [1], "#E7");
703 Assert.IsTrue (idesc.IsComplete, "#E8");
704 mi = idesc.MemberInfo as MethodInfo;
705 Assert.IsNotNull (mi, "#E9");
706 Assert.AreEqual ("ToObject", mi.Name, "#E10");
707 Assert.AreEqual (typeof (Enum), mi.DeclaringType, "#E11");
708 parameters = mi.GetParameters ();
709 Assert.AreEqual (2, parameters.Length, "#E12");
710 Assert.AreEqual (typeof (Type), parameters [0].ParameterType, "#E13");
711 Assert.AreEqual (typeof (int), parameters [1].ParameterType, "#E14");
714 converter.ConvertTo (null, CultureInfo.InvariantCulture,
715 null, typeof (InstanceDescriptor));
717 } catch (NotSupportedException ex) {
718 // 'EnumConverter' is unable to convert '(null)'
719 // to 'System.ComponentModel.Design.Serialization.InstanceDescriptor'
720 Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#F2");
721 Assert.IsNull (ex.InnerException, "#F3");
722 Assert.IsNotNull (ex.Message, "#F4");
723 Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (EnumConverter).Name + "'") != -1, "#F5");
724 Assert.IsTrue (ex.Message.IndexOf ("'(null)'") != -1, "#F6");
725 Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (InstanceDescriptor).FullName + "'") != -1, "#F7");
729 converter.ConvertTo (null, CultureInfo.InvariantCulture,
730 "2,1", typeof (InstanceDescriptor));
732 } catch (FormatException ex) {
733 // Input string was not in a correct format
734 Assert.AreEqual (typeof (FormatException), ex.GetType (), "#G2");
735 Assert.IsNull (ex.InnerException, "#G3");
736 Assert.IsNotNull (ex.Message, "#G4");
740 converter.ConvertTo (null, CultureInfo.InvariantCulture,
741 "Cc", typeof (InstanceDescriptor));
743 } catch (FormatException ex) {
744 // Input string was not in a correct format
745 Assert.AreEqual (typeof (FormatException), ex.GetType (), "#H2");
746 Assert.IsNull (ex.InnerException, "#H3");
747 Assert.IsNotNull (ex.Message, "#H4");
751 converter.ConvertTo (null, CultureInfo.InvariantCulture,
752 (E2) 666 | (E2) 222, typeof (InstanceDescriptor));
754 } catch (NotSupportedException ex) {
755 // 'EnumConverter' is unable to convert 'MonoTests.System.ComponentModel.EnumConverterTests+E2'
756 // to 'System.ComponentModel.Design.Serialization.InstanceDescriptor'
757 Assert.AreEqual (typeof (NotSupportedException), ex.GetType (), "#I2");
758 Assert.IsNull (ex.InnerException, "#I3");
759 Assert.IsNotNull (ex.Message, "#I4");
760 Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (EnumConverter).Name + "'") != -1, "#I5");
761 Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (E2).FullName + "'") != -1, "#I6");
762 Assert.IsTrue (ex.Message.IndexOf ("'" + typeof (InstanceDescriptor).FullName + "'") != -1, "#I7");
765 converter = new EnumConverter (typeof (F2));
766 idesc = converter.ConvertTo (null, CultureInfo.InvariantCulture,
767 F2.Bb | F2.Dd, typeof (InstanceDescriptor))
768 as InstanceDescriptor;
769 Assert.IsNotNull (idesc, "#J1");
770 Assert.IsNotNull (idesc.Arguments, "#J2");
771 Assert.AreEqual (2, idesc.Arguments.Count, "#J3");
772 Assert.AreEqual (typeof (object []), idesc.Arguments.GetType (), "#J4");
773 arguments = (object []) idesc.Arguments;
774 Assert.AreEqual (typeof (F2), arguments [0], "#J5");
775 Assert.AreEqual (typeof (byte), arguments [1].GetType (), "#J6");
776 Assert.AreEqual (10, arguments [1], "#J7");
777 Assert.IsTrue (idesc.IsComplete, "#J8");
778 mi = idesc.MemberInfo as MethodInfo;
779 Assert.IsNotNull (mi, "#J9");
780 Assert.AreEqual ("ToObject", mi.Name, "#J10");
781 Assert.AreEqual (typeof (Enum), mi.DeclaringType, "#J11");
782 parameters = mi.GetParameters ();
783 Assert.AreEqual (2, parameters.Length, "#J12");
784 Assert.AreEqual (typeof (Type), parameters [0].ParameterType, "#J13");
785 Assert.AreEqual (typeof (byte), parameters [1].ParameterType, "#J14");
789 public void ConvertTo_String ()
791 EnumConverter converter = new EnumConverter (typeof (E));
793 Assert.AreEqual ("Bb", converter.ConvertTo (null,
794 CultureInfo.InvariantCulture, E.Bb,
795 typeof (string)), "#A1");
796 Assert.AreEqual ("Dd", converter.ConvertTo (null,
797 CultureInfo.InvariantCulture, 3,
798 typeof (string)), "#A2");
799 Assert.AreEqual (string.Empty, converter.ConvertTo (
800 null, CultureInfo.InvariantCulture, null,
801 typeof (string)), "#A3");
802 Assert.AreEqual ("Cc", converter.ConvertTo (
803 null, CultureInfo.InvariantCulture, (E) 2,
804 typeof (string)), "#A4");
805 Assert.AreEqual ("Cc", converter.ConvertTo (null,
806 CultureInfo.InvariantCulture, E2.Bb,
807 typeof (string)), "#A5");
808 Assert.AreEqual ("Dd", converter.ConvertTo (null,
809 CultureInfo.InvariantCulture, E.Bb | E.Dd,
810 typeof (string)), "#A6");
813 converter.ConvertTo (null, CultureInfo.InvariantCulture,
814 (E) 666, typeof (string));
816 } catch (ArgumentException ex) {
817 // The value '666' is not a valid value for the enum 'E'
818 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
819 Assert.IsNull (ex.InnerException, "#B3");
820 Assert.IsNotNull (ex.Message, "#B4");
821 Assert.IsTrue (ex.Message.IndexOf ("'666'") != -1, "#B5");
822 Assert.IsTrue (ex.Message.IndexOf ("'E'") != -1, "#B6");
823 Assert.IsNull (ex.ParamName, "#B7");
827 converter.ConvertTo (null, CultureInfo.InvariantCulture,
828 "Cc", typeof (string));
830 } catch (FormatException ex) {
831 // Input string was not in a correct format
832 Assert.AreEqual (typeof (FormatException), ex.GetType (), "#C2");
833 Assert.IsNull (ex.InnerException, "#C3");
834 Assert.IsNotNull (ex.Message, "#C4");
838 converter = new EnumConverter (typeof (E2));
840 Assert.AreEqual ("Bb", converter.ConvertTo (null,
841 CultureInfo.InvariantCulture, E2.Bb,
842 typeof (string)), "#B1");
843 Assert.AreEqual ("Aa, Bb", converter.ConvertTo (null,
844 CultureInfo.InvariantCulture, 3,
845 typeof (string)), "#B2");
846 Assert.AreEqual (string.Empty, converter.ConvertTo (
847 null, CultureInfo.InvariantCulture, null,
848 typeof (string)), "#B3");
849 Assert.AreEqual ("Bb", converter.ConvertTo (
850 null, CultureInfo.InvariantCulture, (E2) 2,
851 typeof (string)), "#B4");
852 Assert.AreEqual ("Aa, Bb", converter.ConvertTo (
853 null, CultureInfo.InvariantCulture, E.Dd,
854 typeof (string)), "#B5");
855 Assert.AreEqual ("Bb, Dd", converter.ConvertTo (null,
856 CultureInfo.InvariantCulture, E2.Bb | E2.Dd,
857 typeof (string)), "#B6");