JUnit4.11和hamcrest-core-1.3 搭建自己的测试环境（非eclipse内置Junit）

1、JUnit4.11和hamcrest-core-1.3之间的关系

       junit和hamcrest是两个不同的框架，不同的东西。只不过是junit使用了hamcrest框架而已。

      在junit上可以直接下载junit包junit-4.11.jar  https://github.com/junit-team/junit/wiki/Download-and-Install

（建议此下载：http://download.youkuaiyun.com/detail/luojiming1990/5427395）

       另外再下载 关于hamcrest的相关的一系列的包（如果是java就下载jar的包）， http://code.google.com/p/hamcrest/downloads/list

下载后解压，lib包下有很多JAR包，如下

hamcrest-all-1.3.ORC2.ajr：几乎包含所有的hamctest的类（没有验证过）。

hamcrest-core-1.3.ORC2.jar：hamcrest的核心包，使用hamcrest框架必须引入的包。（junit官方给的包就包含了该包）

hamcrest-library-1.3.ORC2.jar：包含各种断言，补充hamcrest core包中的断言。

这次我们从中选两个：hamcrest-core-1.3.jar和hamcrest-library-1.3.jar

使用是导入包的方案：junit-4.11.jar +hamcrest-core-1.3.jar+ hamcrest-library-1.3.jar

或者是：junit-dep.ajr+hancrest-all.jar

这两种导入方法虽然尽量避免了导入重复的包，但使用时还是遇到了冲突。查看包中各类和文档后发现有些类(例如：断言is()）同时出现在了org.hamcrest.Mathchers和org.hamcrest.core中，则在用到时候引入的时候需要注意。（http://blog.youkuaiyun.com/lu8000/article/details/8941520）

在本地建立自己的Library 文件包，然后当作变量进行导入。（http://blog.youkuaiyun.com/dreamjava9213/article/details/41950955）

2、hamcrest

      hamcrest可以有效增加junit的测试能力，用一些对通俗语言来进行测试.

      Hamcrest 是一个测试的框架，它提供了一套通用的匹配符 Matcher，灵活使用这些匹配符定义的规则，程序员可以更加精确的表达自己的测试思想，指定所想设定的测试条件。比如，有时候定义的测试数据范围太精 确，往往是若干个固定的确定值，这时会导致测试非常脆弱，因为接下来的测试数据只要稍稍有变化，就可能导致测试失败（比如 assertEquals( x, 10 ); 只能判断 x 是否等于 10，如果 x 不等于 10， 测试失败）；有时候指定的测试数据范围又不够太精确，这时有可能会造成某些本该会导致测试不通过的数据，仍然会通过接下来的测试，这样就会降低测试的价 值。 Hamcrest 的出现，给程序员编写测试用例提供了一套规则和方法，使用其可以更加精确的表达程序员所期望的测试的行为。

hamcrest常用的匹配器:

• 核心
  • anything - 总是匹配,如果你不关心测试下的对象是什么是有用的
  • describedAs - 添加一个定制的失败表述装饰器
  • is - 改进可读性装饰器 - 见下 “Sugar”
• 逻辑
  • allOf - 如果所有匹配器都匹配才匹配, short circuits (很难懂的一个词,意译是短路,感觉不对,就没有翻译)(像 Java &&)
  • anyOf - 如果任何匹配器匹配就匹配, short circuits (像 Java ||)
  • not - 如果包装的匹配器不匹配器时匹配,反之亦然
• 对象
  • equalTo - 测试对象相等使用Object.equals方法
  • hasToString - 测试Object.toString方法
  • instanceOf, isCompatibleType - 测试类型
  • notNullValue, nullValue - 测试null
  • sameInstance - 测试对象实例
• Beans
  • hasProperty - 测试JavaBeans属性
• 集合
  • array - 测试一个数组元素test an array’s elements against an array of matchers
  • hasEntry, hasKey, hasValue - 测试一个Map包含一个实体,键或者值
  • hasItem, hasItems - 测试一个集合包含一个元素
  • hasItemInArray - 测试一个数组包含一个元素
• 数字
  • closeTo - 测试浮点值接近给定的值
  • greaterThan, greaterThanOrEqualTo, lessThan, lessThanOrEqualTo - 测试次序
• 文本
  • equalToIgnoringCase - 测试字符串相等忽略大小写
  • equalToIgnoringWhiteSpace - 测试字符串忽略空白
  • containsString, endsWith, startsWith - 测试字符串匹配

1.  要用junit中的assertThat来进行断言，记住静态导入

1. import static org.hamcrest.MatcherAssert.assertThat;  
2. import static org.hamcrest.Matchers.*;  
3. import static org.junit.Assert.*;  

2. 测试实例：

1. @Test  
2. public void testHamcrest(){  
3.     // 比较50是否和50相等  
4.     assertThat(50, equalTo(50));  
5. // 50是否大于30并且小于60  
6. assertThat("错误",50, allOf(greaterThan(30), lessThan(60)));  
7. // 判断字符串是否以.txt结尾  
8. assertThat("错误", "abc.txt", endsWith(".txt"));  
9.   
10. }  

特别注意， 如果使用junit4.10， 必须把hamcrest的jar包移到junit的jar包之前，否则组合条件allOf会抛出异常。
（http://blog.youkuaiyun.com/zl544434558/article/details/12650761）

三、简单的例子

    记得在几乎每本语言教学书上都能找到HelloWorld这个入门代码。今天在这里，我们也从一个简单到根本不用单元测试的例子入手。四则运算。

    第一步：建立项目引用junit-4.11.jar和hamcrest-core-1.3.jar

    第二步：编写Calculator类,代码如下:

1. package com.zjw.junit4;  
2.   
3. public class Calculator {   
4.   
5.     public int plus(int x, int y) {  
6.         return x + y;  
7.     }  
8.   
9.     public int subtraction(int x, int y) {  
10.         return x - y;  
11.     }  
12.   
13.     public int multiplication(int x, int y) {  
14.         return x * y;  
15.     }  
16.   
17.     public int division(int x, int y) {  
18.         return x / y;  
19.     }  
20.   
21. }   

    第三步：编写单元测试类,代码如下:

1. package com.zjw.junit4.test;  
2.   
3. import static org.junit.Assert.*; //注意这边,静态导入  
4.   
5. import org.junit.Ignore;  
6. import org.junit.Test;  
7.   
8. import com.zjw.junit4.Calculator;  
9.   
10. public class TestCalculator {  
11.   
12.     @Test  
13.     public void testPlus() {  
14.         Calculator cal = new Calculator();  
15.         assertEquals(cal.plus(5, 5), 10);  
16.     }  
17.   
18.     @Test  
19.     public void testSubtraction() {  
20.         Calculator cal = new Calculator();  
21.         assertEquals(cal.subtraction(5, 5), 0);  
22.     }  
23.   
24.     @Ignore  
25.     @Test  
26.     public void testMultiplication() {  
27.         Calculator cal = new Calculator();  
28.         assertTrue(cal.multiplication(5, 5) > 20);  
29.     }  
30.   
31.     @Test(expected = java.lang.ArithmeticException.class, timeout = 50)  
32.     public void testDivision() {  
33.         Calculator cal = new Calculator();  
34.         assertEquals(cal.division(8, 0), 4); //大家注意看,除数是0  
35.     }  
36. }  

    第四步:测试,在这里,我用的是MyEclipse,在TestCalculator类上右键找到Run As 下的JUnit Test,点击然后就开始测试了

    第五步:观察测试结果,在这里我测试都是正确的,我们来分析测试结果和代码:

   

1.         Failure是指测试失败

2.         Error是指测试程序本身出错

3.         由于我在testMultiplication方法上加了@Ignore 所以该方法会被忽略

4.         testDivision为什么报测试异常？

1. @Test(expected = java.lang.ArithmeticException.class, timeout = 50)  

看这个@Test expected后面指定你希望抛出的异常,timeout的意思是 如果测试没有在50ms内完成,那么就算测试失败.

5.       大家有没有觉得在每个测试方法下都new一个Calculator对象很浪费资源,假如有80个测试方法呢?所以接下来我们要使用@BeforeClass,代码如下:

1. package com.zjw.junit4.test;  
2.   
3. import static org.junit.Assert.*;  
4.   
5. import org.junit.BeforeClass;  
6. import org.junit.Ignore;  
7. import org.junit.Test;  
8.   
9. import com.zjw.junit4.Calculator;  
10.   
11. public class TestCalculator {  
12.       
13.     private static Calculator cal;  
14.           
15.     @BeforeClass  
16.     public static void beforeClass(){ //静态方法  
17.         cal=new Calculator();  
18.     }  
19.       
20.     @Test  
21.     public void testPlus() {  
22.         assertEquals(cal.plus(5, 5), 10);  
23.     }  
24.   
25.     @Test  
26.     public void testSubtraction() {  
27.         assertEquals(cal.subtraction(5, 5), 0);  
28.     }  
29.   
30.     @Ignore  
31.     @Test  
32.     public void testMultiplication() {  
33.         assertTrue(cal.multiplication(5, 5) > 20);  
34.     }  
35.   
36.     @Test(expected = java.lang.ArithmeticException.class, timeout = 50)  
37.     public void testDivision() {  
38.         assertEquals(cal.division(8, 0), 4);  
39.     }  
40. }  

为什么@BeforeClass下的方法必须是静态的?因为它在类初始化之前就运行了 .

为什么需要@BeforeClass,因为有的测试需要在测试之前需要取得一些很耗费时间的资源或者要搭建比较耗时间的环境例如建立数据库连接,搭建数据库连接池.与之对应的还有@AfterClass,用于释放资源,这边我就不写了.

四、JUnit的Annoation:

1.         @Test: 测试方法

a)        (expected=XXException.class)

b)        (timeout=xxx)

2.         @Ignore: 忽略测试方法

3.         @Before: 每一个测试方法之前运行

4.         @After: 每一个测试方法之后运行

5.         @BeforeClass: 所有测试开始之前运行,别忘了方法是静态的.

6.         @AfterClass: 所有测试结束之后运行

五、注意

a)        测试类放在test包中

b)        类名用TestXXX

c)        方法用test方法名命名

六、总结

本文简单的介绍了JUnit使用的入门知识,以后会讲同时测试多个类以及JUnit4的新特性...(http://blog.youkuaiyun.com/a672489861/article/details/10065133)