Junit执行器Runner探索之旅 | 京东云技术团队-低调大师

Junit执行器Runner探索之旅 | 京东云技术团队

2023-06-13 235

单元测试是每个程序员必备的技能，而Runner是每个单元测试类必有属性。本文通过解读Junit源码，介绍junit中每个执行器的使用方法，让读者在单元测试时，可以灵活的使用Runner执行器。

一、背景

在今年的敏捷团队建设中，京东物流通过Suite执行器实现了一键自动化单元测试。Juint除了Suite执行器还有哪些执行器呢？由此京东物流的Runner探索之旅开始了！

二、RunWith

RunWith的注释是当一个类用@RunWith注释或扩展一个用@RunWith注释的类时，JUnit将调用它引用的类来运行该类中的测试，而不是内置到JUnit中的运行器，就是测试类根据指定运行方式进行运行。

代码如下：

public @interface RunWith {
    Class<? extends Runner> value();
}

其中：Runner 就是指定的运行方式。

三、Runner

Runner的作用是告诉Junit如何运行一个测试类，它是一个抽象类。通过RunWith 指定具体的实现类，如果不指定默认使用BlockJUnit4ClassRunner，Runner的代码如下：

public abstract class Runner implements Describable {
    public abstract Description getDescription();
    public abstract void run(RunNotifier notifier);
    public int testCount() {
        return getDescription().testCount();
    }
}

3.1 ParentRunner

ParentRunner是一个抽象类，提供了大多数特定于运行器的功能，是经常使用运行器的父节点。实现了Filterable,Sortable接口，可以过滤和排序子对象。

提供了3个抽象方法：

protected abstract List<T> getChildren();
protected abstract Description describeChild(T child);
protected abstract void runChild(T child, RunNotifier notifier);

3.1.1 BlockJUnit4ClassRunner

BlockJUnit4ClassRunner是Juint4默认的运行器，具有与旧的测试类运行器(JUnit4ClassRunner)完全相同的行为。

ParentRunner3个抽象方法的实现如下：

@Override
protected void runChild(final FrameworkMethod method, RunNotifier notifier) {
    Description description = describeChild(method);
    if (isIgnored(method)) {
        notifier.fireTestIgnored(description);
    } else {
        runLeaf(methodBlock(method), description, notifier);
    }
}
@Override
protected Description describeChild(FrameworkMethod method) {
    Description description = methodDescriptions.get(method);


    if (description == null) {
        description = Description.createTestDescription(getTestClass().getJavaClass(),
                testName(method), method.getAnnotations());
        methodDescriptions.putIfAbsent(method, description);
    }


    return description;
}
@Override
protected List<FrameworkMethod> getChildren() {
    return computeTestMethods();
}

runChild() :

调用describeChild()
判断方法是否包含@Ignore注解，有就触发TestIgnored事件通知
构造Statement回调，通过methodBlock()构造并装饰测试方法
执行测试方法调用statement.evaluate()

describeChild() : 对测试方法创建Description并进行缓存

getChildren():返回运行测试的方法。默认实现返回该类和超类上所有用@Test标注的未重写的方法

3.1.2 BlockJUnit4ClassRunnerWithParameters

BlockJUnit4ClassRunnerWithParameters是一个支持参数的BlockJUnit4ClassRunner。参数可以通过构造函数注入或注入到带注释的字段中。参数包含名称、测试类和一组参数。

private final Object[] parameters;
private final String name;
public BlockJUnit4ClassRunnerWithParameters(TestWithParameters test)
        throws InitializationError {
    super(test.getTestClass().getJavaClass());
    parameters = test.getParameters().toArray(
            new Object[test.getParameters().size()]);
    name = test.getName();
}

参数代码如下：

public class TestWithParameters {
    private final String name;
    private final TestClass testClass;
    private final List<Object> parameters;
    public TestWithParameters(String name, TestClass testClass,
            List<Object> parameters) {
        notNull(name, "The name is missing.");
        notNull(testClass, "The test class is missing.");
        notNull(parameters, "The parameters are missing.");
        this.name = name;
        this.testClass = testClass;
        this.parameters = unmodifiableList(new ArrayList<Object>(parameters));
    }

BlockJUnit4ClassRunnerWithParameters一般结合Parameterized使用

3.1.3 Theories

Theories允许对无限数据点集的子集测试某种功能。提供一组参数的排列组合值作为待测方法的输入参数。同时注意到在使用Theories这个Runner的时候，待测方法可以拥有输入参数，可以使您的测试更加灵活。

测试代码如下：

@RunWith(Theories.class)
public class TheoriesTest {
    @DataPoints
    public static String[] tables = {"方桌子", "圆桌子"};
    @DataPoints
    public static int[] counts = {4,6,8};
    @Theory
    public void testMethod(String table, int count){
        System.out.println(String.format("一套桌椅有一个%s和%d个椅子", table, count));
    }
}

运行结果：

图2 Theories测试代码的执行结果

3.1.4 JUnit4

JUnit4是Junit4默认执行器的别名，想要显式地将一个类标记为JUnit4类,应该使用@RunWith(JUnit4.class)，而不是，使用@RunWith(BlockJUnit4ClassRunner.class)

3.1.5 Suite

Suite允许您手动构建包含来自许多类的测试的套件.通过Suite.SuiteClasses定义要执行的测试类，一键执行所有的测试类。

测试代码如下：

@RunWith(Suite.class)
@Suite.SuiteClasses({Suite_test_a.class,Suite_test_b.class,Suite_test_c.class })
public class Suite_main {
}
public class Suite_test_a {
    @Test
    public void testRun(){
        System.out.println("Suite_test_a_running");
    }
}
public class Suite_test_b {
    @Test
    public void testRun(){
        System.out.println("Suite_test_b_running");
    }
}
public class Suite_test_c {
    @Test
    public void testRun(){
        System.out.println("Suite_test_c_running");
    }
}

执行结果：

图3 Suite测试代码的执行结果

如结果所示：执行MainSuit时依次执行了Suite_test_a，Suite_test_b,Suite_test_c 的方法，实现了一键执行。

3.1.6 Categories

Categories在给定的一组测试类中，只运行用带有@ inclecategory标注的类别或该类别的子类型标注的类和方法。通过ExcludeCategory过滤类型。

测试代码如下：

public interface BlackCategory {}
public interface WhiteCategory {}


public class Categories_test_a {
    @Test
    @Category(BlackCategory.class)
    public void testFirst(){
        System.out.println("Categories_test_a_testFirst_running");
    }
    @Test
    @Category(WhiteCategory.class)
    public void testSecond(){
        System.out.println("Categories_test_a_testSecond_running");
    }
}


public class Categories_test_b {
    @Test
    @Category(WhiteCategory.class)
    public void testFirst(){
        System.out.println("Categories_test_b_testFirst_running");
    }
    @Test
    @Category(BlackCategory.class)
    public void testSecond(){
        System.out.println("Categories_test_b_testSecond_running");
    }
}

执行带WhiteCategory的方法

@RunWith(Categories.class)
@Categories.IncludeCategory(WhiteCategory.class)
@Categories.ExcludeCategory(BlackCategory.class)
@Suite.SuiteClasses( { Categories_test_a.class, Categories_test_b.class })
public class Categories_main {
}

运行结果:

图4 Categories测试代码WhiteCategory分组执行结果

执行带BlackCategory的方法

@RunWith(Categories.class)
@Categories.IncludeCategory(BlackCategory.class)
@Categories.ExcludeCategory(WhiteCategory.class)
@Suite.SuiteClasses( { Categories_test_a.class, Categories_test_b.class })
public class Categories_main {
}

运行结果：

图5 Categories测试代码BlackCategory分组执行结果

如运行结果所示，通过IncludeCategory，ExcludeCategory可以灵活的运行具体的测试类和方法。

3.1.7 Enclosed

Enclosed使用Enclosed运行外部类，内部类中的测试将被运行。您可以将测试放在内部类中，以便对它们进行分组或共享常量。

测试代码：

public class EnclosedTest {
   @Test
    public  void runOutMethou(){
        System.out.println("EnclosedTest_runOutMethou_running");
    }
    public static class EnclosedInnerTest {
        @Test
       public  void runInMethou(){
            System.out.println("EnclosedInnerTest_runInMethou_running");
        }
    }
}

运行结果：没有执行内部类的测试方法。

图6 Enclosed测试代码的执行结果

使用Enclosed执行器：

@RunWith(Enclosed.class)
public class EnclosedTest {
   @Test
    public  void runOutMethou(){
        System.out.println("EnclosedTest_runOutMethou_running");
    }
    public static class EnclosedInnerTest {
        @Test
       public  void runInMethou(){
            System.out.println("EnclosedInnerTest_runInMethou_running");
        }
    }
}

执行结果：执行了内部类的测试方法。

图7 Enclosed测试代码的执行结果

3.1.8 Parameterized

Parameterized实现参数化测试。运行参数化的测试类时，会为测试方法和测试数据元素的交叉乘积创建实例。

Parameterized包含一个提供数据的方法，这个方法必须增加Parameters注解，并且这个方法必
须是静态static的，并且返回一个集合Collection，Collection中的值长度必须相等。

测试代码：

@RunWith(Parameterized.class)
public class ParameterizedTest {
    @Parameterized.Parameters
    public static Collection<Object[]> initData(){
       return Arrays.asList(new Object[][]{
               {"小白",1,"鸡腿"},{"小黑",2,"面包"},{"小红",1,"苹果"}
       });
    }
    private String name;
    private int  count;
    private String food;


    public ParameterizedTest(String name, int count, String food) {
        this.name = name;
        this.count = count;
        this.food = food;
    }
    @Test
    public void eated(){
       System.out.println(String.format("%s中午吃了%d个%s",name,count,food));
    }
}

运行结果：

图8 Parameterized测试代码的执行结果

3.2 JUnit38ClassRunner

JUnit38ClassRunner及其子类是Junit4的内部运行器，有一个内部类OldTestClassAdaptingListener

实现了TestListener接口。

3.3 ErrorReportingRunner

ErrorReportingRunner也是Junit4运行错误时抛出的异常，代码如下：

private final List<Throwable> causes;


public ErrorReportingRunner(Class<?> testClass, Throwable cause) {
    if (testClass == null) {
        throw new NullPointerException("Test class cannot be null");
    }
    this.testClass = testClass;
    causes = getCauses(cause);
}


    private List<Throwable> getCauses(Throwable cause) {
        if (cause instanceof InvocationTargetException) {
            return getCauses(cause.getCause());
        }
        if (cause instanceof InitializationError) {
            return ((InitializationError) cause).getCauses();
        }
        if (cause instanceof org.junit.internal.runners.InitializationError) {
            return ((org.junit.internal.runners.InitializationError) cause)
                    .getCauses();
        }
        return Arrays.asList(cause);
    }

当junit运行错误时，会抛出ErrorReportingRunner，例如：

public Runner getRunner() {
    try {
        Runner runner = request.getRunner();
        fFilter.apply(runner);
        return runner;
    } catch (NoTestsRemainException e) {
        return new ErrorReportingRunner(Filter.class, new Exception(String
                .format("No tests found matching %s from %s", fFilter
                        .describe(), request.toString())));
    }
}

3.4 IgnoredClassRunner

IgnoredClassRunner是当测试的方法包含Ignore注解时，会忽略该方法。

public class IgnoredClassRunner extends Runner {
    private final Class<?> clazz;
    public IgnoredClassRunner(Class<?> testClass) {
        clazz = testClass;
    }
    @Override
    public void run(RunNotifier notifier) {
        notifier.fireTestIgnored(getDescription());
    }
    @Override
    public Description getDescription() {
        return Description.createSuiteDescription(clazz);
    }
}

IgnoredClassRunner的使用

public class IgnoredBuilder extends RunnerBuilder {
    @Override
    public Runner runnerForClass(Class<?> testClass) {
        if (testClass.getAnnotation(Ignore.class) != null) {
            return new IgnoredClassRunner(testClass);
        }
        return null;
    }
}

当测试时想忽略某些方法时，可以通过继承IgnoredClassRunner增加特定注解实现。

四、小结

Runner探索之旅结束了，可是单元测试之路才刚刚开始。不同的Runner组合，让单元测试更加灵活，测试场景更加丰富，更好的实现了测试驱动开发，让系统更加牢固可靠。

作者：京东物流陈昌浩

来源：京东云开发者社区

微信关注我们

原文链接：https://my.oschina.net/u/4090830/blog/10074258

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

插件化工程R文件瘦身技术方案 | 京东云技术团队

随着业务的发展及版本迭代，客户端工程中不断增加新的业务逻辑、引入新的资源，随之而来的问题就是安装包体积变大，前期各个业务模块通过无用资源删减、大图压缩或转上云、AB实验业务逻辑下线或其他手段在降低包体积上取得了一定的成果。在瘦身的过程中我们关注到了R文件瘦身的概念，目前京东APP是支持插件化的，有业务插件工程、宿主工程，对业务插件包文件进行分析，发现除了常规的资源及代码外，R类文件大概占包体积的3%~5%左右，对宿主工程包文件进行分析，R类文件占比也有3%左右。我们先后在对R类文件瘦身的可行性及业界开源项目进行调研后，探索出了一套适用于插件化工程的R文件瘦身技术方案。理论基础—R文件 R文件也就是我们日常工作中经常打交道的R.java文件，在Android开发规范中我们需要将应用中用到的资源分别放入专门命名的资源目录中，外部化应用资源以便对其进行单独维护。外部化应用资源后，我们可在项目中使用R类ID来访问这些资源，且R类ID具有唯一性。 public class MainActivity extends BaseActivity { @Override protected v...

2023-06-13

238

本文通过实际业务需求场景建模案例，为读者提供一种业务模型向数据模型设计的方法论，用于指导实际开发中如何进行业务模型向数据模型转化抽象，并对设计的数据模型可用性、扩展性提供了建议性思考。通过文章，读者可以收获到业务模型向数据模型抽象可参考的一种方法论，并针对后期业务需求变化，尽可能降低模型调整或者模型推a倒重建的风险。本文可以重点关注建模实施流程，针对自己实际业务场景，不断抽象优化自己的数据模型。一、背景从研发人员的角度出发，技术更多的是为业务赋能，同时研发人员也可以通过业务模型设计来提升自己的技术，他们更多的是技术控，追求拥有更多的技术栈。不过今天不讨论具体的技术，准备换一种思维模式来分享下自己在业务开发中的一些经验，并结合实际案例来阐述针对业务场景进行数据建模的方法论。开发人员在日常工作中，参与PRD评审、听产品经理讲述用户故事、提出各种需求。评审结束，一般会一股脑投入到设计开发，而数据库表设计就是其中不可或缺的一个过程。对于熟悉的业务模块，通过对需求分析，可以轻而易举的完成数据表设计，但对于非熟悉业务领域，可能会经过多轮PRD分析，整理一套数据表结构基础，然后对其追加字段，就...

2023-06-13

758

资源下载

更多资源

优质分享App

近一个月的开发和优化，本站点的第一个app全新上线。该app采用极致压缩，本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。