ryujinx-backup/Opentk
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Improved test naming.

Browse source
This commit is contained in:
Jarl Gullberg 2017-06-01 21:09:10 +02:00
parent 8993dffad2
commit c7298d8784
No known key found for this signature in database
GPG key ID: 750FF6F6BDA72D23
4 changed files with 318 additions and 288 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

86
tests/OpenTK.Tests/Matrix4Tests.fs
View file

@ -266,7 +266,7 @@ module Matrix4 =
module Indexing =
//
[<Property>]
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)
[<Property>]
let ``Matrix indexing throws on negative indices`` (a) =
let mutable A = Matrix4()
let invalidIndexingAssignmentR = fun() -> A.[-1, 2] <- a
let invalidIndexingAssignmentC = fun() -> A.[1, -2] <- a
let invalidIndexingAssignmentRC = fun() -> A.[-1, -2] <- a
let invalidIndexingAccessR = fun() -> A.[-1, 2] |> ignore
let invalidIndexingAccessC = fun() -> A.[1, -2] |> ignore
let invalidIndexingAccessRC = fun() -> A.[-1, -2] |> ignore
Assert.Throws<IndexOutOfRangeException>(invalidIndexingAssignmentR) |> ignore
Assert.Throws<IndexOutOfRangeException>(invalidIndexingAssignmentC) |> ignore
Assert.Throws<IndexOutOfRangeException>(invalidIndexingAssignmentRC) |> ignore
Assert.Throws<IndexOutOfRangeException>(invalidIndexingAccessR) |> ignore
Assert.Throws<IndexOutOfRangeException>(invalidIndexingAccessC) |> ignore
Assert.Throws<IndexOutOfRangeException>(invalidIndexingAccessRC) |> ignore
[<Property>]
let ``Matrix indexing throws on large indices`` (a) =
let mutable A = Matrix4()
let invalidIndexingAssignmentR = fun() -> A.[5, 2] <- a
let invalidIndexingAssignmentC = fun() -> A.[1, 6] <- a
let invalidIndexingAssignmentRC = fun() -> A.[7, 12] <- a
let invalidIndexingAccessR = fun() -> A.[5, 2] |> ignore
let invalidIndexingAccessC = fun() -> A.[1, 6] |> ignore
let invalidIndexingAccessRC = fun() -> A.[7, 12] |> ignore
Assert.Throws<IndexOutOfRangeException>(invalidIndexingAssignmentR) |> ignore
Assert.Throws<IndexOutOfRangeException>(invalidIndexingAssignmentC) |> ignore
Assert.Throws<IndexOutOfRangeException>(invalidIndexingAssignmentRC) |> ignore
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.Throws<IndexOutOfRangeException>(invalidIndexingAccessR) |> ignore
Assert.Throws<IndexOutOfRangeException>(invalidIndexingAccessC) |> ignore
Assert.Throws<IndexOutOfRangeException>(invalidIndexingAccessRC) |> ignore
Assert.Equal(a, A.[0, 0])
Assert.Equal(b, A.[0, 1])
Assert.Equal(c, A.[0, 2])
Assert.Equal(d, A.[0, 3])
Assert.Equal(e, A.[1, 0])
Assert.Equal(f, A.[1, 1])
Assert.Equal(g, A.[1, 2])
Assert.Equal(h, A.[1, 3])
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.Equal(m, A.[3, 0])
Assert.Equal(n, A.[3, 1])
Assert.Equal(o, A.[3, 2])
Assert.Equal(p, A.[3, 3])
[<Property>]
let ``Indexed set operator throws exception for negative indices`` (b : Matrix4, x : float32) =
let mutable a = b
(fun() -> a.[-1, 2] <- x) |> Assert.Throws<IndexOutOfRangeException> |> ignore
(fun() -> a.[1, -2] <- x) |> Assert.Throws<IndexOutOfRangeException> |> ignore
(fun() -> a.[-1, -2] <- x) |> Assert.Throws<IndexOutOfRangeException> |> ignore
[<Property>]
let ``Indexed get operator throws exception for negative indices`` (a : Matrix4) =
(fun() -> a.[-1, 2] |> ignore) |> Assert.Throws<IndexOutOfRangeException> |> ignore
(fun() -> a.[1, -2] |> ignore) |> Assert.Throws<IndexOutOfRangeException> |> ignore
(fun() -> a.[-1, -2] |> ignore) |> Assert.Throws<IndexOutOfRangeException> |> ignore
[<Property>]
let ``Indexed set operator throws exception for large indices`` (a : Matrix4, x : float32) =
let mutable b = a
(fun() -> b.[5, 2] <- x) |> Assert.Throws<IndexOutOfRangeException> |> ignore
(fun() -> b.[1, 6] <- x) |> Assert.Throws<IndexOutOfRangeException> |> ignore
(fun() -> b.[7, 12] <- x) |> Assert.Throws<IndexOutOfRangeException> |> ignore
[<Property>]
let ``Indexed get operator throws exception for large indices`` (a : Matrix4) =
(fun() -> a.[5, 2] |> ignore) |> Assert.Throws<IndexOutOfRangeException> |> ignore
(fun() -> a.[1, 6] |> ignore) |> Assert.Throws<IndexOutOfRangeException> |> ignore
(fun() -> a.[7, 12] |> ignore) |> Assert.Throws<IndexOutOfRangeException> |> ignore
[<Properties(Arbitrary = [| typeof<OpenTKGen> |])>]
module ``Row and column properties`` =

186
tests/OpenTK.Tests/Vector2Tests.fs
View file

@ -22,14 +22,29 @@ module Vector2 =
let v = Vector2(x,y)
Assert.Equal(x,v.X)
Assert.Equal(y,v.Y)
//[<Property>]
// 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)
[<Properties(Arbitrary = [| typeof<OpenTKGen> |])>]
module Clamping =
//
[<Property>]
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)
[<Property>]
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)
[<Properties(Arbitrary = [| typeof<OpenTKGen> |])>]
module Length =
@ -81,28 +96,35 @@ module Vector2 =
module Indexing =
//
[<Property>]
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])
[<Property>]
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)
let invalidIndexingAccess = fun() -> v.[2] |> ignore
Assert.Throws<IndexOutOfRangeException>(invalidIndexingAccess) |> ignore
let invalidIndexingAssignment = (fun() -> v.[2] <- x)
Assert.Throws<IndexOutOfRangeException>(invalidIndexingAssignment) |> ignore
(fun() -> v.[-1] <- x) |> Assert.Throws<IndexOutOfRangeException> |> ignore
[<Property>]
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 negative indices`` (x, y) =
let mutable v = Vector2(x, y)
(fun() -> v.[-1] |> ignore) |> Assert.Throws<IndexOutOfRangeException> |> ignore
[<Property>]
let ``Indexed set operator throws exception for large indices`` (x, y) =
let mutable v = Vector2(x, y)
(fun() -> v.[2] <- x) |> Assert.Throws<IndexOutOfRangeException> |> ignore
[<Property>]
let ``Indexed get operator throws exception for large indices`` (x, y) =
let mutable v = Vector2(x, y)
(fun() -> v.[2] |> ignore) |> Assert.Throws<IndexOutOfRangeException> |> ignore
[<Properties(Arbitrary = [| typeof<OpenTKGen> |])>]
module ``Simple Properties`` =
@ -235,14 +257,13 @@ module Vector2 =
//
[<Property>]
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)
[<Property>]
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)
[<Property>]
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)
[<Property>]
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)
[<Property>]
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 =
//
[<Property>]
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 =
//
[<Property>]
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)
[<Property>]
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)
[<Property>]
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 =
//
[<Property>]
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 =
//
[<Property>]
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)
[<Property>]
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`` =
//
[<Property>]
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)
[<Property>]
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)
[<Properties(Arbitrary = [| typeof<OpenTKGen> |])>]
module Normalization =
//
[<Property>]
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)
[<Property>]
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)
[<Property>]
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)
[<Property>]
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)
[<Property>]
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));
[<Property>]
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)
[<Property>]
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`` =
//
[<Property>]
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)
[<Property>]
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)
[<Property>]
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)
[<Property>]
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)
[<Property>]
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)
[<Property>]
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)
[<Properties(Arbitrary = [| typeof<OpenTKGen> |])>]
module Clamping =
//
[<Property>]
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)
[<Property>]
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)
[<Properties(Arbitrary = [| typeof<OpenTKGen> |])>]
module Transformation =

162
tests/OpenTK.Tests/Vector3Tests.fs
View file

@ -69,52 +69,56 @@ module Vector3 =
module Indexing =
//
[<Property>]
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])
[<Property>]
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)
Assert.Throws<IndexOutOfRangeException>(invalidIndexingAccess) |> ignore
Assert.Throws<IndexOutOfRangeException>(invalidIndexingAssignment) |> ignore
(fun() -> v.[-1] <- x) |> Assert.Throws<IndexOutOfRangeException> |> ignore
[<Property>]
let ``Indexed get operator throws exception for negative indices`` (x, y, z) =
let mutable v = Vector3(x, y, z)
(fun() -> v.[-1] |> ignore) |> Assert.Throws<IndexOutOfRangeException> |> ignore
[<Property>]
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<IndexOutOfRangeException> |> ignore
[<Property>]
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<IndexOutOfRangeException>(invalidIndexingAccess) |> ignore
Assert.Throws<IndexOutOfRangeException>(invalidIndexingAssignment) |> ignore
(fun() -> v.[4] |> ignore) |> Assert.Throws<IndexOutOfRangeException> |> ignore
[<Properties(Arbitrary = [| typeof<OpenTKGen> |])>]
module Length =
//
[<Property>]
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)
[<Property>]
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)
[<Property>]
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 =
//
[<Property>]
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)
[<Property>]
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)
[<Property>]
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)
[<Property>]
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)
[<Property>]
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));
[<Property>]
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)
[<Property>]
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)
[<Property>]
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)
[<Property>]
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)
[<Property>]
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)
[<Property>]
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)
[<Property>]
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)
[<Property>]
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 =
//
[<Property>]
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 =
//
[<Property>]
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)
[<Property>]
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)
[<Property>]
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 =
//
[<Property>]
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);
[<Property>]
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);
[<Property>]
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 =
//
[<Property>]
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)
[<Property>]
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`` =
//
[<Property>]
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)
[<Property>]
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`` =
//
[<Property>]
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)
[<Property>]
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)
[<Property>]
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)
[<Property>]
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)
[<Property>]
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)
[<Property>]
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 =
//
[<Property>]
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)
[<Property>]
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

172
tests/OpenTK.Tests/Vector4Tests.fs
View file

@ -56,6 +56,20 @@ module Vector4 =
Assert.Equal(z, v2.Z)
Assert.Equal((float32)0, v2.W)
[<Property>]
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)
[<Property>]
let ``Vector4 value constructor sets all components to the correct values`` (x, y, z, w) =
let v1 = Vector4(x, y, z, w)
@ -84,44 +98,48 @@ module Vector4 =
Assert.Equal(w, v.[3])
[<Property>]
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<IndexOutOfRangeException> |> ignore
[<Property>]
let ``Indexed get operator throws exception for negative indices`` (x, y, z, w) =
let mutable v = Vector4(x, y, z, w)
(fun() -> v.[-1] |> ignore) |> Assert.Throws<IndexOutOfRangeException> |> ignore
[<Property>]
let ``Indexed set operator throws exception for large 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<IndexOutOfRangeException>(invalidIndexingAccess) |> ignore
Assert.Throws<IndexOutOfRangeException>(invalidIndexingAssignment) |> ignore
(fun() -> v.[4] <- x) |> Assert.Throws<IndexOutOfRangeException> |> ignore
[<Property>]
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<IndexOutOfRangeException>(invalidIndexingAccess) |> ignore
Assert.Throws<IndexOutOfRangeException>(invalidIndexingAssignment) |> ignore
(fun() -> v.[4] |> ignore) |> Assert.Throws<IndexOutOfRangeException> |> ignore
[<Properties(Arbitrary = [| typeof<OpenTKGen> |])>]
module Length =
//
[<Property>]
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)
[<Property>]
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)
[<Property>]
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 =
//
[<Property>]
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)
[<Property>]
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)
[<Property>]
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)
[<Property>] // 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)
[<Property>]
let ``Normalization by reference is the same as division by magnitude`` (a : Vector4) =
let norm = a / a.Length
let vRes = Vector4.Normalize(ref a)
[<Property>] // 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)
[<Property>]
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));
[<Property>]
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)
[<Property>]
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)
[<Property>]
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)
[<Property>]
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)
[<Property>]
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)
[<Property>]
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)
[<Property>]
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)
[<Property>]
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 =
//
[<Property>]
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 =
//
[<Property>]
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)
[<Property>]
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)
[<Property>]
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)
[<Property>]
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)
[<Properties(Arbitrary = [| typeof<OpenTKGen> |])>]
module Swizzling =
//
[<Property>]
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)
[<Property>]
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)
[<Property>]
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)
[<Property>]
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 =
//
[<Property>]
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)
[<Property>]
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`` =
//
[<Property>]
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`` =
//
[<Property>]
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)
[<Property>]
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 =
//
[<Property>]
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)
[<Property>]
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