1 /* 2 * Copyright (c) 2007 Mockito contributors 3 * This program is made available under the terms of the MIT License. 4 */ 5 6 package org.mockito.verification; 7 8 import org.mockito.Mockito; 9 10 /** 11 * VerificationWithTimeout is a {@link VerificationMode} that allows combining existing verification modes with 'timeout'. E.g: 12 * 13 * <pre class="code"><code class="java"> 14 * verify(mock, timeout(100).times(5)).foo(); 15 * 16 * verify(mock, timeout(100).never()).bar(); 17 * 18 * verify(mock, timeout(200).atLeastOnce()).baz(); 19 * </code></pre> 20 * 21 * <p> 22 * See examples in javadoc for {@link Mockito#verify(Object, VerificationMode)} 23 */ 24 public interface VerificationWithTimeout extends VerificationMode { 25 26 /** 27 * Allows verifying exact number of invocations within given timeout 28 * <pre class="code"><code class="java"> 29 * verify(mock, timeout(100).times(2)).someMethod("some arg"); 30 * </code></pre> 31 * 32 * See examples in javadoc for {@link Mockito} class 33 * 34 * @param wantedNumberOfInvocations wanted number of invocations 35 * 36 * @return verification mode 37 */ times(int wantedNumberOfInvocations)38 public VerificationMode times(int wantedNumberOfInvocations); 39 40 /** 41 * Alias to times(0), see {@link #times(int)} 42 * <p> 43 * Verifies that interaction did not happen within given timeout. E.g: 44 * <pre class="code"><code class="java"> 45 * verify(mock, timeout(100).never()).someMethod(); 46 * </code></pre> 47 * 48 * <p> 49 * If you want to verify there were NO interactions with the mock 50 * check out {@link Mockito#verifyNoMoreInteractions(Object...)} 51 * <p> 52 * See examples in javadoc for {@link Mockito} class 53 * 54 * @return verification mode 55 */ never()56 public VerificationMode never(); 57 58 /** 59 * Allows at-least-once verification withing given timeout. E.g: 60 * <pre class="code"><code class="java"> 61 * verify(mock, timeout(100).atLeastOnce()).someMethod("some arg"); 62 * </code></pre> 63 * Alias to atLeast(1) 64 * <p> 65 * See examples in javadoc for {@link Mockito} class 66 * 67 * @return verification mode 68 */ atLeastOnce()69 public VerificationMode atLeastOnce(); 70 71 /** 72 * Allows at-least-x verification withing given timeout. E.g: 73 * <pre class="code"><code class="java"> 74 * verify(mock, timeout(100).atLeast(3)).someMethod("some arg"); 75 * </code></pre> 76 * 77 * See examples in javadoc for {@link Mockito} class 78 * 79 * @param minNumberOfInvocations minimum number of invocations 80 * 81 * @return verification mode 82 */ atLeast(int minNumberOfInvocations)83 public VerificationMode atLeast(int minNumberOfInvocations); 84 85 /** 86 * @deprecated 87 * 88 * <b>Deprecated</b> 89 * validation with timeout combined with atMost simply does not make sense... 90 * The test would have passed immediately in the concurrent environment 91 * <p> 92 * To avoid compilation erros upon upgrade the method is deprecated and it throws a "friendly reminder" exception. 93 * <p> 94 * In future release we will remove timeout(x).atMost(y) from the API. 95 * <p> 96 * Do you want to find out more? See <a href="http://code.google.com/p/mockito/issues/detail?id=235">issue 235</a> 97 * 98 * @return verification mode 99 */ 100 @Deprecated atMost(int maxNumberOfInvocations)101 public VerificationMode atMost(int maxNumberOfInvocations); 102 103 /** 104 * Allows checking if given method was the only one invoked. E.g: 105 * <pre class="code"><code class="java"> 106 * verify(mock, only()).someMethod(); 107 * //above is a shorthand for following 2 lines of code: 108 * verify(mock).someMethod(); 109 * verifyNoMoreInvocations(mock); 110 * </code></pre> 111 * 112 * <p> 113 * See also {@link Mockito#verifyNoMoreInteractions(Object...)} 114 * <p> 115 * See examples in javadoc for {@link Mockito} class 116 * 117 * @return verification mode 118 */ only()119 public VerificationMode only(); 120 }