@Test public void testDoesNotPutNullBitmapAcquiredFromPool() { reset(pool); when(pool.get(anyInt(), anyInt(), any(Bitmap.Config.class))).thenReturn(null); centerCrop.transform(context, resource, 100, 100); verify(pool, never()).put(any(Bitmap.class)); }
private void resetOutsideWorldMock() { reset( out ); when( out.fileSystem() ).thenReturn( fileSystem ); } }
void verifyAllMessagesCommitted(long messageCount) { verify(consumerSpy).commitSync(commitCapture.capture()); final Map<TopicPartition, OffsetAndMetadata> commits = commitCapture.getValue(); assertThat("Expected commits for only one topic partition", commits.entrySet().size(), is(1)); OffsetAndMetadata offset = commits.entrySet().iterator().next().getValue(); assertThat("Expected committed offset to cover all emitted messages", offset.offset(), is(messageCount)); reset(consumerSpy); } }
@Test public void tryCheckPointShouldWaitTheCurrentCheckPointingToCompleteNoRunCheckPointButUseTheTxIdOfTheEarlierRun() throws Throwable { // Given Lock lock = mock( Lock.class ); final CheckPointerImpl checkPointing = checkPointer( mutex( lock ) ); mockTxIdStore(); checkPointing.forceCheckPoint( INFO ); verify( appender ).checkPoint( eq( logPosition ), any( LogCheckPointEvent.class ) ); reset( appender ); checkPointing.tryCheckPoint( INFO ); verifyNoMoreInteractions( appender ); }
@Test public void transferMigratedIndexesToStoreDirectory() throws IOException { ExplicitIndexProvider indexProviders = getExplicitIndexProvider(); ExplicitIndexMigrator indexMigrator = new TestExplicitIndexMigrator( fs, indexProviders, logProvider, true ); indexMigrator.migrate( storeLayout, migrationLayout, progressMonitor, StandardV2_3.STORE_VERSION, StandardV3_0.STORE_VERSION ); reset( fs ); indexMigrator.moveMigratedFiles( migrationLayout, storeLayout, "any", "any" ); verify( fs ).deleteRecursively( originalIndexStore ); verify( fs ).moveToDirectory( migratedIndexStore, storeLayout.databaseDirectory() ); }
@Test public void testFailingTransitionGoesToLowestStatus() throws Exception { final LifeCycled mock = mock(LifeCycled.class); InternalCache ehcache = getCache(mock(Store.class)); doThrow(new Exception()).when(mock).init(); ehcache.addHook(mock); try { ehcache.init(); fail(); } catch (StateTransitionException e) { assertThat(ehcache.getStatus(), is(Status.UNINITIALIZED)); } reset(mock); ehcache.init(); assertThat(ehcache.getStatus(), is(Status.AVAILABLE)); ehcache.close(); }
@Test public void shouldResumeTransactionWhenExecutingStatementsOnSecondRequest() throws Exception TransitionalTxManagementKernelTransaction transactionContext = kernel.newTransaction( explicit, AUTH_DISABLED, -1); TransactionRegistry registry = mock( TransactionRegistry.class ); QueryExecutionEngine executionEngine = mock( QueryExecutionEngine.class ); TransactionalContext transactionalContext = prepareKernelWithQuerySession( kernel ); when( registry.begin( any( TransactionHandle.class ) ) ).thenReturn( 1337L ); TransactionHandle handle = getTransactionHandle( kernel, executionEngine, registry ); ExecutionResultSerializer output = mock( ExecutionResultSerializer.class ); mock( HttpServletRequest.class ) ); reset( transactionContext, registry, executionEngine, output ); Result executionResult = mock( Result.class ); when( executionEngine.executeQuery( "query", NO_PARAMS, transactionalContext ) ).thenReturn( executionResult );
@Test public void onServerStart_has_no_effect_if_called_twice_to_support_medium_test_doing_startup_tasks_multiple_times() { underTest.onServerStart(server); reset(processingScheduler, cleaningScheduler); underTest.onServerStart(server); verifyZeroInteractions(processingScheduler, cleaningScheduler); } }
@Override protected boolean processInjection(Field field, Object fieldOwner, Set<Object> mockCandidates) { FieldReader fieldReader = new FieldReader(fieldOwner, field); // TODO refoctor : code duplicated in SpyAnnotationEngine if(!fieldReader.isNull() && field.isAnnotationPresent(Spy.class)) { try { Object instance = fieldReader.read(); if (MockUtil.isMock(instance)) { // A. instance has been spied earlier // B. protect against multiple use of MockitoAnnotations.initMocks() Mockito.reset(instance); } else { Object mock = Mockito.mock(instance.getClass(), withSettings() .spiedInstance(instance) .defaultAnswer(Mockito.CALLS_REAL_METHODS) .name(field.getName())); setField(fieldOwner, field, mock); } } catch (Exception e) { throw new MockitoException("Problems initiating spied field " + field.getName(), e); } } return false; } }
@Test public void scheduleDrainBuffers() { Executor executor = Mockito.mock(Executor.class); BoundedLocalCache<?, ?> cache = new BoundedLocalCache<Object, Object>( Caffeine.newBuilder().executor(executor), /* loader */ null, /* async */ false) {}; Map<Integer, Integer> transitions = ImmutableMap.of( IDLE, PROCESSING_TO_IDLE, REQUIRED, PROCESSING_TO_IDLE, PROCESSING_TO_IDLE, PROCESSING_TO_IDLE, PROCESSING_TO_REQUIRED, PROCESSING_TO_REQUIRED); transitions.forEach((start, end) -> { cache.drainStatus = start; cache.scheduleDrainBuffers(); assertThat(cache.drainStatus, is(end)); if (!start.equals(end)) { Mockito.verify(executor).execute(any()); Mockito.reset(executor); } }); }
private void verifyNoRedirection(String requestUrl, @Nullable String queryString) throws IOException, ServletException { when(request.getRequestURI()).thenReturn(requestUrl); when(request.getQueryString()).thenReturn(queryString); when(request.getParameter(anyString())).thenReturn(null); underTest.doFilter(request, response, chain); verify(chain).doFilter(request, response); verifyZeroInteractions(response); reset(response, chain); } }
@Test @SuppressWarnings("unchecked") public void testSimpleRemove2ArgsWithLoaderAndWriter_existsInStore() throws Exception { testCache.put(1, "un"); reset(cacheLoaderWriter); assertThat(testCache.remove(1, "un"), is(true)); verify(cacheLoaderWriter, times(1)).delete(eq(1)); verifyNoMoreInteractions(cacheLoaderWriter); }
@Test public void create_or_get_tries_get_first() throws Exception { reset(dao); dao.createOrGet(new ScimGroup("openid"), IdentityZone.getUaa().getId()); verify(dao, times(1)).getByName("openid", IdentityZone.getUaa().getId()); verify(dao, never()).createAndIgnoreDuplicate(anyString(), anyString()); }
@Test public void testBuffering01() throws Exception { setUp("name", 0); final LogEvent event1 = mock(LogEvent.class); final LogEvent event2 = mock(LogEvent.class); final LogEvent event3 = mock(LogEvent.class); manager.startup(); then(manager).should().startupInternal(); reset(manager); manager.write(event1, null); then(manager).should().connectAndStart(); then(manager).should().writeInternal(same(event1), (Serializable) isNull()); then(manager).should().commitAndClose(); reset(manager); manager.write(event2, null); then(manager).should().connectAndStart(); then(manager).should().writeInternal(same(event2), (Serializable) isNull()); then(manager).should().commitAndClose(); reset(manager); manager.write(event3, null); then(manager).should().connectAndStart(); then(manager).should().writeInternal(same(event3), (Serializable) isNull()); then(manager).should().commitAndClose(); then(manager).shouldHaveNoMoreInteractions(); }
@Test public void execute_calls_interrupter_with_current_thread_before_each_step() throws Throwable { executeCallsInterrupterWithCurrentThreadBeforeEachStep(); reset(computationStep1, computationStep2, computationStep3, taskInterrupter); runInOtherThread(this::executeCallsInterrupterWithCurrentThreadBeforeEachStep); }
private void resetOutsideWorldMock() { reset(out); when( out.fileSystem() ).thenReturn( fileSystem ); } }
private Message<String> startSession(String id) { this.messageHandler.start(); Message<String> connectMessage = createConnectMessage(id, new TestPrincipal("joe"), null); this.messageHandler.setTaskScheduler(this.taskScheduler); this.messageHandler.handleMessage(connectMessage); verify(this.clientOutChannel, times(1)).send(this.messageCaptor.capture()); reset(this.clientOutChannel); return connectMessage; }
private void verifyRedirection(String requestUrl, @Nullable String queryString, String expectedRedirection) throws Exception { when(request.getRequestURI()).thenReturn(requestUrl); when(request.getQueryString()).thenReturn(queryString); underTest.doFilter(request, response, chain); verify(response).sendRedirect(expectedRedirection); verifyZeroInteractions(chain); reset(response, chain); }