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                         Assert.AreEqual ("FF", TestingEnum4.Test.ToString ("x"), "#B3");
 205                         Assert.AreEqual ("FF", TestingEnum4.Test.ToString ("X"), "#B4");
 206
 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");
 211
 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");
 216
 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");
 221                 }
 222
 223                 [Test]
 224                 public void TestGetHashCode ()
 225                 {
 226                         Enum e1 = new TestingEnum ();
 227                         Enum e2 = new TestingEnum2 ();
 228
 229                         Assert.AreEqual (e1.GetHashCode (), e1.GetHashCode ());
 230                 }
 231
 232                 [Test]
 233                 public void GetName ()
 234                 {
 235                         try {
 236                                 TestingEnum x = TestingEnum.Test;
 237                                 Enum.GetName (null, x);
 238                                 Assert.Fail ("#A1");
 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");
 245                         }
 246
 247                         try {
 248                                 TestingEnum x = TestingEnum.Test;
 249                                 Enum.GetName (x.GetType (), null);
 250                                 Assert.Fail ("#B1");
 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");
 257                         }
 258
 259                         try {
 260                                 String bad = "huh?";
 261                                 TestingEnum x = TestingEnum.Test;
 262                                 Enum.GetName (bad.GetType (), x);
 263                                 Assert.Fail ("#C1");
 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");
 271                         }
 272
 273                         try {
 274                                 String bad = "huh?";
 275                                 TestingEnum x = TestingEnum.Test;
 276                                 Enum.GetName (x.GetType (), bad);
 277                                 Assert.Fail ("#D1");
 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");
 284                         }
 285
 286                         TestingEnum a = TestingEnum.This;
 287                         TestingEnum b = TestingEnum.Is;
 288                         TestingEnum c = TestingEnum.A;
 289                         TestingEnum2 d = TestingEnum2.Test;
 290
 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");
 295                 }
 296
 297                 [Test]
 298                 public void GetNameIdenticalToGetEnumName ()
 299                 {
 300                         Assert.AreEqual (typeof (EnumOverlap).GetEnumName (0), Enum.GetName (typeof(EnumOverlap), 0), "#1");
 301                         Assert.AreEqual ("First", Enum.GetName (typeof(EnumOverlap), 0), "#2");
 302                 }
 303
 304                 [Test]
 305                 public void TestGetNames ()
 306                 {
 307                         try {
 308                                 Enum.GetNames (null);
 309                                 Assert.Fail ("#A1");
 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");
 316                         }
 317
 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");
 325                 }
 326
 327                 [Test]
 328                 public void TestGetTypeCode ()
 329                 {
 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");
 334                 }
 335
 336                 [Test]
 337                 public void TestGetUnderlyingType ()
 338                 {
 339                         try {
 340                                 Enum.GetUnderlyingType (null);
 341                                 Assert.Fail ("#A1");
 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");
 348                         }
 349
 350                         try {
 351                                 String bad = "huh?";
 352                                 Enum.GetUnderlyingType (bad.GetType ());
 353                                 Assert.Fail ("#B1");
 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");
 361                         }
 362
 363                         short sh = 5;
 364                         int i = 5;
 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");
 369                 }
 370
 371                 [Test]
 372                 public void TestGetValues ()
 373                 {
 374                         try {
 375                                 Enum.GetValues (null);
 376                                 Assert.Fail ("#A1");
 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");
 383                         }
 384
 385                         try {
 386                                 String bad = "huh?";
 387                                 Enum.GetValues (bad.GetType ());
 388                                 Assert.Fail ("#B1");
 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");
 396                         }
 397
 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");
 402
 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");
 407                 }
 408
 409                 [Test]
 410                 public void TestIsDefined ()
 411                 {
 412                         try {
 413                                 Enum.IsDefined (null, 1);
 414                                 Assert.Fail ("#A1");
 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");
 421                         }
 422
 423                         try {
 424                                 TestingEnum x = TestingEnum.Test;
 425                                 Enum.IsDefined (x.GetType (), null);
 426                                 Assert.Fail ("#B1");
 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");
 433                         }
 434
 435                         try {
 436                                 String bad = "huh?";
 437                                 int i = 4;
 438                                 Enum.IsDefined (bad.GetType (), i);
 439                                 Assert.Fail ("#C1");
 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");
 447                         }
 448
 449                         try {
 450                                 TestingEnum x = TestingEnum.Test;
 451                                 short i = 4;
 452                                 Enum.IsDefined (x.GetType (), i);
 453                                 Assert.Fail ("#D1");
 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");
 459                         }
 460
 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");
 467                 }
 468
 469                 [Test]
 470                 public void TestParse1 ()
 471                 {
 472                         try {
 473                                 String name = "huh?";
 474                                 Enum.Parse (null, name);
 475                                 Assert.Fail ("#A1");
 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");
 482                         }
 483
 484                         try {
 485                                 TestingEnum x = TestingEnum.Test;
 486                                 Enum.Parse (x.GetType (), null);
 487                                 Assert.Fail ("#B1");
 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");
 494                         }
 495
 496                         try {
 497                                 String bad = "huh?";
 498                                 Enum.Parse (bad.GetType (), bad);
 499                                 Assert.Fail ("#C1");
 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");
 507                         }
 508
 509                         try {
 510                                 TestingEnum x = TestingEnum.Test;
 511                                 String bad = "";
 512                                 Enum.Parse (x.GetType (), bad);
 513                                 Assert.Fail ("#D1");
 514                         } catch (ArgumentException ex) {
 515                                 // Must specify valid information for parsing
 516                                 // in the string
 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");
 521                         }
 522
 523                         try {
 524                                 TestingEnum x = TestingEnum.Test;
 525                                 String bad = " ";
 526                                 Enum.Parse (x.GetType (), bad);
 527                                 Assert.Fail ("#E1");
 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");
 533                         }
 534
 535                         try {
 536                                 String bad = "huh?";
 537                                 TestingEnum x = TestingEnum.Test;
 538                                 Enum.Parse (x.GetType (), bad);
 539                                 Assert.Fail ("#F1");
 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");
 545                         }
 546
 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");
 557                 }
 558
 559                 [Test]
 560                 public void TestParse2 ()
 561                 {
 562                         try {
 563                                 String name = "huh?";
 564                                 Enum.Parse (null, name, true);
 565                                 Assert.Fail ("#A1");
 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");
 572                         }
 573
 574                         try {
 575                                 TestingEnum x = TestingEnum.Test;
 576                                 Enum.Parse (x.GetType (), null, true);
 577                                 Assert.Fail ("#B1");
 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");
 584                         }
 585
 586                         try {
 587                                 String bad = "huh?";
 588                                 Enum.Parse (bad.GetType (), bad, true);
 589                                 Assert.Fail ("#C1");
 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");
 597                         }
 598
 599                         try {
 600                                 TestingEnum x = TestingEnum.Test;
 601                                 String bad = "";
 602                                 Enum.Parse (x.GetType (), bad, true);
 603                                 Assert.Fail ("#E1");
 604                         } catch (ArgumentException ex) {
 605                                 // Must specify valid information for parsing
 606                                 // in the string
 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");
 611                         }
 612
 613                         try {
 614                                 TestingEnum x = TestingEnum.Test;
 615                                 String bad = " ";
 616                                 Enum.Parse (x.GetType (), bad, true);
 617                                 Assert.Fail ("#F1");
 618                         } catch (ArgumentException ex) {
 619                                 // Must specify valid information for parsing
 620                                 // in the string
 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");
 626                         }
 627
 628                         try {
 629                                 String bad = "huh?";
 630                                 TestingEnum x = TestingEnum.Test;
 631                                 Enum.Parse (x.GetType (), bad, true);
 632                                 Assert.Fail ("#G1");
 633                         } catch (ArgumentException ex) {
 634                                 // Requested value 'huh?' was not found
 635                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#G2");
 636                                 Assert.IsNull (ex.InnerException, "#G3");
 637                                 Assert.IsNotNull (ex.Message, "#G4");
 638                                 Assert.IsTrue (ex.Message.IndexOf ("'huh?'") != -1, "#G5");
 639                                 Assert.IsNull (ex.ParamName, "#G6");
 640                         }
 641
 642                         try {
 643                                 String bad = "test";
 644                                 TestingEnum x = TestingEnum.Test;
 645                                 Enum.Parse (x.GetType (), bad, false);
 646                                 Assert.Fail ("#H1");
 647                         } catch (ArgumentException ex) {
 648                                 // Requested value 'test' was not found
 649                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#H2");
 650                                 Assert.IsNull (ex.InnerException, "#H3");
 651                                 Assert.IsNotNull (ex.Message, "#H4");
 652                                 Assert.IsTrue (ex.Message.IndexOf ("'test'") != -1, "#H5");
 653                                 Assert.IsNull (ex.ParamName, "#H6");
 654                         }
 655
 656                         TestingEnum t1 = new TestingEnum ();
 657                         Assert.AreEqual (TestingEnum.This, Enum.Parse (t1.GetType (), "this", true), "#I1");
 658                         Assert.AreEqual (TestingEnum.Is, Enum.Parse (t1.GetType (), "is", true), "#I2");
 659                         Assert.AreEqual (TestingEnum.A, Enum.Parse (t1.GetType (), "a", true), "#I3");
 660                         Assert.AreEqual (TestingEnum.Test, Enum.Parse (t1.GetType (), "test", true), "#I4");
 661                         Assert.AreEqual (TestingEnum.Test, Enum.Parse (t1.GetType (), "    \n\ntest\t", true), "#I5");
 662
 663                         Assert.AreEqual (TestingEnum.Is, Enum.Parse (t1.GetType (), "This,is", true), "#J1");
 664                         Assert.AreEqual (TestingEnum.Test, Enum.Parse (t1.GetType (), "This,test", true), "#J2");
 665                         Assert.AreEqual (TestingEnum.Test, Enum.Parse (t1.GetType (), "This,is,A", true), "#J3");
 666                         Assert.AreEqual (TestingEnum.Test, Enum.Parse (t1.GetType (), "   \n\tThis \t\n,    is,a \n", true), "#J4");
 667                 }
 668
 669                 [Test]
 670                 public void ParseValue ()
 671                 {
 672                         TestingEnum3 t1 = new TestingEnum3 ();
 673                         Assert.AreEqual (TestingEnum3.Test, Enum.Parse (t1.GetType (), "18446744073709551615", false));
 674                 }
 675
 676 #if NET_4_0
 677                 [Test]
 678                 public void TryParseErrors ()
 679                 {
 680                         TestingEnum result;
 681                         bool success;
 682
 683                         success = Enum.TryParse<TestingEnum> (null, out result);
 684                         Assert.AreEqual (false, success, "#A1");
 685                         Assert.AreEqual (TestingEnum.This, result, "#A2");
 686
 687                         success = Enum.TryParse<TestingEnum> ("WrongValue", out result);
 688                         Assert.AreEqual (false, success, "#B1");
 689                         Assert.AreEqual (TestingEnum.This, result, "#B2");
 690
 691                         success = Enum.TryParse<TestingEnum> (String.Empty, out result);
 692                         Assert.AreEqual (false, success, "#C1");
 693                         Assert.AreEqual (TestingEnum.This, result, "#C2");
 694
 695                         success = Enum.TryParse<TestingEnum> (" ", out result);
 696                         Assert.AreEqual (false, success, "#D1");
 697                         Assert.AreEqual (TestingEnum.This, result, "#D2");
 698
 699                         // TryParse throws ArgumentException if TEnum is not an enumeration type
 700                         try {
 701                                 int n;
 702                                 Enum.TryParse<int> ("31416", out n);
 703                                 Assert.Fail ("#E1");
 704                         } catch (ArgumentException ex) {
 705                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#E2");
 706                                 Assert.IsNull (ex.InnerException, "#E3");
 707                                 Assert.IsNotNull (ex.Message, "#E4");
 708                                 Assert.IsNotNull (ex.ParamName, "#E5");
 709                                 Assert.AreEqual ("enumType", ex.ParamName, "#E6");
 710                         }
 711                 }
 712
 713                 [Test]
 714                 public void TryParse ()
 715                 {
 716                         TestingEnum result;
 717                         bool success;
 718
 719                         success = Enum.TryParse<TestingEnum> ("Is", out result);
 720                         Assert.AreEqual (true, success, "#A1");
 721                         Assert.AreEqual (TestingEnum.Is, result, "#A2");
 722
 723                         success = Enum.TryParse<TestingEnum> ("100", out result);
 724                         Assert.AreEqual (true, success, "#C1");
 725                         Assert.AreEqual (((TestingEnum)100), result, "#C2");
 726
 727                         success = Enum.TryParse<TestingEnum> ("is", out result);
 728                         Assert.AreEqual (false, success, "#D1");
 729                         Assert.AreEqual (TestingEnum.This, result, "#D2");
 730
 731                         success = Enum.TryParse<TestingEnum> ("is", true, out result);
 732                         Assert.AreEqual (true, success, "#D1");
 733                         Assert.AreEqual (TestingEnum.Is, result, "#D2");
 734
 735                         success = Enum.TryParse<TestingEnum> ("  Is  ", out result);
 736                         Assert.AreEqual (true, success, "#E1");
 737                         Assert.AreEqual (TestingEnum.Is, result, "#E2");
 738                 }
 739 #endif
 740
 741                 [Test]
 742                 public void ToObject_EnumType_Int32 ()
 743                 {
 744                         object value = Enum.ToObject (typeof (TestingEnum), 0);
 745                         Assert.AreEqual (TestingEnum.This, value, "#1");
 746                         value = Enum.ToObject (typeof (TestingEnum), 2);
 747                         Assert.AreEqual (TestingEnum.A, value, "#2");
 748                 }
 749
 750                 [Test]
 751                 public void ToObject_EnumType_UInt64 ()
 752                 {
 753                         object value = Enum.ToObject (typeof (TestingEnum3), 0);
 754                         Assert.AreEqual (TestingEnum3.This, value, "#1");
 755                         value = Enum.ToObject (typeof (TestingEnum3), 1);
 756                         Assert.AreEqual (TestingEnum3.Is, value, "#2");
 757                         value = Enum.ToObject (typeof (TestingEnum3), ulong.MaxValue);
 758                         Assert.AreEqual (TestingEnum3.Test, value, "#3");
 759                 }
 760
 761                 [Test]
 762                 public void ToObject_EnumType_Byte ()
 763                 {
 764                         object value = Enum.ToObject (typeof (TestingEnum4), 0);
 765                         Assert.AreEqual (TestingEnum4.This, value, "#1");
 766                         value = Enum.ToObject (typeof (TestingEnum4), byte.MaxValue);
 767                         Assert.AreEqual (TestingEnum4.Test, value, "#2");
 768                 }
 769
 770                 [Test]
 771                 public void ToObject_EnumType_Int16 ()
 772                 {
 773                         object value = Enum.ToObject (typeof (TestingEnum5), 0);
 774                         Assert.AreEqual (TestingEnum5.This, value, "#1");
 775                         value = Enum.ToObject (typeof (TestingEnum5), short.MaxValue);
 776                         Assert.AreEqual (TestingEnum5.Test, value, "#2");
 777                 }
 778
 779                 [Test]
 780                 public void ToObject_EnumType_Bool ()
 781                 {
 782                         object value = Enum.ToObject (typeof (TestingEnum5), true);
 783                         Assert.AreEqual (TestingEnum5.Is, value, "#1");
 784                 }
 785
 786                 [Test]
 787                 public void ToObject_EnumType_Char ()
 788                 {
 789                         object value = Enum.ToObject (typeof (TestingEnum3), (object) '\0');
 790                         Assert.AreEqual (TestingEnum3.This, value, "#1");
 791                 }
 792
 793                 [Test]
 794                 public void ToObject_EnumType_Invalid ()
 795                 {
 796                         try {
 797                                 Enum.ToObject (typeof (string), 1);
 798                                 Assert.Fail ("#1");
 799                         } catch (ArgumentException ex) {
 800                                 // Type provided must be an Enum
 801                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 802                                 Assert.IsNull (ex.InnerException, "#3");
 803                                 Assert.IsNotNull (ex.Message, "#4");
 804                                 Assert.IsNotNull (ex.ParamName, "#5");
 805                                 Assert.AreEqual ("enumType", ex.ParamName, "#6");
 806                         }
 807                 }
 808
 809                 [Test]
 810                 public void ToObject_EnumType_Null ()
 811                 {
 812                         try {
 813                                 Enum.ToObject (null, 1);
 814                                 Assert.Fail ("#1");
 815                         } catch (ArgumentNullException ex) {
 816                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 817                                 Assert.IsNull (ex.InnerException, "#3");
 818                                 Assert.IsNotNull (ex.Message, "#4");
 819                                 Assert.IsNotNull (ex.ParamName, "#5");
 820                                 Assert.AreEqual ("enumType", ex.ParamName, "#6");
 821                         }
 822                 }
 823
 824                 [Test]
 825                 public void ToObject_Value_Null ()
 826                 {
 827                         try {
 828                                 Enum.ToObject (typeof (TestingEnum), (object) null);
 829                                 Assert.Fail ("#1");
 830                         } catch (ArgumentNullException ex) {
 831                                 Assert.AreEqual (typeof (ArgumentNullException), ex.GetType (), "#2");
 832                                 Assert.IsNull (ex.InnerException, "#3");
 833                                 Assert.IsNotNull (ex.Message, "#4");
 834                                 Assert.IsNotNull (ex.ParamName, "#5");
 835                                 Assert.AreEqual ("value", ex.ParamName, "#6");
 836                         }
 837                 }
 838
 839                 [Test]
 840                 public void ToObject_Value_Invalid ()
 841                 {
 842                         try {
 843                                 Enum.ToObject (typeof (TestingEnum), "This");
 844                                 Assert.Fail ("#1");
 845                         } catch (ArgumentException ex) {
 846                                 // The value passed in must be an enum base or
 847                                 // an underlying type for an enum, such as an
 848                                 // Int32
 849                                 Assert.AreEqual (typeof (ArgumentException), ex.GetType (), "#2");
 850                                 Assert.IsNull (ex.InnerException, "#3");
 851                                 Assert.IsNotNull (ex.Message, "#4");
 852                                 Assert.IsNotNull (ex.ParamName, "#5");
 853                                 Assert.AreEqual ("value", ex.ParamName, "#6");
 854                         }
 855                 }
 856
 857                 [Test]
 858                 public void IConvertible_Valid ()
 859                 {
 860                         IConvertible ic = TestingEnum.This;
 861                         Assert.AreEqual ("This", ic.ToType (typeof (string), null), "#1");
 862                         Assert.AreEqual (TestingEnum.This, ic.ToType (typeof (TestingEnum), null), "#2");
 863                         Assert.AreEqual (TestingEnum.This, ic.ToType (typeof (Enum), null), "#3");
 864                 }
 865
 866                 [Test]
 867                 public void TestToString ()
 868                 {
 869                         Assert.AreEqual ("This", TestingEnum.This.ToString (), "#A1");
 870                         Assert.AreEqual ("Is", TestingEnum.Is.ToString (), "#A2");
 871                         Assert.AreEqual ("A", TestingEnum.A.ToString (), "#A3");
 872                         Assert.AreEqual ("Test", TestingEnum.Test.ToString (), "#A4");
 873
 874                         Enum is1 = TestingEnum.Is;
 875
 876                         Assert.AreEqual ("1", is1.ToString ("d"), "#B1");
 877                         Assert.AreEqual ("Is", is1.ToString ("g"), "#B2");
 878                         Assert.AreEqual ("00000001", is1.ToString ("x"), "#B3");
 879                         Assert.AreEqual ("Is", is1.ToString ("f"), "#B4");
 880
 881                         Assert.AreEqual ("b, c", ((SomeEnum) 3).ToString ("f"), "#C1");
 882                         Assert.AreEqual ("b, c", ((SomeByteEnum) 3).ToString ("f"), "#C2");
 883                         Assert.AreEqual ("b, c", ((SomeInt64Enum) 3).ToString ("f"), "#C3");
 884
 885                         Assert.AreEqual ("12", ((SomeEnum) 12).ToString ("f"), "#D1");
 886                         Assert.AreEqual ("12", ((SomeByteEnum) 12).ToString ("f"), "#D2");
 887                         Assert.AreEqual ("12", ((SomeInt64Enum) 12).ToString ("f"), "#D3");
 888                 }
 889
 890                 [Test]
 891                 public void FlagTest ()
 892                 {
 893                         int [] evalues = new int [4] { 0, 1, 2, 3 };
 894                         E [] e = new E [4] { E.Aa, E.Bb, E.Cc, E.Dd };
 895
 896                         for (int i = 0; i < 4; ++i)
 897                                 Assert.AreEqual (e [i].ToString (),
 898                                         Enum.Format (typeof (E), evalues [i], "f"),
 899                                         "#1" + i);
 900
 901                         int invalidValue = 1000;
 902
 903                         Assert.AreEqual (invalidValue.ToString (),
 904                                 Enum.Format (typeof (E2), invalidValue, "g"),
 905                                 "#2");
 906                 }
 907
 908                 [Test]
 909                 public void FlagTest_Negative ()
 910                 {
 911                         FlagsNegativeTestEnum t;
 912
 913                         t = FlagsNegativeTestEnum.None;
 914                         Assert.AreEqual ("None", t.ToString (), "#01");
 915                         t = FlagsNegativeTestEnum.One;
 916                         Assert.AreEqual ("One", t.ToString (), "#02");
 917                 }
 918
 919                 [Test]
 920                 public void AnotherFormatBugPinned ()
 921                 {
 922                         Assert.AreEqual ("100", Enum.Format (typeof (E3), 100, "f"));
 923                 }
 924
 925                 [Test]
 926                 public void LogicBugPinned ()
 927                 {
 928                         string format = null;
 929                         string [] names = new string [] { "A", "B", "C", "D", };
 930                         string [] fmtSpl = null;
 931                         UE ue = UE.A | UE.B | UE.C | UE.D;
 932
 933                         //all flags must be in format return
 934                         format = Enum.Format (typeof (UE), ue, "f");
 935                         fmtSpl = format.Split (',');
 936                         for (int i = 0; i < fmtSpl.Length; ++i)
 937                                 fmtSpl [i] = fmtSpl [i].Trim ();
 938
 939                         foreach (string nval in fmtSpl)
 940                                 Assert.IsTrue (Array.IndexOf (names, nval) >= 0, "#1:" + nval);
 941
 942                         foreach (string nval in names)
 943                                 Assert.IsTrue (Array.IndexOf (fmtSpl, nval) >= 0, "#2:" + nval);
 944                 }
 945                 // TODO - ToString with IFormatProviders
 946
 947                 [Test]
 948                 public void GetHashCode_ShouldBeEqualToUnderlyingType ()
 949                 {
 950                         Assert.AreEqual (EnInt8.A.GetHashCode(), SByte.MinValue, "i8#0");
 951                         Assert.AreEqual (EnInt8.B.GetHashCode(), 44, "i8#1");
 952                         Assert.AreEqual (EnInt8.C.GetHashCode(), SByte.MaxValue, "i8#2");
 953
 954                         Assert.AreEqual (EnUInt8.A.GetHashCode(), Byte.MinValue, "u8#0");
 955                         Assert.AreEqual (EnUInt8.B.GetHashCode(), 55, "u8#1");
 956                         Assert.AreEqual (EnUInt8.C.GetHashCode(), Byte.MaxValue, "u8#2");
 957
 958                         Assert.AreEqual (EnInt16.A.GetHashCode(), Int16.MinValue, "i16#0");
 959                         Assert.AreEqual (EnInt16.B.GetHashCode(), 66, "i16#1");
 960                         Assert.AreEqual (EnInt16.C.GetHashCode(), Int16.MaxValue, "i16#2");
 961
 962                         Assert.AreEqual (EnUInt16.A.GetHashCode(), UInt16.MinValue, "u16#0");
 963                         Assert.AreEqual (EnUInt16.B.GetHashCode(), 77, "u16#1");
 964                         Assert.AreEqual (EnUInt16.C.GetHashCode(), UInt16.MaxValue, "u16#2");
 965
 966                         Assert.AreEqual (EnInt32.A.GetHashCode(), Int32.MinValue, "i32#0");
 967                         Assert.AreEqual (EnInt32.B.GetHashCode(), 88, "i32#1");
 968                         Assert.AreEqual (EnInt32.C.GetHashCode(), Int32.MaxValue, "i32#2");
 969
 970                         Assert.AreEqual (EnUInt32.A.GetHashCode(), UInt32.MinValue, "u32#0");
 971                         Assert.AreEqual (EnUInt32.B.GetHashCode(), 99, "u32#1");
 972                         Assert.AreEqual (EnUInt32.C.GetHashCode(), UInt32.MaxValue.GetHashCode (), "u32#2");
 973
 974                         Assert.AreEqual (EnInt64.A.GetHashCode(), Int64.MinValue.GetHashCode (), "i64#0");
 975                         Assert.AreEqual (EnInt64.B.GetHashCode(), 3488924689489L.GetHashCode (), "i64#1");
 976                         Assert.AreEqual (EnInt64.C.GetHashCode(), Int64.MaxValue.GetHashCode (), "i64#2");
 977
 978                         Assert.AreEqual (EnUInt64.A.GetHashCode(), UInt64.MinValue.GetHashCode (), "u64#0");
 979                         Assert.AreEqual (EnUInt64.B.GetHashCode(), 3488924689489L.GetHashCode (), "u64#1");
 980                         Assert.AreEqual (EnUInt64.C.GetHashCode(), UInt64.MaxValue.GetHashCode (), "u64#2");
 981                 }
 982
 983                 [Test]
 984                 public void CompareTo_NotEqualToUnderlyingType ()
 985                 {
 986                         Assert.AreEqual (0, EnInt8.A.CompareTo (EnInt8.A), "i8#0");
 987                         Assert.AreEqual (-1, EnInt8.A.CompareTo (EnInt8.B), "i8#1");
 988                         Assert.AreEqual (1, EnInt8.B.CompareTo (EnInt8.A), "i8#2");
 989
 990                         Assert.AreEqual (0, EnUInt8.A.CompareTo (EnUInt8.A), "ui8#0");
 991                         Assert.AreEqual (-1,  EnUInt8.A.CompareTo (EnUInt8.B), "ui8#1");
 992                         Assert.AreEqual (1, EnUInt8.B.CompareTo (EnUInt8.A),"ui8#2");
 993
 994                         Assert.AreEqual (0, EnInt16.A.CompareTo (EnInt16.A), "i16#0");
 995                         Assert.AreEqual (-1, EnInt16.A.CompareTo (EnInt16.B), "i16#1");
 996                         Assert.AreEqual (1, EnInt16.B.CompareTo (EnInt16.A), "i16#2");
 997
 998                         Assert.AreEqual (0, EnUInt16.A.CompareTo (EnUInt16.A), "ui16#0");
 999                         Assert.AreEqual (-1, EnUInt16.A.CompareTo (EnUInt16.B), "ui16#1");
1000                         Assert.AreEqual (1, EnUInt16.B.CompareTo (EnUInt16.A), "ui16#2");
1001
1002                         Assert.AreEqual (int.MinValue.CompareTo (int.MinValue), EnInt32.A.CompareTo (EnInt32.A), "i32#0");
1003                         Assert.AreEqual (int.MinValue.CompareTo ((int)88), EnInt32.A.CompareTo (EnInt32.B), "i32#1");
1004                         Assert.AreEqual (((int)88).CompareTo (int.MinValue), EnInt32.B.CompareTo (EnInt32.A), "i32#2");
1005
1006                         Assert.AreEqual (uint.MinValue.CompareTo (uint.MinValue), EnUInt32.A.CompareTo (EnUInt32.A), "u32#0");
1007                         Assert.AreEqual (uint.MinValue.CompareTo ((uint)99), EnUInt32.A.CompareTo (EnUInt32.B), "u32#1");
1008                         Assert.AreEqual (((uint)99).CompareTo (uint.MinValue), EnUInt32.B.CompareTo (EnUInt32.A), "u32#2");
1009
1010                         Assert.AreEqual (long.MinValue.CompareTo (long.MinValue), EnInt64.A.CompareTo (EnInt64.A), "i64#0");
1011                         Assert.AreEqual (long.MinValue.CompareTo ((long)456), EnInt64.A.CompareTo (EnInt64.D), "i64#1");
1012                         Assert.AreEqual (((long)456).CompareTo (long.MinValue), EnInt64.D.CompareTo (EnInt64.A), "i64#2");
1013
1014                         Assert.AreEqual (ulong.MinValue.CompareTo (ulong.MinValue), EnUInt64.A.CompareTo (EnUInt64.A), "u64#0");
1015                         Assert.AreEqual (ulong.MinValue.CompareTo ((ulong)789),  EnUInt64.A.CompareTo (EnUInt64.D), "u64#1");
1016                         Assert.AreEqual (((ulong)789).CompareTo (ulong.MinValue), EnUInt64.D.CompareTo (EnUInt64.A), "u64#2");
1017                 }
1018
1019                 //
1020                 // This is used to verify that the output matches the specified behavior
1021                 // See bug #371559 for details.
1022                 //
1023                 [Test]
1024                 public void CompareOrder_FromGetNames ()
1025                 {
1026                         Array r = Enum.GetValues (typeof (EnumByte));
1027                         Assert.AreEqual (5, r.Length);
1028                         Assert.AreEqual ("byte_Cc", Enum.GetName (typeof (EnumByte), (EnumByte)(0x00)));
1029                         Assert.AreEqual ("byte_Cc", r.GetValue (0).ToString ());
1030                         Assert.AreEqual ("byte_Aa", Enum.GetName (typeof (EnumByte), (EnumByte)(0x05)));
1031                         Assert.AreEqual ("byte_Aa", r.GetValue (1).ToString ());
1032                         Assert.AreEqual ("byte_Ff", Enum.GetName (typeof (EnumByte), (EnumByte)(0x64)));
1033                         Assert.AreEqual ("byte_Ff", r.GetValue (2).ToString ());
1034                         Assert.AreEqual ("byte_Dd", Enum.GetName (typeof (EnumByte), (EnumByte)(0x7F)));
1035                         Assert.AreEqual ("byte_Dd", r.GetValue (3).ToString ());
1036                         Assert.AreEqual ("byte_Bb", Enum.GetName (typeof (EnumByte), (EnumByte)(0xFF)));
1037                         Assert.AreEqual ("byte_Bb", r.GetValue (4).ToString ());
1038
1039                         r = Enum.GetValues (typeof (EnumSByte));
1040                         Assert.AreEqual (6, r.Length);
1041                         Assert.AreEqual ("sbyte_Cc", Enum.GetName (typeof (EnumSByte), (EnumSByte)(0x00)));
1042                         Assert.AreEqual ("sbyte_Cc", r.GetValue (0).ToString ());
1043                         Assert.AreEqual ("sbyte_Aa", Enum.GetName (typeof (EnumSByte), (EnumSByte)(0x05)));
1044                         Assert.AreEqual ("sbyte_Aa", r.GetValue (1).ToString ());
1045                         Assert.AreEqual ("sbyte_Ff", Enum.GetName (typeof (EnumSByte), (EnumSByte)(0x64)));
1046                         Assert.AreEqual ("sbyte_Ff", r.GetValue (2).ToString ());
1047                         Assert.AreEqual ("sbyte_Ee", Enum.GetName (typeof (EnumSByte), (EnumSByte)(0x7F)));
1048                         Assert.AreEqual ("sbyte_Ee", r.GetValue (3).ToString ());
1049                         Assert.AreEqual ("sbyte_Bb", Enum.GetName (typeof (EnumSByte), unchecked ((EnumSByte)(0xF0))));
1050                         Assert.AreEqual ("sbyte_Bb", r.GetValue (4).ToString ());
1051                         Assert.AreEqual ("sbyte_Dd", Enum.GetName (typeof (EnumSByte), unchecked ((EnumSByte)(0xFF))));
1052                         Assert.AreEqual ("sbyte_Dd", r.GetValue (5).ToString ());
1053
1054                         r = Enum.GetValues (typeof (EnumUShort));
1055                         Assert.AreEqual (5, r.Length);
1056                         Assert.AreEqual ("ushort_Cc", Enum.GetName (typeof (EnumUShort), (EnumUShort)(0x0000)));
1057                         Assert.AreEqual ("ushort_Cc", r.GetValue (0).ToString ());
1058                         Assert.AreEqual ("ushort_Aa", Enum.GetName (typeof (EnumUShort), (EnumUShort)(0x0005)));
1059                         Assert.AreEqual ("ushort_Aa", r.GetValue (1).ToString ());
1060                         Assert.AreEqual ("ushort_Ff", Enum.GetName (typeof (EnumUShort), (EnumUShort)(0x0064)));
1061                         Assert.AreEqual ("ushort_Ff", r.GetValue (2).ToString ());
1062                         Assert.AreEqual ("ushort_Ee", Enum.GetName (typeof (EnumUShort), (EnumUShort)(0x7FFF)));
1063                         Assert.AreEqual ("ushort_Ee", r.GetValue (3).ToString ());
1064                         Assert.AreEqual ("ushort_Bb", Enum.GetName (typeof (EnumUShort), (EnumUShort)(0xFF00)));
1065                         Assert.AreEqual ("ushort_Bb", r.GetValue (4).ToString ());
1066
1067                         r = Enum.GetValues (typeof (EnumShort));
1068                         Assert.AreEqual (6, r.Length);
1069                         Assert.AreEqual ("short_Cc", Enum.GetName (typeof (EnumShort), (EnumShort)(0x0000)));
1070                         Assert.AreEqual ("short_Cc", r.GetValue (0).ToString ());
1071                         Assert.AreEqual ("short_Aa", Enum.GetName (typeof (EnumShort), (EnumShort)(0x0005)));
1072                         Assert.AreEqual ("short_Aa", r.GetValue (1).ToString ());
1073                         Assert.AreEqual ("short_Ff", Enum.GetName (typeof (EnumShort), (EnumShort)(0x0064)));
1074                         Assert.AreEqual ("short_Ff", r.GetValue (2).ToString ());
1075                         Assert.AreEqual ("short_Ee", Enum.GetName (typeof (EnumShort), (EnumShort)(0x7FFF)));
1076                         Assert.AreEqual ("short_Ee", r.GetValue (3).ToString ());
1077                         Assert.AreEqual ("short_Bb", Enum.GetName (typeof (EnumShort), unchecked ((EnumShort)(0xFF00))));
1078                         Assert.AreEqual ("short_Bb", r.GetValue (4).ToString ());
1079                         Assert.AreEqual ("short_Dd", Enum.GetName (typeof (EnumShort), unchecked ((EnumShort)(0xFFFF))));
1080                         Assert.AreEqual ("short_Dd", r.GetValue (5).ToString ());
1081
1082                         r = Enum.GetValues (typeof (EnumUInt));
1083                         Assert.AreEqual (4, r.Length);
1084                         Assert.AreEqual ("uint_Cc", Enum.GetName (typeof (EnumUInt), (EnumUInt)(0x00000000)));
1085                         Assert.AreEqual ("uint_Cc", r.GetValue (0).ToString ());
1086                         Assert.AreEqual ("uint_Aa", Enum.GetName (typeof (EnumUInt), (EnumUInt)(0x00000005)));
1087                         Assert.AreEqual ("uint_Aa", r.GetValue (1).ToString ());
1088                         Assert.AreEqual ("uint_Ff", Enum.GetName (typeof (EnumUInt), (EnumUInt)(0x00000064)));
1089                         Assert.AreEqual ("uint_Ff", r.GetValue (2).ToString ());
1090                         Assert.AreEqual ("uint_Ee", Enum.GetName (typeof (EnumUInt), (EnumUInt)(0x7FFFFFFF)));
1091                         Assert.AreEqual ("uint_Ee", r.GetValue (3).ToString ());
1092
1093                         r = Enum.GetValues (typeof (EnumInt));
1094                         Assert.AreEqual (6, r.Length);
1095                         Assert.AreEqual ("int_Cc", Enum.GetName (typeof (EnumInt), (EnumInt)(0x00000000)));
1096                         Assert.AreEqual ("int_Cc", r.GetValue (0).ToString ());
1097                         Assert.AreEqual ("int_Aa", Enum.GetName (typeof (EnumInt), (EnumInt)(0x00000005)));
1098                         Assert.AreEqual ("int_Aa", r.GetValue (1).ToString ());
1099                         Assert.AreEqual ("int_Ff", Enum.GetName (typeof (EnumInt), (EnumInt)(0x00000064)));
1100                         Assert.AreEqual ("int_Ff", r.GetValue (2).ToString ());
1101                         Assert.AreEqual ("int_Ee", Enum.GetName (typeof (EnumInt), (EnumInt)(0x7FFFFFFF)));
1102                         Assert.AreEqual ("int_Ee", r.GetValue (3).ToString ());
1103                         Assert.AreEqual ("int_Bb", Enum.GetName (typeof (EnumInt), unchecked ((EnumInt)(0xFFFF0000))));
1104                         Assert.AreEqual ("int_Bb", r.GetValue (4).ToString ());
1105                         Assert.AreEqual ("int_Dd", Enum.GetName (typeof (EnumInt), unchecked ((EnumInt)(0xFFFFFFFF))));
1106                         Assert.AreEqual ("int_Dd", r.GetValue (5).ToString ());
1107
1108                         r = Enum.GetValues (typeof (EnumULong));
1109                         Assert.AreEqual (5, r.Length);
1110                         Assert.AreEqual ("ulong_Cc", Enum.GetName (typeof (EnumULong), (EnumULong)(0x0000000000000000)));
1111                         Assert.AreEqual ("ulong_Cc", r.GetValue (0).ToString ());
1112                         Assert.AreEqual ("ulong_Cc", Enum.GetName (typeof (EnumULong), (EnumULong)(0x0000000000000000)));
1113                         Assert.AreEqual ("ulong_Aa", r.GetValue (1).ToString ());
1114                         Assert.AreEqual ("ulong_Aa", Enum.GetName (typeof (EnumULong), (EnumULong)(0x0000000000000005)));
1115                         Assert.AreEqual ("ulong_Ff", r.GetValue (2).ToString ());
1116                         Assert.AreEqual ("ulong_Ff", Enum.GetName (typeof (EnumULong), (EnumULong)(0x0000000000000064)));
1117                         Assert.AreEqual ("ulong_Ee", r.GetValue (3).ToString ());
1118                         Assert.AreEqual ("ulong_Ee", Enum.GetName (typeof (EnumULong), (EnumULong)(0x7FFFFFFFFFFFFFFF)));
1119                         Assert.AreEqual ("ulong_Bb", r.GetValue (4).ToString ());
1120
1121                         r = Enum.GetValues (typeof (EnumLong));
1122                         Assert.AreEqual (6, r.Length);
1123                         Assert.AreEqual ("long_Cc", Enum.GetName (typeof (EnumLong), (EnumLong)(0x0000000000000000)));
1124                         Assert.AreEqual ("long_Cc", r.GetValue (0).ToString ());
1125                         Assert.AreEqual ("long_Aa", Enum.GetName (typeof (EnumLong), (EnumLong)(0x0000000000000005)));
1126                         Assert.AreEqual ("long_Aa", r.GetValue (1).ToString ());
1127                         Assert.AreEqual ("long_Ff", Enum.GetName (typeof (EnumLong), (EnumLong)(0x0000000000000064)));
1128                         Assert.AreEqual ("long_Ff", r.GetValue (2).ToString ());
1129                         Assert.AreEqual ("long_Ee", Enum.GetName (typeof (EnumLong), (EnumLong)(0x7FFFFFFFFFFFFFFF)));
1130                         Assert.AreEqual ("long_Ee", r.GetValue (3).ToString ());
1131                         Assert.AreEqual ("long_Bb", Enum.GetName (typeof (EnumLong), unchecked ((EnumLong)(0xFFFFFFFF00000000))));
1132                         Assert.AreEqual ("long_Bb", r.GetValue (4).ToString ());
1133                         Assert.AreEqual ("long_Dd", Enum.GetName (typeof (EnumLong), unchecked ((EnumLong)(0xFFFFFFFFFFFFFFFF))));
1134                         Assert.AreEqual ("long_Dd", r.GetValue (5).ToString ());
1135                 }
1136
1137                 [Flags]
1138                 enum Foo {
1139                         negative = -1
1140                 }
1141
1142 #if NET_4_0
1143                 // Our first implementation used to crash
1144                 [Test]
1145                 public void HasFlagTest ()
1146                 {
1147                         Foo f = Foo.negative;
1148                         bool has = f.HasFlag (Foo.negative);
1149                 }
1150 #endif
1151
1152                 [Test]
1153                 [ExpectedException (typeof (ArgumentNullException))]
1154                 public void HasFlagNull ()
1155                 {
1156                         SomeEnum x = SomeEnum.a;
1157
1158                         x.HasFlag (null);
1159                 }
1160
1161                 [Test]
1162                 [ExpectedException (typeof (ArgumentException))]
1163                 public void HasFlagWrongType ()
1164                 {
1165                         SomeEnum x = SomeEnum.a;
1166
1167                         x.HasFlag (SomeByteEnum.a);
1168                 }
1169
1170                 [Flags]
1171                 enum SomeEnum
1172                 {
1173                         a,
1174                         b,
1175                         c
1176                 }
1177
1178                 [Flags]
1179                 enum SomeByteEnum : byte
1180                 {
1181                         a,
1182                         b,
1183                         c
1184                 }
1185
1186                 [Flags]
1187                 enum SomeInt64Enum : long
1188                 {
1189                         a,
1190                         b,
1191                         c
1192                 }
1193
1194                 enum TestShortEnum : short
1195                 {
1196                         zero,
1197                         one,
1198                         two,
1199                         three,
1200                         four,
1201                         five,
1202                         six
1203                 }
1204
1205                 enum E
1206                 {
1207                         Aa = 0,
1208                         Bb = 1,
1209                         Cc = 2,
1210                         Dd = 3,
1211                 }
1212
1213                 [Flags]
1214                 enum E2
1215                 {
1216                         Aa,
1217                         Bb,
1218                         Cc,
1219                         Dd,
1220                 }
1221
1222                 [Flags]
1223                 enum FlagsNegativeTestEnum
1224                 {
1225                         None = 0,
1226                         One = 1,
1227                         Two = 2,
1228                         Negative = unchecked ((int) 0xFFFF0000)
1229                 }
1230
1231                 enum TestingEnum
1232                 {
1233                         This,
1234                         Is,
1235                         A,
1236                         Test
1237                 }
1238
1239                 enum TestingEnum2
1240                 {
1241                         This,
1242                         Is,
1243                         A,
1244                         Test
1245                 }
1246
1247                 enum TestingEnum3 : ulong
1248                 {
1249                         This,
1250                         Is,
1251                         A,
1252                         Test = ulong.MaxValue
1253                 }
1254
1255                 enum TestingEnum4 : byte
1256                 {
1257                         This,
1258                         Is,
1259                         A,
1260                         Test = byte.MaxValue
1261                 }
1262
1263                 enum TestingEnum5 : short
1264                 {
1265                         This,
1266                         Is,
1267                         A,
1268                         Test = short.MaxValue
1269                 }
1270
1271                 enum TestingEnum6
1272                 {
1273                         This,
1274                         Is,
1275                         A,
1276                         Test = int.MaxValue
1277                 }
1278
1279                 enum E3
1280                 {
1281                         A = 0,
1282                         B = 1,
1283                         C = 2,
1284                         D = 3
1285                 }
1286
1287                 enum UE : ulong
1288                 {
1289                         A = 1,
1290                         B = 2,
1291                         C = 4,
1292                         D = 8
1293                 }
1294
1295                 enum EA
1296                 {
1297                         A = 0,
1298                         B = 2,
1299                         C = 3,
1300                         D = 4
1301                 }
1302
1303                 enum EnInt8 : sbyte{
1304                         A = SByte.MinValue,
1305                         B = 44,
1306                         C = SByte.MaxValue,
1307                 }
1308
1309                 enum EnUInt8 : byte {
1310                         A = Byte.MinValue,
1311                         B = 55,
1312                         C = Byte.MaxValue,
1313                 }
1314
1315                 enum EnInt16 : short{
1316                         A = Int16.MinValue,
1317                         B = 66,
1318                         C = Int16.MaxValue,
1319                 }
1320
1321                 enum EnUInt16 : ushort {
1322                         A = UInt16.MinValue,
1323                         B = 77,
1324                         C = UInt16.MaxValue,
1325                 }
1326
1327                 enum EnInt32 : int{
1328                         A = Int32.MinValue,
1329                         B = 88,
1330                         C = Int32.MaxValue,
1331                 }
1332
1333                 enum EnUInt32 : uint {
1334                         A = UInt32.MinValue,
1335                         B = 99,
1336                         C = UInt32.MaxValue,
1337                 }
1338
1339                 enum EnInt64 : long{
1340                         A = Int64.MinValue,
1341                         B = 3488924689489L,
1342                         C = Int64.MaxValue,
1343                         D = 456L
1344                 }
1345
1346                 enum EnUInt64 : ulong {
1347                         A = UInt64.MinValue,
1348                         B = 3488924689489L,
1349                         C = UInt64.MaxValue,
1350                         D = 789L
1351                 }
1352
1353                 enum EnumByte : byte {
1354                   byte_Aa = 5,
1355                   byte_Bb = 0xff,
1356                   byte_Cc = 0,
1357                   byte_Dd = 0x7f,
1358                   byte_Ff = 100
1359                 }
1360
1361                 enum EnumSByte : sbyte {
1362                   sbyte_Aa = 5,
1363                   sbyte_Bb = unchecked ((sbyte) 0xf0),
1364                   sbyte_Cc = 0,
1365                   sbyte_Dd = -1,
1366                   sbyte_Ee = 0x7F,
1367                   sbyte_Ff = 100
1368                 }
1369
1370                 enum EnumShort : short
1371                 {
1372                   short_Aa = 5,
1373                   short_Bb = unchecked((short)0xFF00),
1374                   short_Cc = 0,
1375                   short_Dd = -1,
1376                   short_Ee = 0x7FFF,
1377                   short_Ff = 100
1378                 }
1379
1380                 enum EnumUShort : ushort
1381                 {
1382                   ushort_Aa = 5,
1383                   ushort_Bb = unchecked((int)0xFF00),
1384                   ushort_Cc = 0,
1385                   ushort_Ee = 0x7FFF,
1386                   ushort_Ff = 100
1387                 }
1388
1389                 enum EnumInt
1390                 {
1391                   int_Aa = 5,
1392                   int_Bb = unchecked((int)0xFFFF0000),
1393                   int_Cc = 0,
1394                   int_Dd = -1,
1395                   int_Ee = 0x7FFFFFFF,
1396                   int_Ff = 100
1397                 }
1398
1399                 enum EnumUInt : uint
1400                 {
1401                   uint_Aa = 5,
1402                   uint_Cc = 0,
1403                   uint_Ee = 0x7FFFFFFF,
1404                   uint_Ff = 100
1405                 }
1406
1407                 enum EnumLong : long
1408                 {
1409                   long_Aa = 5,
1410                   long_Bb = unchecked((long)0xffffFFFF00000000),
1411                   long_Cc = 0,
1412                   long_Dd = -1,
1413                   long_Ee = 0x7FFFFFFFffffffff,
1414                   long_Ff = 100
1415                 }
1416
1417                 enum EnumULong : ulong
1418                 {
1419                   ulong_Aa = 5,
1420                   ulong_Bb = unchecked((ulong)0xffffFFFF00000000),
1421                   ulong_Cc = 0,
1422                   ulong_Ee = 0x7FFFFFFFffffffff,
1423                   ulong_Ff = 100
1424                 }
1425
1426                 enum EnumOverlap
1427                 {
1428                         Unknown = 0,
1429                         First = 0,
1430                         System_Math = First,
1431                 }
1432         }
1433 }