JMockit学习笔记

一、在eclipse下建立JMockit工程

1、下载最新版JMockit（jmockit-1.4.zip）；

2、解压后的文件夹包含有：library jars, source files, samples, API javadocs, and additional documentation；

3、将jmockit.jar添加到项目classpath中；

特别的：

1）确保classpath中Jar包的顺序：jmockit的jar包必须在junit之前（通过Order and Export" 标签上下移动）；

2）eclipse项目所用JRE来自于JDK，而不是“简洁”版的JRE，因为后者缺少本地类库“attach”。

二、行为和状态的测试

基于行为（Behavior-based）的mock是站在目标测试代码外面的角度的，通常主要模拟行为，而基于状态

（State-based）的是站在目标测试代码内部的。我们可以对传入的参数进行检查、匹配，才返回某些结果。

Mockup用于State-based测试。

二、声明和使用mock类型

1、字段，期望块的字段与期望块内的局部属性字段使用@Mocked来声明Mock类型。

2、参数，方法的参数声明来引入一个Mock类型。

第一种情况，属性字段是属于测试类或者一个mockit.Expectations子类（一个expectation期望块的内部的局部

属性字段）。

第二种情况，参数必须是属于某个测试方法（@Test标签下的方法）。

在所有的情况，一个mock属性字段或者参数声明，都可以通过使用@Mocked声明。对于方法mock的参数或者

在expectations期望块中定义的mock属性字段来说，该注解是可选的，而对于定义在测试类（XXXTest类）中的

属性字段，@Mocked标签是必须，这是为了防止和该测试类的其它不需要mock的字段属性产生冲突。

package main;

import static org.junit.Assert.*;

import java.io.Serializable;

import org.junit.Test;

import mockit.Expectations;
import mockit.Mocked;
import mockit.NonStrictExpectations;
import mockit.Verifications;

/*
 * 一个用户接口（外部依赖）
 */
interface Dependency {
	String doSomething(boolean b);
}

// 声明变量类型MultiMock（它实现两个接口，作用域是整个测试类）
public class MultiMocksTest<MultiMock extends Dependency & Runnable> {

	@Mocked
	MultiMock multiMock;

	@Test
	public void mockFieldWithTwoInterfaces() {
		new NonStrictExpectations() {
			{
				multiMock.doSomething(false);
				result = "test";
			}
		};

		multiMock.run();
		assertEquals("test", multiMock.doSomething(false));

		// 验证run()方法执行一次
		new Verifications() {
			{
				multiMock.run();
			}
		};
	}

	@Test
	// 声明变量类型M，它实现两个接口，作用域为该测试方法
	// final M mock 前的@Mocked注解是可选的
	public <M extends Dependency & Serializable> void mockParameterWithTwoInterfaces(
			@Mocked final M mock) {
		new Expectations() {
			{
				mock.doSomething(true);
				result = "";
			}
		};

		assertEquals("", multiMock.doSomething(true));
	}
}

3、对于一个返回值不为void类型的方法，Expectations中如何模拟方法返回值：

1）其返回值可以通过Expectations的result属性域来记录

2）Expectations的returns(Object)方法来记录

例如，方法返回一个Throwable异常类，只需将一个类型实验赋给result（注意，异常类只能通过result方式

赋值）。

package main;

import mockit.Expectations;

import org.junit.Test;

public class UnitUnderTest {

	// 1、构造方法
	private OutWork work = new OutWork();

	public void doSomthing() {
		// 2、intReturningMethod()方法
		int n = work.intReturningMethod();

		for (int i = 0; i < n; i++) {
			String s;
			try {
				// 3、stringReturningMethod()方法
				s = work.stringReturningMethod();
			} catch (Exception e) {
				// 处理异常
				e.printStackTrace();
			}
		}

		// 其它逻辑...
	}

	@Test
	public void test() {
		new Expectations() {
			OutWork work;
			{
				// 1、构造方法模拟
				new OutWork();

				// 2、intReturningMethod()方法模拟
				work.intReturningMethod();
				result = 3;

				// 3、stringReturningMethod()方法模拟
				work.stringReturningMethod();
				// 方法分别返回三个值，两个字符串，一个异常
				returns("str1", "str2");
				result = new Exception("testException");
			}
		};

		new UnitUnderTest().doSomthing();
	}
}

class OutWork {
	public int intReturningMethod() {
		return 0;
	}

	public String stringReturningMethod() {
		return "";
	}
}

三、从严格到非严格

1、@Mocked+Expections块：会进行隐式校验（执行顺序和次数）

2、@Mocked+NonStrictExpections块：NonStrictExpections块中的Incovation可以非严格执行（不执行或者

执行N次，除非显示地指定执行次数）。

package main;
/*
 * 用于Mock的接口
 */
public interface WinportUrlService {
	public boolean hasWinport(String id);
	public String getMsg();
	public Throwable getWinportUrlThrowException(String id);
}

package main;

import static org.junit.Assert.*;
import mockit.Expectations;
import mockit.Mocked;
import mockit.NonStrictExpectations;

import org.junit.Test;

public class IntroductionTest {

	// @Mocked注解+Expectations/NonStrictExpectations块
	@Mocked
	private WinportUrlService winportUrlService = null;

	@Test
	public void testNoExceptions() {
		final String memberId = "test";
		// 未指定期望块，方法返回默认值
		assertEquals(false, winportUrlService.hasWinport(memberId));
		assertEquals(null, winportUrlService.getMsg());
		assertEquals(null, winportUrlService.getWinportUrlThrowException(memberId));
	}

	@Test
	public void testWithExpectations() {
		final String memerId = "test";

		// 步骤一：record

		// 严格期望块
		new Expectations() {
			{
				// 下面的Invocation必须严格执行
				winportUrlService.hasWinport(memerId);
				result = false;// 也可以是returns(false)

				// 未指定执行次数
			}
		};

		// 非严格期望块
		new NonStrictExpectations() {
			{
				// 下面的Invocation非严格执行
				winportUrlService.getMsg();
				result = "test";// 也可以是returns("test")

				// 未指定执行次数
			}
		};

		// 步骤二：replay阶段

		// hasWinport必须严格执行一次
		assertEquals(false, winportUrlService.hasWinport(memerId));

		// getMsg可以不执行或执行多次
		assertEquals("test", winportUrlService.getMsg());
		assertEquals("test", winportUrlService.getMsg());

		// 下面的Invocation失败
		// winportUrlService.getWinportUrlThrowException(memerId);
	}
}

3、@NonStrict：可以在replay中调用或不调用。@NonStrict可以避免需要记录调用构造函数，或任何不感兴

趣的方法。

注意：@NonStrict它是针对类的属性非严格，类的属性适用于类中的所有测试方法。这个非严格的范围比

NonStrictExpections块的作用范围大很多，一旦使用了@NonStrict，Expections中的Incovation就变成了非严

格的invocation，因此其它测试方法还想在该属性的基础上使用Expections块是不可能的了。如果是这种情况

就需要这样使用（@Mocked+NonStrictExpectations块）。

package main;

import static org.junit.Assert.*;
import mockit.Expectations;
import mockit.NonStrict;

import org.junit.Test;

public class IntroductionTest2 {

	// @NonStrict注解
	@NonStrict
	private WinportUrlService winportUrlService = null;

	@Test
	public void testWithExpectations() {
		final String memberId = "test";

		// 步骤一：record

		// 用了@NonStrict，Expectation中的invocation就变成了非严格的invocation
		new Expectations() {
			{
				// 下面的Invocation非严格执行
				winportUrlService.hasWinport(memberId);
				result = false;// 也可以是returns(false)

				// 未指定执行次数
			}
		};

		// 步骤二：replay阶段

		// hasWinport可以不执行或执行多次
		assertEquals(false, winportUrlService.hasWinport(memberId));
		assertEquals(false, winportUrlService.hasWinport(memberId));

		// 下面的Invocation成功
		winportUrlService.getWinportUrlThrowException(memberId);

	}
}

4、此外，若不指定执行次数，Expections块默认必须执行一次，NonStrictExpections块中的Invocation可执行

N次或不执行；若显式地指定执行次数（N次），二者的Invocation都必须执行N次。

注：文章转载自

博客园 技术生活杂烩-迟到 的博客《jmockit》一文