简介

JUnit 是一个用于Java 编程语言的 单元测试 框架和 回归测试 框架。

JUnit的特点：

开放的资源框架
提供注释来识别测试方法
提供断言来测试预期结果
提供测试运行来运行测试。
运行速度快，优雅简洁
可以自动运行并且检查自身结果并提供即时反馈

使用

断言

断言是JUnit中主要的功能，在JUnit中所有的断言都包含在 Assert 类中。

Assert类中主要方法如下：

方法名	方法描述
assertEquals	断言传入的预期值与实际值是相等的
assertNotEquals	断言传入的预期值与实际值是不相等的
assertArrayEquals	断言传入的预期数组与实际数组是相等的
assertNull	断言传入的对象是为空
assertNotNull	断言传入的对象是不为空
assertTrue	断言条件为真
assertFalse	断言条件为假
assertSame	断言两个对象引用同一个对象，相当于“==”
assertNotSame	断言两个对象引用不同的对象，相当于“!=”
assertThat	断言实际值是否满足指定的条件

注意：上面的方法都为Assert的静态方法，通过Assert.xxx 调用，如果需要直接调用，需要加上 import static org.junit.Assert.*;

执行顺序

在JUnit中通过@BeforeClass、@Before 、@Test、@After和@AfterClass注解来确定执行顺序。

注解	介绍
`@beforeClass()`	注解的方法首先执行，并且只执行一次。
`@afterClass()`	注解的方法最后执行，并且只执行一次。
`@before()`	注解的方法针对每一个测试用例执行，但是是在执行测试用例之前。
`@after()`	注解的方法针对每一个测试用例执行，但是是在执行测试用例之后。
`@Test`	在 before() 方法和 after() 方法之间，执行每一个测试用例。执行顺序根据代码位置来决定

示例如下:

   @BeforeClass
    public static void beforeClass() {
    
    
        System.out.println("in before class");
    }

    //execute only once, in the end
    @AfterClass
    public static void  afterClass() {
    
    
        System.out.println("in after class");
    }

    //execute for each test, before executing test
    @Before
    public void before() {
    
    
        System.out.println("in before");
    }

    //execute for each test, after executing test
    @After
    public void after() {
    
    
        System.out.println("in after");
    }

    //test case 1
    @Test
    public void testCase1() {
    
    
        System.out.println("in test case 1");
    }

    //test case 2
    @Test
    public void testCase2() {
    
    
        System.out.println("in test case 2");
    }

结果如图：
在这里插入图片描述

编写测试

下面是我们要测试的加密程序

public class Encryption {
    
    
    /**
     * 加密程序，算法是将字符串反转,如 abc 会转为为 cba
     * @param content
     * @return
     */
    public static String encryption(String content){
    
    
       if (content == null)throw new NullPointerException();
       if (content.length() < 2)return content;
       char[] data = content.toCharArray();
       int size = data.length;
       for (int i = 0; i < size/2; i++) {
    
    
            char c = data[i];
            data[i] = data[size - i - 1];
            data[size - i - 1] = c;
       }
       return new String(data);
    }
}

测试代码如下

public class EncryptionTest {
    String content = "abc";
    @Test
    public void encryption() {
        assertEquals(Encryption.encryption(content),"cba");
    }
}

参数化测试

上面的测试代码，每次测试一个方法都要去设置对应的值，非常麻烦。Junit 4 引入了一个新的功能参数化测试。参数化测试允许开发人员使用不同的值反复运行同一个测试。你将遵循 5 个步骤来创建参数化测试。

用 @RunWith(Parameterized.class) 来注解 EncryptionTest 类。
创建一个由 @Parameterized.Parameters 注解的公共的静态方法，它返回一个对象的集合(数组)来作为测试数据集合。
创建EncryptionTest的公共构造函数，它接受和一行测试数据相等同的东西。
为每一列测试数据创建一个实例变量。
用实例变量作为测试数据的来源来创建你的测试用例。

代码如下:

@RunWith(Parameterized.class)
public class EncryptionTest {
    
    

    String result;

    String content;

    public EncryptionTest(String content, String result) {
    
    
        this.content = content;
        this.result = result;
    }

    @Parameterized.Parameters
    public static Collection primeNumbers(){
    
    
        return Arrays.asList(new Object[][]{
    
    
                {
    
    "abc","cba"},
                {
    
    "1234","4321"},
                {
    
    "",""}
        });
    }

    @Test
    public void encryption() {
    
    
        System.out.println("content = "+content+"  result = "+result);
        assertEquals(Encryption.encryption(content),result);
    }
}

测试结果如图：
在这里插入图片描述

异常测试

当我们输入的content = null时，会抛出异常。那么我们怎么测试异常情况，这个就要使用@Test注解的expected参数，参数值为要检测的异常。抛出了对应的异常则测试成功，反之则测试失败。

代码如下：

    @Test(expected = NullPointerException.class)
    public void encryption() {
    
    
        System.out.println("content = "+content+"  result = "+result);
        assertEquals(Encryption.encryption(content),result);
    }

时间测试

有时候我们要检测某一模块的效率，就需要进行运行时间的测试。我们可以通过@Test的timeout 参数，确定最大的运行时间，单位为毫秒。

代码如下：

    @Test(timeout = 1000)
    public void encryption() {
    
    
        System.out.println("content = "+content+"  result = "+result);
        assertEquals(Encryption.encryption(content),result);
    }

异步测试

原理：异步测试的原理就是阻塞测试线程，等异步的线程执行完后，再执行测试线程。

这里用wait和notiftyAll方法来实现,代码如下

/**
*要测试的类
*/
public class Simple {
    
    

    public interface Callback{
    
    
        void finish(String result);
    }

    private Callback callback;

    public void setCallback(Callback callback) {
    
    
        this.callback = callback;
    }

    public void deal(){
    
    
        new Thread(){
    
    
            @Override
            public void run() {
    
    
                try {
    
    
                    //模拟耗时操作
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
    
    
                    e.printStackTrace();
                }
                callback.finish("完成");
            }
        }.start();
    }
}


/**
*测试类
*/
public class SimpleTest {
    
    
    private Object lock = new Object();
    private int flag = 0;
    String res = null;
    @Test
    public void deal(){
    
    
         Simple simple = new Simple();
         simple.setCallback(result -> {
    
    
             synchronized (lock){
    
    
                 flag = 1;
                 lock.notifyAll();
             }
             res = result;
         });
         simple.deal();
             synchronized (lock){
    
    
                 while (flag == 0){
    
    
                     try {
    
    
                         lock.wait();
                     } catch (InterruptedException e) {
    
    
                         e.printStackTrace();
                     }
                 }
             }
        assertEquals(res,"完成");
    }
}

assertThat

转自Android单元测试(一)：JUnit框架的使用的assertThat的使用

上面我们所用到的一些基本的断言，如果我们没有设置失败时的输出信息，那么在断言失败时只会抛出AssertionError，无法知道到底是哪一部分出错。而assertThat就帮我们解决了这一点。它的可读性更好。

assertThat(T actual, Matcher<? super T> matcher);

assertThat(String reason, T actual, Matcher<? super T> matcher);

其中reason为断言失败时的输出信息，actual为断言的值，matcher为断言的匹配器。

常用的匹配器整理：

匹配器	说明	例子
is	断言参数等于后面给出的匹配表达式	assertThat(5, is (5));
not	断言参数不等于后面给出的匹配表达式 assertThat(5, not(6));
equalTo	断言参数相等	assertThat(30, equalTo(30));
equalToIgnoringCase	断言字符串相等忽略大小写	assertThat(“Ab”, equalToIgnoringCase(“ab”));
containsString	断言字符串包含某字符串	assertThat(“abc”, containsString(“bc”));
startsWith	断言字符串以某字符串开始	assertThat(“abc”, startsWith(“a”));
endsWith	断言字符串以某字符串结束	assertThat(“abc”, endsWith(“c”));
nullValue	断言参数的值为null	assertThat(null, nullValue());
notNullValue	断言参数的值不为null	assertThat(“abc”, notNullValue());
greaterThan	断言参数大于	assertThat(4, greaterThan(3));
lessThan	断言参数小于	assertThat(4, lessThan(6));
greaterThanOrEqualTo	断言参数大于等于	assertThat(4, greaterThanOrEqualTo(3));
lessThanOrEqualTo	断言参数小于等于	assertThat(4, lessThanOrEqualTo(6));
closeTo	断言浮点型数在某一范围内	assertThat(4.0, closeTo(2.6, 4.3));
allOf	断言符合所有条件，相当于&&	assertThat(4,allOf(greaterThan(3), lessThan(6)));
anyOf	断言符合某一条件，相当于或	assertThat(4,anyOf(greaterThan(9), lessThan(6)));
hasKey	断言Map集合含有此键	assertThat(map, hasKey(“key”));
hasValue	断言Map集合含有此值	assertThat(map, hasValue(value));
hasItem	断言迭代对象含有此元素	assertThat(list, hasItem(element));

下图为使用assertThat测试失败时所显示的具体错误信息。可以看到错误信息很详细！
在这里插入图片描述

当然了匹配器也是可以自定义的。这里我自定义一个字符串是否是手机号码的匹配器来演示一下。

只需要继承BaseMatcher抽象类，实现matches与describeTo方法。代码如下：

public class IsMobilePhoneMatcher extends BaseMatcher<String> {
    /**
     * 进行断言判定，返回true则断言成功，否则断言失败
     */

    @Override
    public boolean matches(Object item) {
        if (item == null) {
            return false;
        }

        Pattern pattern = Pattern.compile("(1|861)(3|5|7|8)\\d{9}$*");
        Matcher matcher = pattern.matcher((String) item);

        return matcher.find();
    }

    /**
     * 给期待断言成功的对象增加描述
     */
    @Override
    public void describeTo(Description description) {
        description.appendText("预计此字符串是手机号码！");
    }

    /**
     * 给断言失败的对象增加描述
     */
    @Override
    public void describeMismatch(Object item, Description description) {
        description.appendText(item.toString() + "不是手机号码！");
    }
}

@Rule用法

转自Android单元测试(一)：JUnit框架的使用的@Rule用法

还记得一开始我们在@Before与@After注解的方法中加入”测试开始”的提示信息吗？假如我们一直需要这样的提示，那是不是需要每次在测试类中去实现它。这样就会比较麻烦。这时你就可以使用@Rule来解决这个问题，它甚至比@Before与@After还要强大。

自定义@Rule很简单，就是实现TestRule 接口，实现apply方法。代码如下：

public class MyRule implements TestRule {
    
    

    @Override
    public Statement apply(final Statement base, final Description description) {
    
    

        return new Statement() {
    
    
            @Override
            public void evaluate() throws Throwable {
    
    
                // evaluate前执行方法相当于@Before
                String methodName = description.getMethodName(); // 获取测试方法的名字
                System.out.println(methodName + "测试开始！");

                base.evaluate();  // 运行的测试方法

                // evaluate后执行方法相当于@After
                System.out.println(methodName + "测试结束！");
            }
        };
    }

}

我们使用一下我们自定义的MyRule，效果如图：

在这里插入图片描述

JUnit - 框架扩展

Cactus

Cactus 是一个简单框架用来测试服务器端的 Java 代码（Servlets, EJBs, Tag Libs, Filters）。Cactus 的设计意图是用来减小为服务器端代码写测试样例的成本。它使用 JUnit 并且在此基础上进行扩展。Cactus 实现了 in-container 的策略，意味着可以在容器内部执行测试。

JWebUnit

JWebUnit 是一个基于 Java 的用于 web 应用的测试框架。它以一种统一、简单测试接口的方式包装了如 HtmlUnit 和 Selenium 这些已经存在的框架来允许你快速地测试 web 应用程序的正确性。

JWebUnit 提供了一种高级别的 Java API 用来处理结合了一系列验证程序正确性的断言的 web 应用程序。这包括通过链接，表单的填写和提交，表格内容的验证和其他 web 应用程序典型的业务特征。

XMLUnit

XMLUnit 提供了一个单一的 JUnit 扩展类，即 XMLTestCase，还有一些允许断言的支持类：

比较两个 XML 文件的不同（通过使用 Diff 和 DetailedDiff 类）
一个 XML 文件的验证（通过使用 Validator 类）
使用 XSLT 转换一个 XML 文件的结果（通过使用 Transform 类）
对一个 XML 文件 XPath 表达式的评估（通过实现 XpathEngine 接口）
一个 XML 文件进行 DOM Traversal 后的独立结点（通过使用 NodeTest 类）

MockObject

在一个单元测试中，虚拟对象可以模拟复杂的，真实的（非虚拟）对象的行为，因此当一个真实对象不现实或不可能包含进一个单元测试的时候非常有用。

JUnit用法全解析

简介

使用

断言