博客分类：
Mockito是一个流行的Mocking框架。它使用起来简单，学习成本很低，而且具有非常简洁的API，测试代码的可读性很高。因此它十分受欢迎，用户群越来越多，很多的开源的软件也选择了Mockito。要想了解更多有关Mockito的信息，请访问它的官方网站：http://mockito.org/
在开始使用Mockito之前，先简单的了解一下Stub和Mock的区别。
Stub对象用来提供测试时所需要的测试数据，可以对各种交互设置相应的回应。例如我们可以设置方法调用的返回值等等。Mockito中when(…).thenReturn(…) 这样的语法便是设置方法调用的返回值。另外也可以设置方法在何时调用会抛异常等。Mock对象用来验证测试中所依赖对象间的交互是否能够达到预期。Mockito中用 verify(…).methodXxx(…) 语法来验证 methodXxx方法是否按照预期进行了调用。有关stub和mock的详细论述见，Martin Fowler文章《Mocks Aren't Stub》/articles/mocksArentStubs.html。在Mocking框架中所谓的mock对象实际上是作为上述的stub和mock对象同时使用的。因为它既可以设置方法调用返回值，又可以验证方法的调用。
Mockito的获取
Jar包的获取
可以访问下面的链接来下载最新的Jar包，笔者使用的当前最新版为：1.8.5 /p/mockito/downloads/list
Maven
如果项目是通过Maven管理的，需要在项目的Pom.xml中增加如下的依赖：
&dependencies&
&dependency&
&groupId&org.mockito&/groupId&
&artifactId&mockito-all&/artifactId&
&version&1.8.5&/version&
&scope&test&/scope&
&/dependency&
&/dependencies&
Mocktio包的引入
在程序中可以import org.mockito.M然后调用它的static方法，或者import static org.mockito.Mockito.*;个人倾向于后者，因为这样可以更方便些。
一个简单的例子
import static org.junit.Assert.*;
import static org.mockito.Mockito.*;
import java.util.I
import org.junit.T
* @author Brian Zhao
public class SimpleTest {
public void simpleTest(){
Iterator i=mock(Iterator.class);
when(i.next()).thenReturn("Hello").thenReturn("World");
String result=i.next()+" "+i.next();
verify(i, times(2)).next();
assertEquals("Hello World", result);
在上面的例子中包含了Mockito的基本功能：
创建Mock对象
创建Mock对象的语法为，mock(class or interface)。例子中创建了Iterator接口的mock对象。
设置方法调用的预期返回
通过when(mock.someMethod()).thenReturn(value) 来设定mock对象某个方法调用时的返回值。例子中我们对Iterator接口的next()方法调用进行了预期设定，当调用next()方法时会返回”Hello”，由于连续设定了返回值，因此当第二次调用时将返回”World”。
验证方法调用
接下来对mock对象的next()方法进行了一系列实际的调用。mock对象一旦建立便会自动记录自己的交互行为，所以我们可以有选择的对它的交互行为进行验证。在Mockito中验证mock对象交互行为的方法是verify(mock).someMethod(…)。于是用此方法验证了next()方法调用，因为调用了两次，所以在verify中我们指定了times参数（times的具体应用在后面会继续介绍）。最后assert返回值是否和预期一样。
浏览: 168169 次
来自: 北京
显示的数据叠加在一起了怎么解决？　数据挨着一起，不好看
使用上面的方法，也是报类找不到，
Filling repo ...
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'博客分类：
之前介绍了如何设置mock对象预期调用的方法及返回值。下面介绍方法调用的验证，而它关注点则在mock对象的交互行为上，比如验证mock对象的某个方法调用参数，调用次数，顺序等等。下面来看例子：
public void verifyTestTest() {
List&String& mock = mock(List.class);
List&String& mock2 = mock(List.class);
when(mock.get(0)).thenReturn("hello");
mock.get(0);
mock.get(1);
mock.get(2);
mock2.get(0);
verify(mock).get(2);
verify(mock, never()).get(3);
verifyNoMoreInteractions(mock);
verifyZeroInteractions(mock2);
}
验证的基本方法
我们已经熟悉了使用verify(mock).someMethod(…)来验证方法的调用。例子中，我们mock了List接口，然后调用了mock对象的一些方法。验证是否调用了mock.get(2)方法可以通过verify(mock).get(2)来进行。verify方法的调用不关心是否模拟了get(2)方法的返回值，只关心mock对象后，是否执行了mock.get(2)，如果没有执行，测试方法将不会通过。
验证未曾执行的方法
在verify方法中可以传入never()方法参数来确认mock.get(3)方法不曾被执行过。另外还有很多调用次数相关的参数将会在下面提到。
查询多余的方法调用
verifyNoMoreInteractions()方法可以传入多个mock对象作为参数，用来验证传入的这些mock对象是否存在没有验证过的调用方法。本例中传入参数mock，测试将不会通过，因为我们只verify了mock对象的get(2)方法，没有对get(0)和get(1)进行验证。为了增加测试的可维护性，官方不推荐我们过于频繁的在每个测试方法中都使用它，因为它只是测试的一个工具，只在你认为有必要的时候才用。
查询没有交互的mock对象
verifyZeroInteractions()也是一个测试工具，源码和verifyNoMoreInteractions()的实现是一样的，为了提高逻辑的可读性，所以只不过名字不同。在例子中，它的目的是用来确认mock2对象没有进行任何交互，但mock2执行了get(0)方法，所以这里测试会报错。由于它和verifyNoMoreInteractions()方法实现的源码都一样，因此如果在verifyZeroInteractions(mock2)执行之前对mock.get(0)进行了验证那么测试将会通过。
验证方法调用的次数
如果要验证Mock对象的某个方法调用次数，则需给verify方法传入相关的验证参数，它的调用接口是verify(T mock, VerificationMode mode)。如：verify(mock,times(3)).someMethod(argument)验证mock对象someMethod(argument)方法是否调用了三次。times(N)参数便是验证调用次数的参数，N代表方法调用次数。其实verify方法中如果不传调用次数的验证参数，它默认传入的便是times(1)，即验证mock对象的方法是否只被调用一次，如果有多次调用测试方法将会失败。
Mockito除了提供times(N)方法供我们调用外，还提供了很多可选的方法：
never() 没有被调用，相当于times(0)
atLeast(N) 至少被调用N次
atLeastOnce() 相当于atLeast(1)
atMost(N) 最多被调用N次
超时验证
Mockito提供对超时的验证，但是目前不支持在下面提到的顺序验证中使用。进行超时验证和上述的次数验证一样，也要在verify中进行参数的传入，参数为timeout(int millis)，timeout方法中输入的是毫秒值。下面看例子：
验证someMethod()是否能在指定的100毫秒中执行完毕
verify(mock, timeout(100)).someMethod();
结果和上面的例子一样，在超时验证的同时可进行调用次数验证，默认次数为1
verify(mock, timeout(100).times(1)).someMethod();
在给定的时间内完成执行次数
verify(mock, timeout(100).times(2)).someMethod();
给定的时间内至少执行两次
verify(mock, timeout(100).atLeast(2)).someMethod();
另外timeout也支持自定义的验证模式，
verify(mock, new Timeout(100, yourOwnVerificationMode)).someMethod();
验证方法调用的顺序
Mockito同样支持对不同Mock对象不同方法的调用次序进行验证。进行次序验证是，我们需要创建InOrder对象来进行支持。例：
创建mock对象
List&String& firstMock = mock(List.class);
List&String& secondMock = mock(List.class);
调用mock对象方法
firstMock.add("was called first");
firstMock.add("was called first");
secondMock.add("was called second");
secondMock.add("was called third");
创建InOrder对象
inOrder方法可以传入多个mock对象作为参数，这样便可对这些mock对象的方法进行调用顺序的验证InOrder inOrder = inOrder( secondMock, firstMock );
验证方法调用
接下来我们要调用InOrder对象的verify方法对mock方法的调用顺序进行验证。注意，这里必须是你对调用顺序的预期。
InOrder对象的verify方法也支持调用次数验证，上例中，我们期望firstMock.add("was called first")方法先执行并执行两次，所以进行了下面的验证inOrder.verify(firstMock,times(2)).add("was called first")。其次执行了secondMock.add("was called second")方法，继续验证此方法的执行inOrder.verify(secondMock).add("was called second")。如果mock方法的调用顺序和InOrder中verify的顺序不同，那么测试将执行失败。
InOrder的verifyNoMoreInteractions()方法
它用于确认上一个顺序验证方法之后，mock对象是否还有多余的交互。它和Mockito提供的静态方法verifyNoMoreInteractions不同，InOrder的验证是基于顺序的，另外它只验证创建它时所提供的mock对象，在本例中只对firstMock和secondMock有效。例如：
inOrder.verify(secondMock).add("was called second");
inOrder.verifyNoMoreInteractions();
在验证secondMock.add("was called second")方法之后，加上InOrder的verifyNoMoreInteractions方法，表示此方法调用后再没有多余的交互。例子中会报错，因为在此方法之后还执行了secondMock.add("was called third")。现在将上例改成：
inOrder.verify(secondMock).add("was called third");
inOrder.verifyNoMoreInteractions();
测试会恢复为正常，因为在secondMock.add("was called third")之后已经没有多余的方法调用了。如果这里换成Mockito类的verifyNoMoreInteractions方法测试还是会报错，它查找的是mock对象中是否存在没有验证的调用方法，和顺序是无关的。
浏览: 168171 次
来自: 北京
显示的数据叠加在一起了怎么解决？　数据挨着一起，不好看
使用上面的方法，也是报类找不到，
Filling repo ...
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'Mockito(一) -- 入门篇 - CSDN博客
Mockito(一) -- 入门篇
Mockito是一种mock工具/框架。我理解EasyMock有点过时了，Mockito是现在比较流行的。
什么是mock？说的直白一点，大家都知道unit test应该是尽可能独立的。对一个class的unit test不应该再和其他class有任何交互。
现在有一个类，扫描一个目录并将找到的文件都上传到FTP server。该类对于不同的FTP响应(找不到FTP server 或 上传成功，或上传失败)，有一些后续操作。
在写这个类的UT时，我们就必须虚构出来一个FTP对象。这样在UT中，这个虚构的对象能够代替真正的FTP，对被测试类的调用做出一定的响应。从而知道被测试类是否正确的调用了FTP并做出一些正确的期望的响应。从而达到测试的目的。
mock可以模拟各种各样的对象，从而代替真正的对象做出希望的响应。
关于mock的概念和EasyMock，可以参考：
&Mock object and EasyMock framework
&一篇很好的入门文章：
http://blog.csdn.net/huoshuxiao/archive//6107835.aspx
&一些稍微复杂且实用一点的例子：
下面介绍mockito的基本使用方法。
&如前面所说，我们需要创建一个mock对象来代替真的对象。
模拟对象是第一步。模拟对象使用mock();
指定mock对象被调用时的返回值是第二步，比如指定让mockFTP对象第一次被调用时返回&找不到FTP server&。这一步一般称为stubbing。一般是when(mockedList.get(0)).thenReturn(&first&)的样子。
验证被测试类是否正确工作是第三步，使用verify()。例如，验证当mockFTP对象返回&找不到FTP server&时，测试代码是否按要求重试。
然后测试就完成啦~~
模拟对象：
&&LinkedList&mockedList&=&mock(LinkedList.class); &&&&&&&System.out.println(mockedList.get(999));&&
模拟方法调用的返回值：
& 给特定的方法调用返回固定值在官方说法中称为stub。when(mockedList.get(0)).thenReturn(&first&); &&&&
&&System.out.println(mockedList.get(0));&&
模拟方法调用抛出异常：
&&when(mockedList.get(1)).thenThrow(new&RuntimeException()); &&&&&&System.out.println(mockedList.get(1));&&
&没有返回值类型的方法也可以模拟异常抛出：
doThrow(new&RuntimeException()).when(mockedList).clear();
模拟调用方法时的参数匹配：
&&when(mockedList.get(anyInt())).thenReturn(&element&); &&&&
&&System.out.println(mockedList.get(999));&
模拟方法调用次数：
&&mockedList.add(&once&); &&&&&&verify(mockedList).add(&once&); &&verify(mockedList,&times(1)).add(&once&);&&
&还可以通过atLeast(int i)和atMost(int i)来替代time(int i)来验证被调用的次数最小值和最大值。
结束~很简单吧。
这篇文章基本上是转帖，下篇文章将介绍如何在代码里使用Mockito，最后介绍mockito的大部分功能。
本文已收录于以下专栏：
相关文章推荐
import static org.junit.Assert.assertE
import static org.mockito.Mockito.atL
import stati...
Mockito是最好的mock框架之一，API设计简洁优美，使用方便，可以在一定程度上提高我们的开发效率。
这篇教程介绍了如何使用 Mockito 框架来给软件写测试用例
如果需要往下学习，你需要先理解 Junit 框架中的单元测试。
如果你不熟悉 JUnit，请查看下面的教程： ...
刚开始做网站的时候，测试都是这样的（比如测试修改用户信息的表单逻辑）：设置断点，启动运行程序，登陆，点击点击点击然后进入到测试的页面，输入测试数据，进入断点…….。一个大的程序启动又慢，还要登陆，还要...
Android 单元测试之Roboletric RxJava、Retrofit、访问真实网络、虚拟服务器添加依赖android {
configurations.all {
学习了基本知识后，就可以实战了。Mockito的实际使用还是比较麻烦的。
因为在实际使用中，最常遇到的就是需要模拟第三方类库的行为。
比如现在有一个类FTPFileTransfer，实现了向FTP...
单元测试的重要性无需赘述，但单元测试也会遇到困难，其中之一就是如何
创建依赖。试想我们常见的server端分层架构，数据访问层Dao，业务层，
以及Web层，想要单元测试业务层，我们需要依赖Dao...
一、Mockito的引用
Gradle:repositories { jcenter() }
dependencies { testCompile &org.mockito:mockito-core...
一、什么是mock测试，什么是mock对象？
先来看看下面这个示例：
从上图可以看出如果我们要对A进行测试，那么就要先把整个依赖树构建出来，也就是BCDE的实例。
他的最新文章
讲师：吴岸城
您举报文章：
举报原因：
原文地址：
原因补充：
(最多只允许输入30个字)Mockito 入门篇的 - CSDN博客
Mockito 入门篇的
自动化ui测试已经可以完成基本的测试需求，最主要的还是白盒测试，网上看google官方mvp设计模式，正好配套有unit 测试。顺带看了一下，并分享出来
Mockito是一个针对Java的mocking框架。它与EasyMock和jMock很相似，但是通过在执行后校验什么已经被调用，它消除了对期望行为（expectations）的需要。其它的mocking库需要你在执行前记录期望行为（expectations），而这导致了丑陋的初始化代码。
1.1 Mockito是什么？
Mockito是mocking框架，它让你用简洁的API做测试。而且Mockito简单易学，它可读性强和验证语法简洁。
1.2 为什么需要Mock
测试驱动的开发( TDD)要求我们先写单元测试，再写实现代码。在写单元测试的过程中，我们往往会遇到要测试的类有很多依赖，这些依赖的类/对象/资源又有别的依赖，从而形成一个大的依赖树，要在单元测试的环境中完整地构建这样的依赖，是一件很困难的事情。如下图所示：
为了测试类A，我们需要Mock B类和C类（用虚拟对象来代替）如下图所示：
1.3 Stub和Mock异同[1]
相同：Stub和Mock都是模拟外部依赖
不同：Stub是完全模拟一个外部依赖， 而Mock还可以用来判断测试通过还是失败
1.4 Mockito资源
项目源码：
1.5 使用场景
提前创建测试; TDD（测试驱动开发）
团队可以并行工作
你可以创建一个验证或者演示程序
为无法访问的资源编写测试
Mock 可以交给用户
2 使用Mockito
Mockito 依赖
2.1 验证行为
mockito 类似与一个记录器，可以记录从初始化mock到mock销毁过程中所有的mock操作
public void verify_behaviour(){
List mock = mock(List.class);
mock.add(1);
mock.clear();
verify(mock).add(1);
verify(mock).clear();
2.2 模拟我们所期望的结果
public void when_thenReturn(){
Iterator iterator = mock(Iterator.class);
when(iterator.next()).thenReturn("hello").thenReturn("world");
String result = iterator.next() + " " + iterator.next() + " " + iterator.next();
assertEquals("hello world world",result);
@Test(expected = IOException.class)
public void when_thenThrow() throws IOException {
OutputStream outputStream = mock(OutputStream.class);
OutputStreamWriter writer = new OutputStreamWriter(outputStream);
doThrow(new IOException()).when(outputStream).close();
outputStream.close();
2.3 RETURNS_SMART_NULLS和RETURNS_DEEP_STUBS
RETURNS_SMART_NULLS实现了Answer接口的对象，它是创建mock对象时的一个可选参数，mock(Class,Answer)。
在创建mock对象时，有的方法我们没有进行stubbing，所以调用时会放回Null这样在进行操作是很可能抛出NullPointerException。如果通过RETURNS_SMART_NULLS参数创建的mock对象在没有调用stubbed方法时会返回SmartNull。例如：返回类型是String，会返回”“;是int，会返回0；是List，会返回空的List。另外，在控制台窗口中可以看到SmartNull的友好提示。
public void returnsSmartNullsTest() {
List mock = mock(List.class, RETURNS_SMART_NULLS)
System.out.println(mock.get(0))
//使用RETURNS_SMART_NULLS参数创建的mock对象，不会抛出NullPointerException异常。另外控制台窗口会提示信息“SmartNull returned by unstubbed get() method on mock”
System.out.println(mock.toArray().length)
RETURNS_DEEP_STUBS也是创建mock对象时的备选参数
RETURNS_DEEP_STUBS参数程序会自动进行mock所需的对象，方法deepstubsTest和deepstubsTest2是等价的
public void deepstubsTest(){
Account account=mock(Account.class,RETURNS_DEEP_STUBS)
when(account.getRailwayTicket().getDestination()).thenReturn("Beijing")
account.getRailwayTicket().getDestination()
verify(account.getRailwayTicket()).getDestination()
assertEquals("Beijing",account.getRailwayTicket().getDestination())
public void deepstubsTest2(){
Account account=mock(Account.class);
RailwayTicket railwayTicket=mock(RailwayTicket.class);
when(account.getRailwayTicket()).thenReturn(railwayTicket);
when(railwayTicket.getDestination()).thenReturn("Beijing");
account.getRailwayTicket().getDestination();
verify(account.getRailwayTicket()).getDestination();
assertEquals("Beijing",account.getRailwayTicket().getDestination());
public class RailwayTicket{
public String getDestination() {
public void setDestination(String destination) {
this.destination =
public class Account{
private RailwayTicket railwayT
public RailwayTicket getRailwayTicket() {
return railwayT
public void setRailwayTicket(RailwayTicket railwayTicket) {
this.railwayTicket = railwayT
2.4 模拟方法体抛出异常
@Test(expected = RuntimeException.class)
public void doThrow_when(){
List list = mock(List.class);
doThrow(new RuntimeException()).when(list).add(1);
list.add(1);
2.5 使用注解来快速模拟
在上面的测试中我们在每个测试方法里都mock了一个List对象，为了避免重复的mock，是测试类更具有可读性，我们可以使用下面的注解方式来快速模拟对象：
private List mockL
OK，我们再用注解的mock对象试试
public void shorthand(){
mockList.add(1);
verify(mockList).add(1);
运行这个测试类你会发现报错了，mock的对象为NULL，为此我们必须在基类中添加初始化mock的代码
public class MockitoExample2 {
private List mockL
public MockitoExample2(){
MockitoAnnotations.initMocks(this);
public void shorthand(){
mockList.add(1);
verify(mockList).add(1);
或者使用built-in runner：MockitoJUnitRunner
@RunWith(MockitoJUnitRunner.class)public class MockitoExample2 {
private List mockL
public void shorthand(){
mockList.add(1);
verify(mockList).add(1);
2.6 参数匹配
public void with_arguments(){
Comparable comparable = mock(Comparable.class)
//预设根据不同的参数返回不同的结果
when(comparable.compareTo("Test")).thenReturn(1)
when(comparable.compareTo("Omg")).thenReturn(2)
assertEquals(1, comparable.compareTo("Test"))
assertEquals(2, comparable.compareTo("Omg"))
//对于没有预设的情况会返回默认值
assertEquals(0, comparable.compareTo("Not stub"))
除了匹配制定参数外，还可以匹配自己想要的任意参数
public void with_unspecified_arguments(){
List list = mock(List.class);
when(list.get(anyInt())).thenReturn(1);
when(list.contains(argThat(new IsValid()))).thenReturn(true);
assertEquals(1, list.get(1));
assertEquals(1, list.get(999));
assertTrue(list.contains(1));
assertTrue(!list.contains(3));
private class IsValid extends ArgumentMatcher&List&{
public boolean matches(Object o) {
return o == 1 || o == 2;
注意：如果你使用了参数匹配，那么所有的参数都必须通过matchers来匹配，如下代码：
public void all_arguments_provided_by_matchers(){
Comparator comparator = mock(Comparator.class);
pare("nihao","hello");
verify(comparator).compare(anyString(),eq("hello"));
2.7 自定义参数匹配
public void argumentMatchersTest(){
List&String& mock = mock(List.class);
when(mock.addAll(argThat(new IsListofTwoElements()))).thenReturn(true);
mock.addAll(Arrays.asList("one","two","three"));
verify(mock).addAll(argThat(new IsListofTwoElements()));
class IsListofTwoElements extends ArgumentMatcher&List&
public boolean matches(Object list)
return((List)list).size()==2;
2.8 捕获参数来进一步断言
较复杂的参数匹配器会降低代码的可读性，有些地方使用参数捕获器更加合适。
public void capturing_args(){
PersonDao personDao = mock(PersonDao.class)
PersonService personService = new PersonService(personDao)
ArgumentCaptor&Person& argument = ArgumentCaptor.forClass(Person.class)
personService.update(1,"jack")
verify(personDao).update(argument.capture())
assertEquals(1,argument.getValue().getId())
assertEquals("jack",argument.getValue().getName())
class Person{
private int
Person(int id, String name) {
this.name =
public int getId() {
public String getName() {
interface PersonDao{
public void update(Person person);
class PersonService{
private PersonDao personD
PersonService(PersonDao personDao) {
this.personDao = personD
public void update(int id,String name){
personDao.update(new Person(id,name));
2.9 使用方法预期回调接口生成期望值（Answer结构）
public void answerTest(){
when(mockList.get(anyInt())).thenAnswer(new CustomAnswer());
assertEquals("hello world:0",mockList.get(0));
assertEquals("hello world:999",mockList.get(999));
private class CustomAnswer implements Answer&String&{
public String answer(InvocationOnMock invocation) throws Throwable {
Object[] args = invocation.getArguments();
return "hello world:"+args[0];
也可使用匿名内部类实现
public void answer_with_callback(){
when(mockList.get(anyInt())).thenAnswer(new Answer&Object&() {
public Object answer(InvocationOnMock invocation) throws Throwable {
Object[] args = invocation.getArguments();
return "hello world:"+args[0];
assertEquals("hello world:0",mockList.get(0));
assertEquals("hello world:999",mockList.get(999));
2.10 修改对未预设的调用返回默认期望
public void unstubbed_invocations(){
List mock = mock(List.class,new Answer() {
public Object answer(InvocationOnMock invocation) throws Throwable {
return 999;
assertEquals(999, mock.get(1));
assertEquals(999,mock.size());
2.11 用spy监控真实对象
Mock不是真实的对象，它只是用类型的class创建了一个虚拟对象，并可以设置对象行为
Spy是一个真实的对象，但它可以设置对象行为
InjectMocks创建这个类的对象并自动将标记@Mock、@Spy等注解的属性值注入到这个中
@Test(expected = IndexOutOfBoundsException.class)
public void spy_on_real_objects(){
List list = new LinkedList()
List spy = spy(list)
//下面预设的spy.get(0)会报错，因为会调用真实对象的get(0)，所以会抛出越界异常
//when(spy.get(0)).thenReturn(3)
//使用doReturn-when可以避免when-thenReturn调用真实对象api
doReturn(999).when(spy).get(999)
//预设size()期望值
when(spy.size()).thenReturn(100)
//调用真实对象的api
spy.add(1)
spy.add(2)
assertEquals(100,spy.size())
assertEquals(1,spy.get(0))
assertEquals(2,spy.get(1))
verify(spy).add(1)
verify(spy).add(2)
assertEquals(999,spy.get(999))
spy.get(2)
2.12 真实的部分mock
public void real_partial_mock(){
List list = spy(new ArrayList());
assertEquals(0,list.size());
= mock(A.class);
assertEquals(999,a.doSomething(999));
public int doSomething(int i){
2.13 重置mock
public void reset_mock(){
List list = mock(List.class);
when(list.size()).thenReturn(10);
list.add(1);
assertEquals(10,list.size());
assertEquals(0,list.size());
2.14 验证确切的调用次数
public void verifying_number_of_invocations(){
List list = mock(List.class);
list.add(1);
list.add(2);
list.add(2);
list.add(3);
list.add(3);
list.add(3);
verify(list).add(1);
verify(list,times(1)).add(1);
verify(list,times(2)).add(2);
verify(list,times(3)).add(3);
verify(list,never()).add(4);
verify(list,atLeastOnce()).add(1);
verify(list,atLeast(2)).add(2);
verify(list,atMost(3)).add(3);
2.15 连续调用
@Test(expected = RuntimeException.class)
public void consecutive_calls(){
when(mockList.get(0)).thenReturn(0);
when(mockList.get(0)).thenReturn(1);
when(mockList.get(0)).thenReturn(2);
when(mockList.get(1)).thenReturn(0).thenReturn(1).thenThrow(new RuntimeException());
assertEquals(2,mockList.get(0));
assertEquals(2,mockList.get(0));
assertEquals(0,mockList.get(1));
assertEquals(1,mockList.get(1));
mockList.get(1);
2.16 验证执行顺序
public void verification_in_order(){
List list = mock(List.class)
List list2 = mock(List.class)
list.add(1)
list2.add("hello")
list.add(2)
list2.add("world")
//将需要排序的mock对象放入InOrder
InOrder inOrder = inOrder(list,list2)
//下面的代码不能颠倒顺序，验证执行顺序
inOrder.verify(list).add(1)
inOrder.verify(list2).add("hello")
inOrder.verify(list).add(2)
inOrder.verify(list2).add("world")
2.17 确保模拟对象上无互动发生
public void verify_interaction(){
List list = mock(List.class);
List list2 = mock(List.class);
List list3 = mock(List.class);
list.add(1);
verify(list).add(1);
verify(list,never()).add(2);
2.18 找出冗余的互动(即未被验证到的)
@Test(expected = NoInteractionsWanted.class)
public void find_redundant_interaction(){
List list = mock(List.class)
list.add(1)
list.add(2)
verify(list,times(2)).add(anyInt())
//检查是否有未被验证的互动行为，因为add(1)和add(2)都会被上面的anyInt()验证到，所以下面的代码会通过
verifyNoMoreInteractions(list)
List list2 = mock(List.class)
list2.add(1)
list2.add(2)
verify(list2).add(1)
//检查是否有未被验证的互动行为，因为add(2)没有被验证，所以下面的代码会失败抛出异常
verifyNoMoreInteractions(list2)
3 Mockito如何实现Mock[3]
Mockito并不是创建一个真实的对象，而是模拟这个对象，他用简单的when(mock.method(params)).thenRetrun(result)语句设置mock对象的行为，如下语句：
// 设置mock对象的行为 － 当调用其get方法获取第0个元素时，返回”first”
Mockito.when(mockedList.get(0)).thenReturn(“first”);
在Mock对象的时候，创建一个proxy对象，保存被调用的方法名（get），以及调用时候传递的参数（0），然后在调用thenReturn方法时再把“first”保存起来，这样，就有了构建一个stub方法所需的所有信息，构建一个stub。当get方法被调用的时候，实际上调用的是之前保存的proxy对象的get方法，返回之前保存的数据。
mockito官方api：
Mockito总结：
本文已收录于以下专栏：
相关文章推荐
本文中API文档部分，翻译自：Mockito
水平有限自己感觉很多地方表达的并不到位，但找不到更好的表达方式，如果您觉着有更好的表达方式，帮助我改进！
Mockito 是什么？Mockito 是...
转载请标明出处：http://blog.csdn.net/shensky711/article/details/
本文出自: 【HansChen的博客】
mock和Mockito...
import static org.junit.Assert.assertE
import static org.mockito.Mockito.atL
import stati...
Mockito是最好的mock框架之一，API设计简洁优美，使用方便，可以在一定程度上提高我们的开发效率。
这篇教程介绍了如何使用 Mockito 框架来给软件写测试用例
如果需要往下学习，你需要先理解 Junit 框架中的单元测试。
如果你不熟悉 JUnit，请查看下面的教程： ...
刚开始做网站的时候，测试都是这样的（比如测试修改用户信息的表单逻辑）：设置断点，启动运行程序，登陆，点击点击点击然后进入到测试的页面，输入测试数据，进入断点…….。一个大的程序启动又慢，还要登陆，还要...
Android 单元测试之Roboletric RxJava、Retrofit、访问真实网络、虚拟服务器添加依赖android {
configurations.all {
学习了基本知识后，就可以实战了。Mockito的实际使用还是比较麻烦的。
因为在实际使用中，最常遇到的就是需要模拟第三方类库的行为。
比如现在有一个类FTPFileTransfer，实现了向FTP...
单元测试的重要性无需赘述，但单元测试也会遇到困难，其中之一就是如何
创建依赖。试想我们常见的server端分层架构，数据访问层Dao，业务层，
以及Web层，想要单元测试业务层，我们需要依赖Dao...
他的最新文章
讲师：吴岸城
您举报文章：
举报原因：
原文地址：
原因补充：
(最多只允许输入30个字)}