using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading.Tasks;

namespace Azimuth.UnitTests
{
    public class Vector4Tests : UnitTestSharp.TestFixture
    {
        public class ComponentAccess : UnitTestSharp.TestFixture
        {
            Vector4 vector = new Vector4(1, 2, 3, 4);

            public void GetX()
            {
                CheckEqual(1, vector.X);
            }

            public void GetY()
            {
                CheckEqual(2, vector.Y);
            }

            public void GetZ()
            {
                CheckEqual(3, vector.Z);
            }

            public void GetW()
            {                
                CheckEqual(4, vector.W);
            }

            public void SetX()
            {
                vector.X = 7;
                CheckEqual(7, vector.X);
            }

            public void SetY()
            {
                vector.Y = 7;
                CheckEqual(7, vector.Y);
            }

            public void SetZ()
            {
                vector.Z = 7;
                CheckEqual(7, vector.Z);
            }

            public void SetW()
            {
                vector.W = 7;
                CheckEqual(7, vector.W);
            }
        }

        public class IndexerAccess : UnitTestSharp.TestFixture
        {
            Vector4 vector = new Vector4(1, 2, 3, 4);

            public void GetIndex0()
            {
                CheckEqual(1, vector[0]);
            }

            public void GetIndex1()
            {
                CheckEqual(2, vector[1]);
            }

            public void GetIndex2()
            {
                CheckEqual(3, vector[2]);
            }

            public void GetIndex3()
            {
                CheckEqual(4, vector[3]);
            }

            public void SetIndex0()
            {
                vector[0] = 7;
                CheckEqual(7, vector[0]);
            }

            public void SetIndex1()
            {
                vector[1] = 7;
                CheckEqual(7, vector[1]);
            }

            public void SetIndex2()
            {
                vector[2] = 7;
                CheckEqual(7, vector[2]);
            }

            public void SetIndex3()
            {
                vector[3] = 7;
                CheckEqual(7, vector[3]);
            }
        }

        public class DotProduct : UnitTestSharp.TestFixture
        {
            public void Basic()
            {
                var x = new Vector4(2, 3, 4, 5);
                var y = new Vector4(6, 7, 9, 8);

                CheckEqual(12 + 21 + 36 + 40, x.DotProduct(y));
                CheckEqual(12 + 21 + 36 + 40, y.DotProduct(x));
            }

            public void InnerProduct()
            {
                var x = new Vector4(2, 3, 4, 5);
                var y = new Vector4(6, 7, 9, 8);

                CheckEqual(12 + 21 + 36 + 40, x.InnerProduct(y));
                CheckEqual(12 + 21 + 36 + 40, y.InnerProduct(x));
            }
        }

        public class LengthSquared : UnitTestSharp.TestFixture
        {
            public void Zero()
            {
                CheckEqual(0, Vector4.Zero.LengthSquared());
            }

            public void Basic()
            {
                var x = new Vector4(2, 3, 4, 5);
                CheckEqual(4 + 9 + 16 + 25, x.LengthSquared());
            }
        }

        public class Length : UnitTestSharp.TestFixture
        {
            public void Zero()
            {
                CheckEqual(0, Vector4.Zero.Length());
            }

            public void Basic()
            {
                var x = new Vector4(2, 3, 4, 5);
                CheckEqual(Math.Sqrt(54), x.Length());
            }
        }

        public class DistanceSquared : UnitTestSharp.TestFixture
        {
            public void Zero()
            {
                var x = new Vector4(1, 2, 3, 4);
                CheckEqual(0, Vector4.DistanceSquared(x, x));
            }

            public void Basic()
            {
                var x = new Vector4(1, 2, 3, 4);
                var y = new Vector4(2, 1, 4, 7);
                CheckEqual(12, Vector4.DistanceSquared(x, y));
            }
        }

        public class Distance : UnitTestSharp.TestFixture
        {
            public void Zero()
            {
                var x = new Vector4(1, 2, 3, 4);
                CheckEqual(0, Vector4.Distance(x, x));
            }

            public void Basic()
            {
                var x = new Vector4(1, 2, 3, 4);
                var y = new Vector4(2, 1, 4, 7);
                CheckEqual(Math.Sqrt(12), Vector4.Distance(x, y));
            }
        }

        public class EqualsTests : UnitTestSharp.TestFixture
        {
            public void True()
            {
                var x = new Vector4(1, 2, 3, 4);
                var y = new Vector4(1, 2, 3, 4);
                CheckTrue(x.Equals(y));
                CheckTrue(y.Equals(x));
            }

            public void UnequalX()
            {
                var x = new Vector4(1, 2, 3, 4);
                var y = new Vector4(0, 2, 3, 4);
                CheckFalse(x.Equals(y));
                CheckFalse(y.Equals(x));
            }

            public void UnequalY()
            {
                var x = new Vector4(1, 2, 3, 4);
                var y = new Vector4(1, 1, 3, 4);
                CheckFalse(x.Equals(y));
                CheckFalse(y.Equals(x));
            }

            public void UnequalZ()
            {
                var x = new Vector4(1, 2, 3, 4);
                var y = new Vector4(1, 2, 1, 4);
                CheckFalse(x.Equals(y));
                CheckFalse(y.Equals(x));
            }

            public void UnequalW()
            {
                var x = new Vector4(1, 2, 1, 3);
                var y = new Vector4(1, 2, 1, 4);
                CheckFalse(x.Equals(y));
                CheckFalse(y.Equals(x));
            }
        }

        public class Operators : UnitTestSharp.TestFixture
        {
            public void Negate()
            {
                var x = new Vector4(1, 2, 3, 4);
                var y = -x;
                var expected = new Vector4(-1, -2, -3, -4);

                CheckEqual(expected, y);
            }

            public void PostMultiply()
            {
                var x = new Vector4(1, 2, 3, 4);
                var y = x * -3;
                var expected = new Vector4(-3, -6, -9, -12);

                CheckEqual(expected, y);
            }

            public void PreMultiply()
            {
                var x = new Vector4(1, 2, 3, 4);
                var y = -3 * x;
                var expected = new Vector4(-3, -6, -9, -12);

                CheckEqual(expected, y);
            }

            public void Add()
            {
                var x = new Vector4(1, 2, 3, 4);
                var y = new Vector4(1, 3, 2, 0);
                var expected = new Vector4(2, 5, 5, 4);

                CheckEqual(expected, x + y);
                CheckEqual(expected, y + x);
            }

            public void Subtract()
            {
                var x = new Vector4(1, 2, 3, 4);
                var y = new Vector4(1, 3, 2, 0);
                var expected = new Vector4(0, -1, 1, 4);

                CheckEqual(expected, x - y);
                CheckEqual(-expected, y - x);
            }

            public void DivideByScalar()
            {
                var x = new Vector4(1, 2, 3, 4);
                var expected = new Vector4(-0.5, -1, -1.5, -4.0/3.0);

                CheckEqual(expected, x / -2);
            }

            public void DivideScalar()
            {
                var x = new Vector4(1, 2, 3, 4);
                var expected = new Vector4(-2, -1, -2.0/3, -2.0);

                CheckEqual(expected, -2 / x);
            }
        }

        public class IVectorSpaceTests : UnitTestSharp.TestFixture
        {
            public void AddAssignment()
            {
                Vector4 vector = new Vector4(1, 2, 3, 4);
                IVectorSpace<Vector4> space = vector;
                Vector4 returnValue = space.AddAssignment(new Vector4(4, 3, 2, 1));
                Vector4 expected = new Vector4(5, 5, 5, 5);
                CheckEqual(expected, space);
                CheckEqual(expected, returnValue);
            }

            public void SubtractAssignment()
            {
                Vector4 vector = new Vector4(1, 2, 3, 4);
                IVectorSpace<Vector4> space = vector;
                Vector4 returnValue = space.SubtractAssignment(new Vector4(4, 3, 2, 1));
                Vector4 expected = new Vector4(-3, -1, 1, 3);
                CheckEqual(expected, space);
                CheckEqual(expected, returnValue);
            }

            public void ScaleAssignment()
            {
                Vector4 vector = new Vector4(1, 2, 3, 4);
                IVectorSpace<Vector4> space = vector;
                Vector4 returnValue = space.ScaleAssignment(-2);
                Vector4 expected = new Vector4(-2, -4, -6, -8);
                CheckEqual(expected, space);
                CheckEqual(expected, returnValue);
            }

            public void ScaleThenAddAssignment()
            {
                Vector4 vector = new Vector4(1, 2, 3, 4);
                IVectorSpace<Vector4> space = vector;
                Vector4 returnValue = space.ScaleThenAddAssignment(-2, new Vector4(-2, -4, -6, -8));
                Vector4 expected = new Vector4(5, 10, 15, 20);
                CheckEqual(expected, space);
                CheckEqual(expected, returnValue);
            }

            public void Clone()
            {
                Vector4 vector = new Vector4(1, 2, 3, 4);
                IVectorSpace<Vector4> space = vector;
                Vector4 returnValue = space.Clone();
                returnValue[1] = 7;
                Vector4 expectedOriginal = new Vector4(1, 2, 3, 4);
                Vector4 expectedClone = new Vector4(1, 7, 3, 4);

                CheckEqual(expectedOriginal, space);
                CheckEqual(expectedClone, returnValue);
            }
        }

        public class Normalize : UnitTestSharp.TestFixture
        {
            public void Basic()
            {
                var x = new Vector4(1, 2, 3, 4);
                x.Normalize();
                var expected = new Vector4(1, 2, 3, 4) / Math.Sqrt(30);
                CheckEqual(expected, x);
            }

            public void NormalizedCopy()
            {
                var x = new Vector4(1, 2, 3, 4);
                Vector4 copy = x.NormalizedCopy();
                var expected = new Vector4(1, 2, 3, 4);
                var expectedCopy = new Vector4(1, 2, 3, 4) / Math.Sqrt(30);
                CheckEqual(expected, x);
                CheckEqual(expectedCopy, copy);
            }
        }

        public class IsNaN : UnitTestSharp.TestFixture
        {
            public void NotNaN()
            {
                var x = new Vector4(1, 2, 3, 4);
                CheckFalse(Vector4.IsNaN(x));
            }

            public void NaN_X()
            {
                var x = new Vector4(Scalar.NaN, 2, 3, 4);
                Check(Vector4.IsNaN(x));
            }

            public void NaN_Y()
            {
                var x = new Vector4(1, Scalar.NaN, 3, 4);
                Check(Vector4.IsNaN(x));
            }

            public void NaN_Z()
            {
                var x = new Vector4(1, 2, Scalar.NaN, 4);
                Check(Vector4.IsNaN(x));
            }

            public void NaN_W()
            {
                var x = new Vector4(1, 2, 3, Scalar.NaN);
                Check(Vector4.IsNaN(x));
            }
        }

        public class CompareToTests : UnitTestSharp.TestFixture
        {
            public void CompletelyEqual()
            {
                var x = new Vector4(1, 2, 3, 4);
                var y = new Vector4(1, 2, 3, 4);

                CheckEqual(0, x.CompareTo(y));
                CheckEqual(0, y.CompareTo(x));
            }

            public void XGreater()
            {
                var x = new Vector4(2, 1, 1, 1);
                var y = new Vector4(1, 2, 3, 4);

                CheckEqual(1, x.CompareTo(y));
                CheckEqual(-1, y.CompareTo(x));
            }

            public void YGreater()
            {
                var x = new Vector4(1, 3, 1, 1);
                var y = new Vector4(1, 2, 3, 4);

                CheckEqual(1, x.CompareTo(y));
                CheckEqual(-1, y.CompareTo(x));
            }

            public void ZGreater()
            {
                var x = new Vector4(1, 2, 4, 1);
                var y = new Vector4(1, 2, 3, 4);

                CheckEqual(1, x.CompareTo(y));
                CheckEqual(-1, y.CompareTo(x));
            }

            public void WGreater()
            {
                var x = new Vector4(1, 2, 3, 5);
                var y = new Vector4(1, 2, 3, 4);

                CheckEqual(1, x.CompareTo(y));
                CheckEqual(-1, y.CompareTo(x));
            }
        }

        public class MinMaxTests : UnitTestSharp.TestFixture
        {
            public void InPlace()
            {
                var x = new Vector4(1, 2, 5, 4);
                var y = new Vector4(0, 3, -1, 10);

                x.MinMax(ref y);

                CheckEqual(new Vector4(0, 2, -1, 4), x);
                CheckEqual(new Vector4(1, 3, 5, 10), y);
            }

            public void Out()
            {
                var x = new Vector4(1, 2, 5, 4);
                var y = new Vector4(0, 3, -1, 10);

                Vector4 min, max;
                x.MinMax(y, out min, out max);

                CheckEqual(new Vector4(0, 2, -1, 4), min);
                CheckEqual(new Vector4(1, 3, 5, 10), max);
                CheckEqual(new Vector4(1, 2, 5, 4), x);
                CheckEqual(new Vector4(0, 3, -1, 10), y);
            }
        }

        public class ToStringTests : UnitTestSharp.TestFixture
        {
            public void Fractions()
            {
                var Vector4 = new Vector4(1.125, 5.321, 2.111, 3.123);

                CheckEqual("<1.125 : 5.321 : 2.111 : 3.123>", Vector4.ToString());
            }

            public void Basic()
            {
                var Vector4 = new Vector4(1, 5, 2, 3);

                CheckEqual("<1 : 5 : 2 : 3>", Vector4.ToString());
            }

            public void Infinity()
            {
                var Vector4 = new Vector4(
                    Scalar.PositiveInfinity, Scalar.PositiveInfinity,
                    Scalar.PositiveInfinity, Scalar.PositiveInfinity);

                CheckEqual("<Infinity : Infinity : Infinity : Infinity>", Vector4.ToString());
            }

            public void NegativeInfinity()
            {
                var Vector4 = new Vector4(
                    Scalar.NegativeInfinity, Scalar.NegativeInfinity,
                    Scalar.NegativeInfinity, Scalar.NegativeInfinity);

                CheckEqual("<-Infinity : -Infinity : -Infinity : -Infinity>", Vector4.ToString());
            }

            public void NaN()
            {
                var Vector4 = new Vector4(Scalar.NaN, Scalar.NaN, Scalar.NaN, Scalar.NaN);

                CheckEqual("<NaN : NaN : NaN : NaN>", Vector4.ToString());
            }

            public class FormatProviders : UnitTestSharp.TestFixture
            {
                private static NumberFormatInfo formatter =
                    System.Globalization.CultureInfo.GetCultureInfo("de-DE").NumberFormat;

                public void Basic()
                {
                    var Vector4 = new Vector4(1, 5, 2, 3);

                    CheckEqual("<1 : 5 : 2 : 3>", Vector4.ToString(formatter));
                }

                public void Fractions()
                {
                    var Vector4 = new Vector4(1.125, 5.321, 2.111, 3.123);

                    CheckEqual("<1,125 : 5,321 : 2,111 : 3,123>", Vector4.ToString(formatter));
                }

                public void Infinity()
                {
                    var Vector4 = new Vector4(
                        Scalar.PositiveInfinity, Scalar.PositiveInfinity,
                        Scalar.PositiveInfinity, Scalar.PositiveInfinity);

                    string symbol = formatter.PositiveInfinitySymbol;
                    CheckEqual($"<{symbol} : {symbol} : {symbol} : {symbol}>", Vector4.ToString(formatter));
                }

                public void NegativeInfinity()
                {
                    var Vector4 = new Vector4(
                        Scalar.NegativeInfinity, Scalar.NegativeInfinity,
                        Scalar.NegativeInfinity, Scalar.NegativeInfinity);

                    string symbol = formatter.NegativeInfinitySymbol;
                    CheckEqual($"<{symbol} : {symbol} : {symbol} : {symbol}>", Vector4.ToString(formatter));
                }

                public void NaN()
                {
                    var Vector4 = new Vector4(Scalar.NaN, Scalar.NaN, Scalar.NaN, Scalar.NaN);

                    string symbol = formatter.NaNSymbol;
                    CheckEqual($"<{symbol} : {symbol} : {symbol} : {symbol}>", Vector4.ToString(formatter));
                }
            }

            public class CustomFormatter : UnitTestSharp.TestFixture
            {
                public void Fractions()
                {
                    var Vector4 = new Vector4(1.125, 5.321, 2.2222, 3.123);

                    CheckEqual("<MOM 1.1 : MOM 5.3 : MOM 2.2 : MOM 3.1>", Vector4.ToString("MOM 0.#"));
                }

                public void Basic()
                {
                    var Vector4 = new Vector4(1, 5, 2, 3);

                    CheckEqual("<MOM 1 : MOM 5 : MOM 2 : MOM 3>", Vector4.ToString("MOM 0.#"));
                }

                public void Infinity()
                {
                    var Vector4 = new Vector4(
                        Scalar.PositiveInfinity, Scalar.PositiveInfinity,
                        Scalar.PositiveInfinity, Scalar.PositiveInfinity);

                    CheckEqual("<Infinity : Infinity : Infinity : Infinity>", Vector4.ToString("MOM 0.#"));
                }

                public void NegativeInfinity()
                {
                    var Vector4 = new Vector4(
                        Scalar.NegativeInfinity, Scalar.NegativeInfinity,
                        Scalar.NegativeInfinity, Scalar.NegativeInfinity);

                    CheckEqual("<-Infinity : -Infinity : -Infinity : -Infinity>", Vector4.ToString("MOM 0.#"));
                }

                public void NaN()
                {
                    var Vector4 = new Vector4(Scalar.NaN, Scalar.NaN, Scalar.NaN, Scalar.NaN);

                    CheckEqual("<NaN : NaN : NaN : NaN>", Vector4.ToString("MOM 0.#"));
                }
            }
        }

        public class Parse : UnitTestSharp.TestFixture
        {
            public void Basic()
            {
                var text = "<10.45 : 11.234 : 2.123 : 3.123>";
                var expected = new Vector4(10.45, 11.234, 2.123, 3.123);

                var actual = Vector4.Parse(text);

                CheckEqual(expected, actual);
            }

            public void NaN()
            {
                var text = "<NaN : NaN : NaN : NaN>";

                var actual = Vector4.Parse(text);

                Check(Scalar.IsNaN(actual.X));
                Check(Scalar.IsNaN(actual.Y));
                Check(Scalar.IsNaN(actual.Z));
                Check(Scalar.IsNaN(actual.W));
            }

            public void Infinity()
            {
                var text = "<Infinity : -Infinity : Infinity : -Infinity>";

                var actual = Vector4.Parse(text);

                Check(Scalar.IsInfinity(actual.X));
                Check(Scalar.IsNegativeInfinity(actual.Y));
                Check(Scalar.IsInfinity(actual.Z));
                Check(Scalar.IsNegativeInfinity(actual.W));
            }

            public void NotEnoughElements()
            {
                var text = "<Infinity : -Infinity : Infinity>";

                CheckThrow(typeof(Exception));
                Vector4.Parse(text);
            }

            public void TooManyElements()
            {
                var text = "<Infinity : -Infinity : Infinity : Infinity : Infinity>";

                CheckThrow(typeof(Exception));
                Vector4.Parse(text);
            }

            public void NotNumbers()
            {
                var text = "<A : 2 : 3 : 4>";

                CheckThrow(typeof(Exception));
                Vector4.Parse(text);
            }

            public class FormatProviders : UnitTestSharp.TestFixture
            {
                private static NumberFormatInfo formatter =
                    System.Globalization.CultureInfo.GetCultureInfo("de-DE").NumberFormat;

                public void Basic()
                {
                    var text = "<3000,23 : 7043,1 : 2,123 : 3,123>";
                    var expected = new Vector4(3000.23, 7043.1, 2.123, 3.123);

                    var actual = Vector4.Parse(text, formatter);

                    CheckEqual(expected, actual);
                }

                public void NaN()
                {
                    string symbol = formatter.NaNSymbol;
                    var text = $"<{symbol} : {symbol} : {symbol} : {symbol}>";

                    var actual = Vector4.Parse(text, formatter);

                    Check(Scalar.IsNaN(actual.X));
                    Check(Scalar.IsNaN(actual.Y));
                    Check(Scalar.IsNaN(actual.Z));
                }

                public void Infinity()
                {
                    string inf = formatter.PositiveInfinitySymbol;
                    string neg = formatter.NegativeInfinitySymbol;
                    var text = $"<{inf} : {neg} : {inf} : {neg}>";

                    var actual = Vector4.Parse(text, formatter);

                    Check(Scalar.IsInfinity(actual.X));
                    Check(Scalar.IsNegativeInfinity(actual.Y));
                    Check(Scalar.IsInfinity(actual.Z));
                    Check(Scalar.IsNegativeInfinity(actual.W));
                }
            }

            public class CustomFormatter : UnitTestSharp.TestFixture
            {
                public void Basic()
                {
                    var text = "<3,000.23 : 7,043.1 : 2,123 : 3,123>";
                    var expected = new Vector4(3000.23, 7043.1, 2123, 3123);

                    var actual = Vector4.Parse(text,
                        System.Globalization.NumberStyles.AllowThousands | System.Globalization.NumberStyles.Float);

                    CheckEqual(expected, actual);
                }

                public void NaN()
                {
                    var text = "<NaN : NaN : NaN : NaN>";

                    var actual = Vector4.Parse(text,
                        System.Globalization.NumberStyles.AllowThousands | System.Globalization.NumberStyles.Float);

                    Check(Scalar.IsNaN(actual.X));
                    Check(Scalar.IsNaN(actual.Y));
                    Check(Scalar.IsNaN(actual.Z));
                    Check(Scalar.IsNaN(actual.W));
                }

                public void Infinity()
                {
                    var text = "<Infinity : -Infinity : Infinity : -Infinity>";

                    var actual = Vector4.Parse(text,
                        System.Globalization.NumberStyles.AllowThousands | System.Globalization.NumberStyles.Float);

                    Check(Scalar.IsInfinity(actual.X));
                    Check(Scalar.IsNegativeInfinity(actual.Y));
                    Check(Scalar.IsInfinity(actual.Z));
                    Check(Scalar.IsNegativeInfinity(actual.W));
                }
            }
        }

        public class TryParse : UnitTestSharp.TestFixture
        {
            public void Basic()
            {
                var text = "<10.45 : 11.234 : 2.123 : 3.123>";
                var expected = new Vector4(10.45, 11.234, 2.123, 3.123);

                Vector4 actual;
                bool success = Vector4.TryParse(text, out actual);

                CheckEqual(expected, actual);
                Check(success);
            }

            public void NaN()
            {
                var text = "<NaN : NaN : NaN : NaN>";

                Vector4 actual;
                bool success = Vector4.TryParse(text, out actual);

                Check(Scalar.IsNaN(actual.X));
                Check(Scalar.IsNaN(actual.Y));
                Check(Scalar.IsNaN(actual.Z));
                Check(Scalar.IsNaN(actual.W));
                Check(success);
            }

            public void Infinity()
            {
                var text = "<Infinity : -Infinity : Infinity : -Infinity>";

                Vector4 actual;
                bool success = Vector4.TryParse(text, out actual);

                Check(Scalar.IsInfinity(actual.X));
                Check(Scalar.IsNegativeInfinity(actual.Y));
                Check(Scalar.IsInfinity(actual.Z));
                Check(Scalar.IsNegativeInfinity(actual.W));
                Check(success);
            }

            public void NotEnoughElements()
            {
                var text = "<Infinity : -Infinity : Infinity>";

                Vector4 actual;
                bool success = Vector4.TryParse(text, out actual);
                CheckFalse(success);
            }

            public void TooManyElements()
            {
                var text = "<Infinity : -Infinity : Infinity : Infinity : Infinity>";

                Vector4 actual;
                bool success = Vector4.TryParse(text, out actual);
                CheckFalse(success);
            }

            public void NotNumbers()
            {
                var text = "<A : 2 : 3 : 4>";

                Vector4 actual;
                bool success = Vector4.TryParse(text, out actual);
                CheckFalse(success);
            }

            public class FormatProviders : UnitTestSharp.TestFixture
            {
                private static NumberFormatInfo formatter =
                    System.Globalization.CultureInfo.GetCultureInfo("de-DE").NumberFormat;

                public void Basic()
                {
                    var text = "<3000,23 : 7043,1 : 2,123 : 3,123>";
                    var expected = new Vector4(3000.23, 7043.1, 2.123, 3.123);

                    Vector4 actual;
                    bool success = Vector4.TryParse(text, formatter, out actual);

                    CheckEqual(expected, actual);
                    Check(success);
                }

                public void NaN()
                {
                    string symbol = formatter.NaNSymbol;
                    var text = $"<{symbol} : {symbol} : {symbol} : {symbol}>";

                    Vector4 actual;
                    bool success = Vector4.TryParse(text, formatter, out actual);

                    Check(Scalar.IsNaN(actual.X));
                    Check(Scalar.IsNaN(actual.Y));
                    Check(Scalar.IsNaN(actual.Z));
                    Check(Scalar.IsNaN(actual.W));
                    Check(success);
                }

                public void Infinity()
                {
                    string inf = formatter.PositiveInfinitySymbol;
                    string neg = formatter.NegativeInfinitySymbol;
                    var text = $"<{inf} : {neg} : {inf} : {neg}>";

                    Vector4 actual;
                    bool success = Vector4.TryParse(text, formatter, out actual);

                    Check(Scalar.IsInfinity(actual.X));
                    Check(Scalar.IsNegativeInfinity(actual.Y));
                    Check(Scalar.IsInfinity(actual.Z));
                    Check(Scalar.IsNegativeInfinity(actual.W));
                    Check(success);
                }
            }

            public class CustomFormatter : UnitTestSharp.TestFixture
            {
                public void Basic()
                {
                    var text = "<3,000.23 : 7,043.1 : 2,123 : 3,123>";
                    var expected = new Vector4(3000.23, 7043.1, 2123, 3123);

                    Vector4 actual;
                    bool success = Vector4.TryParse(text,
                        System.Globalization.NumberStyles.AllowThousands | System.Globalization.NumberStyles.Float,
                        out actual);

                    CheckEqual(expected, actual);
                    Check(success);
                }

                public void NaN()
                {
                    var text = "<NaN : NaN : NaN : NaN>";

                    Vector4 actual;
                    bool success = Vector4.TryParse(text,
                        System.Globalization.NumberStyles.AllowThousands | System.Globalization.NumberStyles.Float,
                        out actual);

                    Check(Scalar.IsNaN(actual.X));
                    Check(Scalar.IsNaN(actual.Y));
                    Check(Scalar.IsNaN(actual.Z));
                    Check(Scalar.IsNaN(actual.W));
                    Check(success);
                }

                public void Infinity()
                {
                    var text = "<Infinity : -Infinity : Infinity : -Infinity>";

                    Vector4 actual;
                    bool success = Vector4.TryParse(text,
                        System.Globalization.NumberStyles.AllowThousands | System.Globalization.NumberStyles.Float,
                        out actual);

                    Check(Scalar.IsInfinity(actual.X));
                    Check(Scalar.IsNegativeInfinity(actual.Y));
                    Check(Scalar.IsInfinity(actual.Z));
                    Check(Scalar.IsNegativeInfinity(actual.W));
                    Check(success);
                }
            }
        }
    }
}