【转】JUnit（二）

【转】JUnit（二）

8.3.3 编写断言
JUnit主要有以下断言：

— assertEquals（期望值，实际值），检查两个值是否相等。

— assertEquals（期望对象，实际对象），检查两个对象是否相等，利用对象的equals()方法进行判断。

— assertSame（期望对象，实际对象），检查具有相同内存地址的两个对象是否相等，利用内存地址进行判断，注意和上面assertEquals方法的区别。

— assertNotSame（期望对象，实际对象），检查两个对象是否不相等。

— assertNull（对象1，对象2），检查一个对象是否为空。

— assertNotNull（对象1，对象2），检查一个对象是否不为空。

— assertTrue(布尔条件)，检查布尔条件是否为真。

— assertFalse(布尔条件)，检查布尔条件是否为假。

这些断言主要定义在JUnit的Assert类里，Assert类的示例代码如下：

//******* Assert.java**************

package junit.framework;

/**一系列的断言方法

*/

public class Assert {

/**构造函数

*/

protected Assert() {

}

/**断言是否为真，带消息

*/

static public void assertTrue(String message, boolean condition) {

if (!condition)

fail(message);

}

/**断言是否为真

*/

static public void assertTrue(boolean condition) {

assertTrue(null, condition);

}

/**断言是否为假，带消息

*/

static public void assertFalse(String message, boolean condition) {

assertTrue(message, !condition);

}

/**断言是否为假

*/

static public void assertFalse(boolean condition) {

assertFalse(null, condition);

}

/**断言是否为失败

*/

static public void fail(String message) {

throw new AssertionFailedError(message);

}

/**断言是否为失败

*/

static public void fail() {

fail(null);

}

/**是否相等的断言，带消息Object

*/

static public void assertEquals(String message, Object expected, Object actual) {

if (expected == null && actual == null)

return;

if (expected != null && expected.equals(actual))

return;

failNotEquals(message, expected, actual);

}

/**是否相等的断言，Object

*/

static public void assertEquals(Object expected, Object actual) {

assertEquals(null, expected, actual);

}

/**是否相等的断言，带消息String

*/

static public void assertEquals(String message, String expected, String actual) {

if (expected == null && actual == null)

return;

if (expected != null && expected.equals(actual))

return;

throw new ComparisonFailure(message, expected, actual);

}

/**是否相等的断言，String

*/

static public void assertEquals(String expected, String actual) {

assertEquals(null, expected, actual);

}

/**是否相等的断言，带消息double

*/

static public void assertEquals(String message, double expected, double actual, double delta) {

if (Double.compare(expected, actual) == 0)

return;

if (!(Math.abs(expected-actual) <= delta))

failNotEquals(message, new Double(expected), new Double(actual));

}

/**是否相等的断言，double

*/

static public void assertEquals(double expected, double actual, double delta) {

assertEquals(null, expected, actual, delta);

}

/**是否相等的断言，带消息float

*/

static public void assertEquals(String message, float expected, float actual, float delta) {

if (Float.compare(expected, actual) == 0)

return;

if (!(Math.abs(expected - actual) <= delta))

failNotEquals(message, new Float(expected), new Float(actual));

}

/**是否相等的断言， float

*/

static public void assertEquals(float expected, float actual, float delta) {

assertEquals(null, expected, actual, delta);

}

/**是否相等的断言，带消息long

*/

static public void assertEquals(String message, long expected, long actual) {

assertEquals(message, new Long(expected), new Long(actual));

}

/**是否相等的断言， long

*/

static public void assertEquals(long expected, long actual) {

assertEquals(null, expected, actual);

}

/**是否相等的断言，带消息boolean

*/

static public void assertEquals(String message, boolean expected, boolean actual) {

assertEquals(message, Boolean.valueOf(expected), Boolean.valueOf(actual));

}

/**是否相等的断言，boolean

*/

static public void assertEquals(boolean expected, boolean actual) {

assertEquals(null, expected, actual);

}

/**是否相等的断言，带消息byte

*/

static public void assertEquals(String message, byte expected, byte actual) {

assertEquals(message, new Byte(expected), new Byte(actual));

}

/**是否相等的断言， byte

*/

static public void assertEquals(byte expected, byte actual) {

assertEquals(null, expected, actual);

}

/**是否相等的断言，带消息char

*/

static public void assertEquals(String message, char expected, char actual) {

assertEquals(message, new Character(expected), new Character(actual));

}

/**是否相等的断言，char

*/

static public void assertEquals(char expected, char actual) {

assertEquals(null, expected, actual);

}

/**是否相等的断言，带消息short

*/

static public void assertEquals(String message, short expected, short actual) {

assertEquals(message, new Short(expected), new Short(actual));

}

/**是否相等的断言，short

static public void assertEquals(short expected, short actual) {

assertEquals(null, expected, actual);

}

/**是否相等的断言，带消息int

*/

static public void assertEquals(String message, int expected, int actual) {

assertEquals(message, new Integer(expected), new Integer(actual));

}

/**是否相等的断言，int

*/

static public void assertEquals(int expected, int actual) {

assertEquals(null, expected, actual);

}

/**是否不为null的断言 Object

*/

static public void assertNotNull(Object object) {

assertNotNull(null, object);

}

/**是否不为null的断言，带消息Object

*/

static public void assertNotNull(String message, Object object) {

assertTrue(message, object != null);

}

/**是否为null的断言Object

*/

static public void assertNull(Object object) {

assertNull(null, object);

}

/**是否为null的断言，带消息Object

*/

static public void assertNull(String message, Object object) {

assertTrue(message, object == null);

}

/**是否相同的断言，带消息*/

static public void assertSame(String message, Object expected, Object actual) {

if (expected == actual)

return;

failNotSame(message, expected, actual);

}

/**是否相同的断言，Object

*/

static public void assertSame(Object expected, Object actual) {

assertSame(null, expected, actual);

}

/**是否不相同的断言，带消息

*/

static public void assertNotSame(String message, Object expected, Object actual) {

if (expected == actual)

failSame(message);

}

/**是否不相同的断言Object

*/

static public void assertNotSame(Object expected, Object actual) {

assertNotSame(null, expected, actual);

}

/**相同时失败

*/

static public void failSame(String message) {

String formatted= "";

if (message != null)

formatted= message+" ";

fail(formatted+"expected not same");

}

/**不相同时失败

*/

static public void failNotSame(String message, Object expected, Object actual) {

String formatted= "";

if (message != null)

formatted= message+" ";

fail(formatted+"expected same:<"+expected+"> was not:<"+actual+">");

}

/**不相等时失败

*/

static public void failNotEquals(String message, Object expected, Object actual) {

fail(format(message, expected, actual));

}

/**格式化消息

*/

public static String format(String message, Object expected, Object actual) {

String formatted= "";

if (message != null)

formatted= message+" ";

return formatted+"expected:<"+expected+"> but was:<"+actual+">";

}

}

从上述代码中，读者可以研读JUnit中有关断言的实现方式，其实，最终都是使用后面的几个static方法来实现的。

8.4 JUnit的新特性
Java 5的发布为JUnit带来了新的特性。自JUnit 4.0之后，JUnit大量使用了annotations特性，使编写单元测试变得更加简单。

8.4.1 改变测试方法的命名方式
前面讲过，使用JUnit 4.0以上版本可以不用遵循以前JUnit约定的测试方法命名方法，以前命名方法的示例代码如下：

//******* TestAddAndSub.java**************

import junit.framework.TestCase;

public class TestAddAndSub extends TestCase {

public void testadd() {

//断言计算结果与10是否相等

assertEquals(10, AddAndSub.add(4, 6));

}

public void testsub() {

//断言计算结果与2是否相等

assertEquals(2, AddAndSub.sub(6, 4));

}

public static void main(String args[]){

junit.textui.TestRunner.run(TestAddAndSub .class); }

}

JUnit 4.0以上版本的命名方式，是在测试方法前使用@Test注释，示例代码如下：

//******* TestAddAndSub.java**************

import junit.framework.TestCase;

import org.junit.*;

public class TestAddAndSub extends TestCase {

@Test public void add() {

//断言计算结果与10是否相等

assertEquals(10, AddAndSub.add(4, 6));

}

@Test public void sub() {

//断言计算结果与2是否相等

assertEquals(2, AddAndSub.sub(6, 4));

}

}

这个时候，测试方法的命名将不再重要，开发人员可以按照自己的命名方式来命名。

8.4.2 不再继承TestCase
新版本的JUnit将不再强制继承TestCase，但需要import org.junit.Assert来实现断言，示例代码如下：

//******* TestAddAndSub.java**************

import static org.junit.Assert.assertEquals;

import org.junit.*;

public class TestAddAndSub{

@Test public void add() {

//断言计算结果与10是否相等

assertEquals(10, AddAndSub.add(4, 6));

}

@Test public void sub() {

//断言计算结果与2是否相等

assertEquals(2, AddAndSub.sub(6, 4));

}

}

8.4.3 改变初始化和销毁方式
以前，JUnit使用SetUp和TearDown方法来进行初始化和销毁动作，JUnit 4.0以上版本将不再强制使用SetUp和TearDown方法来进行初始化和销毁，原来使用SetUp和TearDown方法的示例代码如下：

//******* TestAddAndSub.java**************

import junit.framework.TestCase;

public class TestAddAndSub extends TestCase {

private int m = 0;

private int n = 0;

//初始化

protected void setUp() {

m = 4;

n = 6;

}

public void testadd() {

//断言计算结果与10是否相等

assertEquals(10, AddAndSub.add(m, n));

}

public void testsub() {

//断言计算结果与2是否相等

assertEquals(2, AddAndSub.sub(n, m));

}

//销毁

protected void tearDown() {

m = 0;

n = 0;

}

}

不使用SetUp和TearDown方法的示例代码如下：

//******* TestAddAndSub.java**************

import static org.junit.Assert.assertEquals;

import org.junit.*;

public class TestAddAndSub {

protected int m = 0;

protected int n = 0;

//初始化

@Before public void init() {

m = 4;

n = 6;

}

@Test public void add() {

//断言计算结果与10是否相等

assertEquals(10, AddAndSub.add(m, n));

}

@Test public void sub() {

//断言计算结果与2是否相等

assertEquals(2, AddAndSub.sub(n, m));

}

//销毁

@After public void destory() {

m = 0;

n = 0;

}

}

上面示例中的初始化和销毁都是针对一个方法来说的，每个方法执行前都要进行初始化，执行完毕都要进行销毁。而JUnit的最新版本则提供了新的特性，针对类进行初始化和销毁。也就是说，该类中的方法只进行一次初始化和销毁，方法就是使用@Before和@After，示例代码如下：

//******* TestAddAndSub.java**************

import static org.junit.Assert.assertEquals;

import org.junit.*;

public class TestAddAndSub {

protected int m = 0;

protected int n = 0;

//初始化

@BeforeClass public void init() {

m = 4;

n = 6;

}

@Test public void add() {

//断言计算结果与10是否相等

assertEquals(10, AddAndSub.add(m, n));

}

@Test public void sub() {

//断言计算结果与2是否相等

assertEquals(2, AddAndSub.sub(n, m));

}

//销毁

@AfterClass public void destory() {

m = 0;

n = 0;

}

}

上述初始化和销毁动作，只执行一次即可。

8.4.4 改变异常处理的方式
以前，使用JUnit进行单元测试时，如果遇到异常情况，需要使用try…catch的形式来捕捉异常，示例代码如下：

//******* TestAddAndSub.java**************

import junit.framework.TestCase;

public class TestAddAndSub extends TestCase {

private int m = 0;

private int n = 0;

//初始化

protected void setUp() {

m = 4;

n = 6;

}

public void testadd() {

//断言计算结果与10是否相等

assertEquals(10, AddAndSub.add(m, n));

}

public void testsub() {

//断言计算结果与2是否相等

assertEquals(2, AddAndSub.sub(n, m));

}

public void testdiv() {

//断言除数为0

try {

int n = 2 / 0;

fail("Divided by zero!");

}

catch (ArithmeticException success) {

assertNotNull(success.getMessage());

}

}

//销毁

protected void tearDown() {

m = 0;

n = 0;

}

}

JUnit4.0以后的版本将不再使用try…catch的方式来捕捉异常，示例代码如下：

//******* TestAddAndSub.java**************

import static org.junit.Assert.assertEquals;

import org.junit.*;

public class TestAddAndSub {

protected int m = 0;

protected int n = 0;

//初始化

@Before public void init() {

m = 4;

n = 6;

}

@Test public void add() {

//断言计算结果与10是否相等

assertEquals(10, AddAndSub.add(m, n));

}

@Test public void sub() {

//断言计算结果与2是否相等

assertEquals(2, AddAndSub.sub(n, m));

}

@Test t(expected=ArithmeticException.class) public void div() {

//断言除数是否为0

int n = 2 / 0;

}

//销毁

@After public void destory() {

m = 0;

n = 0;

}

}

当然，JUnit还有许多新的特性，限于篇幅原因，这里只对比较重要的特性进行讲解，其余将不再多讲，想要了解的读者可以到JUnit的相关网站进行学习。

8.5 小结
本章首先讲述了JUnit的下载和安装，接着又讲解了JUnit的相关知识，最后讲解了JUnit的新特性。

JUnit对开发人员进行大规模的单元测试来说，是非常有用的，但对于大量的代码如何来管理就只有靠CVS了。CVS是一个版本控制系统，主要用来管理开发人员代码的历史，下一章主要讲如何使用CVS。