#if !UNITY_5_6_OR_NEWER
using System;
using System.Formats.Asn1;
using NUnit.Framework;

namespace LinearAlgebra.Test {
    public class AngleTests {
        [SetUp]
        public void Setup() {
        }

        [Test]
        public void Construct() {
            // Degrees
            float angle = 0.0f;
            AngleFloat a = AngleFloat.Degrees(angle);
            Assert.AreEqual(angle, a.inDegrees);

            angle = -180.0f;
            a = AngleFloat.Degrees(angle);
            Assert.AreEqual(angle, a.inDegrees);

            angle = 270.0f;
            a = AngleFloat.Degrees(angle);
            Assert.AreEqual(-90, a.inDegrees);

            angle = -270.0f;
            a = AngleFloat.Degrees(angle);
            Assert.AreEqual(90, a.inDegrees);

            // Radians
            angle = 0.0f;
            a = AngleFloat.Radians(angle);
            Assert.AreEqual(angle, a.inRadians);

            angle = (float)-Math.PI;
            a = AngleFloat.Radians(angle);
            Assert.AreEqual(angle, a.inRadians);

            angle = (float)Math.PI * 1.5f;
            a = AngleFloat.Radians(angle);
            Assert.AreEqual(-Math.PI * 0.5f, a.inRadians, 1.0E-05F);

            // Revolutions
            angle = 0.0f;
            a = AngleFloat.Revolutions(angle);
            Assert.AreEqual(angle, a.inRevolutions);

            angle = -0.5f;
            a = AngleFloat.Revolutions(angle);
            Assert.AreEqual(angle, a.inRevolutions);

            angle = 0.75f;
            a = AngleFloat.Revolutions(angle);
            Assert.AreEqual(-0.25f, a.inRevolutions);

        }

        [Test]
        public void Revolutions() {
            AngleFloat a;

            // Test zero
            a = AngleFloat.Revolutions(0.0f);
            Assert.AreEqual(0.0f, a.inRevolutions);

            // Test positive values within range
            a = AngleFloat.Revolutions(0.25f);
            Assert.AreEqual(0.25f, a.inRevolutions);

            a = AngleFloat.Revolutions(0.5f);
            Assert.AreEqual(-0.5f, a.inRevolutions);

            // Test negative values within range
            a = AngleFloat.Revolutions(-0.25f);
            Assert.AreEqual(-0.25f, a.inRevolutions);

            a = AngleFloat.Revolutions(-0.5f);
            Assert.AreEqual(-0.5f, a.inRevolutions);

            // Test values outside range (positive)
            a = AngleFloat.Revolutions(1.0f);
            Assert.AreEqual(0.0f, a.inRevolutions);

            a = AngleFloat.Revolutions(1.25f);
            Assert.AreEqual(0.25f, a.inRevolutions);

            a = AngleFloat.Revolutions(1.75f);
            Assert.AreEqual(-0.25f, a.inRevolutions);

            // Test values outside range (negative)
            a = AngleFloat.Revolutions(-1.0f);
            Assert.AreEqual(0.0f, a.inRevolutions);

            a = AngleFloat.Revolutions(-1.25f);
            Assert.AreEqual(-0.25f, a.inRevolutions);

            a = AngleFloat.Revolutions(-1.75f);
            Assert.AreEqual(0.25f, a.inRevolutions);

            // Test infinity
            a = AngleFloat.Revolutions(float.PositiveInfinity);
            Assert.AreEqual(float.PositiveInfinity, a.inRevolutions);

            a = AngleFloat.Revolutions(float.NegativeInfinity);
            Assert.AreEqual(float.NegativeInfinity, a.inRevolutions);
        }

        [Test]
        public void Equality() {
            // Test equality operator
            Assert.IsTrue(AngleFloat.Degrees(90) == AngleFloat.Degrees(90), "90 == 90");
            Assert.IsFalse(AngleFloat.Degrees(90) == AngleFloat.Degrees(45), "90 == 45");
            Assert.IsTrue(AngleFloat.Degrees(0) == AngleFloat.Degrees(0), "0 == 0");
            Assert.IsTrue(AngleFloat.Degrees(-180) == AngleFloat.Degrees(-180), "-180 == -180");

            // Test inequality operator
            Assert.IsTrue(AngleFloat.Degrees(90) != AngleFloat.Degrees(45), "90 != 45");
            Assert.IsFalse(AngleFloat.Degrees(90) != AngleFloat.Degrees(90), "90 != 90");
            Assert.IsTrue(AngleFloat.Degrees(0) != AngleFloat.Degrees(1), "0 != 1");

            // Test greater than operator
            Assert.IsTrue(AngleFloat.Degrees(90) > AngleFloat.Degrees(45), "90 > 45");
            Assert.IsFalse(AngleFloat.Degrees(45) > AngleFloat.Degrees(90), "45 > 90");
            Assert.IsFalse(AngleFloat.Degrees(90) > AngleFloat.Degrees(90), "90 > 90");

            // Test greater than or equal operator
            Assert.IsTrue(AngleFloat.Degrees(90) >= AngleFloat.Degrees(45), "90 >= 45");
            Assert.IsTrue(AngleFloat.Degrees(90) >= AngleFloat.Degrees(90), "90 >= 90");
            Assert.IsFalse(AngleFloat.Degrees(45) >= AngleFloat.Degrees(90), "45 >= 90");

            // Test less than operator
            Assert.IsTrue(AngleFloat.Degrees(45) < AngleFloat.Degrees(90), "45 < 90");
            Assert.IsFalse(AngleFloat.Degrees(90) < AngleFloat.Degrees(45), "90 < 45");
            Assert.IsFalse(AngleFloat.Degrees(90) < AngleFloat.Degrees(90), "90 < 90");

            // Test less than or equal operator
            Assert.IsTrue(AngleFloat.Degrees(45) <= AngleFloat.Degrees(90), "45 <= 90");
            Assert.IsTrue(AngleFloat.Degrees(90) <= AngleFloat.Degrees(90), "90 <= 90");
            Assert.IsFalse(AngleFloat.Degrees(90) <= AngleFloat.Degrees(45), "90 <= 45");
        }

        // [Test]
        // public void Normalize() {
        //     float r = 0;

        //     r = Angle.Normalize(90);
        //     Assert.AreEqual(r, 90, "Normalize 90");

        //     r = Angle.Normalize(-90);
        //     Assert.AreEqual(r, -90, "Normalize -90");

        //     r = Angle.Normalize(270);
        //     Assert.AreEqual(r, -90, "Normalize 270");

        //     r = Angle.Normalize(270 + 360);
        //     Assert.AreEqual(r, -90, "Normalize 270+360");

        //     r = Angle.Normalize(-270);
        //     Assert.AreEqual(r, 90, "Normalize -270");

        //     r = Angle.Normalize(-270 - 360);
        //     Assert.AreEqual(r, 90, "Normalize -270-360");

        //     r = Angle.Normalize(0);
        //     Assert.AreEqual(r, 0, "Normalize 0");

        //     r = Angle.Normalize(float.PositiveInfinity);
        //     Assert.AreEqual(r, float.PositiveInfinity, "Normalize INFINITY");

        //     r = Angle.Normalize(float.NegativeInfinity);
        //     Assert.AreEqual(r, float.NegativeInfinity, "Normalize INFINITY");
        // }

        [Test]
        public void Clamp() {
            float r = 0;

            r = AngleFloat.Clamp(AngleFloat.Degrees(1), AngleFloat.Degrees(0), AngleFloat.Degrees(2));
            Assert.AreEqual(1, r, "Clamp 1 0 2");

            r = AngleFloat.Clamp(AngleFloat.Degrees(-1), AngleFloat.Degrees(0), AngleFloat.Degrees(2));
            Assert.AreEqual(0, r, "Clamp -1 0 2");

            r = AngleFloat.Clamp(AngleFloat.Degrees(3), AngleFloat.Degrees(0), AngleFloat.Degrees(2));
            Assert.AreEqual(2, r, "Clamp 3 0 2");

            r = AngleFloat.Clamp(AngleFloat.Degrees(1), AngleFloat.Degrees(0), AngleFloat.Degrees(0));
            Assert.AreEqual(0, r, "Clamp 1 0 0");

            r = AngleFloat.Clamp(AngleFloat.Degrees(0), AngleFloat.Degrees(0), AngleFloat.Degrees(0));
            Assert.AreEqual(0, r, "Clamp 0 0 0");

            r = AngleFloat.Clamp(AngleFloat.Degrees(0), AngleFloat.Degrees(1), AngleFloat.Degrees(-1));
            Assert.AreEqual(1, r, "Clamp 0 1 -1");

            r = AngleFloat.Clamp(AngleFloat.Degrees(1), AngleFloat.Degrees(0), AngleFloat.Degrees(float.PositiveInfinity));
            Assert.AreEqual(1, r, "Clamp 1 0 INFINITY");

            r = AngleFloat.Clamp(AngleFloat.Degrees(1), AngleFloat.Degrees(float.NegativeInfinity), AngleFloat.Degrees(1));
            Assert.AreEqual(1, r, "Clamp 1 -INFINITY 1");
        }

        [Test]
        public void Cos() {
            // Test zero
            Assert.AreEqual(1.0f, AngleFloat.Cos(AngleFloat.Degrees(0)), 1.0E-05F, "Cos(0°)");

            // Test 90 degrees
            Assert.AreEqual(0.0f, AngleFloat.Cos(AngleFloat.Degrees(90)), 1.0E-05F, "Cos(90°)");

            // Test 180 degrees
            Assert.AreEqual(-1.0f, AngleFloat.Cos(AngleFloat.Degrees(180)), 1.0E-05F, "Cos(180°)");

            // Test 270 degrees
            Assert.AreEqual(0.0f, AngleFloat.Cos(AngleFloat.Degrees(270)), 1.0E-05F, "Cos(270°)");

            // Test 45 degrees
            Assert.AreEqual(MathF.Sqrt(2) / 2, AngleFloat.Cos(AngleFloat.Degrees(45)), 1.0E-05F, "Cos(45°)");

            // Test negative angle
            Assert.AreEqual(1.0f, AngleFloat.Cos(AngleFloat.Degrees(-360)), 1.0E-05F, "Cos(-360°)");

            // Test using radians
            Assert.AreEqual(1.0f, AngleFloat.Cos(AngleFloat.Radians(0)), 1.0E-05F, "Cos(0 rad)");
            Assert.AreEqual(0.0f, AngleFloat.Cos(AngleFloat.Radians((float)Math.PI / 2)), 1.0E-05F, "Cos(π/2)");
            Assert.AreEqual(-1.0f, AngleFloat.Cos(AngleFloat.Radians((float)Math.PI)), 1.0E-05F, "Cos(π)");
        }

        [Test]
        public void Sin() {
            // Test zero
            Assert.AreEqual(0.0f, AngleFloat.Sin(AngleFloat.Degrees(0)), 1.0E-05F, "Sin(0°)");

            // Test 90 degrees
            Assert.AreEqual(1.0f, AngleFloat.Sin(AngleFloat.Degrees(90)), 1.0E-05F, "Sin(90°)");

            // Test 180 degrees
            Assert.AreEqual(0.0f, AngleFloat.Sin(AngleFloat.Degrees(180)), 1.0E-05F, "Sin(180°)");

            // Test 270 degrees
            Assert.AreEqual(-1.0f, AngleFloat.Sin(AngleFloat.Degrees(270)), 1.0E-05F, "Sin(270°)");

            // Test 45 degrees
            Assert.AreEqual(MathF.Sqrt(2) / 2, AngleFloat.Sin(AngleFloat.Degrees(45)), 1.0E-05F, "Sin(45°)");

            // Test negative angle
            Assert.AreEqual(0.0f, AngleFloat.Sin(AngleFloat.Degrees(-360)), 1.0E-05F, "Sin(-360°)");

            // Test using radians
            Assert.AreEqual(0.0f, AngleFloat.Sin(AngleFloat.Radians(0)), 1.0E-05F, "Sin(0 rad)");
            Assert.AreEqual(1.0f, AngleFloat.Sin(AngleFloat.Radians((float)Math.PI / 2)), 1.0E-05F, "Sin(π/2)");
            Assert.AreEqual(0.0f, AngleFloat.Sin(AngleFloat.Radians((float)Math.PI)), 1.0E-05F, "Sin(π)");
        }

        [Test]
        public void Tan() {
            // Test zero
            Assert.AreEqual(0.0f, AngleFloat.Tan(AngleFloat.Degrees(0)), 1.0E-05F, "Tan(0°)");

            // Test 45 degrees
            Assert.AreEqual(1.0f, AngleFloat.Tan(AngleFloat.Degrees(45)), 1.0E-05F, "Tan(45°)");

            // Test -45 degrees
            Assert.AreEqual(-1.0f, AngleFloat.Tan(AngleFloat.Degrees(-45)), 1.0E-05F, "Tan(-45°)");

            // Test using radians
            Assert.AreEqual(0.0f, AngleFloat.Tan(AngleFloat.Radians(0)), 1.0E-05F, "Tan(0 rad)");
            Assert.AreEqual(1.0f, AngleFloat.Tan(AngleFloat.Radians((float)Math.PI / 4)), 1.0E-05F, "Tan(π/4)");
        }

        [Test]
        public void Acos() {
            // Test 1 (0 degrees)
            Assert.AreEqual(0.0f, AngleFloat.Acos(1.0f).inRadians, 1.0E-05F, "Acos(1)");

            // Test 0 (90 degrees or π/2 radians)
            Assert.AreEqual((float)Math.PI / 2, AngleFloat.Acos(0.0f).inRadians, 1.0E-05F, "Acos(0)");

            // Test -1 (-180 degrees or π radians)
            Assert.AreEqual((float)-Math.PI, AngleFloat.Acos(-1.0f).inRadians, 1.0E-05F, "Acos(-1)");

            // Test 0.5 (60 degrees or π/3 radians)
            Assert.AreEqual((float)Math.PI / 3, AngleFloat.Acos(0.5f).inRadians, 1.0E-05F, "Acos(0.5)");

            // Test sqrt(2)/2 (45 degrees or π/4 radians)
            Assert.AreEqual((float)Math.PI / 4, AngleFloat.Acos(MathF.Sqrt(2) / 2).inRadians, 1.0E-05F, "Acos(√2/2)");
        }

        [Test]
        public void Asin() {
            // Test 0 (0 degrees)
            Assert.AreEqual(0.0f, AngleFloat.Asin(0.0f).inRadians, 1.0E-05F, "Asin(0)");

            // Test 1 (90 degrees or π/2 radians)
            Assert.AreEqual((float)Math.PI / 2, AngleFloat.Asin(1.0f).inRadians, 1.0E-05F, "Asin(1)");

            // Test -1 (-90 degrees or -π/2 radians)
            Assert.AreEqual(-(float)Math.PI / 2, AngleFloat.Asin(-1.0f).inRadians, 1.0E-05F, "Asin(-1)");

            // Test 0.5 (30 degrees or π/6 radians)
            Assert.AreEqual((float)Math.PI / 6, AngleFloat.Asin(0.5f).inRadians, 1.0E-05F, "Asin(0.5)");

            // Test sqrt(2)/2 (45 degrees or π/4 radians)
            Assert.AreEqual((float)Math.PI / 4, AngleFloat.Asin(MathF.Sqrt(2) / 2).inRadians, 1.0E-05F, "Asin(√2/2)");
        }


        [Test]
        public void Atan() {
            // Test zero
            Assert.AreEqual(0.0f, AngleFloat.Atan(0.0f).inRadians, 1.0E-05F, "Atan(0)");

            // Test 1 (45 degrees or π/4 radians)
            Assert.AreEqual((float)Math.PI / 4, AngleFloat.Atan(1.0f).inRadians, 1.0E-05F, "Atan(1)");

            // Test -1 (-45 degrees or -π/4 radians)
            Assert.AreEqual(-(float)Math.PI / 4, AngleFloat.Atan(-1.0f).inRadians, 1.0E-05F, "Atan(-1)");

            // Test sqrt(3) (60 degrees or π/3 radians)
            Assert.AreEqual((float)Math.PI / 3, AngleFloat.Atan(MathF.Sqrt(3)).inRadians, 1.0E-05F, "Atan(√3)");

            // Test 1/sqrt(3) (30 degrees or π/6 radians)
            Assert.AreEqual((float)Math.PI / 6, AngleFloat.Atan(1.0f / MathF.Sqrt(3)).inRadians, 1.0E-05F, "Atan(1/√3)");

            // Test positive infinity
            Assert.AreEqual((float)Math.PI / 2, AngleFloat.Atan(float.PositiveInfinity).inRadians, 1.0E-05F, "Atan(+∞)");

            // Test negative infinity
            Assert.AreEqual(-(float)Math.PI / 2, AngleFloat.Atan(float.NegativeInfinity).inRadians, 1.0E-05F, "Atan(-∞)");
        }

        [Test]
        public void Atan2() {
            // Test basic quadrant I
            Assert.AreEqual((float)Math.PI / 4, AngleFloat.Atan2(1.0f, 1.0f).inRadians, 1.0E-05F, "Atan2(1, 1)");

            // Test quadrant II
            Assert.AreEqual(3 * (float)Math.PI / 4, AngleFloat.Atan2(1.0f, -1.0f).inRadians, 1.0E-05F, "Atan2(1, -1)");

            // Test quadrant III
            Assert.AreEqual(-(float)Math.PI * 0.75f, AngleFloat.Atan2(-1.0f, -1.0f).inRadians, 1.0E-05F, "Atan2(-1, -1)");

            // Test quadrant IV
            Assert.AreEqual(-(float)Math.PI / 4, AngleFloat.Atan2(-1.0f, 1.0f).inRadians, 1.0E-05F, "Atan2(-1, 1)");

            // Test positive x-axis
            Assert.AreEqual(0.0f, AngleFloat.Atan2(0.0f, 1.0f).inRadians, 1.0E-05F, "Atan2(0, 1)");

            // Test positive y-axis
            Assert.AreEqual((float)Math.PI / 2, AngleFloat.Atan2(1.0f, 0.0f).inRadians, 1.0E-05F, "Atan2(1, 0)");

            // Test negative y-axis
            Assert.AreEqual(-(float)Math.PI / 2, AngleFloat.Atan2(-1.0f, 0.0f).inRadians, 1.0E-05F, "Atan2(-1, 0)");

            // Test origin
            Assert.AreEqual(0.0f, AngleFloat.Atan2(0.0f, 0.0f).inRadians, 1.0E-05F, "Atan2(0, 0)");

            // Test with different magnitudes
            Assert.AreEqual((float)Math.PI / 3, AngleFloat.Atan2(MathF.Sqrt(3), 1.0f).inRadians, 1.0E-05F, "Atan2(√3, 1)");

            // Test negative x-axis
            Assert.AreEqual((float)-Math.PI, AngleFloat.Atan2(0.0f, -1.0f).inRadians, 1.0E-05F, "Atan2(0, -1)");
        }

        [Test]
        public void Multiplication() {
            AngleFloat r = AngleFloat.zero;

            // Angle * float
            r = AngleFloat.Degrees(90) * 2;
            Assert.AreEqual(-180, r.inDegrees, "Multiply 90 * 2");

            r = AngleFloat.Degrees(45) * 0.5f;
            Assert.AreEqual(22.5f, r.inDegrees, "Multiply 45 * 0.5");

            r = AngleFloat.Degrees(90) * 0;
            Assert.AreEqual(0, r.inDegrees, "Multiply 90 * 0");

            r = AngleFloat.Degrees(-90) * 2;
            Assert.AreEqual(-180, r.inDegrees, "Multiply -90 * 2");

            r = AngleFloat.Degrees(270) * 2;
            Assert.AreEqual(-180, r.inDegrees, "Multiply 270 * 2 (normalized)");

            // float * Angle
            r = 2 * AngleFloat.Degrees(90);
            Assert.AreEqual(-180, r.inDegrees, "Multiply 2 * 90");

            r = 0.5f * AngleFloat.Degrees(45);
            Assert.AreEqual(22.5, r.inDegrees, "Multiply 0.5 * 45");

            r = 0 * AngleFloat.Degrees(90);
            Assert.AreEqual(0, r.inDegrees, "Multiply 0 * 90");

            r = 2 * AngleFloat.Degrees(-90);
            Assert.AreEqual(-180, r.inDegrees, "Multiply 2 * -90");

            // Negative factor
            r = AngleFloat.Degrees(90) * -1;
            Assert.AreEqual(-90, r.inDegrees, "Multiply 90 * -1");

            r = -1 * AngleFloat.Degrees(90);
            Assert.AreEqual(-90, r.inDegrees, "Multiply -1 * 90");
        }

        [Test]
        public void MoveTowards() {
            AngleFloat r = AngleFloat.zero;

            r = AngleFloat.MoveTowards(AngleFloat.Degrees(0), AngleFloat.Degrees(90), 30);
            Assert.AreEqual(30, r.inDegrees, "MoveTowards 0 90 30");

            r = AngleFloat.MoveTowards(AngleFloat.Degrees(0), AngleFloat.Degrees(90), 90);
            Assert.AreEqual(90, r.inDegrees, "MoveTowards 0 90 90");

            r = AngleFloat.MoveTowards(AngleFloat.Degrees(0), AngleFloat.Degrees(90), 180);
            Assert.AreEqual(90, r.inDegrees, "MoveTowards 0 90 180");

            r = AngleFloat.MoveTowards(AngleFloat.Degrees(0), AngleFloat.Degrees(90), 270);
            Assert.AreEqual(90, r.inDegrees, "MoveTowrads 0 90 270");

            r = AngleFloat.MoveTowards(AngleFloat.Degrees(0), AngleFloat.Degrees(90), -30);
            Assert.AreEqual(0, r.inDegrees, "MoveTowards 0 90 -30");

            r = AngleFloat.MoveTowards(AngleFloat.Degrees(0), AngleFloat.Degrees(-90), -30);
            Assert.AreEqual(0, r.inDegrees, "MoveTowards 0 -90 -30");

            r = AngleFloat.MoveTowards(AngleFloat.Degrees(0), AngleFloat.Degrees(-90), -90);
            Assert.AreEqual(0, r.inDegrees, "MoveTowards 0 -90 -90");

            r = AngleFloat.MoveTowards(AngleFloat.Degrees(0), AngleFloat.Degrees(-90), -180);
            Assert.AreEqual(0, r.inDegrees, "MoveTowards 0 -90 -180");

            r = AngleFloat.MoveTowards(AngleFloat.Degrees(0), AngleFloat.Degrees(-90), -270);
            Assert.AreEqual(0, r.inDegrees, "MoveTowrads 0 -90 -270");

            r = AngleFloat.MoveTowards(AngleFloat.Degrees(0), AngleFloat.Degrees(90), 0);
            Assert.AreEqual(0, r.inDegrees, "MoveTowards 0 90 0");

            r = AngleFloat.MoveTowards(AngleFloat.Degrees(0), AngleFloat.Degrees(0), 0);
            Assert.AreEqual(0, r.inDegrees, "MoveTowards 0 0 0");

            r = AngleFloat.MoveTowards(AngleFloat.Degrees(0), AngleFloat.Degrees(0), 30);
            Assert.AreEqual(0, r.inDegrees, "MoveTowrads 0 0 30");

            r = AngleFloat.MoveTowards(AngleFloat.Degrees(0), AngleFloat.Degrees(90), float.PositiveInfinity);
            Assert.AreEqual(90, r.inDegrees, "MoveTowards 0 90 INFINITY");

            r = AngleFloat.MoveTowards(AngleFloat.Degrees(0), AngleFloat.Degrees(float.PositiveInfinity), 30);
            Assert.AreEqual(30, r.inDegrees, "MoveTowrads 0 INFINITY 30");

            r = AngleFloat.MoveTowards(AngleFloat.Degrees(0), AngleFloat.Degrees(-90), float.NegativeInfinity);
            Assert.AreEqual(0, r.inDegrees, "MoveTowards 0 -90 -INFINITY");

            r = AngleFloat.MoveTowards(AngleFloat.Degrees(0), AngleFloat.Degrees(float.NegativeInfinity), -30);
            Assert.AreEqual(0, r.inDegrees, "MoveTowrads 0 -INFINITY -30");

        }

        [Test]
        public void Difference() {
            float r = 0;

            r = Angles.Difference(0, 90);
            Assert.AreEqual(90, r, "Difference 0 90");

            r = Angles.Difference(0, -90);
            Assert.AreEqual(-90, r, "Difference 0 -90");

            r = Angles.Difference(0, 270);
            Assert.AreEqual(-90, r, "Difference 0 270");

            r = Angles.Difference(0, -270);
            Assert.AreEqual(90, r, "Difference 0 -270");

            r = Angles.Difference(90, 0);
            Assert.AreEqual(-90, r, "Difference 90 0");

            r = Angles.Difference(-90, 0);
            Assert.AreEqual(90, r, "Difference -90 0");

            r = Angles.Difference(0, 0);
            Assert.AreEqual(0, r, "Difference 0 0");

            r = Angles.Difference(90, 90);
            Assert.AreEqual(0, r, "Difference 90 90");

            r = Angles.Difference(0, float.PositiveInfinity);
            Assert.AreEqual(float.PositiveInfinity, r, "Difference 0 INFINITY");

            r = Angles.Difference(0, float.NegativeInfinity);
            Assert.AreEqual(float.NegativeInfinity, r, "Difference 0 -INFINITY");

            r = Angles.Difference(float.NegativeInfinity, float.PositiveInfinity);
            Assert.AreEqual(float.PositiveInfinity, r, "Difference -INFINITY INFINITY");
        }
    }

}
#endif