test: assert new error messages in ComposableExpression

Author: MilesCranmer

test/test_composable_expression.jl

@@ -130,6 +130,43 @@ end
     @test ex(x1_val, x2_val).valid == false
 end
 
+@testitem "ValidVector helpful error messages" tags = [:part2] begin
+    using SymbolicRegression
+    using SymbolicRegression: ValidVector, ValidVectorMixError, ValidVectorAccessError
+
+    vv = ValidVector([1.0, 2.0], true)
+    v = [3.0, 4.0]
+
+    # Helper function to get error message
+    get_error_msg(err) =
+        let io = IOBuffer()
+            Base.showerror(io, err)
+            String(take!(io))
+        end
+
+    # Test vector arithmetic errors encourage ValidVector wrapping
+    err_mix = @test_throws ValidVectorMixError vv + v
+    @test_throws ValidVectorMixError v * vv  # Test other direction too
+
+    mix_msg = get_error_msg(err_mix.value)
+    @test contains(
+        mix_msg,
+        "ValidVector handles validity checks, auto-vectorization, and batching in template expressions",
+    )
+
+    # Test array access errors mention .x and .valid
+    err_access = @test_throws ValidVectorAccessError vv[1]
+    @test_throws ValidVectorAccessError length(vv)
+    @test_throws ValidVectorAccessError push!(vv, 5.0)
+
+    access_msg = get_error_msg(err_access.value)
+    @test contains(access_msg, "valid_ar.x[1]")
+    @test contains(access_msg, "valid_ar.valid")
+    @test contains(access_msg, "length(valid_ar.x)")
+    @test contains(access_msg, "doesn't support direct array operations")
+    @test contains(access_msg, "ValidVector handles validity/batching automatically")
+end
+
 @testitem "Test Number inputs" tags = [:part2] begin
     using SymbolicRegression: ComposableExpression, Node, ValidVector
     using DynamicExpressions: OperatorEnum

test/test_template_expression.jl

@@ -657,3 +657,38 @@ end
         parse_guesses(PopMember{Float64,Float64}, [bad_guess], [dataset], options)
     )
 end
+
+@testitem "Template expression return validation" tags = [:part2] begin
+    using SymbolicRegression:
+        TemplateReturnError,
+        ValidVector,
+        ComposableExpression,
+        TemplateStructure,
+        TemplateExpression
+    using DynamicExpressions: OperatorEnum, Node
+
+    operators = OperatorEnum(; binary_operators=(+, *, /, -), unary_operators=(sin, cos))
+    x1 = ComposableExpression(Node{Float64}(; feature=1); operators, variable_names=nothing)
+
+    # Test that returning a regular vector from template expression throws TemplateReturnError
+    bad_structure = TemplateStructure{(:f,)}(
+        ((; f), (x,)) -> [1.0, 2.0];  # Returns regular Vector instead of ValidVector
+        num_features=(; f=1),
+    )
+    bad_expr = TemplateExpression(
+        (; f=x1); structure=bad_structure, operators, variable_names=nothing
+    )
+    X = [1.0 2.0]'
+
+    function get_error_msg(err)
+        io = IOBuffer()
+        Base.showerror(io, err)
+        return String(take!(io))
+    end
+
+    err = @test_throws TemplateReturnError bad_expr(X)
+    msg = get_error_msg(err.value)
+    @test contains(msg, "Template expression returned a regular Vector")
+    @test contains(msg, "ValidVector is required")
+    @test contains(msg, "ValidVector(my_data, computation_is_valid)")
+end