Restructure the testsuite a little.

Author: maleadt

src/GPUArrays.jl

@@ -1,20 +1,18 @@
-__precompile__(true)
 module GPUArrays
 
 using Serialization
 using Random
 using LinearAlgebra
 using Printf
-import Base: copyto!
 
 import Random: rand, rand!
 using LinearAlgebra.BLAS
-using FFTW
-import FFTW: *, plan_ifft!, plan_fft!, plan_fft, plan_ifft, size, plan_bfft, plan_bfft!
 import Base: pointer, similar, size, convert
 using Base: @propagate_inbounds, @pure, RefValue
 using Base.Cartesian
-using Random
+
+using FFTW
+import FFTW: *, plan_ifft!, plan_fft!, plan_fft, plan_ifft, size, plan_bfft, plan_bfft!
 
 include("abstractarray.jl")
 include("abstract_gpu_interface.jl")
@@ -30,10 +28,12 @@ include("linalg.jl")
 include("mapreduce.jl")
 include("vectors.jl")
 include("convolution.jl")
-include("testsuite/testsuite.jl")
-include("jlbackend.jl")
 include("random.jl")
 
+include("array.jl")
+
+include("testsuite.jl")
+
 export GPUArray, gpu_call, thread_blocks_heuristic, global_size, synchronize_threads
 export linear_index, @linearidx, @cartesianidx, convolution!, device, synchronize
 export JLArray

src/jlbackend.jl renamed to src/array.jl

@@ -0,0 +1,74 @@
+# Abstract test suite that can be used for all packages inheriting from GPUArray
+
+module TestSuite
+
+using GPUArrays
+using GPUArrays: mapidx, gpu_sub2ind
+
+using LinearAlgebra
+using Random
+using Test
+
+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
+
+"""
+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)
+end
+
+
+include("testsuite/blas.jl")
+include("testsuite/broadcasting.jl")
+include("testsuite/construction.jl")
+include("testsuite/fft.jl")
+include("testsuite/gpuinterface.jl")
+include("testsuite/linalg.jl")
+include("testsuite/mapreduce.jl")
+include("testsuite/base.jl")
+include("testsuite/indexing.jl")
+# include("testsuite/vector.jl")
+include("testsuite/random.jl")
+
+function supported_eltypes()
+    (Float32, Float64, Int32, Int64, ComplexF32, ComplexF64)
+end
+
+export against_base, run_tests, supported_eltypes
+
+end
+
+
+"""
+Runs the GPUArrays test suite on array type `Typ`
+"""
+function test(Typ)
+    GPUArrays.allowslow(false)
+    TestSuite.test_gpuinterface(Typ)
+    TestSuite.test_base(Typ)
+    TestSuite.test_blas(Typ)
+    TestSuite.test_broadcasting(Typ)
+    TestSuite.test_construction(Typ)
+    TestSuite.test_fft(Typ)
+    TestSuite.test_linalg(Typ)
+    TestSuite.test_mapreduce(Typ)
+    TestSuite.test_indexing(Typ)
+    TestSuite.test_random(Typ)
+end

src/testsuite.jl

@@ -26,7 +26,7 @@ function ntuple_closure(state, result, ::Val{N}, testval) where N
     return
 end
 
-function run_base(Typ)
+function test_base(Typ)
     @testset "base functionality" begin
         @testset "mapidx" begin
             a = rand(ComplexF32, 77)

src/testsuite/base.jl

@@ -1,6 +1,4 @@
-using LinearAlgebra
-
-function run_blas(Typ)
+function test_blas(Typ)
     @testset "BLAS" begin
         T = Typ{Float32}
         @testset "matmul" begin

src/testsuite/blas.jl

@@ -1,9 +1,7 @@
-
-
-function run_broadcasting(Typ)
+function test_broadcasting(Typ)
     @testset "broadcast" begin
-        test_broadcast(Typ)
-        test_vec3(Typ)
+        broadcasting(Typ)
+        vec3(Typ)
     end
 end
 
@@ -31,16 +29,15 @@ function test_kernel(a::T, b) where T
     return c
 end
 
-
-function test_broadcast(Typ)
+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 = TestSuite.toarray(ET, (2*N,))
+                cy = toarray(ET, (2*N,))
                 gy = Typ(cy)
                 cres = fill(zero(ET), size(cidx))
                 gres = Typ(cres)
@@ -115,7 +112,7 @@ function test_broadcast(Typ)
     end
 end
 
-function test_vec3(Typ)
+function vec3(Typ)
     @testset "vec 3" begin
         N = 20
 

src/testsuite/broadcasting.jl

@@ -1,6 +1,4 @@
-using FillArrays
-
-function run_construction(Typ)
+function test_construction(Typ)
     @testset "Construction" begin
         constructors(Typ)
         conversion(Typ)

src/testsuite/construction.jl

@@ -1,5 +1,4 @@
-
-function run_fft(Typ)
+function test_fft(Typ)
     T = Typ{ComplexF32}
     for n = 1:3
         @testset "FFT with ND = $n" begin

src/testsuite/fft.jl

@@ -1,4 +1,4 @@
-function run_gpuinterface(Typ)
+function test_gpuinterface(Typ)
     @testset "parallel execution interface" begin
         N = 10
         x = Typ(Vector{Int}(undef, N))

src/testsuite/gpuinterface.jl

@@ -1,6 +1,4 @@
-
-
-function run_indexing(Typ)
+function test_indexing(Typ)
     @testset "indexing" begin
         for T in (Float32, Int32#=, SVector{3, Float32}=#)
             @testset "Indexing with $T" begin