simplify tests

Author: ChrisRackauckas

test/FixedSizeDiffCache/core_dispatch.jl

@@ -41,6 +41,28 @@ results = test(u0, dual, chunk_size)
 @test eltype(results[5]) == eltype(u0)
 @test eltype(results[7]) == eltype(dual)
 
+chunk_size = 5
+u0_B = ones(5, 5)
+dual_B = zeros(ForwardDiff.Dual{ForwardDiff.Tag{typeof(something), Float64}, Float64,
+                                chunk_size}, 2, 2)
+cache_B = FixedSizeDiffCache(u0_B, chunk_size)
+tmp_du_BA = get_tmp(cache_B, u0_B)
+tmp_dual_du_BA = get_tmp(cache_B, dual_B)
+tmp_du_BN = get_tmp(cache_B, u0_B[1])
+tmp_dual_du_BN = get_tmp(cache_B, dual_B[1])
+@test size(tmp_du_BA) == size(u0_B)
+@test typeof(tmp_du_BA) == typeof(u0_B)
+@test eltype(tmp_du_BA) == eltype(u0_B)
+@test size(tmp_dual_du_BA) == size(u0_B)
+@test_broken typeof(tmp_dual_du_BA) == typeof(dual_B)
+@test eltype(tmp_dual_du_BA) == eltype(dual_B)
+@test size(tmp_du_BN) == size(u0_B)
+@test typeof(tmp_du_BN) == typeof(u0_B)
+@test eltype(tmp_du_BN) == eltype(u0_B)
+@test size(tmp_dual_du_BN) == size(u0_B)
+@test_broken typeof(tmp_dual_du_BN) == typeof(dual_B)
+@test eltype(tmp_dual_du_BN) == eltype(dual_B)
+
 #LArray tests
 chunk_size = 4
 u0 = LArray((2, 2); a = 1.0, b = 1.0, c = 1.0, d = 1.0)
@@ -94,3 +116,27 @@ results = test(u0, dual, chunk_size)
 #eltype tests
 @test eltype(results[5]) == eltype(u0)
 @test eltype(results[7]) == eltype(dual)
+
+u0_AP = ArrayPartition(ones(2, 2), ones(3, 3))
+dual_a = zeros(ForwardDiff.Dual{ForwardDiff.Tag{typeof(something), Float64}, Float64,
+                                chunk_size}, 2, 2)
+dual_b = zeros(ForwardDiff.Dual{ForwardDiff.Tag{typeof(something), Float64}, Float64,
+                                chunk_size}, 3, 3)
+dual_AP = ArrayPartition(dual_a, dual_b)
+cache_AP = FixedSizeDiffCache(u0_AP, chunk_size)
+tmp_du_APA = get_tmp(cache_AP, u0_AP)
+tmp_dual_du_APA = get_tmp(cache_AP, dual_AP)
+tmp_du_APN = get_tmp(cache_AP, u0_AP[1])
+tmp_dual_du_APN = get_tmp(cache_AP, dual_AP[1])
+@test size(tmp_du_APA) == size(u0_AP)
+@test typeof(tmp_du_APA) == typeof(u0_AP)
+@test eltype(tmp_du_APA) == eltype(u0_AP)
+@test size(tmp_dual_du_APA) == size(u0_AP)
+@test_broken typeof(tmp_dual_du_APA) == typeof(dual_AP)
+@test eltype(tmp_dual_du_APA) == eltype(dual_AP)
+@test size(tmp_du_APN) == size(u0_AP)
+@test typeof(tmp_du_APN) == typeof(u0_AP)
+@test eltype(tmp_du_APN) == eltype(u0_AP)
+@test size(tmp_dual_du_APN) == size(u0_AP)
+@test_broken typeof(tmp_dual_du_APN) == typeof(dual_AP)
+@test eltype(tmp_dual_du_APN) == eltype(dual_AP)

test/FixedSizeDiffCache/core_odes.jl

@@ -1,6 +1,9 @@
 using LinearAlgebra, OrdinaryDiffEq, Test, PreallocationTools, LabelledArrays,
       RecursiveArrayTools
 
+# upstream
+OrdinaryDiffEq.DiffEqBase.anyeltypedual(x::FixedSizeDiffCache, counter = 0) = Any
+
 #Base array
 function foo(du, u, (A, tmp), t)
     tmp = get_tmp(tmp, u)
@@ -17,12 +20,22 @@ prob = ODEProblem{true, SciMLBase.FullSpecialize}(foo, u0, (0.0, 1.0), (A, cache
 sol = solve(prob, TRBDF2(chunk_size = chunk_size))
 @test sol.retcode == ReturnCode.Success
 
+cache = FixedSizeDiffCache(zeros(5, 5), chunk_size)
+prob = ODEProblem{true, SciMLBase.FullSpecialize}(foo, u0, (0.0, 1.0), (A, cache))
+sol = solve(prob, TRBDF2(chunk_size = chunk_size))
+@test sol.retcode == ReturnCode.Success
+
 #with auto-detected chunk_size
 cache = DiffCache(zeros(5, 5))
 prob = ODEProblem{true, SciMLBase.FullSpecialize}(foo, ones(5, 5), (0.0, 1.0), (A, cache))
 sol = solve(prob, TRBDF2())
 @test sol.retcode == ReturnCode.Success
 
+prob = ODEProblem(foo, ones(5, 5), (0.0, 1.0),
+                  (ones(5, 5), FixedSizeDiffCache(zeros(5, 5))))
+sol = solve(prob, TRBDF2())
+@test sol.retcode == ReturnCode.Success
+
 #Base array with LBC
 function foo(du, u, (A, lbc), t)
     tmp = lbc[u]

test/FixedSizeDiffCache/core_resizing.jl

@@ -24,6 +24,10 @@ end
 df1 = ForwardDiff.derivative(τ -> claytonsample!(stod, τ, 0.0), 0.3)
 @test size(randmat) == size(df1)
 
+stod = FixedSizeDiffCache(sto)
+ForwardDiff.derivative(τ -> claytonsample!(stod, τ), 0.3)
+@test size(randmat) == size(df1)
+
 #calculating the jacobian of claytonsample! with respect to τ and α
 df2 = ForwardDiff.jacobian(x -> claytonsample!(stod, x[1], x[2]), [0.3; 0.0]) #should give a 15x2 array,
 #because ForwardDiff flattens the output of jacobian, see: https://juliadiff.org/ForwardDiff.jl/stable/user/api/#ForwardDiff.jacobian

test/FixedSizeDiffCache/gpu_all.jl

@@ -1,6 +1,9 @@
 using LinearAlgebra, OrdinaryDiffEq, Test, PreallocationTools, CUDA, ForwardDiff,
       ArrayInterfaceCore
 
+# upstream
+OrdinaryDiffEq.DiffEqBase.anyeltypedual(x::FixedSizeDiffCache, counter = 0) = Any
+
 #Dispatch tests
 chunk_size = 5
 u0_CU = cu(ones(5, 5))
@@ -27,6 +30,20 @@ tmp_dual_du_CUN = get_tmp(cache_CU, dual_N)
 @test typeof(tmp_dual_du_CUN) == typeof(dual_CU)
 @test eltype(tmp_dual_du_CUN) == eltype(dual_CU)
 
+chunk_size = 5
+u0_B = cu(ones(5, 5))
+dual_B = cu(zeros(ForwardDiff.Dual{ForwardDiff.Tag{typeof(something), Float32}, Float32,
+                                   chunk_size}, 2, 2))
+cache_B = FixedSizeDiffCache(u0_B, chunk_size)
+tmp_du_BA = get_tmp(cache_B, u0_B)
+tmp_dual_du_BA = get_tmp(cache_B, dual_B)
+@test size(tmp_du_BA) == size(u0_B)
+@test typeof(tmp_du_BA) == typeof(u0_B)
+@test eltype(tmp_du_BA) == eltype(u0_B)
+@test size(tmp_dual_du_BA) == size(u0_B)
+@test typeof(tmp_dual_du_BA) == typeof(dual_B)
+@test eltype(tmp_dual_du_BA) == eltype(dual_B)
+
 #ODE tests
 function foo(du, u, (A, tmp), t)
     tmp = get_tmp(tmp, u)
@@ -43,6 +60,11 @@ prob = ODEProblem{true, SciMLBase.FullSpecialize}(foo, u0, (0.0f0, 1.0f0), (A, c
 sol = solve(prob, TRBDF2(chunk_size = chunk_size))
 @test sol.retcode == ReturnCode.Success
 
+cache = FixedSizeDiffCache(cu(zeros(5, 5)), chunk_size)
+prob = ODEProblem{true, SciMLBase.FullSpecialize}(foo, u0, (0.0f0, 1.0f0), (A, cache))
+sol = solve(prob, TRBDF2(chunk_size = chunk_size))
+@test sol.retcode == ReturnCode.Success
+
 #with auto-detected chunk_size
 u0 = cu(rand(10, 10)) #example kept small for test purposes.
 A = cu(-randn(10, 10))
@@ -51,6 +73,13 @@ prob = ODEProblem{true, SciMLBase.FullSpecialize}(foo, u0, (0.0f0, 1.0f0), (A, c
 sol = solve(prob, TRBDF2())
 @test sol.retcode == ReturnCode.Success
 
+u0 = cu(rand(10, 10)) #example kept small for test purposes.
+A = cu(-randn(10, 10))
+cache = FixedSizeDiffCache(A)
+prob = ODEProblem(foo, u0, (0.0f0, 1.0f0), (A, cache))
+sol = solve(prob, TRBDF2())
+@test sol.retcode == ReturnCode.Success
+
 #resizing tests
 randmat = cu(rand(5, 3))
 sto = similar(randmat)

test/DiffCache/core_dispatch.jl renamed to test/core_dispatch.jl

@@ -11,19 +11,14 @@ function activate_downstream_env()
 end
 
 if GROUP == "All" || GROUP == "Core"
-    @safetestset "DiffCache Dispatch" begin include("DiffCache/core_dispatch.jl") end
-    @safetestset "DiffCache ODE tests" begin include("DiffCache/core_odes.jl") end
-    @safetestset "DiffCache Resizing" begin include("DiffCache/core_resizing.jl") end
-    @safetestset "DiffCache Nested Duals" begin include("DiffCache/core_nesteddual.jl") end
-    @safetestset "DiffCache Sparsity Support" begin include("DiffCache/sparsity_support.jl") end
-
-    @safetestset "FixedSizeDiffCache Dispatch" begin include("FixedSizeDiffCache/core_dispatch.jl") end
-    @safetestset "FixedSizeDiffCache ODE tests" begin include("FixedSizeDiffCache/core_odes.jl") end
-    @safetestset "FixedSizeDiffCache Base Array Resizing" begin include("FixedSizeDiffCache/core_resizing.jl") end
+    @safetestset "DiffCache Dispatch" begin include("core_dispatch.jl") end
+    @safetestset "DiffCache ODE tests" begin include("core_odes.jl") end
+    @safetestset "DiffCache Resizing" begin include("core_resizing.jl") end
+    @safetestset "DiffCache Nested Duals" begin include("core_nesteddual.jl") end
+    @safetestset "DiffCache Sparsity Support" begin include("sparsity_support.jl") end
 end
 
 if !is_APPVEYOR && GROUP == "GPU"
     activate_downstream_env()
-    @safetestset "GPU tests" begin include("FixedSizeDiffCache/gpu_all.jl") end
-    @safetestset "GPU tests" begin include("DiffCache/gpu_all.jl") end
+    @safetestset "GPU tests" begin include("gpu_all.jl") end
 end