Java OngoingStubbing类代码示例

import org.mockito.stubbing.OngoingStubbing; //导入依赖的package包/类
@Test
public void test() {
    String pattern = "test\\.test\\..*";

    MetricRegexFilter filter = new MetricRegexFilter(pattern);

    assertEquals(pattern, filter.getPattern());

    OngoingStubbing<String> stub = when(mock(Metric.class).name());

    assertTrue(filter.accept(stub.thenReturn("test.test.1").getMock()));
    assertTrue(filter.accept(stub.thenReturn("test.test.2").getMock()));

    assertFalse(filter.accept(stub.thenReturn("test1").getMock()));
    assertFalse(filter.accept(stub.thenReturn("test1test.2").getMock()));
    assertFalse(filter.accept(stub.thenReturn("invalid").getMock()));
    assertFalse(filter.accept(stub.thenReturn("invalid.test").getMock()));
}
 

import org.mockito.stubbing.OngoingStubbing; //导入依赖的package包/类
private void mockBucketResponses(final int count, final TagValue... tagValues) {
    when(element.getName()).thenReturn(
        new QName("", IdolParametricValuesServiceImpl.VALUES_NODE_NAME),
        new QName("", IdolParametricValuesServiceImpl.VALUE_NODE_NAME)
    );

    OngoingStubbing<Serializable> stub = when(element.getValue()).thenReturn(count);

    for(final TagValue tagValue : tagValues) {
        stub = stub.thenReturn(tagValue);
    }

    final GetQueryTagValuesResponseData responseData = new GetQueryTagValuesResponseData();
    final FlatField field2 = new FlatField();
    field2.getName().add("ParametricNumericDateField");
    field2.getValueAndSubvalueOrValues().add(element);
    for(final TagValue ignored : tagValues) {
        field2.getValueAndSubvalueOrValues().add(element);
    }
    responseData.getField().add(field2);

    when(queryExecutor.executeGetQueryTagValues(any(AciParameters.class), any())).thenReturn(responseData);
}
 

import org.mockito.stubbing.OngoingStubbing; //导入依赖的package包/类
public static AndroidLibrary createMockLibrary(String allResources, String publicResources,
        List<AndroidLibrary> dependencies)
        throws IOException {
    final File tempDir = TestUtils.createTempDirDeletedOnExit();

    Files.write(allResources, new File(tempDir, FN_RESOURCE_TEXT), Charsets.UTF_8);
    File publicTxtFile = new File(tempDir, FN_PUBLIC_TXT);
    if (publicResources != null) {
        Files.write(publicResources, publicTxtFile, Charsets.UTF_8);
    }
    AndroidLibrary library = mock(AndroidLibrary.class);
    when(library.getPublicResources()).thenReturn(publicTxtFile);

    // Work around wildcard capture
    //when(mock.getLibraryDependencies()).thenReturn(dependencies);
    List libraryDependencies = library.getLibraryDependencies();
    OngoingStubbing<List> setter = when(libraryDependencies);
    setter.thenReturn(dependencies);
    return library;
}
 

import org.mockito.stubbing.OngoingStubbing; //导入依赖的package包/类
private SheetReader buildMockSheetReader(LocalDateDoubleTimeSeries lddts) { 
  
  DateTimeFormatterBuilder builder = new DateTimeFormatterBuilder();
  builder.appendPattern(DATE_FORMAT);
  DateTimeFormatter dateFormat = builder.toFormatter();

  SheetReader mock = mock(SheetReader.class);
  OngoingStubbing<Map<String, String>> stub = when(mock.loadNextRow());
  for (Map.Entry<LocalDate, Double> entry : lddts) {
    Map<String, String> row = new HashMap<String, String>();
    row.put("id", EXISTING_HTSINFO_EXTERNALID.getValue());
    row.put("date", entry.getKey().toString(dateFormat));
    row.put("value", entry.getValue().toString());
    stub = stub.thenReturn(row);
  }
  stub.thenReturn(null);
  return mock;    
}
 

import org.mockito.stubbing.OngoingStubbing; //导入依赖的package包/类
@Test
public void testExtractor() throws Exception {
  // setup
  Schema schema = new Schema("testExtractor");
  schema.addColumn(new Text("TextCol"));
  ExtractorContext context = new ExtractorContext(null, writerMock, schema);
  LinkConfiguration linkConfig = new LinkConfiguration();
  FromJobConfiguration jobConfig = new FromJobConfiguration();
  KiteDatasetPartition partition = new KiteDatasetPartition();
  partition.setUri("dataset:hdfs:/path/to/dataset");
  OngoingStubbing<Object[]> readRecordMethodStub = when(executorMock.readRecord());
  final int NUMBER_OF_ROWS = 1000;
  for (int i = 0; i < NUMBER_OF_ROWS; i++) {
    // TODO: SQOOP-1616 will cover more column data types
    readRecordMethodStub = readRecordMethodStub.thenReturn(new Object[]{});
  }
  readRecordMethodStub.thenReturn(null);

  // exercise
  extractor.extract(context, linkConfig, jobConfig, partition);

  // verify
  verify(writerMock, times(NUMBER_OF_ROWS)).writeArrayRecord(
      any(Object[].class));
}
 

import org.mockito.stubbing.OngoingStubbing; //导入依赖的package包/类
public OngoingStubbing<T> withAnyArguments() throws Exception {
    if (mockType == null) {
        throw new IllegalArgumentException("Class to expected cannot be null");
    }
    final Class<T> unmockedType = (Class<T>) WhiteboxImpl.getUnmockedType(mockType);
    final Constructor<?>[] allConstructors = WhiteboxImpl.getAllConstructors(unmockedType);
    final Constructor<?> constructor = allConstructors[0];
    final Class<?>[] parameterTypes = constructor.getParameterTypes();
    Object[] paramArgs = new Object[parameterTypes.length];
    for (int i = 0; i < parameterTypes.length; i++) {
        Class<?> paramType = parameterTypes[i];
        paramArgs[i] = Matchers.any(paramType);
    }
    final OngoingStubbing<T> ongoingStubbing = createNewSubstituteMock(mockType, parameterTypes, paramArgs);
    Constructor<?>[] otherCtors = new Constructor<?>[allConstructors.length-1];
    System.arraycopy(allConstructors, 1, otherCtors, 0, allConstructors.length-1);
    return new DelegatingToConstructorsOngoingStubbing<T>(otherCtors, ongoingStubbing);
}
 

import org.mockito.stubbing.OngoingStubbing; //导入依赖的package包/类
public OngoingStubbing<T> invoke() {
    final InvocationSubstitute<T> mock = stubbing.getMock();
    for (Constructor<?> constructor : ctors) {
        final Class<?>[] parameterTypesForCtor = constructor.getParameterTypes();
        Object[] paramArgs = new Object[parameterTypesForCtor.length];
        for (int i = 0; i < parameterTypesForCtor.length; i++) {
            Class<?> paramType = parameterTypesForCtor[i];
            paramArgs[i] = Matchers.any(paramType);
        }
        try {
            final OngoingStubbing<T> when = when(mock.performSubstitutionLogic(paramArgs));
            performStubbing(when);
        } catch (Exception e) {
            throw new RuntimeException("PowerMock internal error",e);
        }
    }

    return stubbing;
}
 

import org.mockito.stubbing.OngoingStubbing; //导入依赖的package包/类
/**
 * wrap when(dbaasStub.createDatabase( ...any parameters... ))
 * @param dbaasStub
 * @return a stub object representing and a call to the createDatabase method with any parameters
 * @throws Exception
 */
public static OngoingStubbing<CreateDatabaseResponseObject> whenCreateDatabase(DbaasApiRemote dbaasStub) throws Exception {
	return when(dbaasStub.createDatabase(
			anyString(), 
			anyString(),
			anyInt(), 
			any(ServiceClassWsEnum.class), 
			any(EngineWsEnum.class), 
			anyString(), 
			anyListOf(DatabaseUserInfo.class),
			any(SloWsEnum.class), 
			anyBoolean(), 
			any(UsageWsEnum.class), 
			anyString(), 
			any(NetworkZoneWsEnum.class), 
			anyString(), 
			anyString(), 
			anyString(), 
			any(BackupPlanWsEnum.class), 
			anyString(), 
			anyBoolean(), 
			anyString()));
}
 

import org.mockito.stubbing.OngoingStubbing; //导入依赖的package包/类
private void getAllPrBuildsCommonExpectations(int size) {
    when(job.getBuilds()).thenReturn(builds);
    when(builds.size()).thenReturn(size);
    when(job.getParent()).thenReturn(itemGroup);
    when(itemGroup.getFullName()).thenReturn("JobName");

    when(builds.iterator()).thenReturn(iterator);

    OngoingStubbing<Boolean> hasNextExpectation = size >= 1 ?
            when(iterator.hasNext()).thenReturn(true) : when(iterator.hasNext()).thenReturn(false);
    for (int i = 1; i < size; i++) {
        hasNextExpectation.thenReturn(true);
    }
    hasNextExpectation.thenReturn(false);

    OngoingStubbing<Object> nextExpectation = when(iterator.next()).thenReturn(run);
    for (int i = 1; i < size; i++) {
        nextExpectation.thenReturn(run);
    }
}
 

import org.mockito.stubbing.OngoingStubbing; //导入依赖的package包/类
@Test
public void second_stubbing_throws_IndexOutOfBoundsException() throws Exception {
    Map<String, String> map = mock(Map.class);

    OngoingStubbing<String> mapOngoingStubbing = when(map.get(anyString()));

    mapOngoingStubbing.thenReturn("first stubbing");

    try {
        mapOngoingStubbing.thenReturn("second stubbing");
        fail();
    } catch (MockitoException e) {
        assertThat(e.getMessage())
                .contains("Incorrect use of API detected here")
                .contains(this.getClass().getSimpleName());
    }
}
 

import org.mockito.stubbing.OngoingStubbing; //导入依赖的package包/类
@Test
public void shouldPollUntilQueueEmpty_onPoll() {
    // Given
    when(mockTransactionalResourceManager.inTransaction()).thenReturn(false);
    final int messageCount = randomInt(5) + 1;
    final InMemoryMessageListener<TypedMessage> mockMemoryMessageListener = mock(InMemoryMessageListener.class);
    poller.register(mockMemoryMessageListener);

    // pollForMessage() should return true for messageCount times
    OngoingStubbing<Boolean> ongoingStubbing = when(mockMemoryMessageListener.receiveAndHandleMessages());
    for (int n = 0; n < messageCount; n++) {
        ongoingStubbing = ongoingStubbing.thenReturn(true);
    }
    ongoingStubbing.thenReturn(false);

    // When
    poller.poll();

    // Then
    verify(mockMemoryMessageListener, times(messageCount + 1)).receiveAndHandleMessages();
}
 

import org.mockito.stubbing.OngoingStubbing; //导入依赖的package包/类
/**
 * Mock a content provider that returns for the first call to
 * {@link SemanticContentProvider#getRelevantContent(SoftwareElement, boolean)} the first list
 * of provided terms, and for the second call the second list.
 *
 * @param terms1
 *            The terms to return for the first call.
 * @param terms2
 *            The terms to return for the second call.
 * @return The prepared mock.
 * @throws UnsupportedSoftwareElementException
 */
private SemanticContentProvider mockContentProviderForTermLists(List<List<String>> termLists)
        throws UnsupportedSoftwareElementException {

    SemanticContentProvider provider = mock(SemanticContentProvider.class);
    OngoingStubbing<SemanticContent> mockStub = when(provider.getRelevantContent(any(SoftwareElement.class),
            anyBoolean()));

    for (List<String> terms : termLists) {
        SemanticContent semantic = new SemanticContent();
        for (String term : terms) {
            semantic.addCode(term);
        }
        mockStub = mockStub.thenReturn(semantic);
    }

    return provider;
}
 

import org.mockito.stubbing.OngoingStubbing; //导入依赖的package包/类
private List<Connection> mockedConnectionsForClient(Client client, int numConnections) throws IOException {
    final ConnectionFactory mockFactory = mock(ConnectionFactory.class);
    final OngoingStubbing<Connection> newConnectionStub = when(mockFactory.newConnection());
    List<Connection> conns = new ArrayList<Connection>(numConnections);
    // TODO OMG this is ugly. there's got to be a better way.
    OngoingStubbing<Connection> connectionOngoingStubbing = null;
    for (int i = 0; i < numConnections; i++) {
        final Connection mockConnection = mock(Connection.class);
        if (i == 0) {
            connectionOngoingStubbing = newConnectionStub.thenReturn(mockConnection);
        } else {
            connectionOngoingStubbing.thenReturn(mockConnection);
        }
        final Channel mockChannel = mock(Channel.class);
        when(mockConnection.createChannel()).thenReturn(mockChannel);
        conns.add(mockConnection);
    }
    client.setConnectionFactory(mockFactory);
    return conns;
}
 

import org.mockito.stubbing.OngoingStubbing; //导入依赖的package包/类
private Random createRandom(int... values) {
    Random random = mock(Random.class);
    
    OngoingStubbing<Integer> ongoingStubbing = when(random.nextInt(36));
    for (int value : values) {
        ongoingStubbing = ongoingStubbing.thenReturn(value);
    }
    
    return random;
}
 

import org.mockito.stubbing.OngoingStubbing; //导入依赖的package包/类
private void configureHttpResponses(HttpResponse... responses) throws IOException {
    requestCaptor = ArgumentCaptor.forClass(HttpGeneric.class);
    OngoingStubbing<HttpResponse> stubbing =
            when(mockHttpClient.executeOverride(requestCaptor.capture(), any(HttpContext.class)));

    for (HttpResponse response : responses) {
        stubbing = stubbing.thenReturn(response);
    }
}