假如在测试的时候遇到如下情况：

1. 我要测试函数A,但是A依赖一个 complexObject 对象（很难new出来，因为构造函数中依赖很多东西）
2. 但是A函数中只用到了complexObject中的一个简单函数，那真么办？

maven

<dependencies>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.11</version>
    </dependency>
    <dependency>
        <groupId>org.jmock</groupId>
        <artifactId>jmock-junit4</artifactId>
        <version>2.5.1</version>
    </dependency>
    <dependency>
        <groupId>org.objenesis</groupId>
        <artifactId>objenesis</artifactId>
        <version>2.2</version>
    </dependency>
    <dependency>
        <groupId>cglib</groupId>
        <artifactId>cglib-nodep</artifactId>
        <version>2.2.2</version>
    </dependency>
    <dependency>
        <groupId>org.jmock</groupId>
        <artifactId>jmock-legacy</artifactId>
        <version>2.5.1</version>
    </dependency>

</dependencies>

代码

import junit.framework.Assert;
import org.jmock.Expectations;
import org.jmock.Mockery;
import org.jmock.integration.junit4.JUnit4Mockery;
import org.junit.Test;
import org.jmock.lib.legacy.ClassImposteriser;

public class A {
    @Test
    public void B() {

        // 建立一个context上下文对象。（用于mock interfac）
        Mockery context = new Mockery();
        // 生成一个mock对象
        final AddressService addressServcie = context.mock(AddressService.class);
        // 设置期望。
        context.checking(new Expectations() {
            {
                String s1 = "age";
                //  设置期望：  addressServcie 对象，调用getAge函数，参数是s1
                allowing(addressServcie).getAge(s1);
                //  设置返回值
                will(returnValue("age:11"));
                String s2 = "name";
                oneOf(addressServcie).getName(s2);
                will(returnValue("name:fang"));
            }
        });
        // 验证结果
        Assert.assertEquals("age:11name:fang", testMockInterface(addressServcie));

//------------------------------------------------------------------------------------

        // 建立一个context上下文对象。（用于mock class）
        final Mockery context1 = new JUnit4Mockery() {{
            setImposteriser(ClassImposteriser.INSTANCE);
        }};
        // 生成一个mock对象
        final Address address = context1.mock(Address.class);
        // 设置期望。
        context1.checking(new Expectations() {
            {
                allowing(address).test();
                will(returnValue("test"));
            }
        });
        // 验证结果
        Assert.assertEquals("test", testMockClass(address));
    }

//  因为传递了一个模拟对象进来，终于让这个函数可以顺利进行测试了
    public String  testMockInterface(AddressService addressService) {
        return addressService.getAge("age")+ addressService.getName("name");
    }

    public String  testMockClass(Address address) {
        return address.test();
    }
}

interface AddressService{
    String getAge(String age);//{
    String getName(String name);//{

}
class Address{

    public Address(String a){
        System.out.println("init");
    }
    public String test(){
        return "1";
    }
}

invocation-count (mock-object).method(argument-constraints);
    inSequence(sequence-name);
    when(state-machine.is(state-name));
    will(action);
    then(state-machine.is(new-state-name));

• invocation-count 调用的次数约束
• mock-object mock对象
• method 方法
• argument-constraints 参数约束
• inSequence 顺序
• when 当mockery的状态为指定的时候触发。
• will(action) 方法触发的动作
• then 方法触发后设置mockery的状态

1. exactly 精确多少次
2. oneOf 精确1次
3. atLeast 至少多少次
4. between 一个范围
5. atMost 至多多少次
6. allowing 任意次
7. ignoring 忽略
8. never 从不执行