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");
639 Assert.IsTrue (ex.Message.IndexOf ("'huh?'") != -1, "#G5");
641 Assert.IsTrue (ex.Message.IndexOf ("huh?") != -1, "#G5");
643 Assert.IsNull (ex.ParamName, "#G6");
648 TestingEnum x = TestingEnum.Test;
649 Enum.Parse (x.GetType (), bad, false);
651 } catch (ArgumentException ex) {
652 // Requested value 'test' was not found
653 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#H2");
654 Assert.IsNull (ex.InnerException, "#H3");
655 Assert.IsNotNull (ex.Message, "#H4");
657 Assert.IsTrue (ex.Message.IndexOf ("'test'") != -1, "#H5");
659 Assert.IsTrue (ex.Message.IndexOf ("test") != -1, "#H5");
661 Assert.IsNull (ex.ParamName, "#H6");
664 TestingEnum t1 = new TestingEnum ();
665 Assert.AreEqual (TestingEnum.This, Enum.Parse (t1.GetType (), "this", true), "#I1");
666 Assert.AreEqual (TestingEnum.Is, Enum.Parse (t1.GetType (), "is", true), "#I2");
667 Assert.AreEqual (TestingEnum.A, Enum.Parse (t1.GetType (), "a", true), "#I3");
668 Assert.AreEqual (TestingEnum.Test, Enum.Parse (t1.GetType (), "test", true), "#I4");
669 Assert.AreEqual (TestingEnum.Test, Enum.Parse (t1.GetType (), " \n\ntest\t", true), "#I5");
671 Assert.AreEqual (TestingEnum.Is, Enum.Parse (t1.GetType (), "This,is", true), "#J1");
672 Assert.AreEqual (TestingEnum.Test, Enum.Parse (t1.GetType (), "This,test", true), "#J2");
673 Assert.AreEqual (TestingEnum.Test, Enum.Parse (t1.GetType (), "This,is,A", true), "#J3");
674 Assert.AreEqual (TestingEnum.Test, Enum.Parse (t1.GetType (), " \n\tThis \t\n, is,a \n", true), "#J4");
678 public void ParseValue ()
680 TestingEnum3 t1 = new TestingEnum3 ();
681 Assert.AreEqual (TestingEnum3.Test, Enum.Parse (t1.GetType (), "18446744073709551615", false));
686 public void TryParseErrors ()
691 success = Enum.TryParse<TestingEnum> (null, out result);
692 Assert.AreEqual (false, success, "#A1");
693 Assert.AreEqual (TestingEnum.This, result, "#A2");
695 success = Enum.TryParse<TestingEnum> ("WrongValue", out result);
696 Assert.AreEqual (false, success, "#B1");
697 Assert.AreEqual (TestingEnum.This, result, "#B2");
699 success = Enum.TryParse<TestingEnum> (String.Empty, out result);
700 Assert.AreEqual (false, success, "#C1");
701 Assert.AreEqual (TestingEnum.This, result, "#C2");
703 success = Enum.TryParse<TestingEnum> (" ", out result);
704 Assert.AreEqual (false, success, "#D1");
705 Assert.AreEqual (TestingEnum.This, result, "#D2");
707 // TryParse throws ArgumentException if TEnum is not an enumeration type
710 Enum.TryParse<int> ("31416", out n);
712 } catch (ArgumentException ex) {
713 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#E2");
714 Assert.IsNull (ex.InnerException, "#E3");
715 Assert.IsNotNull (ex.Message, "#E4");
716 Assert.IsNotNull (ex.ParamName, "#E5");
717 Assert.AreEqual ("enumType", ex.ParamName, "#E6");
722 public void TryParse ()
727 success = Enum.TryParse<TestingEnum> ("Is", out result);
728 Assert.AreEqual (true, success, "#A1");
729 Assert.AreEqual (TestingEnum.Is, result, "#A2");
731 success = Enum.TryParse<TestingEnum> ("100", out result);
732 Assert.AreEqual (true, success, "#C1");
733 Assert.AreEqual (((TestingEnum)100), result, "#C2");
735 success = Enum.TryParse<TestingEnum> ("is", out result);
736 Assert.AreEqual (false, success, "#D1");
737 Assert.AreEqual (TestingEnum.This, result, "#D2");
739 success = Enum.TryParse<TestingEnum> ("is", true, out result);
740 Assert.AreEqual (true, success, "#D1");
741 Assert.AreEqual (TestingEnum.Is, result, "#D2");
743 success = Enum.TryParse<TestingEnum> (" Is ", out result);
744 Assert.AreEqual (true, success, "#E1");
745 Assert.AreEqual (TestingEnum.Is, result, "#E2");
750 public void ToObject_EnumType_Int32 ()
752 object value = Enum.ToObject (typeof (TestingEnum), 0);
753 Assert.AreEqual (TestingEnum.This, value, "#1");
754 value = Enum.ToObject (typeof (TestingEnum), 2);
755 Assert.AreEqual (TestingEnum.A, value, "#2");
760 [Category ("NotDotNet")]
762 public void ToObject_EnumType_UInt64 ()
764 object value = Enum.ToObject (typeof (TestingEnum3), 0);
765 Assert.AreEqual (TestingEnum3.This, value, "#1");
766 value = Enum.ToObject (typeof (TestingEnum3), 1);
767 Assert.AreEqual (TestingEnum3.Is, value, "#2");
768 value = Enum.ToObject (typeof (TestingEnum3), ulong.MaxValue);
769 Assert.AreEqual (TestingEnum3.Test, value, "#3");
773 public void ToObject_EnumType_Byte ()
775 object value = Enum.ToObject (typeof (TestingEnum4), 0);
776 Assert.AreEqual (TestingEnum4.This, value, "#1");
777 value = Enum.ToObject (typeof (TestingEnum4), byte.MaxValue);
778 Assert.AreEqual (TestingEnum4.Test, value, "#2");
782 public void ToObject_EnumType_Int16 ()
784 object value = Enum.ToObject (typeof (TestingEnum5), 0);
785 Assert.AreEqual (TestingEnum5.This, value, "#1");
786 value = Enum.ToObject (typeof (TestingEnum5), short.MaxValue);
787 Assert.AreEqual (TestingEnum5.Test, value, "#2");
791 public void ToObject_EnumType_Bool ()
793 object value = Enum.ToObject (typeof (TestingEnum5), true);
794 Assert.AreEqual (TestingEnum5.Is, value, "#1");
798 public void ToObject_EnumType_Char ()
800 object value = Enum.ToObject (typeof (TestingEnum3), (object) '\0');
801 Assert.AreEqual (TestingEnum3.This, value, "#1");
805 public void ToObject_EnumType_Invalid ()
808 Enum.ToObject (typeof (string), 1);
810 } catch (ArgumentException ex) {
811 // Type provided must be an Enum
812 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
813 Assert.IsNull (ex.InnerException, "#3");
814 Assert.IsNotNull (ex.Message, "#4");
815 Assert.IsNotNull (ex.ParamName, "#5");
816 Assert.AreEqual ("enumType", ex.ParamName, "#6");
821 public void ToObject_EnumType_Null ()
824 Enum.ToObject (null, 1);
826 } catch (ArgumentNullException ex) {
827 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
828 Assert.IsNull (ex.InnerException, "#3");
829 Assert.IsNotNull (ex.Message, "#4");
830 Assert.IsNotNull (ex.ParamName, "#5");
831 Assert.AreEqual ("enumType", ex.ParamName, "#6");
836 public void ToObject_Value_Null ()
839 Enum.ToObject (typeof (TestingEnum), (object) null);
841 } catch (ArgumentNullException ex) {
842 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
843 Assert.IsNull (ex.InnerException, "#3");
844 Assert.IsNotNull (ex.Message, "#4");
845 Assert.IsNotNull (ex.ParamName, "#5");
846 Assert.AreEqual ("value", ex.ParamName, "#6");
851 public void ToObject_Value_Invalid ()
854 Enum.ToObject (typeof (TestingEnum), "This");
856 } catch (ArgumentException ex) {
857 // The value passed in must be an enum base or
858 // an underlying type for an enum, such as an
860 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
861 Assert.IsNull (ex.InnerException, "#3");
862 Assert.IsNotNull (ex.Message, "#4");
863 Assert.IsNotNull (ex.ParamName, "#5");
864 Assert.AreEqual ("value", ex.ParamName, "#6");
869 public void IConvertible_Valid ()
871 IConvertible ic = TestingEnum.This;
872 Assert.AreEqual ("This", ic.ToType (typeof (string), null), "#1");
873 Assert.AreEqual (TestingEnum.This, ic.ToType (typeof (TestingEnum), null), "#2");
874 Assert.AreEqual (TestingEnum.This, ic.ToType (typeof (Enum), null), "#3");
878 public void TestToString ()
880 Assert.AreEqual ("This", TestingEnum.This.ToString (), "#A1");
881 Assert.AreEqual ("Is", TestingEnum.Is.ToString (), "#A2");
882 Assert.AreEqual ("A", TestingEnum.A.ToString (), "#A3");
883 Assert.AreEqual ("Test", TestingEnum.Test.ToString (), "#A4");
885 Enum is1 = TestingEnum.Is;
887 Assert.AreEqual ("1", is1.ToString ("d"), "#B1");
888 Assert.AreEqual ("Is", is1.ToString ("g"), "#B2");
889 Assert.AreEqual ("00000001", is1.ToString ("x"), "#B3");
890 Assert.AreEqual ("Is", is1.ToString ("f"), "#B4");
892 Assert.AreEqual ("b, c", ((SomeEnum) 3).ToString ("f"), "#C1");
893 Assert.AreEqual ("b, c", ((SomeByteEnum) 3).ToString ("f"), "#C2");
894 Assert.AreEqual ("b, c", ((SomeInt64Enum) 3).ToString ("f"), "#C3");
896 Assert.AreEqual ("12", ((SomeEnum) 12).ToString ("f"), "#D1");
897 Assert.AreEqual ("12", ((SomeByteEnum) 12).ToString ("f"), "#D2");
898 Assert.AreEqual ("12", ((SomeInt64Enum) 12).ToString ("f"), "#D3");
902 public void FlagTest ()
904 int [] evalues = new int [4] { 0, 1, 2, 3 };
905 E [] e = new E [4] { E.Aa, E.Bb, E.Cc, E.Dd };
907 for (int i = 0; i < 4; ++i)
908 Assert.AreEqual (e [i].ToString (),
909 Enum.Format (typeof (E), evalues [i], "f"),
912 int invalidValue = 1000;
914 Assert.AreEqual (invalidValue.ToString (),
915 Enum.Format (typeof (E2), invalidValue, "g"),
920 public void FlagTest_Negative ()
922 FlagsNegativeTestEnum t;
924 t = FlagsNegativeTestEnum.None;
925 Assert.AreEqual ("None", t.ToString (), "#01");
926 t = FlagsNegativeTestEnum.One;
927 Assert.AreEqual ("One", t.ToString (), "#02");
931 public void AnotherFormatBugPinned ()
933 Assert.AreEqual ("100", Enum.Format (typeof (E3), 100, "f"));
937 public void LogicBugPinned ()
939 string format = null;
940 string [] names = new string [] { "A", "B", "C", "D", };
941 string [] fmtSpl = null;
942 UE ue = UE.A | UE.B | UE.C | UE.D;
944 //all flags must be in format return
945 format = Enum.Format (typeof (UE), ue, "f");
946 fmtSpl = format.Split (',');
947 for (int i = 0; i < fmtSpl.Length; ++i)
948 fmtSpl [i] = fmtSpl [i].Trim ();
950 foreach (string nval in fmtSpl)
951 Assert.IsTrue (Array.IndexOf (names, nval) >= 0, "#1:" + nval);
953 foreach (string nval in names)
954 Assert.IsTrue (Array.IndexOf (fmtSpl, nval) >= 0, "#2:" + nval);
956 // TODO - ToString with IFormatProviders
959 public void GetHashCode_ShouldBeEqualToUnderlyingType ()
961 Assert.AreEqual (EnInt8.A.GetHashCode(), SByte.MinValue, "i8#0");
962 Assert.AreEqual (EnInt8.B.GetHashCode(), 44, "i8#1");
963 Assert.AreEqual (EnInt8.C.GetHashCode(), SByte.MaxValue, "i8#2");
965 Assert.AreEqual (EnUInt8.A.GetHashCode(), Byte.MinValue, "u8#0");
966 Assert.AreEqual (EnUInt8.B.GetHashCode(), 55, "u8#1");
967 Assert.AreEqual (EnUInt8.C.GetHashCode(), Byte.MaxValue, "u8#2");
969 Assert.AreEqual (EnInt16.A.GetHashCode(), Int16.MinValue, "i16#0");
970 Assert.AreEqual (EnInt16.B.GetHashCode(), 66, "i16#1");
971 Assert.AreEqual (EnInt16.C.GetHashCode(), Int16.MaxValue, "i16#2");
973 Assert.AreEqual (EnUInt16.A.GetHashCode(), UInt16.MinValue, "u16#0");
974 Assert.AreEqual (EnUInt16.B.GetHashCode(), 77, "u16#1");
975 Assert.AreEqual (EnUInt16.C.GetHashCode(), UInt16.MaxValue, "u16#2");
977 Assert.AreEqual (EnInt32.A.GetHashCode(), Int32.MinValue, "i32#0");
978 Assert.AreEqual (EnInt32.B.GetHashCode(), 88, "i32#1");
979 Assert.AreEqual (EnInt32.C.GetHashCode(), Int32.MaxValue, "i32#2");
981 Assert.AreEqual (EnUInt32.A.GetHashCode(), UInt32.MinValue, "u32#0");
982 Assert.AreEqual (EnUInt32.B.GetHashCode(), 99, "u32#1");
983 Assert.AreEqual (EnUInt32.C.GetHashCode(), UInt32.MaxValue.GetHashCode (), "u32#2");
985 Assert.AreEqual (EnInt64.A.GetHashCode(), Int64.MinValue.GetHashCode (), "i64#0");
986 Assert.AreEqual (EnInt64.B.GetHashCode(), 3488924689489L.GetHashCode (), "i64#1");
987 Assert.AreEqual (EnInt64.C.GetHashCode(), Int64.MaxValue.GetHashCode (), "i64#2");
989 Assert.AreEqual (EnUInt64.A.GetHashCode(), UInt64.MinValue.GetHashCode (), "u64#0");
990 Assert.AreEqual (EnUInt64.B.GetHashCode(), 3488924689489L.GetHashCode (), "u64#1");
991 Assert.AreEqual (EnUInt64.C.GetHashCode(), UInt64.MaxValue.GetHashCode (), "u64#2");
995 public void CompareTo_NotEqualToUnderlyingType ()
997 Assert.AreEqual (0, EnInt8.A.CompareTo (EnInt8.A), "i8#0");
998 Assert.AreEqual (-1, EnInt8.A.CompareTo (EnInt8.B), "i8#1");
999 Assert.AreEqual (1, EnInt8.B.CompareTo (EnInt8.A), "i8#2");
1001 Assert.AreEqual (0, EnUInt8.A.CompareTo (EnUInt8.A), "ui8#0");
1002 Assert.AreEqual (-1, EnUInt8.A.CompareTo (EnUInt8.B), "ui8#1");
1003 Assert.AreEqual (1, EnUInt8.B.CompareTo (EnUInt8.A),"ui8#2");
1005 Assert.AreEqual (0, EnInt16.A.CompareTo (EnInt16.A), "i16#0");
1006 Assert.AreEqual (-1, EnInt16.A.CompareTo (EnInt16.B), "i16#1");
1007 Assert.AreEqual (1, EnInt16.B.CompareTo (EnInt16.A), "i16#2");
1009 Assert.AreEqual (0, EnUInt16.A.CompareTo (EnUInt16.A), "ui16#0");
1010 Assert.AreEqual (-1, EnUInt16.A.CompareTo (EnUInt16.B), "ui16#1");
1011 Assert.AreEqual (1, EnUInt16.B.CompareTo (EnUInt16.A), "ui16#2");
1013 Assert.AreEqual (int.MinValue.CompareTo (int.MinValue), EnInt32.A.CompareTo (EnInt32.A), "i32#0");
1014 Assert.AreEqual (int.MinValue.CompareTo ((int)88), EnInt32.A.CompareTo (EnInt32.B), "i32#1");
1015 Assert.AreEqual (((int)88).CompareTo (int.MinValue), EnInt32.B.CompareTo (EnInt32.A), "i32#2");
1017 Assert.AreEqual (uint.MinValue.CompareTo (uint.MinValue), EnUInt32.A.CompareTo (EnUInt32.A), "u32#0");
1018 Assert.AreEqual (uint.MinValue.CompareTo ((uint)99), EnUInt32.A.CompareTo (EnUInt32.B), "u32#1");
1019 Assert.AreEqual (((uint)99).CompareTo (uint.MinValue), EnUInt32.B.CompareTo (EnUInt32.A), "u32#2");
1021 Assert.AreEqual (long.MinValue.CompareTo (long.MinValue), EnInt64.A.CompareTo (EnInt64.A), "i64#0");
1022 Assert.AreEqual (long.MinValue.CompareTo ((long)456), EnInt64.A.CompareTo (EnInt64.D), "i64#1");
1023 Assert.AreEqual (((long)456).CompareTo (long.MinValue), EnInt64.D.CompareTo (EnInt64.A), "i64#2");
1025 Assert.AreEqual (ulong.MinValue.CompareTo (ulong.MinValue), EnUInt64.A.CompareTo (EnUInt64.A), "u64#0");
1026 Assert.AreEqual (ulong.MinValue.CompareTo ((ulong)789), EnUInt64.A.CompareTo (EnUInt64.D), "u64#1");
1027 Assert.AreEqual (((ulong)789).CompareTo (ulong.MinValue), EnUInt64.D.CompareTo (EnUInt64.A), "u64#2");
1031 // This is used to verify that the output matches the specified behavior
1032 // See bug #371559 for details.
1035 public void CompareOrder_FromGetNames ()
1037 Array r = Enum.GetValues (typeof (EnumByte));
1038 Assert.AreEqual (5, r.Length);
1039 Assert.AreEqual ("byte_Cc", Enum.GetName (typeof (EnumByte), (EnumByte)(0x00)));
1040 Assert.AreEqual ("byte_Cc", r.GetValue (0).ToString ());
1041 Assert.AreEqual ("byte_Aa", Enum.GetName (typeof (EnumByte), (EnumByte)(0x05)));
1042 Assert.AreEqual ("byte_Aa", r.GetValue (1).ToString ());
1043 Assert.AreEqual ("byte_Ff", Enum.GetName (typeof (EnumByte), (EnumByte)(0x64)));
1044 Assert.AreEqual ("byte_Ff", r.GetValue (2).ToString ());
1045 Assert.AreEqual ("byte_Dd", Enum.GetName (typeof (EnumByte), (EnumByte)(0x7F)));
1046 Assert.AreEqual ("byte_Dd", r.GetValue (3).ToString ());
1047 Assert.AreEqual ("byte_Bb", Enum.GetName (typeof (EnumByte), (EnumByte)(0xFF)));
1048 Assert.AreEqual ("byte_Bb", r.GetValue (4).ToString ());
1050 r = Enum.GetValues (typeof (EnumSByte));
1051 Assert.AreEqual (6, r.Length);
1052 Assert.AreEqual ("sbyte_Cc", Enum.GetName (typeof (EnumSByte), (EnumSByte)(0x00)));
1053 Assert.AreEqual ("sbyte_Cc", r.GetValue (0).ToString ());
1054 Assert.AreEqual ("sbyte_Aa", Enum.GetName (typeof (EnumSByte), (EnumSByte)(0x05)));
1055 Assert.AreEqual ("sbyte_Aa", r.GetValue (1).ToString ());
1056 Assert.AreEqual ("sbyte_Ff", Enum.GetName (typeof (EnumSByte), (EnumSByte)(0x64)));
1057 Assert.AreEqual ("sbyte_Ff", r.GetValue (2).ToString ());
1058 Assert.AreEqual ("sbyte_Ee", Enum.GetName (typeof (EnumSByte), (EnumSByte)(0x7F)));
1059 Assert.AreEqual ("sbyte_Ee", r.GetValue (3).ToString ());
1060 Assert.AreEqual ("sbyte_Bb", Enum.GetName (typeof (EnumSByte), unchecked ((EnumSByte)(0xF0))));
1061 Assert.AreEqual ("sbyte_Bb", r.GetValue (4).ToString ());
1062 Assert.AreEqual ("sbyte_Dd", Enum.GetName (typeof (EnumSByte), unchecked ((EnumSByte)(0xFF))));
1063 Assert.AreEqual ("sbyte_Dd", r.GetValue (5).ToString ());
1065 r = Enum.GetValues (typeof (EnumUShort));
1066 Assert.AreEqual (5, r.Length);
1067 Assert.AreEqual ("ushort_Cc", Enum.GetName (typeof (EnumUShort), (EnumUShort)(0x0000)));
1068 Assert.AreEqual ("ushort_Cc", r.GetValue (0).ToString ());
1069 Assert.AreEqual ("ushort_Aa", Enum.GetName (typeof (EnumUShort), (EnumUShort)(0x0005)));
1070 Assert.AreEqual ("ushort_Aa", r.GetValue (1).ToString ());
1071 Assert.AreEqual ("ushort_Ff", Enum.GetName (typeof (EnumUShort), (EnumUShort)(0x0064)));
1072 Assert.AreEqual ("ushort_Ff", r.GetValue (2).ToString ());
1073 Assert.AreEqual ("ushort_Ee", Enum.GetName (typeof (EnumUShort), (EnumUShort)(0x7FFF)));
1074 Assert.AreEqual ("ushort_Ee", r.GetValue (3).ToString ());
1075 Assert.AreEqual ("ushort_Bb", Enum.GetName (typeof (EnumUShort), (EnumUShort)(0xFF00)));
1076 Assert.AreEqual ("ushort_Bb", r.GetValue (4).ToString ());
1078 r = Enum.GetValues (typeof (EnumShort));
1079 Assert.AreEqual (6, r.Length);
1080 Assert.AreEqual ("short_Cc", Enum.GetName (typeof (EnumShort), (EnumShort)(0x0000)));
1081 Assert.AreEqual ("short_Cc", r.GetValue (0).ToString ());
1082 Assert.AreEqual ("short_Aa", Enum.GetName (typeof (EnumShort), (EnumShort)(0x0005)));
1083 Assert.AreEqual ("short_Aa", r.GetValue (1).ToString ());
1084 Assert.AreEqual ("short_Ff", Enum.GetName (typeof (EnumShort), (EnumShort)(0x0064)));
1085 Assert.AreEqual ("short_Ff", r.GetValue (2).ToString ());
1086 Assert.AreEqual ("short_Ee", Enum.GetName (typeof (EnumShort), (EnumShort)(0x7FFF)));
1087 Assert.AreEqual ("short_Ee", r.GetValue (3).ToString ());
1088 Assert.AreEqual ("short_Bb", Enum.GetName (typeof (EnumShort), unchecked ((EnumShort)(0xFF00))));
1089 Assert.AreEqual ("short_Bb", r.GetValue (4).ToString ());
1090 Assert.AreEqual ("short_Dd", Enum.GetName (typeof (EnumShort), unchecked ((EnumShort)(0xFFFF))));
1091 Assert.AreEqual ("short_Dd", r.GetValue (5).ToString ());
1093 r = Enum.GetValues (typeof (EnumUInt));
1094 Assert.AreEqual (4, r.Length);
1095 Assert.AreEqual ("uint_Cc", Enum.GetName (typeof (EnumUInt), (EnumUInt)(0x00000000)));
1096 Assert.AreEqual ("uint_Cc", r.GetValue (0).ToString ());
1097 Assert.AreEqual ("uint_Aa", Enum.GetName (typeof (EnumUInt), (EnumUInt)(0x00000005)));
1098 Assert.AreEqual ("uint_Aa", r.GetValue (1).ToString ());
1099 Assert.AreEqual ("uint_Ff", Enum.GetName (typeof (EnumUInt), (EnumUInt)(0x00000064)));
1100 Assert.AreEqual ("uint_Ff", r.GetValue (2).ToString ());
1101 Assert.AreEqual ("uint_Ee", Enum.GetName (typeof (EnumUInt), (EnumUInt)(0x7FFFFFFF)));
1102 Assert.AreEqual ("uint_Ee", r.GetValue (3).ToString ());
1104 r = Enum.GetValues (typeof (EnumInt));
1105 Assert.AreEqual (6, r.Length);
1106 Assert.AreEqual ("int_Cc", Enum.GetName (typeof (EnumInt), (EnumInt)(0x00000000)));
1107 Assert.AreEqual ("int_Cc", r.GetValue (0).ToString ());
1108 Assert.AreEqual ("int_Aa", Enum.GetName (typeof (EnumInt), (EnumInt)(0x00000005)));
1109 Assert.AreEqual ("int_Aa", r.GetValue (1).ToString ());
1110 Assert.AreEqual ("int_Ff", Enum.GetName (typeof (EnumInt), (EnumInt)(0x00000064)));
1111 Assert.AreEqual ("int_Ff", r.GetValue (2).ToString ());
1112 Assert.AreEqual ("int_Ee", Enum.GetName (typeof (EnumInt), (EnumInt)(0x7FFFFFFF)));
1113 Assert.AreEqual ("int_Ee", r.GetValue (3).ToString ());
1114 Assert.AreEqual ("int_Bb", Enum.GetName (typeof (EnumInt), unchecked ((EnumInt)(0xFFFF0000))));
1115 Assert.AreEqual ("int_Bb", r.GetValue (4).ToString ());
1116 Assert.AreEqual ("int_Dd", Enum.GetName (typeof (EnumInt), unchecked ((EnumInt)(0xFFFFFFFF))));
1117 Assert.AreEqual ("int_Dd", r.GetValue (5).ToString ());
1119 r = Enum.GetValues (typeof (EnumULong));
1120 Assert.AreEqual (5, r.Length);
1121 Assert.AreEqual ("ulong_Cc", Enum.GetName (typeof (EnumULong), (EnumULong)(0x0000000000000000)));
1122 Assert.AreEqual ("ulong_Cc", r.GetValue (0).ToString ());
1123 Assert.AreEqual ("ulong_Cc", Enum.GetName (typeof (EnumULong), (EnumULong)(0x0000000000000000)));
1124 Assert.AreEqual ("ulong_Aa", r.GetValue (1).ToString ());
1125 Assert.AreEqual ("ulong_Aa", Enum.GetName (typeof (EnumULong), (EnumULong)(0x0000000000000005)));
1126 Assert.AreEqual ("ulong_Ff", r.GetValue (2).ToString ());
1127 Assert.AreEqual ("ulong_Ff", Enum.GetName (typeof (EnumULong), (EnumULong)(0x0000000000000064)));
1128 Assert.AreEqual ("ulong_Ee", r.GetValue (3).ToString ());
1129 Assert.AreEqual ("ulong_Ee", Enum.GetName (typeof (EnumULong), (EnumULong)(0x7FFFFFFFFFFFFFFF)));
1130 Assert.AreEqual ("ulong_Bb", r.GetValue (4).ToString ());
1132 r = Enum.GetValues (typeof (EnumLong));
1133 Assert.AreEqual (6, r.Length);
1134 Assert.AreEqual ("long_Cc", Enum.GetName (typeof (EnumLong), (EnumLong)(0x0000000000000000)));
1135 Assert.AreEqual ("long_Cc", r.GetValue (0).ToString ());
1136 Assert.AreEqual ("long_Aa", Enum.GetName (typeof (EnumLong), (EnumLong)(0x0000000000000005)));
1137 Assert.AreEqual ("long_Aa", r.GetValue (1).ToString ());
1138 Assert.AreEqual ("long_Ff", Enum.GetName (typeof (EnumLong), (EnumLong)(0x0000000000000064)));
1139 Assert.AreEqual ("long_Ff", r.GetValue (2).ToString ());
1140 Assert.AreEqual ("long_Ee", Enum.GetName (typeof (EnumLong), (EnumLong)(0x7FFFFFFFFFFFFFFF)));
1141 Assert.AreEqual ("long_Ee", r.GetValue (3).ToString ());
1142 Assert.AreEqual ("long_Bb", Enum.GetName (typeof (EnumLong), unchecked ((EnumLong)(0xFFFFFFFF00000000))));
1143 Assert.AreEqual ("long_Bb", r.GetValue (4).ToString ());
1144 Assert.AreEqual ("long_Dd", Enum.GetName (typeof (EnumLong), unchecked ((EnumLong)(0xFFFFFFFFFFFFFFFF))));
1145 Assert.AreEqual ("long_Dd", r.GetValue (5).ToString ());
1154 // Our first implementation used to crash
1156 public void HasFlagTest ()
1158 Foo f = Foo.negative;
1159 bool has = f.HasFlag (Foo.negative);
1172 enum SomeByteEnum : byte
1180 enum SomeInt64Enum : long
1187 enum TestShortEnum : short
1216 enum FlagsNegativeTestEnum
1221 Negative = unchecked ((int) 0xFFFF0000)
1240 enum TestingEnum3 : ulong
1245 Test = ulong.MaxValue
1248 enum TestingEnum4 : byte
1253 Test = byte.MaxValue
1256 enum TestingEnum5 : short
1261 Test = short.MaxValue
1296 enum EnInt8 : sbyte{
1302 enum EnUInt8 : byte {
1308 enum EnInt16 : short{
1314 enum EnUInt16 : ushort {
1315 A = UInt16.MinValue,
1317 C = UInt16.MaxValue,
1326 enum EnUInt32 : uint {
1327 A = UInt32.MinValue,
1329 C = UInt32.MaxValue,
1332 enum EnInt64 : long{
1339 enum EnUInt64 : ulong {
1340 A = UInt64.MinValue,
1342 C = UInt64.MaxValue,
1346 enum EnumByte : byte {
1354 enum EnumSByte : sbyte {
1356 sbyte_Bb = unchecked ((sbyte) 0xf0),
1363 enum EnumShort : short
1366 short_Bb = unchecked((short)0xFF00),
1373 enum EnumUShort : ushort
1376 ushort_Bb = unchecked((int)0xFF00),
1385 int_Bb = unchecked((int)0xFFFF0000),
1388 int_Ee = 0x7FFFFFFF,
1392 enum EnumUInt : uint
1396 uint_Ee = 0x7FFFFFFF,
1400 enum EnumLong : long
1403 long_Bb = unchecked((long)0xffffFFFF00000000),
1406 long_Ee = 0x7FFFFFFFffffffff,
1410 enum EnumULong : ulong
1413 ulong_Bb = unchecked((ulong)0xffffFFFF00000000),
1415 ulong_Ee = 0x7FFFFFFFffffffff,
1423 System_Math = First,