Improve vector test organization

tests/OpenTK.Tests/Vectors.fs

@@ -36,51 +36,77 @@ type VectorGen =
     static member Vector3() = Generators.Vec3
     static member Vector4() = Generators.Vec4
 
-[<Properties(Arbitrary = [| typeof<VectorGen> |])>]
+module Vector2 = 
-module ``Vector2 tests`` = 
+    [<Properties(Arbitrary = [| typeof<VectorGen> |])>]
-    //
+    module ``Simple Properties`` = 
-    [<Property>]
-    let ``Vector equality is by component`` (a : Vector2,b : Vector2) = 
         //
-        Assert.Equal((a.X = b.X && a.Y = b.Y),(a = b))
+        [<Property>]
+        let ``Vector equality is by component`` (a : Vector2,b : Vector2) = 
+            //
+            Assert.Equal((a.X = b.X && a.Y = b.Y),(a = b))
+        
+        [<Property>]
+        let ``Vector length is always >= 0`` (a : Vector2) = 
+            //
+            Assert.True(a.Length >= 0.0f)
     
-    [<Property>]
+    [<Properties(Arbitrary = [| typeof<VectorGen> |])>]
-    let ``Vector length is always >= 0`` (a : Vector2) = 
+    module Addition = 
         //
-        Assert.True(a.Length >= 0.0f)
+        [<Property>]
+        let ``Vector addition is the same as component addition`` (a : Vector2,b : Vector2) = 
+            let c = a + b
+            Assert.Equal(a.X + b.X,c.X)
+            Assert.Equal(a.Y + b.Y,c.Y)
+        
+        [<Property>]
+        let ``Vector addition is commutative`` (a : Vector2,b : Vector2) = 
+            let c = a + b
+            let c2 = b + a
+            Assert.Equal(c,c2)
+        
+        [<Property>]
+        let ``Vector addition is associative`` (a : Vector2,b : Vector2,c : Vector2) = 
+            let r1 = (a + b) + c
+            let r2 = a + (b + c)
+            Assert.Equal(r1,r2)
     
-    [<Property>]
+    [<Properties(Arbitrary = [| typeof<VectorGen> |])>]
-    let ``Vector addition is the same as component addition`` (a : Vector2,b : Vector2) = 
+    module Multiplication = 
-        let c = a + b
+        //
-        Assert.Equal(a.X + b.X,c.X)
+        [<Property>]
-        Assert.Equal(a.Y + b.Y,c.Y)
+        let ``Vector multiplication is the same as component multiplication`` (a : Vector2,b : Vector2) = 
+            let c = a * b
+            Assert.Equal(a.X * b.X,c.X)
+            Assert.Equal(a.Y * b.Y,c.Y)
+        
+        [<Property>]
+        let ``Vector multiplication is commutative`` (a : Vector2,b : Vector2) = 
+            let r1 = a * b
+            let r2 = b * a
+            Assert.Equal(r1,r2)
+        
+        [<Property>]
+        let ``Vector-float multiplication is the same as component-float multiplication`` (a : Vector2,f : float32) = 
+            let r = a * f
+            Assert.Equal(a.X * f,r.X)
+            Assert.Equal(a.Y * f,r.Y)
     
-    [<Property>]
+    [<Properties(Arbitrary = [| typeof<VectorGen> |])>]
-    let ``Vector addition is commutative`` (a : Vector2,b : Vector2) = 
+    module Subtraction = 
-        let c = a + b
+        //
-        let c2 = b + a
+        [<Property>]
-        Assert.Equal(c,c2)
+        let ``Vector subtraction is the same as component subtraction`` (a : Vector2,b : Vector2) = 
+            let c = a - b
+            Assert.Equal(a.X - b.X,c.X)
+            Assert.Equal(a.Y - b.Y,c.Y)
     
-    [<Property>]
+    [<Properties(Arbitrary = [| typeof<VectorGen> |])>]
-    let ``Vector addition is associative`` (a : Vector2,b : Vector2,c : Vector2) = 
+    module Division = 
-        let r1 = (a + b) + c
+        //
-        let r2 = a + (b + c)
+        [<Property>]
-        Assert.Equal(r1,r2)
+        let ``Vector-float division is the same as component-float division`` (a : Vector2,f : float32) = 
-    
+            if f <> 0.0f then 
-    [<Property>]
+                let r = a / f
-    let ``Vector multiplication is the same as component multiplication`` (a : Vector2,b : Vector2) = 
+                Assert.Equal(a.X / f,r.X)
-        let c = a * b
+                Assert.Equal(a.Y / f,r.Y)
-        Assert.Equal(a.X * b.X,c.X)
-        Assert.Equal(a.Y * b.Y,c.Y)
-    
-    [<Property>]
-    let ``Vector multiplication is commutative`` (a : Vector2,b : Vector2) = 
-        let r1 = a * b
-        let r2 = b * a
-        Assert.Equal(r1,r2)
-    
-    [<Property>]
-    let ``Vector-float multiplication is the same as component-float multiplication`` (a : Vector2,f : float32) = 
-        let r = a * f
-        Assert.Equal(a.X * f,r.X)
-        Assert.Equal(a.Y * f,r.Y)