JUnit4单元测试基础篇

时间:2023-03-08 17:54:07

引言

JUnit作为Java语言的测试框架,在测试驱动开发(TDD)下扮演重要的角色。众所周知,无论开发大型项目还是一般的小型项目,

单元测试都至关重要。单元测试为软件可发测试维护提供了很大的便利。JUnit 4 作为最新版本,增添了许多新的特性,

结合Hamcrest,可以写出很多灵活的测试。从JUnit 4 开始 jar包放在org.junit包下。代码已经托管在GitHub上。

为了以后测试方便,自定义了一个JUnit的类库,把几个重要的jar包导在一个类库,

这样,以后的项目工程需要写单元测试,直接导入这个类库,不需要重新导入各种jar包。

自定义类库结构如下:

JUnit4单元测试基础篇

关于如何自定义类库,Build Path -> Configure Build Path... -> Add Library... -> User Library... -> Next ......,

常规的单元测试,是在工程下新建一个Source Folder和src目录下相同的包名结构,测试A类,就在相对应的包下

创建一个测试类ATest,测试fun方法,就相应的创建测试方法testFun()。本文单纯学习JUnit特性,没有采用这种方式。

ok,废话到此为止,开始测试。文章略长,按需阅读。

断言 - Assertions

在JUnit 之前版本,经常会使用assertTrue,assertEquals,assertNull等断言,根据字面意思就很容易知道函数的用途。

JUnit 4 结合Hamcrest推出更强大的断言AssertThat(),相比于之前的assertXXX,assertThat代码风格将变得统一,更容易维护;

配合Hamcrest的Matchers, 可以写出很多灵活的测试,下面会提到;另一个优点更倾向于英语语法,不像"谓宾主"

(如:assertEquals(9, x)) 语法模式拗口,assertThat使用类型"主谓宾"的语法模式(如:assertThat(x, is(9)),可能是受母语的影响,

这条优点感触不是很深刻; 下面要说的这个优点比较实用,AssertThat测试失败会提供一些可读的描述性错误信息,

而assertXXX不会(当然可以手动去写),assertThat会举例说明; Last but not the least(v~v高考残留的英语记忆),

可发人员可以实现Matcher接口,自定义匹配符,这个功能很强大。

注意:测试的时候需要引入一些类,有些类(Assert, Matchers)比较特殊,采用静态引入的方式,

好处在于可以直接使用这些类的静态方法(assertTure, assertThat),而不用使用类名.方法名的方式。

assertXXX

import static org.junit.Assert.*;

import org.junit.Test;

/**
* AssertXXX测试
* @author michael
*/
public class AssertTests { @Test
public void testAssertArrayEquals() {
byte[] expected = "trial".getBytes();
byte[] actual = "trial".getBytes();
assertArrayEquals("failure - byte arrays not same", expected, actual);
} @Test
public void testEquals() {
assertEquals("failure - strings are not equal", "text", "text");
} @Test
public void testAssertTrue() {
assertTrue("failure - should be true", true);
} @Test
public void testFalse() {
assertFalse("failure - should be false", false);
} @Test
public void testAssertNotNull() {
assertNotNull("should not be null", new Object());
} @Test
public void testAssetNull() {
assertNull("should be null", null);
} @Test
public void testAssertNotSame() {
assertNotSame("should not be same Object", new Object(), new Object());
} @Test
public void testAssertSame() {
Integer aNumber = Integer.valueOf(985);
assertSame("should be same", aNumber, aNumber);
} }

assertThat

import static org.junit.Assert.*;
import static org.hamcrest.Matchers.*; import java.util.Arrays; import org.junit.Test; public class AssertThatTests { //JUnit Matchers assertThat
@Test
public void testAssertThatBothContainsString() {
assertThat("albumen", both(containsString("a")).and(containsString("b")));
} @Test
public void testAssertThathasItemsContainsString() {
assertThat(Arrays.asList("one", "two", "three"), hasItems("one", "three"));
} @Test
public void testAssertThatEveryItemContainsString() {
assertThat(Arrays.asList(new String[] {"fun", "ban", "net"}), everyItem(containsString("n")));
} /**
* Core Hamcrest Matchers with assertThat
* 组合使用多种匹配符
*/
@Test
public void testAssertThatHamcrestCoreMatchers() {
assertThat("good", allOf(equalTo("good"), startsWith("good")));
assertThat("good", not(allOf(equalTo("good"), equalTo("bad"))));
assertThat("good", anyOf(equalTo("good"), equalTo("bad")));
assertThat(3, not(either(equalTo(6)).or(equalTo(9))));
assertThat(new Object(), not(sameInstance(new Object())));
} /**
* Readable failure message
* assertThat会提供可读性的错误信息,assertTrue不会
*/
@Test
public void testFailureMessage() {
String s = "coour";
//assertTrue(s.contains("color") || s.contains("colour"));
assertThat(s, anyOf(containsString("color"), containsString("colour")));
} }

套件测试 - Aggregating tests in Suites

如果你写了一系列的测试类(十几个甚至几十个),你不可能一个一个的去测试,此时,套件测试就会派上用场。

创建一个空类,不需要为这个类定义任何东西,只需要在这个类的头部添加注解@RunWith(Suite.class)。

@Suite.SuiteClasses。在SuiteClasses里添加需要测试的类。创建的这个类只是作为一个载体,承载上面的注解。

import org.junit.runner.RunWith;
import org.junit.runners.Suite; import assertions.AssertTests;
import assertions.AssertThatTests; @RunWith(Suite.class)
@Suite.SuiteClasses({
//添加需要测试的类
AssertTests.class,
AssertThatTests.class // more test classes
}) public class FutureTestSuite { /**
* the class remains empty,
* used only a holder for the above annotations.
*/
}

What's the difference between failure and error in JUnit

顺序测试 - Test Execution Order

顺序测试的应用场景不是很多,当你想让你写的一系列测试方法按照一定的顺序执行才会用到。

添加@FixMethodOrder注解,有三种常用的运行顺序定义在枚举类MethodSorters内。

DEFAULT、JVM、NAME_ASCENDING。

DEFAULT:默认,比较方法名的hashCode值。

JVM:依赖JVM的实现,不同机器上可能有所不同。

NAME_ASCENDING:按照测试函数方法名升序。

import org.junit.FixMethodOrder;
import org.junit.Test;
import org.junit.runners.MethodSorters; @FixMethodOrder(MethodSorters.NAME_ASCENDING)
//@FixMethodOrder(MethodSorters.DEFAULT)
//@FixMethodOrder(MethodSorters.JVM)
public class TestMethodOrder { @Test
public void testA() {
System.out.println("first");
} @Test
public void testB() {
System.out.println("second");
} @Test
public void testC() {
System.out.println("third");
} }

异常测试 - Exception Testing

开发者在编写程序时,有些代码可能会抛出异常。

如何测试这些代码是否按照我们预想的抛出异常,此时就需要用到异常测试。

@Test注解有一个可选择的参数expected,用于指定可能抛出的异常。例如:

Expected Exceptions

import java.util.ArrayList;
import org.junit.Test; public class TestException { @SuppressWarnings("unused")
private double result; @Test(expected = ArithmeticException.class)
public void divide() {
result = 1/0;
} /**
* The expected parameter should be used with care.
* The test will pass if any code in the method throws IndexOutOfBoundsException
*/
@Test(expected = IndexOutOfBoundsException.class)
public void empty() {
new ArrayList<Object>().get(0);
} }

不过,expected参数应当谨慎使用,因为,如果测试方法任意一处代码抛出expected指定的异常,

测试都会通过,无法准确定位哪处代码抛出的异常。长远考虑,推荐使用ExpectedException rule。

关于Rule会在另一篇文章中介绍。

ExceptedException rule

上面的测试方法对于测试简单的例子比较适用,但它存在一定的限制,比如开发者无法测试异常信息。

当然JUnit3.x 提供了Try/Catch Idiom可以预测异常和异常信息。JUnit4则提供了ExpectedException rule。

不同的是,JUnit4 expectedMessage除了可以预测可能抛出的异常信息,还可以与Hamcrest的Matchars配合 使用,

编写出更加灵活的测试。例如:

import static org.hamcrest.Matchers.containsString;

import java.util.ArrayList;
import java.util.List; import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException; public class TestExceptionRule { //Expected Exception Rule
@Rule
public ExpectedException thrown =ExpectedException.none(); /**
* This rule lets you indicate not only what exception you are expecting,
* but also the exception message you are expecting:
*/
@Test
public void shouldTestExceptionMessage() {
List<Object> list = new ArrayList<Object>(); thrown.expect(IndexOutOfBoundsException.class);
thrown.expectMessage("Index: 0, Size: 0");
thrown.expectMessage(containsString("Size: 0")); list.get(0);
} }

测试忽略 - Ignore tests

如果在某次测试中想要跳过某个测试方法,就使用@Ignore注解。

当然直接注释掉@Test注解同样可以跳过该测试方法,不同的是,

注释掉在测试结果中不会显示,而使用@Ignore会显示该方法被忽略。

import org.junit.Ignore;
import org.junit.Test; public class TestIgnore { @Test
public void testA() {
System.out.println("executed");
} @Ignore
@Test
public void testB() {
System.out.println("ignored");
} }

超时测试 - Timeout for tests

超时测试,顾名思义,测试方法超过指定的时间就会报Errors,注意不是Failures。

Why is JUnit timeout an Error Not Failure

开发人员可以为单独某个方法设置超时时间,也可以为整个测试类设置统一超时时间。

单独为一个方法设置超时时间,单位毫秒

import org.junit.Test;

public class TestTimeout {

    @Test(timeout=100)
public void testWithTimeOut() { for( ; ;) { } } }

为整个类设置超时时间,单位毫秒

import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.Timeout; public class TestTimeoutRule { public static int n; @Rule
public Timeout globalTimeout = new Timeout(100); @Test
public void testInfiniteLoop1() {
n++;
for( ; ;) { }
} @Test
public void testInfiniteLoop2() {
n++;
for( ; ;) { }
} }

结束语

Keeps the bar green to keep the code clean.