什么是JUnit

JUnit是Java单元测试框架，方便好用。

单元测试就是最小粒度的测试，Java中就是方法测试，最小粒度是方法。

我们说的JUnit默认指JUnit4，即Java7一下版本使用的单元测试，Java8以后请使用JUnit5，提供了更好用的测试API

本项目所有代码均在github开源：https://github.com/initit-com/JUnitDemo

下载安装

推荐使用Maven引入，本质就是引入了junt.jar和hamcrest-core.jar两个jar包

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

快速上手

  1. //@Test 标注一个方法为单元测试代码
  2. //单元测试是最小粒度的测试，即方法测试
  3. //方法必须是public的 ，返回值必须是 void
  4. @Test
  5. public void test() {
  6.     //todo 这里写你的业务代码
  7.     int num = 1;
  8.     //断言：判断结果是否否和你的预期
  9.     //符合预期 true时 绿条通过
  10.     //不符合预期 false时 红条并输出报错信息
  11.     assertEquals(1, num);
  12. }

断言 assert

  1. //断言两个数组是否相等 assertArrayEquals
  2. @Test
  3. public void testAssertArrayEquals() {
  4.     byte[] expected = "trial".getBytes();
  5.     byte[] actual = "trial".getBytes();
  6.     assertArrayEquals("failure - byte arrays not same", expected, actual);
  7. }
  9. //断言两个对象是否相等
  10. @Test
  11. public void testAssertEquals() {
  12.     assertEquals("failure - strings are not equal", "text", "text");
  13. }
  15. //断言是否为false
  16. @Test
  17. public void testAssertFalse() {
  18.     assertFalse("failure - should be false", false);
  19. }
  21. //断言是否为true
  22. @Test
  23. public void testAssertTrue() {
  24.     assertTrue("failure - should be true", true);
  25. }
  27. //断言是否为空
  28. @Test
  29. public void testAssertNotNull() {
  30.     assertNotNull("should not be null", new Object());
  31. }
  33. //断言两个对象不一样
  34. @Test
  35. public void testAssertNotSame() {
  36.     assertNotSame("should not be same Object", new Object(), new Object());
  37. }
  39. //断言为空
  40. @Test
  41. public void testAssertNull() {
  42.     assertNull("should be null", null);
  43. }
  45. //断言两对象一样
  46. @Test
  47. public void testAssertSame() {
  48.     Integer aNumber = Integer.valueOf(768);
  49.     assertSame("should be same", aNumber, aNumber);
  50. }
  52. //匹配器断言
  53. // JUnit Matchers assertThat
  54. @Test
  55. public void testAssertThatBothContainsString() {
  56.     assertThat("albumen", both(containsString("a")).and(containsString("b")));
  57. }
  59. @Test
  60. public void testAssertThatHasItems() {
  61.     assertThat(Arrays.asList("one", "two", "three"), hasItems("one", "three"));
  62. }
  64. @Test
  65. public void testAssertThatEveryItemContainsString() {
  66.     assertThat(Arrays.asList(new String[]{"fun", "ban", "net"}), everyItem(containsString("n")));
  67. }
  69. // Core Hamcrest Matchers with assertThat
  70. @Test
  71. public void testAssertThatHamcrestCoreMatchers() {
  72.     assertThat("good", allOf(equalTo("good"), startsWith("good")));
  73.     assertThat("good", not(allOf(equalTo("bad"), equalTo("good"))));
  74.     assertThat("good", anyOf(equalTo("bad"), equalTo("good")));
  75.     assertThat(7, not(CombinableMatcher.<Integer>either(equalTo(3)).or(equalTo(4))));
  76.     assertThat(new Object(), not(sameInstance(new Object())));
  77. }

假设 assume

表达一种假设成立的情况下才进行测试，假设不成立则不测试

  1. //假设判断当前操作系统
  2. @Test
  3. public void filenameIncludesUsername() {
  4. //assumeThat(File.separatorChar, is('/'));
  5. assumeThat(File.separatorChar, is('\\'));
  6. System.out.println("走了");
  7. assertThat("configfiles/optimus.cfg", is("configfiles/optimus.cfg"));
  8. }
  9. //windows 下运行 会通过，其他系统会报错

测试执行的顺序

多个测试方法一起执行时，jvm会随机顺序执行，如果你想执行方法的执行顺序，可以使用(MethodSorters.DEFAULT)@FixMethodOrder

  • @FixMethodOrder(MethodSorters.JVM)：将测试方法按 JVM 返回的顺序保留。此顺序可能因运行而异。
  • @FixMethodOrder(MethodSorters.NAME_ASCENDING)：按方法名称、字典顺序对测试方法进行排序。

示例：以下代码将按其名称的顺序执行测试方法，按升序排序

  1. import org.junit.FixMethodOrder;
  2. import org.junit.Test;
  3. import org.junit.runners.MethodSorters;
  5. @FixMethodOrder(MethodSorters.NAME_ASCENDING)
  6. public class Demo3_测试方法执行顺序 {
  8.     @Test
  9.     public void testA() {
  10.         System.out.println("first");
  11.     }
  12.     @Test
  13.     public void testB() {
  14.         System.out.println("second");
  15.     }
  16.     @Test
  17.     public void testC() {
  18.         System.out.println("third");
  19.     }
  20. }

测试结果如下

image.png

异常测试

JUnit可以测试程序运行时抛出的异常，是否跟预期一致

  1. //预期 抛出异常
  2. //expected = IndexOutOfBoundsException.class
  3. @Test(expected = IndexOutOfBoundsException.class)
  4. public void empty() {
  5.     new ArrayList<Object>().get(0);
  6. }
  8. //预期异常消息的值
  9. @Test
  10. public void testExceptionMessage() {
  11.     try {
  12.         new ArrayList<Object>().get(0);
  13.         fail("Expected an IndexOutOfBoundsException to be thrown");
  14.     } catch (IndexOutOfBoundsException anIndexOutOfBoundsException) {
  15.         assertThat(anIndexOutOfBoundsException.getMessage(), is("Index: 0, Size: 0"));
  16.     }
  17. }
  19. //预期异常规则
  20. @Rule
  21. public ExpectedException thrown = ExpectedException.none();
  22. @Test
  23. public void shouldTestExceptionMessage() throws IndexOutOfBoundsException {
  24.     List<Object> list = new ArrayList<Object>();
  26.     thrown.expect(IndexOutOfBoundsException.class);
  27.     thrown.expectMessage("Index: 0, Size: 0");
  28.     //        thrown.expectMessage(CoreMatchers.containsString("Size: 0")); //或者这样写
  29.     list.get(0); // execution will never get past this line
  30. }

匹配器和断言

一种可读性更好的断言方式：assertThat([value], [matcher statement]);

  1. assertThat(x, is(3));
  2. assertThat(x, is(not(4)));
  3. assertThat(responseString, either(containsString("color")).or(containsString("colour")));
  4. assertThat(myList, hasItem("3"));

匹配器断言excel

参考：https://github.com/tobyweston/simple-excel

  1. //安装
  2. //可通过Maven 存储库手动下载或将存储库添加到您的"pom.xml"。
  3. <repositories>
  4.     <repository>
  5.         <id>bad.robot</id>
  6.         <name>bad.robot repository on robotooling</name>
  7.         <url>http://www.robotooling.com/maven/</url>
  8.         <snapshots>
  9.             <enabled>true</enabled>
  10.             <updatePolicy>always</updatePolicy>
  11.         </snapshots>
  12.     </repository>
  13. </repositories>
  14. //然后添加依赖项。
  15. <dependency>
  16.     <groupId>bad.robot</groupId>
  17.     <artifactId>simple-excel</artifactId>
  18.     <version>1.1</version>
  19.     <scope>compile</scope>
  20. </dependency>
  22. //使用            
  23. @Test
  24. public void shouldReplaceCellsInComplicatedAlternateSyntaxExample() throws IOException {
  25.     HSSFWorkbook workbook = getWorkbook("shouldReplaceCellsInComplicatedExampleTemplate.xls");
  26.     new PoiWorkbookMutator(workbook)
  27.             .replaceCell(coordinate(C, 5), "Adding")
  28.             .replaceCell(coordinate(D, 11), "a")
  29.             .replaceCell(coordinate(G, 3), "cell")
  30.             .replaceCell(coordinate(J, 10), "total")
  31.             .replaceCell(coordinate(M, 15), 99.99d);
  33.     assertThat(workbook, sameWorkbook(getWorkbook("shouldReplaceCellsInComplicatedExampleTemplateExpected.xls")));
  34. }
  35. //输出结构
  36. java.lang.AssertionError:
  37. Expected: equality of cell "G1"
  38.      but: cell at "G1" contained <"Text"> expected <99.99D>
  39.     at org.hamcrest.MatcherAssert.assertThat(MatcherAssert.java:20)

匹配器断言Json

参考：https://github.com/hertzsprung/hamcrest-json

  1. //安装
  2. <dependency>
  3.     <groupId>uk.co.datumedge</groupId>
  4.     <artifactId>hamcrest-json</artifactId>
  5.     <version>0.1</version>
  6. </dependency>
  8. //使用
  9. assertThat(
  10.     "{\"age\":43, \"friend_ids\":[16, 52, 23]}",
  11.     sameJSONAs("{\"friend_ids\":[52, 23, 16]}")
  12.         .allowingExtraUnexpectedFields()
  13.         .allowingAnyArrayOrdering());

匹配器断言Xml

参考：https://github.com/davidehringer/xml-matchers

  1. Source xml = ...
  2. assertThat(xml, hasXPath("/mountains/mountain"));
  4. Node xml = ...
  5. assertThat(
  6.        the(xml),
  7.         hasXPath("count(/mountains/mountain)", 
  8.                 returningANumber(), 
  9.                 greaterThanOrEqualTo(2d)));
  12. String xml = "<mountains><mountain>K2</mountain></mountains>";
  13. String xmlWithSpaceWrappingText = "<mountains><mountain>\n\tK2\n\t </mountain></mountains>";
  14. assertThat(the(xml), isEquivalentTo(the(xmlWithSpaceWrappingText)));
  17. Schema schema = w3cXmlSchemaFromClasspath("org/xmlmatchers/validation/example.xsd");
  18. String xml = "<person private=\"true\"><name>Dave</name></person>";
  19. assertThat(the(xml), conformsTo(schema));

忽略测试

如果由于某种原因，您不希望测试失败，您只想忽略它，可以暂时忽略测试

  1. @Ignore("Test is ignored as a demonstration")
  2. @Test
  3. public void testSame() {
  4.     assertThat(1, is(1));
  5. }

测试超时

测试超过一定时间自动失败报错

  1. //毫秒数
  2. @Test(timeout = 1000)
  3. public void testWithTimeout() throws Exception {
  4. Thread.sleep(999);
  5. }

超时规则（适用于测试类中的所有测试用例）

  1. import org.junit.Rule;
  2. import org.junit.Test;
  3. import org.junit.rules.Timeout;
  5. public class HasGlobalTimeout {
  6.     public static String log;
  7.     private final CountDownLatch latch = new CountDownLatch(1);
  9.     @Rule
  10.     // 10 seconds max per method tested
  11.     public Timeout globalTimeout = Timeout.seconds(10); 
  13.     @Test
  14.     public void testSleepForTooLong() throws Exception {
  15.         log += "ran1";
  16.         TimeUnit.SECONDS.sleep(100); // sleep for 100 seconds
  17.     }
  19.     @Test
  20.     public void testBlockForever() throws Exception {
  21.         log += "ran2";
  22.         latch.await(); // will block 
  23.     }
  24. }

测试生命周期处理

有时候，你需要在测试方法运行前做一些准备处理，测试方法完成后做一下后续处理。提供四个测试注解

  • @BeforeClass – 表示在类中的任意public static void方法执行之前执行
  • @AfterClass – 表示在类中的任意public static void方法执行之后执行
  • @Before – 表示在任意使用@Test注解标注的public void方法执行之前执行
  • @After – 表示在任意使用@Test注解标注的public void方法执行之后执行
  • @Test – 使用该注解标注的public void方法会表示为一个测试方法
  1. package org.byron4j.spring_mvc_log4j;
  3. import org.junit.After;
  4. import org.junit.AfterClass;
  5. import org.junit.Before;
  6. import org.junit.BeforeClass;
  7. import org.junit.Test;
  9. public class BasicAnnotationTest {
  10.     // Run once, e.g. Database connection, connection pool
  11.     @BeforeClass
  12.     public static void runOnceBeforeClass() {
  13.         System.out.println("@BeforeClass - runOnceBeforeClass");
  14.     }
  16.     // Run once, e.g close connection, cleanup
  17.     @AfterClass
  18.     public static void runOnceAfterClass() {
  19.         System.out.println("@AfterClass - runOnceAfterClass");
  20.     }
  22.     // Should rename to @BeforeTestMethod
  23.     // e.g. Creating an similar object and share for all @Test
  24.     @Before
  25.     public void runBeforeTestMethod() {
  26.         System.out.println("@Before - runBeforeTestMethod");
  27.     }
  29.     // Should rename to @AfterTestMethod
  30.     @After
  31.     public void runAfterTestMethod() {
  32.         System.out.println("@After - runAfterTestMethod");
  33.     }
  35.     @Test
  36.     public void test_method_1() {
  37.         System.out.println("@Test - test_method_1");
  38.     }
  40.     @Test
  41.     public void test_method_2() {
  42.         System.out.println("@Test - test_method_2");
  43.     }
  44. }
  46. //输出
  47. @BeforeClass - runOnceBeforeClass
  48. @Before - runBeforeTestMethod
  49. @Test - test_method_1
  50. @After - runAfterTestMethod
  51. @Before - runBeforeTestMethod
  52. @Test - test_method_2
  53. @After - runAfterTestMethod
  54. @AfterClass - runOnceAfterClass

参考资源如下