Junit4使用汇总（五）suite

一、Suite测试

进行Suite测试可以将多个待测试的类，打包(Suite)一起测试。在入口测试类上加两个注释:

@RunWith(Suite.class)
@SuiteClasses(TestClass1.class, ...)

当你运行这个入口测试类，框架就会把打包在一起的所有待测试类都测试一遍。

import org.junit.runner.RunWith;
import org.junit.runners.Suite;

@RunWith(Suite.class)
@Suite.SuiteClasses({
    TestFeatureLogin.class,
    TestFeatureLogout.class,
    TestFeatureNavigate.class,
    TestFeatureUpdate.class
})

public class FeatureTestSuite {
  // the class remains empty,
  // used only as a holder for the above annotations
}

框架运行那些待测试的类，是按他们在@Suite.SuiteClasses中罗列的顺序开始测试。

二、Parameterized测试

很多时候，需要用很多测试数据进行多次测试。怎么办？通过复制粘贴代码来实现？累...

针对这种情况，JUnit4框架提供Parameterized测试器(Runner)来实现这种需求。

看下面这个例子:

package mytest;

import static org.junit.Assert.*;

import java.util.Arrays;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;

@RunWith(Parameterized.class)
public class FibonacciTest {
    @Parameters
    public static Iterable<Object[]> data() {
        return Arrays.asList(new Object[][] { { 0, 0 }, { 1, 1 }, { 2, 1 },
                { 3, 2 }, { 4, 3 }, { 5, 5 }, { 6, 8 } });
    }

    private int fInput;

    private int fExpected;

    public FibonacciTest(int input, int expected) {
        fInput= input;
        fExpected= expected;
    }
    @Test
    public void test() {
        assertEquals(fExpected, Fibonacci.compute(fInput));
    }
}

很简单，很方便是吧！

1. 用@Parameters来标记，我们为测试准备的数据
2. 定义一个构造函数，构造函数的参数顺序和准备数据的顺序一致
3. 写你需要的测试方法，用@Test注释
4. 运行起来，每个数据都会测试一遍

如果，你不习惯去写那样一个构造函数，也可以用下面的方法：

@RunWith(Parameterized.class)
public class FibonacciTest {
    @Parameters
    public static Iterable<Object[]> data() {
        return Arrays.asList(new Object[][] { { 0, 0 }, { 1, 1 }, { 2, 2 },
                { 3, 2 }, { 4, 3 }, { 5, 5 }, { 6, 8 } });
    }

    @Parameter(0)
    public int fInput;

    @Parameter(1)
    public int fExpected;

    @Test
    public void test() {
        assertEquals(fExpected, Fibonacci.compute(fInput));
    }
}

运行起来是不是很爽！

可能，你是一个完美主义者，对运行后报错信息不是很满意，现在报错时反馈的信息可能是这样：

test[3](mytest.FibonacciTest): expected:<2> but was:<0>

你想报错时显示测试的输入数据，希望报错类似如下：

test[the 3 test, input:3,2](mytest.FibonacciTest): expected:<2> but was:<0>

要实现这点很简单，给@Parameters加个参数name，整个代码如下：

package mytest;

import static org.junit.Assert.*;

import java.util.Arrays;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;

@RunWith(Parameterized.class)
public class FibonacciTest {
    @Parameters(name="the {index} test, input:{0},{1}")
    public static Iterable<Object[]> data() {
        return Arrays.asList(new Object[][] { { 0, 0 }, { 1, 1 }, { 2, 1 },
                { 3, 2 }, { 4, 3 }, { 5, 5 }, { 6, 8 } });
    }

    private int fInput;

    private int fExpected;

    public FibonacciTest(int input, int expected) {
        fInput= input;
        fExpected= expected;
    }
    @Test
    public void test() {
        assertEquals(fExpected, Fibonacci.compute(fInput));
    }
}

在这里需要稍微解释一下name中的几个参数的含义：

{index} 表示序号，测试数据在整个数据列表中的序号
{0} 表示第一个参数
{1} 表示第二个参数
...
{n} 表示第n+1个参数

三、Categories测试

一个测试类里面包含很多待测试的方法，很多时候，我们需要把这些待测试的方法分类，某些时候测试某类方法，那么需要怎么做呢？

看下面这个例子：

public interface FastTests { /* category marker */ }
public interface SlowTests { /* category marker */ }

public class A {
  @Test
  public void a() {
    fail();
  }

  @Category(SlowTests.class)
  @Test
  public void b() {
  }
}

@Category({SlowTests.class, FastTests.class})
public class B {
  @Test
  public void c() {

  }
}

@RunWith(Categories.class)
@IncludeCategory(SlowTests.class)
@SuiteClasses( { A.class, B.class }) // Note that Categories is a kind of Suite
public class SlowTestSuite {
  // Will run A.b and B.c, but not A.a
}

在上面的例子中，将会测试A.b和B.c两个方法，不会测试A.a。

再看下面：

@RunWith(Categories.class)
@IncludeCategory(SlowTests.class)
@ExcludeCategory(FastTests.class)
@SuiteClasses( { A.class, B.class }) // Note that Categories is a kind of Suite
public class SlowTestSuite {
  // Will run A.b, but not A.a or B.c
}

这次，只会运行A.b，而不会运行A.a和B.c。

四、Theories测试

     一些理论测试。

先看例子：

@RunWith(Theories.class)
public class UserTest {
    @DataPoint
    public static String GOOD_USERNAME = "optimus";
    @DataPoint
    public static String USERNAME_WITH_SLASH = "optimus/prime";

    @Theory
    public void filenameIncludesUsername(String username) {
        assumeThat(username, not(containsString("/")));
        assertThat(new User(username).configFileName(), containsString(username));
    }
}

是不是看得有点苦涩难懂，没关系，我来给你一一讲解：

1. @RunWith(Theories.class) 是告诉框架，下面的测试类将要做理论测试；
2. @DataPoint 告诉框架，标注的这些数据都是准备用来测试的数据；
3. @Theory标注的方法，是需要进行理论测试的方法；
4. assumeThat 是对待测试的数据(@DataPoint标注的数据)进行检查，符合的数据继续往下走，不符合的数据忽略掉.如果，所有的数据都不符合，那么@Theory标注的测试，则算失败(fail)。