Java MemberMatcher类代码示例

import org.powermock.api.support.membermodification.MemberMatcher; //导入依赖的package包/类
@Before
public void setup() throws Exception {
  PowerMockito.replace(
      MemberMatcher.method(
          JdbcUtil.class,
          "getReferredTables",
          Connection.class,
          String.class,
          String.class
      )
  ).with((proxy, method, args) -> new HashSet<>(referredTablesTestRelation.getReferredTableMap().get((String)args[2])));
  tableOrderProvider = new TableOrderProviderFactory(PowerMockito.mock(Connection.class), tableOrderStrategy).create();
  for (String table : referredTablesTestRelation.getTableListingOrder()) {
    final TableContext tableContext = getTableContext(table);
    tableContextsMap.put(table, tableContext);
  }
}
 

import org.powermock.api.support.membermodification.MemberMatcher; //导入依赖的package包/类
@Test(testName = "loadConfiguration")
public void should_load_configuration_from_property_file_with_unsupported_contentMimeType() throws Exception {
    // Given
    mockStaticPartial(RestClientConfiguration.class, "loadProperties");
    Method[] methods = MemberMatcher.methods(RestClientConfiguration.class, "loadProperties");

    expectPrivate(RestClientConfiguration.class, methods[0], "superCoolPath").andReturn(fakePropsWithUnproperContentMimeType);
    replay(RestClientConfiguration.class);

    // When
    RestClientConfiguration configuration = RestClientConfiguration.loadConfiguration("superCoolPath");

    // Then
    assertEquals(configuration.getJasperReportsServerUrl(), fakePropsWithUnproperContentMimeType.getProperty("url"));
    assertEquals(configuration.getContentMimeType(), MimeType.JSON);
    assertEquals(configuration.getAcceptMimeType().toString(), fakePropsWithUnproperContentMimeType.getProperty("acceptMimeType"));
    assertNull(configuration.getConnectionTimeout());
    assertNull(configuration.getReadTimeout());
    assertNotNull(configuration.getTrustManagers());
}
 

import org.powermock.api.support.membermodification.MemberMatcher; //导入依赖的package包/类
@Test(testName = "loadConfiguration")
public void should_load_configuration_from_property_file_with_unsupported_acceptMimeType() throws Exception {
    // Given
    mockStaticPartial(RestClientConfiguration.class, "loadProperties");
    Method[] methods = MemberMatcher.methods(RestClientConfiguration.class, "loadProperties");

    expectPrivate(RestClientConfiguration.class, methods[0], "superCoolPath").andReturn(fakePropsWithUnproperAcceptMimeType);
    replay(RestClientConfiguration.class);

    // When
    RestClientConfiguration configuration = RestClientConfiguration.loadConfiguration("superCoolPath");

    // Then
    assertEquals(configuration.getJasperReportsServerUrl(), fakePropsWithUnproperAcceptMimeType.getProperty("url"));
    assertEquals(configuration.getContentMimeType().toString(), fakePropsWithUnproperAcceptMimeType.getProperty("contentMimeType"));
    assertEquals(configuration.getAcceptMimeType(), MimeType.JSON);
    assertNull(configuration.getConnectionTimeout());
    assertNull(configuration.getReadTimeout());
    assertNotNull(configuration.getTrustManagers());
}
 

import org.powermock.api.support.membermodification.MemberMatcher; //导入依赖的package包/类
@Test
public void should_not_throw_an_exception_with_wrong_contentMimetype() throws Exception {
    // Given
    Properties fakePropsWithUnproperContentMimeType = new Properties() {{
        setProperty("url", "http://localhost:8080/jasperserver-pro/");
        setProperty("contentMimeType", "UnacceptableContentMimeType");
    }};

    mockStaticPartial(RestClientConfiguration.class, "loadProperties");
    Method[] methods = MemberMatcher.methods(RestClientConfiguration.class, "loadProperties");

    expectPrivate(RestClientConfiguration.class, methods[0], "superCoolPath").andReturn(fakePropsWithUnproperContentMimeType);
    replay(RestClientConfiguration.class);

    // When
    RestClientConfiguration configuration = RestClientConfiguration.loadConfiguration("superCoolPath");
    // Then
    Assert.assertEquals(configuration.getContentMimeType(), MimeType.JSON);
}
 

import org.powermock.api.support.membermodification.MemberMatcher; //导入依赖的package包/类
@Test
public void should_not_throw_an_exception_with_wrong_acceptMimetype() throws Exception {
    // Given
    Properties fakePropsWithUnproperAcceptMimeType = new Properties() {{
        setProperty("url", "http://localhost:8080/jasperserver-pro/");
        setProperty("acceptMimeType", "UnacceptableAcceptMimeType");
    }};

    mockStaticPartial(RestClientConfiguration.class, "loadProperties");
    Method[] methods = MemberMatcher.methods(RestClientConfiguration.class, "loadProperties");

    expectPrivate(RestClientConfiguration.class, methods[0], "superCoolPath").andReturn(fakePropsWithUnproperAcceptMimeType);
    replay(RestClientConfiguration.class);

    // When
    RestClientConfiguration configuration = RestClientConfiguration.loadConfiguration("superCoolPath");
    // Then
    Assert.assertEquals(configuration.getAcceptMimeType(), MimeType.JSON);
}
 

import org.powermock.api.support.membermodification.MemberMatcher; //导入依赖的package包/类
@Test
public void should_not_throw_an_exception_with_wrong_jrs_version() throws Exception {
    // Given
    Properties fakePropsWithUnproperJrsVersion = new Properties() {{
        setProperty("url", "http://localhost:8080/jasperserver-pro/");
        setProperty("jrsVersion", "6.1");
    }};
    mockStaticPartial(RestClientConfiguration.class, "loadProperties");
    Method[] methods = MemberMatcher.methods(RestClientConfiguration.class, "loadProperties");

    expectPrivate(RestClientConfiguration.class, methods[0], "superCoolPath").andReturn(fakePropsWithUnproperJrsVersion);
    replay(RestClientConfiguration.class);

    // When
    RestClientConfiguration configuration = RestClientConfiguration.loadConfiguration("superCoolPath");
    // Then
    Assert.assertEquals(configuration.getJrsVersion(), JRSVersion.v5_5_0);
}
 

import org.powermock.api.support.membermodification.MemberMatcher; //导入依赖的package包/类
@Test
public void should_not_throw_an_exception_with_wrong_authintication_type() throws Exception {
    // Given
    Properties fakePropsWithUnproperAuthorizationType = new Properties() {{
        setProperty("url", "http://localhost:8080/jasperserver-pro/");
        setProperty("authenticationType", "authenticationType");
    }};
    mockStaticPartial(RestClientConfiguration.class, "loadProperties");
    Method[] methods = MemberMatcher.methods(RestClientConfiguration.class, "loadProperties");

    expectPrivate(RestClientConfiguration.class, methods[0], "superCoolPath").andReturn(fakePropsWithUnproperAuthorizationType);
    replay(RestClientConfiguration.class);

    // When
    RestClientConfiguration configuration = RestClientConfiguration.loadConfiguration("superCoolPath");

    // Then
    Assert.assertEquals(configuration.getAuthenticationType(), AuthenticationType.SPRING);
}
 

import org.powermock.api.support.membermodification.MemberMatcher; //导入依赖的package包/类
@Test
public void should_load_configuration_from_property_file_with_true_in_boolean_values() throws Exception {
    // Given
    Properties fakePropsWithUnproperJrsVersion = new Properties() {{
        setProperty("url", "http://localhost:8080/jasperserver-pro/");
        setProperty("restrictedHttpMethods", "true");
        setProperty("logHttpEntity", "true");
        setProperty("logHttp", "true");
    }};
    mockStaticPartial(RestClientConfiguration.class, "loadProperties");
    Method[] methods = MemberMatcher.methods(RestClientConfiguration.class, "loadProperties");

    expectPrivate(RestClientConfiguration.class, methods[0], "superCoolPath").andReturn(fakePropsWithUnproperJrsVersion);
    replay(RestClientConfiguration.class);

    // When
    RestClientConfiguration configuration = RestClientConfiguration.loadConfiguration("superCoolPath");
    assertTrue(configuration.getRestrictedHttpMethods());
    assertTrue(configuration.getLogHttp());
    assertTrue(configuration.getLogHttpEntity());
}
 

import org.powermock.api.support.membermodification.MemberMatcher; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Test
public void testExtractCreatedOrUpdated() {
    Map<InstanceIdentifier<DataObject>, DataObject> result = new HashMap<>();

    PowerMockito.suppress(
            MemberMatcher.method(TransactUtils.class, "extractUpdated", AsyncDataChangeEvent.class, Class.class));
    PowerMockito.when(TransactUtils.extractUpdated(any(AsyncDataChangeEvent.class), eq(DataObject.class)))
            .thenReturn(result);

    Map<InstanceIdentifier<DataObject>, DataObject> map = new HashMap<>();
    InstanceIdentifier<DataObject> iid = mock(InstanceIdentifier.class);
    DataObject db = mock(DataObject.class);
    map.put(iid, db);
    PowerMockito.suppress(
            MemberMatcher.method(TransactUtils.class, "extractCreated", AsyncDataChangeEvent.class, Class.class));
    PowerMockito.when(TransactUtils.extractCreated(any(AsyncDataChangeEvent.class), eq(DataObject.class)))
            .thenReturn(map);

    Map<InstanceIdentifier<DataObject>, DataObject> testResult = new HashMap<>();
    testResult.put(iid, db);
    Class<DataObject> klazz = DataObject.class;
    AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes = mock(AsyncDataChangeEvent.class);
    assertEquals(testResult, TransactUtils.extractCreatedOrUpdated(changes, klazz));
}
 

import org.powermock.api.support.membermodification.MemberMatcher; //导入依赖的package包/类
@Test
@SuppressWarnings("unchecked")
public void testExtractCreatedOrUpdatedOrRemoved() {
    Map<InstanceIdentifier<DataObject>, DataObject> result = new HashMap<>();

    PowerMockito.suppress(MemberMatcher.method(TransactUtils.class, "extractCreatedOrUpdated",
            AsyncDataChangeEvent.class, Class.class));
    PowerMockito.when(TransactUtils.extractCreatedOrUpdated(any(AsyncDataChangeEvent.class), eq(DataObject.class)))
            .thenReturn(result);

    Map<InstanceIdentifier<DataObject>, DataObject> map = new HashMap<>();
    InstanceIdentifier<DataObject> iid = mock(InstanceIdentifier.class);
    DataObject db = mock(DataObject.class);
    map.put(iid, db);
    PowerMockito.suppress(MemberMatcher.method(TransactUtils.class, "extractRemovedObjects",
            AsyncDataChangeEvent.class, Class.class));
    PowerMockito.when(TransactUtils.extractRemovedObjects(any(AsyncDataChangeEvent.class), eq(DataObject.class)))
            .thenReturn(map);

    Map<InstanceIdentifier<DataObject>, DataObject> testResult = new HashMap<>();
    testResult.put(iid, db);
    Class<DataObject> klazz = DataObject.class;
    AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes = mock(AsyncDataChangeEvent.class);
    assertEquals(testResult, TransactUtils.extractCreatedOrUpdatedOrRemoved(changes, klazz));
}
 

import org.powermock.api.support.membermodification.MemberMatcher; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Test
public void testExtractRemovedObjects() {
    Set<InstanceIdentifier<DataObject>> iids = new HashSet<>();
    PowerMockito.suppress(
            MemberMatcher.method(TransactUtils.class, "extractRemoved", AsyncDataChangeEvent.class, Class.class));
    PowerMockito.when(TransactUtils.extractRemoved(any(AsyncDataChangeEvent.class), eq(DataObject.class)))
            .thenReturn(iids);

    Map<InstanceIdentifier<DataObject>, DataObject> result = new HashMap<>();
    PowerMockito.suppress(
            MemberMatcher.method(TransactUtils.class, "extractOriginal", AsyncDataChangeEvent.class, Class.class));
    PowerMockito.when(TransactUtils.extractOriginal(any(AsyncDataChangeEvent.class), eq(DataObject.class)))
            .thenReturn(result);

    Class<DataObject> klazz = DataObject.class;
    AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes = mock(AsyncDataChangeEvent.class);
    assertEquals(Maps.filterKeys(result, Predicates.in(iids)), TransactUtils.extractRemovedObjects(changes, klazz));
}
 

import org.powermock.api.support.membermodification.MemberMatcher; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Test
public void testStampInstanceIdentifier() {
    TransactionBuilder transaction = mock(TransactionBuilder.class);
    InstanceIdentifier<?> iid = mock(InstanceIdentifier.class);
    TableSchema<GenericTableSchema> tableSchema = mock(TableSchema.class);
    ColumnSchema<GenericTableSchema, Map<String,String>> columnSchema = mock(ColumnSchema.class);
    InstanceIdentifierCodec instanceIdentifierCodec = mock(InstanceIdentifierCodec.class);

    PowerMockito.suppress(MemberMatcher.method(TransactUtils.class, "stampInstanceIdentifierMutation",
            TransactionBuilder.class,
            InstanceIdentifier.class,
            TableSchema.class,
            ColumnSchema.class,
            InstanceIdentifierCodec.class));
    when(TransactUtils.stampInstanceIdentifierMutation(transaction, iid, tableSchema, columnSchema,
            instanceIdentifierCodec))
            .thenReturn(mock(Mutate.class));
    when(transaction.add(any(Operation.class))).thenReturn(transaction);
    TransactUtils.stampInstanceIdentifier(transaction, iid, tableSchema, columnSchema, instanceIdentifierCodec);
    verify(transaction).add(any(Operation.class));
}
 

import org.powermock.api.support.membermodification.MemberMatcher; //导入依赖的package包/类
@Test
public void testGetOvsdbBridgeAugmentation() throws Exception {
    Optional<OvsdbBridgeAugmentation> optOvsdbBri = briOperationState.getOvsdbBridgeAugmentation(iid);
    verify(briOperationState, times(1)).getBridgeNode(any(InstanceIdentifier.class));
    assertNotNull(optOvsdbBri);
    assertTrue(optOvsdbBri.equals(Optional.absent()));

    suppress(MemberMatcher.method(BridgeOperationalState.class, "getBridgeNode", InstanceIdentifier.class));
    Node node = mock(Node.class);
    Optional<Node> optNode = Optional.of(node);
    when(briOperationState.getBridgeNode(any(InstanceIdentifier.class))).thenReturn(optNode);
    OvsdbBridgeAugmentation ovsdbBriAug = mock(OvsdbBridgeAugmentation.class);
    when(node.getAugmentation(OvsdbBridgeAugmentation.class)).thenReturn(ovsdbBriAug);
    Optional<OvsdbBridgeAugmentation> ovsdbBriAugOptional = briOperationState.getOvsdbBridgeAugmentation(iid);
    assertNotNull(ovsdbBriAugOptional);
    assertTrue(ovsdbBriAugOptional.get() instanceof OvsdbBridgeAugmentation);
}
 

import org.powermock.api.support.membermodification.MemberMatcher; //导入依赖的package包/类
@Test
public void testGetBridgeTerminationPoint() throws Exception {
    Optional<TerminationPoint> optTerm = briOperationState.getBridgeTerminationPoint(iid);
    verify(briOperationState, times(1)).getBridgeNode(any(InstanceIdentifier.class));
    assertNotNull(optTerm);
    assertTrue(optTerm.equals(Optional.absent()));

    TerminationPoint termPnt = mock(TerminationPoint.class);
    List<TerminationPoint> termPntList = new ArrayList<>();
    termPntList.add(termPnt);

    suppress(MemberMatcher.method(BridgeOperationalState.class, "getBridgeNode", InstanceIdentifier.class));
    Node node = mock(Node.class);
    Optional<Node> optNode = Optional.of(node);
    when(briOperationState.getBridgeNode(any(InstanceIdentifier.class))).thenReturn(optNode);
    when(node.getTerminationPoint()).thenReturn(termPntList);
    TerminationPointKey termPntKey = mock(TerminationPointKey.class);
    when(termPnt.getKey()).thenReturn(termPntKey);

    final InstanceIdentifier<?> iid2 = PowerMockito.mock(InstanceIdentifier.class);
    //PowerMockito.suppress(MemberMatcher.method(InstanceIdentifier.class, "firstKeyOf", Class.class, Class.class));
    //PowerMockito.when(iid2.firstKeyOf(TerminationPoint.class, TerminationPointKey.class)).thenReturn(termPntKey);
    Optional<TerminationPoint> optTermPnt = briOperationState.getBridgeTerminationPoint(iid2);
    assertNotNull(optTermPnt);
    //assertTrue(optTermPnt.get() instanceof TerminationPoint);
}
 

import org.powermock.api.support.membermodification.MemberMatcher; //导入依赖的package包/类
@Test
public void testGetOvsdbTerminationPointAugmentation() {
    Optional<OvsdbTerminationPointAugmentation> optOvsdbTermPoint = briOperationState
            .getOvsdbTerminationPointAugmentation(iid);
    assertNotNull(optOvsdbTermPoint);
    verify(briOperationState, times(1)).getBridgeTerminationPoint(any(InstanceIdentifier.class));
    verify(briOperationState, times(1)).getBridgeNode(any(InstanceIdentifier.class));
    assertTrue(optOvsdbTermPoint.equals(Optional.absent()));

    PowerMockito.suppress(MemberMatcher.method(BridgeOperationalState.class, "getBridgeTerminationPoint",
            InstanceIdentifier.class));
    TerminationPoint termPoint = mock(TerminationPoint.class);
    Optional<TerminationPoint> termPntOptional = Optional.of(termPoint);
    when(briOperationState.getBridgeTerminationPoint(any(InstanceIdentifier.class))).thenReturn(termPntOptional);
    OvsdbTerminationPointAugmentation ovsdbTermPntAug = mock(OvsdbTerminationPointAugmentation.class);
    when(termPoint.getAugmentation(OvsdbTerminationPointAugmentation.class)).thenReturn(ovsdbTermPntAug);
    Optional<OvsdbTerminationPointAugmentation> ovsdbTermPointOpt = briOperationState
            .getOvsdbTerminationPointAugmentation(iid);
    assertNotNull(ovsdbTermPointOpt);
    assertTrue(ovsdbTermPointOpt.get() instanceof OvsdbTerminationPointAugmentation);
}