mcs/class/corlib/Test/System/EnumTest.cs

   1 // EnumTest.cs - NUnit Test Cases for the System.Enum class
   2 //
   3 // David Brandt (bucky@keystreams.com)
   4 // Gert Driesen (drieseng@users.sourceforge.net)
   5 //
   6 // (C) Ximian, Inc.  http://www.ximian.com
   7 //
   8
   9 using System;
  10 using System.IO;
  11 using System.Reflection;
  12
  13 using NUnit.Framework;
  14
  15 namespace MonoTests.System
  16 {
  17         [TestFixture]
  18         public class EnumTest
  19         {
  20                 [Test]
  21                 public void TestCompareTo ()
  22                 {
  23                         Enum e1 = new TestingEnum ();
  24                         Enum e2 = new TestingEnum ();
  25                         Enum e3 = new TestingEnum2 ();
  26
  27                         Assert.AreEqual (0, e1.CompareTo (e1), "#A1");
  28                         Assert.AreEqual (0, e1.CompareTo (e2), "#A2");
  29
  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");
  35
  36                         try {
  37                                 e1.CompareTo (e3);
  38                                 Assert.Fail ("#C1");
  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");
  49                         }
  50
  51                         try {
  52                                 ((Enum) e1).CompareTo ((Enum) e3);
  53                                 Assert.Fail ("#D1");
  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");
  64                         }
  65                 }
  66
  67                 [Test]
  68                 public void TestEquals ()
  69                 {
  70                         Enum e1 = new TestingEnum ();
  71                         Enum e2 = new TestingEnum ();
  72                         Enum e3 = new TestingEnum2 ();
  73
  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");
  78                 }
  79
  80                 [Test]
  81                 public void TestFormat_Args ()
  82                 {
  83                         try {
  84                                 TestingEnum x = TestingEnum.Test;
  85                                 Enum.Format (null, x, "G");
  86                                 Assert.Fail ("#A1");
  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");
  93                         }
  94
  95                         try {
  96                                 Enum.Format (typeof (TestingEnum), null, "G");
  97                                 Assert.Fail ("#B1");
  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");
 104                         }
 105
 106                         try {
 107                                 TestingEnum x = TestingEnum.Test;
 108                                 Enum.Format (x.GetType (), x, null);
 109                                 Assert.Fail ("#C1");
 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");
 116                         }
 117
 118                         try {
 119                                 TestingEnum x = TestingEnum.Test;
 120                                 Enum.Format (typeof (string), x, "G");
 121                                 Assert.Fail ("#D1");
 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");
 129                         }
 130
 131                         try {
 132                                 TestingEnum x = TestingEnum.Test;
 133                                 TestingEnum2 y = TestingEnum2.Test;
 134                                 Enum.Format (y.GetType (), x, "G");
 135                                 Assert.Fail ("#E1");
 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");
 146                         }
 147
 148                         try {
 149                                 String bad = "huh?";
 150                                 TestingEnum x = TestingEnum.Test;
 151                                 Enum.Format (x.GetType (), bad, "G");
 152                                 Assert.Fail ("#F1");
 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
 156                                 // was System.Int32
 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");
 163                         }
 164
 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",
 168                                   "y", "z"};
 169                         foreach (string code in codes) {
 170                                 try {
 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");
 179                                 }
 180                         }
 181
 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");
 188                 }
 189
 190                 [Test]
 191                 public void TestFormat_FormatSpecifier ()
 192                 {
 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");
 201
 202                         Assert.AreEqual ("00", TestingEnum4.This.ToString ("x"), "#B1");
 203                         Assert.AreEqual ("00", TestingEnum4.This.ToString ("X"), "#B2");
 204 #if !TARGET_JVM // This appears not to work under .Net
 205                         Assert.AreEqual ("ff", TestingEnum4.Test.ToString ("x"), "#B3");
 206 #endif // TARGET_JVM
 207                         Assert.AreEqual ("FF", TestingEnum4.Test.ToString ("X"), "#B4");
 208
 209                         Assert.AreEqual ("0000", TestingEnum5.This.ToString ("x"), "#C1");
 210                         Assert.AreEqual ("0000", TestingEnum5.This.ToString ("X"), "#C2");
 211 #if !TARGET_JVM // This appears not to work under .Net
 212                         Assert.AreEqual ("7fff", TestingEnum5.Test.ToString ("x"), "#C3");
 213 #endif // TARGET_JVM
 214                         Assert.AreEqual ("7FFF", TestingEnum5.Test.ToString ("X"), "#C4");
 215
 216                         Assert.AreEqual ("00000000", TestingEnum6.This.ToString ("x"), "#D1");
 217                         Assert.AreEqual ("00000000", TestingEnum6.This.ToString ("X"), "#D2");
 218 #if !TARGET_JVM // This appears not to work under .Net
 219                         Assert.AreEqual ("7fffffff", TestingEnum6.Test.ToString ("x"), "#D3");
 220 #endif // TARGET_JVM
 221                         Assert.AreEqual ("7FFFFFFF", TestingEnum6.Test.ToString ("X"), "#D4");
 222
 223                         Assert.AreEqual ("0000000000000000", TestingEnum3.This.ToString ("x"), "#E1");
 224                         Assert.AreEqual ("0000000000000000", TestingEnum3.This.ToString ("X"), "#E2");
 225 #if !TARGET_JVM // This appears not to work under .Net
 226                         Assert.AreEqual ("ffffffffffffffff", TestingEnum3.Test.ToString ("x"), "#E3");
 227 #endif // TARGET_JVM
 228                         Assert.AreEqual ("FFFFFFFFFFFFFFFF", TestingEnum3.Test.ToString ("X"), "#E4");
 229                 }
 230
 231                 [Test]
 232                 public void TestGetHashCode ()
 233                 {
 234                         Enum e1 = new TestingEnum ();
 235                         Enum e2 = new TestingEnum2 ();
 236
 237                         Assert.AreEqual (e1.GetHashCode (), e1.GetHashCode ());
 238                 }
 239
 240                 [Test]
 241                 public void GetName ()
 242                 {
 243                         try {
 244                                 TestingEnum x = TestingEnum.Test;
 245                                 Enum.GetName (null, x);
 246                                 Assert.Fail ("#A1");
 247                         } catch (ArgumentNullException ex) {
 248                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 249                                 Assert.IsNull (ex.InnerException, "#A3");
 250                                 Assert.IsNotNull (ex.Message, "#A4");
 251                                 Assert.IsNotNull (ex.ParamName, "#A5");
 252                                 Assert.AreEqual ("enumType", ex.ParamName, "#A6");
 253                         }
 254
 255                         try {
 256                                 TestingEnum x = TestingEnum.Test;
 257                                 Enum.GetName (x.GetType (), null);
 258                                 Assert.Fail ("#B1");
 259                         } catch (ArgumentNullException ex) {
 260                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
 261                                 Assert.IsNull (ex.InnerException, "#B3");
 262                                 Assert.IsNotNull (ex.Message, "#B4");
 263                                 Assert.IsNotNull (ex.ParamName, "#B5");
 264                                 Assert.AreEqual ("value", ex.ParamName, "#B6");
 265                         }
 266
 267                         try {
 268                                 String bad = "huh?";
 269                                 TestingEnum x = TestingEnum.Test;
 270                                 Enum.GetName (bad.GetType (), x);
 271                                 Assert.Fail ("#C1");
 272                         } catch (ArgumentException ex) {
 273                                 // Type provided must be an Enum
 274                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
 275                                 Assert.IsNull (ex.InnerException, "#C3");
 276                                 Assert.IsNotNull (ex.Message, "#C4");
 277                                 Assert.IsNotNull (ex.ParamName, "#C5");
 278                                 Assert.AreEqual ("enumType", ex.ParamName, "#C6");
 279                         }
 280
 281                         try {
 282                                 String bad = "huh?";
 283                                 TestingEnum x = TestingEnum.Test;
 284                                 Enum.GetName (x.GetType (), bad);
 285                                 Assert.Fail ("#D1");
 286                         } catch (ArgumentException ex) {
 287                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#D2");
 288                                 Assert.IsNull (ex.InnerException, "#D3");
 289                                 Assert.IsNotNull (ex.Message, "#D4");
 290                                 Assert.IsNotNull (ex.ParamName, "#D5");
 291                                 Assert.AreEqual ("value", ex.ParamName, "#D6");
 292                         }
 293
 294                         TestingEnum a = TestingEnum.This;
 295                         TestingEnum b = TestingEnum.Is;
 296                         TestingEnum c = TestingEnum.A;
 297                         TestingEnum2 d = TestingEnum2.Test;
 298
 299                         Assert.AreEqual ("This", Enum.GetName (a.GetType (), a), "#E1");
 300                         Assert.AreEqual ("Is", Enum.GetName (b.GetType (), b), "#E2");
 301                         Assert.AreEqual ("A", Enum.GetName (c.GetType (), c), "#E3");
 302                         Assert.AreEqual ("Test", Enum.GetName (c.GetType (), d), "#E4");
 303                 }
 304
 305                 [Test]
 306                 public void TestGetNames ()
 307                 {
 308                         try {
 309                                 Enum.GetNames (null);
 310                                 Assert.Fail ("#A1");
 311                         } catch (ArgumentNullException ex) {
 312                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 313                                 Assert.IsNull (ex.InnerException, "#A3");
 314                                 Assert.IsNotNull (ex.Message, "#A4");
 315                                 Assert.IsNotNull (ex.ParamName, "#A5");
 316                                 Assert.AreEqual ("enumType", ex.ParamName, "#A6");
 317                         }
 318
 319                         TestingEnum x = TestingEnum.This;
 320                         string [] match = { "This", "Is", "A", "Test" };
 321                         string [] names = Enum.GetNames (x.GetType ());
 322                         Assert.IsNotNull (names, "#B1");
 323                         Assert.AreEqual (match.Length, names.Length, "#B2");
 324                         for (int i = 0; i < names.Length; i++)
 325                                 Assert.AreEqual (match [i], names [i], "#B3");
 326                 }
 327
 328                 [Test]
 329                 public void TestGetTypeCode ()
 330                 {
 331                         TestingEnum x = TestingEnum.This;
 332                         TestingEnum y = new TestingEnum ();
 333                         Assert.AreEqual (TypeCode.Int32, x.GetTypeCode (), "#1");
 334                         Assert.AreEqual (TypeCode.Int32, y.GetTypeCode (), "#2");
 335                 }
 336
 337                 [Test]
 338                 public void TestGetUnderlyingType ()
 339                 {
 340                         try {
 341                                 Enum.GetUnderlyingType (null);
 342                                 Assert.Fail ("#A1");
 343                         } catch (ArgumentNullException ex) {
 344                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 345                                 Assert.IsNull (ex.InnerException, "#A3");
 346                                 Assert.IsNotNull (ex.Message, "#A4");
 347                                 Assert.IsNotNull (ex.ParamName, "#A5");
 348                                 Assert.AreEqual ("enumType", ex.ParamName, "#A6");
 349                         }
 350
 351                         try {
 352                                 String bad = "huh?";
 353                                 Enum.GetUnderlyingType (bad.GetType ());
 354                                 Assert.Fail ("#B1");
 355                         } catch (ArgumentException ex) {
 356                                 // Type provided must be an Enum
 357                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 358                                 Assert.IsNull (ex.InnerException, "#B3");
 359                                 Assert.IsNotNull (ex.Message, "#B4");
 360                                 Assert.IsNotNull (ex.ParamName, "#B5");
 361                                 Assert.AreEqual ("enumType", ex.ParamName, "#B6");
 362                         }
 363
 364                         short sh = 5;
 365                         int i = 5;
 366                         Enum t1 = new TestingEnum ();
 367                         Enum t2 = new TestShortEnum ();
 368                         Assert.AreEqual (i.GetType (), Enum.GetUnderlyingType (t1.GetType ()), "#C1");
 369                         Assert.AreEqual (sh.GetType (), Enum.GetUnderlyingType (t2.GetType ()), "#C2");
 370                 }
 371
 372                 [Test]
 373                 public void TestGetValues ()
 374                 {
 375                         try {
 376                                 Enum.GetValues (null);
 377                                 Assert.Fail ("#A1");
 378                         } catch (ArgumentNullException ex) {
 379                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 380                                 Assert.IsNull (ex.InnerException, "#A3");
 381                                 Assert.IsNotNull (ex.Message, "#A4");
 382                                 Assert.IsNotNull (ex.ParamName, "#A5");
 383                                 Assert.AreEqual ("enumType", ex.ParamName, "#A6");
 384                         }
 385
 386                         try {
 387                                 String bad = "huh?";
 388                                 Enum.GetValues (bad.GetType ());
 389                                 Assert.Fail ("#B1");
 390                         } catch (ArgumentException ex) {
 391                                 // Type provided must be an Enum
 392                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#B2");
 393                                 Assert.IsNull (ex.InnerException, "#B3");
 394                                 Assert.IsNotNull (ex.Message, "#B4");
 395                                 Assert.IsNotNull (ex.ParamName, "#B5");
 396                                 Assert.AreEqual ("enumType", ex.ParamName, "#B6");
 397                         }
 398
 399                         Enum t1 = new TestingEnum ();
 400                         Array a1 = Enum.GetValues (t1.GetType ());
 401                         for (int i = 0; i < a1.Length; i++)
 402                                 Assert.AreEqual ((TestingEnum) i, a1.GetValue (i), "#C1");
 403
 404                         Enum t2 = new TestShortEnum ();
 405                         Array a2 = Enum.GetValues (t2.GetType ());
 406                         for (short i = 0; i < a1.Length; i++)
 407                                 Assert.AreEqual ((TestShortEnum) i, a2.GetValue (i), "#C2");
 408                 }
 409
 410                 [Test]
 411                 public void TestIsDefined ()
 412                 {
 413                         try {
 414                                 Enum.IsDefined (null, 1);
 415                                 Assert.Fail ("#A1");
 416                         } catch (ArgumentNullException ex) {
 417                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 418                                 Assert.IsNull (ex.InnerException, "#A3");
 419                                 Assert.IsNotNull (ex.Message, "#A4");
 420                                 Assert.IsNotNull (ex.ParamName, "#A5");
 421                                 Assert.AreEqual ("enumType", ex.ParamName, "#A6");
 422                         }
 423
 424                         try {
 425                                 TestingEnum x = TestingEnum.Test;
 426                                 Enum.IsDefined (x.GetType (), null);
 427                                 Assert.Fail ("#B1");
 428                         } catch (ArgumentNullException ex) {
 429                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
 430                                 Assert.IsNull (ex.InnerException, "#B3");
 431                                 Assert.IsNotNull (ex.Message, "#B4");
 432                                 Assert.IsNotNull (ex.ParamName, "#B5");
 433                                 Assert.AreEqual ("value", ex.ParamName, "#B6");
 434                         }
 435
 436                         try {
 437                                 String bad = "huh?";
 438                                 int i = 4;
 439                                 Enum.IsDefined (bad.GetType (), i);
 440                                 Assert.Fail ("#C1");
 441                         } catch (ArgumentException ex) {
 442                                 // Type provided must be an Enum
 443                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
 444                                 Assert.IsNull (ex.InnerException, "#C3");
 445                                 Assert.IsNotNull (ex.Message, "#C4");
 446                                 Assert.IsNotNull (ex.ParamName, "#C5");
 447                                 Assert.AreEqual ("enumType", ex.ParamName, "#C6");
 448                         }
 449
 450                         try {
 451                                 TestingEnum x = TestingEnum.Test;
 452                                 short i = 4;
 453                                 Enum.IsDefined (x.GetType (), i);
 454                                 Assert.Fail ("#D1");
 455                         } catch (ArgumentException ex) {
 456                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#D2");
 457                                 Assert.IsNull (ex.InnerException, "#D3");
 458                                 Assert.IsNotNull (ex.Message, "#D4");
 459                                 Assert.IsNull (ex.ParamName, "#D5");
 460                         }
 461
 462                         Enum t1 = new TestingEnum ();
 463                         int valCount = Enum.GetValues (t1.GetType ()).Length;
 464                         for (int i = 0; i < valCount; i++)
 465                                 Assert.IsTrue (Enum.IsDefined (t1.GetType (), i), "#F1:" + i);
 466                         Assert.IsFalse (Enum.IsDefined (t1.GetType (), valCount), "#F2");
 467                         Assert.IsFalse (Enum.IsDefined (typeof (TestingEnum), "huh?"), "#F3");
 468                 }
 469
 470                 [Test]
 471                 public void TestParse1 ()
 472                 {
 473                         try {
 474                                 String name = "huh?";
 475                                 Enum.Parse (null, name);
 476                                 Assert.Fail ("#A1");
 477                         } catch (ArgumentNullException ex) {
 478                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 479                                 Assert.IsNull (ex.InnerException, "#A3");
 480                                 Assert.IsNotNull (ex.Message, "#A4");
 481                                 Assert.IsNotNull (ex.ParamName, "#A5");
 482                                 Assert.AreEqual ("enumType", ex.ParamName, "#A6");
 483                         }
 484
 485                         try {
 486                                 TestingEnum x = TestingEnum.Test;
 487                                 Enum.Parse (x.GetType (), null);
 488                                 Assert.Fail ("#B1");
 489                         } catch (ArgumentNullException ex) {
 490                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
 491                                 Assert.IsNull (ex.InnerException, "#B3");
 492                                 Assert.IsNotNull (ex.Message, "#B4");
 493                                 Assert.IsNotNull (ex.ParamName, "#B5");
 494                                 Assert.AreEqual ("value", ex.ParamName, "#B6");
 495                         }
 496
 497                         try {
 498                                 String bad = "huh?";
 499                                 Enum.Parse (bad.GetType (), bad);
 500                                 Assert.Fail ("#C1");
 501                         } catch (ArgumentException ex) {
 502                                 // Type provided must be an Enum
 503                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#C2");
 504                                 Assert.IsNull (ex.InnerException, "#C3");
 505                                 Assert.IsNotNull (ex.Message, "#C4");
 506                                 Assert.IsNotNull (ex.ParamName, "#C5");
 507                                 Assert.AreEqual ("enumType", ex.ParamName, "#C6");
 508                         }
 509
 510                         try {
 511                                 TestingEnum x = TestingEnum.Test;
 512                                 String bad = "";
 513                                 Enum.Parse (x.GetType (), bad);
 514                                 Assert.Fail ("#D1");
 515                         } catch (ArgumentException ex) {
 516                                 // Must specify valid information for parsing
 517                                 // in the string
 518                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#D2");
 519                                 Assert.IsNull (ex.InnerException, "#D3");
 520                                 Assert.IsNotNull (ex.Message, "#D4");
 521                                 Assert.IsNull (ex.ParamName, "#D5");
 522                         }
 523
 524                         try {
 525                                 TestingEnum x = TestingEnum.Test;
 526                                 String bad = " ";
 527                                 Enum.Parse (x.GetType (), bad);
 528                                 Assert.Fail ("#E1");
 529                         } catch (ArgumentException ex) {
 530                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#E2");
 531                                 Assert.IsNull (ex.InnerException, "#E3");
 532                                 Assert.IsNotNull (ex.Message, "#E4");
 533                                 Assert.IsNull (ex.ParamName, "#E5");
 534                         }
 535
 536                         try {
 537                                 String bad = "huh?";
 538                                 TestingEnum x = TestingEnum.Test;
 539                                 Enum.Parse (x.GetType (), bad);
 540                                 Assert.Fail ("#F1");
 541                         } catch (ArgumentException ex) {
 542                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#F2");
 543                                 Assert.IsNull (ex.InnerException, "#F3");
 544                                 Assert.IsNotNull (ex.Message, "#F4");
 545                                 Assert.IsNull (ex.ParamName, "#F5");
 546                         }
 547
 548                         TestingEnum t1 = new TestingEnum ();
 549                         Assert.AreEqual (TestingEnum.This, Enum.Parse (t1.GetType (), "This"), "#G1");
 550                         Assert.AreEqual (TestingEnum.Is, Enum.Parse (t1.GetType (), "Is"), "#G2");
 551                         Assert.AreEqual (TestingEnum.A, Enum.Parse (t1.GetType (), "A"), "#G3");
 552                         Assert.AreEqual (TestingEnum.Test, Enum.Parse (t1.GetType (), "Test"), "#G4");
 553                         Assert.AreEqual (TestingEnum.Test, Enum.Parse (t1.GetType (), "    \n\nTest\t"), "#G5");
 554                         Assert.AreEqual (TestingEnum.Is, Enum.Parse (t1.GetType (), "This,Is"), "#G6");
 555                         Assert.AreEqual (TestingEnum.Test, Enum.Parse (t1.GetType (), "This,Test"), "#G7");
 556                         Assert.AreEqual (TestingEnum.Test, Enum.Parse (t1.GetType (), "This,Is,A"), "#G8");
 557                         Assert.AreEqual (TestingEnum.Test, Enum.Parse (t1.GetType (), "   \n\tThis \t\n,    Is,A \n"), "#G9");
 558                 }
 559
 560                 [Test]
 561                 public void TestParse2 ()
 562                 {
 563                         try {
 564                                 String name = "huh?";
 565                                 Enum.Parse (null, name, true);
 566                                 Assert.Fail ("#A1");
 567                         } catch (ArgumentNullException ex) {
 568                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#A2");
 569                                 Assert.IsNull (ex.InnerException, "#A3");
 570                                 Assert.IsNotNull (ex.Message, "#A4");
 571                                 Assert.IsNotNull (ex.ParamName, "#A5");
 572                                 Assert.AreEqual ("enumType", ex.ParamName, "#A6");
 573                         }
 574
 575                         try {
 576                                 TestingEnum x = TestingEnum.Test;
 577                                 Enum.Parse (x.GetType (), null, true);
 578                                 Assert.Fail ("#B1");
 579                         } catch (ArgumentNullException ex) {
 580                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#B2");
 581                                 Assert.IsNull (ex.InnerException, "#B3");
 582                                 Assert.IsNotNull (ex.Message, "#B4");
 583                                 Assert.IsNotNull (ex.ParamName, "#B5");
 584                                 Assert.AreEqual ("value", ex.ParamName, "#B6");
 585                         }
 586
 587                         try {
 588                                 String bad = "huh?";
 589                                 Enum.Parse (bad.GetType (), bad, true);
 590                                 Assert.Fail ("#C1");
 591                         } catch (ArgumentException ex) {
 592                                 // Type provided must be an Enum
 593                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#D2");
 594                                 Assert.IsNull (ex.InnerException, "#D3");
 595                                 Assert.IsNotNull (ex.Message, "#D4");
 596                                 Assert.IsNotNull (ex.ParamName, "#D5");
 597                                 Assert.AreEqual ("enumType", ex.ParamName, "#D6");
 598                         }
 599
 600                         try {
 601                                 TestingEnum x = TestingEnum.Test;
 602                                 String bad = "";
 603                                 Enum.Parse (x.GetType (), bad, true);
 604                                 Assert.Fail ("#E1");
 605                         } catch (ArgumentException ex) {
 606                                 // Must specify valid information for parsing
 607                                 // in the string
 608                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#E2");
 609                                 Assert.IsNull (ex.InnerException, "#E3");
 610                                 Assert.IsNotNull (ex.Message, "#E4");
 611                                 Assert.IsNull (ex.ParamName, "#E5");
 612                         }
 613
 614                         try {
 615                                 TestingEnum x = TestingEnum.Test;
 616                                 String bad = " ";
 617                                 Enum.Parse (x.GetType (), bad, true);
 618                                 Assert.Fail ("#F1");
 619                         } catch (ArgumentException ex) {
 620                                 // Must specify valid information for parsing
 621                                 // in the string
 622                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#F2");
 623                                 Assert.IsNull (ex.InnerException, "#F3");
 624                                 Assert.IsNotNull (ex.Message, "#F4");
 625                                 Assert.IsFalse (ex.Message.IndexOf ("' '") != -1, "#F5");
 626                                 Assert.IsNull (ex.ParamName, "#F6");
 627                         }
 628
 629                         try {
 630                                 String bad = "huh?";
 631                                 TestingEnum x = TestingEnum.Test;
 632                                 Enum.Parse (x.GetType (), bad, true);
 633                                 Assert.Fail ("#G1");
 634                         } catch (ArgumentException ex) {
 635                                 // Requested value 'huh?' was not found
 636                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#G2");
 637                                 Assert.IsNull (ex.InnerException, "#G3");
 638                                 Assert.IsNotNull (ex.Message, "#G4");
 639 #if NET_2_0
 640                                 Assert.IsTrue (ex.Message.IndexOf ("'huh?'") != -1, "#G5");
 641 #else
 642                                 Assert.IsTrue (ex.Message.IndexOf ("huh?") != -1, "#G5");
 643 #endif
 644                                 Assert.IsNull (ex.ParamName, "#G6");
 645                         }
 646
 647                         try {
 648                                 String bad = "test";
 649                                 TestingEnum x = TestingEnum.Test;
 650                                 Enum.Parse (x.GetType (), bad, false);
 651                                 Assert.Fail ("#H1");
 652                         } catch (ArgumentException ex) {
 653                                 // Requested value 'test' was not found
 654                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#H2");
 655                                 Assert.IsNull (ex.InnerException, "#H3");
 656                                 Assert.IsNotNull (ex.Message, "#H4");
 657 #if NET_2_0
 658                                 Assert.IsTrue (ex.Message.IndexOf ("'test'") != -1, "#H5");
 659 #else
 660                                 Assert.IsTrue (ex.Message.IndexOf ("test") != -1, "#H5");
 661 #endif
 662                                 Assert.IsNull (ex.ParamName, "#H6");
 663                         }
 664
 665                         TestingEnum t1 = new TestingEnum ();
 666                         Assert.AreEqual (TestingEnum.This, Enum.Parse (t1.GetType (), "this", true), "#I1");
 667                         Assert.AreEqual (TestingEnum.Is, Enum.Parse (t1.GetType (), "is", true), "#I2");
 668                         Assert.AreEqual (TestingEnum.A, Enum.Parse (t1.GetType (), "a", true), "#I3");
 669                         Assert.AreEqual (TestingEnum.Test, Enum.Parse (t1.GetType (), "test", true), "#I4");
 670                         Assert.AreEqual (TestingEnum.Test, Enum.Parse (t1.GetType (), "    \n\ntest\t", true), "#I5");
 671
 672                         Assert.AreEqual (TestingEnum.Is, Enum.Parse (t1.GetType (), "This,is", true), "#J1");
 673                         Assert.AreEqual (TestingEnum.Test, Enum.Parse (t1.GetType (), "This,test", true), "#J2");
 674                         Assert.AreEqual (TestingEnum.Test, Enum.Parse (t1.GetType (), "This,is,A", true), "#J3");
 675                         Assert.AreEqual (TestingEnum.Test, Enum.Parse (t1.GetType (), "   \n\tThis \t\n,    is,a \n", true), "#J4");
 676                 }
 677
 678                 [Test]
 679                 public void ParseValue ()
 680                 {
 681                         TestingEnum3 t1 = new TestingEnum3 ();
 682                         Assert.AreEqual (TestingEnum3.Test, Enum.Parse (t1.GetType (), "18446744073709551615", false));
 683                 }
 684
 685                 [Test]
 686                 public void ToObject_EnumType_Int32 ()
 687                 {
 688                         object value = Enum.ToObject (typeof (TestingEnum), 0);
 689                         Assert.AreEqual (TestingEnum.This, value, "#1");
 690                         value = Enum.ToObject (typeof (TestingEnum), 2);
 691                         Assert.AreEqual (TestingEnum.A, value, "#2");
 692                 }
 693
 694                 [Test]
 695 #if ONLY_1_1
 696                 [Category ("NotDotNet")]
 697 #endif
 698                 public void ToObject_EnumType_UInt64 ()
 699                 {
 700                         object value = Enum.ToObject (typeof (TestingEnum3), 0);
 701                         Assert.AreEqual (TestingEnum3.This, value, "#1");
 702                         value = Enum.ToObject (typeof (TestingEnum3), 1);
 703                         Assert.AreEqual (TestingEnum3.Is, value, "#2");
 704                         value = Enum.ToObject (typeof (TestingEnum3), ulong.MaxValue);
 705                         Assert.AreEqual (TestingEnum3.Test, value, "#3");
 706                 }
 707
 708                 [Test]
 709                 public void ToObject_EnumType_Byte ()
 710                 {
 711                         object value = Enum.ToObject (typeof (TestingEnum4), 0);
 712                         Assert.AreEqual (TestingEnum4.This, value, "#1");
 713                         value = Enum.ToObject (typeof (TestingEnum4), byte.MaxValue);
 714                         Assert.AreEqual (TestingEnum4.Test, value, "#2");
 715                 }
 716
 717                 [Test]
 718                 public void ToObject_EnumType_Int16 ()
 719                 {
 720                         object value = Enum.ToObject (typeof (TestingEnum5), 0);
 721                         Assert.AreEqual (TestingEnum5.This, value, "#1");
 722                         value = Enum.ToObject (typeof (TestingEnum5), short.MaxValue);
 723                         Assert.AreEqual (TestingEnum5.Test, value, "#2");
 724                 }
 725
 726                 [Test]
 727                 public void ToObject_EnumType_Invalid ()
 728                 {
 729                         try {
 730                                 Enum.ToObject (typeof (string), 1);
 731                                 Assert.Fail ("#1");
 732                         } catch (ArgumentException ex) {
 733                                 // Type provided must be an Enum
 734                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 735                                 Assert.IsNull (ex.InnerException, "#3");
 736                                 Assert.IsNotNull (ex.Message, "#4");
 737                                 Assert.IsNotNull (ex.ParamName, "#5");
 738                                 Assert.AreEqual ("enumType", ex.ParamName, "#6");
 739                         }
 740                 }
 741
 742                 [Test]
 743                 public void ToObject_EnumType_Null ()
 744                 {
 745                         try {
 746                                 Enum.ToObject (null, 1);
 747                                 Assert.Fail ("#1");
 748                         } catch (ArgumentNullException ex) {
 749                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 750                                 Assert.IsNull (ex.InnerException, "#3");
 751                                 Assert.IsNotNull (ex.Message, "#4");
 752                                 Assert.IsNotNull (ex.ParamName, "#5");
 753                                 Assert.AreEqual ("enumType", ex.ParamName, "#6");
 754                         }
 755                 }
 756
 757                 [Test]
 758                 public void ToObject_Value_Null ()
 759                 {
 760                         try {
 761                                 Enum.ToObject (typeof (TestingEnum), (object) null);
 762                                 Assert.Fail ("#1");
 763                         } catch (ArgumentNullException ex) {
 764                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 765                                 Assert.IsNull (ex.InnerException, "#3");
 766                                 Assert.IsNotNull (ex.Message, "#4");
 767                                 Assert.IsNotNull (ex.ParamName, "#5");
 768                                 Assert.AreEqual ("value", ex.ParamName, "#6");
 769                         }
 770                 }
 771
 772                 [Test]
 773                 public void ToObject_Value_Invalid ()
 774                 {
 775                         try {
 776                                 Enum.ToObject (typeof (TestingEnum), "This");
 777                                 Assert.Fail ("#1");
 778                         } catch (ArgumentException ex) {
 779                                 // The value passed in must be an enum base or
 780                                 // an underlying type for an enum, such as an
 781                                 // Int32
 782                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 783                                 Assert.IsNull (ex.InnerException, "#3");
 784                                 Assert.IsNotNull (ex.Message, "#4");
 785                                 Assert.IsNotNull (ex.ParamName, "#5");
 786                                 Assert.AreEqual ("value", ex.ParamName, "#6");
 787                         }
 788                 }
 789
 790                 [Test]
 791                 public void ConvertToStringType ()
 792                 {
 793                         Assert.AreEqual ("This", ((IConvertible) TestingEnum.This).ToType (typeof (string), null));
 794                 }
 795
 796                 [Test]
 797                 public void TestToString ()
 798                 {
 799                         Assert.AreEqual ("This", TestingEnum.This.ToString (), "#A1");
 800                         Assert.AreEqual ("Is", TestingEnum.Is.ToString (), "#A2");
 801                         Assert.AreEqual ("A", TestingEnum.A.ToString (), "#A3");
 802                         Assert.AreEqual ("Test", TestingEnum.Test.ToString (), "#A4");
 803
 804                         Enum is1 = TestingEnum.Is;
 805
 806                         Assert.AreEqual ("1", is1.ToString ("d"), "#B1");
 807                         Assert.AreEqual ("Is", is1.ToString ("g"), "#B2");
 808                         Assert.AreEqual ("00000001", is1.ToString ("x"), "#B3");
 809                         Assert.AreEqual ("Is", is1.ToString ("f"), "#B4");
 810
 811                         Assert.AreEqual ("b, c", ((SomeEnum) 3).ToString ("f"), "#C1");
 812                         Assert.AreEqual ("b, c", ((SomeByteEnum) 3).ToString ("f"), "#C2");
 813                         Assert.AreEqual ("b, c", ((SomeInt64Enum) 3).ToString ("f"), "#C3");
 814
 815                         Assert.AreEqual ("12", ((SomeEnum) 12).ToString ("f"), "#D1");
 816                         Assert.AreEqual ("12", ((SomeByteEnum) 12).ToString ("f"), "#D2");
 817                         Assert.AreEqual ("12", ((SomeInt64Enum) 12).ToString ("f"), "#D3");
 818                 }
 819
 820                 [Test]
 821                 public void FlagTest ()
 822                 {
 823                         int [] evalues = new int [4] { 0, 1, 2, 3 };
 824                         E [] e = new E [4] { E.Aa, E.Bb, E.Cc, E.Dd };
 825
 826                         for (int i = 0; i < 4; ++i)
 827                                 Assert.AreEqual (e [i].ToString (),
 828                                         Enum.Format (typeof (E), evalues [i], "f"),
 829                                         "#1" + i);
 830
 831                         int invalidValue = 1000;
 832
 833                         Assert.AreEqual (invalidValue.ToString (),
 834                                 Enum.Format (typeof (E2), invalidValue, "g"),
 835                                 "#2");
 836                 }
 837
 838                 [Test]
 839                 public void FlagTest_Negative ()
 840                 {
 841                         FlagsNegativeTestEnum t;
 842
 843                         t = FlagsNegativeTestEnum.None;
 844                         Assert.AreEqual ("None", t.ToString (), "#01");
 845                         t = FlagsNegativeTestEnum.One;
 846                         Assert.AreEqual ("One", t.ToString (), "#02");
 847                 }
 848
 849                 [Test]
 850                 public void AnotherFormatBugPinned ()
 851                 {
 852                         Assert.AreEqual ("100", Enum.Format (typeof (E3), 100, "f"));
 853                 }
 854
 855                 [Test]
 856                 public void LogicBugPinned ()
 857                 {
 858                         string format = null;
 859                         string [] names = new string [] { "A", "B", "C", "D", };
 860                         string [] fmtSpl = null;
 861                         UE ue = UE.A | UE.B | UE.C | UE.D;
 862
 863                         //all flags must be in format return
 864                         format = Enum.Format (typeof (UE), ue, "f");
 865                         fmtSpl = format.Split (',');
 866                         for (int i = 0; i < fmtSpl.Length; ++i)
 867                                 fmtSpl [i] = fmtSpl [i].Trim ();
 868
 869                         foreach (string nval in fmtSpl)
 870                                 Assert.IsTrue (Array.IndexOf (names, nval) >= 0, "#1:" + nval);
 871
 872                         foreach (string nval in names)
 873                                 Assert.IsTrue (Array.IndexOf (fmtSpl, nval) >= 0, "#2:" + nval);
 874                 }
 875                 // TODO - ToString with IFormatProviders
 876
 877                 [Test]
 878                 public void GetHashCode_ShouldBeEqualToUnderlyingType ()
 879                 {
 880                         Assert.AreEqual (EnInt8.A.GetHashCode(), SByte.MinValue, "i8#0");
 881                         Assert.AreEqual (EnInt8.B.GetHashCode(), 44, "i8#1");
 882                         Assert.AreEqual (EnInt8.C.GetHashCode(), SByte.MaxValue, "i8#2");
 883
 884                         Assert.AreEqual (EnUInt8.A.GetHashCode(), Byte.MinValue, "u8#0");
 885                         Assert.AreEqual (EnUInt8.B.GetHashCode(), 55, "u8#1");
 886                         Assert.AreEqual (EnUInt8.C.GetHashCode(), Byte.MaxValue, "u8#2");
 887
 888                         Assert.AreEqual (EnInt16.A.GetHashCode(), Int16.MinValue, "i16#0");
 889                         Assert.AreEqual (EnInt16.B.GetHashCode(), 66, "i16#1");
 890                         Assert.AreEqual (EnInt16.C.GetHashCode(), Int16.MaxValue, "i16#2");
 891
 892                         Assert.AreEqual (EnUInt16.A.GetHashCode(), UInt16.MinValue, "u16#0");
 893                         Assert.AreEqual (EnUInt16.B.GetHashCode(), 77, "u16#1");
 894                         Assert.AreEqual (EnUInt16.C.GetHashCode(), UInt16.MaxValue, "u16#2");
 895
 896                         Assert.AreEqual (EnInt32.A.GetHashCode(), Int32.MinValue, "i32#0");
 897                         Assert.AreEqual (EnInt32.B.GetHashCode(), 88, "i32#1");
 898                         Assert.AreEqual (EnInt32.C.GetHashCode(), Int32.MaxValue, "i32#2");
 899
 900                         Assert.AreEqual (EnUInt32.A.GetHashCode(), UInt32.MinValue, "u32#0");
 901                         Assert.AreEqual (EnUInt32.B.GetHashCode(), 99, "u32#1");
 902                         Assert.AreEqual (EnUInt32.C.GetHashCode(), UInt32.MaxValue.GetHashCode (), "u32#2");
 903
 904                         Assert.AreEqual (EnInt64.A.GetHashCode(), Int64.MinValue.GetHashCode (), "i64#0");
 905                         Assert.AreEqual (EnInt64.B.GetHashCode(), 3488924689489L.GetHashCode (), "i64#1");
 906                         Assert.AreEqual (EnInt64.C.GetHashCode(), Int64.MaxValue.GetHashCode (), "i64#2");
 907
 908                         Assert.AreEqual (EnUInt64.A.GetHashCode(), UInt64.MinValue.GetHashCode (), "u64#0");
 909                         Assert.AreEqual (EnUInt64.B.GetHashCode(), 3488924689489L.GetHashCode (), "u64#1");
 910                         Assert.AreEqual (EnUInt64.C.GetHashCode(), UInt64.MaxValue.GetHashCode (), "u64#2");
 911                 }
 912
 913                 [Test]
 914                 public void CompareTo_ShouldBeEqualToUnderlyingType ()
 915                 {
 916                         Assert.AreEqual (sbyte.MinValue.CompareTo (sbyte.MinValue), EnInt8.A.CompareTo (EnInt8.A), "i8#0");
 917                         Assert.AreEqual (sbyte.MinValue.CompareTo ((sbyte)44), EnInt8.A.CompareTo (EnInt8.B), "i8#1");
 918                         Assert.AreEqual (((sbyte)44).CompareTo (sbyte.MinValue), EnInt8.B.CompareTo (EnInt8.A), "i8#2");
 919
 920                         Assert.AreEqual (byte.MinValue.CompareTo (byte.MinValue), EnUInt8.A.CompareTo (EnUInt8.A), "ui8#0");
 921                         Assert.AreEqual (byte.MinValue.CompareTo ((byte)55),  EnUInt8.A.CompareTo (EnUInt8.B), "ui8#1");
 922                         Assert.AreEqual (((byte)55).CompareTo (byte.MinValue), EnUInt8.B.CompareTo (EnUInt8.A),"ui8#2");
 923
 924                         Assert.AreEqual (short.MinValue.CompareTo (short.MinValue), EnInt16.A.CompareTo (EnInt16.A), "i16#0");
 925                         Assert.AreEqual (short.MinValue.CompareTo ((short)66), EnInt16.A.CompareTo (EnInt16.B), "i16#1");
 926                         Assert.AreEqual (((short)66).CompareTo (short.MinValue), EnInt16.B.CompareTo (EnInt16.A), "i16#2");
 927
 928                         Assert.AreEqual (ushort.MinValue.CompareTo (ushort.MinValue), EnUInt16.A.CompareTo (EnUInt16.A), "ui16#0");
 929                         Assert.AreEqual (ushort.MinValue.CompareTo ((ushort)77), EnUInt16.A.CompareTo (EnUInt16.B), "ui16#1");
 930                         Assert.AreEqual (((ushort)77).CompareTo (ushort.MinValue), EnUInt16.B.CompareTo (EnUInt16.A), "ui16#2");
 931
 932                         Assert.AreEqual (int.MinValue.CompareTo (int.MinValue), EnInt32.A.CompareTo (EnInt32.A), "i32#0");
 933                         Assert.AreEqual (int.MinValue.CompareTo ((int)88), EnInt32.A.CompareTo (EnInt32.B), "i32#1");
 934                         Assert.AreEqual (((int)88).CompareTo (int.MinValue), EnInt32.B.CompareTo (EnInt32.A), "i32#2");
 935
 936                         Assert.AreEqual (uint.MinValue.CompareTo (uint.MinValue), EnUInt32.A.CompareTo (EnUInt32.A), "u32#0");
 937                         Assert.AreEqual (uint.MinValue.CompareTo ((uint)99), EnUInt32.A.CompareTo (EnUInt32.B), "u32#1");
 938                         Assert.AreEqual (((uint)99).CompareTo (uint.MinValue), EnUInt32.B.CompareTo (EnUInt32.A), "u32#2");
 939
 940                         Assert.AreEqual (long.MinValue.CompareTo (long.MinValue), EnInt64.A.CompareTo (EnInt64.A), "i64#0");
 941                         Assert.AreEqual (long.MinValue.CompareTo ((long)456), EnInt64.A.CompareTo (EnInt64.D), "i64#1");
 942                         Assert.AreEqual (((long)456).CompareTo (long.MinValue), EnInt64.D.CompareTo (EnInt64.A), "i64#2");
 943
 944                         Assert.AreEqual (ulong.MinValue.CompareTo (ulong.MinValue), EnUInt64.A.CompareTo (EnUInt64.A), "u64#0");
 945                         Assert.AreEqual (ulong.MinValue.CompareTo ((ulong)789),  EnUInt64.A.CompareTo (EnUInt64.D), "u64#1");
 946                         Assert.AreEqual (((ulong)789).CompareTo (ulong.MinValue), EnUInt64.D.CompareTo (EnUInt64.A), "u64#2");
 947                 }
 948
 949                 //
 950                 // This is used to verify that the output matches the specified behavior
 951                 // See bug #371559 for details.
 952                 //
 953                 [Test]
 954                 public void CompareOrder_FromGetNames ()
 955                 {
 956                         Array r = Enum.GetValues (typeof (EnumByte));
 957                         Assert.AreEqual (5, r.Length);
 958                         Assert.AreEqual ("byte_Cc", Enum.GetName (typeof (EnumByte), (EnumByte)(0x00)));
 959                         Assert.AreEqual ("byte_Cc", r.GetValue (0).ToString ());
 960                         Assert.AreEqual ("byte_Aa", Enum.GetName (typeof (EnumByte), (EnumByte)(0x05)));
 961                         Assert.AreEqual ("byte_Aa", r.GetValue (1).ToString ());
 962                         Assert.AreEqual ("byte_Ff", Enum.GetName (typeof (EnumByte), (EnumByte)(0x64)));
 963                         Assert.AreEqual ("byte_Ff", r.GetValue (2).ToString ());
 964                         Assert.AreEqual ("byte_Dd", Enum.GetName (typeof (EnumByte), (EnumByte)(0x7F)));
 965                         Assert.AreEqual ("byte_Dd", r.GetValue (3).ToString ());
 966                         Assert.AreEqual ("byte_Bb", Enum.GetName (typeof (EnumByte), (EnumByte)(0xFF)));
 967                         Assert.AreEqual ("byte_Bb", r.GetValue (4).ToString ());
 968
 969                         r = Enum.GetValues (typeof (EnumSByte));
 970                         Assert.AreEqual (6, r.Length);
 971                         Assert.AreEqual ("sbyte_Cc", Enum.GetName (typeof (EnumSByte), (EnumSByte)(0x00)));
 972                         Assert.AreEqual ("sbyte_Cc", r.GetValue (0).ToString ());
 973                         Assert.AreEqual ("sbyte_Aa", Enum.GetName (typeof (EnumSByte), (EnumSByte)(0x05)));
 974                         Assert.AreEqual ("sbyte_Aa", r.GetValue (1).ToString ());
 975                         Assert.AreEqual ("sbyte_Ff", Enum.GetName (typeof (EnumSByte), (EnumSByte)(0x64)));
 976                         Assert.AreEqual ("sbyte_Ff", r.GetValue (2).ToString ());
 977                         Assert.AreEqual ("sbyte_Ee", Enum.GetName (typeof (EnumSByte), (EnumSByte)(0x7F)));
 978                         Assert.AreEqual ("sbyte_Ee", r.GetValue (3).ToString ());
 979                         Assert.AreEqual ("sbyte_Bb", Enum.GetName (typeof (EnumSByte), unchecked ((EnumSByte)(0xF0))));
 980                         Assert.AreEqual ("sbyte_Bb", r.GetValue (4).ToString ());
 981                         Assert.AreEqual ("sbyte_Dd", Enum.GetName (typeof (EnumSByte), unchecked ((EnumSByte)(0xFF))));
 982                         Assert.AreEqual ("sbyte_Dd", r.GetValue (5).ToString ());
 983
 984                         r = Enum.GetValues (typeof (EnumUShort));
 985                         Assert.AreEqual (5, r.Length);
 986                         Assert.AreEqual ("ushort_Cc", Enum.GetName (typeof (EnumUShort), (EnumUShort)(0x0000)));
 987                         Assert.AreEqual ("ushort_Cc", r.GetValue (0).ToString ());
 988                         Assert.AreEqual ("ushort_Aa", Enum.GetName (typeof (EnumUShort), (EnumUShort)(0x0005)));
 989                         Assert.AreEqual ("ushort_Aa", r.GetValue (1).ToString ());
 990                         Assert.AreEqual ("ushort_Ff", Enum.GetName (typeof (EnumUShort), (EnumUShort)(0x0064)));
 991                         Assert.AreEqual ("ushort_Ff", r.GetValue (2).ToString ());
 992                         Assert.AreEqual ("ushort_Ee", Enum.GetName (typeof (EnumUShort), (EnumUShort)(0x7FFF)));
 993                         Assert.AreEqual ("ushort_Ee", r.GetValue (3).ToString ());
 994                         Assert.AreEqual ("ushort_Bb", Enum.GetName (typeof (EnumUShort), (EnumUShort)(0xFF00)));
 995                         Assert.AreEqual ("ushort_Bb", r.GetValue (4).ToString ());
 996
 997                         r = Enum.GetValues (typeof (EnumShort));
 998                         Assert.AreEqual (6, r.Length);
 999                         Assert.AreEqual ("short_Cc", Enum.GetName (typeof (EnumShort), (EnumShort)(0x0000)));
1000                         Assert.AreEqual ("short_Cc", r.GetValue (0).ToString ());
1001                         Assert.AreEqual ("short_Aa", Enum.GetName (typeof (EnumShort), (EnumShort)(0x0005)));
1002                         Assert.AreEqual ("short_Aa", r.GetValue (1).ToString ());
1003                         Assert.AreEqual ("short_Ff", Enum.GetName (typeof (EnumShort), (EnumShort)(0x0064)));
1004                         Assert.AreEqual ("short_Ff", r.GetValue (2).ToString ());
1005                         Assert.AreEqual ("short_Ee", Enum.GetName (typeof (EnumShort), (EnumShort)(0x7FFF)));
1006                         Assert.AreEqual ("short_Ee", r.GetValue (3).ToString ());
1007                         Assert.AreEqual ("short_Bb", Enum.GetName (typeof (EnumShort), unchecked ((EnumShort)(0xFF00))));
1008                         Assert.AreEqual ("short_Bb", r.GetValue (4).ToString ());
1009                         Assert.AreEqual ("short_Dd", Enum.GetName (typeof (EnumShort), unchecked ((EnumShort)(0xFFFF))));
1010                         Assert.AreEqual ("short_Dd", r.GetValue (5).ToString ());
1011
1012                         r = Enum.GetValues (typeof (EnumUInt));
1013                         Assert.AreEqual (4, r.Length);
1014                         Assert.AreEqual ("uint_Cc", Enum.GetName (typeof (EnumUInt), (EnumUInt)(0x00000000)));
1015                         Assert.AreEqual ("uint_Cc", r.GetValue (0).ToString ());
1016                         Assert.AreEqual ("uint_Aa", Enum.GetName (typeof (EnumUInt), (EnumUInt)(0x00000005)));
1017                         Assert.AreEqual ("uint_Aa", r.GetValue (1).ToString ());
1018                         Assert.AreEqual ("uint_Ff", Enum.GetName (typeof (EnumUInt), (EnumUInt)(0x00000064)));
1019                         Assert.AreEqual ("uint_Ff", r.GetValue (2).ToString ());
1020                         Assert.AreEqual ("uint_Ee", Enum.GetName (typeof (EnumUInt), (EnumUInt)(0x7FFFFFFF)));
1021                         Assert.AreEqual ("uint_Ee", r.GetValue (3).ToString ());
1022
1023                         r = Enum.GetValues (typeof (EnumInt));
1024                         Assert.AreEqual (6, r.Length);
1025                         Assert.AreEqual ("int_Cc", Enum.GetName (typeof (EnumInt), (EnumInt)(0x00000000)));
1026                         Assert.AreEqual ("int_Cc", r.GetValue (0).ToString ());
1027                         Assert.AreEqual ("int_Aa", Enum.GetName (typeof (EnumInt), (EnumInt)(0x00000005)));
1028                         Assert.AreEqual ("int_Aa", r.GetValue (1).ToString ());
1029                         Assert.AreEqual ("int_Ff", Enum.GetName (typeof (EnumInt), (EnumInt)(0x00000064)));
1030                         Assert.AreEqual ("int_Ff", r.GetValue (2).ToString ());
1031                         Assert.AreEqual ("int_Ee", Enum.GetName (typeof (EnumInt), (EnumInt)(0x7FFFFFFF)));
1032                         Assert.AreEqual ("int_Ee", r.GetValue (3).ToString ());
1033                         Assert.AreEqual ("int_Bb", Enum.GetName (typeof (EnumInt), unchecked ((EnumInt)(0xFFFF0000))));
1034                         Assert.AreEqual ("int_Bb", r.GetValue (4).ToString ());
1035                         Assert.AreEqual ("int_Dd", Enum.GetName (typeof (EnumInt), unchecked ((EnumInt)(0xFFFFFFFF))));
1036                         Assert.AreEqual ("int_Dd", r.GetValue (5).ToString ());
1037
1038                         r = Enum.GetValues (typeof (EnumULong));
1039                         Assert.AreEqual (5, r.Length);
1040                         Assert.AreEqual ("ulong_Cc", Enum.GetName (typeof (EnumULong), (EnumULong)(0x0000000000000000)));
1041                         Assert.AreEqual ("ulong_Cc", r.GetValue (0).ToString ());
1042                         Assert.AreEqual ("ulong_Cc", Enum.GetName (typeof (EnumULong), (EnumULong)(0x0000000000000000)));
1043                         Assert.AreEqual ("ulong_Cc", r.GetValue (1).ToString ());
1044                         Assert.AreEqual ("ulong_Aa", Enum.GetName (typeof (EnumULong), (EnumULong)(0x0000000000000005)));
1045                         Assert.AreEqual ("ulong_Aa", r.GetValue (2).ToString ());
1046                         Assert.AreEqual ("ulong_Ff", Enum.GetName (typeof (EnumULong), (EnumULong)(0x0000000000000064)));
1047                         Assert.AreEqual ("ulong_Ff", r.GetValue (3).ToString ());
1048                         Assert.AreEqual ("ulong_Ee", Enum.GetName (typeof (EnumULong), (EnumULong)(0x7FFFFFFFFFFFFFFF)));
1049                         Assert.AreEqual ("ulong_Ee", r.GetValue (4).ToString ());
1050
1051                         r = Enum.GetValues (typeof (EnumLong));
1052                         Assert.AreEqual (6, r.Length);
1053                         Assert.AreEqual ("long_Cc", Enum.GetName (typeof (EnumLong), (EnumLong)(0x0000000000000000)));
1054                         Assert.AreEqual ("long_Cc", r.GetValue (0).ToString ());
1055                         Assert.AreEqual ("long_Aa", Enum.GetName (typeof (EnumLong), (EnumLong)(0x0000000000000005)));
1056                         Assert.AreEqual ("long_Aa", r.GetValue (1).ToString ());
1057                         Assert.AreEqual ("long_Ff", Enum.GetName (typeof (EnumLong), (EnumLong)(0x0000000000000064)));
1058                         Assert.AreEqual ("long_Ff", r.GetValue (2).ToString ());
1059                         Assert.AreEqual ("long_Ee", Enum.GetName (typeof (EnumLong), (EnumLong)(0x7FFFFFFFFFFFFFFF)));
1060                         Assert.AreEqual ("long_Ee", r.GetValue (3).ToString ());
1061                         Assert.AreEqual ("long_Bb", Enum.GetName (typeof (EnumLong), unchecked ((EnumLong)(0xFFFFFFFF00000000))));
1062                         Assert.AreEqual ("long_Bb", r.GetValue (4).ToString ());
1063                         Assert.AreEqual ("long_Dd", Enum.GetName (typeof (EnumLong), unchecked ((EnumLong)(0xFFFFFFFFFFFFFFFF))));
1064                         Assert.AreEqual ("long_Dd", r.GetValue (5).ToString ());
1065                 }
1066
1067                 [Flags]
1068                 enum SomeEnum
1069                 {
1070                         a,
1071                         b,
1072                         c
1073                 }
1074
1075                 [Flags]
1076                 enum SomeByteEnum : byte
1077                 {
1078                         a,
1079                         b,
1080                         c
1081                 }
1082
1083                 [Flags]
1084                 enum SomeInt64Enum : long
1085                 {
1086                         a,
1087                         b,
1088                         c
1089                 }
1090
1091                 enum TestShortEnum : short
1092                 {
1093                         zero,
1094                         one,
1095                         two,
1096                         three,
1097                         four,
1098                         five,
1099                         six
1100                 }
1101
1102                 enum E
1103                 {
1104                         Aa = 0,
1105                         Bb = 1,
1106                         Cc = 2,
1107                         Dd = 3,
1108                 }
1109
1110                 [Flags]
1111                 enum E2
1112                 {
1113                         Aa,
1114                         Bb,
1115                         Cc,
1116                         Dd,
1117                 }
1118
1119                 [Flags]
1120                 enum FlagsNegativeTestEnum
1121                 {
1122                         None = 0,
1123                         One = 1,
1124                         Two = 2,
1125                         Negative = unchecked ((int) 0xFFFF0000)
1126                 }
1127
1128                 enum TestingEnum
1129                 {
1130                         This,
1131                         Is,
1132                         A,
1133                         Test
1134                 }
1135
1136                 enum TestingEnum2
1137                 {
1138                         This,
1139                         Is,
1140                         A,
1141                         Test
1142                 }
1143
1144                 enum TestingEnum3 : ulong
1145                 {
1146                         This,
1147                         Is,
1148                         A,
1149                         Test = ulong.MaxValue
1150                 }
1151
1152                 enum TestingEnum4 : byte
1153                 {
1154                         This,
1155                         Is,
1156                         A,
1157                         Test = byte.MaxValue
1158                 }
1159
1160                 enum TestingEnum5 : short
1161                 {
1162                         This,
1163                         Is,
1164                         A,
1165                         Test = short.MaxValue
1166                 }
1167
1168                 enum TestingEnum6
1169                 {
1170                         This,
1171                         Is,
1172                         A,
1173                         Test = int.MaxValue
1174                 }
1175
1176                 enum E3
1177                 {
1178                         A = 0,
1179                         B = 1,
1180                         C = 2,
1181                         D = 3
1182                 }
1183
1184                 enum UE : ulong
1185                 {
1186                         A = 1,
1187                         B = 2,
1188                         C = 4,
1189                         D = 8
1190                 }
1191
1192                 enum EA
1193                 {
1194                         A = 0,
1195                         B = 2,
1196                         C = 3,
1197                         D = 4
1198                 }
1199
1200                 enum EnInt8 : sbyte{
1201                         A = SByte.MinValue,
1202                         B = 44,
1203                         C = SByte.MaxValue,
1204                 }
1205
1206                 enum EnUInt8 : byte {
1207                         A = Byte.MinValue,
1208                         B = 55,
1209                         C = Byte.MaxValue,
1210                 }
1211
1212                 enum EnInt16 : short{
1213                         A = Int16.MinValue,
1214                         B = 66,
1215                         C = Int16.MaxValue,
1216                 }
1217
1218                 enum EnUInt16 : ushort {
1219                         A = UInt16.MinValue,
1220                         B = 77,
1221                         C = UInt16.MaxValue,
1222                 }
1223
1224                 enum EnInt32 : int{
1225                         A = Int32.MinValue,
1226                         B = 88,
1227                         C = Int32.MaxValue,
1228                 }
1229
1230                 enum EnUInt32 : uint {
1231                         A = UInt32.MinValue,
1232                         B = 99,
1233                         C = UInt32.MaxValue,
1234                 }
1235
1236                 enum EnInt64 : long{
1237                         A = Int64.MinValue,
1238                         B = 3488924689489L,
1239                         C = Int64.MaxValue,
1240                         D = 456L
1241                 }
1242
1243                 enum EnUInt64 : ulong {
1244                         A = UInt64.MinValue,
1245                         B = 3488924689489L,
1246                         C = UInt64.MaxValue,
1247                         D = 789L
1248                 }
1249
1250                 enum EnumByte : byte {
1251                   byte_Aa = 5,
1252                   byte_Bb = 0xff,
1253                   byte_Cc = 0,
1254                   byte_Dd = 0x7f,
1255                   byte_Ff = 100
1256                 }
1257
1258                 enum EnumSByte : sbyte {
1259                   sbyte_Aa = 5,
1260                   sbyte_Bb = unchecked ((sbyte) 0xf0),
1261                   sbyte_Cc = 0,
1262                   sbyte_Dd = -1,
1263                   sbyte_Ee = 0x7F,
1264                   sbyte_Ff = 100
1265                 }
1266
1267                 enum EnumShort : short
1268                 {
1269                   short_Aa = 5,
1270                   short_Bb = unchecked((short)0xFF00),
1271                   short_Cc = 0,
1272                   short_Dd = -1,
1273                   short_Ee = 0x7FFF,
1274                   short_Ff = 100
1275                 }
1276
1277                 enum EnumUShort : ushort
1278                 {
1279                   ushort_Aa = 5,
1280                   ushort_Bb = unchecked((int)0xFF00),
1281                   ushort_Cc = 0,
1282                   ushort_Ee = 0x7FFF,
1283                   ushort_Ff = 100
1284                 }
1285
1286                 enum EnumInt
1287                 {
1288                   int_Aa = 5,
1289                   int_Bb = unchecked((int)0xFFFF0000),
1290                   int_Cc = 0,
1291                   int_Dd = -1,
1292                   int_Ee = 0x7FFFFFFF,
1293                   int_Ff = 100
1294                 }
1295
1296                 enum EnumUInt : uint
1297                 {
1298                   uint_Aa = 5,
1299                   uint_Cc = 0,
1300                   uint_Ee = 0x7FFFFFFF,
1301                   uint_Ff = 100
1302                 }
1303
1304                 enum EnumLong : long
1305                 {
1306                   long_Aa = 5,
1307                   long_Bb = unchecked((long)0xffffFFFF00000000),
1308                   long_Cc = 0,
1309                   long_Dd = -1,
1310                   long_Ee = 0x7FFFFFFFffffffff,
1311                   long_Ff = 100
1312                 }
1313
1314                 enum EnumULong : ulong
1315                 {
1316                   ulong_Aa = 5,
1317                   ulong_Bb = unchecked((int)0xffffFFFF00000000),
1318                   ulong_Cc = 0,
1319                   ulong_Ee = 0x7FFFFFFFffffffff,
1320                   ulong_Ff = 100
1321                 }
1322
1323         }
1324 }