使用方法

pom.xml 文件引入依赖:

  1. <dependency>
  2. <groupId>junit</groupId>
  3. <artifactId>junit</artifactId>
  4. <version>4.12</version>
  5. </dependency>

创建测试用例,新建一个测试类 JUnitTestLearn、测试方法 test01 上面增加注解 @org.junit.Test:

  1. public class JUnitTestLearn {
  2. @Test
  3. public void test01() {
  4. System.out.println("hello JUnit");
  5. }
  6. }

点击方法左边绿色三角形运行:
image.png
第一个测试用例测试通过!

@Before和@After运行流程

JUnit 中的方法执行过程,即哪一个方法首先被调用,哪一个方法在一个方法之后调用。以下为 JUnit 测试方法的 API,并且会用例子来说明。
创建测试:

  1. import org.junit.After;
  2. import org.junit.AfterClass;
  3. import org.junit.Before;
  4. import org.junit.BeforeClass;
  5. import org.junit.Test;
  6. public class JUnitTestLearn {
  7. @BeforeClass
  8. public static void beforeClass() {
  9. System.out.println("before class");
  10. }
  11. @AfterClass
  12. public static void afterClass() {
  13. System.out.println("after class");
  14. }
  15. @Before
  16. public void before() {
  17. System.out.println("before");
  18. }
  19. @After
  20. public void after() {
  21. System.out.println("after");
  22. }
  23. @Test
  24. public void test01() {
  25. System.out.println("test01");
  26. }
  27. @Test
  28. public void test02() {
  29. System.out.println("test02");
  30. }
  31. }

运行结果:

  1. before class
  2. before
  3. test01
  4. after
  5. before
  6. test02
  7. after
  8. after class

通过观察上方的运行结果得出结论:

  • @BeforeClass 只执行一次,并且最先执行
  • @AfterClass 只执行一次,并且最后执行
  • @Before 在每个 @Test 方法之前执行一次
  • @After 在每个 @Test 方法之后执行一次

运行流程图:
JUnit单元测试入门 - 图2

测试套件

有时我们想一次性执行多个测试类,如果要手动一个个点击运行会比较烦琐。
测试套件可以将多个测试类合并。在 JUnit 中,@RunWith 和 @Suite 注释用来完成套件测试。
创建 JUnitTest1 类:

  1. import org.junit.Test;
  2. public class JUnitTest1 {
  3. @Test
  4. public void test01() {
  5. System.out.println("JUnitTest1->test01");
  6. }
  7. }

创建 JUnitTest2 类:

  1. import org.junit.Test;
  2. public class JUnitTest2 {
  3. @Test
  4. public void test01() {
  5. System.out.println("JUnitTest2->test01");
  6. }
  7. }

创建 JUnitTestSuite 类,把多个测试类整合在一起:

  1. import org.junit.runner.RunWith;
  2. import org.junit.runners.Suite;
  3. @RunWith(Suite.class)
  4. @Suite.SuiteClasses({
  5. JUnitTest1.class,
  6. JUnitTest2.class
  7. })
  8. public class JUnitTestSuite {
  9. }

点击 JUnitTestSuite 左边三角形箭头即可运行多个测试类:
image.png
运行结果:

  1. JUnitTest1->test01
  2. JUnitTest2->test01

注解总结

@Test:这个注释说明依附在 JUnit 的 public void 方法可以作为一个测试案例。
@Test(expected=Xxx.class):expected 参数表示我们期望会出现什么异常。
@Test(timeout=毫秒):timeout 参数表示我们期望测试在 n 毫秒内运行完成。
@Before:会在每个测试用例开始之前执行一次。
@After:会在每个测试用例结束之后执行一次。
@Ingnore:这个注释是用来忽略有关不需要执行的方法。
@BeforeClass:会在所有用例开始之前执行。
@AfterClass:会在所有用例结束后执行。
@RunWith:测试套件,用于整合多个测试类。
@Suite.SuiteClasses:与@RunWith 一起使用,声明要整合的测试类。

Assert类

org.junit.Assert 下提供了许多断言方法:
image.png
如果不符合断言预期,将抛出 java.lang.AssertionError 异常,该异常类型与 Java 自带 assert 关键字抛出的异常类型一致。