Junit使用教程

时间  2019-11-17
标签 junit 使用 教程 栏目 Java 繁體版
原文   原文链接

       Junit目前在一些大的公司或者相对规范的软件中使用的比较多，至关多的小公司并无把单元测试看的过重要。在大点的公司开发人员天天上班后，第一件事情就是从svn上把本身负责的代码checkout下来，而后运行单元测试，若是单元测试经过，那么说明本身的代码没有问题，而后就在代码块上修改与添加，完成后再用junit进行测试，测试完成后若是没有问题，那么就把相应的代码块提交给svn上。java

测试通常分为：单元测试、集成测试（主要看一块代码加进去后，系统会不会有问题）、验收测试和压力测试。数组

 

       在之前的的项目中也用过Junit，当时的使用只是把Junit当成一个有多个main方法的一个函数。假如一个项目很是的大，测试的东西很是的多，若是不用Junit的话，那么这个工做量是很是大的。单元测试的最基本的一个功能是能进行自动化测试。单元测试都是经过断言的方式来肯定结果是否正确，即便用Assert。svn

 

1、创建Junit测试类函数

1. 右击test测试包，选择New-->Oher...oop

 

2. 在窗口中找到Junit，选择Junit Test Case单元测试

3. 输入名称(Name)，命名规则通常建议采用：类名+Test。Browse...选择要测试的类，这里是StudentService。测试

4. 勾选要测试的方法ui

5. 生成后，效果以下：this

这里import static是引入Assert类中静态属性或静态方法的写法。原来要Assert.fail()，如今只需直接fial()便可，即省略了Assert。spa

其实不经过Junit新建向导来创建也能够，随便创建一个新类后，只需在方法上加入@Test注解便可。

 

2、核心——断言

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

1. 断言核心方法

assertArrayEquals(expecteds, actuals) 查看两个数组是否相等。
assertEquals(expected, actual) 查看两个对象是否相等。相似于字符串比较使用的equals()方法
assertNotEquals(first, second) 查看两个对象是否不相等。
assertNull(object) 查看对象是否为空。
assertNotNull(object) 查看对象是否不为空。
assertSame(expected, actual) 查看两个对象的引用是否相等。相似于使用“==”比较两个对象
assertNotSame(unexpected, actual) 查看两个对象的引用是否不相等。相似于使用“!=”比较两个对象
assertTrue(condition) 查看运行结果是否为true。
assertFalse(condition) 查看运行结果是否为false。
assertThat(actual, matcher) 查看实际值是否知足指定的条件
fail() 让测试失败

2. 示例

[java]   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. }  

3、核心——注解

1. 说明

@Before 初始化方法
@After 释放资源
@Test 测试方法，在这里能够测试指望异常和超时时间
@Ignore 忽略的测试方法
@BeforeClass 针对全部测试，只执行一次，且必须为static void
@AfterClass 针对全部测试，只执行一次，且必须为static void
@RunWith 指定测试类使用某个运行器
@Parameters 指定测试类的测试数据集合
@Rule 容许灵活添加或从新定义测试类中的每一个测试方法的行为
@FixMethodOrder 指定测试方法的执行顺序

2. 执行顺序

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

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

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

@Before –> @Test –> @After

3. 示例

[java]   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
  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=================  

 

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

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

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

 

4、实例总结

1. 参数化测试

有时一个测试方法，不一样的参数值会产生不一样的结果，那么咱们为了测试全面，会把多个参数值都写出来并一一断言测试，这样有时不免费时费力，这是咱们即可以采用参数化测试来解决这个问题。参数化测试就比如把一个“输入值，指望值”的集合传入给测试方法，达到一次性测试的目的。

[java]   view plain
  1. package test;  
  2.   
  3. import static org.junit.Assert.*;  
  4.   
  5. import java.util.Arrays;  
  6.   
  7. import org.junit.Test;  
  8. import org.junit.runner.RunWith;  
  9. import org.junit.runners.Parameterized;  
  10. import org.junit.runners.Parameterized.Parameters;  
  11.   
  12. @RunWith(Parameterized.class)  
  13. public class FibonacciTest {  
  14.   
  15.     @Parameters(name = "{index}: fib({0})={1}")  
  16.     public static Iterable<Object[]> data() {  
  17.         return Arrays.asList(new Object[][] { { 0, 0 }, { 1, 1 }, { 2, 1 },  
  18.                 { 3, 2 }, { 4, 3 }, { 5, 5 }, { 6, 8 } });  
  19.     }  
  20.   
  21.     private int input;  
  22.     private int expected;  
  23.   
  24.     public FibonacciTest(int input, int expected) {  
  25.         this.input = input;  
  26.         this.expected = expected;  
  27.     }  
  28.   
  29.     @Test  
  30.     public void test() {  
  31.         assertEquals(expected, Fibonacci.compute(input));  
  32.     }  
  33. }  
  34.   
  35. class Fibonacci {  
  36.   
  37.     public static int compute(int input) {  
  38.         int result;  
  39.         switch (input) {  
  40.         case 0:  
  41.             result = 0;  
  42.             break;  
  43.         case 1:  
  44.         case 2:  
  45.             result = 1;  
  46.             break;  
  47.         case 3:  
  48.             result = 2;  
  49.             break;  
  50.         case 4:  
  51.             result = 3;  
  52.             break;  
  53.         case 5:  
  54.             result = 5;  
  55.             break;  
  56.         case 6:  
  57.             result = 8;  
  58.             break;  
  59.         default:  
  60.             result = 0;  
  61.         }  
  62.         return result;  
  63.     }  
  64. }  

@Parameters注解参数name，实际是测试方法名称。因为一个test()方法就完成了全部测试，那假如某一组测试数据有问题，那在Junit的结果页面里该如何呈现？所以采用name实际上就是区分每一个测试数据的测试方法名。以下图：

2. 打包测试

一样，若是一个项目中有不少个测试用例，若是一个个测试也很麻烦，所以打包测试就是一次性测试完成包中含有的全部测试用例。

[java]   view plain
  1. package test;  
  2.   
  3. import org.junit.runner.RunWith;  
  4. import org.junit.runners.Suite;  
  5.   
  6. @RunWith(Suite.class)  
  7. @Suite.SuiteClasses({ AssertTests.class, FibonacciTest.class, JDemoTest.class })  
  8. public class AllCaseTest {  
  9.   
  10. }  

这个功能也须要使用一个特殊的Runner ，须要向@RunWith注解传递一个参数Suite.class 。同时，咱们还须要另一个注解@Suite.SuiteClasses，来代表这个类是一个打包测试类。并将须要打包的类做为参数传递给该注解就能够了。至于AllCaseTest随便起一个类名，内容为空既可。运行AllCaseTest类便可完成打包测试

3. 异常测试

异常测试与普通断言测试不一样，共有三种方法，其中最为灵活的是第三种，能够与断言结合使用

第一种：

[java]   view plain
  1. @Test(expected= IndexOutOfBoundsException.class)   
  2. public void empty() {   
  3.      new ArrayList<Object>().get(0);   
  4. }  

第二种：

[java]   view plain
  1. @Test  
  2. public void testExceptionMessage() {  
  3.     try {  
  4.         new ArrayList<Object>().get(0);  
  5.         fail("Expected an IndexOutOfBoundsException to be thrown");  
  6.     } catch (IndexOutOfBoundsException anIndexOutOfBoundsException) {  
  7.         assertThat(anIndexOutOfBoundsException.getMessage(), is("Index: 0, Size: 0"));  
  8.     }  
  9. }  

第三种：

[java]   view plain
  1. @Rule  
  2. public ExpectedException thrown = ExpectedException.none();  
  3.   
  4. @Test  
  5. public void shouldTestExceptionMessage() throws IndexOutOfBoundsException {  
  6.     List<Object> list = new ArrayList<Object>();  
  7.   
  8.     thrown.expect(IndexOutOfBoundsException.class);  
  9.     thrown.expectMessage("Index: 0, Size: 0");  
  10.     list.get(0);  
  11.     Assert.assertEquals(1, list.get(0));  
  12. }  

在上述几种方法中，不管是expected仍是expect都表示指望抛出的异常，假如某一方法，当参数为某一值时会抛出异常，那么使用第一种方法就必须为该参数单独写一个测试方法来测试异常，而没法与其余参数值一同写在一个测试方法里，因此显得累赘。第二种方法虽然解决这个问题，可是写法不只繁琐也不利于理解。而第三种犯法，不只能动态更改指望抛出的异常，与断言语句结合的也很是好，所以推荐使用该方法来测试异常。

4. 限时测试

有时为了防止出现死循环或者方法执行过长（或检查方法效率），而须要使用到限时测试。顾名思义，就是超出设定时间即视为测试失败。共有两种写法。

第一种：

[java]   view plain
  1. @Test(timeout=1000)  
  2. public void testWithTimeout() {  
  3.   ...  
  4. }  

第二种：

[java]   view plain
  1. public class HasGlobalTimeout {  
  2.     public static String log;  
  3.   
  4.     @Rule  
  5.     public Timeout globalTimeout = new Timeout(10000); // 10 seconds max per method tested  
  6.   
  7.     @Test  
  8.     public void testInfiniteLoop1() {  
  9.         log += "ran1";  
  10.         for (;;) {  
  11.         }  
  12.     }  
  13.   
  14.     @Test  
  15.     public void testInfiniteLoop2() {  
  16.         log += "ran2";  
  17.         for (;;) {  
  18.         }  
  19.     }  
  20. }  

其中，第二种方法与异常测试的第三种方法的写法相似。也是推荐的写法。

 

http://huihai.iteye.com/blog/1986568

http://blog.csdn.net/wangpeng047/article/details/9627527

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程