Best Mockito code snippet using org.mockito.internal.verification.VerificationModeFactory
Source:Mockito.java  
2import org.mockito.internal.MockitoCore;3import org.mockito.internal.creation.MockSettingsImpl;4import org.mockito.internal.framework.DefaultMockitoFramework;5import org.mockito.internal.session.DefaultMockitoSessionBuilder;6import org.mockito.internal.verification.VerificationModeFactory;7import org.mockito.session.MockitoSessionBuilder;8import org.mockito.stubbing.Answer;9import org.mockito.stubbing.OngoingStubbing;10import org.mockito.stubbing.Stubber;11import org.mockito.verification.After;12import org.mockito.verification.Timeout;13import org.mockito.verification.VerificationAfterDelay;14import org.mockito.verification.VerificationMode;15import org.mockito.verification.VerificationWithTimeout;16import java.security.AccessController;17import java.security.PrivilegedAction;18/**19 * Wraps Mockito API with calls to AccessController.20 * This is useful if you want to mock in a SecurityManager environment,21 * but contain the permissions to only mocking test libraries.22 * <p>23 * Instead of:24 * <pre>25 * grant {26 *   permission java.lang.RuntimePermission "reflectionFactoryAccess";27 * };28 * </pre>29 * You can just change maven dependencies to use securemock.jar, and then:30 * <pre>31 * grant codeBase "/url/to/securemock.jar" {32 *   permission java.lang.RuntimePermission "reflectionFactoryAccess";33 * };34 * </pre>35 */36@SuppressWarnings("unchecked")37public class Mockito extends ArgumentMatchers {38    static final MockitoCore MOCKITO_CORE = new MockitoCore();39    public static final Answer<Object> RETURNS_DEFAULTS = Answers.RETURNS_DEFAULTS;40    public static final Answer<Object> RETURNS_SMART_NULLS = Answers.RETURNS_SMART_NULLS;41    public static final Answer<Object> RETURNS_MOCKS = Answers.RETURNS_MOCKS;42    public static final Answer<Object> RETURNS_DEEP_STUBS = Answers.RETURNS_DEEP_STUBS;43    public static final Answer<Object> CALLS_REAL_METHODS = Answers.CALLS_REAL_METHODS;44    public static final Answer<Object> RETURNS_SELF = Answers.RETURNS_SELF;45    public static <T> T mock(Class<T> classToMock) {46        T mockedClass = AccessController.doPrivileged((PrivilegedAction<T>) () ->47                mock(classToMock, withSettings()));48        if (mockedClass == null) {49            throw new IllegalStateException("unable to mock " + classToMock);50        }51        return mockedClass;52    }53    public static <T> T mock(final Class<T> classToMock, final String name) {54        return AccessController.doPrivileged((PrivilegedAction<T>) () ->55                mock(classToMock, withSettings()56                        .name(name)57                        .defaultAnswer(RETURNS_DEFAULTS)));58    }59    60    public static MockingDetails mockingDetails(final Object toInspect) {61        return AccessController.doPrivileged((PrivilegedAction<MockingDetails>) () ->62                MOCKITO_CORE.mockingDetails(toInspect));63    }64    public static <T> T mock(final Class<T> classToMock, final Answer defaultAnswer) {65        return AccessController.doPrivileged((PrivilegedAction<T>) () ->66                mock(classToMock, withSettings().defaultAnswer(defaultAnswer)));67    }68    69    public static <T> T mock(final Class<T> classToMock, final MockSettings mockSettings) {70        return AccessController.doPrivileged((PrivilegedAction<T>) () ->71                MOCKITO_CORE.mock(classToMock, mockSettings));72    }73    74    public static <T> T spy(final T object) {75        return AccessController.doPrivileged((PrivilegedAction<T>) () ->76                MOCKITO_CORE.mock((Class<T>) object.getClass(), withSettings()77                        .spiedInstance(object)78                        .defaultAnswer(CALLS_REAL_METHODS)));79    }80    public static <T> T spy(Class<T> classToSpy) {81        return AccessController.doPrivileged((PrivilegedAction<T>) () ->82                MOCKITO_CORE.mock(classToSpy, withSettings()83                .useConstructor()84                .defaultAnswer(CALLS_REAL_METHODS)));85    }86    public static <T> OngoingStubbing<T> when(final T methodCall) {87        return AccessController.doPrivileged((PrivilegedAction<OngoingStubbing<T>>) () ->88                MOCKITO_CORE.when(methodCall));89    }90    91    public static <T> T verify(final T mock) {92        return AccessController.doPrivileged((PrivilegedAction<T>) () ->93                MOCKITO_CORE.verify(mock, times(1)));94    }95    96    public static <T> T verify(final T mock, final VerificationMode mode) {97        return AccessController.doPrivileged((PrivilegedAction<T>) () ->98                MOCKITO_CORE.verify(mock, mode));99    }100    101    public static <T> void reset(final T ... mocks) {102        AccessController.doPrivileged((PrivilegedAction<Void>) () -> {103            MOCKITO_CORE.reset(mocks);104            return null;105        });106    }107    public static <T> void clearInvocations(T ... mocks) {108        AccessController.doPrivileged((PrivilegedAction<Void>) () -> {109            MOCKITO_CORE.clearInvocations(mocks);110            return null;111        });112    }113    public static void verifyNoMoreInteractions(final Object... mocks) {114        AccessController.doPrivileged((PrivilegedAction<Void>) () -> {115            MOCKITO_CORE.verifyNoMoreInteractions(mocks);116            return null;117        });118    }119    120    public static void verifyZeroInteractions(final Object... mocks) {121        AccessController.doPrivileged((PrivilegedAction<Void>) () -> {122            MOCKITO_CORE.verifyNoMoreInteractions(mocks);123            return null;124        });125    }126    127    public static Stubber doThrow(final Throwable... toBeThrown) {128        return AccessController.doPrivileged((PrivilegedAction<Stubber>) () ->129                MOCKITO_CORE.stubber().doThrow(toBeThrown));130    }131    132    public static Stubber doThrow(final Class<? extends Throwable> toBeThrown) {133        return AccessController.doPrivileged((PrivilegedAction<Stubber>) () ->134                MOCKITO_CORE.stubber().doThrow(toBeThrown));135    }136    public static Stubber doThrow(Class<? extends Throwable> toBeThrown, Class<? extends Throwable>... toBeThrownNext) {137        return AccessController.doPrivileged((PrivilegedAction<Stubber>) () ->138                MOCKITO_CORE.stubber().doThrow(toBeThrown, toBeThrownNext));139    }140    public static Stubber doCallRealMethod() {141        return AccessController.doPrivileged((PrivilegedAction<Stubber>) () ->142                MOCKITO_CORE.stubber().doCallRealMethod());143    }144    145    public static Stubber doAnswer(final Answer answer) {146        return AccessController.doPrivileged((PrivilegedAction<Stubber>) () ->147                MOCKITO_CORE.stubber().doAnswer(answer));148    }  149    150    public static Stubber doNothing() {151        return AccessController.doPrivileged((PrivilegedAction<Stubber>) () ->152                MOCKITO_CORE.stubber().doNothing());153    }154    155    public static Stubber doReturn(final Object toBeReturned) {156        return AccessController.doPrivileged((PrivilegedAction<Stubber>) () ->157                MOCKITO_CORE.stubber().doReturn(toBeReturned));158    }159    public static Stubber doReturn(Object toBeReturned, Object... toBeReturnedNext) {160        return  AccessController.doPrivileged((PrivilegedAction<Stubber>) () ->161                MOCKITO_CORE.stubber().doReturn(toBeReturned, toBeReturnedNext));162    }163    164    public static InOrder inOrder(final Object... mocks) {165        return AccessController.doPrivileged((PrivilegedAction<InOrder>) () ->166                MOCKITO_CORE.inOrder(mocks));167    }168    169    public static Object[] ignoreStubs(final Object... mocks) {170        return AccessController.doPrivileged((PrivilegedAction<Object[]>) () ->171                MOCKITO_CORE.ignoreStubs(mocks));172    }173    174    public static VerificationMode times(final int wantedNumberOfInvocations) {175        return AccessController.doPrivileged((PrivilegedAction<VerificationMode>) () ->176                VerificationModeFactory.times(wantedNumberOfInvocations));177    }178    179    public static VerificationMode never() {180        return AccessController.doPrivileged((PrivilegedAction<VerificationMode>) () ->181                times(0));182    }183    184    public static VerificationMode atLeastOnce() {185        return AccessController.doPrivileged((PrivilegedAction<VerificationMode>)186                VerificationModeFactory.atLeastOnce());187    }188    189    public static VerificationMode atLeast(final int minNumberOfInvocations) {190        return AccessController.doPrivileged((PrivilegedAction<VerificationMode>) () ->191                VerificationModeFactory.atLeast(minNumberOfInvocations));192    }193    194    public static VerificationMode atMost(final int maxNumberOfInvocations) {195        return AccessController.doPrivileged((PrivilegedAction<VerificationMode>) () ->196                VerificationModeFactory.atMost(maxNumberOfInvocations));197    }198    199    public static VerificationMode calls(final int wantedNumberOfInvocations) {200        return AccessController.doPrivileged((PrivilegedAction<VerificationMode>) () ->201                VerificationModeFactory.calls(wantedNumberOfInvocations));202    }203    204    public static VerificationMode only() {205        return AccessController.doPrivileged((PrivilegedAction<VerificationMode>)206                VerificationModeFactory::only);207    }208    209    public static VerificationWithTimeout timeout(final int millis) {210        return AccessController.doPrivileged((PrivilegedAction<VerificationWithTimeout>) () ->211                new Timeout(millis, VerificationModeFactory.times(1)));212    }213    public static VerificationAfterDelay after(long millis) {214        return AccessController.doPrivileged((PrivilegedAction<VerificationAfterDelay>) () ->215                new After(millis, VerificationModeFactory.times(1)));216    }217    218    public static void validateMockitoUsage() {219        AccessController.doPrivileged((PrivilegedAction<Void>) () -> {220            MOCKITO_CORE.validateMockitoUsage();221            return null;222        });223    }224    225    public static MockSettings withSettings() {226        return AccessController.doPrivileged((PrivilegedAction<MockSettings>) () ->227                new MockSettingsImpl().defaultAnswer(RETURNS_DEFAULTS));228    }229    public static VerificationMode description(String description) {...Source:CityService_UnitTest.java  
...4import org.junit.jupiter.api.extension.ExtendWith;5import org.mockito.InjectMocks;6import org.mockito.Mock;7import org.mockito.Mockito;8import org.mockito.internal.verification.VerificationModeFactory;9import org.mockito.junit.jupiter.MockitoExtension;10import tqsua.midterm_assignment.cache.Cache;11import tqsua.midterm_assignment.external_api.ExternalAPI;12import static org.assertj.core.api.AssertionsForClassTypes.assertThat;13@ExtendWith(MockitoExtension.class)14class CityService_UnitTest {15    @Mock(lenient = true)16    private Cache cache;17    @Mock(lenient = true)18    private ExternalAPI api;19    @InjectMocks20    private CityService service;21    @BeforeEach22    public void setUp() {23        Mockito.when(cache.getStates("USA")).thenReturn(new String[]{"Alaska", "Kansas"});24        Mockito.when(api.getStates("USA")).thenReturn(new String[]{"Alaska", "Kansas"});25        Mockito.when(cache.getStates("France")).thenReturn(new String[0]);26        Mockito.when(api.getStates("France")).thenReturn(new String[]{"Brittany", "Burgundy"});27        Mockito.when(cache.getCities("USA", "Alaska")).thenReturn(new String[]{"City1", "City2"});28        Mockito.when(api.getCities("USA", "Alaska")).thenReturn(new String[]{"City1", "City2"});29        Mockito.when(cache.getCities("France", "Brittany")).thenReturn(new String[0]);30        Mockito.when(api.getCities("France", "Brittany")).thenReturn(new String[]{"City1", "City2"});31        Mockito.when(cache.getStates("NotReal")).thenReturn(new String[0]);32        Mockito.when(api.getStates("NotReal")).thenReturn(new String[0]);33        Mockito.when(cache.getCities("NotReal","A")).thenReturn(new String[0]);34        Mockito.when(api.getCities("NotReal", "A")).thenReturn(new String[0]);35    }36    @Test37    void whenCountriesExistInCache_thenTheyShouldBeFoundOnTheCache() {38        String[] countries = new String[]{"USA", "France"};39        Mockito.when(cache.getCountries()).thenReturn(countries);40        Mockito.when(api.getCountries()).thenReturn(countries);41        String[] found = service.getCountries();42        assertThat(found).hasSize(2).contains("USA", "France");43        Mockito.verify(cache, VerificationModeFactory.times(1)).getCountries();44        Mockito.verify(api, VerificationModeFactory.times(0)).getCountries();45    }46    @Test47    void whenCountriesExistOnlyInExternalAPI_thenTheyShouldBeFoundOnTheAPI() {48        String[] countries = new String[]{"USA", "France"};49        Mockito.when(cache.getCountries()).thenReturn(new String[0]);50        Mockito.when(api.getCountries()).thenReturn(countries);51        String[] found = service.getCountries();52        assertThat(found).hasSize(2).contains("USA", "France");53        Mockito.verify(cache, VerificationModeFactory.times(1)).getCountries();54        Mockito.verify(api, VerificationModeFactory.times(1)).getCountries();55    }56    @Test57    void whenStatesExistInCache_thenTheyShouldBeFoundOnTheCache() {58        String[] found = service.getStates("USA");59        assertThat(found).hasSize(2).contains("Alaska", "Kansas");60        Mockito.verify(cache, VerificationModeFactory.times(1)).getStates("USA");61        Mockito.verify(api, VerificationModeFactory.times(0)).getStates("USA");62    }63    @Test64    void whenStatesExistOnlyInExternalAPI_thenTheyShouldBeFoundOnTheAPI() {65        String[] found = service.getStates("France");66        assertThat(found).hasSize(2).contains("Burgundy", "Brittany");67        Mockito.verify(cache, VerificationModeFactory.times(1)).getStates("France");68        Mockito.verify(api, VerificationModeFactory.times(1)).getStates("France");69    }70    @Test71    void whenCitiesExistInCache_thenTheyShouldBeFoundOnTheCache() {72        String[] found = service.getCities("USA", "Alaska");73        assertThat(found).hasSize(2).contains("City1", "City2");74        Mockito.verify(cache, VerificationModeFactory.times(1)).getCities("USA", "Alaska");75        Mockito.verify(api, VerificationModeFactory.times(0)).getCities("USA", "Alaska");76    }77    @Test78    void whenCitiesExistOnlyInExternalAPI_thenTheyShouldBeFoundOnTheAPI() {79        String[] found = service.getCities("France", "Brittany");80        assertThat(found).hasSize(2).contains("City1", "City2");81        Mockito.verify(cache, VerificationModeFactory.times(1)).getCities("France", "Brittany");82        Mockito.verify(api, VerificationModeFactory.times(1)).getCities("France", "Brittany");83    }84    @Test85    void whenCountryDoesNotExist_thenStatesShouldNotBeFound() {86        String[] found = service.getStates("NotReal");87        assertThat(found).isEmpty();88        Mockito.verify(cache, VerificationModeFactory.times(1)).getStates("NotReal");89        Mockito.verify(api, VerificationModeFactory.times(1)).getStates("NotReal");90    }91    @Test92    void whenStateOrCountryDoesNotExist_thenCitiesShouldNotBeFound() {93        String[] found = service.getCities("NotReal", "A");94        assertThat(found).isEmpty();95        Mockito.verify(cache, VerificationModeFactory.times(1)).getCities("NotReal", "A");96        Mockito.verify(api, VerificationModeFactory.times(1)).getCities("NotReal", "A");97    }98}...Source:AirQualityService_UnitTest.java  
...4import org.junit.jupiter.api.extension.ExtendWith;5import org.mockito.InjectMocks;6import org.mockito.Mock;7import org.mockito.Mockito;8import org.mockito.internal.verification.VerificationModeFactory;9import org.mockito.junit.jupiter.MockitoExtension;10import tqsua.midterm_assignment.cache.Cache;11import tqsua.midterm_assignment.external_api.ExternalAPI;12import tqsua.midterm_assignment.model.AirQuality;13import static org.assertj.core.api.AssertionsForClassTypes.assertThat;14@ExtendWith(MockitoExtension.class)15class AirQualityService_UnitTest {16    @Mock(lenient = true)17    private Cache cache;18    @Mock(lenient = true)19    private ExternalAPI api;20    @InjectMocks21    private AirQualityService service;22    @BeforeEach23    void setUp() {24        AirQuality aq = new AirQuality(30,40,41,"p1","p2");25        Mockito.when(cache.getAirQuality("France", "Brittany", "Quimper")).thenReturn(aq);26        Mockito.when(api.getAirQuality("France", "Brittany", "Quimper")).thenReturn(aq);27        Mockito.when(cache.getAirQuality("France", "Burgundy", "Burgundy")).thenReturn(null);28        Mockito.when(api.getAirQuality("France", "Burgundy", "Burgundy")).thenReturn(aq);29        Mockito.when(cache.getAirQuality("USA", "Alaska", "City1")).thenReturn(null);30        Mockito.when(api.getAirQuality("USA", "Alaska", "City1")).thenReturn(null);31        Mockito.when(cache.getCount()).thenReturn(3);32        Mockito.when(cache.getMisses()).thenReturn(2);33        Mockito.when(cache.getHits()).thenReturn(1);34    }35    @Test36    void whenAirQualityExistsInCache_thenItShouldBeFoundOnTheCache() {37        AirQuality found = service.getAirQualityByCity("France", "Brittany", "Quimper");38        assertThat(found.getHumidity()).isEqualTo(30);39        Mockito.verify(cache, VerificationModeFactory.times(1)).getAirQuality("France", "Brittany", "Quimper");40        Mockito.verify(api, VerificationModeFactory.times(0)).getAirQuality("France", "Brittany", "Quimper");41    }42    @Test43    void whenAirQualityExistsOnlyInExternalAPI_thenItShouldBeFoundOnTheAPI() {44        AirQuality found = service.getAirQualityByCity("France", "Burgundy", "Burgundy");45        assertThat(found.getHumidity()).isEqualTo(30);46        Mockito.verify(cache, VerificationModeFactory.times(1)).getAirQuality("France", "Burgundy", "Burgundy");47        Mockito.verify(api, VerificationModeFactory.times(1)).getAirQuality("France", "Burgundy", "Burgundy");48    }49    @Test50    void whenAirQualityDoesNotExist_thenItShouldNotBeFound() {51        AirQuality found = service.getAirQualityByCity("USA","Alaska", "City1");52        assertThat(found).isNull();53        Mockito.verify(cache, VerificationModeFactory.times(1)).getAirQuality("USA", "Alaska", "City1");54        Mockito.verify(api, VerificationModeFactory.times(1)).getAirQuality("USA", "Alaska", "City1");55    }56    @Test57    void whenGettingStatistics_thenItShouldReturnStatistics() {58        assertThat(service.getStatistics()).hasFieldOrPropertyWithValue("count", 3);59        assertThat(service.getStatistics()).hasFieldOrPropertyWithValue("misses", 2);60        assertThat(service.getStatistics()).hasFieldOrPropertyWithValue("hits", 1);61        Mockito.verify(cache, VerificationModeFactory.times(3)).getCount();62        Mockito.verify(cache, VerificationModeFactory.times(3)).getMisses();63        Mockito.verify(cache, VerificationModeFactory.times(3)).getHits();64    }65}...Source:CityServiceTest.java  
...11import org.junit.Test;12import org.junit.runner.RunWith;13import org.mockito.Mock;14import org.mockito.Mockito;15import org.mockito.internal.verification.VerificationModeFactory;16import org.mockito.runners.MockitoJUnitRunner;17@RunWith(MockitoJUnitRunner.class)18public class CityServiceTest {19    @Mock20    private CityDao cityDao;21    private CityService cityService;22    private CityEntity moscow;23    private CityEntity tver;24    private CityEntity pskov;25    @Before26    public void setup() {27        cityService = new CityServiceImpl(cityDao);28        prefillTestData();29        defineMocks();30    }31    @Test32    public void addCity() throws DuplicateCityException {33        CityRecord newCity = new CityRecord();34        newCity.setName("СанкÑ-ÐеÑеÑбÑÑг");35        cityService.add(newCity);36        Mockito.verify(cityDao, VerificationModeFactory.times(1)).add(Mockito.any(CityEntity.class));37    }38    @Test(expected = DuplicateCityException.class)39    public void addDuplicateCity() throws DuplicateCityException {40        CityRecord newCity = new CityRecord();41        newCity.setName("ÐоÑква");42        cityService.add(newCity);43        Mockito.verify(cityDao, VerificationModeFactory.times(1)).add(Mockito.any(CityEntity.class));44    }45    @Test46    public void findById() {47        CityEntity city = cityService.findById(1L);48        Assert.assertEquals(moscow, city);49    }50    @Test (expected = EntityNotFoundException.class)51    public void findNonexistentCityById() {52        cityService.findById(100L);53    }54    @Test55    public void removeCity() {56        cityService.remove(1L);57        Mockito.verify(cityDao, VerificationModeFactory.times(1)).remove(moscow);58    }59    @Test (expected = EntityNotFoundException.class)60    public void removeNonexistentCity() {61        cityService.remove(100L);62    }63    @Test64    public void listAll() {65        cityService.listAll();66        Mockito.verify(cityDao, VerificationModeFactory.times(1)).listAll();67    }68    private void prefillTestData () {69        moscow = new CityEntity();70        moscow.setId(1);71        moscow.setName("ÐоÑква");72        tver = new CityEntity();73        tver.setId(2);74        tver.setName("ТвеÑÑ");75        pskov = new CityEntity();76        pskov.setId(6);77        pskov.setName("ÐÑков");78    }79    private void defineMocks() {80        Mockito.when(cityDao.findById(1L)).thenReturn(moscow);...Source:MockingProgressImplTest.java  
...7import org.junit.Test;8import org.mockito.exceptions.base.MockitoException;9import org.mockito.internal.creation.MockSettingsImpl;10import org.mockito.internal.listeners.MockingStartedListener;11import org.mockito.internal.verification.VerificationModeFactory;12import org.mockito.verification.VerificationMode;13import org.mockitoutil.TestBase;14import java.util.List;15import static org.mockito.Matchers.eq;16import static org.mockito.Matchers.notNull;17import static org.mockito.Mockito.mock;18import static org.mockito.Mockito.verify;19public class MockingProgressImplTest extends TestBase {20    private MockingProgress mockingProgress;21    @Before22    public void setup() {23        mockingProgress = new MockingProgressImpl();24    }25    26    @Test27    public void shouldStartVerificationAndPullVerificationMode() throws Exception {28        assertNull(mockingProgress.pullVerificationMode());29        30        VerificationMode mode = VerificationModeFactory.times(19);31        32        mockingProgress.verificationStarted(mode);33        34        assertSame(mode, mockingProgress.pullVerificationMode());35        36        assertNull(mockingProgress.pullVerificationMode());37    }38    39    @Test40    public void shouldCheckIfVerificationWasFinished() throws Exception {41        mockingProgress.verificationStarted(VerificationModeFactory.atLeastOnce());42        try {43            mockingProgress.verificationStarted(VerificationModeFactory.atLeastOnce());44            fail();45        } catch (MockitoException e) {}46    }47    @Test48    public void shouldNotifyListenerWhenMockingStarted() throws Exception {49        //given50        MockingStartedListener listener = mock(MockingStartedListener.class);51        mockingProgress.setListener(listener);52        //when53        mockingProgress.mockingStarted("foo", List.class);54        //then55        verify(listener).mockingStarted(eq("foo"), eq(List.class));56    }57    @Test...Source:Timeout.java  
...3 * This program is made available under the terms of the MIT License.4 */5package org.mockito.verification;67import org.mockito.internal.verification.VerificationModeFactory;8import org.mockito.internal.verification.VerificationWithTimeoutImpl;9import org.mockito.internal.verification.api.VerificationData;1011/**12 * See the javadoc for {@link VerificationWithTimeout}13 */14public class Timeout implements VerificationWithTimeout {1516    VerificationWithTimeoutImpl impl;1718    /**19     * See the javadoc for {@link VerificationWithTimeout}20     */21    public Timeout(int millis, VerificationMode delegate) {22        this(10, millis, delegate);23    }2425    Timeout(int treshhold, int millis, VerificationMode delegate) {26        this.impl = new VerificationWithTimeoutImpl(treshhold, millis, delegate);27    }2829    public void verify(VerificationData data) {30        impl.verify(data);31    }3233    public VerificationMode atLeast(int minNumberOfInvocations) {34        return new Timeout(impl.getTreshhold(), impl.getTimeout(), VerificationModeFactory.atLeast(minNumberOfInvocations));35    }3637    public VerificationMode atLeastOnce() {38        return new Timeout(impl.getTreshhold(), impl.getTimeout(), VerificationModeFactory.atLeastOnce());39    }4041    public VerificationMode atMost(int maxNumberOfInvocations) {42        return new Timeout(impl.getTreshhold(), impl.getTimeout(), VerificationModeFactory.atMost(maxNumberOfInvocations));43    }4445    public VerificationMode never() {46        return new Timeout(impl.getTreshhold(), impl.getTimeout(), VerificationModeFactory.times(0));47    }4849    public VerificationMode only() {50        return new Timeout(impl.getTreshhold(), impl.getTimeout(), VerificationModeFactory.only());51    }5253    public VerificationMode times(int wantedNumberOfInvocations) {54        return new Timeout(impl.getTreshhold(), impl.getTimeout(), VerificationModeFactory.times(wantedNumberOfInvocations));55    }
...Source:VerificationWrapper.java  
...18    protected abstract VerificationMode copySelfWithNewVerificationMode(19            VerificationMode verificationMode);20    public VerificationMode times(int wantedNumberOfInvocations) {21        return copySelfWithNewVerificationMode(22                VerificationModeFactory.times(wantedNumberOfInvocations));23    }24    public VerificationMode never() {25        return copySelfWithNewVerificationMode(VerificationModeFactory.atMost(0));26    }27    public VerificationMode atLeastOnce() {28        return copySelfWithNewVerificationMode(VerificationModeFactory.atLeastOnce());29    }30    public VerificationMode atLeast(int minNumberOfInvocations) {31        return copySelfWithNewVerificationMode(32                VerificationModeFactory.atLeast(minNumberOfInvocations));33    }34    public VerificationMode atMostOnce() {35        return copySelfWithNewVerificationMode(VerificationModeFactory.atMostOnce());36    }37    public VerificationMode atMost(int maxNumberOfInvocations) {38        return copySelfWithNewVerificationMode(39                VerificationModeFactory.atMost(maxNumberOfInvocations));40    }41    public VerificationMode only() {42        return copySelfWithNewVerificationMode(VerificationModeFactory.only());43    }44}...VerificationModeFactory
Using AI Code Generation
1package com.automationrhapsody.mockito;2import static org.mockito.Mockito.mock;3import static org.mockito.Mockito.verify;4import static org.mockito.Mockito.times;5import static org.mockito.Mockito.atLeastOnce;6import static org.mockito.Mockito.atLeast;7import static org.mockito.Mockito.atMost;8import static org.mockito.Mockito.never;9import static org.mockito.Mockito.only;10import static org.mockito.Mockito.after;11import static org.mockito.Mockito.timeout;12import static org.mockito.Mockito.inOrder;13import static org.mockito.Mockito.after;14import static org.mockito.Mockito.timeout;15import static org.mockito.Mockito.inOrder;16import static org.mockito.MoVerificationModeFactory
Using AI Code Generation
1package org.mockito;2import org.mockito.internal.verification.VerificationModeFactory;3import org.mockito.invocation.InvocationOnMock;4import org.mockito.stubbing.Answer;5import java.util.ArrayList;6import java.util.List;7import static org.mockito.Mockito.*;8public class Mockito1 {9    public static void main(String[] args) {10        List mockedList = mock(List.class);11        mockedList.add("one");12        mockedList.clear();13        verify(mockedList).add("one");14        verify(mockedList).clear();15        verify(mockedList, times(1)).add("one");16        verify(mockedList, times(1)).clear();17        verify(mockedList, times(2)).add("one");18        verify(mockedList, times(2)).clear();19        verify(mockedList, times(2)).add("one");20        verify(mockedList, times(2)).clear();21        when(mockedList.get(0)).thenReturn("first");22        when(mockedList.get(1)).thenThrow(new RuntimeException());23        System.out.println(mockedList.get(0));24        System.out.println(mockedList.get(1));25        System.out.println(mockedList.get(999));26        verify(mockedList).get(0);27        when(mockedList.get(anyInt())).thenReturn("element");28        verify(mockedList).get(anyInt());29        verify(mockedList, times(1)).get(0);30        verify(mockedList, atLeastOnce()).get(0);31        verify(mockedList, atLeast(2)).get(0);32        verify(mockedList, atMost(5)).get(0);33        verify(mockedList, never()).get(2);34        when(mockedList.get(anyIntVerificationModeFactory
Using AI Code Generation
1import org.mockito.internal.verification.VerificationModeFactory;2verify(mock, VerificationModeFactory.times(2)).method();3verify(mock, VerificationModeFactory.atLeastOnce()).method();4verify(mock, VerificationModeFactory.atLeast(2)).method();5verify(mock, VerificationModeFactory.atMost(2)).method();6verify(mock, VerificationModeFactory.only()).method();7verify(mock, VerificationModeFactory.noMoreInteractions()).method();8verify(mock, VerificationModeFactory.noInteractions()).method();9verify(mock, VerificationModeFactory.calls(2)).method();10verify(mock, VerificationModeFactory.never()).method();11verify(mock, VerificationModeFactory.timeout(100)).method();12verify(mock, VerificationModeFactory.timeout(100).times(2)).method();13verify(mock, VerificationModeFactory.timeout(100).atLeastOnce()).method();14verify(mock, VerificationModeFactory.timeout(100).atLeast(2)).method();15verify(mock, VerificationModeFactory.timeout(100).atMost(2)).method();16verify(mock, VerificationModeFactory.timeout(100).only()).method();17verify(mock, VerificationModeFactory.timeout(100).noMoreInteractions()).method();18verify(mock, VerificationModeFactory.timeout(100).noInteractions()).method();19verify(mock, VerificationModeFactory.timeout(100).calls(2)).method();20verify(mock, VerificationModeFactory.timeout(100).never()).method();21import org.mockito.verification.VerificationModeFactory;22verify(mock, VerificationModeFactory.times(2)).method();23verify(mock, VerificationModeFactory.atLeastOnce()).method();24verify(mock, VerificationModeFactory.atLeast(2)).method();25verify(mock, VerificationModeFactory.atMost(2)).method();26verify(mock, VerificationModeFactory.only()).method();27verify(mock, VerificationModeFactory.noMoreInteractions()).method();28verify(mock, VerificationModeFactory.noInteractions()).method();29verify(mock, VerificationModeFactory.calls(2)).method();30verify(mock, VerificationModeFactory.never()).method();31verify(mock, VerificationModeFactory.timeout(100)).method();32verify(mock, VerificationModeFactory.timeout(100).times(2)).method();33verify(mock, VerificationModeFactory.timeout(100).atLeastOnce()).method();34verify(mock, VerificationModeFactory.timeout(100).atLeast(2)).method();35verify(mock, VerificationModeFactory.timeout(100).atMost(2)).method();36verify(mock, VerificationModeFactory.timeout(100).onlyVerificationModeFactory
Using AI Code Generation
1import org.mockito.internal.verification.VerificationModeFactory;2import org.mockito.verification.VerificationMode;3public class VerificationModeFactoryTest {4    public static void main(String[] args) {5        VerificationModeFactoryTest verificationModeFactoryTest = new VerificationModeFactoryTest();6        verificationModeFactoryTest.testAtLeastOnce();7        verificationModeFactoryTest.testAtLeast();8        verificationModeFactoryTest.testAtMost();9        verificationModeFactoryTest.testNever();10        verificationModeFactoryTest.testTimes();11        verificationModeFactoryTest.testNoMoreInteractions();12    }13    public void testAtLeastOnce() {14        VerificationMode atLeastOnce = VerificationModeFactory.atLeastOnce();15        System.out.println("atLeastOnce: " + atLeastOnce);16    }17    public void testAtLeast() {18        VerificationMode atLeast = VerificationModeFactory.atLeast(2);19        System.out.println("atLeast: " + atLeast);20    }21    public void testAtMost() {22        VerificationMode atMost = VerificationModeFactory.atMost(3);23        System.out.println("atMost: " + atMost);24    }25    public void testNever() {26        VerificationMode never = VerificationModeFactory.never();27        System.out.println("never: " + never);28    }29    public void testTimes() {30        VerificationMode times = VerificationModeFactory.times(4);31        System.out.println("times: " + times);32    }33    public void testNoMoreInteractions() {34        VerificationMode noMoreInteractions = VerificationModeFactory.noMoreInteractions();35        System.out.println("noMoreInteractions: " + noMoreInteractions);36    }37}VerificationModeFactory
Using AI Code Generation
1package com.automationtesting.mockitotest;2import static org.mockito.Mockito.*;3import org.mockito.internal.verification.VerificationModeFactory;4import org.junit.Test;5public class VerificationModeFactoryTest {6    public void testVerificationModeFactory() {7        MyTest mock = mock(MyTest.class);8        mock.testing(12);9        verify(mock, VerificationModeFactory.times(1)).testing(12);10        verify(mock, VerificationModeFactory.times(2)).testing(12);11    }12}13package com.automationtesting.mockitotest;14import static org.mockito.Mockito.*;15import org.mockito.internal.verification.VerificationModeFactory;16import org.junit.Test;17public class VerificationModeFactoryTest {18    public void testVerificationModeFactory() {19        MyTest mock = mock(MyTest.class);20        mock.testing(12);21        verify(mock, VerificationModeFactory.times(1)).testing(12);22        verify(mock, VerificationModeFactory.times(2)).testing(12);23    }24}25package com.automationtesting.mockitotest;26import static org.mockito.Mockito.*;27import org.mockito.internal.verification.VerificationModeFactory;28import org.junit.Test;29public class VerificationModeFactoryTest {30    public void testVerificationModeFactory() {31        MyTest mock = mock(MyTest.class);32        mock.testing(12);33        verify(mock, VerificationModeFactory.times(1)).testing(12);34        verify(mock, VerificationModeFactory.times(2)).testing(12);35    }36}VerificationModeFactory
Using AI Code Generation
1import org.mockito.internal.verification.VerificationModeFactory;2import static org.mockito.Mockito.*;3{4public static void main(String args[])5{6List mockedList = mock(List.class);7mockedList.add("one");8mockedList.clear();9verify(mockedList).add("one");10verify(mockedList).clear();11}12}13-> at 1.main(1.java:17)14-> at 1.main(1.java:16)15verify(mock).foo(anyObject(), "raw String");16verify(mock).foo(anyObject(), eq("String by matcher"));17verify(mock).foo(anyObject(), "raw String");18verify(mock).foo(anyObject(), eq("String by matcher"));19public class Calculator {20    public int add(int a, int b) {21        return a + b;22    }23}24public class CalculatorTest {25    public void testAdd() {26        Calculator calculator = mock(Calculator.class);27        when(calculator.add(1, 2)).thenReturn(3);28        assertEquals(3, calculator.add(1, 2));29        verify(calculator).add(1, 2);30    }31}VerificationModeFactory
Using AI Code Generation
1package org.mockito.examples;2import org.mockito.Mock;3import org.mockito.Mockito;4import org.mockito.MockitoAnnotations;5import org.mockito.internal.verification.VerificationModeFactory;6import static org.mockito.Mockito.*;7import java.util.List;8public class VerificationModeFactoryExample {9    private List mockedList;10    public static void main(String[] args) {11        VerificationModeFactoryExample verificationModeFactoryExample = new VerificationModeFactoryExample();12        verificationModeFactoryExample.testVerificationModeFactory();13    }14    public void testVerificationModeFactory() {15        MockitoAnnotations.initMocks(this);16        mockedList.add("one");17        mockedList.add("two");18        mockedList.add("two");19        mockedList.add("three");20        mockedList.add("three");VerificationModeFactory
Using AI Code Generation
1import org.mockito.internal.verification.VerificationModeFactory;2import static org.mockito.Mockito.*;3import org.junit.Test;4import org.mockito.Mock;5import org.mockito.MockitoAnnotations;6import static org.junit.Assert.*;7import java.util.*;8import java.util.List;9public class Test1 {10    private List mockedList;11    public void test1() {12        MockitoAnnotations.initMocks(this);13        mockedList.add("one");14        mockedList.clear();15        verify(mockedList).add("one");16        verify(mockedList).clear();17        verify(mockedList, times(1)).add("one");18        verify(mockedList, times(1)).clear();19        verify(mockedList, atLeastOnce()).add("one");20        verify(mockedList, atLeastOnce()).clear();21        verify(mockedList, atLeast(1)).add("one");22        verify(mockedList, atLeast(1)).clear();23        verify(mockedList, atMost(2)).add("one");24        verify(mockedList, atMost(2)).clear();25        verify(mockedList, VerificationModeFactory.times(1)).add("one");26        verify(mockedList, VerificationModeFactory.times(1)).clear();27        verify(mockedList, VerificationModeFactory.atLeastOnce()).add("one");28        verify(mockedList, VerificationModeFactory.atLeastOnce()).clear();29        verify(mockedList, VerificationModeFactory.atLeast(1)).add("one");30        verify(mockedList, VerificationModeFactory.atLeast(1)).clear();31        verify(mockedList, VerificationModeFactory.atMost(2)).add("one");32        verify(mockedList, VerificationModeFactory.atMost(2)).clear();33    }34}35public class TestClass {36    private static final TestClass INSTANCE = new TestClass();37    private TestClass() {38    }39    public static TestClass getInstance() {40        return INSTANCE;41    }42    public void testMethod() {43        System.out.println("testMethod");44    }45}46TestClass tc = Mockito.mock(TestClass.class);VerificationModeFactory
Using AI Code Generation
1import org.mockito.internal.verification.VerificationModeFactory;2import static org.mockito.Mockito.*;3import java.util.List;4public class 1 {5   public static void main(String args[]) {6      List mockedList = mock(List.class);7      mockedList.add("one");8      mockedList.clear();9      verify(mockedList).add("one");10      verify(mockedList).clear();11      verify(mockedList, VerificationModeFactory.times(1)).add("one");12      verify(mockedList, VerificationModeFactory.times(1)).clear();13   }14}15list.add("one");16-> at 1.main(1.java:15)17-> at 1.main(1.java:12)18list.clear();19-> at 1.main(1.java:16)20-> at 1.main(1.java:13)21list.add("one");22-> at 1.main(1.java:17)23-> at 1.main(1.java:12)24list.clear();25-> at 1.main(1.java:18)26-> at 1.main(1.java:13)Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.
You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.
Get 100 minutes of automation test minutes FREE!!
