如何用JUnit5参数化测试所有继承同一基类的类并自动适配新增子类？

要实现对所有Baseclass子类自动执行测试（新增子类无需修改测试代码），不能直接用@ValueSource（它只支持静态指定类），可以通过**类路径扫描+@MethodSource**的方式动态获取所有子类，以下是具体实现：

方案1：纯Java实现类路径扫描 #

无需第三方依赖，自己实现子类扫描逻辑，适配同包下的子类：

import java.io.File;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.util.Arrays;
import java.util.Collections;
import java.util.Enumeration;
import java.util.Objects;
import java.util.stream.Stream;

class Baseclass {
    abstract int method();
}

class A extends Baseclass {
    @Override
    int method() { return 1; }
}

class B extends Baseclass {
    @Override
    int method() { return 2; }
}

// 新增子类C时，无需修改测试代码，自动纳入测试
class C extends Baseclass {
    @Override
    int method() { return 3; }
}

class Testclass {
    @ParameterizedTest
    @MethodSource("baseClassSubclassInstances")
    void test(Baseclass instance) {
        // 执行你的断言逻辑
        assert instance.method() > 0;
    }

    // 提供所有Baseclass子类的实例流
    static Stream<Baseclass> baseClassSubclassInstances() {
        return findAllSubclassesOf(Baseclass.class)
                .map(clazz -> {
                    try {
                        // 实例化子类，若子类有带参构造，需调整此处逻辑
                        return clazz.getDeclaredConstructor().newInstance();
                    } catch (InstantiationException | IllegalAccessException | NoSuchMethodException | InvocationTargetException e) {
                        throw new RuntimeException("无法实例化子类: " + clazz.getName(), e);
                    }
                });
    }

    // 扫描指定父类的所有子类
    private static Stream<Class<? extends Baseclass>> findAllSubclassesOf(Class<Baseclass> parentClass) {
        String packageName = parentClass.getPackageName();
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        String path = packageName.replace('.', '/');

        try {
            Enumeration<URL> resources = classLoader.getResources(path);
            return Collections.list(resources).stream()
                    .flatMap(resource -> {
                        File dir = new File(resource.getFile());
                        if (!dir.exists()) return Stream.empty();
                        return Arrays.stream(dir.listFiles())
                                .filter(file -> file.getName().endsWith(".class"))
                                .map(file -> {
                                    String className = packageName + '.' + file.getName().substring(0, file.getName().length() - 6);
                                    try {
                                        Class<?> clazz = Class.forName(className);
                                        // 过滤出父类的非抽象子类
                                        if (parentClass.isAssignableFrom(clazz) && !clazz.equals(parentClass) && !clazz.isAbstract()) {
                                            return (Class<? extends Baseclass>) clazz;
                                        }
                                    } catch (ClassNotFoundException e) {
                                        e.printStackTrace();
                                    }
                                    return null;
                                })
                                .filter(Objects::nonNull);
                    });
        } catch (IOException e) {
            e.printStackTrace();
            return Stream.empty();
        }
    }
}

方案2：用第三方库简化扫描（推荐） #

使用Reflections库可以大幅简化类路径扫描逻辑，适合跨包或复杂项目：

1. 添加Maven依赖（测试范围）：

<dependency>
    <groupId>org.reflections</groupId>
    <artifactId>reflections</artifactId>
    <version>0.10.2</version>
    <scope>test</scope>
</dependency>

2. 修改测试类的扫描逻辑：

import org.reflections.Reflections;
import java.util.stream.Stream;

class Testclass {
    @ParameterizedTest
    @MethodSource("baseClassSubclassInstances")
    void test(Baseclass instance) {
        assert instance.method() > 0;
    }

    static Stream<Baseclass> baseClassSubclassInstances() {
        return findAllSubclassesOf(Baseclass.class)
                .map(clazz -> {
                    try {
                        return clazz.getDeclaredConstructor().newInstance();
                    } catch (Exception e) {
                        throw new RuntimeException("实例化失败: " + clazz.getName(), e);
                    }
                });
    }

    private static Stream<Class<? extends Baseclass>> findAllSubclassesOf(Class<Baseclass> parentClass) {
        // 扫描指定包下的所有子类
        Reflections reflections = new Reflections(parentClass.getPackageName());
        return reflections.getSubTypesOf(parentClass).stream()
                .filter(clazz -> !clazz.isAbstract()); // 排除抽象子类
    }
}

注意事项 #

• 子类需要有可访问的无参构造函数，若子类只有带参构造，需修改实例化逻辑（比如通过clazz.getDeclaredConstructor(参数类型...)传入对应参数）。
• 扫描范围可根据需求调整，比如new Reflections("com.your.package1", "com.your.package2")指定多个包。
• 若子类是Spring管理的Bean，可通过ApplicationContext.getBeansOfType(Baseclass.class)获取实例，无需手动实例化。

内容的提问来源于stack exchange，提问作者daskai0815