NanoBrain-unitypackage/Runtime/LinearAlgebra/test/DirectionTest.cs

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

namespace LinearAlgebra.Test {
    public class DirectionTest {

        [Test]
        public void RadiansForward() {
            Direction d = Direction.Radians(0, 0);
            Assert.AreEqual(0, d.horizontal.inDegrees, 0.0001f);
            Assert.AreEqual(0, d.vertical.inDegrees, 0.0001f);
        }

        [Test]
        public void RadiansUp() {
            Direction d = Direction.Radians(0, (float)Math.PI / 2);
            Assert.AreEqual(0, d.horizontal.inDegrees, 0.0001f);
            Assert.AreEqual(90, d.vertical.inDegrees, 0.0001f);
        }

        [Test]
        public void RadiansDown() {
            Direction d = Direction.Radians(0, -(float)Math.PI / 2);
            Assert.AreEqual(0, d.horizontal.inDegrees, 0.0001f);
            Assert.AreEqual(-90, d.vertical.inDegrees, 0.0001f);
        }

        [Test]
        public void RadiansArbitrary() {
            Direction d = Direction.Radians((float)Math.PI / 4, (float)Math.PI / 6);
            Assert.AreEqual(45, d.horizontal.inDegrees, 0.0001f);
            Assert.AreEqual(30, d.vertical.inDegrees, 0.0001f);
        }

        [Test]
        public void DegreesNormalize1() {
            Direction d = Direction.Degrees(112, 91);
            Assert.AreEqual(-68, d.horizontal.inDegrees, 0.0001f);
            Assert.AreEqual(89, d.vertical.inDegrees, 0.0001f);
        }

        [Test]
        public void RadiansEquivalentToDegreesConversion() {
            Direction d1 = Direction.Radians((float)Math.PI / 3, (float)Math.PI / 4);
            Direction d2 = Direction.Degrees(60, 45);
            Assert.AreEqual(d1.horizontal.inDegrees, d2.horizontal.inDegrees, 0.0001f);
            Assert.AreEqual(d1.vertical.inDegrees, d2.vertical.inDegrees, 0.0001f);
        }

        [Test]
        public void ToVector3Forward() {
            Direction d = Direction.forward;
            Vector3Float v = d.ToVector3();
            Assert.AreEqual(0, v.horizontal, 0.0001f);
            Assert.AreEqual(0, v.vertical, 0.0001f);
            Assert.AreEqual(1, v.depth, 0.0001f);
        }

        [Test]
        public void ToVector3Up() {
            Direction d = Direction.up;
            Vector3Float v = d.ToVector3();
            Assert.AreEqual(0, v.horizontal, 0.0001f);
            Assert.AreEqual(1, v.vertical, 0.0001f);
            Assert.AreEqual(0, v.depth, 0.0001f);
        }

        [Test]
        public void ToVector3Down() {
            Direction d = Direction.down;
            Vector3Float v = d.ToVector3();
            Assert.AreEqual(0, v.horizontal, 0.0001f);
            Assert.AreEqual(-1, v.vertical, 0.0001f);
            Assert.AreEqual(0, v.depth, 0.0001f);
        }

        [Test]
        public void ToVector3Left() {
            Direction d = Direction.left;
            Vector3Float v = d.ToVector3();
            Assert.AreEqual(-1, v.horizontal, 0.0001f);
            Assert.AreEqual(0, v.vertical, 0.0001f);
            Assert.AreEqual(0, v.depth, 0.0001f);
        }

        [Test]
        public void FromVector3Forward() {
            Vector3Float v = new(0, 0, 1);
            Direction d = Direction.FromVector3(v);
            Assert.AreEqual(0, d.horizontal.inDegrees, 0.0001f);
            Assert.AreEqual(0, d.vertical.inDegrees, 0.0001f);
        }

        [Test]
        public void ToVector3AndBack() {
            Direction d1 = Direction.Degrees(45, 30);
            Vector3Float v = d1.ToVector3();
            Direction d2 = Direction.FromVector3(v);
            Assert.AreEqual(d1.horizontal.inDegrees, d2.horizontal.inDegrees, 0.0001f);
            Assert.AreEqual(d1.vertical.inDegrees, d2.vertical.inDegrees, 0.0001f);
        }

        [Test]
        public void ToVector3AndBack2() {
            Direction d1 = Direction.Degrees(-135, 85);
            Vector3Float v = d1.ToVector3();
            Direction d2 = Direction.FromVector3(v);
            Assert.AreEqual(d1.horizontal.inDegrees, d2.horizontal.inDegrees, 0.0001f);
            Assert.AreEqual(d1.vertical.inDegrees, d2.vertical.inDegrees, 0.0001f);
        }

        [Test]
        public void Compare() {
            Direction d1 = Direction.Degrees(45, 135);
            Direction d2 = new(AngleFloat.Degrees(45), AngleFloat.Degrees(135));
            bool r;
            r = d1 == d2;
            Assert.True(r);
            Assert.AreEqual(d1, d2);
        }

        [Test]
        public void NotEqualWithDifferentHorizontal() {
            Direction d1 = Direction.Degrees(45, 30);
            Direction d2 = Direction.Degrees(90, 30);
            Assert.True(d1 != d2);
        }

        [Test]
        public void NotEqualWithDifferentVertical() {
            Direction d1 = Direction.Degrees(45, 30);
            Direction d2 = Direction.Degrees(45, 60);
            Assert.True(d1 != d2);
        }

        [Test]
        public void NotEqualWithDifferentBoth() {
            Direction d1 = Direction.Degrees(45, 30);
            Direction d2 = Direction.Degrees(90, 60);
            Assert.True(d1 != d2);
        }

        [Test]
        public void NotEqualWithSameValues() {
            Direction d1 = Direction.Degrees(45, 30);
            Direction d2 = Direction.Degrees(45, 30);
            Assert.False(d1 != d2);
        }


        [Test]
        public void EqualsWithSameValues() {
            Direction d1 = Direction.Degrees(45, 30);
            Direction d2 = Direction.Degrees(45, 30);
            Assert.True(d1.Equals(d2));
        }

        [Test]
        public void EqualsWithDifferentHorizontal() {
            Direction d1 = Direction.Degrees(45, 30);
            Direction d2 = Direction.Degrees(90, 30);
            Assert.False(d1.Equals(d2));
        }

        [Test]
        public void EqualsWithDifferentVertical() {
            Direction d1 = Direction.Degrees(45, 30);
            Direction d2 = Direction.Degrees(45, 60);
            Assert.False(d1.Equals(d2));
        }

        [Test]
        public void EqualsWithDifferentBoth() {
            Direction d1 = Direction.Degrees(45, 30);
            Direction d2 = Direction.Degrees(90, 60);
            Assert.False(d1.Equals(d2));
        }

        [Test]
        public void EqualsWithNonDirectionObject() {
            Direction d = Direction.Degrees(45, 30);
            Assert.False(d.Equals("not a direction"));
        }

        [Test]
        public void EqualsWithNull() {
            Direction d = Direction.Degrees(45, 30);
            Assert.False(d.Equals(null));
        }

        [Test]
        public void EqualsWithZeros() {
            Direction d1 = Direction.forward;
            Direction d2 = Direction.Degrees(0, 0);
            Assert.True(d1.Equals(d2));
        }

        [Test]
        public void HashCode() {
            Direction d1 = Direction.Degrees(45, 30);
            Direction d2 = Direction.Degrees(45, 30);
            Assert.AreEqual(d1.GetHashCode(), d2.GetHashCode());

            d1 = Direction.Degrees(45, 30);
            d2 = Direction.Degrees(90, 30);
            Assert.AreNotEqual(d1.GetHashCode(), d2.GetHashCode());

            d1 = Direction.Degrees(45, 30);
            d2 = Direction.Degrees(45, 60);
            Assert.AreNotEqual(d1.GetHashCode(), d2.GetHashCode());

            Direction d = Direction.Degrees(45, 30);
            int hash1 = d.GetHashCode();
            int hash2 = d.GetHashCode();
            Assert.AreEqual(hash1, hash2);

            d1 = Direction.forward;
            d2 = Direction.Degrees(0, 0);
            Assert.AreEqual(d1.GetHashCode(), d2.GetHashCode());
        }

    };
}
#endif