【Junit】Junit使用教程（二）

我不是女神ヾ 2022-06-09 13:18 209阅读 0赞

**二、核心——断言**

断言是编写测试用例的核心实现方式，即期望值是多少，测试的结果是多少，以此来判断测试是否通过。

1. 断言核心方法

<table style="color:rgb(0,0,0); font-family:Arial; font-size:14px"> 
 <tbody> 
  <tr> 
   <td>assertArrayEquals(expecteds, actuals)</td> 
   <td>查看两个数组是否相等。</td> 
  </tr> 
  <tr> 
   <td>assertEquals(expected, actual)</td> 
   <td>查看两个对象是否相等。类似于字符串比较使用的equals()方法</td> 
  </tr> 
  <tr> 
   <td>assertNotEquals(first, second)</td> 
   <td>查看两个对象是否不相等。</td> 
  </tr> 
  <tr> 
   <td>assertNull(object)</td> 
   <td>查看对象是否为空。</td> 
  </tr> 
  <tr> 
   <td>assertNotNull(object)</td> 
   <td>查看对象是否不为空。</td> 
  </tr> 
  <tr> 
   <td>assertSame(expected, actual)</td> 
   <td>查看两个对象的引用是否相等。类似于使用“==”比较两个对象</td> 
  </tr> 
  <tr> 
   <td>assertNotSame(unexpected, actual)</td> 
   <td>查看两个对象的引用是否不相等。类似于使用“!=”比较两个对象</td> 
  </tr> 
  <tr> 
   <td>assertTrue(condition)</td> 
   <td>查看运行结果是否为true。</td> 
  </tr> 
  <tr> 
   <td>assertFalse(condition)</td> 
   <td>查看运行结果是否为false。</td> 
  </tr> 
  <tr> 
   <td>assertThat(actual, matcher)</td> 
   <td>查看实际值是否满足指定的条件</td> 
  </tr> 
  <tr> 
   <td>fail()</td> 
   <td>让测试失败</td> 
  </tr> 
 </tbody> 
</table>

2. 示例

**\[java\]**  [view plain][]   [copy][view plain]

1.  **package** test;  
2.    
3.  **import** **static** org.hamcrest.CoreMatchers.\*;  
4.  **import** **static** org.junit.Assert.\*;  
5.    
6.  **import** java.util.Arrays;  
7.    
8.  **import** org.hamcrest.core.CombinableMatcher;  
9.  **import** org.junit.Test;  
10.   
11. **public** **class** AssertTests \{  
12.   
13.       @Test  
14.       **public** **void** testAssertArrayEquals() \{  
15.         **byte**\[\] expected = "trial".getBytes();  
16.         **byte**\[\] actual = "trial".getBytes();  
17.         org.junit.Assert.assertArrayEquals("failure - byte arrays not same", expected, actual);  
18.       \}  
19.   
20.       @Test  
21.       **public** **void** testAssertEquals() \{  
22.         org.junit.Assert.assertEquals("failure - strings not same", 5l, 5l);  
23.       \}  
24.   
25.       @Test  
26.       **public** **void** testAssertFalse() \{  
27.         org.junit.Assert.assertFalse("failure - should be false", **false**);  
28.       \}  
29.   
30.       @Test  
31.       **public** **void** testAssertNotNull() \{  
32.         org.junit.Assert.assertNotNull("should not be null", **new** Object());  
33.       \}  
34.   
35.       @Test  
36.       **public** **void** testAssertNotSame() \{  
37.         org.junit.Assert.assertNotSame("should not be same Object", **new** Object(), **new** Object());  
38.       \}  
39.   
40.       @Test  
41.       **public** **void** testAssertNull() \{  
42.         org.junit.Assert.assertNull("should be null", **null**);  
43.       \}  
44.   
45.       @Test  
46.       **public** **void** testAssertSame() \{  
47.         Integer aNumber = Integer.valueOf(768);  
48.         org.junit.Assert.assertSame("should be same", aNumber, aNumber);  
49.       \}  
50.   
51.       // JUnit Matchers assertThat  
52.       @Test  
53.       **public** **void** testAssertThatBothContainsString() \{  
54.         org.junit.Assert.assertThat("albumen", both(containsString("a")).and(containsString("b")));  
55.       \}  
56.   
57.       @Test  
58.       **public** **void** testAssertThathasItemsContainsString() \{  
59.         org.junit.Assert.assertThat(Arrays.asList("one", "two", "three"), hasItems("one", "three"));  
60.       \}  
61.   
62.       @Test  
63.       **public** **void** testAssertThatEveryItemContainsString() \{  
64.         org.junit.Assert.assertThat(Arrays.asList(**new** String\[\] \{ "fun", "ban", "net" \}), everyItem(containsString("n")));  
65.       \}  
66.   
67.       // Core Hamcrest Matchers with assertThat  
68.       @Test  
69.       **public** **void** testAssertThatHamcrestCoreMatchers() \{  
70.         assertThat("good", allOf(equalTo("good"), startsWith("good")));  
71.         assertThat("good", not(allOf(equalTo("bad"), equalTo("good"))));  
72.         assertThat("good", anyOf(equalTo("bad"), equalTo("good")));  
73.         assertThat(7, not(CombinableMatcher.<Integer> either(equalTo(3)).or(equalTo(4))));  
74.         assertThat(**new** Object(), not(sameInstance(**new** Object())));  
75.       \}  
76. \}

**三、核心——注解**

1. 说明

<table style="color:rgb(0,0,0); font-family:Arial; font-size:14px"> 
 <tbody> 
  <tr> 
   <td>@Before</td> 
   <td>初始化方法</td> 
  </tr> 
  <tr> 
   <td>@After</td> 
   <td>释放资源</td> 
  </tr> 
  <tr> 
   <td>@Test</td> 
   <td>测试方法，在这里可以测试期望异常和超时时间</td> 
  </tr> 
  <tr> 
   <td>@Ignore</td> 
   <td>忽略的测试方法</td> 
  </tr> 
  <tr> 
   <td>@BeforeClass</td> 
   <td>针对所有测试，只执行一次，且必须为static void</td> 
  </tr> 
  <tr> 
   <td>@AfterClass</td> 
   <td>针对所有测试，只执行一次，且必须为static void</td> 
  </tr> 
  <tr> 
   <td>@RunWith</td> 
   <td>指定测试类使用某个运行器</td> 
  </tr> 
  <tr> 
   <td>@Parameters</td> 
   <td>指定测试类的测试数据集合</td> 
  </tr> 
  <tr> 
   <td>@Rule</td> 
   <td>允许灵活添加或重新定义测试类中的每个测试方法的行为</td> 
  </tr> 
  <tr> 
   <td>@FixMethodOrder</td> 
   <td>指定测试方法的执行顺序</td> 
  </tr> 
 </tbody> 
</table>

2. 执行顺序

一个测试类单元测试的执行顺序为：

@BeforeClass –> @Before –> @Test –> @After –> @AfterClass

每一个测试方法的调用顺序为：

@Before –> @Test –> @After

3. 示例

**\[java\]**  [view plain][]   [copy][view plain]

1.  **package** test;  
2.    
3.  **import** **static** org.junit.Assert.\*;  
4.    
5.  **import** org.junit.\*;  
6.    
7.  **public** **class** JDemoTest \{  
8.    
9.      @BeforeClass  
10.     **public** **static** **void** setUpBeforeClass() **throws** Exception \{  
11.         System.out.println("in BeforeClass================");  
12.     \}  
13.   
14.     @AfterClass  
15.     **public** **static** **void** tearDownAfterClass() **throws** Exception \{  
16.         System.out.println("in AfterClass=================");  
17.     \}  
18.   
19.     @Before  
20.     **public** **void** before() \{  
21.         System.out.println("in Before");  
22.     \}  
23.   
24.     @After  
25.     **public** **void** after() \{  
26.         System.out.println("in After");  
27.     \}  
28.   
29.     @Test(timeout = 10000)  
30.     **public** **void** testadd() \{  
31.         JDemo a = **new** JDemo();  
32.         assertEquals(6, a.add(3, 3));  
33.         System.out.println("in Test ----Add");  
34.     \}  
35.   
36.     @Test  
37.     **public** **void** testdivision() \{  
38.         JDemo a = **new** JDemo();  
39.         assertEquals(3, a.division(6, 2));  
40.         System.out.println("in Test ----Division");  
41.     \}  
42.   
43.     @Ignore  
44.     @Test  
45.     **public** **void** test\_ignore() \{  
46.         JDemo a = **new** JDemo();  
47.         assertEquals(6, a.add(1, 5));  
48.         System.out.println("in test\_ignore");  
49.     \}  
50.   
51.     @Test  
52.     **public** **void** teest\_fail() \{  
53.         fail();  
54.     \}  
55. \}  
56.   
57. **class** JDemo **extends** Thread \{  
58.   
59.     **int** result;  
60.   
61.     **public** **int** add(**int** a, **int** b) \{  
62.         **try** \{  
63.             sleep(1000);  
64.             result = a + b;  
65.         \} **catch** (InterruptedException e) \{  
66.         \}  
67.         **return** result;  
68.     \}  
69.   
70.     **public** **int** division(**int** a, **int** b) \{  
71.         **return** result = a / b;  
72.     \}  
73. \}

执行结果：

**\[plain\]**  [view plain][]   [copy][view plain]

1.  in BeforeClass================  
2.  in Before  
3.  in Test ----Add  
4.  in After  
5.  in Before  
6.  in Test ----Division  
7.  in After  
8.  in AfterClass=================

![Center][]

图中左上红框中部分表示Junit运行结果，5个成功（1个忽略），1个错误，1个失败。（注意错误和失败不是一回事，错误说明代码有错误，而失败表示该测试方法测试失败）

左下红框中则表示出了各个测试方法的运行状态，可以看到成功、错误、失败、失败各自的图标是不一样的，还可以看到运行时间。

右边部分则是异常堆栈，可查看异常信息。

下篇中我们给出更多示例还继续介绍Junit

[view plain]: http://blog.csdn.net/wangpeng047/article/details/9628449#
[Center]: /images/20220609/46fd5ff5e9054f6187ae0482349a001f.png