Enum.TryParse test

gistfile1.cs

//This test has dependency on "PeculiarEnum" and "CharEnum" types that look like:
//.class public auto ansi sealed BoolEnumTest.PeculiarEnum extends [mscorlib]System.Enum
//{
//  .field public specialname rtspecialname bool value__
//  .field public static literal valuetype BoolEnumTest.PeculiarEnum A = bool(false)
//  .field public static literal valuetype BoolEnumTest.PeculiarEnum B = bool(true)
//}
//
//.class public auto ansi sealed BoolEnumTest.CharEnum extends [mscorlib]System.Enum
//{
//  .field public specialname rtspecialname bool value__
//  .field public static literal valuetype BoolEnumTest.CharEnum A = char(48)
//  .field public static literal valuetype BoolEnumTest.CharEnum Zero = char(0)
//}
//
//.class public auto ansi sealed BoolEnumTest.UberTricky extends [mscorlib]System.Enum
//{
//  .field public specialname rtspecialname float64 value__
//  .field public static literal valuetype BoolEnumTest.UberTricky '0' = float64(1)
//  .field public static literal valuetype BoolEnumTest.UberTricky '1' = float64(0)
//}
//Or simply download library from my dropbox: https://dl.dropboxusercontent.com/u/13759233/Work/BoolEnumTest.dll

using System;
using BoolEnumTest;

namespace EnumPerfTest
{

    public enum EasyEnum : sbyte
    {
        Value1 = 1, Value2 = 2, NegativeValue = -100
    }

    public enum LongEnum : long
    {
        ValueMin = long.MinValue, ValueMax = long.MaxValue
    }

    public enum ULongEnum : ulong
    {
        ValueMin = ulong.MinValue, ValueMax = ulong.MaxValue
    }

    public class Program
    {
        static void Main(string[] args)
        {
            RunTests();
            RunPerfTest();
        }

        private static void RunTests()
        {
            //Case 1: string that is in enum
            EasyEnum value;
            Enum.TryParse("Value1", out value);
            if (value != EasyEnum.Value1)
            {
                Console.WriteLine("Case 1 failed");
            }
            //Case 2: integer that is in enum
            Enum.TryParse("1", out value);
            if (value != EasyEnum.Value1)
            {
                Console.WriteLine("Case 2 failed");
            }
            //Case 3: integer that is in enum, with plus sign
            Enum.TryParse("+2", out value);
            if (value != EasyEnum.Value2)
            {
                Console.WriteLine("Case 3 failed");
            }
            //Case 4: negative integer that is in enum
            Enum.TryParse("-100", out value);
            if (value != EasyEnum.NegativeValue)
            {
                Console.WriteLine("Case 4 failed");
            }
            //Case 5: integer with space after it
            Enum.TryParse("2 ", out value);
            if (value != EasyEnum.Value2)
            {
                Console.WriteLine("Case 5 failed");
            }

            //Case 6: integer with spaces on both sides
            Enum.TryParse(" 2 ", out value);
            if (value != EasyEnum.Value2)
            {
                Console.WriteLine("Case 6 failed");
            }

            //Case 7: long max
            LongEnum longEnum;
            Enum.TryParse(long.MaxValue.ToString(), out longEnum);
            if (longEnum != LongEnum.ValueMax)
            {
                Console.WriteLine("Case 7 failed");
            }

            //Case 8: long min
            Enum.TryParse(long.MinValue.ToString(), out longEnum);
            if (longEnum != LongEnum.ValueMin)
            {
                Console.WriteLine("Case 8 failed");
            }

            //Case 9: ulong max
            ULongEnum ulongEnum;
            Enum.TryParse(ulong.MaxValue.ToString(), out ulongEnum);
            if (ulongEnum != ULongEnum.ValueMax)
            {
                Console.WriteLine("Case 9 failed");
            }

            //Case 10: ulong min
            Enum.TryParse(ulong.MinValue.ToString(), out ulongEnum);
            if (ulongEnum != ULongEnum.ValueMin)
            {
                Console.WriteLine("Case 10 failed");
            }

            //Case 11: bad string
            if (Enum.TryParse("abcdef", out value))
            {
                Console.WriteLine("Case 11 failed");
            }

            //Case 12: bad integer
            Enum.TryParse("11", out value);
            if ((sbyte)value != 11)
            {
                Console.WriteLine("Case 12 failed");
            }

            //Case 13: bad integer with overflow
            if (Enum.TryParse("123456789", out value))
            {
                Console.WriteLine("Case 13 failed");
            }

            //Case 14: PeculiarEnum numeric
            PeculiarEnum peculiar;
            if (Enum.TryParse("0", out peculiar))
            {
                Console.WriteLine("Case 14 failed");
            }

            //Case 15: PeculiarEnum string
            if (Enum.TryParse("true", out peculiar))
            {
                Console.WriteLine("Case 15 failed");
            }

            //Case 16: PeculiarEnum good parse
            if (!Enum.TryParse("A", out peculiar))
            {
                Console.WriteLine("Case 16 failed");
            }

            //Case 17: CharEnum Zero
            CharEnum charEnum;
            Enum.TryParse("0", out charEnum);
            var expected = (CharEnum)Enum.ToObject(typeof(CharEnum), '0');
            if (!charEnum.Equals(expected))
            {
                Console.WriteLine("Case 17 failed");
            }

            //Case 18: Some mad enums
            UberTricky uber;
            bool hadException = false;
            try
            {
                uber = (UberTricky)Enum.Parse(typeof(UberTricky), "0");
            }
            catch (ArgumentException)
            {
                hadException = true;
            }
            if (!hadException)
            {
                Console.WriteLine("Case 18 failed");
            }

            Console.WriteLine("Functional test done");
        }

        private static void RunPerfTest()
        {
            const int numrepetitions = 1000000;
            EasyEnum value;
            //Warm-up
            Enum.TryParse("1Value1", out value);
            Enum.TryParse("Value1", out value);
            GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced, true);

            var start = DateTime.UtcNow;
            for (int i = 0; i < numrepetitions; i++)
            {
                Enum.TryParse("Value1", out value);
            }
            Console.WriteLine("Good run: {0}ms", (DateTime.UtcNow - start).TotalMilliseconds);

            GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced, true);

            start = DateTime.UtcNow;
            for (int i = 0; i < numrepetitions; i++)
            {
                Enum.TryParse("1Value1", out value);
            }
            Console.WriteLine("Bad run: {0}ms", (DateTime.UtcNow - start).TotalMilliseconds);

            GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced, true);

            start = DateTime.UtcNow;
            for (int i = 0; i < numrepetitions; i++)
            {
                Enum.TryParse("123456789", out value);
            }
            Console.WriteLine("Big numbers run: {0}ms", (DateTime.UtcNow - start).TotalMilliseconds);

            GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced, true);

            start = DateTime.UtcNow;
            for (int i = 0; i < numrepetitions; i++)
            {
                Enum.TryParse("123", out value);
            }
            Console.WriteLine("Small numbers run: {0}ms", (DateTime.UtcNow - start).TotalMilliseconds);

            GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced, true);

            start = DateTime.UtcNow;
            for (int i = 0; i < numrepetitions; i++)
            {
                Enum.TryParse("abcdefgh", out value);
            }
            Console.WriteLine("All letters run: {0}ms", (DateTime.UtcNow - start).TotalMilliseconds);
        }
    }
}