Consolidate AD-backend tests via shared run_autograd_tests entry point

Move the shared AD-test helpers out of `test/ext/ad_tests.jl` to
`test/autograd_tests.jl` (now used by both `test/ext/` and
`test/integration/` suites) and add a top-level `run_autograd_tests`
umbrella that runs the gradient, jacobian, and empty-input shared tests
on a single adtype. The umbrella supports `namedtuple=true` for
backends with a native NamedTuple path (ForwardDiff, Mooncake) and
`extra_jacobian_modes=(...)` for backends that exercise the jacobian on
multiple modes (Enzyme, Mooncake).

Each per-backend test file now collapses to imports + adtype + a single
`run_autograd_tests(adtype; ...)` call (plus genuinely backend-specific
extras for Enzyme and ReverseDiff).

Also rename test directories to match the rest of the codebase's no-
underscore convention: `forward_diff` -> `forwarddiff` and
`differentiation_interface` -> `differentiationinterface`. The CI ext
matrix and `run_extra.jl` mapping are updated to match.

Net effect: ReverseDiff coverage grows from 9 to 17 (umbrella adds
jacobian and empty-input tests); Enzyme grows from 21 to 29 (empty-
input added, jacobian calls deduplicated through the umbrella).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: yebai

.github/workflows/CI.yml

@@ -53,8 +53,8 @@ jobs:
       matrix:
         label:
           - enzyme
-          - differentiation_interface
-          - forward_diff
+          - differentiationinterface
+          - forwarddiff
           - logdensityproblems
           - mooncake
           - reversediff

ext/AbstractPPLForwardDiffExt.jl

@@ -64,10 +64,10 @@ function AbstractPPL.prepare(
 )
     raw = AbstractPPL.prepare(problem, x)
     evaluator = AbstractPPL.ADProblems.VectorEvaluator{check_dims}(raw, length(x))
-    # Empty inputs short-circuit at the `value_and_*` level; ForwardDiff has no
-    # configuration to build for length-zero arrays.
+    # ForwardDiff has no configuration to build for length-zero arrays; short-circuit
+    # in `value_and_gradient` / `value_and_jacobian` instead.
     length(x) == 0 &&
-        return ForwardDiffPrepared(evaluator, evaluator, nothing, nothing, nothing, nothing)
+        return ForwardDiffPrepared(evaluator, nothing, nothing, nothing, nothing, nothing)
     # Hand ForwardDiff an unchecked wrapper so the per-call dim check does not
     # land in the dual-number hot path; user-visible `prepared(x)` still goes
     # through `evaluator` (whose `check_dims` honors the caller's request).

ext/AbstractPPLMooncakeExt.jl

@@ -47,8 +47,8 @@ function AbstractPPL.prepare(
 )
     raw = AbstractPPL.prepare(problem, x)
     evaluator = AbstractPPL.ADProblems.VectorEvaluator{check_dims}(raw, length(x))
-    # Empty inputs short-circuit at the `value_and_*` level; Mooncake has no
-    # tape to build for length-zero arrays.
+    # Mooncake has no tape to build for length-zero arrays; short-circuit
+    # in `value_and_gradient` / `value_and_jacobian` instead.
     length(x) == 0 && return MooncakePrepared(evaluator, nothing, nothing)
     y = evaluator(x)
     _assert_supported_output(y)

test/autograd_tests.jl

@@ -0,0 +1,134 @@
+# Shared problem definitions and test helpers for AD backend integration tests.
+# Include this file after `using AbstractPPL, Test` and any backend-specific setup.
+
+struct QuadraticProblem end
+struct QuadraticVecPrepared end
+
+function AbstractPPL.prepare(::QuadraticProblem, x::AbstractVector{<:Real})
+    return QuadraticVecPrepared()
+end
+
+function (::QuadraticVecPrepared)(x::AbstractVector{<:Real})
+    return sum(xi -> xi^2, x)
+end
+
+struct VectorValuedProblem end
+struct VectorValuedPrepared end
+
+function AbstractPPL.prepare(::VectorValuedProblem, x::AbstractVector{<:Real})
+    return VectorValuedPrepared()
+end
+
+# y = [x[1]*x[2], x[2]+x[3]] -> J = [x[2] x[1] 0; 0 1 1]
+function (::VectorValuedPrepared)(x::AbstractVector{<:Real})
+    return [x[1] * x[2], x[2] + x[3]]
+end
+
+"""
+    run_shared_gradient_tests(adtype, x0, x; atol=0, rtol=1e-10)
+
+Test the vector-input gradient path for `adtype` on `QuadraticProblem`.
+`x0` is the prototype (zeros), `x = [3.0, 1.0, 2.0]` is the test point.
+"""
+function run_shared_gradient_tests(adtype, x0, x; atol=0, rtol=1e-10)
+    @testset "gradient path" begin
+        problem = QuadraticProblem()
+        prepared = AbstractPPL.prepare(adtype, problem, x0)
+
+        @test prepared(x) ≈ 14.0
+
+        val, grad = AbstractPPL.value_and_gradient(prepared, x)
+        @test val ≈ 14.0 atol = atol rtol = rtol
+        @test grad ≈ [6.0, 2.0, 4.0] atol = atol rtol = rtol
+
+        @test_throws DimensionMismatch prepared([3.0, 1.0, 2.0, 99.0])
+        @test_throws r"floating-point" prepared([3, 1, 2])
+    end
+end
+
+"""
+    run_shared_jacobian_tests(adtype, x0, xj; atol=0, rtol=1e-10)
+
+Test the jacobian path for `adtype` on `VectorValuedProblem`.
+`x0` is the prototype (zeros(3)), `xj` is the test point.
+"""
+function run_shared_jacobian_tests(adtype, x0, xj; atol=0, rtol=1e-10)
+    @testset "jacobian path" begin
+        problem = VectorValuedProblem()
+        prepared = AbstractPPL.prepare(adtype, problem, x0)
+
+        @test prepared(xj) ≈ [6.0, 7.0]
+
+        val, jac = AbstractPPL.value_and_jacobian(prepared, xj)
+        @test val ≈ [6.0, 7.0] atol = atol rtol = rtol
+        @test jac ≈ [3.0 2.0 0.0; 0.0 1.0 1.0] atol = atol rtol = rtol
+
+        @test_throws r"scalar-valued" AbstractPPL.value_and_gradient(prepared, xj)
+    end
+end
+
+"""
+    run_shared_empty_input_tests(adtype)
+
+Test the empty-input short-circuit for `adtype` on both scalar- and
+vector-valued evaluators.
+"""
+function run_shared_empty_input_tests(adtype)
+    @testset "empty input" begin
+        x_empty = Float64[]
+        prepared = AbstractPPL.prepare(adtype, x -> 7.5, x_empty)
+        val, grad = AbstractPPL.value_and_gradient(prepared, x_empty)
+        @test val == 7.5
+        @test grad == Float64[]
+
+        prepared_jac = AbstractPPL.prepare(adtype, x -> [2.0, 3.0], x_empty)
+        valj, jac = AbstractPPL.value_and_jacobian(prepared_jac, x_empty)
+        @test valj == [2.0, 3.0]
+        @test size(jac) == (2, 0)
+    end
+end
+
+"""
+    run_shared_namedtuple_tests(adtype)
+
+Test the NamedTuple-input gradient path for AD backends that support it
+(currently the native ForwardDiff and Mooncake extensions).
+"""
+function run_shared_namedtuple_tests(adtype)
+    @testset "NamedTuple input" begin
+        prepared = AbstractPPL.prepare(
+            adtype, vs -> vs.x^2 + sum(abs2, vs.y), (x=0.0, y=zeros(2))
+        )
+        @test prepared.evaluator isa AbstractPPL.ADProblems.NamedTupleEvaluator
+
+        val, grad = AbstractPPL.value_and_gradient(prepared, (x=3.0, y=[1.0, 2.0]))
+        @test val ≈ 14.0
+        @test grad.x ≈ 6.0
+        @test grad.y ≈ [2.0, 4.0]
+
+        @test_throws r"same NamedTuple structure" AbstractPPL.value_and_gradient(
+            prepared, (x=3.0, z=[1.0, 2.0])
+        )
+    end
+end
+
+"""
+    run_autograd_tests(adtype; namedtuple=false, extra_jacobian_modes=(), kwargs...)
+
+Run the gradient, jacobian, and empty-input shared tests on `adtype`. Pass
+`namedtuple=true` for backends with a native NamedTuple-input path; pass
+`extra_jacobian_modes` to additionally exercise the jacobian path on those
+adtypes. `kwargs` (`atol`, `rtol`, …) are forwarded to the shared helpers.
+"""
+function run_autograd_tests(
+    adtype; namedtuple::Bool=false, extra_jacobian_modes=(), kwargs...
+)
+    run_shared_gradient_tests(adtype, zeros(3), [3.0, 1.0, 2.0]; kwargs...)
+    run_shared_jacobian_tests(adtype, zeros(3), [2.0, 3.0, 4.0]; kwargs...)
+    run_shared_empty_input_tests(adtype)
+    for adtype_jac in extra_jacobian_modes
+        run_shared_jacobian_tests(adtype_jac, zeros(3), [2.0, 3.0, 4.0]; kwargs...)
+    end
+    namedtuple && run_shared_namedtuple_tests(adtype)
+    return nothing
+end

test/ext/ad_tests.jl

@@ -0,0 +1,33 @@
+using Pkg
+Pkg.activate(@__DIR__)
+Pkg.develop(; path=joinpath(@__DIR__, "..", "..", ".."))
+Pkg.instantiate()
+
+using AbstractPPL
+using ADTypes: ADTypes
+using DifferentiationInterface: DifferentiationInterface as DI
+using Test
+
+include(joinpath(@__DIR__, "..", "..", "autograd_tests.jl"))
+
+# Stub backend without a native AbstractPPL extension; this exercises
+# the AbstractPPLDifferentiationInterfaceExt catch-all dispatch.
+struct DummyADType <: ADTypes.AbstractADType end
+const adtype = DummyADType()
+
+DI.prepare_gradient(f, ::DummyADType, x, ::DI.Constant) = Val(:gradient)
+function DI.value_and_gradient(f, prep, ::DummyADType, x, ctx::DI.Constant)
+    return (f(x, ctx.data), 2 .* x)
+end
+DI.prepare_jacobian(f, ::DummyADType, x, ::DI.Constant) = Val(:jacobian)
+function DI.value_and_jacobian(f, prep, ::DummyADType, x, ctx::DI.Constant)
+    jac = [
+        x[2] x[1] zero(eltype(x))
+        zero(eltype(x)) one(eltype(x)) one(eltype(x))
+    ]
+    return (f(x, ctx.data), jac)
+end
+
+@testset "AbstractPPLDifferentiationInterfaceExt" begin
+    run_autograd_tests(adtype; atol=1e-6, rtol=1e-6)
+end