refactor: tests

Author: IgorErin

src/GraphBLAS-sharp.Backend/Common/BitonicSort.fs

@@ -290,7 +290,7 @@ module internal BitonicSort =
             queue.Post(Msg.MsgSetArguments(fun () -> kernel.KernelFunc ndRange rows cols values values.Length))
             queue.Post(Msg.CreateRunMsg<_, _>(kernel))
 
-    let sortKeyValuesInplace (clContext: ClContext) workGroupSize =
+    let sortKeyValuesInplace<'n, 'a when 'n: comparison> (clContext: ClContext) workGroupSize =
 
         let localBegin = localBegin clContext workGroupSize
         let globalStep = globalStep clContext workGroupSize

src/GraphBLAS-sharp.Backend/Common/Scatter.fs

@@ -22,7 +22,7 @@ module internal Scatter =
     /// > val result = [| 2.8; 5.5; 6.4; 8.2; 9.1 |]
     /// </code>
     /// </example>
-    let runInplace (clContext: ClContext) workGroupSize =
+    let runInplace<'a> (clContext: ClContext) workGroupSize =
 
         let run =
             <@ fun (ndRange: Range1D) (positions: ClArray<int>) (positionsLength: int) (values: ClArray<'a>) (result: ClArray<'a>) (resultLength: int) ->

tests/GraphBLAS-sharp.Tests/Common/BitonicSort.fs

@@ -10,7 +10,13 @@ open GraphBLAS.FSharp.Tests.Context
 
 let logger = Log.create "BitonicSort.Tests"
 
-let makeTest (context: ClContext) (q: MailboxProcessor<_>) sort (array: ('n * 'n * 'a) []) =
+let context = defaultContext.ClContext
+let config = { defaultConfig with endSize = 1000000 }
+
+let wgSize = 32
+let q = defaultContext.Queue
+
+let makeTest sort (array: ('n * 'n * 'a) []) =
     if array.Length > 0 then
         let projection (row: 'n) (col: 'n) (v: 'a) = row, col
 
@@ -63,23 +69,18 @@ let makeTest (context: ClContext) (q: MailboxProcessor<_>) sort (array: ('n * 'n
             vals)
         |> compareArrays (=) actualVals expectedVals
 
-let testFixtures<'a when 'a: equality> config wgSize context q =
-    let sort: MailboxProcessor<_> -> ClArray<int> -> ClArray<int> -> ClArray<'a> -> unit =
-        BitonicSort.sortKeyValuesInplace context wgSize
+let testFixtures<'a when 'a: equality> =
+    let sort =
+        BitonicSort.sortKeyValuesInplace<int, 'a> context wgSize
 
-    makeTest context q sort
+    makeTest sort
     |> testPropertyWithConfig config (sprintf "Correctness on %A" typeof<'a>)
 
 let tests =
-    let context = defaultContext.ClContext
-    let config = { defaultConfig with endSize = 1000000 }
-
-    let wgSize = 32
-    let q = defaultContext.Queue
     q.Error.Add(fun e -> failwithf "%A" e)
 
-    [ testFixtures<int> config wgSize context q
-      testFixtures<float> config wgSize context q
-      testFixtures<byte> config wgSize context q
-      testFixtures<bool> config wgSize context q ]
+    [ testFixtures<int>
+      testFixtures<float>
+      testFixtures<byte>
+      testFixtures<bool> ]
     |> testList "Backend.Common.BitonicSort tests"

tests/GraphBLAS-sharp.Tests/Common/Exists.fs

@@ -11,21 +11,21 @@ open GraphBLAS.FSharp.Backend.Objects
 open GraphBLAS.FSharp.Backend.Quotes
 
 let logger =
-    Log.create "Vector.containsNonZero.Tests"
+    Log.create "ClArray.containsNonZero.Tests"
 
 let context = defaultContext.ClContext
 
 let q = defaultContext.Queue
 
-let correctnessGenericTest<'a when 'a: struct and 'a: equality> isZero containsNonZero (array: 'a []) =
+let correctnessGenericTest<'a when 'a: struct and 'a: equality> isZero exists (array: 'a []) =
 
     if array.Length > 0 then
         let vector = createVectorFromArray Dense array isZero
 
         let result =
             match vector.ToDevice context with
             | ClVector.Dense clArray ->
-                let resultCell = containsNonZero q clArray
+                let resultCell = exists q clArray
                 let result = Array.zeroCreate 1
 
                 let res =
@@ -35,6 +35,8 @@ let correctnessGenericTest<'a when 'a: struct and 'a: equality> isZero containsN
 
                 res.[0]
 
+            | _ -> failwith "Unsupported vector format"
+
         $"The results should be the same, vector : {vector}"
         |> Expect.equal result (Array.exists (not << isZero) array)
 
@@ -46,52 +48,40 @@ let testFixtures =
     let getCorrectnessTestName datatype =
         sprintf "Correctness on %s, %A" datatype Dense
 
-    [ let containsNonZeroInt =
+    [ let exists =
           ClArray.exists context wgSize Predicates.isSome
 
-      correctnessGenericTest<int> ((=) 0) containsNonZeroInt
+      correctnessGenericTest<int> ((=) 0) exists
       |> testPropertyWithConfig config (getCorrectnessTestName "int")
 
-      let containsNonZeroByte =
-          ClArray.exists context wgSize Predicates.isSome
-
-      correctnessGenericTest<byte> ((=) 0uy) containsNonZeroByte
-      |> testPropertyWithConfig config (getCorrectnessTestName "byte")
-
-      let containsNonZeroFloat =
-          ClArray.exists context wgSize Predicates.isSome
-
-      correctnessGenericTest<float> ((=) 0.0) containsNonZeroFloat
-      |> testPropertyWithConfig config (getCorrectnessTestName "float")
-
-      let containsNonZeroBool =
-          ClArray.exists context wgSize Predicates.isSome
-
-      correctnessGenericTest<bool> ((=) false) containsNonZeroBool
-      |> testPropertyWithConfig config (getCorrectnessTestName "bool")
-
-      let containsNonZeroInt =
-          ClArray.exists context wgSize Predicates.isSome
-
-      correctnessGenericTest<int> ((=) 0) containsNonZeroInt (Array.create 1000 0)
+      correctnessGenericTest<int> ((=) 0) exists (Array.create 1000 0)
       |> testPropertyWithConfig config (getCorrectnessTestName "int zeros")
 
-      let containsNonZeroByte =
+      let exists =
           ClArray.exists context wgSize Predicates.isSome
 
-      correctnessGenericTest<byte> ((=) 0uy) containsNonZeroByte (Array.create 1000 0uy)
+      correctnessGenericTest<byte> ((=) 0uy) exists
+      |> testPropertyWithConfig config (getCorrectnessTestName "byte")
+
+      correctnessGenericTest<byte> ((=) 0uy) exists (Array.create 1000 0uy)
       |> testPropertyWithConfig config (getCorrectnessTestName "byte zeros")
 
-      let containsNonZeroFloat =
+      let exists =
           ClArray.exists context wgSize Predicates.isSome
 
-      correctnessGenericTest<float> ((=) 0.0) containsNonZeroFloat (Array.create 1000 0.0)
+      correctnessGenericTest<float> ((=) 0.0) exists
+      |> testPropertyWithConfig config (getCorrectnessTestName "float")
+
+      correctnessGenericTest<float> ((=) 0.0) exists (Array.create 1000 0.0)
       |> testPropertyWithConfig config (getCorrectnessTestName "float zeros")
 
-      let containsNonZeroBool =
+      let exists =
           ClArray.exists context wgSize Predicates.isSome
 
-      correctnessGenericTest<bool> ((=) false) containsNonZeroBool (Array.create 1000 false)
+      correctnessGenericTest<bool> ((=) false) exists
+      |> testPropertyWithConfig config (getCorrectnessTestName "bool")
+
+      correctnessGenericTest<bool> ((=) false) exists (Array.create 1000 false)
       |> testPropertyWithConfig config (getCorrectnessTestName "bool zeros") ]
 
 let tests =

tests/GraphBLAS-sharp.Tests/Common/PrefixSum.fs

@@ -12,12 +12,17 @@ let logger = Log.create "ClArray.PrefixSum.Tests"
 
 let context = defaultContext.ClContext
 
-let makeTest (q: MailboxProcessor<_>) scan plus zero isEqual (filter: 'a [] -> 'a []) (array: 'a []) =
+let config = defaultConfig
+
+let wgSize = 128
+
+let q = defaultContext.Queue
+
+let makeTest scan plus zero isEqual (array: 'a []) =
     if array.Length > 0 then
-        let array = filter array
 
         logger.debug (
-            eventX "Filtered array is {array}\n"
+            eventX $"Array is %A{array}\n"
             >> setField "array" (sprintf "%A" array)
         )
 
@@ -49,42 +54,30 @@ let makeTest (q: MailboxProcessor<_>) scan plus zero isEqual (filter: 'a [] -> '
             >> setField "expected" (sprintf "%A" expected)
         )
 
-        "Lengths of arrays should be equal"
-        |> Expect.equal actual.Length expected.Length
-
         "Total sums should be equal"
         |> Expect.equal actualSum expectedSum
 
-        for i in 0 .. actual.Length - 1 do
-            Expect.isTrue
-                (isEqual actual.[i] expected.[i])
-                (sprintf "Arrays should be the same. Actual is \n%A, expected \n%A, input is \n%A" actual expected array)
+        "Arrays should be the same"
+        |> compareArrays isEqual actual expected
 
-let testFixtures config wgSize q plus plusQ zero isEqual filter name =
+let testFixtures plus plusQ zero isEqual name =
     let scan =
         ClArray.prefixSumIncludeInplace plusQ context wgSize
 
-    makeTest q scan plus zero isEqual filter
+    makeTest scan plus zero isEqual
     |> testPropertyWithConfig config (sprintf "Correctness on %s" name)
 
 let tests =
-    let config = defaultConfig
-
-    let wgSize = 128
-    let q = defaultContext.Queue
     q.Error.Add(fun e -> failwithf "%A" e)
 
-    let filterFloats =
-        Array.filter (System.Double.IsNaN >> not)
-
-    [ testFixtures config wgSize q (+) <@ (+) @> 0 (=) id "int add"
-      testFixtures config wgSize q (+) <@ (+) @> 0uy (=) id "byte add"
-      testFixtures config wgSize q max <@ max @> 0 (=) id "int max"
-      testFixtures config wgSize q max <@ max @> 0.0 (=) filterFloats "float max"
-      testFixtures config wgSize q max <@ max @> 0uy (=) id "byte max"
-      testFixtures config wgSize q min <@ min @> System.Int32.MaxValue (=) id "int min"
-      testFixtures config wgSize q min <@ min @> System.Double.MaxValue (=) filterFloats "float min"
-      testFixtures config wgSize q min <@ min @> System.Byte.MaxValue (=) id "byte min"
-      testFixtures config wgSize q (||) <@ (||) @> false (=) id "bool logic-or"
-      testFixtures config wgSize q (&&) <@ (&&) @> true (=) id "bool logic-and" ]
+    [ testFixtures (+) <@ (+) @> 0 (=) "int add"
+      testFixtures (+) <@ (+) @> 0uy (=) "byte add"
+      testFixtures max <@ max @> 0 (=) "int max"
+      testFixtures max <@ max @> 0.0 (=) "float max"
+      testFixtures max <@ max @> 0uy (=) "byte max"
+      testFixtures min <@ min @> System.Int32.MaxValue (=) "int min"
+      testFixtures min <@ min @> System.Double.MaxValue (=) "float min"
+      testFixtures min <@ min @> System.Byte.MaxValue (=) "byte min"
+      testFixtures (||) <@ (||) @> false (=) "bool logic-or"
+      testFixtures (&&) <@ (&&) @> true (=) "bool logic-and" ]
     |> testList "Backend.Common.PrefixSum tests"

tests/GraphBLAS-sharp.Tests/Common/Reduce.fs

@@ -12,16 +12,12 @@ let logger = Log.create "Reduce.Tests"
 
 let context = Context.defaultContext.ClContext
 
-let makeTest
-    (q: MailboxProcessor<_>)
-    (reduce: MailboxProcessor<_> -> ClArray<'a> -> ClCell<'a>)
-    plus
-    zero
-    (filter: 'a [] -> 'a [])
-    (array: 'a [])
-    =
+let config = defaultConfig
 
-    let array = filter array
+let wgSize = 32
+let q = Context.defaultContext.Queue
+
+let makeTest (reduce: MailboxProcessor<_> -> ClArray<'a> -> ClCell<'a>) plus zero (array: 'a []) =
 
     if array.Length > 0 then
         let reduce = reduce q
@@ -57,30 +53,25 @@ let makeTest
         "Total sums should be equal"
         |> Expect.equal actualSum expectedSum
 
-
-let testFixtures config wgSize q plus plusQ zero filter name =
+let testFixtures plus plusQ zero name =
     let reduce = Reduce.reduce context wgSize plusQ
 
-    makeTest q reduce plus zero filter
+    makeTest reduce plus zero
     |> testPropertyWithConfig config (sprintf "Correctness on %s" name)
 
 let tests =
-    let config = defaultConfig
-
-    let wgSize = 32
-    let q = Context.defaultContext.Queue
     q.Error.Add(fun e -> failwithf "%A" e)
 
     let filterFloats = Array.filter System.Double.IsNormal
 
-    [ testFixtures config wgSize q (+) <@ (+) @> 0 id "int add"
-      testFixtures config wgSize q (+) <@ (+) @> 0uy id "byte add"
-      testFixtures config wgSize q max <@ max @> System.Int32.MinValue id "int max"
-      testFixtures config wgSize q max <@ max @> System.Double.MinValue filterFloats "float max"
-      testFixtures config wgSize q max <@ max @> System.Byte.MinValue id "byte max"
-      testFixtures config wgSize q min <@ min @> System.Int32.MaxValue id "int min"
-      testFixtures config wgSize q min <@ min @> System.Double.MaxValue filterFloats "float min"
-      testFixtures config wgSize q min <@ min @> System.Byte.MaxValue id "byte min"
-      testFixtures config wgSize q (||) <@ (||) @> false id "bool logic-or"
-      testFixtures config wgSize q (&&) <@ (&&) @> true id "bool logic-and" ]
+    [ testFixtures (+) <@ (+) @> 0 "int add"
+      testFixtures (+) <@ (+) @> 0uy "byte add"
+      testFixtures max <@ max @> System.Int32.MinValue "int max"
+      testFixtures max <@ max @> System.Double.MinValue "float max"
+      testFixtures max <@ max @> System.Byte.MinValue "byte max"
+      testFixtures min <@ min @> System.Int32.MaxValue "int min"
+      testFixtures min <@ min @> System.Double.MaxValue "float min"
+      testFixtures min <@ min @> System.Byte.MaxValue "byte min"
+      testFixtures (||) <@ (||) @> false "bool logic-or"
+      testFixtures (&&) <@ (&&) @> true "bool logic-and" ]
     |> testList "Backend.Common.Reduce tests"

tests/GraphBLAS-sharp.Tests/Common/Scatter.fs

@@ -10,8 +10,13 @@ open GraphBLAS.FSharp.Tests.Utils
 let logger = Log.create "Scatter.Tests"
 
 let context = defaultContext.ClContext
+let config = { defaultConfig with endSize = 1000000 }
 
-let makeTest (context: ClContext) (q: MailboxProcessor<_>) scatter (array: (int * 'a) []) (result: 'a []) =
+let wgSize = 32
+
+let q = defaultContext.Queue
+
+let makeTest scatter (array: (int * 'a) []) (result: 'a []) =
     if array.Length > 0 then
         let expected = Array.copy result
 
@@ -41,22 +46,16 @@ let makeTest (context: ClContext) (q: MailboxProcessor<_>) scatter (array: (int
         (sprintf "Arrays should be equal. Actual is \n%A, expected \n%A" actual expected)
         |> compareArrays (=) actual expected
 
-let testFixtures<'a when 'a: equality> config wgSize context q =
-    let scatter: MailboxProcessor<_> -> ClArray<int> -> ClArray<'a> -> ClArray<'a> -> unit =
-        Scatter.runInplace context wgSize
+let testFixtures<'a when 'a: equality> =
+    let scatter = Scatter.runInplace<'a> context wgSize
 
-    makeTest context q scatter
+    makeTest scatter
     |> testPropertyWithConfig config (sprintf "Correctness on %A" typeof<'a>)
 
 let tests =
-    let context = defaultContext.ClContext
-    let config = { defaultConfig with endSize = 1000000 }
-
-    let wgSize = 32
-    let q = defaultContext.Queue
     q.Error.Add(fun e -> failwithf "%A" e)
 
-    [ testFixtures<int> config wgSize context q
-      testFixtures<byte> config wgSize context q
-      testFixtures<bool> config wgSize context q ]
+    [ testFixtures<int>
+      testFixtures<byte>
+      testFixtures<bool> ]
     |> testList "Backend.Common.Scatter tests"