JUnit4使用总结及Assert

JUnit3、JUnit4、JUnit5

写这篇文章的时候JUnit5正式版刚刚发布不久。

对于JUnit3(了解)：

1、每一个测试类都需要继承自TestCase

2、每一个测试方法都要以test开头

3、初始化方法名必须是：setUp

4、释放资源的方法么必须是：tearDown

对于JUnit4：

1、初始化方法使用@Before或@BeforeClass标识

2、释放资源方法名用@After或@AfterClass标识

3、命名无限制，为了兼容，JUnit4通常沿用了JUnit3的命名规则（非必须）

备注：

      在使用AWS Device Farm早期版本时，带有Test的类才会被识别为测试类，带有test的方法才会被识别为测试方法。对于带有@Test注解而没有以test开头的方法是不会被识别为测试方法的。可能是业界的默认做法或者说版本支持的混乱，所以沿用JUnit3的命名规则有可能省去不必要的麻烦。

常用注解：

顺序执行(junit4.11+)：

MethodSorters.NAME_ASCENDING

      根据方法名升序排列，结合方法名001、002的规则，唯一稳定的方式

MethodSorters.JVM

      根据JVM返回的顺序，每次执行可能不同

MethodSorters.DEFAULT

      根据方法名的HashCode排序，而HashCode计算规则在不同机器上可能不同

备注：

      JUnit强调用例之间的独立性，彼此之间不具有依赖性。如果要更精准控制用例之间的依赖，可以改用TestNG的依赖测试。

超时测试：

@Test(timeout = 2000)

用例需要在2秒钟之内执行完毕，否则测试失败

异常测试：

@Test(expected = ArithmeticException.class)

用例需要抛出指定异常，否则执行失败

套件测试：一次执行多个测试类

@RunWith(Suite.class)
@Suite.SuiteClasses({JunitOne.class, JunitTwo.class})
public class TestSuite{ }
//根据列出来的测试类，依次执行，TestSuite测试类内容为空。

注解使用范例：

@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class JunitTest {
    @BeforeClass
    public static void testBeforeClass(){
        System.out.println("BeforeClass");
    }
    @AfterClass
    public static void testAfterClass(){
        System.out.println("AfterClass");
    }
    @Before
    public void testBefore(){
        System.out.println("Before");
    }
    @After
    public void testAfter(){
        System.out.println("After");
    }
    @Ignore("not ready for test")
    @Test
    public void test002(){
        System.out.println("test002");
    }
    @Test(expected = ArithmeticException.class)
    public void test003(){
        System.out.println("test003");
        int result = 3 / 0;
    }
    @Test(timeout = 2000)
    public void test001() throws Exception{
        Thread.sleep(1900);
        System.out.println("test001");
    }
    @Test(timeout = 1000, expected = ArrayIndexOutOfBoundsException.class)
    public void test004(){
        System.out.println("test004");
        int[] array = new int[3];
        int a = array[3];
    }
}

测试结果：
BeforeClass
Before
test001
After
not ready for test
Before
test003
After
Before
test004
After
AfterClass

备注：

      其中test001到test004会按照名称降序执行，test002会被忽略。test003要求用例抛出ArithmeticException异常。test001要求用例在2000毫秒以内执行完毕，test004则同时限制了执行时长以及指明需要抛出的异常类。

参数化测试：

@RunWith(Parameterized.class)
public class NewTest {
    private String name;
    private int age;
    
    public NewTest(String a, int b){
        this.name = a;
        this.age = b;
    }
    
    @Parameterized.Parameters
    public static List add(){
        return Arrays.asList(new Object[][]{{"Tommy", 18},{"Marry", 23},{"Jacket", 28}});
    }
    
    @Test
    public void calc(){
        System.out.println("name = "+name+"\t  age = "+age);
    }
}

输出：
name = Tommy	age = 18
name = Marry	age = 23
name = Jacket	age = 28

断言

JUnit通常结合hamcrest库做断言。

CoreMatchers条件匹配工具类

assertTrue(boolean condition)
assertFalse(boolean condition)
assertEquals(Object expected, Object actual)
assertNotEquals(Object unexpected, Object actual)
assertArrayEquals(Object[] expecteds, Object[] actuals)
assertNull(Object object)
assertNotNull(Object object)
assertSame(Object expected, Object actual)	引用相同，指向同一个对象
assertNotSame(Object unexpected, Object actual)
assertThat(T actual, Matcher<? super T> matcher)

AssertThat自定义匹配条件的断言

Assert.assertThat("jianc", CoreMatchers.startsWith("ji"));
Assert.assertThat("jianc", CoreMatchers.endsWith("c"));
Assert.assertThat("jianc", CoreMatchers.instanceOf(CharSequence.class));
Assert.assertThat(true, CoreMatchers.not(false));
Assert.assertThat(true, CoreMatchers.is(true));
Assert.assertThat(true, CoreMatchers.is(CoreMatchers.not(false)));
Assert.assertThat(true, CoreMatchers.anything());
Assert.assertThat(123, CoreMatchers.equalTo(123));
Assert.assertThat(123, CoreMatchers.isA(Number.class));
Assert.assertThat(null, CoreMatchers.nullValue());
Assert.assertThat(Arrays.asList("pig", "dog", "cat"), CoreMatchers.notNullValue());
Assert.assertThat(Arrays.asList("pig", "dog", "cat"), CoreMatchers.hasItem("dog"));
Assert.assertThat(Arrays.asList("pig", "dog", "cat"), CoreMatchers.hasItem(CoreMatchers.containsString("ca")));
Assert.assertThat(Arrays.asList("pig", "dog", "cat"), CoreMatchers.hasItem(CoreMatchers.startsWith("p")));
Assert.assertThat(Arrays.asList("pig", "dog", "catg"), CoreMatchers.everyItem(CoreMatchers.containsString("g")));
Assert.assertThat(Arrays.asList("pig", "dog", "cat"), CoreMatchers.both(CoreMatchers.hasItems("pig")).and(CoreMatchers.hasItem("cat")));
Assert.assertThat(Arrays.asList("pig", "dog", "cat"), CoreMatchers.either(CoreMatchers.hasItems("pig")).or(CoreMatchers.hasItem("catg")));
Assert.assertThat(Arrays.asList("pig", "dog", "cat"), CoreMatchers.anything());