test: more comprehensive tests

Author: AayushSabharwal

test/basic_indexing.jl

@@ -36,9 +36,33 @@ recs = [rand(8) for i in 1:10]
 testa = cat(recs..., dims = 2)
 testva = VectorOfArray(recs)
 
+# Array functions
+@test size(testva) == (8, 10)
+@test axes(testva) == Base.OneTo.((8, 10))
+@test ndims(testva) == 2
+@test eltype(testva) == eltype(eltype(recs))
+testvasim = similar(testva)
+@test size(testvasim) == size(testva)
+@test eltype(testvasim) == eltype(testva)
+testvasim = similar(testva, Float32)
+@test size(testvasim) == size(testva)
+@test eltype(testvasim) == Float32
+testvb = deepcopy(testva)
+@test testva == testvb == recs
+
+# Math operations
+@test testva + testvb == testva + recs == 2testva == 2 .* recs
+@test testva - testvb == testva - recs == 0 .* recs
+@test testva / 2 == recs ./ 2
+@test 2 .\ testva == 2 .\ recs
+
 # ## Linear indexing
 @test_deprecated testva[1]
 @test_deprecated testva[1:2]
+@test_deprecated testva[begin]
+@test_deprecated testva[end]
+@test testva[begin] == testva[:, begin] == first(testva)
+@test testva[end] == testva[:, end] == last(testva)
 @test testa[:, 1] == recs[1]
 @test testva.u == recs
 @test testva[: ,2:end] == VectorOfArray([recs[i] for i in 2:length(recs)])

test/downstream/symbol_indexing.jl

@@ -21,6 +21,9 @@ sol_new = DiffEqArray(sol.u[1:10],
 @test sol_new[RHS] ≈ (1 .- sol_new[x]) ./ 3.0
 @test sol_new[t] ≈ sol_new.t
 @test sol_new[t, 1:5] ≈ sol_new.t[1:5]
+@test sol.ps[τ] == sol_new.ps[τ] == 3.0
+@test_deprecated sol[τ]
+@test_deprecated sol_new[τ]
 
 # Tables interface
 test_tables_interface(sol_new, [:timestamp, Symbol("x(t)")], hcat(sol_new[t], sol_new[x]))

test/symbolic_indexing_interface_test.jl

@@ -1,26 +1,49 @@
-using RecursiveArrayTools, Test, LabelledArrays
+using RecursiveArrayTools, Test, LabelledArrays, SymbolicIndexingInterface
 
 t = 0.0:0.1:1.0
 f(x) = 2x
 f2(x) = 3x
 
 dx = DiffEqArray([[f(x), f2(x)] for x in t],
-    t;
+    t,
+    [1.0, 2.0];
     variables = [:a, :b],
+    parameters = [:p, :q],
     independent_variables = [:t])
 @test dx[:t] == t
 @test dx[:a] == [f(x) for x in t]
-@test dx[:b] == [f2(x) for x in t]
-
-dx = DiffEqArray([[f(x), f2(x)] for x in t],
-    t;
-    variables = [:a, :b],
-    independent_variables = [:t])
+@test dx[:a, 2] ≈ f(t[2])
+@test dx[:b, 3] ≈ f2(t[3])
+@test dx[:a, 2:4] ≈ [f(x) for x in t[2:4]]
+@test dx[:b, 4:6] ≈ [f2(x) for x in t[4:6]]
+@test dx[:b] ≈ [f2(x) for x in t]
+@test dx[[:a, :b]] ≈ [[f(x), f2(x)] for x in t]
+@test dx[(:a, :b)] == [(f(x), f2(x)) for x in t]
+@test dx[[:a, :b], 3] ≈ [f(t[3]), f2(t[3])]
+@test dx[[:a, :b], 4:5] ≈ vcat(f.(t[4:5])', f2.(t[4:5])')
+@test dx.ps[[:p, :q]] == [1.0, 2.0]
+@test dx.ps[:p] == 1.0
+@test dx.ps[:q] == 2.0
 @test dx[:t] == t
+
+@test symbolic_container(dx) isa SymbolCache
+@test parameter_values(dx) == [1.0, 2.0]
+@test is_variable.((dx,), [:a, :b, :p, :q, :t]) == [true, true, false, false, false]
+@test variable_index.((dx,), [:a, :b, :p, :q, :t]) == [1, 2, nothing, nothing, nothing]
+@test is_parameter.((dx,), [:a, :b, :p, :q, :t]) == [false, false, true, true, false]
+@test parameter_index.((dx,), [:a, :b, :p, :q, :t]) == [nothing, nothing, 1, 2, nothing]
+@test is_independent_variable.((dx,), [:a, :b, :p, :q, :t]) == [false, false, false, false, true]
+@test variable_symbols(dx) == [:a, :b]
+@test parameter_symbols(dx) == [:p, :q]
+@test independent_variable_symbols(dx) == [:t]
+@test is_time_dependent(dx)
+@test constant_structure(dx)
+
 dx = DiffEqArray([[f(x), f2(x)] for x in t], t; variables = [:a, :b])
 @test_throws Exception dx[nothing] # make sure it isn't storing [nothing] as indepsym
 
 ABC = @SLVector (:a, :b, :c);
 A = ABC(1, 2, 3);
 B = RecursiveArrayTools.DiffEqArray([A, A], [0.0, 2.0]);
 @test getindex(B, :a) == [1, 1]
+