基础概念

what
JMockit是一款Java类/接口/对象的Mock工具，目前广泛应用于Java应用程序的单元测试中
why
这差不多是目前最强大、最方便和最简单的测试框架了
Record-Replay-Verification单元测试结构

Record: 即先录制某类/对象的某个方法调用，在当输入什么时，返回什么
Replay: 即重放测试逻辑
Verification: 重放后的验证

API
@Mocked、@Tested、@Injectable、@Capturing、@Mock、Expectations、MockUp、Verifications

API用法

@Mocked

加上了JMockit的API @Mocked, JMockit会实例化这个对象
Mocked可以用来修饰类、接口和抽象类，返回默认值（如果是原始类型，返回原始值的默认值，如果为其他对象，则返回一个同样被Mocked的对象）
Mocked十分粗暴，会mock掉整个的实现

@Injectable

@Injectable功能跟@Mocked相似，区别是@Injectable只针对修饰的实例，对mock类的静态方法、构造函数没有影响

@Tested

@Tested表示被测试对象。如果该对象没有赋值，JMockit会去实例化它，若@Tested的构造函数有参数，则JMockit通过在测试属性&测试参数中查找@Injectable修饰的Mocked对象注入@Tested对象的构造函数来实例化，
不然，则用无参构造函数来实例化。除了构造函数的注入，JMockit还会通过属性查找的方式，把@Injectable对象注入到@Tested对象中。
注入的匹配规则：先类型，再名称(构造函数参数名，类的属性名)。若找到多个可以注入的@Injectable，则选择最优先定义的@Injectable对象

@Capturing

@Capturing主要用于子类/实现类的Mock，比如java动态代理生成的类，这些类没有名字，无法进行正常的mock
当只知道父类或接口时，但需要控制其子类的行为时，子类可能有多个实现（可能有人工写的，也可能是AOP代理自动生成时），需要使用@Capturing

Expectations

Record对象的核心方法，最核心和重要的注解了，可以和引用外部类的Mock对象(@Injectabe,@Mocked,@Capturing)来录制，也可以通过构建函数注入类/对象来录制
限制：不能mock对象的native方法和private方法

MockUp & Mock

MockUp & @Mock提供更改代码行为的Mock方式，最强大mock实现，主要有以下限制：

无法mock单个实例
无法mock动态代理对象
对类的所有方法都进行Mock，书写MockUp的代码量太大
可以用于项目中比较通用模块，减少大量重复的Exceptations

Verifications

Verifications是用于做验证，过程式编程的福音，
验证Mock对象（即@Moked/@Injectable@Capturing修饰的或传入Expectation构造函数的对象)有没有调用过某方法，调用了多少次
主要用于一些没有返回值的代码验证

实例

//一个普通类 
public class AnOrdinaryClass {
    // 静态方法
    public static int staticMethod() {
        return 1;
    }
    // 普通方法
    public int ordinaryMethod() {
        return 2;
    }
    // final方法
    public final int finalMethod() {
        return 3;
    }
    // native方法,返回4
    public native int navtiveMethod();
    // private方法
    private int privateMethod() {
        return 5;
    }
    // 调用private方法
    public int callPrivateMethod() {
        return privateMethod();
    }
}

public class Sample {
    private SampleDepend sampleDepend;
    private SampleInterface sampleInterface = new SampleInterface() {
        @Override
        public int call() {
            return 1;
        }
    };

    public Sample() {
    }

    public int getSampleDependVal() {
        return sampleDepend.getVal();
    }

    private static int staticGetOne() { return 1; }
    public static int staticGetPrivateOne() { return staticGetOne(); }

    private int getOne() { return 1; }
    public int getPrivateOne() { return getOne(); }

    public void execute() {
        sampleDepend.getVal();
        doExecute(); }

    private void doExecute() {}

    public int interfaceCall() {
        return sampleInterface.call();
    }

    public interface SampleInterface {
        int call();
    }
}
public class SampleDepend {
    private int val;
    public int getVal() { return val; }
    public void setVal(int val) { this.val = val; }
}

@RunWith(JMockit.class)
public class SampleTest {
    @Tested
    private Sample sample;

    @Test
    public void testStaticGetPrivateOne() {
        new Expectations(sample) {
            {
                Deencapsulation.invoke(sample, "staticGetOne");
                result = 2;
            }
        };

        Assert.assertTrue(sample.staticGetPrivateOne() == 2);
    }

    @Test
    public void testGetPrivateOne() {
        new Expectations(sample) {
            {
                Deencapsulation.invoke(sample, "getOne");
                result = 2;
            }
        };

        Assert.assertTrue(sample.getPrivateOne() == 2);
    }

    @Test
    public void testGetSampleDependVal(@Injectable SampleDepend sampleDepend) {
        new Expectations(sampleDepend) {
            {
                sampleDepend.getVal();
                result = 2;
            }
        };
        Assert.assertTrue(sample.getSampleDependVal() == 2);
        Assert.assertTrue(sample.getSampleDependVal() == 0);
    }

    @Test
    public void testExecute(@Injectable SampleDepend sampleDepend) {
        sample.execute();
        new Verifications() {
            {
                sampleDepend.getVal();
                times = 1;
                Deencapsulation.invoke(sample, "doExecute");
                times = 1;
            }
        };
    }

    @Test
    public void testInterfaceCallWithInjectable(@Injectable Sample.SampleInterface sampleInterface) {
        Deencapsulation.setField(sample, "sampleInterface", sampleInterface);
        new Expectations() {
            {
                sampleInterface.call();
                result = 2;
            }
        };
        Assert.assertTrue(sample.interfaceCall() == 2);
    }

    @Test
    public void testInterfaceCallWithCapturing(@Capturing Sample.SampleInterface sampleInterface) {
        new Expectations() {
            {
                sampleInterface.call();
                result = 2;
            }
        };
        Assert.assertTrue(sample.interfaceCall() == 2);
    }
}