2.2 Junit测试方法介绍
junit.framework是JUnit 中的最重要的程序包，junit.framework中包含了JUnit所有的核心类，包括Assert类、TestCase类、TestResult类以及TestSuite类。
2.2.1 Assert类
Assert类提供了一系列的断言方法来编写测试用例，允许检查测试方法的期望结果值和真实返回值，只有失败的断言才会被记录。
JUnit为所有基本类型、对象和数组提供了可重载的断言方法。断言方法中，参数的顺序是先输入预期输出，后输入真实取值。参数的数量并不一定是两个（预期与真实），还可以视情况填写第一个参数作为可选的错误提示信息。
Assert 类的重要方法如下表2.1所示：
| 方法 | 描述 |
|---|---|
| assertNull(java.lang.Object object) | 检查对象是否为空 |
| assertNotNull(java.lang.Object object) | 检查对象是否不为空 |
| assertEquals(long expected, long actual) | 检查long类型的值是否相等 |
| assertEquals(double expected, double actual, double delta) | 检查指定精度的double值是否相等 |
| assertFalse(boolean condition) | 检查条件是否为假 |
| assertTrue(boolean condition) | 检查条件是否为真 |
| assertSame(java.lang.Object expected, java.lang.Object actual) | 检查两个对象引用是否引用同一对象（即对象是否相等） |
| assertNotSame(java.lang.Object unexpected, java.lang.Object actual) | 检查两个对象引用是否不引用统一对象(即对象不等) |
表2.1 断言的主要方法
我们在上一章节演示的简单的测试流程中，使用的就是assert类的断言方法，判断加减乘除四则运算的结果和我们预期的结果是否相同，如果相同就说明我们定义的加减乘除方法没有出错。如果不同，系统会提示我们哪里的预期值和实际值冲突，方便我们检查错误。
除了上述的断言方法外，在Junit4中，引入了新的断言方法assertthat，assertthat的参数为可选的错误提示，测试的真正输出取值，以及一个Matcher对象。需要注意其参数（预期与真实）的顺序与内置的传统断言方式的取值相反。它可以使用一般匹配符、字符串相关匹配符、数值相关匹配符以及collection相关匹配符。具体使用方法如下所述：
㈠ 一般匹配符
1、allOf
匹配符表明如果接下来的所有条件必须都成立测试才通过，相当于“与”（&&）
assertThat( testedNumber, allOf( greaterThan(8), lessThan(16) ) );
2、anyOf
匹配符表明如果接下来的所有条件只要有一个成立则测试通过，相当于“或”（||）
assertThat( testedNumber, anyOf( greaterThan(16), lessThan(8) ) );
3、anything
匹配符表明无论什么条件，永远为true
assertThat( testedNumber, anything() );
4、is
匹配符表明如果前面待测的object等于后面给出的object，则测试通过
assertThat( testedString, is( "developerWorks" ) );
5、not
匹配符和is匹配符正好相反，表明如果前面待测的object不等于后面给出的object，则测试通过
assertThat( testedString, not( "developerWorks" ) );
㈡ 字符串相关匹配符
1、containsString
匹配符表明如果测试的字符串testedString 包含 子字符串"developerWorks"则测试通过
assertThat( testedString, containsString( "developerWorks" ) );
2、endsWith
匹配符表明如果测试的字符串testedString以子字符串"developerWorks"结尾则测试通过
assertThat( testedString, endsWith( "developerWorks" ) );
3、startsWith
匹配符表明如果测试的字符串testedString以子字符串"developerWorks"开始则测试通过
assertThat( testedString, startsWith( "developerWorks" ) );
4、equalTo
匹配符表明如果测试的testedValue等于expectedValue则测试通过，equalTo可以测试数值之间，字符串
之间和对象之间是否相等，相当于Object的equals方法
assertThat( testedValue, equalTo( expectedValue ) );
5、equalToIgnoringCase
匹配符表明如果测试的字符串testedString在忽略大小写的情况下等于"developerWorks"则测试通过
assertThat( testedString, equalToIgnoringCase( "developerWorks" ) );
6、equalToIgnoringWhiteSpace
匹配符表明如果测试的字符串testedString在忽略头尾的任意个空格的情况下等于"developerWorks"则测试通过，注意：字符串中的空格不能被忽略
assertThat( testedString, equalToIgnoringWhiteSpace( "developerWorks" ) );
㈢ 数值相关匹配符
1、closeTo
匹配符表明如果所测试的浮点型数testedDouble在20.0±0.5范围之内则测试通过
assertThat( testedDouble, closeTo( 20.0, 0.5 ) );
2、greaterThan
匹配符表明如果所测试的数值testedNumber大于16.0则测试通过
assertThat( testedNumber, greaterThan(16.0) );
3、lessThan
匹配符表明如果所测试的数值testedNumber小于16.0则测试通过
assertThat( testedNumber, lessThan (16.0) );
4、greaterThanOrEqualTo
匹配符表明如果所测试的数值testedNumber大于等于16.0则测试通过
assertThat( testedNumber, greaterThanOrEqualTo (16.0) );
5、lessThanOrEqualTo
匹配符表明如果所测试的数值testedNumber小于等于16.0则测试通过
assertThat( testedNumber, lessThanOrEqualTo (16.0) );
㈣ collection相关匹配符
1、hasEntry
匹配符表明如果测试的Map对象mapObject含有一个键值为"key"对应元素值为"value"的Entry项则测试通过
assertThat( mapObject, hasEntry( "key", "value" ) );
2、hasItem
匹配符表明如果测试的迭代对象iterableObject含有元素“element”项则测试通过
assertThat( iterableObject, hasItem ( "element" ) );
3、hasKey
匹配符表明如果测试的Map对象mapObject含有键值“key”则测试通过
assertThat( mapObject, hasKey ( "key" ) );
4、hasValue
匹配符表明如果测试的Map对象mapObject含有元素值“value”则测试通过
assertThat( mapObject, hasValue ( "key" ) );
assertThat方法具有很多优点，1.它可以替代之前我们所罗列的很多assertion语句，包括assertEquals等；2. assertThat 使用了 Hamcrest 的 Matcher 匹配符，用户可以使用匹配符规定的匹配准则精确的指定一些想设定满足的条件，具有很强的易读性，而且使用起来更加灵活；3. assertThat 不再像 assertEquals 那样，使用比较难懂的“谓宾主”语法模式（如：assertEquals(3, x);），相反，assertThat 使用了类似于“主谓宾”的易读语法模式（如：assertThat(x,is(3));），使得代码更加直观、易读；4. assertThat方法可以将这些 Matcher 匹配符联合起来灵活使用，达到更多目的；5.assertThat方法的错误信息更加易懂、可读且具有描述性；6. 开发人员可以通过实现 Matcher 接口，定制自己想要的匹配符。当开发人员发现自己的某些测试代码在不同的测试中重复出现，经常被使用，这时用户就可以自定义匹配符，将这些代码绑定在一个断言语句中，从而可以达到减少重复代码并且更加易读的目的。
2.2.2 TestCase类
TestCase类在整个JUnit框架中处于核心的地位。你可以在junit.framework包中发现TestCase这个类。在JUnit开发人员当中广泛存在着一个疑惑，那就是测试用例（test case）和TestCase类之间的关系。“测试用例”（test case）这个术语通常指的是单个的测试，通过编码来校验某个特定的行为。将多个测试用例都收集到一个类中，这个类是TestCase的子类，而且每一个测试用例都被实现为TestCase类中的一个方法。
虽然在编写测试的时候，你需要创建一个“TestCase”的子类，并把每个测试用例都实现为这个新类的方法；但是在运行的时候，每个测试用例都会被当作TestClass子类的一个实例来运行。使用面向对象的术语来说，每个测试用例都是一个TestCase的对象。
TestCase定义了运行多重测试的固定格式，其重要方法如表2.2所示：
| 方法 | 描述 |
|---|---|
| int countTestCases() | 为被run(TestResult result) 执行的测试案例计数 |
| TestResult createResult() | 创建一个默认的 TestResult 对象 |
| String getName() | 获取 TestCase 的名称 |
| TestResult run() | 一个运行这个测试的方便的方法，收集由TestResult 对象产生的结果 |
| void run(TestResult result) | 在 TestResult 中运行测试案例并收集结果 |
| void setName(String name) | 设置 TestCase 的名称 |
| void setUp() | 创建固定设置，例如，打开一个网络连接 |
| void tearDown() | 拆除固定设置，例如，关闭一个网络连接 |
| String toString() | 返回测试案例的一个字符串表示 |
表2.2 TestCase的主要方法
2.2.3 TestResult类
TestResult 类收集所有被执行的测试案例的结果，是收集参数层面的一个实例。TestResult类可以区分失败和错误。失败是可以预料的并且可以通过假设来检查，而错误是不可预料的问题。
TestResult 类的一些重要方法，如表2.3所示：
| 方法 | 描述 |
|---|---|
| void addError(Test test, Throwable t) | 在错误列表中加入一个错误 |
| void addFailure(Test test, AssertionFailedError t) | 在失败列表中加入一个失败 |
| void endTest(Test test) | 显示测试被编译的结果 |
| int errorCount() | 获取被检测错误的数量 |
| Enumeration errors() | 返回相关错误的详细信息 |
| int failureCount() | 获取被检测出的失败数量 |
| void run(TestCase test) | 运行 TestCase |
| int int runCount() | 获得运行的测试数量 |
| void startTest(Test test) | 声明测试即将开始 |
| void stop() | 声明测试必须停止 |
表2.3 TestResult方法
2.2.4 TestSuite类
TestSuite 类是Junit的测试套件，运行了很多的测试案例。TestSuite 类的一些重要方法如表2.4所示：
| 方法 | 描述 |
|---|---|
| void addTest(Test test) | 在测试套件中加入测试 |
| void addTestSuite(Class<? extends TestCase> testClass) | 将已经给定的类中的测试加到测试套件之中 |
| int countTestCases() | 对这个测试即将运行的测试案例进行计数 |
| String getName() | 返回名称 |
| void run(TestResult result) | 在 TestResult 中运行测试案例并收集结果 |
| void setName(String name) | 设置名称 |
| Test testAt(int index) | 在给定的目录中返回测试 |
| int testCount() | 返回测试套件中测试的数量 |
| static Test warning(String message) | 返回会失败的测试并且记录警告信息 |
表2.4 TestSuite的主要方法
2.2.5断言代码示例
首先我们演示一下断言的具体应用，我们用一个测试用例来显示基本的断言方法：
import static org.junit.Assert.*;
import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
public class AssertionsTest {
//测试为空
@Test
public void testAssertNull() {
String str = null;
assertNull(str);
}
//测试不为空
@Test
public void testAssertNotNull() {
String str = "hello Java!!";
assertNotNull(str);
}
//测试Long类型的两个值相等
@Test
public void testAssertEqualsLong() {
long long1 = 2;
long long2 = 2;
assertEquals(long1, long2);
}
//测试Double类型的两个值相等
@Test
public void testAssertEqualsDouble() {
// test case is successfull as double1 and double 2
// differ by 0.001 which is less than our specified delta
double double1 = 1.236;
double double2 = 1.237;
double delta = 0.002;
assertEquals(double1, double2, delta);
}
//测试为真
@Test
public void testAssertTrue() {
List<String> list = new ArrayList<String>();
assertTrue(list.isEmpty());
}
//测试为假
@Test
public void testAssertFalse() {
List<String> list = new ArrayList<String>();
list.add("hello");
assertFalse(list.isEmpty());
}
//测试相同
@Test
public void testAssertSame() {
String str1 = "hello world!!";
String str2 = "hello world!!";
assertSame(str2, str1);
}
//测试不相同
@Test
public void testAssertNotSame() {
String str1 = "hello world!!";
String str3 = "hello Java!!";
assertNotSame(str1, str3);
}
}
下面再示范assertThat的具体用法，先新建一个java测试类：
public class A {
public int add(int a, int b) {
return a + b;
}
public double div(double a, double b) {
return a / b;
}
public String getName(String name) {
return name;
}
public List<String> getList(String item) {
List<String> l = new ArrayList<String>();
l.add(item);
return l;
}
public Map<String, String> getMap(String key, String value) {
Map<String, String> m = new HashMap<String, String>();
m.put(key, value);
return m;
}
}
下面我们对这个类新建一个测试用例进行测试，具体代码如下：
import static org.junit.Assert.*;
import static org.hamcrest.Matchers.*;
import java.util.List;
import java.util.Map;
import org.junit.Test;
public class ATest {
@Test
public void testAdd() {
//一般匹配符
int s = new C().add(1, 1);
//allOf：所有条件必须都成立，测试才通过
assertThat(s, allOf(greaterThan(1), lessThan(3)));
//anyOf：只要有一个条件成立，测试就通过
assertThat(s, anyOf(greaterThan(1), lessThan(1)));
//anything：无论什么条件，测试都通过
assertThat(s, anything());
//is：变量的值等于指定值时，测试通过
assertThat(s, is(2));
//not：和is相反，变量的值不等于指定值时，测试通过
assertThat(s, not(1));
//数值匹配符
double d = new C().div(10, 3);
//closeTo：浮点型变量的值在3.0±0.5范围内，测试通过
assertThat(d, closeTo(3.0, 0.5));
//greaterThan：变量的值大于指定值时，测试通过
assertThat(d, greaterThan(3.0));
//lessThan：变量的值小于指定值时，测试通过
assertThat(d, lessThan(3.5));
//greaterThanOrEuqalTo：变量的值大于等于指定值时，测试通过
assertThat(d, greaterThanOrEqualTo(3.3));
//lessThanOrEqualTo：变量的值小于等于指定值时，测试通过
assertThat(d, lessThanOrEqualTo(3.4));
//字符串匹配符
String n = new C().getName("Magci");
//containsString：字符串变量中包含指定字符串时，测试通过
assertThat(n, containsString("ci"));
//startsWith：字符串变量以指定字符串开头时，测试通过
assertThat(n, startsWith("Ma"));
//endsWith：字符串变量以指定字符串结尾时，测试通过
assertThat(n, endsWith("i"));
//euqalTo：字符串变量等于指定字符串时，测试通过
assertThat(n, equalTo("Magci"));
//equalToIgnoringCase：字符串变量在忽略大小写的情况下等于指定字符串时，测试通过
assertThat(n, equalToIgnoringCase("magci"));
//equalToIgnoringWhiteSpace：字符串变量在忽略头尾任意空格的情况下等于指定字符串时，测试通过
assertThat(n, equalToIgnoringWhiteSpace(" Magci "));
//集合匹配符
List<String> l = new C().getList("Magci");
//hasItem：Iterable变量中含有指定元素时，测试通过
assertThat(l, hasItem("Magci"));
Map<String, String> m = new C().getMap("mgc", "Magci");
//hasEntry：Map变量中含有指定键值对时，测试通过
assertThat(m, hasEntry("mgc", "Magci"));
//hasKey：Map变量中含有指定键时，测试通过
assertThat(m, hasKey("mgc"));
//hasValue：Map变量中含有指定值时，测试通过
assertThat(m, hasValue("Magci"));
}
}
除了之前提到的命名规范之外，还有一些测试方法规范。例如在每个测试方法之前都必须加上“@Test”，这是像系统说明下面写的是一个测试方法。在原先的Junit版本中，测试方法需要继承TestCase类，而在Junit4中加入了“@Test”的新特性。此外，测试用例中的每个办法必须可以独立测试，测试方法间不能有任何的依赖，形成相互干扰。
在项目的结构上，最好新建一个源代码目录来存放测试代码，方便在测试完成后删除，也不会对原有项目产生干扰。希望大家根据上面的断言代码进行推广练习。
