Output.cs

Go to the documentation of this file.

using System;
using System.Collections;
using System.Globalization;
using System.Linq;
 
using AnalyzeRe;
using AnalyzeRe.Utilities;
 
namespace AnalyzeReTesting.Utilities
{
    public static class Output
    {
        #region Functions
        public static string AutoFormat(object obj)
        {
            if (obj == null)
                return "(null)";
            if (obj is string s)
                return $"\"{s}\"";
            if (obj is double d)
                return DoubleConverter.ToExactString(d);
            if (obj is int i)
                return i.ToString("#,##0");
            if (obj is DateTime dt)
                return dt.ToString("O");
            if (obj is Type t)
                return t.NiceTypeName();
            if (obj is IEnumerable items)
                return "{" + String.Join(",", items.Cast<object>().Select(AutoFormat)) + "}";
            if (obj is IReference<IAPIResource> reference && reference.ref_id != null)
                return reference.ToString();
            if (obj is IAPIType apiObject)
                return $"{apiObject} (JSON:{apiObject.Serialize()})";
            return obj.ToString();
        }
 
        public static string RandomString(int minLength, int maxLength, Random randomGenerator = null)
        {
            // TODO: No longer have to trim strings
            // UntilRelease.Unscheduled();
            // The server will currently trim white space around strings, causing
            // equivalency tests to fail. The workaround is just to not supply any strings
            // that start or end in white space, but this might violate the above
            // minLength, maxLength constraints, so retry if that's the case.
            // We use only allowed set of characters
            // https://stackoverflow.com/questions/1344221/how-can-i-generate-random-alphanumeric-strings
            string random;
            const string allowedChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ,.";
            randomGenerator = randomGenerator ?? new Random();
            do
            {
                int randomLength = randomGenerator.Next(minLength, maxLength + 1);
                random = new string(Enumerable.Repeat(allowedChars, randomLength)
                        .Select(s => s[randomGenerator.Next(s.Length)]).ToArray()).Trim();
            } while (random.Length < minLength);
            return random;
        }
        #endregion Functions
 
        #region DoubleConverter
        public static class DoubleConverter
        {
            public static string ToExactString(double d)
            {
                if (Double.IsPositiveInfinity(d))
                    return "+Infinity";
                if (Double.IsNegativeInfinity(d))
                    return "-Infinity";
                if (Double.IsNaN(d))
                    return "NaN";
 
                // Translate the double into sign, exponent and mantissa.
                long bits = BitConverter.DoubleToInt64Bits(d);
                // Note that the shift is sign-extended, hence the test against -1 not 1
                bool negative = (bits < 0);
                int exponent = (int)((bits >> 52) & 0x7ffL);
                long mantissa = bits & 0xfffffffffffffL;
 
                // Subnormal numbers; exponent is effectively one higher,
                // but there's no extra normalization bit in the mantissa
                if (exponent == 0)
                {
                    exponent++;
                }
                // Normal numbers; leave exponent as it is but add extra
                // bit to the front of the mantissa
                else
                {
                    mantissa = mantissa | (1L << 52);
                }
 
                // Bias the exponent. It's actually biased by 1023, but we're
                // treating the mantissa as m.0 rather than 0.m, so we need
                // to subtract another 52 from it.
                exponent -= 1075;
 
                if (mantissa == 0)
                {
                    return "0";
                }
 
                /* Normalize */
                while ((mantissa & 1) == 0)
                {    /*  i.e., Mantissa is even */
                    mantissa >>= 1;
                    exponent++;
                }
 
                // Construct a new decimal expansion with the mantissa
                ArbitraryDecimal ad = new ArbitraryDecimal(mantissa);
 
                // If the exponent is less than 0, we need to repeatedly
                // divide by 2 - which is the equivalent of multiplying
                // by 5 and dividing by 10.
                if (exponent < 0)
                {
                    for (int i = 0; i < -exponent; i++)
                        ad.MultiplyBy(5);
                    ad.Shift(-exponent);
                }
                // Otherwise, we need to repeatedly multiply by 2
                else
                {
                    for (int i = 0; i < exponent; i++)
                        ad.MultiplyBy(2);
                }
 
                // Finally, return the string with an appropriate sign
                if (negative)
                    return "-" + ad.ToString();
                else
                    return ad.ToString();
            }
 
            private class ArbitraryDecimal
            {
                private byte[] _digits;
                private int _decimalPoint = 0;
 
                internal ArbitraryDecimal(long x)
                {
                    string tmp = x.ToString(CultureInfo.InvariantCulture);
                    _digits = new byte[tmp.Length];
                    for (int i = 0; i < tmp.Length; i++)
                        _digits[i] = (byte)(tmp[i] - '0');
                    Normalize();
                }
 
                internal void MultiplyBy(int amount)
                {
                    byte[] result = new byte[_digits.Length + 1];
                    for (int i = _digits.Length - 1; i >= 0; i--)
                    {
                        int resultDigit = _digits[i] * amount + result[i + 1];
                        result[i] = (byte)(resultDigit / 10);
                        result[i + 1] = (byte)(resultDigit % 10);
                    }
                    if (result[0] != 0)
                    {
                        _digits = result;
                    }
                    else
                    {
                        Array.Copy(result, 1, _digits, 0, _digits.Length);
                    }
                    Normalize();
                }
 
                internal void Shift(int amount)
                {
                    _decimalPoint += amount;
                }
 
                private void Normalize()
                {
                    int first;
                    for (first = 0; first < _digits.Length; first++)
                        if (_digits[first] != 0)
                            break;
                    int last;
                    for (last = _digits.Length - 1; last >= 0; last--)
                        if (_digits[last] != 0)
                            break;
 
                    if (first == 0 && last == _digits.Length - 1)
                        return;
 
                    byte[] tmp = new byte[last - first + 1];
                    for (int i = 0; i < tmp.Length; i++)
                        tmp[i] = _digits[i + first];
 
                    _decimalPoint -= _digits.Length - (last + 1);
                    _digits = tmp;
                }
 
                public override string ToString()
                {
                    char[] digitString = new char[_digits.Length];
                    for (int i = 0; i < _digits.Length; i++)
                        digitString[i] = (char)(_digits[i] + '0');
 
                    // Simplest case - nothing after the decimal point,
                    // and last real digit is non-zero, e.g. value=35
                    if (_decimalPoint == 0)
                    {
                        return new string(digitString);
                    }
 
                    // Fairly simple case - nothing after the decimal
                    // point, but some 0s to add, e.g. value=350
                    if (_decimalPoint < 0)
                    {
                        return new string(digitString) +
                               new string('0', -_decimalPoint);
                    }
 
                    // Nothing before the decimal point, e.g. 0.035
                    if (_decimalPoint >= digitString.Length)
                    {
                        return "0." +
                            new string('0', (_decimalPoint - digitString.Length)) +
                            new string(digitString);
                    }
 
                    // Most complicated case - part of the string comes
                    // before the decimal point, part comes after it,
                    // e.g. 3.5
                    return new string(digitString, 0,
                                       digitString.Length - _decimalPoint) +
                        "." +
                        new string(digitString,
                                    digitString.Length - _decimalPoint,
                                    _decimalPoint);
                }
            }
        }
        #endregion DoubleConverter
    }
}