Enable tests (#9)

* set swiftSettings

* Create swift.yml

simple tests

* enable tests into package;
fix warnings;
add one more test;

* fix order multiplication;

* Feature/linux ci (#1)

* enable tests on linux platform
* add missing configurations
* generate tests for linux

* do transpose same time as multiplication

Author: sakrist

.github/workflows/swift.yml

@@ -0,0 +1,34 @@
+name: Swift
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        os: [macos-latest, ubuntu-20.04]
+
+    runs-on: ${{matrix.os}}
+
+    steps:
+    - name: Install Swift
+      if: runner.os == 'Linux'
+      uses: sersoft-gmbh/SwiftyActions@v1
+      with:
+          release-version: 5.3.2
+          platform: ${{matrix.os}}
+    - uses: actions/checkout@v2
+    - uses: actions/cache@v2
+      with:
+          path: .build
+          key: ${{runner.os}}-${{github.repository}}-spm-${{hashFiles('**/Package.resolved')}}
+          restore-keys: |
+            ${{runner.os}}-${{github.repository}}-spm-
+    - name: Build
+      run: swift build -v
+    - name: Run tests
+      run: swift test -v

Package.swift

@@ -14,6 +14,10 @@ let package = Package(
             name: "SwiftMath",
             path: ".",
             sources: ["Sources"],
-            swiftSettings: [ .define("NOSIMD", .when(platforms: [.linux, .android])),])
+            swiftSettings: [ .define("NOSIMD", .when(platforms: [.linux, .android, .windows, .wasi, ])),]),
+        
+        .testTarget(
+            name: "SwiftMathTests",
+            dependencies: ["SwiftMath"]),
     ]
 )

Sources/Matrix4x4+nosimd.swift

@@ -172,7 +172,7 @@ public struct Matrix4x4f {
 }
 
 public extension Matrix4x4f {
-    public var adjugate: Matrix4x4f {
+    var adjugate: Matrix4x4f {
         var m = Matrix4x4f.identity
 
         m.m11 = m22 * m33 * m44 - m22 * m34 * m43
@@ -246,11 +246,11 @@ public extension Matrix4x4f {
         return m11 * m.m11 + m12 * m.m21 + m13 * m.m31 + m14 * m.m41
     }
 
-    public var determinant: Float {
+    var determinant: Float {
         return determinant(forAdjugate: adjugate)
     }
 
-    public var transposed: Matrix4x4f {
+    var transposed: Matrix4x4f {
         return Matrix4x4f(
             vec4(m11, m21, m31, m41),
             vec4(m12, m22, m32, m42),
@@ -259,12 +259,12 @@ public extension Matrix4x4f {
         )
     }
 
-    public var inversed: Matrix4x4f {
+    var inversed: Matrix4x4f {
         let adjugate = self.adjugate // avoid recalculating
         return adjugate * (1 / determinant(forAdjugate: adjugate))
     }
 
-    public static func *(lhs: Matrix4x4f, rhs: Matrix4x4f) -> Matrix4x4f {
+    static func *(lhs: Matrix4x4f, rhs: Matrix4x4f) -> Matrix4x4f {
         var m = Matrix4x4f.identity
 
         m.m11 = lhs.m11 * rhs.m11 + lhs.m21 * rhs.m12
@@ -318,7 +318,7 @@ public extension Matrix4x4f {
         return m
     }
 
-    public static func *(lhs: Matrix4x4f, rhs: Float) -> Matrix4x4f {
+    static func *(lhs: Matrix4x4f, rhs: Float) -> Matrix4x4f {
         return Matrix4x4f(
             vec4(lhs.m11 * rhs, lhs.m12 * rhs, lhs.m13 * rhs, lhs.m14 * rhs),
             vec4(lhs.m21 * rhs, lhs.m22 * rhs, lhs.m23 * rhs, lhs.m24 * rhs),
@@ -327,7 +327,7 @@ public extension Matrix4x4f {
         )
     }
 
-    public static prefix func -(lhs: Matrix4x4f) -> Matrix4x4f {
+    static prefix func -(lhs: Matrix4x4f) -> Matrix4x4f {
         return Matrix4x4f(
             vec4(-lhs.m11, -lhs.m12, -lhs.m13, -lhs.m14),
             vec4(-lhs.m21, -lhs.m22, -lhs.m23, -lhs.m24),

Sources/Vector4+nosimd.swift

@@ -126,15 +126,20 @@ extension Vector4f: Equatable {
 
     public static func *(lhs: Vector4f, rhs: Matrix4x4f) -> Vector4f {
         return Vector4f(
-            lhs.x * rhs.m11 + lhs.y * rhs.m21 + lhs.z * rhs.m31 + lhs.w * rhs.m41,
-            lhs.x * rhs.m12 + lhs.y * rhs.m22 + lhs.z * rhs.m32 + lhs.w * rhs.m42,
-            lhs.x * rhs.m13 + lhs.y * rhs.m23 + lhs.z * rhs.m33 + lhs.w * rhs.m43,
-            lhs.x * rhs.m14 + lhs.y * rhs.m24 + lhs.z * rhs.m34 + lhs.w * rhs.m44
+            lhs.x * rhs.m11 + lhs.y * rhs.m12 + lhs.z * rhs.m13 + lhs.w * rhs.m14,
+            lhs.x * rhs.m21 + lhs.y * rhs.m22 + lhs.z * rhs.m23 + lhs.w * rhs.m24,
+            lhs.x * rhs.m31 + lhs.y * rhs.m32 + lhs.z * rhs.m33 + lhs.w * rhs.m34,
+            lhs.x * rhs.m41 + lhs.y * rhs.m42 + lhs.z * rhs.m43 + lhs.w * rhs.m44
         )
     }
 
     public static func *(lhs: Matrix4x4f, rhs: Vector4f) -> Vector4f {
-        return rhs * lhs
+        return Vector4f(
+            rhs.x * lhs.m11 + rhs.y * lhs.m21 + rhs.z * lhs.m31 + rhs.w * lhs.m41,
+            rhs.x * lhs.m12 + rhs.y * lhs.m22 + rhs.z * lhs.m32 + rhs.w * lhs.m42,
+            rhs.x * lhs.m13 + rhs.y * lhs.m23 + rhs.z * lhs.m33 + rhs.w * lhs.m43,
+            rhs.x * lhs.m14 + rhs.y * lhs.m24 + rhs.z * lhs.m34 + rhs.w * lhs.m44
+        )
     }
 
     public static func /(lhs: Vector4f, rhs: Vector4f) -> Vector4f {

Tests/LinuxMain.swift

@@ -0,0 +1,8 @@
+import XCTest
+
+import SwiftMathTests
+
+var tests = [XCTestCaseEntry]()
+tests += SwiftMathTests.__allTests()
+
+XCTMain(tests)

Tests/SwiftMathTests/Matrix4x4Tests.swift

@@ -48,6 +48,7 @@ class Matrix4x4Tests: XCTestCase {
 
         XCTAssertEqual(10.0, i[0,1])
         XCTAssertEqual(10.0, i[0][1])
+        XCTAssertEqual(12.0, i[2][1])
 
         XCTAssertEqual(32.0, i[2][3])
     }

Tests/SwiftMathTests/Vector2Tests.swift

@@ -23,7 +23,17 @@ class Vector2fTests: XCTestCase {
         let b = Matrix4x4f.rotate(z: rad(Float.pi/2.0))
         let c = a * b
 
-        XCTAssertEqualWithAccuracy(0.0, c.x, accuracy: 0.001)
-        XCTAssertEqualWithAccuracy(1.0, c.y, accuracy: 0.001)
+        XCTAssertEqual(0.0, c.x, accuracy: 0.001)
+        XCTAssertEqual(1.0, c.y, accuracy: 0.001)
+    }
+    
+    func testVectorMultiplyWithMatrix4x4_2() {
+        let a = Vector2f(1.0, 0.0)
+        var b = Matrix4x4f.rotate(z: rad(Float.pi / -1.5))
+        b =  b * Matrix4x4f.rotate(x: rad(Float.pi / 1.5))
+        let c = a * b
+        
+        XCTAssertEqual(-0.499999881, c.x, accuracy: 0.001)
+        XCTAssertEqual(0.433012635, c.y, accuracy: 0.001)
     }
 }

Tests/SwiftMathTests/XCTestManifests.swift

@@ -0,0 +1,75 @@
+#if !canImport(ObjectiveC)
+import XCTest
+
+extension AngleTests {
+    // DO NOT MODIFY: This is autogenerated, use:
+    //   `swift test --generate-linuxmain`
+    // to regenerate.
+    static let __allTests__AngleTests = [
+        ("testAngleAddition", testAngleAddition),
+        ("testAngleCompoundAdditionAndAssignment", testAngleCompoundAdditionAndAssignment),
+        ("testAngleCompoundSubtractionAndAssignment", testAngleCompoundSubtractionAndAssignment),
+        ("testAngleDivide", testAngleDivide),
+        ("testAngleMultiply", testAngleMultiply),
+        ("testAngleSubtraction", testAngleSubtraction),
+        ("testMakeAngleFromIntegerInDegrees", testMakeAngleFromIntegerInDegrees),
+        ("testPostfixConstructsAngleFromFloatInDegrees", testPostfixConstructsAngleFromFloatInDegrees),
+        ("testPostfixConstructsAngleFromIntInDegrees", testPostfixConstructsAngleFromIntInDegrees),
+    ]
+}
+
+extension ClampTests {
+    // DO NOT MODIFY: This is autogenerated, use:
+    //   `swift test --generate-linuxmain`
+    // to regenerate.
+    static let __allTests__ClampTests = [
+        ("testClampReturnsMaximumValueWhenGreaterThanMaximum", testClampReturnsMaximumValueWhenGreaterThanMaximum),
+        ("testClampReturnsMinimumValueWhenLessThanMinimum", testClampReturnsMinimumValueWhenLessThanMinimum),
+        ("testClampReturnsSameValueWhenWithinRange", testClampReturnsSameValueWhenWithinRange),
+    ]
+}
+
+extension Matrix4x4Tests {
+    // DO NOT MODIFY: This is autogenerated, use:
+    //   `swift test --generate-linuxmain`
+    // to regenerate.
+    static let __allTests__Matrix4x4Tests = [
+        ("testIdentity", testIdentity),
+        ("testInitWithFloats", testInitWithFloats),
+        ("testInitWithFloatsIsRowMajor", testInitWithFloatsIsRowMajor),
+        ("testInitWithVector4IsColumnMajor", testInitWithVector4IsColumnMajor),
+        ("testInitWithVectors", testInitWithVectors),
+    ]
+}
+
+extension RectTests {
+    // DO NOT MODIFY: This is autogenerated, use:
+    //   `swift test --generate-linuxmain`
+    // to regenerate.
+    static let __allTests__RectTests = [
+        ("testRectEquatable", testRectEquatable),
+    ]
+}
+
+extension Vector2fTests {
+    // DO NOT MODIFY: This is autogenerated, use:
+    //   `swift test --generate-linuxmain`
+    // to regenerate.
+    static let __allTests__Vector2fTests = [
+        ("testVectorMultiplyWithMatrix4x4", testVectorMultiplyWithMatrix4x4),
+        ("testVectorMultiplyWithMatrix4x4_2", testVectorMultiplyWithMatrix4x4_2),
+        ("testVectorsAreEqualUsingEquatable", testVectorsAreEqualUsingEquatable),
+        ("testVectorsAreNotEqualUsingEquatable", testVectorsAreNotEqualUsingEquatable),
+    ]
+}
+
+public func __allTests() -> [XCTestCaseEntry] {
+    return [
+        testCase(AngleTests.__allTests__AngleTests),
+        testCase(ClampTests.__allTests__ClampTests),
+        testCase(Matrix4x4Tests.__allTests__Matrix4x4Tests),
+        testCase(RectTests.__allTests__RectTests),
+        testCase(Vector2fTests.__allTests__Vector2fTests),
+    ]
+}
+#endif