單元測試_JUnit常用單元測試注解介紹及代碼演示

@RunWith(Parameterized.class) 參數化運行器，配合@Parameters使用，參數化運行單元測試，需要在被修飾的測試類中的，提供數據的方法上加上一個@Parameters注解，例如，注意，這個提供數據的方法必須是靜態的(static)，並且返回一個集合(Collection)。

我們可以為@Parameters 提供一個“名稱”，以便更清晰的標記每個測試方法在每次運行時所使用的參數

“名稱”可以包含占位符，該占位符在運行時將會被替換。

·{index}: 當前參數的索引

·{0}, {1}, …: 第一個參數，第二個參數等對應的參數值。

@Test 注解將一個普通方法修飾為一個測試方法，可選參數 timeout、expected，如下：

@Test(timeout = 1000) 設置被修飾的測試方法在預期時間（例中為 1000毫秒)內執行完成，否則測試失敗；

@Test(expected = Exception.class）設置被修飾的測試方法應該拋出的預期異常，異常類型為：Exception.class，如果測試方法沒有拋出預期的異常，則測試失敗，例如 @Test(expected = NullPointException.class）

注意：測試方法必須是public void，即公共、無返回

參考鏈接：https://www.cnblogs.com/mengdd/archive/2013/04/13/3019278.html

@BeforeClass 注解用於修飾測試類中的非測試方法，該方法將在其所屬測試類中的所有測試方法被執行前運行，且只運行一次，可用於做一些測試基礎准備，比如數據庫連接，讀取文件等。

注意：@BeforeClass修飾的方法必須是被public static void 修飾的方法，即公開、靜態、無返回

@AfterClass 同@BeforeClass相反，注解用於修飾測試類中的非測試方法，該方法將在其所屬測試類中所有測試方法執行完成后被運行，且只運行一次，可用於做一些測試后續操作，比如斷開數據庫連接，關閉文件等。

注意：@AfterClass 修飾的方法必須是被public static void 修飾的方法，即公開、靜態、無返回

@Before 注解用於修飾測試類中的非測試方法，該方法會在其所屬測試類中的每一個測試方法運行前運行一次

與@BeforeClass的區別在於，@Before不止運行一次，它會在每個測試方法運行之前都運行一次。主要用於為單個測試方法做一些基礎的測試准備工作。

注意：@Before 修飾的方法必須是被public void 修飾的方法，即公開、無返回，但不能是被static修飾的

@After：用於修飾測試類中的非測試方法，同@Before相反，該方法會在其所屬測試類中的每一個測試方法執行完后都運行一次

注意：@After 修飾的方法必須是被public void 修飾的方法，即公開、無返回，但不能是被static修飾的

@ignore 注釋掉一個測試方法或一個類，被注釋的方法或類，不會被執行；

4. 運行環境配置

maven配置

確保安裝了java jdk並正確設置了JAVA_HOME

下載bin.zip壓縮包，解壓到目標路徑(例中 D:\Program Files\apache-maven-3.5.4\

)，設置MAVEN_HOME及Path環境變量，如下

cmd輸入mvn -v測試

Eclipse maven運行環境配置

如圖，Window - Preferences - Maven -User Settings，Browse指定maven配置文件所在路徑

更新項目

為了解決項目jar包依賴之類的問題，更新項目，右鍵項目根目錄 - Maven - Update Project

如下圖，默認已經選中了工程項目，默認選項配置的基礎上，勾選上“Force Update of Snapshots/Releases”，OK提交

5. 單元測試實踐

被測類BinarySearch

package org.shouke.demo;

public class BinarySearch {

public int binarySearch(long[] a, long key) {

int low = 0;

int high = a.length - 1;

while (low <= high) {

int mid = (low + high) >>> 1;

long midVal = a[mid];

if (midVal < key)

low = mid + 1;

else if (midVal > key)

high = mid - 1;

else

return mid;

}

return -1;

}

測試類BinarySearchTest

package org.shouke.test;

import org.junit.After;

import org.junit.AfterClass;

import org.junit.Assert;

import org.junit.Ignore;

import org.junit.Test;

import org.junit.Before;

import org.junit.BeforeClass;

import org.junit.runner.RunWith;

import org.junit.runners.JUnit4;

import org.shouke.demo.BinarySearch;

//@RunWith(SpringRunner.class)

@RunWith(JUnit4.class)

//@SpringBootTest

//@TestPropertySource("classpath:test-application.properties")

public class BinarySearchTest {

private BinarySearch binarySearch = new BinarySearch();

private long[] array1 = new long[] {};

@Test

public void testBinarySearch1() {

System.out.println("執行方法 testBinarySearch1");

int index = binarySearch.binarySearch(array1, 401L);

Assert.assertEquals(-1, index);

}

private long[] array2 = new long[] {123L,123L,123L,123L,123L,123L,123L,123L};

@Ignore

public void testBinarySearch2() {

System.out.println("執行方法 testBinarySearch2");

int index = binarySearch.binarySearch(array2, 401L);

Assert.assertEquals(-1, index);

}

private long[] array3 = new long[] {123L, 456L};

@Test

public void testBinarySearch3() {

System.out.println("執行方法 testBinarySearch3");

int index = binarySearch.binarySearch(array3, 401L);

Assert.assertEquals(-1, index);

}

private long[] array4 = new long[] {123L, 456L};

@Test

public void testBinarySearch4() {

System.out.println("執行方法 testBinarySearch4");

int index = binarySearch.binarySearch(array4, 40L);

Assert.assertEquals(-1, index);

}

private long[] array5 = new long[] {123L, 456L};

@Test

public void testBinarySearch5() {

System.out.println("執行方法 testBinarySearch5");

int index = binarySearch.binarySearch(array5, 123L);

Assert.assertEquals(0, index);

}

private long[] array6 = new long[] {123L, 123L};

@Test

public void testBinarySearch6() {

System.out.println("執行方法 testBinarySearch6");

int index = binarySearch.binarySearch(array6, 123L);

Assert.assertEquals(0, index);

}

@Before

public void testBeforeMethod() {

System.out.println("執行每個方法前先執行該函數");

}

@After

public void testAfterMethod() {

System.out.println("執行完每個方法后都會執行該函數");

}

@BeforeClass

public static void testBeforeClass() {

System.out.println("執行測試類的所有方法前先執行該函數");

}

@AfterClass

public static void testAfterClass() {

System.out.println("執行完測試類的所有方法后都會執行該函數");

}

被測類Caculator

package org.shouke.demo;

public class Caculator {

public int caculate(int arg1, int arg2) {

if (arg1 > arg2) {

return arg1 - arg2;

} else if (arg1 < arg2) {

return arg1 + arg2;

} else {

return arg1;

}

測試類CaculatorTest

package org.keshou.test;

import org.junit.Assert;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.junit.runners.Parameterized;

import org.shouke.demo.Caculator;

import java.util.Arrays;

import java.util.Collection;

@RunWith(Parameterized.class)

public class CaculatorTest {

private Caculator caculator = new Caculator();

public int arg1;

public int arg2;

public CaculatorTest(int arg1, int arg2) {

this.arg1 = arg1;

this.arg2 = arg2;

}

// @Parameterized.Parameters

@Parameterized.Parameters(name = "{index}: (arg1: {0} arg2: {1}")

public static Collectiondata() {

return Arrays.asList(new Object[][] {

{ 10, 1}, { 5, 1 }

});

}

@Test

public void testCaculate1() {

int result = caculator.caculate(arg1, arg2);

System.out.println("執行方法 testCaculate1 參數：" + arg1 + " " + arg1);

Assert.assertEquals(result, arg1-arg2);

}

@Test

public void testCaculate2() {

int result = caculator.caculate(arg1, arg2);

System.out.println("執行方法 testCaculate2 參數：" + arg1 + " " + arg1);

Assert.assertEquals(result, arg1+arg2);

}

說明：被@Parameters 注解修飾用於提供參數的方法有多少個參數，那么就需要為其所在類提供對應數量的類屬性，及一個包含對應數量的參數的構造函數，否則會報錯：java.lang.IllegalArgumentException: wrong number of arguments

測試套件類RunAllTestClass

package org.keshou.test;

import org.junit.runner.RunWith;

import org.junit.runners.Suite;

@RunWith(Suite.class)

@Suite.SuiteClasses({CaculatorTest.class, org.shouke.test.BinarySearchTest.class})

public class RunAllTestClass {

}

說明：如果需要運行多個測試類，只需要把目標測試類名稱.class放入如下的 {}中即可，測試類之間使用逗號分隔，如果不是同一個包中的測試類，記得加上對應的package名稱，或者使用import提前導入對應類。

@Suite.SuiteClasses({A.class, B.class, ...})

運行單元測試

如下圖，右鍵整個項目、單個測試類、測試套件 -> Coverage As -> JUnit Test