1 // EnumTest.cs - NUnit Test Cases for the System.Enum class
3 // David Brandt (bucky@keystreams.com)
4 // Gert Driesen (drieseng@users.sourceforge.net)
6 // (C) Ximian, Inc. http://www.ximian.com
11 using System
.Reflection
;
13 using NUnit
.Framework
;
15 namespace MonoTests
.System
21 public void TestCompareTo ()
23 Enum e1
= new TestingEnum ();
24 Enum e2
= new TestingEnum ();
25 Enum e3
= new TestingEnum2 ();
27 Assert
.AreEqual (0, e1
.CompareTo (e1
), "#A1");
28 Assert
.AreEqual (0, e1
.CompareTo (e2
), "#A2");
30 TestingEnum x
= TestingEnum
.This
;
31 TestingEnum y
= TestingEnum
.Is
;
32 Assert
.AreEqual (0, x
.CompareTo (x
), "#B1");
33 Assert
.AreEqual (-1, x
.CompareTo (y
), "#B2");
34 Assert
.AreEqual (1, y
.CompareTo (x
), "#B3");
39 } catch (ArgumentException ex
) {
40 // Object must be the same type as the enum.
41 // The type passed in was MonoTests.System.EnumTest+TestingEnum2;
42 // the enum type was MonoTests.System.EnumTest+TestingEnum
43 Assert
.AreEqual (typeof (ArgumentException
), ex
.GetType (), "#A2");
44 Assert
.IsNull (ex
.InnerException
, "#A3");
45 Assert
.IsNotNull (ex
.Message
, "#A4");
46 Assert
.IsTrue (ex
.Message
.IndexOf (typeof (TestingEnum
).FullName
) != -1, "#A5");
47 Assert
.IsTrue (ex
.Message
.IndexOf (typeof (TestingEnum2
).FullName
) != -1, "#A6");
48 Assert
.IsNull (ex
.ParamName
, "#A7");
52 ((Enum
) e1
).CompareTo ((Enum
) e3
);
54 } catch (ArgumentException ex
) {
55 // Object must be the same type as the enum.
56 // The type passed in was MonoTests.System.EnumTest+TestingEnum2;
57 // the enum type was MonoTests.System.EnumTest+TestingEnum
58 Assert
.AreEqual (typeof (ArgumentException
), ex
.GetType (), "#D2");
59 Assert
.IsNull (ex
.InnerException
, "#D3");
60 Assert
.IsNotNull (ex
.Message
, "#D4");
61 Assert
.IsTrue (ex
.Message
.IndexOf (typeof (TestingEnum
).FullName
) != -1, "#D5");
62 Assert
.IsTrue (ex
.Message
.IndexOf (typeof (TestingEnum2
).FullName
) != -1, "#D6");
63 Assert
.IsNull (ex
.ParamName
, "#D7");
68 public void TestEquals ()
70 Enum e1
= new TestingEnum ();
71 Enum e2
= new TestingEnum ();
72 Enum e3
= new TestingEnum2 ();
74 Assert
.IsTrue (e1
.Equals (e1
), "#1");
75 Assert
.IsTrue (e1
.Equals (e2
), "#2");
76 Assert
.IsFalse (e1
.Equals (e3
), "#3");
77 Assert
.IsFalse (e1
.Equals (null), "#4");
81 public void TestFormat_Args ()
84 TestingEnum x
= TestingEnum
.Test
;
85 Enum
.Format (null, x
, "G");
87 } catch (ArgumentNullException ex
) {
88 Assert
.AreEqual (typeof (ArgumentNullException
), ex
.GetType (), "#A2");
89 Assert
.IsNull (ex
.InnerException
, "#A3");
90 Assert
.IsNotNull (ex
.Message
, "#A4");
91 Assert
.IsNotNull (ex
.ParamName
, "#A5");
92 Assert
.AreEqual ("enumType", ex
.ParamName
, "#A6");
96 Enum
.Format (typeof (TestingEnum
), null, "G");
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 Assert
.AreEqual ("value", ex
.ParamName
, "#B6");
107 TestingEnum x
= TestingEnum
.Test
;
108 Enum
.Format (x
.GetType (), x
, null);
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 Assert
.AreEqual ("format", ex
.ParamName
, "#C6");
119 TestingEnum x
= TestingEnum
.Test
;
120 Enum
.Format (typeof (string), x
, "G");
122 } catch (ArgumentException ex
) {
123 // Type provided must be an Enum
124 Assert
.AreEqual (typeof (ArgumentException
), ex
.GetType (), "#A2");
125 Assert
.IsNull (ex
.InnerException
, "#A3");
126 Assert
.IsNotNull (ex
.Message
, "#A4");
127 Assert
.IsNotNull (ex
.ParamName
, "#A5");
128 Assert
.AreEqual ("enumType", ex
.ParamName
, "#A6");
132 TestingEnum x
= TestingEnum
.Test
;
133 TestingEnum2 y
= TestingEnum2
.Test
;
134 Enum
.Format (y
.GetType (), x
, "G");
136 } catch (ArgumentException ex
) {
137 // Object must be the same type as the enum. The type passed in was
138 // MonoTests.System.EnumTest.TestingEnum2; the enum type was
139 // MonoTests.System.EnumTest.TestingEnum
140 Assert
.AreEqual (typeof (ArgumentException
), ex
.GetType (), "#E2");
141 Assert
.IsNull (ex
.InnerException
, "#E3");
142 Assert
.IsNotNull (ex
.Message
, "#E4");
143 Assert
.IsTrue (ex
.Message
.IndexOf (typeof (TestingEnum2
).FullName
) != -1, "#E5");
144 Assert
.IsTrue (ex
.Message
.IndexOf (typeof (TestingEnum
).FullName
) != -1, "#E6");
145 Assert
.IsNull (ex
.ParamName
, "#A7");
150 TestingEnum x
= TestingEnum
.Test
;
151 Enum
.Format (x
.GetType (), bad
, "G");
153 } catch (ArgumentException ex
) {
154 // Enum underlying type and the object must be the same type or
155 // object. Type passed in was String.String; the enum underlying
157 Assert
.AreEqual (typeof (ArgumentException
), ex
.GetType (), "#F2");
158 Assert
.IsNull (ex
.InnerException
, "#F3");
159 Assert
.IsNotNull (ex
.Message
, "#F4");
160 Assert
.IsTrue (ex
.Message
.IndexOf (typeof (string).FullName
) != -1, "#F5");
161 Assert
.IsTrue (ex
.Message
.IndexOf (typeof (int).FullName
) != -1, "#F6");
162 Assert
.IsNull (ex
.ParamName
, "#F7");
165 string [] codes
= {"a", "b", "c", "ad", "e", "af", "ag", "h",
166 "i", "j", "k", "l", "m", "n", "o", "p",
167 "q", "r", "s", "t", "u", "v", "w", "ax",
169 foreach (string code
in codes
) {
171 TestingEnum x
= TestingEnum
.Test
;
172 Enum
.Format (x
.GetType (), x
, code
);
173 Assert
.Fail ("#G1:" + code
);
174 } catch (FormatException ex
) {
175 // Format String can be only "G","g","X","x","F","f","D" or "d"
176 Assert
.AreEqual (typeof (FormatException
), ex
.GetType (), "#G2");
177 Assert
.IsNull (ex
.InnerException
, "#G3");
178 Assert
.IsNotNull (ex
.Message
, "#G4");
182 TestingEnum test
= TestingEnum
.Test
;
183 Assert
.AreEqual ("3", Enum
.Format (test
.GetType (), test
, "d"), "#H1");
184 Assert
.AreEqual ("18446744073709551615", Enum
.Format (typeof (TestingEnum3
), TestingEnum3
.Test
, "d"), "#H2");
185 Assert
.AreEqual ("Test", Enum
.Format (test
.GetType (), test
, "g"), "#H3");
186 Assert
.AreEqual ("00000003", Enum
.Format (test
.GetType (), test
, "x"), "#H4");
187 Assert
.AreEqual ("Test", Enum
.Format (test
.GetType (), test
, "f"), "#H5");
191 public void TestFormat_FormatSpecifier ()
193 ParameterAttributes pa
=
194 ParameterAttributes
.In
| ParameterAttributes
.HasDefault
;
195 const string fFormatOutput
= "In, HasDefault";
196 const string xFormatOutput
= "00001001";
197 string fOutput
= Enum
.Format (pa
.GetType (), pa
, "f");
198 Assert
.AreEqual (fFormatOutput
, fOutput
, "#A1");
199 string xOutput
= Enum
.Format (pa
.GetType (), pa
, "x");
200 Assert
.AreEqual (xFormatOutput
, xOutput
, "#A2");
202 Assert
.AreEqual ("00", TestingEnum4
.This
.ToString ("x"), "#B1");
203 Assert
.AreEqual ("00", TestingEnum4
.This
.ToString ("X"), "#B2");
204 Assert
.AreEqual ("ff", TestingEnum4
.Test
.ToString ("x"), "#B3");
205 Assert
.AreEqual ("FF", TestingEnum4
.Test
.ToString ("X"), "#B4");
207 Assert
.AreEqual ("0000", TestingEnum5
.This
.ToString ("x"), "#C1");
208 Assert
.AreEqual ("0000", TestingEnum5
.This
.ToString ("X"), "#C2");
209 Assert
.AreEqual ("7fff", TestingEnum5
.Test
.ToString ("x"), "#C3");
210 Assert
.AreEqual ("7FFF", TestingEnum5
.Test
.ToString ("X"), "#C4");
212 Assert
.AreEqual ("00000000", TestingEnum6
.This
.ToString ("x"), "#D1");
213 Assert
.AreEqual ("00000000", TestingEnum6
.This
.ToString ("X"), "#D2");
214 Assert
.AreEqual ("7fffffff", TestingEnum6
.Test
.ToString ("x"), "#D3");
215 Assert
.AreEqual ("7FFFFFFF", TestingEnum6
.Test
.ToString ("X"), "#D4");
217 Assert
.AreEqual ("0000000000000000", TestingEnum3
.This
.ToString ("x"), "#E1");
218 Assert
.AreEqual ("0000000000000000", TestingEnum3
.This
.ToString ("X"), "#E2");
219 Assert
.AreEqual ("ffffffffffffffff", TestingEnum3
.Test
.ToString ("x"), "#E3");
220 Assert
.AreEqual ("FFFFFFFFFFFFFFFF", TestingEnum3
.Test
.ToString ("X"), "#E4");
224 public void TestGetHashCode ()
226 Enum e1
= new TestingEnum ();
227 Enum e2
= new TestingEnum2 ();
229 Assert
.AreEqual (e1
.GetHashCode (), e1
.GetHashCode ());
233 public void GetName ()
236 TestingEnum x
= TestingEnum
.Test
;
237 Enum
.GetName (null, x
);
239 } catch (ArgumentNullException ex
) {
240 Assert
.AreEqual (typeof (ArgumentNullException
), ex
.GetType (), "#A2");
241 Assert
.IsNull (ex
.InnerException
, "#A3");
242 Assert
.IsNotNull (ex
.Message
, "#A4");
243 Assert
.IsNotNull (ex
.ParamName
, "#A5");
244 Assert
.AreEqual ("enumType", ex
.ParamName
, "#A6");
248 TestingEnum x
= TestingEnum
.Test
;
249 Enum
.GetName (x
.GetType (), null);
251 } catch (ArgumentNullException ex
) {
252 Assert
.AreEqual (typeof (ArgumentNullException
), ex
.GetType (), "#B2");
253 Assert
.IsNull (ex
.InnerException
, "#B3");
254 Assert
.IsNotNull (ex
.Message
, "#B4");
255 Assert
.IsNotNull (ex
.ParamName
, "#B5");
256 Assert
.AreEqual ("value", ex
.ParamName
, "#B6");
261 TestingEnum x
= TestingEnum
.Test
;
262 Enum
.GetName (bad
.GetType (), x
);
264 } catch (ArgumentException ex
) {
265 // Type provided must be an Enum
266 Assert
.AreEqual (typeof (ArgumentException
), ex
.GetType (), "#C2");
267 Assert
.IsNull (ex
.InnerException
, "#C3");
268 Assert
.IsNotNull (ex
.Message
, "#C4");
269 Assert
.IsNotNull (ex
.ParamName
, "#C5");
270 Assert
.AreEqual ("enumType", ex
.ParamName
, "#C6");
275 TestingEnum x
= TestingEnum
.Test
;
276 Enum
.GetName (x
.GetType (), bad
);
278 } catch (ArgumentException ex
) {
279 Assert
.AreEqual (typeof (ArgumentException
), ex
.GetType (), "#D2");
280 Assert
.IsNull (ex
.InnerException
, "#D3");
281 Assert
.IsNotNull (ex
.Message
, "#D4");
282 Assert
.IsNotNull (ex
.ParamName
, "#D5");
283 Assert
.AreEqual ("value", ex
.ParamName
, "#D6");
286 TestingEnum a
= TestingEnum
.This
;
287 TestingEnum b
= TestingEnum
.Is
;
288 TestingEnum c
= TestingEnum
.A
;
289 TestingEnum2 d
= TestingEnum2
.Test
;
291 Assert
.AreEqual ("This", Enum
.GetName (a
.GetType (), a
), "#E1");
292 Assert
.AreEqual ("Is", Enum
.GetName (b
.GetType (), b
), "#E2");
293 Assert
.AreEqual ("A", Enum
.GetName (c
.GetType (), c
), "#E3");
294 Assert
.AreEqual ("Test", Enum
.GetName (c
.GetType (), d
), "#E4");
298 public void GetNameIdenticalToGetEnumName ()
300 Assert
.AreEqual (typeof (EnumOverlap
).GetEnumName (0), Enum
.GetName (typeof(EnumOverlap
), 0), "#1");
301 Assert
.AreEqual ("First", Enum
.GetName (typeof(EnumOverlap
), 0), "#2");
305 public void TestGetNames ()
308 Enum
.GetNames (null);
310 } catch (ArgumentNullException ex
) {
311 Assert
.AreEqual (typeof (ArgumentNullException
), ex
.GetType (), "#A2");
312 Assert
.IsNull (ex
.InnerException
, "#A3");
313 Assert
.IsNotNull (ex
.Message
, "#A4");
314 Assert
.IsNotNull (ex
.ParamName
, "#A5");
315 Assert
.AreEqual ("enumType", ex
.ParamName
, "#A6");
318 TestingEnum x
= TestingEnum
.This
;
319 string [] match
= { "This", "Is", "A", "Test" }
;
320 string [] names
= Enum
.GetNames (x
.GetType ());
321 Assert
.IsNotNull (names
, "#B1");
322 Assert
.AreEqual (match
.Length
, names
.Length
, "#B2");
323 for (int i
= 0; i
< names
.Length
; i
++)
324 Assert
.AreEqual (match
[i
], names
[i
], "#B3");
328 public void TestGetTypeCode ()
330 TestingEnum x
= TestingEnum
.This
;
331 TestingEnum y
= new TestingEnum ();
332 Assert
.AreEqual (TypeCode
.Int32
, x
.GetTypeCode (), "#1");
333 Assert
.AreEqual (TypeCode
.Int32
, y
.GetTypeCode (), "#2");
337 public void TestGetUnderlyingType ()
340 Enum
.GetUnderlyingType (null);
342 } catch (ArgumentNullException ex
) {
343 Assert
.AreEqual (typeof (ArgumentNullException
), ex
.GetType (), "#A2");
344 Assert
.IsNull (ex
.InnerException
, "#A3");
345 Assert
.IsNotNull (ex
.Message
, "#A4");
346 Assert
.IsNotNull (ex
.ParamName
, "#A5");
347 Assert
.AreEqual ("enumType", ex
.ParamName
, "#A6");
352 Enum
.GetUnderlyingType (bad
.GetType ());
354 } catch (ArgumentException ex
) {
355 // Type provided must be an Enum
356 Assert
.AreEqual (typeof (ArgumentException
), ex
.GetType (), "#B2");
357 Assert
.IsNull (ex
.InnerException
, "#B3");
358 Assert
.IsNotNull (ex
.Message
, "#B4");
359 Assert
.IsNotNull (ex
.ParamName
, "#B5");
360 Assert
.AreEqual ("enumType", ex
.ParamName
, "#B6");
365 Enum t1
= new TestingEnum ();
366 Enum t2
= new TestShortEnum ();
367 Assert
.AreEqual (i
.GetType (), Enum
.GetUnderlyingType (t1
.GetType ()), "#C1");
368 Assert
.AreEqual (sh
.GetType (), Enum
.GetUnderlyingType (t2
.GetType ()), "#C2");
372 public void TestGetValues ()
375 Enum
.GetValues (null);
377 } catch (ArgumentNullException ex
) {
378 Assert
.AreEqual (typeof (ArgumentNullException
), ex
.GetType (), "#A2");
379 Assert
.IsNull (ex
.InnerException
, "#A3");
380 Assert
.IsNotNull (ex
.Message
, "#A4");
381 Assert
.IsNotNull (ex
.ParamName
, "#A5");
382 Assert
.AreEqual ("enumType", ex
.ParamName
, "#A6");
387 Enum
.GetValues (bad
.GetType ());
389 } catch (ArgumentException ex
) {
390 // Type provided must be an Enum
391 Assert
.AreEqual (typeof (ArgumentException
), ex
.GetType (), "#B2");
392 Assert
.IsNull (ex
.InnerException
, "#B3");
393 Assert
.IsNotNull (ex
.Message
, "#B4");
394 Assert
.IsNotNull (ex
.ParamName
, "#B5");
395 Assert
.AreEqual ("enumType", ex
.ParamName
, "#B6");
398 Enum t1
= new TestingEnum ();
399 Array a1
= Enum
.GetValues (t1
.GetType ());
400 for (int i
= 0; i
< a1
.Length
; i
++)
401 Assert
.AreEqual ((TestingEnum
) i
, a1
.GetValue (i
), "#C1");
403 Enum t2
= new TestShortEnum ();
404 Array a2
= Enum
.GetValues (t2
.GetType ());
405 for (short i
= 0; i
< a1
.Length
; i
++)
406 Assert
.AreEqual ((TestShortEnum
) i
, a2
.GetValue (i
), "#C2");
410 public void TestIsDefined ()
413 Enum
.IsDefined (null, 1);
415 } catch (ArgumentNullException ex
) {
416 Assert
.AreEqual (typeof (ArgumentNullException
), ex
.GetType (), "#A2");
417 Assert
.IsNull (ex
.InnerException
, "#A3");
418 Assert
.IsNotNull (ex
.Message
, "#A4");
419 Assert
.IsNotNull (ex
.ParamName
, "#A5");
420 Assert
.AreEqual ("enumType", ex
.ParamName
, "#A6");
424 TestingEnum x
= TestingEnum
.Test
;
425 Enum
.IsDefined (x
.GetType (), null);
427 } catch (ArgumentNullException ex
) {
428 Assert
.AreEqual (typeof (ArgumentNullException
), ex
.GetType (), "#B2");
429 Assert
.IsNull (ex
.InnerException
, "#B3");
430 Assert
.IsNotNull (ex
.Message
, "#B4");
431 Assert
.IsNotNull (ex
.ParamName
, "#B5");
432 Assert
.AreEqual ("value", ex
.ParamName
, "#B6");
438 Enum
.IsDefined (bad
.GetType (), i
);
440 } catch (ArgumentException ex
) {
441 // Type provided must be an Enum
442 Assert
.AreEqual (typeof (ArgumentException
), ex
.GetType (), "#C2");
443 Assert
.IsNull (ex
.InnerException
, "#C3");
444 Assert
.IsNotNull (ex
.Message
, "#C4");
445 Assert
.IsNotNull (ex
.ParamName
, "#C5");
446 Assert
.AreEqual ("enumType", ex
.ParamName
, "#C6");
450 TestingEnum x
= TestingEnum
.Test
;
452 Enum
.IsDefined (x
.GetType (), i
);
454 } catch (ArgumentException ex
) {
455 Assert
.AreEqual (typeof (ArgumentException
), ex
.GetType (), "#D2");
456 Assert
.IsNull (ex
.InnerException
, "#D3");
457 Assert
.IsNotNull (ex
.Message
, "#D4");
458 Assert
.IsNull (ex
.ParamName
, "#D5");
461 Enum t1
= new TestingEnum ();
462 int valCount
= Enum
.GetValues (t1
.GetType ()).Length
;
463 for (int i
= 0; i
< valCount
; i
++)
464 Assert
.IsTrue (Enum
.IsDefined (t1
.GetType (), i
), "#F1:" + i
);
465 Assert
.IsFalse (Enum
.IsDefined (t1
.GetType (), valCount
), "#F2");
466 Assert
.IsFalse (Enum
.IsDefined (typeof (TestingEnum
), "huh?"), "#F3");
470 public void TestParse1 ()
473 String name
= "huh?";
474 Enum
.Parse (null, name
);
476 } catch (ArgumentNullException ex
) {
477 Assert
.AreEqual (typeof (ArgumentNullException
), ex
.GetType (), "#A2");
478 Assert
.IsNull (ex
.InnerException
, "#A3");
479 Assert
.IsNotNull (ex
.Message
, "#A4");
480 Assert
.IsNotNull (ex
.ParamName
, "#A5");
481 Assert
.AreEqual ("enumType", ex
.ParamName
, "#A6");
485 TestingEnum x
= TestingEnum
.Test
;
486 Enum
.Parse (x
.GetType (), null);
488 } catch (ArgumentNullException ex
) {
489 Assert
.AreEqual (typeof (ArgumentNullException
), ex
.GetType (), "#B2");
490 Assert
.IsNull (ex
.InnerException
, "#B3");
491 Assert
.IsNotNull (ex
.Message
, "#B4");
492 Assert
.IsNotNull (ex
.ParamName
, "#B5");
493 Assert
.AreEqual ("value", ex
.ParamName
, "#B6");
498 Enum
.Parse (bad
.GetType (), bad
);
500 } catch (ArgumentException ex
) {
501 // Type provided must be an Enum
502 Assert
.AreEqual (typeof (ArgumentException
), ex
.GetType (), "#C2");
503 Assert
.IsNull (ex
.InnerException
, "#C3");
504 Assert
.IsNotNull (ex
.Message
, "#C4");
505 Assert
.IsNotNull (ex
.ParamName
, "#C5");
506 Assert
.AreEqual ("enumType", ex
.ParamName
, "#C6");
510 TestingEnum x
= TestingEnum
.Test
;
512 Enum
.Parse (x
.GetType (), bad
);
514 } catch (ArgumentException ex
) {
515 // Must specify valid information for parsing
517 Assert
.AreEqual (typeof (ArgumentException
), ex
.GetType (), "#D2");
518 Assert
.IsNull (ex
.InnerException
, "#D3");
519 Assert
.IsNotNull (ex
.Message
, "#D4");
520 Assert
.IsNull (ex
.ParamName
, "#D5");
524 TestingEnum x
= TestingEnum
.Test
;
526 Enum
.Parse (x
.GetType (), bad
);
528 } catch (ArgumentException ex
) {
529 Assert
.AreEqual (typeof (ArgumentException
), ex
.GetType (), "#E2");
530 Assert
.IsNull (ex
.InnerException
, "#E3");
531 Assert
.IsNotNull (ex
.Message
, "#E4");
532 Assert
.IsNull (ex
.ParamName
, "#E5");
537 TestingEnum x
= TestingEnum
.Test
;
538 Enum
.Parse (x
.GetType (), bad
);
540 } catch (ArgumentException ex
) {
541 Assert
.AreEqual (typeof (ArgumentException
), ex
.GetType (), "#F2");
542 Assert
.IsNull (ex
.InnerException
, "#F3");
543 Assert
.IsNotNull (ex
.Message
, "#F4");
544 Assert
.IsNull (ex
.ParamName
, "#F5");
547 TestingEnum t1
= new TestingEnum ();
548 Assert
.AreEqual (TestingEnum
.This
, Enum
.Parse (t1
.GetType (), "This"), "#G1");
549 Assert
.AreEqual (TestingEnum
.Is
, Enum
.Parse (t1
.GetType (), "Is"), "#G2");
550 Assert
.AreEqual (TestingEnum
.A
, Enum
.Parse (t1
.GetType (), "A"), "#G3");
551 Assert
.AreEqual (TestingEnum
.Test
, Enum
.Parse (t1
.GetType (), "Test"), "#G4");
552 Assert
.AreEqual (TestingEnum
.Test
, Enum
.Parse (t1
.GetType (), " \n\nTest\t"), "#G5");
553 Assert
.AreEqual (TestingEnum
.Is
, Enum
.Parse (t1
.GetType (), "This,Is"), "#G6");
554 Assert
.AreEqual (TestingEnum
.Test
, Enum
.Parse (t1
.GetType (), "This,Test"), "#G7");
555 Assert
.AreEqual (TestingEnum
.Test
, Enum
.Parse (t1
.GetType (), "This,Is,A"), "#G8");
556 Assert
.AreEqual (TestingEnum
.Test
, Enum
.Parse (t1
.GetType (), " \n\tThis \t\n, Is,A \n"), "#G9");
560 public void TestParse2 ()
563 String name
= "huh?";
564 Enum
.Parse (null, name
, true);
566 } catch (ArgumentNullException ex
) {
567 Assert
.AreEqual (typeof (ArgumentNullException
), ex
.GetType (), "#A2");
568 Assert
.IsNull (ex
.InnerException
, "#A3");
569 Assert
.IsNotNull (ex
.Message
, "#A4");
570 Assert
.IsNotNull (ex
.ParamName
, "#A5");
571 Assert
.AreEqual ("enumType", ex
.ParamName
, "#A6");
575 TestingEnum x
= TestingEnum
.Test
;
576 Enum
.Parse (x
.GetType (), null, true);
578 } catch (ArgumentNullException ex
) {
579 Assert
.AreEqual (typeof (ArgumentNullException
), ex
.GetType (), "#B2");
580 Assert
.IsNull (ex
.InnerException
, "#B3");
581 Assert
.IsNotNull (ex
.Message
, "#B4");
582 Assert
.IsNotNull (ex
.ParamName
, "#B5");
583 Assert
.AreEqual ("value", ex
.ParamName
, "#B6");
588 Enum
.Parse (bad
.GetType (), bad
, true);
590 } catch (ArgumentException ex
) {
591 // Type provided must be an Enum
592 Assert
.AreEqual (typeof (ArgumentException
), ex
.GetType (), "#D2");
593 Assert
.IsNull (ex
.InnerException
, "#D3");
594 Assert
.IsNotNull (ex
.Message
, "#D4");
595 Assert
.IsNotNull (ex
.ParamName
, "#D5");
596 Assert
.AreEqual ("enumType", ex
.ParamName
, "#D6");
600 TestingEnum x
= TestingEnum
.Test
;
602 Enum
.Parse (x
.GetType (), bad
, true);
604 } catch (ArgumentException ex
) {
605 // Must specify valid information for parsing
607 Assert
.AreEqual (typeof (ArgumentException
), ex
.GetType (), "#E2");
608 Assert
.IsNull (ex
.InnerException
, "#E3");
609 Assert
.IsNotNull (ex
.Message
, "#E4");
610 Assert
.IsNull (ex
.ParamName
, "#E5");
614 TestingEnum x
= TestingEnum
.Test
;
616 Enum
.Parse (x
.GetType (), bad
, true);
618 } catch (ArgumentException ex
) {
619 // Must specify valid information for parsing
621 Assert
.AreEqual (typeof (ArgumentException
), ex
.GetType (), "#F2");
622 Assert
.IsNull (ex
.InnerException
, "#F3");
623 Assert
.IsNotNull (ex
.Message
, "#F4");
624 Assert
.IsFalse (ex
.Message
.IndexOf ("' '") != -1, "#F5");
625 Assert
.IsNull (ex
.ParamName
, "#F6");
630 TestingEnum x
= TestingEnum
.Test
;
631 Enum
.Parse (x
.GetType (), bad
, true);
633 } catch (ArgumentException ex
) {
634 // Requested value 'huh?' was not found
635 Assert
.AreEqual (typeof (ArgumentException
), ex
.GetType (), "#G2");
636 Assert
.IsNull (ex
.InnerException
, "#G3");
637 Assert
.IsNotNull (ex
.Message
, "#G4");
638 Assert
.IsTrue (ex
.Message
.IndexOf ("'huh?'") != -1, "#G5");
639 Assert
.IsNull (ex
.ParamName
, "#G6");
644 TestingEnum x
= TestingEnum
.Test
;
645 Enum
.Parse (x
.GetType (), bad
, false);
647 } catch (ArgumentException ex
) {
648 // Requested value 'test' was not found
649 Assert
.AreEqual (typeof (ArgumentException
), ex
.GetType (), "#H2");
650 Assert
.IsNull (ex
.InnerException
, "#H3");
651 Assert
.IsNotNull (ex
.Message
, "#H4");
652 Assert
.IsTrue (ex
.Message
.IndexOf ("'test'") != -1, "#H5");
653 Assert
.IsNull (ex
.ParamName
, "#H6");
656 TestingEnum t1
= new TestingEnum ();
657 Assert
.AreEqual (TestingEnum
.This
, Enum
.Parse (t1
.GetType (), "this", true), "#I1");
658 Assert
.AreEqual (TestingEnum
.Is
, Enum
.Parse (t1
.GetType (), "is", true), "#I2");
659 Assert
.AreEqual (TestingEnum
.A
, Enum
.Parse (t1
.GetType (), "a", true), "#I3");
660 Assert
.AreEqual (TestingEnum
.Test
, Enum
.Parse (t1
.GetType (), "test", true), "#I4");
661 Assert
.AreEqual (TestingEnum
.Test
, Enum
.Parse (t1
.GetType (), " \n\ntest\t", true), "#I5");
663 Assert
.AreEqual (TestingEnum
.Is
, Enum
.Parse (t1
.GetType (), "This,is", true), "#J1");
664 Assert
.AreEqual (TestingEnum
.Test
, Enum
.Parse (t1
.GetType (), "This,test", true), "#J2");
665 Assert
.AreEqual (TestingEnum
.Test
, Enum
.Parse (t1
.GetType (), "This,is,A", true), "#J3");
666 Assert
.AreEqual (TestingEnum
.Test
, Enum
.Parse (t1
.GetType (), " \n\tThis \t\n, is,a \n", true), "#J4");
670 public void ParseValue ()
672 TestingEnum3 t1
= new TestingEnum3 ();
673 Assert
.AreEqual (TestingEnum3
.Test
, Enum
.Parse (t1
.GetType (), "18446744073709551615", false));
678 public void TryParseErrors ()
683 success
= Enum
.TryParse
<TestingEnum
> (null, out result
);
684 Assert
.AreEqual (false, success
, "#A1");
685 Assert
.AreEqual (TestingEnum
.This
, result
, "#A2");
687 success
= Enum
.TryParse
<TestingEnum
> ("WrongValue", out result
);
688 Assert
.AreEqual (false, success
, "#B1");
689 Assert
.AreEqual (TestingEnum
.This
, result
, "#B2");
691 success
= Enum
.TryParse
<TestingEnum
> (String
.Empty
, out result
);
692 Assert
.AreEqual (false, success
, "#C1");
693 Assert
.AreEqual (TestingEnum
.This
, result
, "#C2");
695 success
= Enum
.TryParse
<TestingEnum
> (" ", out result
);
696 Assert
.AreEqual (false, success
, "#D1");
697 Assert
.AreEqual (TestingEnum
.This
, result
, "#D2");
699 // TryParse throws ArgumentException if TEnum is not an enumeration type
702 Enum
.TryParse
<int> ("31416", out n
);
704 } catch (ArgumentException ex
) {
705 Assert
.AreEqual (typeof (ArgumentException
), ex
.GetType (), "#E2");
706 Assert
.IsNull (ex
.InnerException
, "#E3");
707 Assert
.IsNotNull (ex
.Message
, "#E4");
708 Assert
.IsNotNull (ex
.ParamName
, "#E5");
709 Assert
.AreEqual ("enumType", ex
.ParamName
, "#E6");
714 public void TryParse ()
719 success
= Enum
.TryParse
<TestingEnum
> ("Is", out result
);
720 Assert
.AreEqual (true, success
, "#A1");
721 Assert
.AreEqual (TestingEnum
.Is
, result
, "#A2");
723 success
= Enum
.TryParse
<TestingEnum
> ("100", out result
);
724 Assert
.AreEqual (true, success
, "#C1");
725 Assert
.AreEqual (((TestingEnum
)100), result
, "#C2");
727 success
= Enum
.TryParse
<TestingEnum
> ("is", out result
);
728 Assert
.AreEqual (false, success
, "#D1");
729 Assert
.AreEqual (TestingEnum
.This
, result
, "#D2");
731 success
= Enum
.TryParse
<TestingEnum
> ("is", true, out result
);
732 Assert
.AreEqual (true, success
, "#D1");
733 Assert
.AreEqual (TestingEnum
.Is
, result
, "#D2");
735 success
= Enum
.TryParse
<TestingEnum
> (" Is ", out result
);
736 Assert
.AreEqual (true, success
, "#E1");
737 Assert
.AreEqual (TestingEnum
.Is
, result
, "#E2");
742 public void ToObject_EnumType_Int32 ()
744 object value = Enum
.ToObject (typeof (TestingEnum
), 0);
745 Assert
.AreEqual (TestingEnum
.This
, value, "#1");
746 value = Enum
.ToObject (typeof (TestingEnum
), 2);
747 Assert
.AreEqual (TestingEnum
.A
, value, "#2");
751 public void ToObject_EnumType_UInt64 ()
753 object value = Enum
.ToObject (typeof (TestingEnum3
), 0);
754 Assert
.AreEqual (TestingEnum3
.This
, value, "#1");
755 value = Enum
.ToObject (typeof (TestingEnum3
), 1);
756 Assert
.AreEqual (TestingEnum3
.Is
, value, "#2");
757 value = Enum
.ToObject (typeof (TestingEnum3
), ulong.MaxValue
);
758 Assert
.AreEqual (TestingEnum3
.Test
, value, "#3");
762 public void ToObject_EnumType_Byte ()
764 object value = Enum
.ToObject (typeof (TestingEnum4
), 0);
765 Assert
.AreEqual (TestingEnum4
.This
, value, "#1");
766 value = Enum
.ToObject (typeof (TestingEnum4
), byte.MaxValue
);
767 Assert
.AreEqual (TestingEnum4
.Test
, value, "#2");
771 public void ToObject_EnumType_Int16 ()
773 object value = Enum
.ToObject (typeof (TestingEnum5
), 0);
774 Assert
.AreEqual (TestingEnum5
.This
, value, "#1");
775 value = Enum
.ToObject (typeof (TestingEnum5
), short.MaxValue
);
776 Assert
.AreEqual (TestingEnum5
.Test
, value, "#2");
780 public void ToObject_EnumType_Bool ()
782 object value = Enum
.ToObject (typeof (TestingEnum5
), true);
783 Assert
.AreEqual (TestingEnum5
.Is
, value, "#1");
787 public void ToObject_EnumType_Char ()
789 object value = Enum
.ToObject (typeof (TestingEnum3
), (object) '\0');
790 Assert
.AreEqual (TestingEnum3
.This
, value, "#1");
794 public void ToObject_EnumType_Invalid ()
797 Enum
.ToObject (typeof (string), 1);
799 } catch (ArgumentException ex
) {
800 // Type provided must be an Enum
801 Assert
.AreEqual (typeof (ArgumentException
), ex
.GetType (), "#2");
802 Assert
.IsNull (ex
.InnerException
, "#3");
803 Assert
.IsNotNull (ex
.Message
, "#4");
804 Assert
.IsNotNull (ex
.ParamName
, "#5");
805 Assert
.AreEqual ("enumType", ex
.ParamName
, "#6");
810 public void ToObject_EnumType_Null ()
813 Enum
.ToObject (null, 1);
815 } catch (ArgumentNullException ex
) {
816 Assert
.AreEqual (typeof (ArgumentNullException
), ex
.GetType (), "#2");
817 Assert
.IsNull (ex
.InnerException
, "#3");
818 Assert
.IsNotNull (ex
.Message
, "#4");
819 Assert
.IsNotNull (ex
.ParamName
, "#5");
820 Assert
.AreEqual ("enumType", ex
.ParamName
, "#6");
825 public void ToObject_Value_Null ()
828 Enum
.ToObject (typeof (TestingEnum
), (object) null);
830 } catch (ArgumentNullException ex
) {
831 Assert
.AreEqual (typeof (ArgumentNullException
), ex
.GetType (), "#2");
832 Assert
.IsNull (ex
.InnerException
, "#3");
833 Assert
.IsNotNull (ex
.Message
, "#4");
834 Assert
.IsNotNull (ex
.ParamName
, "#5");
835 Assert
.AreEqual ("value", ex
.ParamName
, "#6");
840 public void ToObject_Value_Invalid ()
843 Enum
.ToObject (typeof (TestingEnum
), "This");
845 } catch (ArgumentException ex
) {
846 // The value passed in must be an enum base or
847 // an underlying type for an enum, such as an
849 Assert
.AreEqual (typeof (ArgumentException
), ex
.GetType (), "#2");
850 Assert
.IsNull (ex
.InnerException
, "#3");
851 Assert
.IsNotNull (ex
.Message
, "#4");
852 Assert
.IsNotNull (ex
.ParamName
, "#5");
853 Assert
.AreEqual ("value", ex
.ParamName
, "#6");
858 public void IConvertible_Valid ()
860 IConvertible ic
= TestingEnum
.This
;
861 Assert
.AreEqual ("This", ic
.ToType (typeof (string), null), "#1");
862 Assert
.AreEqual (TestingEnum
.This
, ic
.ToType (typeof (TestingEnum
), null), "#2");
863 Assert
.AreEqual (TestingEnum
.This
, ic
.ToType (typeof (Enum
), null), "#3");
867 public void TestToString ()
869 Assert
.AreEqual ("This", TestingEnum
.This
.ToString (), "#A1");
870 Assert
.AreEqual ("Is", TestingEnum
.Is
.ToString (), "#A2");
871 Assert
.AreEqual ("A", TestingEnum
.A
.ToString (), "#A3");
872 Assert
.AreEqual ("Test", TestingEnum
.Test
.ToString (), "#A4");
874 Enum is1
= TestingEnum
.Is
;
876 Assert
.AreEqual ("1", is1
.ToString ("d"), "#B1");
877 Assert
.AreEqual ("Is", is1
.ToString ("g"), "#B2");
878 Assert
.AreEqual ("00000001", is1
.ToString ("x"), "#B3");
879 Assert
.AreEqual ("Is", is1
.ToString ("f"), "#B4");
881 Assert
.AreEqual ("b, c", ((SomeEnum
) 3).ToString ("f"), "#C1");
882 Assert
.AreEqual ("b, c", ((SomeByteEnum
) 3).ToString ("f"), "#C2");
883 Assert
.AreEqual ("b, c", ((SomeInt64Enum
) 3).ToString ("f"), "#C3");
885 Assert
.AreEqual ("12", ((SomeEnum
) 12).ToString ("f"), "#D1");
886 Assert
.AreEqual ("12", ((SomeByteEnum
) 12).ToString ("f"), "#D2");
887 Assert
.AreEqual ("12", ((SomeInt64Enum
) 12).ToString ("f"), "#D3");
891 public void FlagTest ()
893 int [] evalues
= new int [4] { 0, 1, 2, 3 }
;
894 E
[] e
= new E
[4] { E.Aa, E.Bb, E.Cc, E.Dd }
;
896 for (int i
= 0; i
< 4; ++i
)
897 Assert
.AreEqual (e
[i
].ToString (),
898 Enum
.Format (typeof (E
), evalues
[i
], "f"),
901 int invalidValue
= 1000;
903 Assert
.AreEqual (invalidValue
.ToString (),
904 Enum
.Format (typeof (E2
), invalidValue
, "g"),
909 public void FlagTest_Negative ()
911 FlagsNegativeTestEnum t
;
913 t
= FlagsNegativeTestEnum
.None
;
914 Assert
.AreEqual ("None", t
.ToString (), "#01");
915 t
= FlagsNegativeTestEnum
.One
;
916 Assert
.AreEqual ("One", t
.ToString (), "#02");
920 public void AnotherFormatBugPinned ()
922 Assert
.AreEqual ("100", Enum
.Format (typeof (E3
), 100, "f"));
926 public void LogicBugPinned ()
928 string format
= null;
929 string [] names
= new string [] { "A", "B", "C", "D", }
;
930 string [] fmtSpl
= null;
931 UE ue
= UE
.A
| UE
.B
| UE
.C
| UE
.D
;
933 //all flags must be in format return
934 format
= Enum
.Format (typeof (UE
), ue
, "f");
935 fmtSpl
= format
.Split (',');
936 for (int i
= 0; i
< fmtSpl
.Length
; ++i
)
937 fmtSpl
[i
] = fmtSpl
[i
].Trim ();
939 foreach (string nval
in fmtSpl
)
940 Assert
.IsTrue (Array
.IndexOf (names
, nval
) >= 0, "#1:" + nval
);
942 foreach (string nval
in names
)
943 Assert
.IsTrue (Array
.IndexOf (fmtSpl
, nval
) >= 0, "#2:" + nval
);
945 // TODO - ToString with IFormatProviders
948 public void GetHashCode_ShouldBeEqualToUnderlyingType ()
950 Assert
.AreEqual (EnInt8
.A
.GetHashCode(), SByte
.MinValue
, "i8#0");
951 Assert
.AreEqual (EnInt8
.B
.GetHashCode(), 44, "i8#1");
952 Assert
.AreEqual (EnInt8
.C
.GetHashCode(), SByte
.MaxValue
, "i8#2");
954 Assert
.AreEqual (EnUInt8
.A
.GetHashCode(), Byte
.MinValue
, "u8#0");
955 Assert
.AreEqual (EnUInt8
.B
.GetHashCode(), 55, "u8#1");
956 Assert
.AreEqual (EnUInt8
.C
.GetHashCode(), Byte
.MaxValue
, "u8#2");
958 Assert
.AreEqual (EnInt16
.A
.GetHashCode(), Int16
.MinValue
, "i16#0");
959 Assert
.AreEqual (EnInt16
.B
.GetHashCode(), 66, "i16#1");
960 Assert
.AreEqual (EnInt16
.C
.GetHashCode(), Int16
.MaxValue
, "i16#2");
962 Assert
.AreEqual (EnUInt16
.A
.GetHashCode(), UInt16
.MinValue
, "u16#0");
963 Assert
.AreEqual (EnUInt16
.B
.GetHashCode(), 77, "u16#1");
964 Assert
.AreEqual (EnUInt16
.C
.GetHashCode(), UInt16
.MaxValue
, "u16#2");
966 Assert
.AreEqual (EnInt32
.A
.GetHashCode(), Int32
.MinValue
, "i32#0");
967 Assert
.AreEqual (EnInt32
.B
.GetHashCode(), 88, "i32#1");
968 Assert
.AreEqual (EnInt32
.C
.GetHashCode(), Int32
.MaxValue
, "i32#2");
970 Assert
.AreEqual (EnUInt32
.A
.GetHashCode(), UInt32
.MinValue
, "u32#0");
971 Assert
.AreEqual (EnUInt32
.B
.GetHashCode(), 99, "u32#1");
972 Assert
.AreEqual (EnUInt32
.C
.GetHashCode(), UInt32
.MaxValue
.GetHashCode (), "u32#2");
974 Assert
.AreEqual (EnInt64
.A
.GetHashCode(), Int64
.MinValue
.GetHashCode (), "i64#0");
975 Assert
.AreEqual (EnInt64
.B
.GetHashCode(), 3488924689489L.GetHashCode (), "i64#1");
976 Assert
.AreEqual (EnInt64
.C
.GetHashCode(), Int64
.MaxValue
.GetHashCode (), "i64#2");
978 Assert
.AreEqual (EnUInt64
.A
.GetHashCode(), UInt64
.MinValue
.GetHashCode (), "u64#0");
979 Assert
.AreEqual (EnUInt64
.B
.GetHashCode(), 3488924689489L.GetHashCode (), "u64#1");
980 Assert
.AreEqual (EnUInt64
.C
.GetHashCode(), UInt64
.MaxValue
.GetHashCode (), "u64#2");
984 public void CompareTo_NotEqualToUnderlyingType ()
986 Assert
.AreEqual (0, EnInt8
.A
.CompareTo (EnInt8
.A
), "i8#0");
987 Assert
.AreEqual (-1, EnInt8
.A
.CompareTo (EnInt8
.B
), "i8#1");
988 Assert
.AreEqual (1, EnInt8
.B
.CompareTo (EnInt8
.A
), "i8#2");
990 Assert
.AreEqual (0, EnUInt8
.A
.CompareTo (EnUInt8
.A
), "ui8#0");
991 Assert
.AreEqual (-1, EnUInt8
.A
.CompareTo (EnUInt8
.B
), "ui8#1");
992 Assert
.AreEqual (1, EnUInt8
.B
.CompareTo (EnUInt8
.A
),"ui8#2");
994 Assert
.AreEqual (0, EnInt16
.A
.CompareTo (EnInt16
.A
), "i16#0");
995 Assert
.AreEqual (-1, EnInt16
.A
.CompareTo (EnInt16
.B
), "i16#1");
996 Assert
.AreEqual (1, EnInt16
.B
.CompareTo (EnInt16
.A
), "i16#2");
998 Assert
.AreEqual (0, EnUInt16
.A
.CompareTo (EnUInt16
.A
), "ui16#0");
999 Assert
.AreEqual (-1, EnUInt16
.A
.CompareTo (EnUInt16
.B
), "ui16#1");
1000 Assert
.AreEqual (1, EnUInt16
.B
.CompareTo (EnUInt16
.A
), "ui16#2");
1002 Assert
.AreEqual (int.MinValue
.CompareTo (int.MinValue
), EnInt32
.A
.CompareTo (EnInt32
.A
), "i32#0");
1003 Assert
.AreEqual (int.MinValue
.CompareTo ((int)88), EnInt32
.A
.CompareTo (EnInt32
.B
), "i32#1");
1004 Assert
.AreEqual (((int)88).CompareTo (int.MinValue
), EnInt32
.B
.CompareTo (EnInt32
.A
), "i32#2");
1006 Assert
.AreEqual (uint.MinValue
.CompareTo (uint.MinValue
), EnUInt32
.A
.CompareTo (EnUInt32
.A
), "u32#0");
1007 Assert
.AreEqual (uint.MinValue
.CompareTo ((uint)99), EnUInt32
.A
.CompareTo (EnUInt32
.B
), "u32#1");
1008 Assert
.AreEqual (((uint)99).CompareTo (uint.MinValue
), EnUInt32
.B
.CompareTo (EnUInt32
.A
), "u32#2");
1010 Assert
.AreEqual (long.MinValue
.CompareTo (long.MinValue
), EnInt64
.A
.CompareTo (EnInt64
.A
), "i64#0");
1011 Assert
.AreEqual (long.MinValue
.CompareTo ((long)456), EnInt64
.A
.CompareTo (EnInt64
.D
), "i64#1");
1012 Assert
.AreEqual (((long)456).CompareTo (long.MinValue
), EnInt64
.D
.CompareTo (EnInt64
.A
), "i64#2");
1014 Assert
.AreEqual (ulong.MinValue
.CompareTo (ulong.MinValue
), EnUInt64
.A
.CompareTo (EnUInt64
.A
), "u64#0");
1015 Assert
.AreEqual (ulong.MinValue
.CompareTo ((ulong)789), EnUInt64
.A
.CompareTo (EnUInt64
.D
), "u64#1");
1016 Assert
.AreEqual (((ulong)789).CompareTo (ulong.MinValue
), EnUInt64
.D
.CompareTo (EnUInt64
.A
), "u64#2");
1020 // This is used to verify that the output matches the specified behavior
1021 // See bug #371559 for details.
1024 public void CompareOrder_FromGetNames ()
1026 Array r
= Enum
.GetValues (typeof (EnumByte
));
1027 Assert
.AreEqual (5, r
.Length
);
1028 Assert
.AreEqual ("byte_Cc", Enum
.GetName (typeof (EnumByte
), (EnumByte
)(0x00)));
1029 Assert
.AreEqual ("byte_Cc", r
.GetValue (0).ToString ());
1030 Assert
.AreEqual ("byte_Aa", Enum
.GetName (typeof (EnumByte
), (EnumByte
)(0x05)));
1031 Assert
.AreEqual ("byte_Aa", r
.GetValue (1).ToString ());
1032 Assert
.AreEqual ("byte_Ff", Enum
.GetName (typeof (EnumByte
), (EnumByte
)(0x64)));
1033 Assert
.AreEqual ("byte_Ff", r
.GetValue (2).ToString ());
1034 Assert
.AreEqual ("byte_Dd", Enum
.GetName (typeof (EnumByte
), (EnumByte
)(0x7F)));
1035 Assert
.AreEqual ("byte_Dd", r
.GetValue (3).ToString ());
1036 Assert
.AreEqual ("byte_Bb", Enum
.GetName (typeof (EnumByte
), (EnumByte
)(0xFF)));
1037 Assert
.AreEqual ("byte_Bb", r
.GetValue (4).ToString ());
1039 r
= Enum
.GetValues (typeof (EnumSByte
));
1040 Assert
.AreEqual (6, r
.Length
);
1041 Assert
.AreEqual ("sbyte_Cc", Enum
.GetName (typeof (EnumSByte
), (EnumSByte
)(0x00)));
1042 Assert
.AreEqual ("sbyte_Cc", r
.GetValue (0).ToString ());
1043 Assert
.AreEqual ("sbyte_Aa", Enum
.GetName (typeof (EnumSByte
), (EnumSByte
)(0x05)));
1044 Assert
.AreEqual ("sbyte_Aa", r
.GetValue (1).ToString ());
1045 Assert
.AreEqual ("sbyte_Ff", Enum
.GetName (typeof (EnumSByte
), (EnumSByte
)(0x64)));
1046 Assert
.AreEqual ("sbyte_Ff", r
.GetValue (2).ToString ());
1047 Assert
.AreEqual ("sbyte_Ee", Enum
.GetName (typeof (EnumSByte
), (EnumSByte
)(0x7F)));
1048 Assert
.AreEqual ("sbyte_Ee", r
.GetValue (3).ToString ());
1049 Assert
.AreEqual ("sbyte_Bb", Enum
.GetName (typeof (EnumSByte
), unchecked ((EnumSByte
)(0xF0))));
1050 Assert
.AreEqual ("sbyte_Bb", r
.GetValue (4).ToString ());
1051 Assert
.AreEqual ("sbyte_Dd", Enum
.GetName (typeof (EnumSByte
), unchecked ((EnumSByte
)(0xFF))));
1052 Assert
.AreEqual ("sbyte_Dd", r
.GetValue (5).ToString ());
1054 r
= Enum
.GetValues (typeof (EnumUShort
));
1055 Assert
.AreEqual (5, r
.Length
);
1056 Assert
.AreEqual ("ushort_Cc", Enum
.GetName (typeof (EnumUShort
), (EnumUShort
)(0x0000)));
1057 Assert
.AreEqual ("ushort_Cc", r
.GetValue (0).ToString ());
1058 Assert
.AreEqual ("ushort_Aa", Enum
.GetName (typeof (EnumUShort
), (EnumUShort
)(0x0005)));
1059 Assert
.AreEqual ("ushort_Aa", r
.GetValue (1).ToString ());
1060 Assert
.AreEqual ("ushort_Ff", Enum
.GetName (typeof (EnumUShort
), (EnumUShort
)(0x0064)));
1061 Assert
.AreEqual ("ushort_Ff", r
.GetValue (2).ToString ());
1062 Assert
.AreEqual ("ushort_Ee", Enum
.GetName (typeof (EnumUShort
), (EnumUShort
)(0x7FFF)));
1063 Assert
.AreEqual ("ushort_Ee", r
.GetValue (3).ToString ());
1064 Assert
.AreEqual ("ushort_Bb", Enum
.GetName (typeof (EnumUShort
), (EnumUShort
)(0xFF00)));
1065 Assert
.AreEqual ("ushort_Bb", r
.GetValue (4).ToString ());
1067 r
= Enum
.GetValues (typeof (EnumShort
));
1068 Assert
.AreEqual (6, r
.Length
);
1069 Assert
.AreEqual ("short_Cc", Enum
.GetName (typeof (EnumShort
), (EnumShort
)(0x0000)));
1070 Assert
.AreEqual ("short_Cc", r
.GetValue (0).ToString ());
1071 Assert
.AreEqual ("short_Aa", Enum
.GetName (typeof (EnumShort
), (EnumShort
)(0x0005)));
1072 Assert
.AreEqual ("short_Aa", r
.GetValue (1).ToString ());
1073 Assert
.AreEqual ("short_Ff", Enum
.GetName (typeof (EnumShort
), (EnumShort
)(0x0064)));
1074 Assert
.AreEqual ("short_Ff", r
.GetValue (2).ToString ());
1075 Assert
.AreEqual ("short_Ee", Enum
.GetName (typeof (EnumShort
), (EnumShort
)(0x7FFF)));
1076 Assert
.AreEqual ("short_Ee", r
.GetValue (3).ToString ());
1077 Assert
.AreEqual ("short_Bb", Enum
.GetName (typeof (EnumShort
), unchecked ((EnumShort
)(0xFF00))));
1078 Assert
.AreEqual ("short_Bb", r
.GetValue (4).ToString ());
1079 Assert
.AreEqual ("short_Dd", Enum
.GetName (typeof (EnumShort
), unchecked ((EnumShort
)(0xFFFF))));
1080 Assert
.AreEqual ("short_Dd", r
.GetValue (5).ToString ());
1082 r
= Enum
.GetValues (typeof (EnumUInt
));
1083 Assert
.AreEqual (4, r
.Length
);
1084 Assert
.AreEqual ("uint_Cc", Enum
.GetName (typeof (EnumUInt
), (EnumUInt
)(0x00000000)));
1085 Assert
.AreEqual ("uint_Cc", r
.GetValue (0).ToString ());
1086 Assert
.AreEqual ("uint_Aa", Enum
.GetName (typeof (EnumUInt
), (EnumUInt
)(0x00000005)));
1087 Assert
.AreEqual ("uint_Aa", r
.GetValue (1).ToString ());
1088 Assert
.AreEqual ("uint_Ff", Enum
.GetName (typeof (EnumUInt
), (EnumUInt
)(0x00000064)));
1089 Assert
.AreEqual ("uint_Ff", r
.GetValue (2).ToString ());
1090 Assert
.AreEqual ("uint_Ee", Enum
.GetName (typeof (EnumUInt
), (EnumUInt
)(0x7FFFFFFF)));
1091 Assert
.AreEqual ("uint_Ee", r
.GetValue (3).ToString ());
1093 r
= Enum
.GetValues (typeof (EnumInt
));
1094 Assert
.AreEqual (6, r
.Length
);
1095 Assert
.AreEqual ("int_Cc", Enum
.GetName (typeof (EnumInt
), (EnumInt
)(0x00000000)));
1096 Assert
.AreEqual ("int_Cc", r
.GetValue (0).ToString ());
1097 Assert
.AreEqual ("int_Aa", Enum
.GetName (typeof (EnumInt
), (EnumInt
)(0x00000005)));
1098 Assert
.AreEqual ("int_Aa", r
.GetValue (1).ToString ());
1099 Assert
.AreEqual ("int_Ff", Enum
.GetName (typeof (EnumInt
), (EnumInt
)(0x00000064)));
1100 Assert
.AreEqual ("int_Ff", r
.GetValue (2).ToString ());
1101 Assert
.AreEqual ("int_Ee", Enum
.GetName (typeof (EnumInt
), (EnumInt
)(0x7FFFFFFF)));
1102 Assert
.AreEqual ("int_Ee", r
.GetValue (3).ToString ());
1103 Assert
.AreEqual ("int_Bb", Enum
.GetName (typeof (EnumInt
), unchecked ((EnumInt
)(0xFFFF0000))));
1104 Assert
.AreEqual ("int_Bb", r
.GetValue (4).ToString ());
1105 Assert
.AreEqual ("int_Dd", Enum
.GetName (typeof (EnumInt
), unchecked ((EnumInt
)(0xFFFFFFFF))));
1106 Assert
.AreEqual ("int_Dd", r
.GetValue (5).ToString ());
1108 r
= Enum
.GetValues (typeof (EnumULong
));
1109 Assert
.AreEqual (5, r
.Length
);
1110 Assert
.AreEqual ("ulong_Cc", Enum
.GetName (typeof (EnumULong
), (EnumULong
)(0x0000000000000000)));
1111 Assert
.AreEqual ("ulong_Cc", r
.GetValue (0).ToString ());
1112 Assert
.AreEqual ("ulong_Cc", Enum
.GetName (typeof (EnumULong
), (EnumULong
)(0x0000000000000000)));
1113 Assert
.AreEqual ("ulong_Aa", r
.GetValue (1).ToString ());
1114 Assert
.AreEqual ("ulong_Aa", Enum
.GetName (typeof (EnumULong
), (EnumULong
)(0x0000000000000005)));
1115 Assert
.AreEqual ("ulong_Ff", r
.GetValue (2).ToString ());
1116 Assert
.AreEqual ("ulong_Ff", Enum
.GetName (typeof (EnumULong
), (EnumULong
)(0x0000000000000064)));
1117 Assert
.AreEqual ("ulong_Ee", r
.GetValue (3).ToString ());
1118 Assert
.AreEqual ("ulong_Ee", Enum
.GetName (typeof (EnumULong
), (EnumULong
)(0x7FFFFFFFFFFFFFFF)));
1119 Assert
.AreEqual ("ulong_Bb", r
.GetValue (4).ToString ());
1121 r
= Enum
.GetValues (typeof (EnumLong
));
1122 Assert
.AreEqual (6, r
.Length
);
1123 Assert
.AreEqual ("long_Cc", Enum
.GetName (typeof (EnumLong
), (EnumLong
)(0x0000000000000000)));
1124 Assert
.AreEqual ("long_Cc", r
.GetValue (0).ToString ());
1125 Assert
.AreEqual ("long_Aa", Enum
.GetName (typeof (EnumLong
), (EnumLong
)(0x0000000000000005)));
1126 Assert
.AreEqual ("long_Aa", r
.GetValue (1).ToString ());
1127 Assert
.AreEqual ("long_Ff", Enum
.GetName (typeof (EnumLong
), (EnumLong
)(0x0000000000000064)));
1128 Assert
.AreEqual ("long_Ff", r
.GetValue (2).ToString ());
1129 Assert
.AreEqual ("long_Ee", Enum
.GetName (typeof (EnumLong
), (EnumLong
)(0x7FFFFFFFFFFFFFFF)));
1130 Assert
.AreEqual ("long_Ee", r
.GetValue (3).ToString ());
1131 Assert
.AreEqual ("long_Bb", Enum
.GetName (typeof (EnumLong
), unchecked ((EnumLong
)(0xFFFFFFFF00000000))));
1132 Assert
.AreEqual ("long_Bb", r
.GetValue (4).ToString ());
1133 Assert
.AreEqual ("long_Dd", Enum
.GetName (typeof (EnumLong
), unchecked ((EnumLong
)(0xFFFFFFFFFFFFFFFF))));
1134 Assert
.AreEqual ("long_Dd", r
.GetValue (5).ToString ());
1143 // Our first implementation used to crash
1145 public void HasFlagTest ()
1147 Foo f
= Foo
.negative
;
1148 bool has
= f
.HasFlag (Foo
.negative
);
1161 enum SomeByteEnum
: byte
1169 enum SomeInt64Enum
: long
1176 enum TestShortEnum
: short
1205 enum FlagsNegativeTestEnum
1210 Negative
= unchecked ((int) 0xFFFF0000)
1229 enum TestingEnum3
: ulong
1234 Test
= ulong.MaxValue
1237 enum TestingEnum4
: byte
1242 Test
= byte.MaxValue
1245 enum TestingEnum5
: short
1250 Test
= short.MaxValue
1285 enum EnInt8
: sbyte{
1291 enum EnUInt8
: byte {
1297 enum EnInt16
: short{
1303 enum EnUInt16
: ushort {
1304 A
= UInt16
.MinValue
,
1306 C
= UInt16
.MaxValue
,
1315 enum EnUInt32
: uint {
1316 A
= UInt32
.MinValue
,
1318 C
= UInt32
.MaxValue
,
1321 enum EnInt64
: long{
1328 enum EnUInt64
: ulong {
1329 A
= UInt64
.MinValue
,
1331 C
= UInt64
.MaxValue
,
1335 enum EnumByte
: byte {
1343 enum EnumSByte
: sbyte {
1345 sbyte_Bb
= unchecked ((sbyte) 0xf0),
1352 enum EnumShort
: short
1355 short_Bb
= unchecked((short)0xFF00),
1362 enum EnumUShort
: ushort
1365 ushort_Bb
= unchecked((int)0xFF00),
1374 int_Bb
= unchecked((int)0xFFFF0000),
1377 int_Ee
= 0x7FFFFFFF,
1381 enum EnumUInt
: uint
1385 uint_Ee
= 0x7FFFFFFF,
1389 enum EnumLong
: long
1392 long_Bb
= unchecked((long)0xffffFFFF00000000),
1395 long_Ee
= 0x7FFFFFFFffffffff,
1399 enum EnumULong
: ulong
1402 ulong_Bb
= unchecked((ulong)0xffffFFFF00000000),
1404 ulong_Ee
= 0x7FFFFFFFffffffff,
1412 System_Math
= First
,