Spring系列第54篇：集成junit

star2017 1年前 ⋅ 618 阅读

通常我们写完代码之后，为了确保代码的正确性，都需要自己测试一遍，看一下代码的运行结果和我们期望的结果是不是一样的，也就是我们常说的单元测试，java中最常用的单元测试框架是junit，本文主要介绍3个内容：

1、玩转junit

2、spring集成junit

3、开发工具中使用junit

1、背景

我们写了一个工具类，有2个方法

  1. package com.javacode2018.junit.demo1;
  3. public class MathUtils {
  4.     /**
  5.      * 获取最大的数字
  6.      *
  7.      * @param args
  8.      * @return
  9.      */
  10.     public static int max(int... args) {
  11.         int result = Integer.MIN_VALUE;
  12.         for (int arg : args) {
  13.             result = result > arg ? result : arg;
  14.         }
  15.         return result;
  16.     }
  18.     /**
  19.      * 获取最小的数字
  20.      *
  21.      * @param args
  22.      * @return
  23.      */
  24.     public static int min(int... args) {
  25.         int result = Integer.MAX_VALUE;
  26.         for (int arg : args) {
  27.             result = result < arg ? result : arg;
  28.         }
  29.         return result;
  30.     }
  32. }

然后我们想测试这两个方法，下面我们来写测试代码，如下，测试一下max方法和min方法的结果和我们期望的结果是否一致，不一致的时候，输出一段文字

  1. package com.javacode2018.junit.demo1;
  3. public class MathUtilsTest1 {
  4.     public static void main(String[] args) {
  5.         testMax();
  6.         testMin();
  7.     }
  9.     public static void testMax() {
  10.         int result = MathUtils.max(1, 2, 3);
  11.         if (result != 3) {
  12.             System.out.println(String.format("max 方法有问题，期望结果是3，实际结果是%d", result));
  13.         }
  14.     }
  16.     public static void testMin() {
  17.         int result = MathUtils.min(1, 2, 3);
  18.         if (result != 1) {
  19.             System.out.println(String.format("min 方法有问题，期望结果是3，实际结果是%d", result));
  20.         }
  21.     }
  22. }

上面我们要测试的方法就2个，若需测试的方法很多的时候，咱们需要写大量的这种测试代码，工作量还是蛮大的，而junit做的事情和上面差不多，都是用来判断被测试的方法和期望的结果是否一致，不一致的时候给出提示，不过junit用起来更容易一些，还有各种开发用到的ide（eclipse、idea）结合的更好一些，用起来特别的顺手。

2、junit用法详解

2.1、使用步骤

1)、添加junit maven配置，这里我们就用4.13，你们也可以用最新的

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

2)、写测试用例，在写好的测试方法上面添加@Test注解，比如我们需要对上面案例中的max方法进行测试，通常我们会新建一个测试类，类名为被测试的类加上Test后缀，即：MathUtilsTest，然后在这个类我们需要写max方法的测试方法，如下，需要我们在max方法上面加上@Test注解

  1. package com.javacode2018.junit.demo1;
  3. import org.junit.Assert;
  4. import org.junit.Test;
  6. public class MathUtilsTest {
  7.     @Test
  8.     public void max() throws Exception {
  9.         int result = MathUtils.max(1, 2, 3);
  10.         //判断测试结果和我们期望的结果是否一致
  11.         Assert.assertEquals(result, 3);
  12.     }
  13. }

3、运行测试用例，现在测试代码都写好了，下面我们写个类来启动测试用例，这里需要使用JUnitCore.runClasses方法来运行测试用例，如下：

  1. package com.javacode2018.junit.demo1;
  3. import org.junit.runner.JUnitCore;
  4. import org.junit.runner.Result;
  5. import org.junit.runner.notification.Failure;
  7. public class Demo1TestRunner {
  8.     public static void main(String[] args) {
  9.         //使用JUnitCore.runClasses方法传入测试用例的类，然后获取测试用例的运行结果
  10.         Result result = JUnitCore.runClasses(MathUtilsTest.class);
  11.         //获取失败的用例
  12.         for (Failure failure : result.getFailures()) {
  13.             System.out.println(failure);
  14.         }
  15.         //获取所有测试用例是否执行成功
  16.         System.out.println(result.wasSuccessful());
  17.     }
  18. }

2.2、同时运行多个测试用例

可以一个测试类中写多个测试方法，每个方法上加上@Test注解就可以了，然后通过JUnitCore来执行就可以，下面代码中我们写2个方法对MathUtils中的max和min方法都进行测试，我们故意将执行结果和期望结果搞成不一致的，运行下面代码，然后看看运行结果。

  1. package com.javacode2018.junit.demo2;
  3. import com.javacode2018.junit.demo1.MathUtils;
  4. import org.junit.Assert;
  5. import org.junit.Test;
  6. import org.junit.runner.JUnitCore;
  7. import org.junit.runner.Result;
  8. import org.junit.runner.manipulation.Ordering;
  9. import org.junit.runner.notification.Failure;
  11. public class MathUtilsTest2 {
  12.     @Test
  13.     public void max() throws Exception {
  14.         int result = MathUtils.max(1, 2, 3);
  15.         //判断测试结果和我们期望的结果是否一致
  16.         Assert.assertEquals(result, 1);
  17.     }
  19.     @Test
  20.     public void min() throws Exception {
  21.         int result = MathUtils.min(1, 2, 3);
  22.         //判断测试结果和我们期望的结果是否一致
  23.         Assert.assertEquals(result, 3);
  24.     }
  26.     public static void main(String[] args) {
  27.         Result result = JUnitCore.runClasses(MathUtilsTest2.class);
  29.         System.out.println("失败用例个数:" + result.getFailures().size());
  30.         for (Failure failure : result.getFailures()) {
  31.             System.out.println(failure);
  32.         }
  33.         System.out.println("运行测试用例个数:" + result.getRunCount());
  34.         System.out.println("运行测试用例总耗时(ms):" + result.getRunTime());
  35.         System.out.println("测试用例是否都成功了：" + result.wasSuccessful());
  36.     }
  37. }

运行输出如下，运行了2个用例，失败了2个，测试的详细信息都被输出了

  1. 失败用例个数:2
  2. max(com.javacode2018.junit.demo2.MathUtilsTest2): expected:<3> but was:<1>
  3. min(com.javacode2018.junit.demo2.MathUtilsTest2): expected:<1> but was:<3>
  4. 运行测试用例个数:2
  5. 运行测试用例总耗时(ms):11
  6. 测试用例是否都成功了：false

2.3、使用断言

什么是断言？

断言是用来判断程序的运行结果和我们期望的结果是不是一致的，如果不一致，会抛出异常，断言中有3个信息比较关键

1、被测试的数据

2、期望的数据

3、抛出异常

断言提供的方法将被测试的数据和期望的数据进行对比，如果不一样的时候，将抛出异常，程序可以捕获这个异常，这样就可以知道测试失败了。

junit中的org.junit.Assert类中提供了大量静态方法，用来判断被测试的数据和期望的数据是否一致，不一致，将抛出异常，这里随便列几个大家看一下吧

  1. //判断condition如果不是true，将抛出异常，异常的提示信息是message
  2. public static void assertTrue(String message, boolean condition) 
  4. //判断expected和actual是否相等，如果不相等，将抛出异常
  5. public static void assertEquals(Object expected, Object actual)

用法，如：

  1. int result = MathUtils.max(1, 2, 3);
  2. //判断测试结果和我们期望的结果是否一致
  3. Assert.assertEquals(result, 1);

2.4、测试套件：批量运行测试用例

到目前为止，我们还只能一次运行一个测试类，如下

  1. JUnitCore.runClasses(MathUtilsTest2.class)

但是在实际项目中，我们可能会有很多测试类，需要批量运行。

比如我们有下面2个测试类

MathUtilsTest3001.java

  1. package com.javacode2018.junit.demo3;
  3. import com.javacode2018.junit.demo1.MathUtils;
  4. import org.junit.Assert;
  5. import org.junit.Test;
  7. public class MathUtilsTest3001 {
  8.     @Test
  9.     public void max() throws Exception {
  10.         int result = MathUtils.max(1, 2, 3);
  11.         //判断测试结果和我们期望的结果是否一致
  12.         Assert.assertEquals(result, 3);
  13.     }
  15.     @Test
  16.     public void min() throws Exception {
  17.         int result = MathUtils.min(1, 2, 3);
  18.         //判断测试结果和我们期望的结果是否一致
  19.         Assert.assertEquals(result, 1);
  20.     }
  21. }

MathUtilsTest3002.java

  1. package com.javacode2018.junit.demo3;
  3. import com.javacode2018.junit.demo1.MathUtils;
  4. import org.junit.Assert;
  5. import org.junit.Test;
  6. import org.junit.runner.JUnitCore;
  7. import org.junit.runner.Result;
  8. import org.junit.runner.notification.Failure;
  10. public class MathUtilsTest3002 {
  11.     @Test
  12.     public void max() throws Exception {
  13.         int result = MathUtils.max(100, 99, 200);
  14.         //判断测试结果和我们期望的结果是否一致
  15.         Assert.assertEquals(result, 200);
  16.     }
  18.     @Test
  19.     public void min() throws Exception {
  20.         int result = MathUtils.min(1, -1, 10);
  21.         //判断测试结果和我们期望的结果是否一致
  22.         Assert.assertEquals(result, -1);
  23.     }
  24. }

现在我们希望同时运行上面2个测试类，我们可以这么做，创建一个AllTest.java类，注意这个类上有2个注解比较特殊，都是junit提供的，@RunWith表示这是一个测试套件类，需要批量运行测试类，具体要运行哪些测试类呢，通过@Suite.SuiteClasses来指定

  1. package com.javacode2018.junit.demo3;
  3. import org.junit.runner.RunWith;
  4. import org.junit.runners.Suite;
  6. @RunWith(Suite.class)
  7. @Suite.SuiteClasses({MathUtilsTest3001.class, MathUtilsTest3002.class})
  8. public class AllTest {
  9. }

下面来个启动类，将AllTest传递给JUnitCore.runClasses

  1. package com.javacode2018.junit.demo3;
  3. import com.javacode2018.junit.demo1.MathUtilsTest;
  4. import com.javacode2018.junit.demo2.MathUtilsTest2;
  5. import org.junit.runner.JUnitCore;
  6. import org.junit.runner.Result;
  7. import org.junit.runner.notification.Failure;
  9. public class Demo3TestRunner {
  10.     public static void main(String[] args) {
  11.         //@1：传入AllTest
  12.         Result result = JUnitCore.runClasses(AllTest.class);
  14.         System.out.println("失败用例个数:" + result.getFailures().size());
  15.         for (Failure failure : result.getFailures()) {
  16.             System.out.println(failure);
  17.         }
  18.         System.out.println("运行测试用例个数:" + result.getRunCount());
  19.         System.out.println("运行测试用例总耗时(ms):" + result.getRunTime());
  20.         System.out.println("测试用例是否都成功了：" + result.wasSuccessful());
  21.     }
  22. }

运行输出

  1. 失败用例个数:0
  2. 运行测试用例个数:4
  3. 运行测试用例总耗时(ms):12
  4. 测试用例是否都成功了：true

测试套件中不仅可以包含基本的测试类，而且可以包含其它的测试套件，这样可以很方便的分层管理不同模块的单元测试代码，比如下面代码，Module2Test和Module2Test都是测试套件

  1. @RunWith(Suite.class)
  2. @Suite.SuiteClasses({Test1.class, Test2.class})
  3. public class Module2Test {
  4. }
  6. @RunWith(Suite.class)
  7. @Suite.SuiteClasses({Test1.class, Test2.class})
  8. public class Module2Test {
  9. }
  11. @RunWith(Suite.class)
  12. @Suite.SuiteClasses({Module2Test.class, Module2Test.class, Test3.java})
  13. public class AllTest {
  14. }
  16. //运行AllTest
  17. JUnitCore.runClasses(AllTest.class);

2.5、Junit常用注解

1）@Test注解

@Test：将一个普通方法修饰成一个测试方法

@Test(excepted=xx.class)：xx.class 表示异常类，表示测试的方法抛出此异常时，认为是正常的测试通过的

@Test(timeout = 毫秒数)：测试方法执行时间是否符合预期

2）@BeforeClass

会在所有的方法执行前被执行，static 方法 （全局只会执行一次，而且是第一个运行）

3）@AfterClass

会在所有的方法执行之后进行执行，static 方法 （全局只会执行一次，而且是最后一个运行）

4）@Before

会在每一个测试方法被运行前执行一次

5）@After

会在每一个测试方法运行后被执行一次

6）@Ignore

所修饰的测试方法会被测试运行器忽略

7）@RunWith

可以更改测试运行器 org.junit.runner.Runner

下面的案例，基本上用到了上面所有的注解，大家结合输出理解一下。

  1. package com.javacode2018.junit.demo4;
  3. import com.javacode2018.junit.demo1.MathUtils;
  4. import org.junit.*;
  5. import org.junit.runner.JUnitCore;
  6. import org.junit.runner.Result;
  7. import org.junit.runner.notification.Failure;
  9. import java.util.concurrent.TimeUnit;
  11. public class MathUtilsTest4 {
  13.     @BeforeClass
  14.     public static void bc() {
  15.         System.out.println("@BeforeClass");
  16.         System.out.println("-----------------");
  17.     }
  19.     @AfterClass
  20.     public static void ac() {
  21.         System.out.println("@AfterClass");
  22.     }
  24.     @Before
  25.     public void bf() {
  26.         System.out.println("@Before:" + this);
  27.     }
  29.     @After
  30.     public void af() {
  31.         System.out.println("@After:" + this);
  32.         System.out.println("##################");
  33.     }
  35.     @Test
  36.     public void max() throws Throwable {
  37.         System.out.println("max():" + this);
  38.         int result = MathUtils.max(1, 2, 3);
  39.         //判断测试结果和我们期望的结果是否一致
  40.         Assert.assertEquals(result, 3);
  41.     }
  43.     @Test
  44.     public void min() throws Exception {
  45.         System.out.println("min():" + this);
  46.         int result = MathUtils.min(1, 2, 3);
  47.         //判断测试结果和我们期望的结果是否一致
  48.         Assert.assertEquals(result, 1);
  49.     }
  51.     //方法运行时间超过了timeout，表示测试用例运行失败
  52.     @Test(timeout = 1000)
  53.     public void timeOutTest() throws InterruptedException {
  54.         System.out.println("timeOutTest():" + this);
  55.         TimeUnit.SECONDS.sleep(2000);
  56.     }
  58.     //方法若未抛出expected指定的异常，表示测试用例运行失败
  59.     @Test(expected = NullPointerException.class)
  60.     public void expectedTest() {
  61.         System.out.println("expectedTest():" + this);
  62.         new RuntimeException("异常不匹配");
  63.     }
  65.     @Test
  66.     @Ignore
  67.     public void ignoredMethod() {
  68.         System.out.println("我是被忽略的方法");
  69.     }
  71.     public static void main(String[] args) {
  72.         Result result = JUnitCore.runClasses(MathUtilsTest4.class);
  73.         System.out.println("-----------------");
  74.         System.out.println("运行测试用例个数:" + result.getRunCount());
  75.         System.out.println("失败用例个数:" + result.getFailures().size());
  76.         for (Failure failure : result.getFailures()) {
  77.             System.out.println(failure);
  78.         }
  79.         System.out.println("运行测试用例总耗时(ms):" + result.getRunTime());
  80.         System.out.println("测试用例是否都成功了：" + result.wasSuccessful());
  82.     }
  83. }

运行结果如下

  1. @BeforeClass
  2. -----------------
  3. @Before:com.javacode2018.junit.demo4.MathUtilsTest4@78e03bb5
  4. timeOutTest():com.javacode2018.junit.demo4.MathUtilsTest4@78e03bb5
  5. @After:com.javacode2018.junit.demo4.MathUtilsTest4@78e03bb5
  6. ##################
  7. @Before:com.javacode2018.junit.demo4.MathUtilsTest4@48533e64
  8. max():com.javacode2018.junit.demo4.MathUtilsTest4@48533e64
  9. @After:com.javacode2018.junit.demo4.MathUtilsTest4@48533e64
  10. ##################
  11. @Before:com.javacode2018.junit.demo4.MathUtilsTest4@7e0b37bc
  12. min():com.javacode2018.junit.demo4.MathUtilsTest4@7e0b37bc
  13. @After:com.javacode2018.junit.demo4.MathUtilsTest4@7e0b37bc
  14. ##################
  15. @Before:com.javacode2018.junit.demo4.MathUtilsTest4@1a93a7ca
  16. expectedTest():com.javacode2018.junit.demo4.MathUtilsTest4@1a93a7ca
  17. @After:com.javacode2018.junit.demo4.MathUtilsTest4@1a93a7ca
  18. ##################
  19. @AfterClass
  20. -----------------
  21. 运行测试用例个数:4
  22. 失败用例个数:3
  23. timeOutTest(com.javacode2018.junit.demo4.MathUtilsTest4): test timed out after 1000 milliseconds
  24. max(com.javacode2018.junit.demo4.MathUtilsTest4): hah 
  25. expectedTest(com.javacode2018.junit.demo4.MathUtilsTest4): Expected exception: java.lang.NullPointerException
  26. 运行测试用例总耗时(ms):1018
  27. 测试用例是否都成功了：false

从输出中可以看出

  • @BeforeClass和@AfterClass标注的方法只会运行一次
  • 每个@Test标注的方法运行之前会先运行@Before标注的方法，然后运行@Test标注的这个方法，之后再运行@After
  • 从this的输出看出，每个@Test运行的时候，当前类的实例都会重新创建一个新的
  • 不论@Test标注的方法是否异常，@AfterClass、@After标注的方法都会执行，且异常会被淹没，输出中看不到异常信息

2.6、参数化测试

Junit 4 引入了一个新的功能参数化测试。

参数化测试允许开发人员使用不同的值反复运行同一个测试，你将遵循 5 个步骤来创建参数化测试。

  • 用 @RunWith(Parameterized.class) 来注释 test 类。
  • 创建一个由 @Parameters 注释的公共的静态方法，它返回一个对象的集合(数组)来作为测试数据集合。
  • 创建一个公共的构造函数，它接受和一行测试数据相等同的东西。
  • 为每一列测试数据创建一个实例变量。
  • 用实例变量作为测试数据的来源来创建你的测试用例。

可能大家看了上面的理解，还是比较迷糊。

比如我们com.javacode2018.junit.demo1.MathUtils#max测试下面几组数组

  1. 1,2,3
  2. 100,99,80
  3. 30,-1,100

我们可以这么写

  1. package com.javacode2018.junit.demo5;
  3. import com.javacode2018.junit.demo1.MathUtils;
  4. import org.junit.Assert;
  5. import org.junit.Test;
  6. import org.junit.runner.JUnitCore;
  7. import org.junit.runner.Result;
  8. import org.junit.runner.RunWith;
  9. import org.junit.runner.notification.Failure;
  10. import org.junit.runners.Parameterized;
  12. import java.util.ArrayList;
  13. import java.util.Arrays;
  14. import java.util.List;
  16. @RunWith(Parameterized.class)
  17. public class MathUtilsTest5 {
  19.     public static class TestData {
  20.         int[] testData;//测试数据
  21.         int expectedValue;//预期的结果
  23.         public TestData(int[] testData, int expectedValue) {
  24.             this.testData = testData;
  25.             this.expectedValue = expectedValue;
  26.         }
  28.         @Override
  29.         public String toString() {
  30.             return "TestData{" +
  31.                     "testData=" + Arrays.toString(testData) +
  32.                     ", expectedValue=" + expectedValue +
  33.                     '}';
  34.         }
  35.     }
  37.     private TestData testData;
  39.     @Parameterized.Parameters
  40.     public static List<TestData> initTestData() {
  41.         System.out.println("initTestData()");
  42.         //key：期望的结果，value：max方法需要测试的数据
  43.         List<TestData> result = new ArrayList<>();
  44.         result.add(new TestData(new int[]{1, 2, 3}, 3));
  45.         result.add(new TestData(new int[]{100, 99, 80}, 100));
  46.         result.add(new TestData(new int[]{30, -1, 100}, 100));
  47.         return result;
  48.     }
  50.     public MathUtilsTest5(TestData testData) {
  51.         System.out.println("MathUtilsTest5构造器:" + testData);
  52.         this.testData = testData;
  53.     }
  55.     @Test
  56.     public void maxTest() throws Throwable {
  57.         System.out.println(this.hashCode() + ",maxTest():" + this.testData);
  58.         int result = MathUtils.max(this.testData.testData);
  59.         //判断测试结果和我们期望的结果是否一致
  60.         Assert.assertEquals(this.testData.expectedValue, result);
  61.         System.out.println("###################");
  62.     }
  64.     public static void main(String[] args) {
  65.         Result result = JUnitCore.runClasses(MathUtilsTest5.class);
  66.         System.out.println("-----------------");
  67.         System.out.println("运行测试用例个数:" + result.getRunCount());
  68.         System.out.println("失败用例个数:" + result.getFailures().size());
  69.         for (Failure failure : result.getFailures()) {
  70.             System.out.println(failure);
  71.         }
  72.         System.out.println("运行测试用例总耗时(ms):" + result.getRunTime());
  73.         System.out.println("测试用例是否都成功了：" + result.wasSuccessful());
  75.     }
  76. }

为了方便大家理解代码的运行过程，代码中添加了很多日志输出，运行结果如下，结合代码和输出，理解很容易

  1. initTestData()
  2. MathUtilsTest5构造器:TestData{testData=[1, 2, 3], expectedValue=3}
  3. 721748895,maxTest():TestData{testData=[1, 2, 3], expectedValue=3}
  4. ###################
  5. MathUtilsTest5构造器:TestData{testData=[100, 99, 80], expectedValue=100}
  6. 463345942,maxTest():TestData{testData=[100, 99, 80], expectedValue=100}
  7. ###################
  8. MathUtilsTest5构造器:TestData{testData=[30, -1, 100], expectedValue=100}
  9. 195600860,maxTest():TestData{testData=[30, -1, 100], expectedValue=100}
  10. ###################
  11. -----------------
  12. 运行测试用例个数:3
  13. 失败用例个数:0
  14. 运行测试用例总耗时(ms):12
  15. 测试用例是否都成功了：true

3、Spring集成junit

spring集成junit比较简单，下面我们来个案例感受一下。

3.1、加入maven配置

  1. <dependency>
  2.     <groupId>org.springframework</groupId>
  3.     <artifactId>spring-test</artifactId>
  4.     <version>5.2.6.RELEASE</version>
  5. </dependency>
  6. <dependency>
  7.     <groupId>junit</groupId>
  8.     <artifactId>junit</artifactId>
  9.     <version>4.13</version>
  10. </dependency>

3.2、来个spring的入口配置类

  1. package com.javacode2018.springjunit;
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.context.annotation.Configuration;
  6. @Configuration
  7. public class MainConfig {
  8.     @Bean
  9.     public String name() {
  10.         return "路人甲java";
  11.     }
  13.     @Bean
  14.     public int age() {
  15.         return 30;
  16.     }
  17. }

3.3、来个junit测试类集成spring

下面我们来个测试类，对上面的MainConfig中注册的2个bean进行测试

  1. package com.javacode2018.springjunit;
  3. import org.junit.Assert;
  4. import org.junit.Test;
  5. import org.junit.runner.RunWith;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.test.context.ContextConfiguration;
  8. import org.springframework.test.context.junit4.SpringRunner;
  10. @RunWith(SpringRunner.class) //@1
  11. @ContextConfiguration(classes = {MainConfig.class}) //@2
  12. public class MainConfigTest {
  14.     @Autowired
  15.     private String name;
  17.     @Autowired
  18.     private int age;
  20.     @Test
  21.     public void nameTest() {
  22.         System.out.println(this.name);
  23.         Assert.assertEquals("路人甲java", this.name);
  24.     }
  26.     @Test
  27.     public void ageTest() {
  28.         System.out.println(this.age);
  29.         Assert.assertEquals(30, this.age);
  30.     }
  31. }

注意上面的@1和@2的代码了，这就是spring集成junit的关键代码，@Runwith的值是org.springframework.test.context.junit4.SpringRunner，@ContextConfiguration注解通过classes属性指定spring启动类，如果是xml的方式，可以使用另外一个属性value或者locations来指定入口xml的位置。

上面代码中name和age属性上面都有@Autowired注解，这2个属性会被自动从spring容器中注入进来。

3.4、来个测试启动类

  1. package com.javacode2018.springjunit;
  3. import org.junit.runner.JUnitCore;
  4. import org.junit.runner.Result;
  5. import org.junit.runner.notification.Failure;
  7. public class TestRunner {
  9.     public static void main(String[] args) {
  10.         Result result = JUnitCore.runClasses(MainConfigTest.class);
  11.         System.out.println("-----------------");
  12.         System.out.println("运行测试用例个数:" + result.getRunCount());
  13.         System.out.println("失败用例个数:" + result.getFailures().size());
  14.         for (Failure failure : result.getFailures()) {
  15.             System.out.println(failure);
  16.         }
  17.         System.out.println("运行测试用例总耗时(ms):" + result.getRunTime());
  18.         System.out.println("测试用例是否都成功了：" + result.wasSuccessful());
  20.     }
  22. }

运行输出

  1. 30
  2. 路人甲java
  3. -----------------
  4. 运行测试用例个数:2
  5. 失败用例个数:0
  6. 运行测试用例总耗时(ms):422
  7. 测试用例是否都成功了：true

4、开发工具中使用junit

上面介绍的所有案例，都是通过main方法中用JUnitCore.runClasses来运行测试用例的，实际上有更简单的方式。

java的常用开发工具有eclipse和idea，这两个工具都将junit集成好了，通过开发工具继承的功能，运行测试用例更方便，不需要我们写JUnitCore.runClasses代码了。

我们来演示一下，如下图

点击1处的蓝色箭头，即可运行当前测试类中的所有用例，即2个测试方法，运行效果如下，左边显示了运行的测试用例列表，右边的显示了输出信息。

图中的2和3也可以点击，只会运行选中的那个测试方法，比如点击2，只会运行nameTest()这个用例，效果如下

5、总结

1、本文详细介绍了junit的用法，常用的注解有@Test、@BeforeClass、@AfterClass、@Before、@After、@Ignore、@RunWith，这些都要掌握

2、spring中集成junit，主要的配置就是在测试类上面需要加上下面代码

  1. @RunWith(SpringRunner.class) //@1
  2. @ContextConfiguration(classes = {MainConfig.class}) //@2

3、开发工具中使用junit更容易

6、案例源码

  1. git地址：
  2. https://gitee.com/javacode2018/spring-series
  4. 本文案例对应源码：
  5.     spring-series\lesson-008-junit
  6.     spring-series\lesson-008-springjunit

本博客所有系列案例代码以后都会放到这个上面，大家watch一下，可以持续关注动态。

最新资料

更多内容请访问：IT源点

注意：本文归作者所有，未经作者允许，不得转载

#Spring教程
阅读全部
相关文章推荐

全部评论: 0 条

    我有话说: