Junit4学习与使用

原文地址：

http://blog.csdn.net/qqhjqs/article/details/42219037?reload

http://blog.csdn.net/liushuijinger/article/details/32140843

学习使用JUnit4，既然使用最新版本了，就不要再考虑老版本是如何使用的了，之前有听过JUnit但一直没有使用，现在开始学习使用JUnit4！

介绍就不说了，简单的理解为“就是一个方便大家测试的插件！”

现在使用Myeclipse来实现创建Junit4（Eclipse突然挂掉了，但两者差不了多少）

既然要测试方法，首先要有方法，我使用最简单的加减乘除。

Calculator.java

[java] view plain copy

1. package com.demo;  
2.   
3. public class Calculator {  
4.     private double x;  
5.     private double y;  
6.     public double getX() {  
7.         return x;  
8.     }  
9.     public void setX(double x) {  
10.         this.x = x;  
11.     }  
12.     public double getY() {  
13.         return y;  
14.     }  
15.     public void setY(double y) {  
16.         this.y = y;  
17.     }  
18.   
19.     public double add(double x , double y) {  
20.         return x + y;  
21.     }  
22.       
23.     public double reduction(double x , double y) {  
24.         return x - y;  
25.     }  
26.       
27.     public double multiply(double x , double y) {  
28.         return x * y;  
29.     }  
30.       
31.     public double division(double x , double y) {  
32.         return x / y;  
33.     }  
34. }  

接下来就要为这个类创建测试类了，看仔细步骤：

第一步：右键点击Calculator.java，New--->JUnit Test case（一般情况下直接会看到，如果没有看到的话就点击Other，然后就可以找到了），如图：

这里说明一点，最好右键你想测试的测试类，这样的话，测试类的名称与路径工具会为你自动填充，就像下面，如图：

三个红框要填写准确，对了，还有上面选择JUnit版本，如果出来的界面和这不一样，都空着，那就自己填写，名字规范化“XXXTest”,下面的Class under test 点击Browse之后，要自己输入类名，路径才能出现。

第二步，点击next，选择你将要测试的方法，如图：

最后，点击finish，一个测试类就自动完成了。

CalculatrorTest.java

[java] view plain copy

1. public class CalculatorTest {  
2.   
3.     @BeforeClass  
4.     public static void setUpBeforeClass() throws Exception {  
5.     }  
6.   
7.     @AfterClass  
8.     public static void tearDownAfterClass() throws Exception {  
9.     }  
10.   
11.     @Test  
12.     public void testAdd() {  
13.         fail("Not yet implemented");  
14.     }  
15.   
16.     @Test  
17.     public void testReduction() {  
18.         fail("Not yet implemented");  
19.     }  
20.   
21.     @Test  
22.     public void testMultiply() {  
23.         fail("Not yet implemented");  
24.     }  
25.   
26.     @Test  
27.     public void testDivision() {  
28.         fail("Not yet implemented");  
29.     }  
30.   
31. }  

首先观察一下内部代码结构
和@BeforeClass、@AfterClass、@Test

setUpBeforeClass()方法在整个类初始化之后调用，一般用来做测试准备工作；

tearDownAfterClass()方法在整个类结束之前调用，一般做测试的清理工作。

这里使用了注解，简单的理解为依赖反射，在测试类前标注@Test即可，我看了JUnit3中，写测试方法名必须以testxxx标识，而且需要继承TestCase等等，JUnit4大量的使用注解来解决这一现象，既方便又快捷。

下面介绍一下经常使用到的一些注解：

       @Before：初始化方法

@After：释放资源

@Test：测试方法，在这里可以测试期望异常和超过时间

@Ignore：忽略的测试方法

@BeforeClass：针对所有测试方法，只执行一次，且必须为static void

@AfterClass：针对所有测试，只执行一次，且必须为static void

@RunWith：指定测试类使用某个运行器

@Parameters：指定测试类的测试数据集合

@Rule：允许灵活添加或重新定义测试类中的每个测试方法的行为

@FixMethodOrder:指定测试方法的执行顺序

下面为测试类编写测试过程，这里还要说明一下，我当时不知道咋想的，定义的变量是double型，然后在写assertEquals的时候出现了问题，一般情况下使用这个函数assertEquals（expected, actual）“期望值和实际值”，然后就提示说这个方法被废弃，这点很纳闷，之前用的还好好的，怎么就突然被废弃了呢？后来才知道，double型的参数与函数，要使用assertEquals(expected, actual, delta)除了期望值和实际值之外还有一个“delta---差值”也就是可允许的误差范围！这一点不得不佩服编写API的人员，因为他想的太周到了，下面就用代码演示一下：

[java] view plain copy

1. package com.demo;  
2.   
3. import static org.junit.Assert.*;  
4.   
5. import org.junit.AfterClass;  
6. import org.junit.BeforeClass;  
7. import org.junit.Ignore;  
8. import org.junit.Test;  
9.   
10. public class CalculatorTest {  
11.   
12.     @BeforeClass  
13.     public static void setUpBeforeClass() throws Exception {  
14.         System.out.println("开始测试");  
15.     }  
16.   
17.     @AfterClass  
18.     public static void tearDownAfterClass() throws Exception {  
19.         System.out.println("测试结束");  
20.     }  
21.   
22.     @Test  
23.     public void testAdd() {  
24.         System.out.println("加法测试");  
25.         Calculator test = new Calculator();  
26.         assertEquals(10,test.add(4, 6),0);  
27.     }  
28.   
29.     @Test  
30.     public void testReduction() {  
31.         System.out.println("减法测试");  
32.         Calculator test = new Calculator();  
33.         assertEquals(5, test.reduction(6.9, 1.4), 0.1);  
34.     }  
35.     @Ignore("忽略乘法测试")  
36.     @Test  
37.     public void testMultiply() {  
38.         System.out.println("乘法测试");  
39.         fail("Not yet implemented");  
40.     }  
41.   
42.     @Test  
43.     public void testDivision() {  
44.         System.out.println("除法测试");  
45.         Calculator test = new Calculator();  
46.         assertEquals(3, test.division(10, 3), 0.5);  
47.     }  
48.   
49. }  

先看下运行结果：

可以看看JUnit对话框中出现的四个方法，打钩的是运行成功；“/”是添加@Ignore注解的方法，也就是忽略测试的方法；每个方法后面都有运行的时间，控制台输出方法运行的顺序

@BeforeClass –> @Test –> @AfterClass

如果加上@Before和@After的话，顺序就是这样

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

再看提示的错误信息，相差0.5，也就是说误差是0.5，然而我故意写的0.05，当然报错了，这里提示的信息很详细。。。；注意代码里的除法测试，我给的参数是10和3，也就是10/3，然后给的期望值是3，无论给多少都有误差（0.3333333333...），所以我在误差里写上0.5，程序运行正确！

到这里Junit4最最简单的介绍和最最基本的使用方法交代完毕，肯定有不足的地方，希望大家给出建议和批评。随着对JUnit的使用，以后我还会继续记录JUnit的使用方法！

如何更好的进行单元测试？

在讨论如何更好的进行单元测试之前，先来看看我们以前是怎么测试代码的。

以前是这样测试程序的：

[java] view plain copy

1. public int add(int x,int y) {  
2.     return x + y;  
3. }  
4.       
5. public static void main(String args[]) {  
6.     int z = new Junit().add(2, 3);  
7.     System.out.println(z);  
8. }  

如上面所示，在测试我们写好的一个方法时，通常是用一个main方法调用一下我们要测试的方法，然后将结果打印一下。现在看来这种方式已经非常out了，所以出现了很多单元测试的工具，如：JUnit、TestNG等。借助它们可以让我们的单元测试变得非常方便、高效。今天就说说如何利用JUnit进行单元测试。

我们新建一个Java Project以便进行演示，至于Java Project怎么创建我就不在此赘述了，如果连怎么建Java Project，那你还不适合看这篇文章。建好以后在该项目的“src”目录上右击，选择new——》JUnit Test Case，然后按下图填写必要信息：

填写好包名和类名（选择New JUnit 4 Test），点击最下面的那个“Browse”按钮来选择需要测试的类：

手动输入我们要测试的类，选择该类，点击“OK”，回到第一张图的界面，然后点击“Next”，来到下图：

勾选要测试的方法，点击“Finish”，这样我们的JUnit测试实例就建好了。然后就可以写具体的测试了：

[java] view plain copy

1. package com.tgb.junit.test;  
2.   
3. //静态引入  
4. import static org.junit.Assert.*;  
5. import static org.hamcrest.Matchers.*;  
6.   
7. import org.junit.Test;  
8.   
9. import com.tgb.junit.Junit;  
10.   
11. public class JUnitTest {  
12.   
13.     @Test  
14.     public void testAdd() {  
15.         int z = new  Junit().add(2, 3);  
16.         assertThat(z , is(5));  
17.     }  
18.   
19.     @Test  
20.     public void testDivide() {  
21.         int z = new Junit().divide(4, 2);         
22.         assertThat(z, is(2));  
23.     }  
24. }  

写好以后，右击该类选择“Run As”——》“JUnit Test”，出现下图代表测试通过：

到这里，可能有人会有疑问，JUnit跟用main方法测试有什么区别呢？

首先，JUnit的结果更加直观，直接根据状态条的颜色即可判断测试是否通过，而用main方法你需要去检查他的输出结果，然后跟自己的期望结果进行对比，才能知道是否测试通过。有一句话能够很直观的说明这一点——keeps the bar green to keeps the code clean。意思就是说，只要状态条是绿色的，那么你的代码就是正确的。

第二点，JUnit让我们同时运行多个测试变得非常方便，下面就演示一下如何进行多实例测试：

首先我们要再建一个待测试类，然后再建一个对应的JUnit测试实例，步骤略。然后在我们测试实例的包上右击选择“Run As”——》“Run Configurations”，如下图；

选择第二项“Run all tests in the selected project, package or source folder”，然后点击“Run”效果如下：

可以看到，我们本次测试了两个类，共三个方法，这种方便的效果在测试实例越多的情况下，体现的越明显。至于main方法运行多个测试，想想就觉得非常麻烦，这里就不演示了。

JUnit除了可以测试这些简单的小程序，还可以测试Struts、JDBC等等，这里只是用这个小程序做过简单的介绍。本实例使用的是hamcrest断言，而没有使用老的断言，因为hamcrest断言更加接近自然语言的表达方式，更易于理解。

本实例需要引入以下三个jar包：

hamcrest-core-1.3.jar
hamcrest-library-1.3.jar
junit-4.10.jar

最后附上常用hamcrest断言的使用说明：

[java] view plain copy

1. 数值类型  
2. //n大于1并且小于15，则测试通过  
3. assertThat( n, allOf( greaterThan(1), lessThan(15) ) );  
4. //n大于16或小于8，则测试通过  
5. assertThat( n, anyOf( greaterThan(16), lessThan(8) ) );  
6. //n为任何值，都测试通过  
7. assertThat( n, anything() );  
8. //d与3.0的差在±0.3之间，则测试通过  
9. assertThat( d, closeTo( 3.0, 0.3 ) );  
10. //d大于等于5.0，则测试通过  
11. assertThat( d, greaterThanOrEqualTo (5.0) );  
12. //d小于等于16.0，则测试通过  
13. assertThat( d, lessThanOrEqualTo (16.0) );  
14.   
15. 字符类型  
16. //str的值为“tgb”，则测试通过  
17. assertThat( str, is( "tgb" ) );  
18. //str的值不是“tgb”，则测试通过  
19. assertThat( str, not( "tgb" ) );  
20. //str的值包含“tgb”，则测试通过  
21. assertThat( str, containsString( "tgb" ) );  
22. //str以“tgb”结尾，则测试通过  
23. assertThat( str, endsWith("tgb" ) );   
24. //str以“tgb”开头，则测试通过  
25. assertThat( str, startsWith( "tgb" ) );   
26. //str忽略大小写后，值为“tgb”，则测试通过  
27. assertThat( str, equalToIgnoringCase( "tgb" ) );   
28. //str忽略空格后，值为“tgb”，则测试通过  
29. assertThat( str, equalToIgnoringWhiteSpace( "tgb" ) );  
30. //n与nExpected相等，则测试通过（对象之间）  
31. assertThat( n, equalTo( nExpected ) );   
32.   
33. collection类型  
34. //map中包含key和value为“tgb”的键值对，则测试通过  
35. assertThat( map, hasEntry( "tgb", "tgb" ) );  
36. //list中包含“tgb”元素，则测试通过  
37. assertThat( iterable, hasItem ( "tgb" ) );  
38. //map中包含key为“tgb”的元素，则测试通过  
39. assertThat( map, hasKey ( "tgb" ) );  
40. //map中包含value为“tgb”的元素，则测试通过  
41. assertThat( map, hasValue ( "tgb" ) );