From b475acab1e677c3d570e83fe791fdffac54f0e0b Mon Sep 17 00:00:00 2001
From: JaggerJo <jaeger.josua@gmail.com>
Date: Thu, 15 Aug 2019 21:17:38 +0200
Subject: [PATCH] - add tests - add instance methods for normalize & negate -
 make length squared simpler

---
 src/Avalonia.Visuals/Vector.cs                |  18 ++-
 .../Avalonia.Visuals.UnitTests/VectorTests.cs | 112 ++++++++++++++++++
 2 files changed, 128 insertions(+), 2 deletions(-)
 create mode 100644 tests/Avalonia.Visuals.UnitTests/VectorTests.cs

diff --git a/src/Avalonia.Visuals/Vector.cs b/src/Avalonia.Visuals/Vector.cs
index 2c02c00d00..782a917c62 100644
--- a/src/Avalonia.Visuals/Vector.cs
+++ b/src/Avalonia.Visuals/Vector.cs
@@ -88,12 +88,12 @@ namespace Avalonia
         /// <summary>
         /// Length of the vector
         /// </summary>
-        public double Length => Math.Sqrt(X * X + Y * Y);
+        public double Length => Math.Sqrt(_x * _x + _y * _y);
 
         /// <summary>
         /// Squared Length of the vector
         /// </summary>
-        public double SquaredLength => Math.Sqrt(Length);
+        public double SquaredLength => _x * _x + _y * _y;
 
         /// <summary>
         /// Negates a vector.
@@ -201,6 +201,20 @@ namespace Avalonia
             return new Vector(_x, y);
         }
 
+        /// <summary>
+        /// Returns a normalized version of this vector.
+        /// </summary>
+        /// <returns>The normalized vector.</returns>
+        public Vector Normalize()
+            => Normalize(this);
+
+        /// <summary>
+        /// Returns a negated version of this vector.
+        /// </summary>
+        /// <returns>The negated vector.</returns>
+        public Vector Negate()
+            => Negate(this);
+
         /// <summary>
         /// Returns the dot product of two vectors.
         /// </summary>
diff --git a/tests/Avalonia.Visuals.UnitTests/VectorTests.cs b/tests/Avalonia.Visuals.UnitTests/VectorTests.cs
new file mode 100644
index 0000000000..1bcc165aef
--- /dev/null
+++ b/tests/Avalonia.Visuals.UnitTests/VectorTests.cs
@@ -0,0 +1,112 @@
+// Copyright (c) The Avalonia Project. All rights reserved.
+// Licensed under the MIT license. See licence.md file in the project root for full license information.
+
+using Xunit;
+using Avalonia;
+using System;
+
+namespace Avalonia.Visuals.UnitTests
+{
+    public class VectorTests
+    {
+        [Fact]
+        public void Length_Should_Return_Correct_Length_Of_Vector()
+        {
+            var vector = new Vector(2, 4);
+            var length = Math.Sqrt(2 * 2 + 4 * 4);
+
+            Assert.Equal(length, vector.Length);
+        }
+
+        [Fact]
+        public void Length_Squared_Should_Return_Correct_Length_Of_Vector()
+        {
+            var vectorA = new Vector(2, 4);
+            var squaredLengthA = 2 * 2 + 4 * 4;
+
+            Assert.Equal(squaredLengthA, vectorA.SquaredLength);
+        }
+
+        [Fact]
+        public void Normalize_Should_Return_Normalized_Vector()
+        {
+            // the length of a normalized vector must be 1
+
+            var vectorA = new Vector(13, 84);
+            var vectorB = new Vector(-34, 345);
+            var vectorC = new Vector(-34, -84);
+
+            Assert.Equal(1.0, vectorA.Normalize().Length);
+            Assert.Equal(1.0, vectorB.Normalize().Length);
+            Assert.Equal(1.0, vectorC.Normalize().Length);
+        }
+
+        [Fact]
+        public void Negate_Should_Return_Negated_Vector()
+        {
+            var vector = new Vector(2, 4);
+            var negated = new Vector(-2, -4);
+
+            Assert.Equal(negated, vector.Negate());
+        }
+
+        [Fact]
+        public void Dot_Should_Return_Correct_Value()
+        {
+            var a = new Vector(-6, 8.0);
+            var b = new Vector(5, 12.0);
+
+            Assert.Equal(66.0, Vector.Dot(a, b));
+        }
+
+        [Fact]
+        public void Cross_Should_Return_Correct_Value()
+        {
+            var a = new Vector(-6, 8.0);
+            var b = new Vector(5, 12.0);
+
+            Assert.Equal(-112.0, Vector.Cross(a, b));
+        }
+
+        [Fact]
+        public void Divied_By_Vector_Should_Return_Correct_Value()
+        {
+            var a = new Vector(10, 2);
+            var b = new Vector(5, 2);
+
+            var expected = new Vector(2, 1);
+
+            Assert.Equal(expected, Vector.Divide(a, b));
+        }
+
+        [Fact]
+        public void Divied_Should_Return_Correct_Value()
+        {
+            var vector = new Vector(10, 2);
+            var expected = new Vector(5, 1);
+
+            Assert.Equal(expected, Vector.Divide(vector, 2));
+        }
+
+        [Fact]
+        public void Multiply_By_Vector_Should_Return_Correct_Value()
+        {
+            var a = new Vector(10, 2);
+            var b = new Vector(2, 2);
+
+            var expected = new Vector(20, 4);
+
+            Assert.Equal(expected, Vector.Multiply(a, b));
+        }
+
+        [Fact]
+        public void Multiply_Should_Return_Correct_Value()
+        {
+            var vector = new Vector(10, 2);
+
+            var expected = new Vector(20, 4);
+
+            Assert.Equal(expected, Vector.Multiply(vector, 2));
+        }
+    }
+}