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());