Add withChecks to most tests

kmath-torch/build.gradle.kts

@@ -187,4 +187,8 @@ tasks {
     withType<Test>{
         systemProperty("java.library.path", cppBuildDir.toString())
     }
-}
+}
+
+// No JS implementation
+project.gradle.startParameter.excludedTaskNames.add("jsTest")
+project.gradle.startParameter.excludedTaskNames.add("jsBrowserTest")

kmath-torch/src/nativeTest/kotlin/kscience/kmath/torch/TestAutograd.kt

@@ -6,15 +6,19 @@ import kotlin.test.*
 internal class TestAutograd {
     @Test
     fun testAutoGrad() = TorchTensorFloatAlgebra {
-        withCuda { device ->
+        withChecks {
-            testingAutoGrad(device)
+            withCuda { device ->
+                testingAutoGrad(device)
+            }
         }
     }
 
     @Test
     fun testBatchedAutoGrad() = TorchTensorFloatAlgebra {
-        withCuda { device ->
+        withChecks {
-            testingBatchedAutoGrad(device)
+            withCuda { device ->
+                testingBatchedAutoGrad(device)
+            }
         }
     }
 }

kmath-torch/src/nativeTest/kotlin/kscience/kmath/torch/TestTorchTensor.kt

@@ -47,8 +47,10 @@ class TestTorchTensor {
 
     @Test
     fun testViewWithNoCopy() = TorchTensorIntAlgebra {
-        withCuda {
+        withChecks {
-            device ->  testingViewWithNoCopy(device)
+            withCuda {
+                    device ->  testingViewWithNoCopy(device)
+            }
         }
     }
 

kmath-torch/src/nativeTest/kotlin/kscience/kmath/torch/TestTorchTensorAlgebra.kt

@@ -7,43 +7,55 @@ internal class TestTorchTensorAlgebra {
 
     @Test
     fun testScalarProduct() = TorchTensorRealAlgebra {
-        withCuda { device ->
+        withChecks {
-            testingScalarProduct(device)
+            withCuda { device ->
+                testingScalarProduct(device)
+            }
         }
     }
 
     @Test
     fun testMatrixMultiplication() = TorchTensorRealAlgebra {
-        withCuda { device ->
+        withChecks {
-            testingMatrixMultiplication(device)
+            withCuda { device ->
+                testingMatrixMultiplication(device)
+            }
         }
     }
 
     @Test
     fun testLinearStructure() = TorchTensorRealAlgebra {
-        withCuda { device ->
+        withChecks {
-            testingLinearStructure(device)
+            withCuda { device ->
+                testingLinearStructure(device)
+            }
         }
     }
 
     @Test
     fun testTensorTransformations() = TorchTensorRealAlgebra {
-        withCuda { device ->
+        withChecks {
-            testingTensorTransformations(device)
+            withCuda { device ->
+                testingTensorTransformations(device)
+            }
         }
     }
 
     @Test
     fun testBatchedSVD() = TorchTensorRealAlgebra {
-        withCuda { device ->
+        withChecks {
-            testingBatchedSVD(device)
+            withCuda { device ->
+                testingBatchedSVD(device)
+            }
         }
     }
 
     @Test
     fun testBatchedSymEig() = TorchTensorRealAlgebra {
-        withCuda { device ->
+        withChecks {
-            testingBatchedSymEig(device)
+            withCuda { device ->
+                testingBatchedSymEig(device)
+            }
         }
     }