Mockito图书馆

直接已知子类：

BDDMockito

公共类Mockito
扩展了ArgumentMatchers

• 字段摘要

  修饰符和类型	字段和说明
  static Answer<Object>	CALLS_REAL_METHODS 可选Answer用于mock(Class, Answer)
  static Answer<Object>	RETURNS_DEEP_STUBS 可选Answer用于mock(Class, Answer)。
  static Answer<Object>	RETURNS_DEFAULTS Answer每个模拟的默认值，如果模拟不被扼杀。
  static Answer<Object>	RETURNS_MOCKS 可选Answer用于mock(Class, Answer)
  static Answer<Object>	RETURNS_SELF 可选Answer用于mock(Class, Answer)。
  static Answer<Object>	RETURNS_SMART_NULLS 可选Answer用于mock(Class, Answer)。

• 构造器摘要

  构造函数和说明
  Mockito()

• 方法摘要

  修饰符和类型	方法和描述
  static VerificationAfterDelay	after(long millis) 允许在给定的时间内进行验证。
  static VerificationMode	atLeast(int minNumberOfInvocations) 允许至少x验证。
  static VerificationMode	atLeastOnce() 允许至少一次验证。
  static VerificationMode	atMost(int maxNumberOfInvocations) 允许进行最多x验证。
  static VerificationMode	calls(int wantedNumberOfInvocations) 按顺序进行非贪婪验证。
  static <T> void	clearInvocations(T... mocks) 使用这个方法只是为了清除调用，当存根是非平凡的。
  static VerificationMode	description(String description) 如果验证失败，则添加要打印的说明。
  static Stubber	doAnswer(Answer answer) 使用doAnswer()时要与存根通用空隙的方法Answer。
  static Stubber	doCallRealMethod() 使用doCallRealMethod()时要调用真正执行的方法。
  static Stubber	doNothing() 使用doNothing()设置无效的方法什么也不做。
  static Stubber	doReturn(Object toBeReturned) 使用doReturn()在那些极少数情况下，你不能使用when(Object)。
  static Stubber	doReturn(Object toBeReturned, Object... toBeReturnedNext) 相同doReturn(Object)但设置要返回的连续值。
  static Stubber	doThrow(Class<? extends Throwable> toBeThrown) 使用doThrow()时要与存根异常的无效方法。
  static Stubber	doThrow(Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... toBeThrownNext) 与doThrow(Class)设置连续的异常类相同。
  static Stubber	doThrow(Throwable... toBeThrown) 使用doThrow()时要与存根异常的无效方法。
  static MockitoFramework	framework() 对于高级用户或框架集成商。
  static Object[]	ignoreStubs(Object... mocks) 为了验证，忽略了给定模拟的残留方法。
  static InOrder	inOrder(Object... mocks) 创建InOrder允许按顺序验证模拟的对象。
  static <T> T	mock(Class<T> classToMock) 创建给定的类或接口的模拟对象。
  static <T> T	mock(Class<T> classToMock, Answer defaultAnswer) 创建一个指定的策略模拟其交互的答案。
  static <T> T	mock(Class<T> classToMock, MockSettings mockSettings) 用一些非标准设置创建一个模拟。
  static <T> T	mock(Class<T> classToMock, String name) 指定模拟名称。
  static MockingDetails	mockingDetails(Object toInspect) 返回一个MockingDetails实例，该实例可以检查特定对象的Mockito相关信息。
  static MockitoSessionBuilder	mockitoSession() MockitoSession 是一个可选的强烈推荐的功能，通过消除样板代码和添加额外的验证来帮助推动清洁测试。
  static VerificationMode	never() 别名times(0)，看times(int)
  static VerificationMode	only() 允许检查给定的方法是唯一被调用的方法。
  static <T> void	reset(T... mocks) 智能Mockito用户很难使用这个功能，因为他们知道这可能是一个糟糕的测试的迹象。
  static <T> T	spy(Class<T> classToSpy) 请参阅文档spy(Object)。
  static <T> T	spy(T object) 创建真实对象的间谍。
  static VerificationWithTimeout	timeout(long millis) 允许超时验证。
  static VerificationMode	times(int wantedNumberOfInvocations) 允许验证确切的调用次数。
  static void	validateMockitoUsage() 首先，如果遇到任何问题，我建议您阅读Mockito FAQ：https：//github.com/mockito/mockito/wiki/FAQ
  static <T> T	verify(T mock) 验证一次发生的某些行为。
  static <T> T	verify(T mock, VerificationMode mode) 验证某些行为发生至少一次/确切的次数/从不。
  static void	verifyNoMoreInteractions(Object... mocks) 检查是否有任何给定的模拟有任何未经验证的交互。
  static void	verifyZeroInteractions(Object... mocks) 验证除了先前验证的交互之外，在给定的模拟上没有发生交互。 这种方法具有相同的行为verifyNoMoreInteractions(Object...)。
  static <T> OngoingStubbing<T>	when(T methodCall) 启用存根方法。
  static MockSettings	withSettings() 允许使用附加的模拟设置进行模拟创建。

  • 从类org.mockito继承的方法 ArgumentMatchers

    any, any, anyBoolean, anyByte, anyChar, anyCollection, anyCollectionOf, anyDouble, anyFloat, anyInt, anyIterable, anyIterableOf, anyList, anyListOf, anyLong, anyMap, anyMapOf, anyObject, anySet, anySetOf, anyShort, anyString, anyVararg, argThat, booleanThat, byteThat, charThat, contains, doubleThat, endsWith, eq, eq, eq, eq, eq, eq, eq, eq, eq, floatThat, intThat, isA, isNotNull, isNotNull, isNull, isNull, longThat, matches, matches, notNull, notNull, nullable, refEq, same, shortThat, startsWith

  • 从类java.lang继承的方法 目的

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

• 字段细节

  • RETURNS_DEFAULTS

    public static final  Answer < Object > RETURNS_DEFAULTS

    Answer每个模拟的默认值，如果模拟不被扼杀。通常它只是返回一些空的值。

    Answer 可以用来定义未打开的调用的返回值。

    此实现首先尝试全局配置，如果没有全局配置，则将使用返回零，空集合，空值等的默认答案。

  • RETURNS_SMART_NULLS

    public static final  Answer： < Object > RETURNS_SMART_NULLS

    可选Answer用于mock(Class, Answer)。

    Answer 可以用来定义未打开的调用的返回值。

    这个实现在处理遗留代码时会很有帮助。未被拼接的方法通常返回null。如果你的代码使用了一个未经调用的调用返回的对象，你将得到一个NullPointerException异常。Answer的这个实现返回SmartNull而不是null。 SmartNull比NPE提供更好的异常消息，因为它指出了未调用方法被调用的行。你只需点击堆栈跟踪。

    ReturnsSmartNulls首先尝试返回普通的值（零，空集合，空字符串等），然后尝试返回SmartNull。如果返回类型是final，则null返回plain 。

    ReturnsSmartNulls 将可能是Mockito 3.0.0中的默认返回值策略

    例：

    
Foo mock = mock(Foo.class, RETURNS_SMART_NULLS); //calling unstubbed method here:
Stuff stuff = mock.getStuff(); //using object returned by unstubbed call:
stuff.doSomething(); //Above doesn't yield NullPointerException this time!
//Instead, SmartNullPointerException is thrown.
//Exception's cause links to unstubbed mock.getStuff() - just click on the stack trace.


  • RETURNS_MOCKS

    public static final  Answer： < Object > RETURNS_MOCKS

    可选Answer用于mock(Class, Answer)

    Answer 可以用来定义未打开的调用的返回值。

    这个实现在处理遗留代码时会很有帮助。

    ReturnsMocks首先尝试返回普通的值（零，空集合，空字符串等），然后尝试返回模拟。如果返回类型不能被模拟（例如final），则null返回plain 。

  • RETURNS_DEEP_STUBS

    public static final  Answer： < Object > RETURNS_DEEP_STUBS

    可选Answer用于mock(Class, Answer)。

    显示深度存根工作原理的示例：

    
Foo mock = mock(Foo.class, RETURNS_DEEP_STUBS); // note that we're stubbing a chain of methods here: getBar().getName()
when(mock.getBar().getName()).thenReturn("deep"); // note that we're chaining method calls: getBar().getName()
assertEquals("deep", mock.getBar().getName());


    警告： 常规清洁代码很少需要此功能！将其留作遗留代码。嘲讽一个嘲讽返回一个模拟，返回一个模拟，（...），返回一些有意义的提示，违反得墨忒耳法或嘲弄价值对象（一个众所周知的反模式）。

    我有一天在网上看到了很好的报价：每次模拟回来模拟一个仙女死亡。

    请注意，这个答案将返回与存根相匹配的现有模拟。这种行为对于深存根是可以的，并且允许验证在链的最后模拟上工作。

    
when(mock.getBar(anyString()).getThingy().getName()).thenReturn("deep"); mock.getBar("candy bar").getThingy().getName(); assertSame(mock.getBar(anyString()).getThingy().getName(), mock.getBar(anyString()).getThingy().getName());
verify(mock.getBar("candy bar").getThingy()).getName();
verify(mock.getBar(anyString()).getThingy()).getName();


    验证只适用于链中的最后一个模拟。您可以使用验证模式。

    
when(person.getAddress(anyString()).getStreet().getName()).thenReturn("deep");
when(person.getAddress(anyString()).getStreet(Locale.ITALIAN).getName()).thenReturn("deep");
when(person.getAddress(anyString()).getStreet(Locale.CHINESE).getName()).thenReturn("deep"); person.getAddress("the docks").getStreet().getName();
person.getAddress("the docks").getStreet().getLongName();
person.getAddress("the docks").getStreet(Locale.ITALIAN).getName();
person.getAddress("the docks").getStreet(Locale.CHINESE).getName(); // note that we are actually referring to the very last mock in the stubbing chain.
InOrder inOrder = inOrder(
person.getAddress("the docks").getStreet(),
person.getAddress("the docks").getStreet(Locale.CHINESE),
person.getAddress("the docks").getStreet(Locale.ITALIAN)
);
inOrder.verify(person.getAddress("the docks").getStreet(), times(1)).getName();
inOrder.verify(person.getAddress("the docks").getStreet()).getLongName();
inOrder.verify(person.getAddress("the docks").getStreet(Locale.ITALIAN), atLeast(1)).getName();
inOrder.verify(person.getAddress("the docks").getStreet(Locale.CHINESE)).getName();


    多少深存根在内部工作？

    
//this:
Foo mock = mock(Foo.class, RETURNS_DEEP_STUBS);
when(mock.getBar().getName(), "deep"); //is equivalent of
Foo foo = mock(Foo.class);
Bar bar = mock(Bar.class);
when(foo.getBar()).thenReturn(bar);
when(bar.getName()).thenReturn("deep");


    当包含在链中的任何返回类型的方法不能被模拟时（例如：是原始类还是最终类），此功能将不起作用。这是因为java类型的系统。

  • CALLS_REAL_METHODS

    public static final  Answer < Object > CALLS_REAL_METHODS

    可选Answer用于mock(Class, Answer)

    Answer 可以用来定义未打开的调用的返回值。

    这个实现在处理遗留代码时会很有帮助。当使用这个实现时，未解压的方法将委托给真正的实现。这是创建一个默认调用真实方法的部分模拟对象的一种方法。

    像往常一样，您将阅读部分模拟警告：面向对象的编程通过将复杂性划分为单独的，特定的SRPy对象来解决更复杂的问题。部分模拟如何适应这种模式？那么，它只是不...部分模拟通常意味着复杂性已被移动到同一个对象上的不同方法。在大多数情况下，这不是您想要设计应用程序的方式。

    但是，有些情况下，部分模拟会变得很方便：处理不能轻易更改的代码（第三方接口，传统代码的临时重构等）。但是，我不会使用部分模拟来实现新的，测试驱动的，设计的代码。

    例：

    
Foo mock = mock(Foo.class, CALLS_REAL_METHODS); // this calls the real implementation of Foo.getSomething()
value = mock.getSomething(); when(mock.getSomething()).thenReturn(fakeValue); // now fakeValue is returned
value = mock.getSomething();


  • RETURNS_SELF

    public static final  Answer < Object > RETURNS_SELF

    可选Answer用于mock(Class, Answer)。当一个方法被调用返回一个Type等于该类或一个超类的方法时，允许Builder mock返回自身。

    请记住，这个答案使用方法的返回类型。如果这个类型可以分配给模拟类，它将返回模拟。因此，如果你有一个方法返回一个超类（例如Object）它将匹配并返回模拟。

    考虑HttpRequesterWithHeaders中使用的HttpBuilder。

    
public class HttpRequesterWithHeaders { private HttpBuilder builder; public HttpRequesterWithHeaders(HttpBuilder builder) {
this.builder = builder;
} public String request(String uri) {
return builder.withUrl(uri)
.withHeader("Content-type: application/json")
.withHeader("Authorization: Bearer")
.request();
}
} private static class HttpBuilder { private String uri;
private List<String> headers; public HttpBuilder() {
this.headers = new ArrayList<String>();
} public HttpBuilder withUrl(String uri) {
this.uri = uri;
return this;
} public HttpBuilder withHeader(String header) {
this.headers.add(header);
return this;
} public String request() {
return uri + headers.toString();
}
}


    以下测试将成功

    
@Test
public void use_full_builder_with_terminating_method() {
HttpBuilder builder = mock(HttpBuilder.class, RETURNS_SELF);
HttpRequesterWithHeaders requester = new HttpRequesterWithHeaders(builder);
String response = "StatusCode: 200"; when(builder.request()).thenReturn(response); assertThat(requester.request("URI")).isEqualTo(response);
}


• 构造函数的细节

  • 的Mockito

    公众Mockito（）

• 方法细节

  • 嘲笑

    public static <T> T mock（Class <T> classToMock）

    创建给定的类或接口的模拟对象。

    见的例子中的javadoc Mockito类

    参数：

    classToMock - 类或接口来模拟

    返回：

    模拟对象

  • 嘲笑

    public static <T> T mock（Class <T> classToMock，
    String  name）

    指定模拟名称。命名模拟可能对调试有帮助 - 名称用于所有验证错误。

    请注意，命名模拟不适用于使用太多模拟或协作者的复杂代码。 如果你有太多的mock，那么重构代码，这样很容易测试/调试，而不必命名模拟。

    如果你使用@Mock注释，那么你已经免费命名模拟！ @Mock使用字段名称作为模拟名称。Read more.

    见的例子中的javadoc Mockito类

    参数：

    classToMock - 类或接口来模拟

    name - 模拟

    返回：

    模拟对象

  • mockingDetails

    公共静态  MockingDetails  mockingDetails（Object  toInspect）

    返回一个MockingDetails实例，该实例可以检查特定对象的Mockito相关信息。可以用来找出给定的对象是否是Mockito模拟，或者找出给定的模拟是间谍还是模拟。

    在将来的Mockito版本中，MockingDetails可能会增长，并提供有关模拟的其他有用信息，例如调用，存根信息等。

    参数：

    toInspect - - 检查对象。空输入是允许的。

    返回：

    一个MockingDetails实例。

    以来：

    1.9.5

  • 嘲笑

    public static <T> T mock（Class <T> classToMock，
    Answer  defaultAnswer）

    创建一个指定的策略模拟其交互的答案。这是一个相当先进的功能，通常你不需要它来写出体面的测试。但是，使用旧系统时可能会有所帮助。

    这是默认的答案，所以只有当你不存在方法调用时才会使用它。

    
Foo mock = mock(Foo.class, RETURNS_SMART_NULLS);
Foo mockTwo = mock(Foo.class, new YourOwnAnswer());


    见的例子中的javadoc Mockito类

    参数：

    classToMock - 类或接口来模拟

    defaultAnswer - 未打开的方法的默认答案

    返回：

    模拟对象

  • 嘲笑

    public static <T> T mock（Class <T> classToMock，
    MockSettings  mockSettings）

    用一些非标准设置创建一个模拟。

    模拟的配置点数量增长，所以我们需要一个流利的方式来引入新的配置，而不会增加更多的重载Mockito.mock（）方法。因此MockSettings。

    
Listener mock = mock(Listener.class, withSettings()
.name("firstListner").defaultBehavior(RETURNS_SMART_NULLS));
);


    小心使用，偶尔使用。什么可能是你的测试需要非标准模拟的原因？被测试的代码是如此复杂以至于它需要非标准的模拟？你不喜欢重构测试中的代码，所以它是可测试的一个简单的方法？

    也可以看看 withSettings()

    见的例子中的javadoc Mockito类

    参数：

    classToMock - 类或接口来模拟

    mockSettings - 额外的模拟设置

    返回：

    模拟对象

  • 间谍

    公共静态<T> T间谍（T对象）

    创建真实对象的间谍。间谍调用真正的方法，除非他们被扼杀。

    真正的间谍应该谨慎地偶尔使用，例如在处理遗留代码时。

    像往常一样，您将阅读部分模拟警告：面向对象编程通过将复杂性划分为单独的，特定的SRPy对象来解决复杂性问题。部分模拟如何适应这种模式？那么，它只是不...部分模拟通常意味着复杂性已被移动到同一个对象上的不同方法。在大多数情况下，这不是您想要设计应用程序的方式。

    但是，有些情况下，部分模拟会变得很方便：处理不能轻易更改的代码（第三方接口，传统代码的临时重构等）。但是，我不会使用部分模拟来实现新的，测试驱动的，设计的代码。

    例：

    
List list = new LinkedList();
List spy = spy(list); //optionally, you can stub out some methods:
when(spy.size()).thenReturn(100); //using the spy calls real methods
spy.add("one");
spy.add("two"); //prints "one" - the first element of a list
System.out.println(spy.get(0)); //size() method was stubbed - 100 is printed
System.out.println(spy.size()); //optionally, you can verify
verify(spy).add("one");
verify(spy).add("two");


    关于间谍真相的重要窍门！

    1. 有时使用when(Object)吝啬的间谍是不可能或不切实际的。因此，对于间谍，建议始终使用doReturn| Answer| Throw()| CallRealMethod 存根方法的家庭。例：

       
List list = new LinkedList();
List spy = spy(list); //Impossible: real method is called so spy.get(0) throws IndexOutOfBoundsException (the list is yet empty)
when(spy.get(0)).thenReturn("foo"); //You have to use doReturn() for stubbing
doReturn("foo").when(spy).get(0);


    2. Mockito *不会将调用委托给传入的实例，而是实际创建一个副本。所以如果你保留真实的实例并与之交互，不要期望被侦察者知道这些交互以及它们对实际实例状态的影响。其必然结果是，当* unstubbed *方法被调用*在间谍*，但*不上真正的实例*，你不会看到真正的实例的任何影响。
    3. 留意最后的方法。Mockito不会嘲笑最后的方法，所以底线是：当你窥探真实的物体时，你试图存根最后的方法=麻烦。你也将无法验证这些方法。

    见的例子中的javadoc Mockito类

    请注意，间谍不会有任何关于间谍类型的注释，因为CGLIB不会重写它们。对于依靠间谍来获得这些注释的代码来说，可能会很麻烦。

    参数：

    object - 监视

    返回：

    一个真正的对象的间谍

  • 间谍

    @Incubating
    public static <T> T spy（Class <T> classToSpy）

    请参阅文档spy(Object)。滥用间谍暗示代码设计的气味。

    这个方法与原来的方法相反spy(Object)，是基于类而不是一个对象来创建一个间谍。有时候，基于类创建间谍更为方便，并避免提供一个间谍对象的实例。这对侦察抽象类非常有用，因为它们不能被实例化。另见MockSettings.useConstructor(Object...)。

    例子：

    
SomeAbstract spy = spy(SomeAbstract.class); //Robust API, via settings builder:
OtherAbstract spy = mock(OtherAbstract.class, withSettings()
.useConstructor().defaultAnswer(CALLS_REAL_METHODS)); //Mocking a non-static inner abstract class:
InnerAbstract spy = mock(InnerAbstract.class, withSettings()
.useConstructor().outerInstance(outerInstance).defaultAnswer(CALLS_REAL_METHODS));


    类型参数：

    T - 间谍的类型

    参数：

    classToSpy - 要窥探的班级

    返回：

    提供的类的间谍

    以来：

    1.10.12

  • 什么时候

    public static <T>  OngoingStubbing <T> when（T methodCall）

    启用存根方法。当你想要模拟特定的方法被调用时返回特定的值使用它。

    简单地说：“ 当 x方法被调用，然后返回y”。

    例子：

    
when(mock.someMethod()).thenReturn(10); //you can use flexible argument matchers, e.g:
when(mock.someMethod(anyString())).thenReturn(10); //setting exception to be thrown:
when(mock.someMethod("some arg")).thenThrow(new RuntimeException()); //you can set different behavior for consecutive method calls.
//Last stubbing (e.g: thenReturn("foo")) determines the behavior of further consecutive calls.
when(mock.someMethod("some arg"))
.thenThrow(new RuntimeException())
.thenReturn("foo"); //Alternative, shorter version for consecutive stubbing:
when(mock.someMethod("some arg"))
.thenReturn("one", "two");
//is the same as:
when(mock.someMethod("some arg"))
.thenReturn("one")
.thenReturn("two"); //shorter version for consecutive method calls throwing exceptions:
when(mock.someMethod("some arg"))
.thenThrow(new RuntimeException(), new NullPointerException();

    有关throwables的void方法，请参见： doThrow(Throwable...)

    可以覆盖桩号：例如，普通桩可以进入夹具设置，但测试方法可以覆盖它。请注意，覆盖残片是一种潜在的代码异味，指出了太多的残片。

    一旦被存根，该方法将总是返回存根值，而不管被调用的次数多少。

    最后的茬更重要 - 当你多次用相同的参数扼杀相同的方法。

    尽管可以验证存根调用，但通常这只是多余的。比方说，你已经残废了foo.bar()。如果你的代码关心什么foo.bar()返回，那么别的东西就会中断（通常在verify()执行之前）。如果你的代码不在乎什么get(0)返回，那么它不应该被扼杀。不服气？看到这里。

    见的例子中的javadoc Mockito类

    参数：

    methodCall - 方法被扼杀

    返回：

    OngoingStubbing对象用于流利地存根。 不要创建对此返回对象的引用。

  • 校验

    public static <T> T verify（T mock）

    验证一次发生的某些行为。

    别名verify(mock, times(1))如：

    
verify(mock).someMethod("some arg");


    以上相当于：

    
verify(mock, times(1)).someMethod("some arg");


    使用equals()方法比较传递的参数。阅读ArgumentCaptor或ArgumentMatcher找出其他方式匹配/断言传递的参数。

    尽管可以验证存根调用，但通常这只是多余的。比方说，你已经残废了foo.bar()。如果你的代码关心什么foo.bar()返回，那么别的东西就会中断（通常在verify()执行之前）。如果你的代码不在乎什么get(0)返回，那么它不应该被扼杀。不服气？看到这里。

    见的例子中的javadoc Mockito类

    参数：

    mock - 待验证

    返回：

    模拟对象本身

  • 校验

    public static <T> T验证（T模拟，
    VerificationMode  模式）

    验证某些行为发生至少一次/确切的次数/从不。例如：

    
verify(mock, times(5)).someMethod("was called five times"); verify(mock, atLeast(2)).someMethod("was called at least two times"); //you can use flexible argument matchers, e.g:
verify(mock, atLeastOnce()).someMethod(anyString());


    次（1）是默认值，可以省略

    使用equals()方法比较传递的参数。阅读ArgumentCaptor或ArgumentMatcher找出其他方式匹配/断言传递的参数。

    参数：

    mock - 待验证

    mode - times（x），atLeastOnce（）或never（）

    返回：

    模拟对象本身

  • 重启

    public static <T> void reset（T ... mocks）

    智能Mockito用户很难使用这个功能，因为他们知道这可能是一个糟糕的测试的迹象。通常情况下，你不需要重置你的模拟，只是为每个测试方法创建新的模拟。

    不要#reset()考虑写一些简单，小而重点明确的测试方法，而不要考虑冗长的，过度规定的测试。 第一个潜在的代码气味正reset()处于测试方法的中间。这可能意味着你测试太多了。按照你的测试方法的低语：“请保持我们的小而专注于单一的行为”。在mockito邮件列表上有几个线程。

    我们添加reset()方法的唯一原因是使用容器注入的模拟工作成为可能。欲了解更多信息，请参阅常见问题（这里）。

    不要伤害你自己 reset()在测试方法的中间是一个代码气味（你可能测试太多）。

    
List mock = mock(List.class);
when(mock.size()).thenReturn(10);
mock.add(1); reset(mock);
//at this point the mock forgot any interactions & stubbing


    类型参数：

    T - 嘲笑的类型

    参数：

    mocks - 重置

  • clearInvocations

    public static <T> void clearInvocations（T ... mocks）

    使用这个方法只是为了清除调用，当存根是非平凡的。用例可以是：

    • 你正在使用依赖注入框架来注入你的模拟。
    • 这个模拟是在有状态的情况下使用的。例如，一个类是独立的，这取决于你的模拟。

    尽量避免这种方法，不惜一切代价。只有清除调用，如果你不能有效地测试你的程序。

    类型参数：

    T - 嘲笑的类型

    参数：

    mocks - 嘲笑清除调用

  • verifyNoMoreInteractions

    公共静态无效verifyNoMoreInteractions（对象 ...嘲笑）

    检查是否有任何给定的模拟有任何未经验证的交互。

    你可以在验证你的模拟之后使用这个方法 - 确保你的模拟中没有其他的东西被调用。

    另请参阅never()- 它更加明确，并充分传达意图。

    存根调用（如果调用）也被视为交互。

    一句警告：谁做了很多经典的一些用户，期望-运行-验证嘲讽倾向于使用verifyNoMoreInteractions()非常频繁，甚至在每个测试方法。 verifyNoMoreInteractions()不建议在每个测试方法中使用。verifyNoMoreInteractions()是交互测试工具包的一个方便的断言。只有在相关时才使用它。滥用它会导致过度指定，不易维护的测试。你可以在这里找到更多的阅读 。

    此方法还将检测在测试方法之前发生的未经验证的调用，例如：in setUp()，@Beforemethod或构造函数中。考虑编写漂亮的代码，只在测试方法中进行交互。

    例：

    
//interactions
mock.doSomething();
mock.doSomethingUnexpected(); //verification
verify(mock).doSomething(); //following will fail because 'doSomethingUnexpected()' is unexpected
verifyNoMoreInteractions(mock);

    见的例子中的javadoc Mockito类

    参数：

    mocks - 待验证

  • verifyZeroInteractions

    公共静态无效verifyZeroInteractions（对象 ...嘲笑）

    验证除了先前验证的交互之外，在给定的模拟上没有发生交互。
    这种方法具有相同的行为verifyNoMoreInteractions(Object...)。

    参数：

    mocks - 待验证

  • doThrow

    公共静态  Stubber  doThrow（Throwable ... toBeThrown）

    使用doThrow()时要与存根异常的无效方法。

    when(Object)由于编译器不喜欢方括号内的void方法 ，所以 需要使用不同的方法

    例：

    
doThrow(new RuntimeException()).when(mock).someVoidMethod();


    参数：

    toBeThrown - 当被调用的方法被调用时被抛出

    返回：

    stubber - 选择一个存根的方法

  • doThrow

    公共静态  Stubber  doThrow（Class <？extends Throwable > toBeThrown）

    使用doThrow()时要与存根异常的无效方法。

    将为每个方法调用创建一个新的异常实例。

    when(Object)由于编译器不喜欢方括号内的void方法 ，所以 需要使用不同的方法

    例：

    
doThrow(RuntimeException.class).when(mock).someVoidMethod();


    参数：

    toBeThrown - 当被调用的方法被调用时被抛出

    返回：

    stubber - 选择一个存根的方法

    以来：

    2.1.0

  • doThrow

    public static  Stubber  doThrow（Class <？extends Throwable > toBeThrown，
    Class <？extends Throwable > ... toBeThrownNext）

    与doThrow(Class)设置连续的异常类相同。记住要使用 doThrow()时要存根的void方法抛出指定类的几个异常。

    将为每个方法调用创建一个新的异常实例。

    when(Object)由于编译器不喜欢方括号内的void方法 ，所以 需要使用不同的方法

    例：

    
doThrow(RuntimeException.class, BigFailure.class).when(mock).someVoidMethod();


    参数：

    toBeThrown - 当被调用的方法被调用时被抛出

    toBeThrownNext - 当被调用的方法被调用时接下来被抛出

    返回：

    stubber - 选择一个存根的方法

    以来：

    2.1.0

  • doCallRealMethod

    public static  Stubber  doCallRealMethod（）

    使用doCallRealMethod()时要调用真正执行的方法。

    像往常一样，您将阅读部分模拟警告：面向对象的编程通过将复杂性划分为单独的，特定的SRPy对象来解决更复杂的问题。部分模拟如何适应这种模式？那么，它只是不...部分模拟通常意味着复杂性已被移动到同一个对象上的不同方法。在大多数情况下，这不是您想要设计应用程序的方式。

    但是，有些情况下，部分模拟会变得很方便：处理不能轻易更改的代码（第三方接口，传统代码的临时重构等）。但是，我不会使用部分模拟来实现新的，测试驱动的，设计的代码。

    另请参阅javadoc spy(Object)以了解有关部分嘲讽的更多信息。 Mockito.spy（）是创建部分模拟的推荐方法。 原因是它保证真正的方法被称为正确构造的对象，因为你负责构造传递给spy（）方法的对象。

    例：

    
Foo mock = mock(Foo.class);
doCallRealMethod().when(mock).someVoidMethod(); // this will call the real implementation of Foo.someVoidMethod()
mock.someVoidMethod();


    见的例子中的javadoc Mockito类

    返回：

    stubber - 选择一个存根的方法

    以来：

    1.9.5

  • doAnswer

    公共静态  Stubber  doAnswer（回答  ）

    使用doAnswer()时要与存根通用空隙的方法Answer。

    when(Object)由于编译器不喜欢方括号内的void方法 ，所以 需要使用不同的方法

    例：

    
doAnswer(new Answer() {
public Object answer(InvocationOnMock invocation) {
Object[] args = invocation.getArguments();
Mock mock = invocation.getMock();
return null;
}})
.when(mock).someMethod();


    见的例子中的javadoc Mockito类

    参数：

    answer - 在调用存根方法时回答

    返回：

    stubber - 选择一个存根的方法

  • 没做什么

    公共静态  Stubber  doNothing（）

    使用doNothing()设置无效的方法什么也不做。请注意，虚拟方法嘲笑默认情况下不做任何事情！ 但是，在doNothing（）方便的情况下，

    1. 连续调用一个void方法：

       
doNothing().
doThrow(new RuntimeException())
.when(mock).someVoidMethod(); //does nothing the first time:
mock.someVoidMethod(); //throws RuntimeException the next time:
mock.someVoidMethod();


    2. 当你窥探真实的物体时，你想让void方法什么也不做：

       
List list = new LinkedList();
List spy = spy(list); //let's make clear() do nothing
doNothing().when(spy).clear(); spy.add("one"); //clear() does nothing, so the list still contains "one"
spy.clear();


    见的例子中的javadoc Mockito类

    返回：

    stubber - 选择一个存根的方法

  • doReturn

    公共静态  Stubber  doReturn（Object  toBeReturned）

    使用doReturn()在那些极少数情况下，你不能使用when(Object)。

    注意when(Object)总是建议用于存根，因为它是参数类型安全的，并且更具可读性（特别是在连续调用存根时）。

    以下是doReturn（）方便使用的情况：

    1. 当间谍侦察真实的对象和调用真正的方法间谍带来的副作用

       
List list = new LinkedList();
List spy = spy(list); //Impossible: real method is called so spy.get(0) throws IndexOutOfBoundsException (the list is yet empty)
when(spy.get(0)).thenReturn("foo"); //You have to use doReturn() for stubbing:
doReturn("foo").when(spy).get(0);


    2. 覆盖以前的例外情况：

       
when(mock.foo()).thenThrow(new RuntimeException()); //Impossible: the exception-stubbed foo() method is called so RuntimeException is thrown.
when(mock.foo()).thenReturn("bar"); //You have to use doReturn() for stubbing:
doReturn("bar").when(mock).foo();


    以上场景展示了Mockito优雅语法的折衷。请注意，情景是非常罕见的，虽然。间谍应该是零星的，压倒一切的例外情况非常罕见。更不用说，一般来说，被覆盖的残片是一种潜在的代码味道，指出了太多的残片。

    见的例子中的javadoc Mockito类

    参数：

    toBeReturned - 当被调用的方法被调用时被返回

    返回：

    stubber - 选择一个存根的方法

  • doReturn

    公共静态  Stubber  doReturn（Object  toBeReturned，
    Object ... toBeReturnedNext）

    相同doReturn(Object)但设置要返回的连续值。请记住doReturn()在不能使用的情况下使用 这些罕见的场合when(Object)。

    注意when(Object)总是建议用于存根，因为它是参数类型安全的，并且更具可读性（特别是在连续调用存根时）。

    以下是doReturn（）方便使用的情况：

    1. 当间谍侦察真实的对象和调用真正的方法间谍带来的副作用

       
List list = new LinkedList();
List spy = spy(list); //Impossible: real method is called so spy.get(0) throws IndexOutOfBoundsException (the list is yet empty)
when(spy.get(0)).thenReturn("foo", "bar", "qix"); //You have to use doReturn() for stubbing:
doReturn("foo", "bar", "qix").when(spy).get(0);


    2. 覆盖以前的例外情况：

       
when(mock.foo()).thenThrow(new RuntimeException()); //Impossible: the exception-stubbed foo() method is called so RuntimeException is thrown.
when(mock.foo()).thenReturn("bar", "foo", "qix"); //You have to use doReturn() for stubbing:
doReturn("bar", "foo", "qix").when(mock).foo();


    以上场景展示了Mockito优雅语法的折衷。请注意，情景是非常罕见的，虽然。间谍应该是零星的，压倒一切的例外情况非常罕见。更不用说，一般来说，被覆盖的残片是一种潜在的代码味道，指出了太多的残片。

    见的例子中的javadoc Mockito类

    参数：

    toBeReturned - 当被调用的方法被调用时被返回

    toBeReturnedNext - 在调用存根方法时连续调用返回

    返回：

    stubber - 选择一个存根的方法

    以来：

    2.1.0

  • 为了

    公共静态  InOrder inOrder  （Object ... mocks）

    创建InOrder允许按顺序验证模拟的对象。

    
InOrder inOrder = inOrder(firstMock, secondMock); inOrder.verify(firstMock).add("was called first");
inOrder.verify(secondMock).add("was called second");


    按顺序进行验证是非常灵活的 - 您不必逐个验证所有交互，只需要验证您有兴趣测试的所有交互。

    此外，您可以创建InOrder对象，只传递与按序验证相关的模拟。

    InOrder验证是“贪婪”的，但你几乎不会注意到它。如果你想了解更多，请阅读 这个维基页面。

    从Mockito 1.8.4开始，您可以按顺序验证NoMoreInvocations（）。阅读更多：InOrder.verifyNoMoreInteractions()

    见的例子中的javadoc Mockito类

    参数：

    mocks - 按顺序核实

    返回：

    InOrder对象用于按顺序进行验证

  • ignoreStubs

    public static  Object [] ignoreStubs（Object ... mocks）

    为了验证，忽略了给定模拟的残留方法。有时加上verifyNoMoreInteractions()或验证时有用inOrder()。有助于避免冗余验证，通常我们对验证存根不感兴趣。

    警告，ignoreStubs()可能会导致过度使用verifyNoMoreInteractions(ignoreStubs(...)); Bear记住，Mockito不建议verifyNoMoreInteractions() 按照javadoc中概述的原因轰击每个测试。verifyNoMoreInteractions(Object...) 其他的话：所有* stubbed *方法的给定mock被标记*验证*，以便他们不进入verifyNoMoreInteractions（）期间的一种方法。

    这种方法改变输入模拟！这个方法只是为了方便返回输入模拟。

    包括在内的被忽略的存根也将被忽略用于验证InOrder.verifyNoMoreInteractions()。看第二个例子。

    例：

    
//mocking lists for the sake of the example (if you mock List in real you will burn in hell)
List mock1 = mock(List.class), mock2 = mock(List.class); //stubbing mocks:
when(mock1.get(0)).thenReturn(10);
when(mock2.get(0)).thenReturn(20); //using mocks by calling stubbed get(0) methods:
System.out.println(mock1.get(0)); //prints 10
System.out.println(mock2.get(0)); //prints 20 //using mocks by calling clear() methods:
mock1.clear();
mock2.clear(); //verification:
verify(mock1).clear();
verify(mock2).clear(); //verifyNoMoreInteractions() fails because get() methods were not accounted for.
try { verifyNoMoreInteractions(mock1, mock2); } catch (NoInteractionsWanted e); //However, if we ignore stubbed methods then we can verifyNoMoreInteractions()
verifyNoMoreInteractions(ignoreStubs(mock1, mock2)); //Remember that ignoreStubs() *changes* the input mocks and returns them for convenience.


    忽略存根可用于验证顺序：

    
List list = mock(List.class);
when(mock.get(0)).thenReturn("foo"); list.add(0);
System.out.println(list.get(0)); //we don't want to verify this
list.clear(); InOrder inOrder = inOrder(ignoreStubs(list));
inOrder.verify(list).add(0);
inOrder.verify(list).clear();
inOrder.verifyNoMoreInteractions();


    参数：

    mocks - 输入模拟将被改变

    返回：

    同样的模拟参数传入

    以来：

    1.9.0

  • 时

    public static  VerificationMode  times（int wantedNumberOfInvocations）

    允许验证确切的调用次数。例如：

    
verify(mock, times(2)).someMethod("some arg");


    见的例子中的javadoc Mockito类

    参数：

    wantedNumberOfInvocations - 想要的调用次数

    返回：

    验证模式

  • 决不

    public static  VerificationMode  never（）

    别名times(0)，看times(int)

    验证交互没有发生。例如：

    
verify(mock, never()).someMethod();


    如果你想验证没有任何与模拟检查verifyZeroInteractions(Object...) 或互动verifyNoMoreInteractions(Object...)

    见的例子中的javadoc Mockito类

    返回：

    验证模式

  • 至少一次

    公共静态  验证模式  atLeastOnce（）

    允许至少一次验证。例如：

    
verify(mock, atLeastOnce()).someMethod("some arg");


    别名atLeast(1)。

    见的例子中的javadoc Mockito类

    返回：

    验证模式

  • 至少

    公共静态  VerificationMode  atLeast（int minNumberOfInvocations）

    允许至少x验证。例如：

    
verify(mock, atLeast(3)).someMethod("some arg");


    见的例子中的javadoc Mockito类

    参数：

    minNumberOfInvocations - 最少的调用次数

    返回：

    验证模式

  • 最多

    公共静态  VerificationMode  atMost（int maxNumberOfInvocations）

    允许进行最多x验证。例如：

    
verify(mock, atMost(3)).someMethod("some arg");


    见的例子中的javadoc Mockito类

    参数：

    maxNumberOfInvocations - 最大的调用次数

    返回：

    验证模式

  • 电话

    公共静态  VerificationMode  调用（int wantedNumberOfInvocations）

    按顺序进行非贪婪验证。例如

    
inOrder.verify( mock, calls( 2 )).someMethod( "some arg" );


    • 如果方法被调用3次不会失败，不像时间（2）
    • 不会将第三次调用标记为已验证，不像atLeast（2）

    该验证模式只能用于验证。

    参数：

    wantedNumberOfInvocations - 要验证的调用次数

    返回：

    验证模式

  • 只要

    public static  VerificationMode  only（）

    允许检查给定的方法是唯一被调用的方法。例如：

    
verify(mock, only()).someMethod();
//above is a shorthand for following 2 lines of code:
verify(mock).someMethod();
verifyNoMoreInvocations(mock);


    也可以看看 verifyNoMoreInteractions(Object...)

    见的例子中的javadoc Mockito类

    返回：

    验证模式

  • 时间到

    公共静态  VerificationWithTimeout  超时（长毫秒）

    允许超时验证。它会导致验证等待指定的时间段进行期望的交互，而不是立即失败，如果还没有发生。可能对并发条件下的测试有用。

    这不同于after()在（）之后将等待整个周期，除非最后的测试结果是早期知道的（例如，如果一个never（）失败），而timeout（）将在验证通过后尽早停止，当使用时产生不同的行为与时间（2），例如，可以通过，然后失败。在这种情况下，超时将在时间（2）通过后立即传递，而在时间（2）失败后运行，然后失败。

    这个功能应该很少使用 - 找出测试你的多线程系统的更好方法。

    
//passes when someMethod() is called within given time span
verify(mock, timeout(100)).someMethod();
//above is an alias to:
verify(mock, timeout(100).times(1)).someMethod(); //passes as soon as someMethod() has been called 2 times before the given timeout
verify(mock, timeout(100).times(2)).someMethod(); //equivalent: this also passes as soon as someMethod() has been called 2 times before the given timeout
verify(mock, timeout(100).atLeast(2)).someMethod(); //verifies someMethod() within given time span using given verification mode
//useful only if you have your own custom verification modes.
verify(mock, new Timeout(100, yourOwnVerificationMode)).someMethod();


    见的例子中的javadoc Mockito类

    参数：

    millis - - 以毫秒为单位的时间跨度

    返回：

    验证模式

  • 后

     （long millis）之后的公共静态  VerificationAfterDelay

    允许在给定的时间内进行验证。它会导致验证等待指定的时间段进行所需的交互，而不是立即失败（如果尚未发生）。可能对并发条件下的测试有用。

    这不同于timeout()在（）之后等待整个周期，而timeout（）将在验证通过后立即提前停止，在与时间（2）一起使用时产生不同的行为，例如，可以通过然后失败。在这种情况下，超时会在时间（2）通过后立即传递，而在之后的时间将运行整个时间，哪个时间点将失败，因为时间（2）失败。

    这个功能应该很少使用 - 找出测试你的多线程系统的更好方法。

    尚未实施以使用InOrder验证。

    
//passes after 100ms, if someMethod() has only been called once at that time.
verify(mock, after(100)).someMethod();
//above is an alias to:
verify(mock, after(100).times(1)).someMethod(); //passes if someMethod() is called *exactly* 2 times after the given timespan
verify(mock, after(100).times(2)).someMethod(); //passes if someMethod() has not been called after the given timespan
verify(mock, after(100).never()).someMethod(); //verifies someMethod() after a given time span using given verification mode
//useful only if you have your own custom verification modes.
verify(mock, new After(100, yourOwnVerificationMode)).someMethod();


    见的例子中的javadoc Mockito类

    参数：

    millis - - 以毫秒为单位的时间跨度

    返回：

    验证模式

  • validateMockitoUsage

    公共静态无效validateMockitoUsage（）

    首先，如果遇到任何问题，我建议您阅读Mockito FAQ：https：//github.com/mockito/mockito/wiki/FAQ

    如有疑问，您也可以发送到mockito邮件列表：http：//groups.google.com/group/mockito

    validateMockitoUsage() 明确验证框架状态以检测Mockito的无效使用。不过，这个功能是可选的，因为Mockito始终验证使用情况...但是有一个小问题需要阅读。

    错误使用的例子：

    
//Oops, thenReturn() part is missing:
when(mock.get()); //Oops, verified method call is inside verify() where it should be on the outside:
verify(mock.execute()); //Oops, missing method to verify:
verify(mock);


    如果你滥用Mockito会抛出异常，这样你就知道你的测试是否写得正确。问题是Mockito 在下一次使用框架时会进行验证（例如，下一次验证，存根，调用模拟等）。但是，即使在下一次测试中可能会抛出异常，异常消息中也会包含一个带有缺陷位置的可导航堆栈跟踪元素。因此，您可以点击并找到Mockito被滥用的地方。

    有时候，你可能想明确地验证框架的用法。例如，其中一个用户想要投入validateMockitoUsage()他的@After方法，以便他在误用Mockito时立即知道。没有它，他会早在下一次他就使用这个框架就知道了。validateMockitoUsage()进入的另外一个好处@After是，jUnit跑步者和规则在测试方法中总会失败，而普通的“下一次”验证可能会使下一个测试方法失败。但即使JUnit可能会将下一个测试报告为红色，也不要担心，只需单击异常消息中的可导航堆栈跟踪元素即可找到您误用mockito的地方。

    内置runner MockitoJUnitRunner和规则：MockitoRule在每个测试方法之后，执行validateMockitoUsage（）。

    请记住，通常情况下，您不必validateMockitoUsage() 在下一次触发框架验证时就足够了，这主要是因为增强了异常消息和可点击的缺陷位置。但是，如果您已经拥有足够的测试基础架构（比如您自己的所有测试的运行者或基类），那么我会推荐使用validateMockitoUsage（），因为添加了一个特殊的操作来实现@After零成本。

    见的例子中的javadoc Mockito类

  • withSettings

    public static  MockSettings  withSettings（）

    允许使用附加的模拟设置进行模拟创建。

    不要经常使用它。考虑编写使用简单模拟的简单测试。重复我之后：简单的测试推简单，KISSy，可读和可维护的代码。如果你不能以简单的方式编写测试 - 重构测试中的代码。

    模拟设置的例子：

    
//Creates mock with different default answer & name
Foo mock = mock(Foo.class, withSettings()
.defaultAnswer(RETURNS_SMART_NULLS)
.name("cool mockie")); //Creates mock with different default answer, descriptive name and extra interfaces
Foo mock = mock(Foo.class, withSettings()
.defaultAnswer(RETURNS_SMART_NULLS)
.name("cool mockie")
.extraInterfaces(Bar.class));


    MockSettings已经出现了两个原因。首先，当需求到来时，很容易添加另一个模拟设置。其次，为了能够结合不同的模拟设置而不需要引入大量的重载模拟（）方法。

    查看javadoc MockSettings了解可能的模拟设置。

    返回：

    模拟设置实例与默认值。

  • 描述

    public static  VerificationMode  description（String  description）

    如果验证失败，则添加要打印的说明。

    
verify(mock, description("This will print on failure")).someMethod("some arg");


    参数：

    description - 描述打印失败。

    返回：

    验证模式

    以来：

    2.1.0

  • 骨架

    @Incubating
    公共静态  MockitoFramework  框架（）

    对于高级用户或框架集成商。见MockitoFramework课。

    以来：

    2.1.0

  • mockitoSession

    @Incubating
    public static  MockitoSessionBuilder  mockitoSession（）

    MockitoSession 是一个可选的强烈推荐的功能，通过消除样板代码和添加额外的验证来帮助推动清洁测试。