初识Java 14-1 测试

目录

测试

单元测试

JUnit

测试覆盖率

前置条件

断言

Java提供的断言语法

Guava提供的更方便的断言

契约式设计中的断言

[DbC + 单元测试](#DbC + 单元测试)

Guava中的前置条件


本笔记参考自: 《On Java 中文版》


测试

||| 如果没有经过测试,代码就不可能正常工作。

Java大体上可以被称为一门静态类型语言。静态类型检查是一种非常有限的测试类型,它仅仅保证代码的语法和基本类型没有问题,但却不能保证我们的代码能够满足程序的目标。

为此,就需要程序员来进行代码验证。第一步,我们需要创建测试,检查我们的代码行为是否满足了我们的目标。

单元测试

单元测试是一个++将集成测试构建到我们所创建的所有代码中++ 的过程。并在每次测试的时候运行这些测试。这种做法可以用来++检测语义错误++。

单元测试通常是一小段代码。通过为每一个类构建自己的测试来检查它所有方法的行为。Java的垃圾收集和类型检查等功能共同构成了Java的安全网。将单元测试集成到构建过程中,我们就可以扩展这个安全网。从而加快开发速度。

除此之外,还有"系统"测试,用来检测已完成的程序是否能够满足最终要求。

项目构建

通过一些项目构建工具,我们可以把源代码生成可执行应用程序的过程自动化。这种工具可以帮助我们管理项目的外部依赖包、项目编译和打包等工作。这里简单介绍几种Java的项目构建工具(参考自默 语的博客):

  1. Ant
    1. 优点:灵活、速度快。
    2. 缺点:学习路线较为陡峭,配置复杂,难以适应大型项目。
  2. Maven
    1. 优点:功能强大,可自动下载依赖包并构建项目。
    2. 缺点:项目构建僵化,配置不够灵活,不适合小型项目。
  3. Gradle
    1. 优点:灵活、可扩展,支持远程仓库。可以根据需要自定义任务和行为。
    2. 缺点:学习成本高,版本兼容性差等。

JUnit

JUnit是一个开源的Java测试框架,可用于编写可靠、高效的测试(并且可用于创建自动测试)。在编写单元测试时,它是一个很好的工具。

直至笔者写下本笔记的时候,Junit已经更新到了JUnit 5版本,可以在GitHub上找到这个项目:

JUnit 5https://github.com/junit-team/junit5接下来将会参考JUnit 5的指导手册,做一些必要的介绍(但不会包括如何下载和配置JUnit,已经有许多人写过很出色的博客来说明这部分了)。

JUnit需要运行在JVM上,而JUnit 5在运行时的最低配置是JDK 8(不过也可以用它来测试更早版本的程序)。JUnit提供了许多用于配置测试并扩展框架的注解,可以在官方提供的文档中进行查看,这里仅仅简单介绍一些我们会用到的:

注释 描述
@Test 表明该方法是测试方法。在JUnit 5中,该注释没有任何属性。
@TestFactory 表明该方法是一个被用于动态测试的测试工厂。
@BeforeAll 拥有该注解的方法会在任何测试执行++之前++运行一次,这种方法必须是静态的。
@AfterAll 拥有该注解的方法会在任何测试执行++之后++运行一次,这种方法必须是静态的。
@BeforeEach 通常用于创建和初始化一组公共对象,并在每次测试之前运行。
@AfterEach 拥有该注解的方法会在测试结束之后运行。通常用于每次测试之后的++清理++ (如恢复static成员,关闭文件、数据库或网络连接等)。

【例子:简单的测试】

首先写一段简单的代码:

java 复制代码
package validating;

import java.util.ArrayList;

public class CountedList extends ArrayList<String> {
    private static int counter = 0;
    private int id = counter++;

    public CountedList() {
        System.out.println("CountedList #" + id);
    }

    public int getId() {
        return id;
    }
}

接下来编写测试代码对其进行检查。标准的做法是将测试代码放在一个独立的包中:

java 复制代码
package validating.tests;

import org.junit.jupiter.api.*;
import validating.CountedList;

import java.util.Arrays;
import java.util.List;

import static org.junit.jupiter.api.Assertions.*;

class CountedListTest {
    private CountedList list;

    // BeforeAll和AfterAll修饰的方法都是静态的
    @BeforeAll
    static void beforeAllMsg() {
        System.out.println(">>> 开始对CountedList的测试");
    }

    @AfterAll
    static void afterAllmsg() {
        System.out.println();
        System.out.println(">>> 结束对CountedList的测试");
    }

    @BeforeEach
    public void initialize() {
        System.out.println();
        list = new CountedList();
        System.out.println("对id为#" + list.getId() + "的单元进行设置");
        for (int i = 0; i < 3; i++)
            list.add(Integer.toString(i));
    }

    @AfterEach
    public void cleanup() {
        System.out.println("对id为#" + list.getId() + "的单元进行清理");
    }

    @Test
    public void insert() {
        System.out.println("运行测试:输入");
        assertEquals(list.size(), 3); // 断言方法

        list.add(1, "插入");
        assertEquals(list.size(), 4); // 断言方法
        assertEquals(list.get(1), "插入");
    }

    @Test
    public void replace() {
        System.out.println("运行测试:替换");
        assertEquals(list.size(), 3);

        list.set(1, "替换");
        assertEquals(list.size(), 3);
        assertEquals(list.get(1), "替换");
    }

    // 只需要在测试中运行的辅助方法compare
    // 没有@Test之类的注解,不会自动运行
    private void compare(List<String> lt, String[] strs) {
        assertArrayEquals(lt.toArray(new String[0]), strs);
    }

    @Test
    public void order() {
        System.out.println("运行测试:检查顺序");
        compare(list, new String[]{"0", "1", "2"});
    }

    @Test
    public void remove() {
        System.out.println("运行测试:删除");
        assertEquals(list.size(), 3);

        list.remove(1);
        assertEquals(list.size(), 2);
        compare(list, new String[]{"0", "2"});
    }

    @Test
    public void addAll() {
        System.out.println("运行测试:放入多项数据");

        list.addAll(Arrays.asList(new String[]{"许多", "项", "数据"}));
        assertEquals(list.size(), 6);
        compare(list, new String[]{"0", "1", "2", "许多", "项", "数据"});
    }
}

程序执行的结果是:

JUnit使用@Test来标注测试方法。在这些方法中,我们可以执行任何所需的操作。并且可以使用JUnit的断言方法(这些方法都以"asset"开头)来验证测试的正确性。如果需要,可以在文档中找到这些断言方法的说明。

测试覆盖率

||| 测试覆盖率 ,也称为代码覆盖率。是衡量代码库的测试百分比,百分比越高,测试覆盖率越大。

可能会存在这样一种误解,必须追求覆盖率的100%:

这是有问题的,因为这个数据并不是衡量测试有效性的合理标准。有时,即使我们测试了++所有需要测试的内容++,测试覆盖率也只会达到60%~70%。换言之,如果盲目追求100%的覆盖率,就会浪费大量的时间。

一般情况下,测试覆盖率只作为粗略的衡量标准。注意,必要依赖覆盖率来获取测试质量的相关信息。

前置条件

前置条件 的概念来自契约式设计,并且使用了基本的断言机制来实现。在了解契约式设计之前,需要先介绍一下断言的基本概念。

断言

断言通过验证程序执行期间是否满足某些条件来提高程序的稳健性。断言可以应用于判断数值的范围、参数的有效性等多种场景。

Java提供的断言语法

有许多编程结构可以用来模拟断言的效果。Java本身也提供了两种现成的断言语句:

java 复制代码
assert boolean-expression;
assert boolean-expression: information-expression;

断言会判断表达式的值是否为true。若不是true,断言会产生一个AssertionError异常(这个异常是Throwable的子类,因此不需要指定异常规范)。

注意: 第一种断言形式产生的异常不会包含boolean-expression的任何信息。

【例子:第一种断言形式】

java 复制代码
// 需要在运行时显示地启动断言、
// 启动断言最简单的方法是在运行程序时使用-ea标志
public class Assert1 {
    public static void main(String[] args) {
        assert false;
    }
}

程序执行的结果是:

Java的断言默认不打开,因此我们必须在运行程序时显式地启用断言。最简单的方法是使用-ea标志(也可拼写为-enableassertions)。这将在运行程序时执行任何断言语句。IDEA可以通过修改运行配置添加该标志:

而若使用第二种的断言,就可以在异常栈中生成一个有用的消息:

【例子:第二种断言形式】

java 复制代码
public class Assert2 {
    public static void main(String[] args) {
        assert false :
                "这是一条信息,用来说明发生了什么"; // information-expression
    }
}

程序执行的结果是:

information-expression可以是任何类型的对象。但通常,我们会构造一个更复杂的字符串,其中会包含与失败断言有关的对象的信息。

可以根据类名或包名打开或关闭断言,详见JDK文档

还有另一种控制断言的方式:以编程的方式操作ClassLoader对象。ClassLoader中有几种方法允许动态启用和禁用断言。

【例子:通过ClassLoader开启断言】

java 复制代码
public class LoaderAssertions {
    public static void main(String[] args) {
        ClassLoader.getSystemClassLoader()
                .setDefaultAssertionStatus(true); // 该方法会为其之后加载的所有类设置断言状态
        new Loaded().go();
    }
}

class Loaded {
    public void go() {
        assert false : "Loaded.go()";
    }
}

程序执行的结果是:

这样就不需要使用-ea标志了。在独立交付产品时,可能会需要使用独立脚本来配置其他启动参数,以保证用户无论如何都可以启动程序。

另外,也可以在程序运行时再决定是否启用断言,可以使用静态语句做到这一点。

【例子:使用静态语句控制断言】

java 复制代码
static {
    boolean assertionsEnabled = false;
    assert assertionsEnabled = true; // 利用赋值的副作用进行重新赋值
    if (!assertionsEnabled)
        throw new RuntimeException("断言已禁用");
}

由于赋值的返回值是赋值操作符右边的值,因此可以利用这一点控制断言的开启。


Guava提供的更方便的断言

Guava团队提供了一个Verify类来替代Java原生的断言,这个类提供了始终启动的替换断言(Guava是谷歌提供的第三方库,可以在GitHub上找到这个库)。他们建议静态导入Verify类:

【例子:Guava中的断言】

java 复制代码
import com.google.common.base.VerifyException;

import static com.google.common.base.Verify.*;

public class GuavaAssertions {
    public static void main(String[] args) {
        verify(1 + 1 == 2);
        try {
            verify(1 + 1 == 4);
        } catch (VerifyException e) {
            System.out.println(e);
        }

        try {
            verify(1 + 1 == 4, "算错了");
        } catch (VerifyException e) {
            System.out.println(e.getMessage());
        }

        try {
            verify(1 + 1 == 4, "算错了:%s", "不是4");
        } catch (VerifyException e) {
            System.out.println(e.getMessage());
        }

        String s = "";
        s = verifyNotNull(s);
        s = null;
        try {
            verifyNotNull(s);
        } catch (VerifyException e) {
            System.out.println(e.getMessage());
        }

        try {
            verifyNotNull(s, "不应该为空:%s", "arg s");
        } catch (VerifyException e) {
            System.out.println(e.getMessage());
        }
    }
}

程序执行的结果是:

verify()和verifyNotNull()都可以提供错误信息。但推荐使用verifyNotNull(),因为verify()提供的信息过于笼统了。


契约式设计中的断言

契约式设计(DbC),即通过保证对象遵循某些规则来创建稳健的程序。这些规则由要解决问题的性质决定,而且++超出了编译器可以验证的范围++ (也有说法认为,接口的本质就是契约)。

断言可以创建一种非正式的DbC编程风格。

DbC假定服务提供者和服务消费者之间++存在着明确的合同++。接口分隔了提供者和消费者,当客户调用某些公共方法时,他们会期望调用特定的行为:对象中状态的改变,或是可预测的返回值。这种行为的设计主旨概括如下:

  1. 可以明确规定这种行为,就好像合同一样。
  2. 通过运行时检查包装上述行为,即前置条件后置条件不变项

同任何解决方案一样,DbC也存在着它的局限。但只有知道这些局限,我们才能更好地使用它们。

在DbC中,我们可以更多地去关注其对特定类的约束。

检查指令

首先需要考虑断言最简单的用法,即检查指令 :当我们无法仅凭借程序执行的结果得出结论时,就可以用一个检查指令来断言我们获得的结果是否正确。其思想是在代码中表达并非显而易见的结论,这不仅可以用来测试用例,还可以作为阅读代码时的文档。

前置条件测试

确保客户(即调用此方法的代码)履行其合同部分。因此我们基本上需要在方法调用的最开始(准确的说,是在该方法开始执行任何操作之前)检查参数。

后置条件

用于检测方法的执行结果。一般放置在方法调用的末尾,return语句之前。对复杂的计算而言,后置条件是++必不可少的++。我们可以将那些对方法结果的约束放在后置条件中。

不变项

用以确保对象的状态在方法调用之间是不变的(但可以在方法执行期间偏离)。不变项只保证对象的状态信息++在以下两个时间段++遵守规定的规则:

  1. 进入方法前;
  2. 离开方法后。

不变项是对对象构造后状态的保证。

可以把不变项命名定义为一个方法,一般命名为invariant(),这个方法会在①对象构造之后以及②每个方法的开始和结束时被调用。可以这样调用该方法:

java 复制代码
assert invariant(); // 当禁用断言时,就不会因此产生开销了

放宽DbC的限制

尽管前置条件、后置条件和不变项十分有用,但在发布的产品中包含所有的DbC代码并不总是可行的。可以根据对特定位置代码的信任程度放宽DbC检查。以下是DbC检查的顺序,从最安全到最不安全:

  1. 禁用方法开头的不变项检查。
  2. 当有合理的单元测试来验证方法的返回值时,可以禁用后置条件检查。
  3. 如果确信方法体不会将对象置于无效状态(可使用白盒测试进行检测,即使用可以访问私有字段的单元测试来验证对象状态),则可以禁用方法调用结束时的不变项检查。
  4. 最不安全的,禁用前置条件检查。即使我们自己了解自己的代码,但++无法控制客户传递给方法的参数++。

不建议在禁用检查时直接删除执行检查的代码(只需要将其注释掉即可)。


DbC + 单元测试

可以将契约式设计中的概念和单元测试进行结合:

【例子:测试一个循环队列】

不同于以往直接编写程序,这次需要为这个队列做一些契约性的定义:

  1. 前置条件(对put()):不允许将空元素添加到队列中。
  2. 前置条件(对put()):将元素放入已满的队列是非法的。
  3. 前置条件(对get()):尝试从空元素中获取元素是非法的。
  4. 后置条件(对get()):不能从数组中获取空元素。
  5. 不变项:队列中包含对象的区域不能有任何空元素。
  6. 不变项:队列中不包含对象的区域必须只能有空值。

① 创建一个专用的Exception:

java 复制代码
public class CircularQueueException extends RuntimeException {
    public CircularQueueException(String why) {
        super(why);
    }
}

② 接下来进行CircularQueue类的创建:

java 复制代码
import java.util.Arrays;

public class CircularQueue {
    private Object[] data;
    private int
            in = 0, // 指向下一个可用的空间
            out = 0; // 指向下一个出队的对象
    private boolean wrapped = false; // 用以判断是否回到了循环队列的开头

    public CircularQueue(int size) {
        data = new Object[size];

        // 构造完毕后的对象必须遵守不变项的约束
        assert invariant();
    }

    public boolean empty() {
        return !wrapped && in == out;
    }

    public boolean full() {
        return wrapped && in == out;
    }

    public boolean isWrapped() {
        return wrapped;
    }

    public void put(Object item) {
        precondition(item != null, "放入元素为空");
        precondition(!full(), "试图向已满的队列放入元素");
        assert invariant();

        data[in++] = item;
        if (in >= data.length) {
            in = 0;
            wrapped = true;
        }

        assert invariant();
    }

    public Object get() {
        precondition(!empty(), "试图从空队列中获取元素");
        assert invariant();

        Object returnval = data[out];
        data[out] = null;
        out++;

        if (out >= data.length) {
            out = 0;
            wrapped = false;
        }

        assert postcondition(
                returnval != null, "在循环队列中存在空元素");
        assert invariant();
        return returnval;
    }

    // 契约式设计的相关方法
    private static void
    precondition(boolean cond, String msg) { // 前置条件
        if (!cond)
            throw new CircularQueueException(msg);
    }

    private static boolean
    postcondition(boolean cond, String msg) { // 后置条件
        if (!cond)
            throw new CircularQueueException(msg);
        return true;
    }

    private boolean invariant() { // 不变项
        // 确定对象的data区域不会有空值
        for (int i = out; i != in; i = (i + 1) % data.length)
            if (data[i] == null)
                throw new CircularQueueException("在循环队列中存在值");

        // 确定对象的data区域之外只会有空值
        if (full())
            return true;
        for (int i = in; i != out; i = (i + 1) % data.length)
            if (data[i] != null)
                throw new CircularQueueException("在循环队列之外存在非空值:"
                        + dump());
        return true;
    }

    public String dump() { // 返回更多信息
        return "in = " + in +
                ", out = " + out +
                ", full() = " + full() +
                ", empty() = " + empty() +
                ", CircularQueue = " + Arrays.asList(data);
    }
}

通常,我们会需要在代码中保留前置条件。将这些条件都封装在一个precondition()中,可以方便我们减少或关闭前置条件。注意,precondition()返回void,因为它不会和assert一起使用。

与之相对,postcondition()和invariant()都返回boolean,它们可以和assert一起使用。并且在为了性能而关闭断言时,可以直接屏蔽这些方法调用。

③ 创建JUnit测试

java 复制代码
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import validating.CircularQueue;
import validating.CircularQueueException;

import static org.junit.jupiter.api.Assertions.*;

class CircularQueueTest {
    private CircularQueue queue = new CircularQueue(10);
    private int i = 0;

    @BeforeEach
    public void initialize() {
        while (i < 5)
            queue.put(Integer.toString(i++));
    }

    // 辅助用方法
    private void showFullness() {
        assertTrue(queue.full());
        assertFalse(queue.empty());
        System.out.println(queue.dump());
    }

    private void showEmptioness() {
        assertFalse(queue.full());
        assertTrue(queue.empty());
        System.out.println(queue.dump());
    }

    @Test
    public void full() {
        System.out.println("测试:Full");
        System.out.println(queue.dump());
        System.out.println(queue.get());
        System.out.println(queue.get());

        while (!queue.full())
            queue.put(Integer.toString(i++));
        String msg = "";
        try {
            queue.put("");
        } catch (CircularQueueException e) {
            msg = e.getMessage();
            System.out.println(msg);
        }

        assertEquals(msg, "试图向已满的队列放入元素");
        showFullness();
    }

    @Test
    public void empty() {
        System.out.println("测试:Empty");

        while (!queue.empty())
            System.out.println(queue.get());
        String msg = "";
        try {
            queue.get();
        } catch (CircularQueueException e) {
            msg = e.getMessage();
            System.out.println(msg);
        }

        assertEquals(msg, "试图从空队列中获取元素");
        showEmptioness();
    }

    @Test
    public void nullPut() {
        System.out.println("测试:NullPut");

        String msg = "";
        try {
            queue.put(null);
        } catch (CircularQueueException e) {
            msg = e.getMessage();
            System.out.println(msg);
        }
        assertEquals(msg, "放入元素为空");
    }

    @Test
    public void circularity() {
        System.out.println("测试:Circularity");

        while (!queue.full())
            queue.put(Integer.toString(i++));
        showFullness();

        assertTrue(queue.isWrapped());
        while (!queue.empty())
            System.out.println(queue.get());
        showEmptioness();

        while (!queue.full())
            queue.put(Integer.toString(i++));
        showFullness();

        while (!queue.empty())
            System.out.println(queue.get());
        showEmptioness();
    }
}

程序执行的结果是:

通过将DbC和单元测试向结合,我们不仅可以利用它们各自的优点,而且可以将一些DbC测试移动到单元测试之后(而不是替代它)。这样就能保证某些层次的测试。


Guava中的前置条件

之前提到过,++前置条件是DbC中不应该删除的部分++,因为它是用来检查方法参数的有效性的。因此我们最好检测它,这时Java默认的禁用断言就会造成些许麻烦,使用其他可以始终验证方法参数的库是一个不错的选择。

这里还是使用Google的Guava库:

【例子:使用第三方库的前置条件检测】

java 复制代码
import java.util.function.Consumer;

import static com.google.common.base.Preconditions.*;

public class GuavaPreconditions {
    static void test(Consumer<String> c, String s) {
        try {
            System.out.println(s);
            c.accept(s);
            System.out.println("成功");
        } catch (Exception e) {
            String type = e.getClass().getSimpleName();
            String msg = e.getMessage();
            System.out.println(type + (msg == null ? "" : ": " + msg));
        }
    }

    public static void main(String[] args) {
        test(s -> s = checkNotNull(s), "X");
        test(s -> s = checkNotNull(s), null);
        test(s -> s = checkNotNull(s, "s是null"), null);
        test(s -> s = checkNotNull(
                        s, "s是null,%s %s", "arg2", "arg3")
                , null);

        System.out.println();
        // checkArgument()会使用布尔表达式对参数进行具体的检测
        test(s -> checkArgument(s == "ABC"), "ABC");
        test(s -> checkArgument(s == "ABC"), "X");
        test(s -> checkArgument(s == "ABC"), null);
        test(s -> checkArgument(
                s == "ABC", "匹配失败"), null);
        test(s -> checkArgument(
                s == "ABC", "匹配失败,应该是 %s", s), null);

        System.out.println();
        // 会检测对象的状态,而不是检查参数(也可用于检查不变项)。
        test(s -> checkState(s.length() > 6), "长度足够长");
        test(s -> checkState(s.length() > 6), "不够长");
        test(s -> checkState(s.length() > 6), null);

        System.out.println();
        // 确保第一个参数是一个List、String或数组的有效元素索引
        test(s -> checkElementIndex(6, s.length()), "比6个字符长一点");
        test(s -> checkElementIndex(6, s.length()), "短了");
        test(s -> checkElementIndex(6, s.length()), null);

        System.out.println();
        // 确保其的第一个参数在0和第二个参数(包括)的范围内
        test(s -> checkPositionIndex(6, s.length()), "看起来和上面的差不多");
        test(s -> checkPositionIndex(6, s.length()), "短了");
        test(s -> checkPositionIndex(6, s.length()), null);
    }
}

程序执行的结果是:

上述例子只演示了String类型,但Guava的前置条件是适用于所有类型的。

另外,Guava提供的前置条件,其每个都有三种不同的重载形式:没有消息的测试、带有一个String消息的测试和带有String及替换值的可变参数列表的测试。出于效率考虑,只允许使用%s替换标签。

因为checkNotNull()会返回参数,因此可以通过内联的方式进行使用:

【例子:内联的checkNotNull()】

java 复制代码
import static com.google.common.base.Preconditions.checkNotNull;

public class NonNullConstruction {
    private Integer n;
    private String s;

    NonNullConstruction(Integer n, String s) {
        this.n = checkNotNull(n);
        this.s = checkNotNull(s);
    }

    public static void main(String[] args) {
        NonNullConstruction nnc =
                new NonNullConstruction(3, "ABC");
    }
}

编译器会判断是否进行内联。

相关推荐
wjs20247 分钟前
MongoDB 更新集合名
开发语言
monkey_meng10 分钟前
【遵守孤儿规则的External trait pattern】
开发语言·后端·rust
草莓base23 分钟前
【手写一个spring】spring源码的简单实现--bean对象的创建
java·spring·rpc
legend_jz35 分钟前
【Linux】线程控制
linux·服务器·开发语言·c++·笔记·学习·学习方法
drebander1 小时前
使用 Java Stream 优雅实现List 转化为Map<key,Map<key,value>>
java·python·list
乌啼霜满天2491 小时前
Spring 与 Spring MVC 与 Spring Boot三者之间的区别与联系
java·spring boot·spring·mvc
tangliang_cn1 小时前
java入门 自定义springboot starter
java·开发语言·spring boot
程序猿阿伟1 小时前
《智能指针频繁创建销毁:程序性能的“隐形杀手”》
java·开发语言·前端
Grey_fantasy1 小时前
高级编程之结构化代码
java·spring boot·spring cloud
新知图书1 小时前
Rust编程与项目实战-模块std::thread(之一)
开发语言·后端·rust