Add tests, generated by Claude Code

Author: RomeoV

test/struct_copy_test.jl

@@ -0,0 +1,151 @@
+using RecursiveArrayTools, Test
+
+# Test structures for struct-aware recursivecopy
+struct SimpleStruct
+    a::Int
+    b::Float64
+end
+
+mutable struct MutableStruct
+    a::Vector{Float64}
+    b::Matrix{Int}
+    c::String
+end
+
+struct NestedStruct
+    simple::SimpleStruct
+    mutable::MutableStruct
+    array::Vector{Int}
+end
+
+struct ParametricStruct{T}
+    data::Vector{T}
+    metadata::T
+end
+
+@testset "Struct recursivecopy tests" begin
+    
+    @testset "Simple immutable struct" begin
+        original = SimpleStruct(42, 3.14)
+        copied = recursivecopy(original)
+        
+        @test copied isa SimpleStruct
+        @test copied.a == original.a
+        @test copied.b == original.b
+        # Note: For immutable structs with only primitive types, Julia may optimize 
+        # to use the same memory location, so we test functionality rather than identity
+    end
+    
+    @testset "Mutable struct with arrays" begin
+        original = MutableStruct([1.0, 2.0, 3.0], [1 2; 3 4], "test")
+        
+        # Should error for mutable structs
+        @test_throws ErrorException("recursivecopy for mutable structs is not currently implemented. Use deepcopy instead.") recursivecopy(original)
+    end
+    
+    @testset "Nested struct" begin
+        simple = SimpleStruct(10, 2.5)
+        # Create a nested struct with only immutable components
+        struct ImmutableNested
+            simple::SimpleStruct
+            array::Vector{Int}
+            name::String
+        end
+        
+        original = ImmutableNested(simple, [100, 200, 300], "nested")
+        copied = recursivecopy(original)
+        
+        @test copied isa ImmutableNested
+        @test copied.simple.a == original.simple.a
+        @test copied.simple.b == original.simple.b
+        @test copied.array == original.array
+        @test copied.name == original.name
+        
+        @test copied !== original
+        @test copied.array !== original.array
+        
+        # Test independence
+        original.array[1] = 999
+        @test copied.array[1] == 100  # Should remain unchanged
+    end
+    
+    @testset "Parametric struct" begin
+        original = ParametricStruct([1, 2, 3], 42)
+        copied = recursivecopy(original)
+        
+        @test copied isa ParametricStruct{Int}
+        @test copied.data == original.data
+        @test copied.metadata == original.metadata
+        @test copied !== original
+        @test copied.data !== original.data
+    end
+    
+    @testset "Compatibility with existing types" begin
+        # Test that arrays still work
+        arr = [1, 2, 3]
+        copied_arr = recursivecopy(arr)
+        @test copied_arr == arr
+        @test copied_arr !== arr
+        
+        # Test that numbers still work
+        num = 42
+        copied_num = recursivecopy(num)
+        @test copied_num == num
+        
+        # Test that strings still work
+        str = "hello"
+        copied_str = recursivecopy(str)
+        @test copied_str == str
+    end
+    
+    @testset "ArrayPartition with structs" begin
+        simple1 = SimpleStruct(1, 1.0)
+        simple2 = SimpleStruct(2, 2.0)
+        ap = ArrayPartition([simple1, simple2])
+        copied_ap = recursivecopy(ap)
+        
+        @test copied_ap isa ArrayPartition
+        @test length(copied_ap.x) == length(ap.x)
+        @test copied_ap.x[1][1].a == ap.x[1][1].a
+        @test copied_ap !== ap
+        @test copied_ap.x[1] !== ap.x[1]
+    end
+    
+    @testset "Array dispatch still works correctly" begin
+        # Test that our struct method doesn't interfere with existing array methods
+        
+        # Arrays of numbers should use copy
+        num_array = [1, 2, 3]
+        copied_num = recursivecopy(num_array)
+        @test copied_num == num_array
+        @test copied_num !== num_array
+        
+        # Arrays of arrays should recursively copy
+        nested_array = [[1, 2], [3, 4]]
+        copied_nested = recursivecopy(nested_array)
+        @test copied_nested == nested_array
+        @test copied_nested !== nested_array
+        @test copied_nested[1] !== nested_array[1]
+        @test copied_nested[2] !== nested_array[2]
+        
+        # AbstractVectorOfArray should use its method
+        ap = ArrayPartition([1.0, 2.0], [3, 4])
+        copied_ap = recursivecopy(ap)
+        @test copied_ap isa ArrayPartition
+        @test copied_ap.x[1] == ap.x[1]
+        @test copied_ap.x[1] !== ap.x[1]
+        
+        # Test that structs containing arrays still work
+        struct StructWithArrays
+            data::Vector{Vector{Int}}
+            metadata::String
+        end
+        
+        original_struct = StructWithArrays([[1, 2], [3, 4]], "test")
+        copied_struct = recursivecopy(original_struct)
+        @test copied_struct.data == original_struct.data
+        @test copied_struct.data !== original_struct.data
+        @test copied_struct.data[1] !== original_struct.data[1]
+        @test copied_struct.metadata == original_struct.metadata
+    end
+end