Add downstream ODE solution recursivecopy tests

- Test recursivecopy with ODE solutions and ArrayPartition integration
- Verify struct-based parameter copying in differential equations
- Ensure deep independence of copied solution objects

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: RomeoV

test/downstream/ode_solution_copy_test.jl

@@ -0,0 +1,111 @@
+using OrdinaryDiffEq, RecursiveArrayTools, Test
+
+@testset "ODE Solution recursivecopy tests" begin
+    
+    @testset "Basic ODE solution copying" begin
+        # Define a simple ODE system
+        function simple_ode!(du, u, p, t)
+            du[1] = -0.5 * u[1]
+            du[2] = 0.3 * u[2]
+        end
+        
+        u0 = [1.0, 2.0]
+        tspan = (0.0, 2.0)
+        prob = ODEProblem(simple_ode!, u0, tspan)
+        sol = solve(prob, Tsit5(), saveat=0.5)
+        
+        # Test that we can copy the solution
+        copied_sol = recursivecopy(sol)
+        
+        # Verify the solution structure is preserved
+        @test typeof(copied_sol) == typeof(sol)
+        @test copied_sol.t == sol.t
+        @test copied_sol.u == sol.u
+        @test copied_sol.retcode == sol.retcode
+        
+        # Verify that arrays are independent copies
+        @test copied_sol !== sol
+        @test copied_sol.u !== sol.u
+        @test copied_sol.t !== sol.t
+        
+        # Test that modifying one doesn't affect the other
+        if length(copied_sol.u) > 0
+            original_value = sol.u[1][1]
+            copied_sol.u[1][1] = 999.0
+            @test sol.u[1][1] == original_value  # Original should be unchanged
+        end
+    end
+    
+    @testset "ArrayPartition ODE solution copying" begin
+        # Use the Lorenz system from the existing tests
+        function lorenz!(du, u, p, t)
+            du.x[1][1] = 10.0 * (u.x[2][1] - u.x[1][1])
+            du.x[1][2] = u.x[1][1] * (28.0 - u.x[2][1]) - u.x[1][2]
+            du.x[2][1] = u.x[1][1] * u.x[1][2] - (8/3) * u.x[2][1]
+        end
+        
+        u0 = ArrayPartition([1.0, 0.0], [0.0])
+        tspan = (0.0, 1.0)
+        prob = ODEProblem(lorenz!, u0, tspan)
+        sol = solve(prob, Tsit5(), saveat=0.2)
+        
+        # Test that we can copy the ArrayPartition-based solution
+        copied_sol = recursivecopy(sol)
+        
+        # Verify solution structure
+        @test typeof(copied_sol) == typeof(sol)
+        @test copied_sol.t == sol.t
+        @test length(copied_sol.u) == length(sol.u)
+        
+        # Verify ArrayPartition structure is preserved
+        for i in eachindex(sol.u)
+            @test copied_sol.u[i] isa ArrayPartition
+            @test copied_sol.u[i].x[1] == sol.u[i].x[1]
+            @test copied_sol.u[i].x[2] == sol.u[i].x[2]
+            
+            # Verify independence
+            @test copied_sol.u[i] !== sol.u[i]
+            @test copied_sol.u[i].x[1] !== sol.u[i].x[1]
+            @test copied_sol.u[i].x[2] !== sol.u[i].x[2]
+        end
+    end
+    
+    @testset "Struct-based parameter copying in ODE" begin
+        # Create an ODE with struct-based parameters to test our struct copying
+        struct ODEParams
+            decay_rate::Float64
+            growth_rate::Float64
+            coefficients::Vector{Float64}
+        end
+        
+        function parametric_ode!(du, u, params::ODEParams, t)
+            du[1] = -params.decay_rate * u[1] + params.coefficients[1]
+            du[2] = params.growth_rate * u[2] + params.coefficients[2]
+        end
+        
+        params = ODEParams(0.5, 0.3, [0.1, 0.2])
+        u0 = [1.0, 2.0]
+        tspan = (0.0, 1.0)
+        prob = ODEProblem(parametric_ode!, u0, tspan, params)
+        sol = solve(prob, Tsit5(), saveat=0.5)
+        
+        # Test copying the solution (which contains the struct parameters)
+        copied_sol = recursivecopy(sol)
+        
+        # Verify parameter struct is copied correctly
+        @test copied_sol.prob.p isa ODEParams
+        @test copied_sol.prob.p.decay_rate == sol.prob.p.decay_rate
+        @test copied_sol.prob.p.growth_rate == sol.prob.p.growth_rate
+        @test copied_sol.prob.p.coefficients == sol.prob.p.coefficients
+        
+        # Verify independence
+        @test copied_sol.prob.p !== sol.prob.p
+        @test copied_sol.prob.p.coefficients !== sol.prob.p.coefficients
+        
+        # Test that modifying copied parameters doesn't affect original
+        copied_sol.prob.p.coefficients[1] = 999.0
+        @test sol.prob.p.coefficients[1] == 0.1  # Original unchanged
+    end
+    
+    println("All ODE solution recursivecopy tests completed successfully!")
+end