Remove magic and add correctness to testsuite compare function.

Author: maleadt

src/testsuite.jl

@@ -13,25 +13,15 @@ using FFTW
 using FillArrays
 using StaticArrays
 
-toarray(T, x::Tuple{X, Vararg{Int}}) where X = fill(first(x), Base.tail(x))
-toarray(::Type{T}, x::NTuple{N, Int}) where {T <: Bool, N} = rand(T, x)
-toarray(::Type{T}, x::NTuple{N, Int}) where {T <: Integer, N} = rand(T(1):T(10), x)
-toarray(T, x::NTuple{N, Int}) where N = rand(T, x)
-toarray(T, x) = x
-togpu(T, x::AbstractArray) = T(x)
-togpu(T, x) = x
+convert_array(f, x) = f(x)
+convert_array(f, x::Base.RefValue) = x[]
 
-"""
-Calls function `f` on input arrays generated by `sizes` as Base.Array and converted to
-`Typ`. Compares the result of `f` and tests if they agree. `sizes` can be the shape of the
-array, a value or a tuple `(val, shape...)` which will create a `fill(val, shape...)`.
-"""
-function against_base(f, Typ, sizes...)
-    jl_arrays = toarray.(eltype(Typ), sizes)
-    gpu_arrays = togpu.(Typ, jl_arrays)
-    res_jl = f(jl_arrays...)
-    res_gpu = f(gpu_arrays...)
-    @test res_jl ≈ Array(res_gpu)
+function compare(f, Typ, xs...)
+    cpu_in = convert_array.(copy, xs)
+    gpu_in = convert_array.(Typ, xs)
+    cpu_out = f(cpu_in...)
+    gpu_out = f(gpu_in...)
+    cpu_out ≈ Array(gpu_out)
 end
 
 
@@ -52,7 +42,7 @@ function supported_eltypes()
     (Float32, Float64, Int32, Int64, ComplexF32, ComplexF64)
 end
 
-export against_base, run_tests, supported_eltypes
+export run_tests, supported_eltypes
 
 end
 

src/testsuite/base.jl

@@ -47,7 +47,6 @@ function test_base(Typ)
             @test Array(A) ≈ a
         end
 
-
         @testset "copyto!" begin
             x = fill(0f0, (10, 10))
             y = rand(Float32, (20, 10))
@@ -69,17 +68,12 @@ function test_base(Typ)
         end
 
         @testset "vcat + hcat" begin
-            x = fill(0f0, (10, 10))
-            y = rand(Float32, 20, 10)
-            a = Typ(x)
-            b = Typ(y)
-            @test vcat(x, y) == Array(vcat(a, b))
-            z = rand(Float32, 10, 10)
-            c = Typ(z)
-            @test hcat(x, z) == Array(hcat(a, c))
+            @test compare(vcat, Typ, fill(0f0, (10, 10)), rand(Float32, 20, 10))
+            @test compare(hcat, Typ, fill(0f0, (10, 10)), rand(Float32, 10, 10))
 
-            against_base(hcat, Typ{Float32}, (3, 3), (3, 3))
-            against_base(vcat, Typ{Float32}, (3, 3), (3, 3))
+            @test compare(hcat, Typ, rand(Float32, 3, 3), rand(Float32, 3, 3))
+            @test compare(vcat, Typ, rand(Float32, 3, 3), rand(Float32, 3, 3))
+            @test compare((a,b) -> cat(a, b; dims=4), Typ, rand(Float32, 3, 4), rand(Float32, 3, 4))
         end
 
         @testset "reinterpret" begin
@@ -121,18 +115,17 @@ function test_base(Typ)
             @test map!(-, jy, jy) ≈ Array(x)
         end
 
-        T = Typ{Float32}
         @testset "map" begin
-            against_base((a, b)-> map(+, a, b), T, (10,), (10,))
-            against_base((a, b)-> map!(-, a, b), T, (10,), (10,))
-            against_base((a, b, c, d)-> map!(*, a, b, c, d), T, (10,), (10,), (10,), (10,))
+            @test compare((a, b)-> map(+, a, b),    Typ, rand(Float32, 10), rand(Float32, 10))
+            @test compare((a, b)-> map!(-, a, b),   Typ, rand(Float32, 10), rand(Float32, 10))
+            @test compare((a, b, c, d)-> map!(*, a, b, c, d), Typ, rand(Float32, 10), rand(Float32, 10), rand(Float32, 10), rand(Float32, 10))
         end
 
         @testset "repeat" begin
-            against_base(a-> repeat(a, 5, 6), T, (10,))
-            against_base(a-> repeat(a, 5), T, (10,))
-            against_base(a-> repeat(a, 5), T, (5, 4))
-            against_base(a-> repeat(a, 4, 3), T, (10, 15))
+            @test compare(a-> repeat(a, 5, 6),  Typ, rand(Float32, 10))
+            @test compare(a-> repeat(a, 5),     Typ, rand(Float32, 10))
+            @test compare(a-> repeat(a, 5),     Typ, rand(Float32, 5, 4))
+            @test compare(a-> repeat(a, 4, 3),  Typ, rand(Float32, 10, 15))
         end
     end
 end

src/testsuite/blas.jl

@@ -1,21 +1,22 @@
 function test_blas(Typ)
     @testset "BLAS" begin
-        T = Typ{Float32}
         @testset "matmul" begin
-            against_base(*, T, (5, 5), (5, 5))
-            against_base(*, T, (5, 5), (5,))
-            against_base((a, b)-> a * transpose(b), T, (5, 5), (5, 5))
-            against_base((c, a, b)-> mul!(c, a, transpose(b)), T, (10, 32), (10, 60), (32, 60))
-            against_base((a, b)-> transpose(a) * b, T, (5, 5), (5, 5))
-            against_base((a, b)-> transpose(a) * transpose(b), T, (10, 15), (1, 10))
-            against_base((a, b)-> transpose(a) * b, T, (10, 15), (10,))
-            against_base(mul!, T, (15,), (15, 10), (10,))
+            @test compare(*, Typ, rand(Float32, 5, 5), rand(Float32, 5, 5))
+            @test compare(*, Typ, rand(Float32, 5, 5), rand(Float32, 5))
+            @test compare((a, b)-> a * transpose(b), Typ, rand(Float32, 5, 5), rand(Float32, 5, 5))
+            @test compare((c, a, b)-> mul!(c, a, transpose(b)), Typ, rand(Float32, 10, 32), rand(Float32, 10, 60), rand(Float32, 32, 60))
+            @test compare((a, b)-> transpose(a) * b, Typ, rand(Float32, 5, 5), rand(Float32, 5, 5))
+            @test compare((a, b)-> transpose(a) * transpose(b), Typ, rand(Float32, 10, 15), rand(Float32, 1, 10))
+            @test compare((a, b)-> transpose(a) * b, Typ, rand(Float32, 10, 15), rand(Float32, 10))
+            @test compare(mul!, Typ, rand(Float32, 15), rand(Float32, 15, 10), rand(Float32, 10))
         end
+
         for T in (ComplexF32, Float32)
             @testset "rmul! $T" begin
-                against_base(rmul!, Typ{T}, (13, 23), 77f0)
+                @test compare(rmul!, Typ, rand(T, 13, 23), Ref(77f0))
             end
         end
+
         @testset "gbmv" begin
             m, n = 10, 11
             A, x, y = randn(Float32, 3, n), randn(Float32, n), fill(0f0, m)

src/testsuite/broadcasting.jl

@@ -32,60 +32,61 @@ end
 function broadcasting(Typ)
     for ET in supported_eltypes()
         N = 10
-        T = Typ{ET}
         @testset "broadcast $ET" begin
             @testset "RefValue" begin
                 cidx = rand(1:Int(N), 2*N)
                 gidx = Typ(cidx)
-                cy = toarray(ET, (2*N,))
+                cy = rand(ET, 2*N)
                 gy = Typ(cy)
                 cres = fill(zero(ET), size(cidx))
                 gres = Typ(cres)
                 gres .= test_idx.(gidx, Base.RefValue(gy))
                 cres .= test_idx.(cidx, Base.RefValue(cy))
                 @test Array(gres) == cres
             end
+
             @testset "Tuple" begin
-                against_base(T, (3, N), (3, N), (N,), (N,), (N,)) do out, arr, a, b, c
-                    res2 = broadcast!(out, arr, (a, b, c)) do xx, yy
-                        xx + sum(yy)
+                @test compare(Typ, rand(ET, 3, N), rand(ET, 3, N), rand(ET, N), rand(ET, N), rand(ET, N)) do out, arr, a, b, c
+                    broadcast!(out, arr, (a, b, c)) do xx, yy
+                        xx + first(yy)
                     end
                 end
             end
+
             ############
             # issue #27
-            against_base((a, b)-> a .+ b, T, (4, 5, 3), (1, 5, 3))
-            against_base((a, b)-> a .+ b, T, (4, 5, 3), (1, 5, 1))
+            @test compare((a, b)-> a .+ b, Typ, rand(ET, 4, 5, 3), rand(ET, 1, 5, 3))
+            @test compare((a, b)-> a .+ b, Typ, rand(ET, 4, 5, 3), rand(ET, 1, 5, 1))
 
             ############
             # issue #22
             dim = (32, 32)
-            against_base(T, dim, dim, dim) do tmp, a1, a2
+            @test compare(Typ, rand(ET, dim), rand(ET, dim), rand(ET, dim)) do tmp, a1, a2
                 tmp .=  a1 .+ a2 .* ET(2)
             end
 
             ############
             # issue #21
             if ET in (Float32, Float64)
-                against_base((a1, a2)-> muladd.(ET(2), a1, a2), T, dim, dim)
+                @test compare((a1, a2)-> muladd.(ET(2), a1, a2), Typ, rand(ET, dim), rand(ET, dim))
                 #########
                 # issue #41
                 # The first issue is likely https://github.com/JuliaLang/julia/issues/22255
                 # since GPUArrays adds some arguments to the function, it becomes longer longer, hitting the 12
                 # so this wont fix for now
-                against_base(T, dim, dim, dim, dim, dim, dim) do a1, a2, a3, a4, a5, a6
+                @test compare(Typ, rand(ET, dim), rand(ET, dim), rand(ET, dim), rand(ET, dim), rand(ET, dim), rand(ET, dim)) do a1, a2, a3, a4, a5, a6
                     @. a1 = a2 + (1.2) *((1.3)*a3 + (1.4)*a4 + (1.5)*a5 + (1.6)*a6)
                 end
 
-                against_base(T, dim, dim, dim, dim) do u, uprev, duprev, ku
+                @test compare(Typ, rand(ET, dim), rand(ET, dim), rand(ET, dim), rand(ET, dim)) do u, uprev, duprev, ku
                     fract = ET(1//2)
                     dt = ET(1.4)
                     dt2 = dt^2
                     @. u = uprev + dt*duprev + dt2*(fract*ku)
                 end
-                against_base((x) -> (-).(x), T, (2, 3))
+                @test compare((x) -> (-).(x), Typ, rand(ET, 2, 3))
 
-                against_base(T, dim, dim, dim, dim, dim, dim) do utilde, gA, k1, k2, k3, k4
+                @test compare(Typ, rand(ET, dim), rand(ET, dim), rand(ET, dim), rand(ET, dim), rand(ET, dim), rand(ET, dim)) do utilde, gA, k1, k2, k3, k4
                     btilde1 = ET(1)
                     btilde2 = ET(1)
                     btilde3 = ET(1)
@@ -95,19 +96,18 @@ function broadcasting(Typ)
                 end
             end
 
-            against_base((x) -> fill!(x, 1), T, (3,3))
-            against_base((x, y) -> map(+, x, y), T, (2, 3), (2, 3))
+            @test compare((x) -> fill!(x, 1), Typ, rand(ET, 3,3))
+            @test compare((x, y) -> map(+, x, y), Typ, rand(ET, 2, 3), rand(ET, 2, 3))
 
-            against_base((x) -> 2x, T, (2, 3))
-            against_base((x, y) -> x .+ y, T, (2, 3), (1, 3))
-            against_base((z, x, y) -> z .= x .+ y, T, (2, 3), (2, 3), (2,))
+            @test compare((x) -> 2x, Typ, rand(ET, 2, 3))
+            @test compare((x, y) -> x .+ y, Typ, rand(ET, 2, 3), rand(ET, 1, 3))
+            @test compare((z, x, y) -> z .= x .+ y, Typ, rand(ET, 2, 3), rand(ET, 2, 3), rand(ET, 2))
 
-            T = Typ{ET}
-            against_base(A -> A .= identity.(ET(10)), T, (40, 40))
-            against_base(A -> test_kernel.(A, ET(10)), T, (40, 40))
-            against_base(A -> A .* ET(10), T, (40, 40))
-            against_base((A, B) -> A .* B, T, (40, 40), (40, 40))
-            against_base((A, B) -> A .* B .+ ET(10), T, (40, 40), (40, 40))
+            @test compare(A -> A .= identity.(ET(10)), Typ, rand(ET, 40, 40))
+            @test compare(A -> test_kernel.(A, ET(10)), Typ, rand(ET, 40, 40))
+            @test compare(A -> A .* ET(10), Typ, rand(ET, 40, 40))
+            @test compare((A, B) -> A .* B, Typ, rand(ET, 40, 40), rand(ET, 40, 40))
+            @test compare((A, B) -> A .* B .+ ET(10), Typ, rand(ET, 40, 40), rand(ET, 40, 40))
         end
     end
 end

src/testsuite/construction.jl

@@ -1,5 +1,5 @@
 function test_construction(Typ)
-    @testset "Construction" begin
+    @testset "construction" begin
         constructors(Typ)
         conversion(Typ)
         value_constructor(Typ)
@@ -89,7 +89,7 @@ function conversion(Typ)
 end
 
 function value_constructor(Typ)
-    @testset "value constructor" begin
+    @testset "value constructors" begin
         for T in supported_eltypes()
             x = fill(zero(T), (2, 2))
             x1 = fill(Typ{T}, T(0), (2, 2))

src/testsuite/fft.jl

@@ -1,13 +1,12 @@
 function test_fft(Typ)
-    T = Typ{ComplexF32}
     for n = 1:3
         @testset "FFT with ND = $n" begin
-            dims = ntuple(i-> 40, n)
-            against_base(fft!, T, dims)
-            against_base(ifft!, T, dims)
+            dims = ntuple(i -> 40, n)
+            @test compare(fft!, Typ, rand(ComplexF32, dims))
+            @test compare(ifft!, Typ, rand(ComplexF32, dims))
 
-            against_base(fft, T, dims)
-            against_base(ifft, T, dims)
+            @test compare(fft, Typ, rand(ComplexF32, dims))
+            @test compare(ifft, Typ, rand(ComplexF32, dims))
         end
     end
 end

src/testsuite/io.jl

@@ -1,6 +1,6 @@
 function test_io(Typ)
-    @testset "i/o" begin
-        @testset "Showing" begin
+    @testset "input/output" begin
+        @testset "showing" begin
           io = IOBuffer()
           A = Typ([1])
 

src/testsuite/linalg.jl

@@ -1,13 +1,13 @@
 function test_linalg(Typ)
-    T = Typ{Float32}
-    @testset "Linalg" begin
+    @testset "linear algebra" begin
         @testset "transpose" begin
-            against_base(adjoint, T, (32, 32))
+            @test compare(adjoint, Typ, rand(Float32, 32, 32))
         end
-        @testset "PermuteDims" begin
-            against_base(x -> permutedims(x, (2, 1)), T, (2, 3))
-            against_base(x -> permutedims(x, (2, 1, 3)), T, (4, 5, 6))
-            against_base(x -> permutedims(x, (3, 1, 2)), T, (4, 5, 6))
+
+        @testset "permutedims" begin
+            @test compare(x -> permutedims(x, (2, 1)), Typ, rand(Float32, 2, 3))
+            @test compare(x -> permutedims(x, (2, 1, 3)), Typ, rand(Float32, 4, 5, 6))
+            @test compare(x -> permutedims(x, (3, 1, 2)), Typ, rand(Float32, 4, 5, 6))
         end
     end
 end