From c7298d878412d2df3cda1d8c9c5d284a2ef0c2c9 Mon Sep 17 00:00:00 2001 From: Jarl Gullberg Date: Thu, 1 Jun 2017 21:09:10 +0200 Subject: [PATCH] Improved test naming. --- tests/OpenTK.Tests/Matrix4Tests.fs | 76 ++++++++------- tests/OpenTK.Tests/Vector2Tests.fs | 184 ++++++++++++++++++------------------- tests/OpenTK.Tests/Vector3Tests.fs | 162 ++++++++++++++++---------------- tests/OpenTK.Tests/Vector4Tests.fs | 172 +++++++++++++++++++--------------- 4 files changed, 312 insertions(+), 282 deletions(-) diff --git a/tests/OpenTK.Tests/Matrix4Tests.fs b/tests/OpenTK.Tests/Matrix4Tests.fs index 1a0eabc..5a589d6 100644 --- a/tests/OpenTK.Tests/Matrix4Tests.fs +++ b/tests/OpenTK.Tests/Matrix4Tests.fs @@ -266,7 +266,7 @@ module Matrix4 = module Indexing = // [] - let ``Matrix indexing sets correct components`` (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) = + let ``Matrix set indexing sets correct components`` (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) = let mutable A = Matrix4() A.[0, 0] <- a @@ -308,46 +308,56 @@ module Matrix4 = Assert.Equal(n, A.M42) Assert.Equal(o, A.M43) Assert.Equal(p, A.M44) - + [] - let ``Matrix indexing throws on negative indices`` (a) = - let mutable A = Matrix4() + let ``Matrix get indexing accesses the correct components`` (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) = + let A = Matrix4(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) + + Assert.Equal(a, A.[0, 0]) + Assert.Equal(b, A.[0, 1]) + Assert.Equal(c, A.[0, 2]) + Assert.Equal(d, A.[0, 3]) - let invalidIndexingAssignmentR = fun() -> A.[-1, 2] <- a - let invalidIndexingAssignmentC = fun() -> A.[1, -2] <- a - let invalidIndexingAssignmentRC = fun() -> A.[-1, -2] <- a + Assert.Equal(e, A.[1, 0]) + Assert.Equal(f, A.[1, 1]) + Assert.Equal(g, A.[1, 2]) + Assert.Equal(h, A.[1, 3]) - let invalidIndexingAccessR = fun() -> A.[-1, 2] |> ignore - let invalidIndexingAccessC = fun() -> A.[1, -2] |> ignore - let invalidIndexingAccessRC = fun() -> A.[-1, -2] |> ignore + Assert.Equal(i, A.[2, 0]) + Assert.Equal(j, A.[2, 1]) + Assert.Equal(k, A.[2, 2]) + Assert.Equal(l, A.[2, 3]) - Assert.Throws(invalidIndexingAssignmentR) |> ignore - Assert.Throws(invalidIndexingAssignmentC) |> ignore - Assert.Throws(invalidIndexingAssignmentRC) |> ignore - - Assert.Throws(invalidIndexingAccessR) |> ignore - Assert.Throws(invalidIndexingAccessC) |> ignore - Assert.Throws(invalidIndexingAccessRC) |> ignore - - [] - let ``Matrix indexing throws on large indices`` (a) = - let mutable A = Matrix4() + Assert.Equal(m, A.[3, 0]) + Assert.Equal(n, A.[3, 1]) + Assert.Equal(o, A.[3, 2]) + Assert.Equal(p, A.[3, 3]) - let invalidIndexingAssignmentR = fun() -> A.[5, 2] <- a - let invalidIndexingAssignmentC = fun() -> A.[1, 6] <- a - let invalidIndexingAssignmentRC = fun() -> A.[7, 12] <- a + [] + let ``Indexed set operator throws exception for negative indices`` (b : Matrix4, x : float32) = + let mutable a = b + (fun() -> a.[-1, 2] <- x) |> Assert.Throws |> ignore + (fun() -> a.[1, -2] <- x) |> Assert.Throws |> ignore + (fun() -> a.[-1, -2] <- x) |> Assert.Throws |> ignore - let invalidIndexingAccessR = fun() -> A.[5, 2] |> ignore - let invalidIndexingAccessC = fun() -> A.[1, 6] |> ignore - let invalidIndexingAccessRC = fun() -> A.[7, 12] |> ignore + [] + let ``Indexed get operator throws exception for negative indices`` (a : Matrix4) = + (fun() -> a.[-1, 2] |> ignore) |> Assert.Throws |> ignore + (fun() -> a.[1, -2] |> ignore) |> Assert.Throws |> ignore + (fun() -> a.[-1, -2] |> ignore) |> Assert.Throws |> ignore - Assert.Throws(invalidIndexingAssignmentR) |> ignore - Assert.Throws(invalidIndexingAssignmentC) |> ignore - Assert.Throws(invalidIndexingAssignmentRC) |> ignore + [] + let ``Indexed set operator throws exception for large indices`` (a : Matrix4, x : float32) = + let mutable b = a + (fun() -> b.[5, 2] <- x) |> Assert.Throws |> ignore + (fun() -> b.[1, 6] <- x) |> Assert.Throws |> ignore + (fun() -> b.[7, 12] <- x) |> Assert.Throws |> ignore - Assert.Throws(invalidIndexingAccessR) |> ignore - Assert.Throws(invalidIndexingAccessC) |> ignore - Assert.Throws(invalidIndexingAccessRC) |> ignore + [] + let ``Indexed get operator throws exception for large indices`` (a : Matrix4) = + (fun() -> a.[5, 2] |> ignore) |> Assert.Throws |> ignore + (fun() -> a.[1, 6] |> ignore) |> Assert.Throws |> ignore + (fun() -> a.[7, 12] |> ignore) |> Assert.Throws |> ignore [ |])>] module ``Row and column properties`` = diff --git a/tests/OpenTK.Tests/Vector2Tests.fs b/tests/OpenTK.Tests/Vector2Tests.fs index 5cddb74..3a3c3bd 100644 --- a/tests/OpenTK.Tests/Vector2Tests.fs +++ b/tests/OpenTK.Tests/Vector2Tests.fs @@ -22,14 +22,29 @@ module Vector2 = let v = Vector2(x,y) Assert.Equal(x,v.X) Assert.Equal(y,v.Y) - - //[] - // disabled - behaviour needs discussion - let ``Clamping works for each component`` (a : Vector2,b : Vector2,c : Vector2) = - let inline clamp (value : float32) minV maxV = MathHelper.Clamp(value,minV,maxV) - let r = Vector2.Clamp(a,b,c) - Assert.Equal(clamp a.X b.X c.X,r.X) - Assert.Equal(clamp a.Y b.Y c.Y,r.Y) + + [ |])>] + module Clamping = + // + [] + let ``Clamping one vector between two other vectors clamps all components between corresponding components`` (a : Vector2, b : Vector2, w : Vector2) = + let res = Vector2.Clamp(w, a, b) + + let expX = if w.X < a.X then a.X else if w.X > b.X then b.X else w.X + let expY = if w.Y < a.Y then a.Y else if w.Y > b.Y then b.Y else w.Y + + Assert.Equal(expX, res.X) + Assert.Equal(expY, res.Y) + + [] + let ``Clamping one vector between two other vectors by reference clamps all components`` (a : Vector2, b : Vector2, w : Vector2) = + let res = Vector2.Clamp(ref w, ref a, ref b) + + let expX = if w.X < a.X then a.X else if w.X > b.X then b.X else w.X + let expY = if w.Y < a.Y then a.Y else if w.Y > b.Y then b.Y else w.Y + + Assert.Equal(expX, res.X) + Assert.Equal(expY, res.Y) [ |])>] module Length = @@ -81,28 +96,35 @@ module Vector2 = module Indexing = // [] - let ``Index operators work for the correct components`` (x,y) = - let v = Vector2(x,y) - Assert.Equal(v.[0],v.X) - Assert.Equal(v.[1],v.Y) + let ``Index operator accesses the correct components`` (x, y) = + let v = Vector2(x, y) + + Assert.Equal(x, v.[0]) + Assert.Equal(y, v.[1]) [] - let ``Vector indexing throws index out of range exception correctly`` (x, y) = + let ``Indexed set operator throws exception for negative indices`` (x, y) = + let mutable v = Vector2(x, y) + + (fun() -> v.[-1] <- x) |> Assert.Throws |> ignore + + [] + let ``Indexed get operator throws exception for negative indices`` (x, y) = + let mutable v = Vector2(x, y) + + (fun() -> v.[-1] |> ignore) |> Assert.Throws |> ignore + + [] + let ``Indexed set operator throws exception for large indices`` (x, y) = let mutable v = Vector2(x, y) - let invalidIndexingAccess = fun() -> v.[2] |> ignore - Assert.Throws(invalidIndexingAccess) |> ignore - let invalidIndexingAssignment = (fun() -> v.[2] <- x) - Assert.Throws(invalidIndexingAssignment) |> ignore - + (fun() -> v.[2] <- x) |> Assert.Throws |> ignore + [] - let ``Component assignment by indexing works`` (x, y) = - let mutable v = Vector2() - v.[0] <- x - v.[1] <- y - Assert.Equal(x, v.X) - Assert.Equal(y, v.Y) - + let ``Indexed get operator throws exception for large indices`` (x, y) = + let mutable v = Vector2(x, y) + + (fun() -> v.[2] |> ignore) |> Assert.Throws |> ignore [ |])>] module ``Simple Properties`` = @@ -235,14 +257,13 @@ module Vector2 = // [] let ``Vector2-float division is the same as component-float division`` (a : Vector2, f : float32) = - if not (approxEq f 0.0f) then // we don't support diving by zero. - let r = a / f - - Assert.ApproximatelyEqual(a.X / f,r.X) - Assert.ApproximatelyEqual(a.Y / f,r.Y) + let r = a / f + + Assert.ApproximatelyEqual(a.X / f,r.X) + Assert.ApproximatelyEqual(a.Y / f,r.Y) [] - let ``Static Vector2-Vector2 division method works`` (a : Vector2, b : Vector2) = + let ``Static Vector2-Vector2 division method is the same as component division`` (a : Vector2, b : Vector2) = let v1 = Vector2(a.X / b.X, a.Y / b.Y) let sum = Vector2.Divide(a, b) @@ -250,7 +271,7 @@ module Vector2 = Assert.ApproximatelyEqual(v1, sum) [] - let ``Static Vector2-Vector2 divison method works by reference`` (a : Vector2, b : Vector2) = + let ``Static Vector2-Vector2 divison method by reference `` (a : Vector2, b : Vector2) = let v1 = Vector2(a.X / b.X, a.Y / b.Y) let sum = Vector2.Divide(ref a, ref b) @@ -258,7 +279,7 @@ module Vector2 = Assert.ApproximatelyEqual(v1, sum) [] - let ``Static Vector2-scalar division method works`` (a : Vector2, b : float32) = + let ``Static Vector2-scalar division method is the same as component division`` (a : Vector2, b : float32) = let v1 = Vector2(a.X / b, a.Y / b) let sum = Vector2.Divide(a, b) @@ -266,7 +287,7 @@ module Vector2 = Assert.ApproximatelyEqual(v1, sum) [] - let ``Static Vector2-scalar divison method works by reference`` (a : Vector2, b : float32) = + let ``Static Vector2-scalar divison method by reference is the same as component division`` (a : Vector2, b : float32) = let v1 = Vector2(a.X / b, a.Y / b) let sum = Vector2.Divide(ref a, b) @@ -277,7 +298,7 @@ module Vector2 = module Negation = // [] - let ``Vector negation operator works`` (x, y) = + let ``Vector negation operator negates all components`` (x, y) = let v = Vector2(x, y) let vNeg = -v Assert.Equal(-x, vNeg.X) @@ -287,7 +308,7 @@ module Vector2 = module Equality = // [] - let ``Vector equality operator works`` (x, y) = + let ``Vector equality operator is by component`` (x, y) = let v1 = Vector2(x, y) let v2 = Vector2(x, y) let equality = v1 = v2 @@ -295,7 +316,7 @@ module Vector2 = Assert.True(equality) [] - let ``Vector inequality operator works`` (x, y) = + let ``Vector inequality operator is by component`` (x, y) = let v1 = Vector2(x, y) let v2 = Vector2(x + (float32)1 , y + (float32)1) let inequality = v1 <> v2 @@ -303,7 +324,7 @@ module Vector2 = Assert.True(inequality) [] - let ``Vector equality method works`` (x, y) = + let ``Vector equality method is by component`` (x, y) = let v1 = Vector2(x, y) let v2 = Vector2(x, y) let notVector = Matrix2() @@ -318,7 +339,7 @@ module Vector2 = module Swizzling = // [] - let ``Vector swizzling works`` (x, y) = + let ``Vector swizzling returns the correct composites`` (x, y) = let v1 = Vector2(x, y) let v2 = Vector2(y, x) @@ -329,7 +350,7 @@ module Vector2 = module Interpolation = // [] - let ``Linear interpolation works`` (a : Vector2, b : Vector2, q) = + let ``Linear interpolation is by component`` (a : Vector2, b : Vector2, q) = let blend = q @@ -343,7 +364,7 @@ module Vector2 = Assert.Equal(vExp, vRes) [] - let ``Barycentric interpolation works`` (a : Vector2, b : Vector2, c : Vector2, u, v) = + let ``Barycentric interpolation follows the barycentric formula`` (a : Vector2, b : Vector2, c : Vector2, u, v) = let r = a + u * (b - a) + v * (c - a) @@ -356,7 +377,7 @@ module Vector2 = module ``Vector products`` = // [] - let ``Dot product works`` (a : Vector2, b : Vector2) = + let ``Dot product follows the dot product formula`` (a : Vector2, b : Vector2) = let dot = a.X * b.X + a.Y * b.Y Assert.Equal(dot, Vector2.Dot(a, b)); @@ -365,19 +386,19 @@ module Vector2 = Assert.Equal(dot, vRes) [] - let ``Perpendicular dot product works`` (a : Vector2, b : Vector2) = - let dot = a.X * b.Y - a.Y * b.X + let ``Perpendicular dot product follows the perpendicular dot product formula`` (a : Vector2, b : Vector2) = + let perpDot = a.X * b.Y - a.Y * b.X - Assert.Equal(dot, Vector2.PerpDot(a, b)); + Assert.Equal(perpDot, Vector2.PerpDot(a, b)); let vRes = Vector2.PerpDot(ref a, ref b) - Assert.Equal(dot, vRes) + Assert.Equal(perpDot, vRes) [ |])>] module Normalization = // [] - let ``Normalization of instance, creating a new vector, works`` (a, b) = + let ``Normalization creates a new unit length vector with the correct components`` (a, b) = let v = Vector2(a, b) let l = v.Length @@ -389,7 +410,7 @@ module Vector2 = Assert.ApproximatelyEqual(v.Y / l, norm.Y) [] - let ``Normalization of instance works`` (a, b) = + let ``Normalization of instance transforms the instance into a unit length vector with the correct components`` (a, b) = let v = Vector2(a, b) let l = v.Length @@ -401,7 +422,7 @@ module Vector2 = Assert.ApproximatelyEqual(v.Y / l, norm.Y) [] - let ``Fast approximate normalization of instance works`` (a, b) = + let ``Fast approximate normalization of instance transforms the instance into a unit length vector with the correct components`` (a, b) = let v = Vector2(a, b) let norm = Vector2(a, b) norm.NormalizeFast() @@ -412,36 +433,32 @@ module Vector2 = Assert.ApproximatelyEqual(v.Y * scale, norm.Y) [] - let ``Normalization by reference works`` (a : Vector2) = - if not (approxEq a.Length 0.0f) then - let scale = 1.0f / a.Length - let norm = Vector2(a.X * scale, a.Y * scale) - let vRes = Vector2.Normalize(ref a) - - Assert.ApproximatelyEqual(norm, vRes) + let ``Normalization by reference is the same as division by magnitude`` (a : Vector2) = + let norm = a / a.Length + let vRes = Vector2.Normalize(ref a) + + Assert.ApproximatelyEqual(norm, vRes) [] - let ``Normalization works`` (a : Vector2) = - if not (approxEq a.Length 0.0f) then - let scale = 1.0f / a.Length - let norm = Vector2(a.X * scale, a.Y * scale) - - Assert.ApproximatelyEqual(norm, Vector2.Normalize(a)); + let ``Normalization is the same as division by magnitude`` (a : Vector2) = + let norm = a / a.Length + + Assert.ApproximatelyEqual(norm, Vector2.Normalize(a)); [] - let ``Fast approximate normalization by reference works`` (a : Vector2) = + let ``Fast approximate normalization by reference is the same as multiplication by the fast inverse square`` (a : Vector2) = let scale = MathHelper.InverseSqrtFast(a.X * a.X + a.Y * a.Y) - let norm = Vector2(a.X * scale, a.Y * scale) + let norm = a * scale let vRes = Vector2.NormalizeFast(ref a) Assert.ApproximatelyEqual(norm, vRes) [] - let ``Fast approximate normalization works`` (a : Vector2) = + let ``Fast approximate normalization is the same as multiplication by the fast inverse square`` (a : Vector2) = let scale = MathHelper.InverseSqrtFast(a.X * a.X + a.Y * a.Y) - let norm = Vector2(a.X * scale, a.Y * scale) + let norm = a * scale Assert.ApproximatelyEqual(norm, Vector2.NormalizeFast(a)); @@ -449,7 +466,7 @@ module Vector2 = module ``Component min and max`` = // [] - let ``Producing a new vector from the smallest components of given vectors works`` (x, y, u, w) = + let ``ComponentMin produces a new vector from the smallest components of the given vectors`` (x, y, u, w) = let v1 = Vector2(x, y) let v2 = Vector2(u, w) @@ -462,7 +479,7 @@ module Vector2 = Assert.True(vMin.Y <= v2.Y) [] - let ``Producing a new vector from the largest components of given vectors works`` (x, y, u, w) = + let ``ComponentMax produces a new vector from the largest components of the given vectors`` (x, y, u, w) = let v1 = Vector2(x, y) let v2 = Vector2(u, w) @@ -475,7 +492,7 @@ module Vector2 = Assert.True(vMax.Y >= v2.Y) [] - let ``Producing a new vector from the smallest components of given vectors by reference works`` (x, y, u, w) = + let ``ComponentMin by reference produces a new vector from the smallest components of the given vectors`` (x, y, u, w) = let v1 = Vector2(x, y) let v2 = Vector2(u, w) @@ -488,7 +505,7 @@ module Vector2 = Assert.True(vMin.Y <= v2.Y) [] - let ``Producing a new vector from the largest components of given vectors by reference works`` (x, y, u, w) = + let ``ComponentMax by reference produces a new vector from the largest components of the given vectors`` (x, y, u, w) = let v1 = Vector2(x, y) let v2 = Vector2(u, w) @@ -501,7 +518,7 @@ module Vector2 = Assert.True(vMax.Y >= v2.Y) [] - let ``Selecting the lesser of two vectors works`` (x, y, u, w) = + let ``Min selects the vector with lesser magnitude given two vectors`` (x, y, u, w) = let v1 = Vector2(x, y) let v2 = Vector2(u, w) @@ -518,7 +535,7 @@ module Vector2 = Assert.True(equalsLast) [] - let ``Selecting the greater of two vectors works`` (x, y, u, w) = + let ``Max selects the vector with greater magnitude given two vectors`` (x, y, u, w) = let v1 = Vector2(x, y) let v2 = Vector2(u, w) @@ -533,29 +550,6 @@ module Vector2 = else let equalsLast = vMin = v2 Assert.True(equalsLast) - - [ |])>] - module Clamping = - // - [] - let ``Clamping one vector between two other vectors works`` (a : Vector2, b : Vector2, w : Vector2) = - let res = Vector2.Clamp(w, a, b) - - let expX = if w.X < a.X then a.X else if w.X > b.X then b.X else w.X - let expY = if w.Y < a.Y then a.Y else if w.Y > b.Y then b.Y else w.Y - - Assert.Equal(expX, res.X) - Assert.Equal(expY, res.Y) - - [] - let ``Clamping one vector between two other vectors works by reference`` (a : Vector2, b : Vector2, w : Vector2) = - let res = Vector2.Clamp(ref w, ref a, ref b) - - let expX = if w.X < a.X then a.X else if w.X > b.X then b.X else w.X - let expY = if w.Y < a.Y then a.Y else if w.Y > b.Y then b.Y else w.Y - - Assert.Equal(expX, res.X) - Assert.Equal(expY, res.Y) [ |])>] module Transformation = diff --git a/tests/OpenTK.Tests/Vector3Tests.fs b/tests/OpenTK.Tests/Vector3Tests.fs index 87b2dc9..81edaa2 100644 --- a/tests/OpenTK.Tests/Vector3Tests.fs +++ b/tests/OpenTK.Tests/Vector3Tests.fs @@ -69,52 +69,56 @@ module Vector3 = module Indexing = // [] - let ``Index operator accesses the correct components`` (a, b, c) = - let v = Vector3(a, b, c) + let ``Index operator accesses the correct components`` (x, y, z) = + let v = Vector3(x, y, z) - Assert.Equal(a, v.[0]) - Assert.Equal(b, v.[1]) - Assert.Equal(c, v.[2]) + Assert.Equal(x, v.[0]) + Assert.Equal(y, v.[1]) + Assert.Equal(z, v.[2]) [] - let ``Index operator throws exception for negative indices`` (a, b, c) = - let mutable v = Vector3(a, b, c) - - let invalidIndexingAccess = fun() -> v.[-1] |> ignore - let invalidIndexingAssignment = fun() -> v.[-1] <- a + let ``Indexed set operator throws exception for negative indices`` (x, y, z) = + let mutable v = Vector3(x, y, z) + + (fun() -> v.[-1] <- x) |> Assert.Throws |> ignore + + [] + let ``Indexed get operator throws exception for negative indices`` (x, y, z) = + let mutable v = Vector3(x, y, z) - Assert.Throws(invalidIndexingAccess) |> ignore - Assert.Throws(invalidIndexingAssignment) |> ignore + (fun() -> v.[-1] |> ignore) |> Assert.Throws |> ignore + + [] + let ``Indexed set operator throws exception for large indices`` (x, y, z) = + let mutable v = Vector3(x, y, z) + + (fun() -> v.[4] <- x) |> Assert.Throws |> ignore [] - let ``Index operator throws exception for large indices`` (a, b, c) = - let mutable v = Vector3(a, b, c) + let ``Indexed get operator throws exception for large indices`` (x, y, z) = + let mutable v = Vector3(x, y, z) - let invalidIndexingAccess = fun() -> v.[3] |> ignore - let invalidIndexingAssignment = fun() -> v.[3] <- a - - Assert.Throws(invalidIndexingAccess) |> ignore - Assert.Throws(invalidIndexingAssignment) |> ignore + (fun() -> v.[4] |> ignore) |> Assert.Throws |> ignore [ |])>] module Length = // [] - let ``Length method works`` (a, b, c) = + let ``Length method follows the pythagorean theorem`` (a, b, c) = let v = Vector3(a, b, c) let l = System.Math.Sqrt((float)(a * a + b * b + c * c)) Assert.Equal((float32)l, v.Length) [] - let ``Fast length method works`` (a, b, c) = + let ``Fast length method is the same as one divided by the fast inverse square`` (a, b, c) = let v = Vector3(a, b, c) let l = 1.0f / MathHelper.InverseSqrtFast(a * a + b * b + c * c) Assert.Equal(l, v.LengthFast) [] - let ``Length squared method works`` (a, b, c) = + let ``Length squared method returns each component squared and summed`` (a, b, c) = let v = Vector3(a, b, c) let lsq = a * a + b * b + c * c @@ -124,7 +128,7 @@ module Vector3 = module Normalization = // [] - let ``Normalization of instance, creating a new vector, works`` (a, b, c) = + let ``Normalization creates a new unit length vector with the correct components`` (a, b, c) = let v = Vector3(a, b, c) let l = v.Length @@ -137,22 +141,20 @@ module Vector3 = Assert.ApproximatelyEqual(v.Z / l, norm.Z) [] - let ``Normalization of instance works`` (a, b, c) = + let ``Normalization of instance transforms the instance into a unit length vector with the correct components`` (a, b, c) = let v = Vector3(a, b, c) let l = v.Length if not (approxEq l 0.0f) then let norm = Vector3(a, b, c) norm.Normalize() - - - + Assert.ApproximatelyEqual(v.X / l, norm.X) Assert.ApproximatelyEqual(v.Y / l, norm.Y) Assert.ApproximatelyEqual(v.Z / l, norm.Z) [] - let ``Fast approximate normalization of instance works`` (a, b, c) = + let ``Fast approximate normalization of instance transforms the instance into a unit length vector with the correct components`` (a, b, c) = let v = Vector3(a, b, c) let norm = Vector3(a, b, c) norm.NormalizeFast() @@ -164,36 +166,32 @@ module Vector3 = Assert.ApproximatelyEqual(v.Z * scale, norm.Z) [] - let ``Normalization by reference works`` (a : Vector3) = - if not (approxEq a.Length 0.0f) then - let scale = 1.0f / a.Length - let norm = Vector3(a.X * scale, a.Y * scale, a.Z * scale) - let vRes = Vector3.Normalize(ref a) - - Assert.ApproximatelyEqual(norm, vRes) + let ``Normalization by reference is the same as division by magnitude`` (a : Vector3) = + let norm = a / a.Length + let vRes = Vector3.Normalize(ref a) + + Assert.ApproximatelyEqual(norm, vRes) [] - let ``Normalization works`` (a : Vector3) = - if not (approxEq a.Length 0.0f) then - let scale = 1.0f / a.Length - let norm = Vector3(a.X * scale, a.Y * scale, a.Z * scale) - - Assert.ApproximatelyEqual(norm, Vector3.Normalize(a)); + let ``Normalization is the same as division by magnitude`` (a : Vector3) = + let norm = a / a.Length + + Assert.ApproximatelyEqual(norm, Vector3.Normalize(a)); [] - let ``Fast approximate normalization by reference works`` (a : Vector3) = + let ``Fast approximate normalization by reference is the same as multiplication by the fast inverse square`` (a : Vector3) = let scale = MathHelper.InverseSqrtFast(a.X * a.X + a.Y * a.Y + a.Z * a.Z) - let norm = Vector3(a.X * scale, a.Y * scale, a.Z * scale) + let norm = a * scale let vRes = Vector3.NormalizeFast(ref a) Assert.ApproximatelyEqual(norm, vRes) [] - let ``Fast approximate normalization works`` (a : Vector3) = + let ``Fast approximate normalization is the same as multiplication by fast inverse square`` (a : Vector3) = let scale = MathHelper.InverseSqrtFast(a.X * a.X + a.Y * a.Y + a.Z * a.Z) - let norm = Vector3(a.X * scale, a.Y * scale, a.Z * scale) + let norm = a * scale Assert.ApproximatelyEqual(norm, Vector3.NormalizeFast(a)); @@ -307,7 +305,7 @@ module Vector3 = Assert.Equal(a.Z * f,r.Z) [] - let ``Vector3-Matrix3 multiplication works for right-handed notation`` (a : Matrix3, b : Vector3) = + let ``Vector3-Matrix3 multiplication using right-handed notation is the same as vector/row multiplication and summation`` (a : Matrix3, b : Vector3) = let res = a*b let c1 = b.X * a.M11 + b.Y * a.M12 + b.Z * a.M13 @@ -319,7 +317,7 @@ module Vector3 = Assert.Equal(exp, res) [] - let ``Vector3-Matrix3 multiplication works for left-handed notation`` (a : Matrix3, b : Vector3) = + let ``Vector3-Matrix3 multiplication using left-handed notation is the same as vector/column multiplication and summation`` (a : Matrix3, b : Vector3) = let res = b*a let c1 = b.X * a.M11 + b.Y * a.M21 + b.Z * a.M31 @@ -359,7 +357,7 @@ module Vector3 = Assert.ApproximatelyEqual(a.Z / f,r.Z) [] - let ``Static Vector3-Vector3 division method works`` (a : Vector3, b : Vector3) = + let ``Static Vector3-Vector3 division method is the same as component division`` (a : Vector3, b : Vector3) = let v1 = Vector3(a.X / b.X, a.Y / b.Y, a.Z / b.Z) let sum = Vector3.Divide(a, b) @@ -367,7 +365,7 @@ module Vector3 = Assert.ApproximatelyEqual(v1, sum) [] - let ``Static Vector3-Vector3 divison method works by reference`` (a : Vector3, b : Vector3) = + let ``Static Vector3-Vector3 divison method by reference is the same as component division`` (a : Vector3, b : Vector3) = let v1 = Vector3(a.X / b.X, a.Y / b.Y, a.Z / b.Z) let sum = Vector3.Divide(ref a, ref b) @@ -375,7 +373,7 @@ module Vector3 = Assert.ApproximatelyEqual(v1, sum) [] - let ``Static Vector3-scalar division method works`` (a : Vector3, b : float32) = + let ``Static Vector3-scalar division method is the same as component division`` (a : Vector3, b : float32) = let v1 = Vector3(a.X / b, a.Y / b, a.Z / b) let sum = Vector3.Divide(a, b) @@ -383,7 +381,7 @@ module Vector3 = Assert.ApproximatelyEqual(v1, sum) [] - let ``Static Vector3-scalar divison method works by reference`` (a : Vector3, b : float32) = + let ``Static Vector3-scalar divison method by reference is the same as component division`` (a : Vector3, b : float32) = let v1 = Vector3(a.X / b, a.Y / b, a.Z / b) let sum = Vector3.Divide(ref a, b) @@ -394,7 +392,7 @@ module Vector3 = module Negation = // [] - let ``Vector negation operator works`` (x, y, z) = + let ``Vector negation operator negates all components`` (x, y, z) = let v = Vector3(x, y, z) let vNeg = -v Assert.Equal(-x, vNeg.X) @@ -405,7 +403,7 @@ module Vector3 = module Equality = // [] - let ``Vector equality operator works`` (x, y, z) = + let ``Vector equality operator is by component`` (x, y, z) = let v1 = Vector3(x, y, z) let v2 = Vector3(x, y, z) let equality = v1 = v2 @@ -413,7 +411,7 @@ module Vector3 = Assert.True(equality) [] - let ``Vector inequality operator works`` (x, y, z) = + let ``Vector inequality operator is by component`` (x, y, z) = let v1 = Vector3(x, y, z) let v2 = Vector3(x + (float32)1 , y + (float32)1, z + (float32)1) let inequality = v1 <> v2 @@ -421,7 +419,7 @@ module Vector3 = Assert.True(inequality) [] - let ``Vector equality method works`` (x, y, z) = + let ``Vector equality method is by component`` (x, y, z) = let v1 = Vector3(x, y, z) let v2 = Vector3(x, y, z) let notVector = Matrix2() @@ -436,7 +434,7 @@ module Vector3 = module Swizzling = // [] - let ``Vector swizzling works`` (x, y, z) = + let ``Vector swizzling returns the correct composite for X-primary components`` (x, y, z) = let v = Vector3(x, y, z) let xyz = Vector3(x, y, z) @@ -444,26 +442,34 @@ module Vector3 = let xy = Vector2(x, y) let xz = Vector2(x, z) - let yxz = Vector3(y, x, z) - let yzx = Vector3(y, z, x) - let yx = Vector2(y, x) - let yz = Vector2(y, z) - - let zxy = Vector3(z, x, y) - let zyx = Vector3(z, y, x) - let zx = Vector2(z, x) - let zy = Vector2(z, y) - Assert.Equal(xyz, v); Assert.Equal(xzy, v.Xzy); Assert.Equal(xy, v.Xy); Assert.Equal(xz, v.Xz); + [] + let ``Vector swizzling returns the correct composite for Y-primary components`` (x, y, z) = + let v = Vector3(x, y, z) + + let yxz = Vector3(y, x, z) + let yzx = Vector3(y, z, x) + let yx = Vector2(y, x) + let yz = Vector2(y, z) + Assert.Equal(yxz, v.Yxz); Assert.Equal(yzx, v.Yzx); Assert.Equal(yx, v.Yx); Assert.Equal(yz, v.Yz); + [] + let ``Vector swizzling returns the correct composite for Z-primary components`` (x, y, z) = + let v = Vector3(x, y, z) + + let zxy = Vector3(z, x, y) + let zyx = Vector3(z, y, x) + let zx = Vector2(z, x) + let zy = Vector2(z, y); + Assert.Equal(zxy, v.Zxy); Assert.Equal(zyx, v.Zyx); Assert.Equal(zx, v.Zx); @@ -473,7 +479,7 @@ module Vector3 = module Interpolation = // [] - let ``Linear interpolation works`` (a : Vector3, b : Vector3, q) = + let ``Linear interpolation is by component`` (a : Vector3, b : Vector3, q) = let blend = q @@ -488,7 +494,7 @@ module Vector3 = Assert.Equal(vExp, vRes) [] - let ``Barycentric interpolation works`` (a : Vector3, b : Vector3, c : Vector3, u, v) = + let ``Barycentric interpolation follows the barycentric formula`` (a : Vector3, b : Vector3, c : Vector3, u, v) = let r = a + u * (b - a) + v * (c - a) @@ -501,7 +507,7 @@ module Vector3 = module ``Vector products`` = // [] - let ``Dot product works`` (a : Vector3, b : Vector3) = + let ``Dot product follows the dot product formula`` (a : Vector3, b : Vector3) = let dot = a.X * b.X + a.Y * b.Y + a.Z * b.Z Assert.Equal(dot, Vector3.Dot(a, b)); @@ -510,7 +516,7 @@ module Vector3 = Assert.Equal(dot, vRes) [] - let ``Cross product works`` (a : Vector3, b : Vector3) = + let ``Cross product follows the cross product formula`` (a : Vector3, b : Vector3) = let crossX = a.Y * b.Z - a.Z * b.Y let crossY = a.Z * b.X - a.X * b.Z let crossZ = a.X * b.Y - a.Y * b.X @@ -525,7 +531,7 @@ module Vector3 = module ``Component min and max`` = // [] - let ``Producing a new vector from the smallest components of given vectors works`` (x, y, z, u, w, q) = + let ``ComponentMin produces a new vector from the smallest components of the given vectors`` (x, y, z, u, w, q) = let v1 = Vector3(x, y, z) let v2 = Vector3(u, w, q) @@ -541,7 +547,7 @@ module Vector3 = Assert.True(vMin.Z <= v2.Z) [] - let ``Producing a new vector from the largest components of given vectors works`` (x, y, z, u, w, q) = + let ``ComponentMax producing a new vector from the largest components of the given vectors`` (x, y, z, u, w, q) = let v1 = Vector3(x, y, z) let v2 = Vector3(u, w, q) @@ -557,7 +563,7 @@ module Vector3 = Assert.True(vMax.Z >= v2.Z) [] - let ``Producing a new vector from the smallest components of given vectors by reference works`` (x, y, z, u, w, q) = + let ``ComponentMin by reference produces a new vector from the smallest components of the given vectors`` (x, y, z, u, w, q) = let v1 = Vector3(x, y, z) let v2 = Vector3(u, w, q) @@ -573,7 +579,7 @@ module Vector3 = Assert.True(vMin.Z <= v2.Z) [] - let ``Producing a new vector from the largest components of given vectors by reference works`` (x, y, z, u, w, q) = + let ``ComponentMax produces a new vector from the smallest components of the given vectors`` (x, y, z, u, w, q) = let v1 = Vector3(x, y, z) let v2 = Vector3(u, w, q) @@ -589,7 +595,7 @@ module Vector3 = Assert.True(vMax.Z >= v2.Z) [] - let ``Selecting the lesser of two vectors works`` (x, y, z, u, w, q) = + let ``Min selects the vector with lesser magnitude given two vectors`` (x, y, z, u, w, q) = let v1 = Vector3(x, y, z) let v2 = Vector3(u, w, q) @@ -606,7 +612,7 @@ module Vector3 = Assert.True(equalsLast) [] - let ``Selecting the greater of two vectors works`` (x, y, z, u, w, q) = + let ``Max selects the vector with greater magnitude given two vectors`` (x, y, z, u, w, q) = let v1 = Vector3(x, y, z) let v2 = Vector3(u, w, q) @@ -626,7 +632,7 @@ module Vector3 = module Clamping = // [] - let ``Clamping one vector between two other vectors works`` (a : Vector3, b : Vector3, w : Vector3) = + let ``Clamping one vector between two other vectors clamps all components between corresponding components`` (a : Vector3, b : Vector3, w : Vector3) = let res = Vector3.Clamp(w, a, b) let expX = if w.X < a.X then a.X else if w.X > b.X then b.X else w.X @@ -638,7 +644,7 @@ module Vector3 = Assert.Equal(expZ, res.Z) [] - let ``Clamping one vector between two other vectors works by reference`` (a : Vector3, b : Vector3, w : Vector3) = + let ``Clamping one vector between two other vectors by reference clamps all components between corresponding components`` (a : Vector3, b : Vector3, w : Vector3) = let res = Vector3.Clamp(ref w, ref a, ref b) let expX = if w.X < a.X then a.X else if w.X > b.X then b.X else w.X diff --git a/tests/OpenTK.Tests/Vector4Tests.fs b/tests/OpenTK.Tests/Vector4Tests.fs index b0b9c3a..877e174 100644 --- a/tests/OpenTK.Tests/Vector4Tests.fs +++ b/tests/OpenTK.Tests/Vector4Tests.fs @@ -57,6 +57,20 @@ module Vector4 = Assert.Equal((float32)0, v2.W) [] + let ``Vector3 value and scalar constructor sets all components to the correct values`` (x, y, z, w) = + let v1 = Vector3(x, y, z) + let v2 = Vector4(v1, w) + + Assert.Equal(v1.X, v2.X) + Assert.Equal(v1.Y, v2.Y) + Assert.Equal(v1.Z, v2.Z) + + Assert.Equal(x, v2.X) + Assert.Equal(y, v2.Y) + Assert.Equal(z, v2.Z) + Assert.Equal(w, v2.W) + + [] let ``Vector4 value constructor sets all components to the correct values`` (x, y, z, w) = let v1 = Vector4(x, y, z, w) let v2 = Vector4(v1) @@ -84,44 +98,48 @@ module Vector4 = Assert.Equal(w, v.[3]) [] - let ``Index operator throws exception for negative indices`` (x, y, z, w) = + let ``Indexed set operator throws exception for negative indices`` (x, y, z, w) = + let mutable v = Vector4(x, y, z, w) + + (fun() -> v.[-1] <- x) |> Assert.Throws |> ignore + + [] + let ``Indexed get operator throws exception for negative indices`` (x, y, z, w) = let mutable v = Vector4(x, y, z, w) - - let invalidIndexingAccess = fun() -> v.[-1] |> ignore - let invalidIndexingAssignment = fun() -> v.[-1] <- x - Assert.Throws(invalidIndexingAccess) |> ignore - Assert.Throws(invalidIndexingAssignment) |> ignore + (fun() -> v.[-1] |> ignore) |> Assert.Throws |> ignore + + [] + let ``Indexed set operator throws exception for large indices`` (x, y, z, w) = + let mutable v = Vector4(x, y, z, w) + + (fun() -> v.[4] <- x) |> Assert.Throws |> ignore [] - let ``Index operator throws exception for large indices`` (x, y, z, w) = + let ``Indexed get operator throws exception for large indices`` (x, y, z, w) = let mutable v = Vector4(x, y, z, w) - let invalidIndexingAccess = fun() -> v.[4] |> ignore - let invalidIndexingAssignment = fun() -> v.[4] <- x - - Assert.Throws(invalidIndexingAccess) |> ignore - Assert.Throws(invalidIndexingAssignment) |> ignore + (fun() -> v.[4] |> ignore) |> Assert.Throws |> ignore [ |])>] module Length = // [] - let ``Length method works`` (x, y, z, w) = + let ``Length method follows the pythagorean theorem`` (x, y, z, w) = let v = Vector4(x, y, z, w) let l = System.Math.Sqrt((float)(x * x + y * y + z * z + w * w)) Assert.Equal((float32)l, v.Length) [] - let ``Fast length method works`` (x, y, z, w) = + let ``Fast length method is the same as one divided by the fast inverse square`` (x, y, z, w) = let v = Vector4(x, y, z, w) let l = 1.0f / MathHelper.InverseSqrtFast(x * x + y * y + z * z + w * w) Assert.Equal(l, v.LengthFast) [] - let ``Length squared method works`` (x, y, z, w) = + let ``Length squared method returns each component squared and summed`` (x, y, z, w) = let v = Vector4(x, y, z, w) let lsq = x * x + y * y + z * z + w * w @@ -131,35 +149,32 @@ module Vector4 = module Normalization = // [] - let ``Normalization of instance, creating a new vector, works`` (x, y, z, w) = + let ``Normalization creates a new unit length vector with the correct components`` (x, y, z, w) = let v = Vector4(x, y, z, w) let l = v.Length - - // Dividing by zero is not supported - if not (approxEq l 0.0f) then - let norm = v.Normalized() - - Assert.ApproximatelyEqual(v.X / l, norm.X) - Assert.ApproximatelyEqual(v.Y / l, norm.Y) - Assert.ApproximatelyEqual(v.Z / l, norm.Z) - Assert.ApproximatelyEqual(v.W / l, norm.W) + + let norm = v.Normalized() + + Assert.ApproximatelyEqual(v.X / l, norm.X) + Assert.ApproximatelyEqual(v.Y / l, norm.Y) + Assert.ApproximatelyEqual(v.Z / l, norm.Z) + Assert.ApproximatelyEqual(v.W / l, norm.W) [] - let ``Normalization of instance works`` (x, y, z, w) = + let ``Normalization of instance transforms the instance into a unit length vector with the correct components`` (x, y, z, w) = let v = Vector4(x, y, z, w) let l = v.Length - - if not (approxEq l 0.0f) then - let norm = Vector4(x, y, z, w) - norm.Normalize() - - Assert.ApproximatelyEqual(v.X / l, norm.X) - Assert.ApproximatelyEqual(v.Y / l, norm.Y) - Assert.ApproximatelyEqual(v.Z / l, norm.Z) - Assert.ApproximatelyEqual(v.W / l, norm.W) + + let norm = Vector4(x, y, z, w) + norm.Normalize() + + Assert.ApproximatelyEqual(v.X / l, norm.X) + Assert.ApproximatelyEqual(v.Y / l, norm.Y) + Assert.ApproximatelyEqual(v.Z / l, norm.Z) + Assert.ApproximatelyEqual(v.W / l, norm.W) [] - let ``Fast approximate normalization of instance works`` (x, y, z, w) = + let ``Fast approximate normalization of instance transforms the instance into a unit length vector with the correct components`` (x, y, z, w) = let v = Vector4(x, y, z, w) let norm = Vector4(x, y, z, w) norm.NormalizeFast() @@ -171,37 +186,33 @@ module Vector4 = Assert.ApproximatelyEqual(v.Z * scale, norm.Z) Assert.ApproximatelyEqual(v.W * scale, norm.W) - [] // TODO: Eliminate coefficient calculation, rounding error - let ``Normalization by reference works`` (a : Vector4) = - if not (approxEq a.Length 0.0f) then - let scale = 1.0f / a.Length - let norm = Vector4(a.X * scale, a.Y * scale, a.Z * scale, a.W * scale) - let vRes = Vector4.Normalize(ref a) - - Assert.ApproximatelyEqual(norm, vRes) + [] + let ``Normalization by reference is the same as division by magnitude`` (a : Vector4) = + let norm = a / a.Length + let vRes = Vector4.Normalize(ref a) - [] // TODO: Eliminate coefficient calculation, rounding error - let ``Normalization works`` (a : Vector4) = - if not (approxEq a.Length 0.0f) then - let scale = 1.0f / a.Length - let norm = Vector4(a.X * scale, a.Y * scale, a.Z * scale, a.W * scale) - - Assert.ApproximatelyEqual(norm, Vector4.Normalize(a)); + Assert.ApproximatelyEqual(norm, vRes) [] - let ``Fast approximate normalization by reference works`` (a : Vector4) = + let ``Normalization is the same as division by magnitude`` (a : Vector4) = + let norm = a / a.Length + + Assert.ApproximatelyEqual(norm, Vector4.Normalize(a)); + + [] + let ``Fast approximate normalization by reference is the same as multiplication by the fast inverse square`` (a : Vector4) = let scale = MathHelper.InverseSqrtFast(a.X * a.X + a.Y * a.Y + a.Z * a.Z + a.W * a.W) - let norm = Vector4(a.X * scale, a.Y * scale, a.Z * scale, a.W * scale) + let norm = a * scale let vRes = Vector4.NormalizeFast(ref a) Assert.ApproximatelyEqual(norm, vRes) [] - let ``Fast approximate normalization works`` (a : Vector4) = + let ``Fast approximate normalization is the same as multiplication by the fast inverse square`` (a : Vector4) = let scale = MathHelper.InverseSqrtFast(a.X * a.X + a.Y * a.Y + a.Z * a.Z + a.W * a.W) - let norm = Vector4(a.X * scale, a.Y * scale, a.Z * scale, a.W * scale) + let norm = a * scale Assert.ApproximatelyEqual(norm, Vector4.NormalizeFast(a)); @@ -322,7 +333,7 @@ module Vector4 = Assert.Equal(a.W * f,r.W) [] - let ``Vector4-Matrix4 multiplication works for right-handed notation`` (a : Matrix4, b : Vector4) = + let ``Vector4-Matrix4 multiplication using right-handed notation is the same as vector/row multiplication and summation`` (a : Matrix4, b : Vector4) = let res = a*b let c1 = b.X * a.M11 + b.Y * a.M12 + b.Z * a.M13 + b.W * a.M14 @@ -335,7 +346,7 @@ module Vector4 = Assert.Equal(exp, res) [] - let ``Vector4-Matrix4 multiplication works for left-handed notation`` (a : Matrix4, b : Vector4) = + let ``Vector4-Matrix4 multiplication using left-handed notation is the same as vector/column multiplication and summation`` (a : Matrix4, b : Vector4) = let res = b*a let c1 = b.X * a.M11 + b.Y * a.M21 + b.Z * a.M31 + b.W * a.M41 @@ -377,7 +388,7 @@ module Vector4 = Assert.ApproximatelyEqual(a.W / f, r.W) [] - let ``Static Vector4-Vector4 division method works`` (a : Vector4, b : Vector4) = + let ``Static Vector4-Vector4 division method is the same as component division`` (a : Vector4, b : Vector4) = let v1 = Vector4(a.X / b.X, a.Y / b.Y, a.Z / b.Z, a.W / b.W) let sum = Vector4.Divide(a, b) @@ -385,7 +396,7 @@ module Vector4 = Assert.ApproximatelyEqual(v1, sum) [] - let ``Static Vector4-Vector4 divison method works by reference`` (a : Vector4, b : Vector4) = + let ``Static Vector4-Vector4 divison method by reference is the same as component division`` (a : Vector4, b : Vector4) = let v1 = Vector4(a.X / b.X, a.Y / b.Y, a.Z / b.Z, a.W / b.W) let sum = Vector4.Divide(ref a, ref b) @@ -393,7 +404,7 @@ module Vector4 = Assert.ApproximatelyEqual(v1, sum) [] - let ``Static Vector4-scalar division method works`` (a : Vector4, b : float32) = + let ``Static Vector4-scalar division method is the same as component division`` (a : Vector4, b : float32) = let v1 = Vector4(a.X / b, a.Y / b, a.Z / b, a.W / b) let sum = Vector4.Divide(a, b) @@ -401,7 +412,7 @@ module Vector4 = Assert.ApproximatelyEqual(v1, sum) [] - let ``Static Vector4-scalar divison method works by reference`` (a : Vector4, b : float32) = + let ``Static Vector4-scalar divison method by reference is the same as component division`` (a : Vector4, b : float32) = let v1 = Vector4(a.X / b, a.Y / b, a.Z / b, a.W / b) let sum = Vector4.Divide(ref a, b) @@ -412,7 +423,7 @@ module Vector4 = module Negation = // [] - let ``Vector negation operator works`` (x, y, z, w) = + let ``Vector negation operator negates all components`` (x, y, z, w) = let v = Vector4(x, y, z, w) let vNeg = -v Assert.Equal(-x, vNeg.X) @@ -424,7 +435,7 @@ module Vector4 = module Equality = // [] - let ``Vector equality operator works`` (x, y, z, w) = + let ``Vector equality operator is by component`` (x, y, z, w) = let v1 = Vector4(x, y, z, w) let v2 = Vector4(x, y, z, w) let equality = v1 = v2 @@ -432,7 +443,7 @@ module Vector4 = Assert.True(equality) [] - let ``Vector inequality operator works`` (x, y, z, w) = + let ``Vector inequality operator is by component`` (x, y, z, w) = let v1 = Vector4(x, y, z, w) let v2 = Vector4(x + (float32)1 , y + (float32)1, z + (float32)1, w + (float32)1) let inequality = v1 <> v2 @@ -440,7 +451,7 @@ module Vector4 = Assert.True(inequality) [] - let ``Vector equality method works`` (x, y, z, w) = + let ``Vector equality method is by component`` (x, y, z, w) = let v1 = Vector4(x, y, z, w) let v2 = Vector4(x, y, z, w) let notVector = Matrix2() @@ -451,11 +462,20 @@ module Vector4 = Assert.True(equality) Assert.False(inequalityByOtherType) + [] + let ``Vector equality method returns false for other classes`` (x, y, z, w) = + let v1 = Vector4(x, y, z, w) + let notVector = Matrix2() + + let inequalityByOtherType = v1.Equals(notVector) + + Assert.False(inequalityByOtherType) + [ |])>] module Swizzling = // [] - let ``Vector swizzling works for X-primary components`` (x, y, z, w) = + let ``Vector swizzling returns the correct composite for X-primary components`` (x, y, z, w) = let v = Vector4(x, y, z, w) @@ -497,7 +517,7 @@ module Vector4 = Assert.Equal(xw, v.Xw) [] - let ``Vector swizzling works for Y-primary components`` (x, y, z, w) = + let ``Vector swizzling returns the correct composite for Y-primary components`` (x, y, z, w) = let v = Vector4(x, y, z, w) @@ -543,7 +563,7 @@ module Vector4 = Assert.Equal(yw, v.Yw) [] - let ``Vector swizzling works for Z-primary components`` (x, y, z, w) = + let ``Vector swizzling returns the correct composite for Z-primary components`` (x, y, z, w) = let v = Vector4(x, y, z, w) @@ -587,7 +607,7 @@ module Vector4 = Assert.Equal(zw, v.Zw) [] - let ``Vector swizzling works for W-primary components`` (x, y, z, w) = + let ``Vector swizzling returns the correct composite for W-primary components`` (x, y, z, w) = let v = Vector4(x, y, z, w) @@ -634,7 +654,7 @@ module Vector4 = module Interpolation = // [] - let ``Linear interpolation works`` (a : Vector4, b : Vector4, q) = + let ``Linear interpolation is by component`` (a : Vector4, b : Vector4, q) = let blend = q @@ -650,7 +670,7 @@ module Vector4 = Assert.Equal(vExp, vRes) [] - let ``Barycentric interpolation works`` (a : Vector4, b : Vector4, c : Vector4, u, v) = + let ``Barycentric interpolation follows the barycentric formula`` (a : Vector4, b : Vector4, c : Vector4, u, v) = let r = a + u * (b - a) + v * (c - a) @@ -663,7 +683,7 @@ module Vector4 = module ``Vector products`` = // [] - let ``Dot product works`` (a : Vector4, b : Vector4) = + let ``Dot product method follows the dot product formula`` (a : Vector4, b : Vector4) = let dot = a.X * b.X + a.Y * b.Y + a.Z * b.Z + a.W * b.W Assert.Equal(dot, Vector4.Dot(a, b)); @@ -675,7 +695,7 @@ module Vector4 = module ``Component min and max`` = // [] - let ``Selecting the lesser of two vectors works`` (x, y, z, w, a, b, c, d) = + let ``Min selects the vector with lesser magnitude given two vectors`` (x, y, z, w, a, b, c, d) = let v1 = Vector4(x, y, z, w) let v2 = Vector4(a, b, c, d) @@ -692,7 +712,7 @@ module Vector4 = Assert.True(v2ShorterThanv1) [] - let ``Selecting the greater of two vectors works`` (x, y, z, w, a, b, c, d) = + let ``Max selects the vector with greater magnitude given two vectors`` (x, y, z, w, a, b, c, d) = let v1 = Vector4(x, y, z, w) let v2 = Vector4(a, b, c, d) @@ -712,7 +732,7 @@ module Vector4 = module Clamping = // [] - let ``Clamping one vector between two other vectors works`` (a : Vector4, b : Vector4, w : Vector4) = + let ``Clamping one vector between two other vectors clamps all components between corresponding components`` (a : Vector4, b : Vector4, w : Vector4) = let res = Vector4.Clamp(w, a, b) let expX = if w.X < a.X then a.X else if w.X > b.X then b.X else w.X @@ -726,7 +746,7 @@ module Vector4 = Assert.Equal(expW, res.W) [] - let ``Clamping one vector between two other vectors works by reference`` (a : Vector4, b : Vector4, w : Vector4) = + let ``Clamping one vector between two other vectors by reference clamps all components`` (a : Vector4, b : Vector4, w : Vector4) = let res = Vector4.Clamp(ref w, ref a, ref b) let expX = if w.X < a.X then a.X else if w.X > b.X then b.X else w.X -- 2.7.4