using System;

using System.Globalization;

using System.Collections.Generic;

using System.Diagnostics;

using System.Linq;

using System.Threading;

using Microsoft.VisualStudio.TestTools.UnitTesting;

public class Program

{

    /// <summary>Custom parsers that afford greater performance and/or greater flexibility

    /// than standard parsers.</summary>

    public static class Parsers

    {

        private static readonly CultureInfo CurrentCulture = CultureInfo.CurrentCulture;

        private static readonly NumberFormatInfo NumberFormat = CurrentCulture.NumberFormat;

        private static readonly char CharNegative = NumberFormat.NegativeSign[0];

​

        /// <summary>High performance integer parser with rudimentary flexibility.

        /// Supports negative numbers, but no whitespace or other non-digit characters.</summary>

        public static unsafe bool FastTryParseInt(string input, out int result)

        {

            fixed (char* cString = input)

            {

                unchecked // Allows faster integer math by not testing for overflows

                {

                    char* nextChar = cString;

                    bool isNegative = false;

                    // Handle a possible negative sign at the beginning of the string.

                    if (*nextChar == CharNegative)

                    {

                        isNegative = true;

                        nextChar++;

                    }

                    // Now process each character of the string

                    result = 0;

                    while (*nextChar >= '0' && *nextChar <= '9')

                        result = result * 10 + (*nextChar++ - '0');

                    // If the non-numeric character encountered to end the while loop

                    // wasn't the null terminator, the string is invalid.

                    if (*nextChar != Char.MinValue) return false;

​

                    // We need to check for an integer overflow based on the length of the string

                    long ptrLen = nextChar - cString;

                    // Result and overflow logic is different if there was a minus sign.

                    if (isNegative)

                    {

                        result = -result;

                        // Less than 11 characters (including negative) is no risk of overflow

                        // Longest possible negative int is 11 chars (-2147483648)

                        // If exactly 11 characters, we know our negative integer overflowed

                        // if the final result is greater than zero, otherwise it's fine.

                        return ptrLen < 11L || ptrLen <= 11L && result <= 0;

                    }

                    // Otherwise, overflow logic is the same, but opposite, and one fewer

                    // characters is allowed (because there was no minus sign)

                    return ptrLen < 10L || ptrLen <= 10L && result >= 0;

                }

            }

        }

        #region Test Parsers

        #region Parser Test Helpers

        private delegate void ParserTestFunction<in T>(string value, T parsedResult);

        private delegate void EqualityAsserter<in T>(T expected, T actual, string message);

​

        /// <summary>Construct a test function that will assert that a string can be

        /// parsed by our test parser and matches the expected value.</summary>

        private ParserTestFunction<T> ParserTestSuccessFactory<T>(

            ParserFunction<T>.Custom fastParse,

            ParserFunction<T>.Custom parserWrapper,

            ParserTestFunction<T> compareToNativeParser,

            EqualityAsserter<T> equalityTest) =>

            (value, expected) =>

            {

                Assert.IsTrue(fastParse(value, out T result),

                    $"Expected Custom Parser to be able to handle the input \"{value}\"");

                equalityTest(expected, result,

                    $"The input string \"{value}\" was not parsed correctly.");

                compareToNativeParser(value, result);

​

                // We can also assert that the *exact* same result is achieved by calling

                // the custom parser's wrapper, which should be calling the fast parser directly.

                Assert.IsTrue(parserWrapper(value, out T result2));

                Assert.AreEqual(result2, result, "Expected identical outputs " +

                    $"from both signatures when parsing the string \"{value}\".");

            };

​

        /// <summary>Construct a test function that will assert that a string cannot

        /// be parsed by our custom "fast parser", but that the more flexible wrapper

        /// parser is capable of falling back to another (slower) parse method that

        /// can handle the input.</summary>

        private ParserTestFunction<T> ParserTestFallbackFactory<T>(

            ParserFunction<T>.Custom fastParse,

            ParserFunction<T>.Custom parserWrapper,

            ParserTestFunction<T> compareToNativeParser,

            EqualityAsserter<T> equalityTest) =>

            (value, expected) =>

            {

                Assert.IsFalse(fastParse(value, out T result),

                    $"Expected The fast custom parser to be unable to handle the input \"{value}\"");

                Assert.IsTrue(parserWrapper(value, out result),

                    $"Expected the custom parser wrapper to be able to handle the input \"{value}\"");

                equalityTest(expected, result, "Parsed result was not as expected.");

                compareToNativeParser(value, result);

            };

​

        /// <summary>Construct a test function that will assert that a string cannot

        /// be parsed by our custom "fast parser", but that the more flexible wrapper

        /// parser is capable of falling back to another (slower) parse method that

        /// can handle the input.</summary>

        private Action<string> ParserTestUnparsableFactory<T>(ParserFunction<T>.Custom fastParse,

            ParserFunction<T>.Custom parserWrapper) => value =>

        {

            Assert.IsFalse(fastParse(value, out T result),

                $"Expected the fast custom parser to be unable to handle the input \"{value}\". " +

                $"Instead, it parsed the result as {result:G17}");

            Assert.IsFalse(parserWrapper(value, out result),

                $"Expected the custom parser wrapper to be unable to handle the input \"{value}\". " +

                $"Instead, it parsed the result as {result:G17}");

        };

        #endregion Parser Test Helper Delegates

​

        [TestMethod, TestCategory(TestCategory)]

        public void Test_Utilities_Parsers_ParseInt()

        {

            // We should assert that any result is identical to if we had used the native parser

            void CompareToNativeParser(string value, int parsedResult)

            {

                if (!Int32.TryParse(value, NumberStyles.Currency | NumberStyles.AllowExponent,

                    CultureInfo.CurrentCulture, out int nativeResult))

                    Console.WriteLine($"Note: Native parser cannot parse the string \"{value}\".");

                else

                    Assert.AreEqual(nativeResult, parsedResult, "Expected output to be identical " +

                        $"to the native parser when parsing the string \"{value}\".");

            }

​

            // Assert that various simple int representations can be parsed successfully

            // using our custom `FastTryParseInt` method.

            ParserTestFunction<int> TestSuccess = ParserTestSuccessFactory<int>(

                Parsers.FastTryParseInt, Parsers.TryParseInt, CompareToNativeParser, Assert.AreEqual);

​

            TestSuccess("0", 0);

            TestSuccess("1", 1);

            TestSuccess("-1", -1);

            TestSuccess("123456789", 123456789);

            TestSuccess("-123456789", -123456789);

            TestSuccess("000012345", 12345);

            TestSuccess("-000012345", -12345);

            TestSuccess("123450000", 123450000);

            TestSuccess("-123450000", -123450000);

            // More than 9 digits of precision/magnitude,

            // since these might have to be checked for overflow

            TestSuccess("1000000000", 1000000000);

            TestSuccess("-1000000000", -1000000000);

            // Min and max value

            TestSuccess("2147483647", 2147483647);

            TestSuccess("-2147483648", -2147483648);

            // Special case, an empty dash is interpreted as negative zero (natively not parsable)

            TestSuccess("-", 0);

​

            // Assert that more complex int representations cannot be parsed by the fast parser,

            // but that the primary parsing method will fall back to the advanced parsing algorithm.

            ParserTestFunction<int> TestFallback = ParserTestFallbackFactory<int>(

                Parsers.FastTryParseInt, Parsers.TryParseInt, CompareToNativeParser, Assert.AreEqual);

​

            // Several formats will not be supported by the FastParse function, but the

            // fallback method used should support these:

            // Exponential notation

            TestFallback("1.2345678e7", 12345678);

            TestFallback("-1.2345678e7", -12345678);

            // Thousand separators

            TestFallback("1,234,567,890", 1234567890);

            TestFallback("-1,234,567,890", -1234567890);

            // Special keywords (these are coerced from double)

            TestFallback("Unlimited", Int32.MaxValue);

            TestFallback("∞", Int32.MaxValue);

            TestFallback("-∞", Int32.MinValue);

            // Currency symbols

            TestFallback("$123", 123);

            TestFallback("123$", 123);

            TestFallback("£123", 123);

            TestFallback("€123", 123);

            TestFallback("¥123", 123);

            TestFallback("₱123", 123);

            // No fast support for whitespace

            TestFallback("$ 123", 123);

            TestFallback("123 $", 123);

            TestFallback(" 1234", 1234);

            TestFallback("1234 ", 1234);

            TestFallback(" 1234 ", 1234);

            TestFallback(" -1234", -1234);

            TestFallback("- 1234", -1234);

​

            // Assert that invalid strings return false (cannot be parsed) rather than

            // incorrectly returning true and some invalid result.

            Action<string> TestUnparsable = ParserTestUnparsableFactory<int>(

                Parsers.FastTryParseInt, Parsers.TryParseInt);

​

            // Numbers beyond the limits of integers

            TestUnparsable("2147483648");

            TestUnparsable("-2147483649");

            TestUnparsable("4294967296"); // 2x Int.MaxValue = 0 with Overflow

            TestUnparsable("-4294967296");

            TestUnparsable("9999999999");

            TestUnparsable("-9999999999");

            TestUnparsable("10000000000");

            TestUnparsable("-10000000000");

            TestUnparsable("1000000000000000000000000000000");

            TestUnparsable("-1000000000000000000000000000000");

            // Strings with invalid characters

            TestUnparsable("NaN");

            TestUnparsable(@"~");

            TestUnparsable(@"abc");

            TestUnparsable(@"1234a");

            TestUnparsable(@"123.456.789");

            TestUnparsable(@"12 % 89");

            TestUnparsable(@"--123");

            TestUnparsable(@"-123-");

            TestUnparsable("-0.00000000000000000123456789~");

        }

​

        [TestMethod, TestCategory(TestCategory)]

        public void Test_Utilities_Parsers_FastParseInt_Performance()

        {

            // Test parsing integer strings with values between 0 and a billion

            const int testRange = 1000000000;

            Random random = new Random();

            PerformanceTestHelper<int>(() => random.Next(0, testRange).ToString(),

                Int32.TryParse, Parsers.FastTryParseInt, NumberStyles.AllowLeadingSign);

        }

​

        /// <summary>Defines delegates for parsers for a type T.</summary>

        private static class ParserFunction<T>

        {

            public delegate bool Native(string value, NumberStyles style, CultureInfo info, out T result);

            public delegate bool Custom(string value, out T result);

        }

​

        /// <summary>Assert that our custom parser implementation is significantly faster

        /// than the native Double.TryParse implementation.</summary>

        private void PerformanceTestHelper<T>(Func<string> generateRandomInput,

            ParserFunction<T>.Native nativeParse, ParserFunction<T>.Custom customParse,

            NumberStyles nativeNumberStyles)

        {

            // Native parsers are not very efficient. Ours are 3 to 7 times faster in release mode

            // (debug mode adds a lot of overhead though)

            // Require at least a 100% speedup when in release mode, or 25% speedup in debug mode,

            // for the custom implementation to be considered successful

#if DEBUG

            const double requiredGain = 0.25;

#else

            const double requiredGain = 1d;

#endif

            const int uniqueValues = 1000000;

            const int iterations = 100;

​

            // Ensure any one-time initialization by both parsers is done in advance:

            Stopwatch timer = Stopwatch.StartNew();

            CultureInfo cachedCulture = CultureInfo.CurrentCulture;

            nativeParse(generateRandomInput(), nativeNumberStyles, cachedCulture, out T _);

            customParse(generateRandomInput(), out T _);

            Console.WriteLine($"Took {timer.ElapsedMilliseconds} ms to initialize parsers.");

​

            timer.Restart();

            string[] randomIntegers = Enumerable.Repeat(0, uniqueValues)

                .Select(i => generateRandomInput()).ToArray();

            Console.WriteLine($"Took {timer.ElapsedMilliseconds} ms to generate random strings.");

​

            // Test Native Parsing Method

            timer.Restart();

            foreach (int _ in Enumerable.Repeat(0, iterations))

                foreach (string value in randomIntegers)

                    if (!nativeParse(value, nativeNumberStyles, cachedCulture, out T _))

                        Assert.Fail($"Native parser failed to parse the string {value}");

            double nativeElapsed = timer.ElapsedMilliseconds;

            Console.WriteLine($"Native parser took {nativeElapsed} ms.");

​

            // Test FastTryParse

            timer.Restart();

            foreach (int _ in Enumerable.Repeat(0, iterations))

                foreach (string value in randomIntegers)

                    if (!customParse(value, out T _))

                        Assert.Fail($"Custom parser failed to parse the string {value}");

            double customElapsed = timer.ElapsedMilliseconds;

            Console.WriteLine($"Custom parser took {customElapsed} ms.");

​

            double perfGain = nativeElapsed / customElapsed - 1;

            Console.WriteLine($"Performance gain was {perfGain:P2}");

            if (perfGain < requiredGain)

            {

                string message = $"Expected a {requiredGain:P2} improvement in parsing performance " +

                    $"or better by using a custom parser, but the performance difference was {perfGain:P2}.";

                // If we don't meet the required performance gain while test are being run,

                // raise a warning so that the test conditions can be reviewed. We shouldn't

                // just fail CI test machines can be quite noisy and prone to random slowdowns.

                Assert.Inconclusive(message);

            }

        }

        #endregion Test Parsers

    }

}