Java 类org.mockito.ArgumentMatcher 实例源码

@Test
public void testRequest() throws Throwable {
    createServerApiMock();
    createTestScheduler();
    App.setObjectGraph(ObjectGraph.create(new MainPresenterTestModule()));

    MainPresenter presenter = new MainPresenter();
    presenter.onCreate(null);
    presenter.request(FIRST_NAME + " " + LAST_NAME);

    MainActivity mainActivity = mock(MainActivity.class);
    presenter.takeView(mainActivity);

    testScheduler.triggerActions();

    verify(serverAPIMock).getItems(FIRST_NAME, LAST_NAME);
    verify(mainActivity).onItems(argThat(new ArgumentMatcher<ServerAPI.Item[]>() {
        @Override
        public boolean matches(Object argument) {
            return ((ServerAPI.Item[])argument)[0].text.equals(TEST_TEXT);
        }
    }), anyString());
}

@Test
public void testRequest() throws Throwable {
    createServerApiMock();
    createTestScheduler();
    App.setObjectGraph(ObjectGraph.create(new MainPresenterTestModule()));

    MainPresenter presenter = new MainPresenter();
    presenter.onCreate(null);
    presenter.request(FIRST_NAME + " " + LAST_NAME);

    MainActivity mainActivity = mock(MainActivity.class);
    presenter.takeView(mainActivity);

    testScheduler.triggerActions();

    verify(serverAPIMock).getItems(FIRST_NAME, LAST_NAME);
    verify(mainActivity).onItems(argThat(new ArgumentMatcher<ServerAPI.Item[]>() {
        @Override
        public boolean matches(Object argument) {
            return ((ServerAPI.Item[])argument)[0].text.equals(TEST_TEXT);
        }
    }), anyString());
}

@Test
public void senses() throws Exception {
    final MetricRecorder recorder = new StubRecorder();

    final Sensor sensor1 = mock(Sensor.class);
    final Sensor sensor2 = mock(Sensor.class);
    when(sensor1.addContext(any(TypedMap.class))).then(invocation -> invocation.getArgument(0));
    when(sensor2.addContext(any(TypedMap.class))).then(invocation -> invocation.getArgument(0));

    List<Sensor> sensors = new ArrayList<>();
    sensors.add(sensor1);
    sensors.add(sensor2);

    MXBeanPoller poller = new MXBeanPoller(recorder, 1, sensors);
    Thread.sleep(1500); // wait for a poll to occur
    poller.shutdown();

    final ArgumentMatcher<TypedMap> dataMatch = new DataMatcher();
    verify(sensor1).addContext(argThat(dataMatch));
    verify(sensor2).addContext(argThat(dataMatch));
    verify(sensor1, atLeastOnce()).sense(any(MetricRecorder.Context.class));
    verify(sensor2, atLeastOnce()).sense(any(MetricRecorder.Context.class));
}

protected ArgumentMatcher<SearchParameters> getArgMatcher()
{
    return new ArgumentMatcher<SearchParameters>()
    {
        @Override
        public boolean matches(Object argument)
        {
            if (argument instanceof SearchParameters)
            {
                String matchingString = getMatchingString();
                if (matchingString != null && argument.toString().contains(matchingString))
                {
                    return true;
                }
            }
            return false;
        }
    };
}

@Test
public void includeVat_grossAmount() {
    // given
    doReturn(BigDecimal.ONE).when(vatForCustomer).getTotalCosts();

    // when
    bean.includeVat(billingDetails, billingInput, billingResult,
            overallCosts);

    // then
    OverallCostsType overallCostsType = billingDetails.getOverallCosts();
    verify(overallCostsType).setGrossAmount(
            argThat(new ArgumentMatcher<BigDecimal>() {

                @Override
                public boolean matches(Object argument) {
                    BigDecimal b = (BigDecimal) argument;
                    BigDecimalAsserts.checkEquals(BigDecimal.ONE, b);
                    return true;
                }
            }));
}

@Test
public void testReadConfiguration() {
    final int DB_CONNECTIONS = 15;
    final String SERVICE_NAME = "abc";

    when(configurationMock.getDbConnectionThreads()).thenReturn(DB_CONNECTIONS);

    ArgumentMatcher<DataSourceConfig> dataSourceConfigMatcher = new LambdaArgumentMatcher<DataSourceConfig>(
        (Object input) -> DB_CONNECTIONS == ((DataSourceConfig) input).getPoolConfig().getMaxTotal());
    when(springCloudMock.getServiceConnector(eq(SERVICE_NAME), eq(DataSource.class), argThat(dataSourceConfigMatcher)))
        .thenReturn(createdDataSource);

    testedFactory.setDefaultDataSource(defaultDataSource);
    testedFactory.setServiceName(SERVICE_NAME);

    testedFactory.afterPropertiesSet();

    verify(springCloudMock, atLeastOnce()).getServiceConnector(any(), any(), any());
    assertEquals(testedFactory.getObject(), createdDataSource);
}

public void testPostAdd() throws FrameworkException, ApplicationExceptions {
    User user = new User();
    StaticContext.initialize(user);
    assertNotNull(user.getFlexBean());

    UOW mockUow = Mockito.mock(UOW.class);
    user.setUOW(mockUow);
    user.setId("1234");

    // flexbean should not have been updated since the values haven't changed
    user.postAdd();
    verify(mockUow, never()).add(new Object());

    user.getFlexBean().set("reinstateDate", new Date());
    user.postAdd();


    // the flextfield for the date should have attempted to "add" in the uow
    verify(mockUow).add(argThat(new ArgumentMatcher<FlexField>() {
        @Override
        public boolean matches(Object emp) {
            return ((FlexField) emp).getFieldName().equals("reinstateDate");
        }
    }));
}

@Test
public void listSpecificTrigger() throws Exception {
    when(mockSchedulingService.getTriggerByKey(any(NameAndGroup.class))).thenReturn(immediateTrigger);
    mockMvc.perform(get("/triggers?name=test&group=group"))
           .andExpect(status().isOk())
           .andExpect(result -> assertEquals("application/json;charset=UTF-8", result.getResponse().getContentType()))
           .andExpect(result -> {
               String responseBody = result.getResponse().getContentAsString();
               TriggerDefinition trigger = mapper.readValue(responseBody, TriggerDefinition.class);
               assertTriggers(immediateTrigger, trigger);
           });
    verify(mockSchedulingService).getTriggerByKey(argThat(new ArgumentMatcher<NameAndGroup>() {
        @Override
        public boolean matches(Object o) {
            return (o instanceof NameAndGroup) &&
                    ((NameAndGroup) o).getName().equals("test") &&
                    ((NameAndGroup) o).getGroup().equals("group");
        }
    }));
}

@Test
public void listTriggersForSpecificJob() throws Exception {
    when(mockSchedulingService.getTriggersForJob(any(NameAndGroup.class))).thenReturn(singletonList(cronTrigger));
    mockMvc.perform(get("/triggers/job?name=job&group=jobGroup"))
           .andExpect(status().isOk())
           .andExpect(result -> assertEquals("application/json;charset=UTF-8", result.getResponse().getContentType()))
           .andExpect(result -> {
               String responseBody = result.getResponse().getContentAsString();
               List<TriggerDefinition> triggers = Arrays.asList(mapper.readValue(responseBody, TriggerDefinition[].class));
               assertEquals(1, triggers.size());
               assertTriggers(cronTrigger, triggers.get(0));
           });
    verify(mockSchedulingService).getTriggersForJob(argThat(new ArgumentMatcher<NameAndGroup>() {
        @Override
        public boolean matches(Object o) {
            return (o instanceof NameAndGroup) &&
                    ((NameAndGroup) o).getName().equals("job") &&
                    ((NameAndGroup) o).getGroup().equals("jobGroup");
        }
    }));
}

@Test
public void triggerAJob() throws Exception {
    when(mockSchedulingService.triggerNow(any(NameAndGroup.class))).thenReturn(immediateTrigger);
    mockMvc.perform(post("/triggers/start?name=test&group=group"))
           .andExpect(status().isOk())
           .andExpect(result -> assertEquals("application/json;charset=UTF-8", result.getResponse().getContentType()))
           .andExpect(result -> {
               String responseBody = result.getResponse().getContentAsString();
               TriggerDefinition trigger = mapper.readValue(responseBody, TriggerDefinition.class);
               assertTriggers(immediateTrigger, trigger);
           });
    verify(mockSchedulingService).triggerNow(argThat(new ArgumentMatcher<NameAndGroup>() {
        @Override
        public boolean matches(Object o) {
            return (o instanceof NameAndGroup) &&
                    ((NameAndGroup) o).getName().equals("test") &&
                    ((NameAndGroup) o).getGroup().equals("group");
        }
    }));
}

@Test
public void triggerANewImmediateTrigger() throws Exception {
    mockMvc.perform(post("/triggers/new/immediate").content(mapper.writeValueAsString(immediateTrigger)).contentType(MediaType.APPLICATION_JSON))
           .andExpect(status().isOk());
    verify(mockSchedulingService).saveOrUpdateTrigger(argThat(new ArgumentMatcher<TriggerDefinition>() {
        @Override
        public boolean matches(Object o) {
            return (o instanceof Immediate) &&
                    ((Immediate) o).getTriggerKey().getName().equals("test") &&
                    ((Immediate) o).getTriggerKey().getGroup().equals("group") &&
                    ((Immediate) o).getJobKey().getName().equals("job") &&
                    ((Immediate) o).getJobKey().getGroup().equals("jobGroup") &&
                    ((Immediate) o).getTriggerData().get("key1").equals("value") &&
                    ((Immediate) o).getTriggerData().get("key2").equals(5) &&
                    ((Immediate) o).getMisfireInstruction() == MisfireInstruction.DROP;
        }
    }));
}

@Test
public void createImmediateTrigger() throws Exception {
    mockMvc.perform(post("/triggers/new").content(mapper.writeValueAsString(immediateTrigger)).contentType(MediaType.APPLICATION_JSON))
           .andExpect(status().isOk());
    verify(mockSchedulingService).saveOrUpdateTrigger(argThat(new ArgumentMatcher<TriggerDefinition>() {
        @Override
        public boolean matches(Object o) {
            return (o instanceof Immediate) &&
                    ((Immediate) o).getTriggerKey().getName().equals("test") &&
                    ((Immediate) o).getTriggerKey().getGroup().equals("group") &&
                    ((Immediate) o).getJobKey().getName().equals("job") &&
                    ((Immediate) o).getJobKey().getGroup().equals("jobGroup") &&
                    ((Immediate) o).getTriggerData().get("key1").equals("value") &&
                    ((Immediate) o).getTriggerData().get("key2").equals(5) &&
                    ((Immediate) o).getMisfireInstruction() == MisfireInstruction.DROP;
        }
    }));
}

@Test
public void createCronTrigger() throws Exception {
    mockMvc.perform(post("/triggers/new").content(mapper.writeValueAsString(cronTrigger)).contentType(MediaType.APPLICATION_JSON))
           .andExpect(status().isOk());
    verify(mockSchedulingService).saveOrUpdateTrigger(argThat(new ArgumentMatcher<TriggerDefinition>() {
        @Override
        public boolean matches(Object o) {
            return (o instanceof Cron) &&
                    ((Cron) o).getTriggerKey().getName().equals("test") &&
                    ((Cron) o).getTriggerKey().getGroup().equals("group") &&
                    ((Cron) o).getJobKey().getName().equals("job") &&
                    ((Cron) o).getJobKey().getGroup().equals("jobGroup") &&
                    ((Cron) o).getTriggerData().get("key1").equals("value") &&
                    ((Cron) o).getTriggerData().get("key2").equals(5) &&
                    ((Cron) o).getCronExpression().equals("0 0/1 * 1/1 * ? *") &&
                    ((Cron) o).getMisfireInstruction() == Cron.MisfireInstruction.FIRE_ONCE;
        }
    }));
}

@Test
public void listSpecificJob() throws Exception {
    when(mockSchedulingService.getJobByKey(any(NameAndGroup.class))).thenReturn(jobDefinition);
    mockMvc.perform(get("/jobs/?name=test&group=group"))
           .andExpect(status().isOk())
           .andExpect(result -> assertEquals("application/json;charset=UTF-8", result.getResponse()
                   .getContentType()))
           .andExpect(result -> {
               String responseBody = result.getResponse().getContentAsString();
               JobDefinition job = mapper.readValue(responseBody, JobDefinition.class);
               assertJobs(jobDefinition, job);
           });
    verify(mockSchedulingService).getJobByKey(argThat(new ArgumentMatcher<NameAndGroup>() {
        @Override
        public boolean matches(Object o) {
            return (o instanceof NameAndGroup) &&
                    ((NameAndGroup) o).getName().equals("test") &&
                    ((NameAndGroup) o).getGroup().equals("group");
        }
    }));
}

@Test
public void testSingleEntry() {
  Storage storage = getEmptyStorage();

  Metadata metadata = new Metadata.Builder()
      .addLayer(new Metadata.Layer.Builder().setId("layer").setMinZoom(0).setMaxZoom(0).build())
      .build();
  DataSource dataSource = new DataSource(storage, metadata);
  dataSource
      .using("layer")
      .add(createPoint("1", "First Point", new double[]{0, 0}))
      .commit();

  // we only expect a single entry to be written to storage (one point on single global tile)
  final int expectedEntries = 1;

  verify(storage).putEntries(argThat(new ArgumentMatcher<Observable<Entry>>() {
    @Override
    public boolean matches(Observable<Entry> argument) {
      return expectedEntries == argument.count().blockingGet();
    }
  }));
}

private void assertSortRequest(FeatureFileSortRequest request, ArgumentMatcher payloadMatcher) throws Exception {
    ResultActions actions = mvc()
            .perform(post(URL_SORT).content(getObjectMapper().writeValueAsString(request))
                    .contentType(EXPECTED_CONTENT_TYPE))
            .andExpect(status().isOk())
            .andExpect(content().contentType(EXPECTED_CONTENT_TYPE))
            .andExpect(jsonPath(JPATH_PAYLOAD).value(payloadMatcher))
            .andExpect(jsonPath(JPATH_STATUS).value(ResultStatus.OK.name()));
    actions.andDo(MockMvcResultHandlers.print());

    final ResponseResult<String> res = getObjectMapper()
            .readValue(actions.andReturn().getResponse().getContentAsByteArray(),
                    getTypeFactory().constructParametrizedType(ResponseResult.class, ResponseResult.class,
                            String.class));

    Assert.assertNotNull(res.getPayload());
}

HttpClient.HttpRequest requestContainingFunctionId(String functionId) {
    ArgumentMatcher<HttpClient.HttpRequest> argumentMatcher = httpRequest -> {
        if(httpRequest.method != "POST") {
            System.err.println("Expecting a POST request, got " + httpRequest.method);
            return false;
        }
        try {
            APIModel.CreateGraphRequest createGraphRequest = objectMapper.readValue(new String(httpRequest.bodyBytes), APIModel.CreateGraphRequest.class);
            if ((createGraphRequest.functionId != null) && (createGraphRequest.functionId.equals(functionId))) {
                return true;
            }
            System.err.println("Request body doesn't contain an CreateGraphRequest with matching functionId field");
            return false;
        } catch (IOException e) {
            System.err.println("Request body doesn't contain an CreateGraphRequest");
            return false;
        }
    };
    ThreadSafeMockingProgress.mockingProgress().getArgumentMatcherStorage().reportMatcher(argumentMatcher);
    return null;
}

HttpClient.HttpRequest requestContainingAddStageRequest(String blobId, List<String> dependencies) {
    ArgumentMatcher<HttpClient.HttpRequest> argumentMatcher = httpRequest -> {
        if(httpRequest.method != "POST") {
            System.err.println("Expecting a POST request, got " + httpRequest.method);
            return false;
        }
        try {
            APIModel.AddStageRequest addStageRequest = objectMapper.readValue(new String(httpRequest.bodyBytes), APIModel.AddStageRequest.class);
            if (    (addStageRequest.closure != null) &&
                    (addStageRequest.closure.blobId.equals(blobId)) &&
                    (addStageRequest.deps.equals(dependencies))) {
                return true;
            }
            System.err.println("Request body doesn't contain an AddStageRequest with closure with matching blobId field");
            return false;
        } catch (IOException e) {
            System.err.println("Request body doesn't contain an AddStageRequest");
            return false;
        }
    };
    ThreadSafeMockingProgress.mockingProgress().getArgumentMatcherStorage().reportMatcher(argumentMatcher);
    return null;
}

HttpClient.HttpRequest requestContainingAddInvokeFunctionStageRequest(String functionId, APIModel.HTTPMethod httpMethod) {
    ArgumentMatcher<HttpClient.HttpRequest> argumentMatcher = httpRequest -> {
        if(httpRequest.method != "POST") {
            System.err.println("Expecting a POST request, got " + httpRequest.method);
            return false;
        }
        try {
            APIModel.AddInvokeFunctionStageRequest addInvokeFunctionStageRequest = objectMapper.readValue(new String(httpRequest.bodyBytes), APIModel.AddInvokeFunctionStageRequest.class);
            if ((addInvokeFunctionStageRequest.functionId != null) &&
                    (addInvokeFunctionStageRequest.functionId.equals(functionId)) &&
                    (addInvokeFunctionStageRequest.arg.method.equals(httpMethod))) {
                return true;
            } else {
                System.err.println("Request body doesn't contain a matching AddInvokeFunctionStageRequest");
            }
            return false;
        } catch (IOException e) {
            System.err.println("Request body doesn't contain an AddInvokeFunctionStageRequest");
            return false;
        }
    };
    ThreadSafeMockingProgress.mockingProgress().getArgumentMatcherStorage().reportMatcher(argumentMatcher);
    return null;
}

static DOMEntityOwnershipChange ownershipChange(final DOMEntity expEntity, final boolean expWasOwner,
        final boolean expIsOwner, final boolean expHasOwner, final boolean expInJeopardy) {
    return Matchers.argThat(new ArgumentMatcher<DOMEntityOwnershipChange>() {
        @Override
        public boolean matches(Object argument) {
            DOMEntityOwnershipChange change = (DOMEntityOwnershipChange) argument;
            return expEntity.equals(change.getEntity()) && expWasOwner == change.getState().wasOwner()
                    && expIsOwner == change.getState().isOwner() && expHasOwner == change.getState().hasOwner()
                    && expInJeopardy == change.inJeopardy();
        }

        @Override
        public void describeTo(Description description) {
            description.appendValue(new DOMEntityOwnershipChange(expEntity, EntityOwnershipChangeState.from(
                    expWasOwner, expIsOwner, expHasOwner), expInJeopardy));
        }
    });
}

protected CreateTransaction eqCreateTransaction(final String expMemberName,
        final TransactionType type) {
    ArgumentMatcher<CreateTransaction> matcher = new ArgumentMatcher<CreateTransaction>() {
        @Override
        public boolean matches(final Object argument) {
            if (CreateTransaction.class.equals(argument.getClass())) {
                CreateTransaction obj = CreateTransaction.fromSerializable(argument);
                return obj.getTransactionId().getHistoryId().getClientId().getFrontendId().getMemberName()
                        .getName().equals(expMemberName) && obj.getTransactionType() == type.ordinal();
            }

            return false;
        }
    };

    return argThat(matcher);
}

private void givenPermissions(String username, String password, Set<Permission> permissions) {
    String credentials = username + ":" + password;
    try {
        String authHeaderValue = "Basic "
                + Base64.getEncoder().encodeToString(credentials.getBytes("UTF-8"));
        given(req.getHeader("Authorization")).willReturn(authHeaderValue);
    } catch (UnsupportedEncodingException e) {
        throw new RuntimeException(e);
    }
    given(securityApi.isSubjectAuthenticated()).willReturn(true);
    given(securityApi
            .getCurrentUserPermissions(Matchers.argThat(new ArgumentMatcher<TenantContext>() {

                @Override
                public boolean matches(Object arg) {
                    return (arg instanceof TenantContext
                            && tenantId.equals(((TenantContext) arg).getTenantId()));
                }

            }))).willReturn(permissions);
}

@Test
public void updateDisableLastSubscriptionAndDisableAlarmOK() throws Exception {
    Alarm alarm = TestUtils.getDefaultAlarm();
    Subscription subscription = alarm.getSubscriptions().get(0);
    subscription.setEnabled(false);

    subscriptionService.updateSubscription(subscription, TestUtils.DEFAULT_ALARM_ID);

    verify(seyrenRepository).updateSubscription(subscription, TestUtils.DEFAULT_ALARM_ID);
    verify(seyrenRepository).updateAlarm(argThat(new ArgumentMatcher<Alarm>() {
        @Override
        public boolean matches(Object argument) {
            Alarm argAlarm = (Alarm) argument;
            return argAlarm.getId().equals(alarm.getId()) && !argAlarm.isEnabled();
        }
    }));
}

@Test
public void updateSubscriptionEnableAlarm() throws Exception {
    // ****
    // Init, set repo to return a fully disabled alarm
    Alarm disabledAlarm = TestUtils.getDefaultAlarm();
    disabledAlarm.getSubscriptions().get(0).setEnabled(false);
    when(seyrenRepository.getAlarm(TestUtils.DEFAULT_ALARM_ID)).thenReturn(disabledAlarm);
    // ****

    Alarm alarm = TestUtils.getDefaultAlarm();
    Subscription subscription = alarm.getSubscriptions().get(0);
    subscription.setEnabled(true);

    subscriptionService.updateSubscription(subscription, TestUtils.DEFAULT_ALARM_ID);

    verify(seyrenRepository).updateSubscription(subscription, TestUtils.DEFAULT_ALARM_ID);
    verify(seyrenRepository).updateAlarm(argThat(new ArgumentMatcher<Alarm>() {
        @Override
        public boolean matches(Object argument) {
            Alarm argAlarm = (Alarm) argument;
            return argAlarm.getId().equals(alarm.getId()) && argAlarm.isEnabled();
        }
    }));
}

/**
 * Verify arbitrary compaction.
 * @param policy Policy to test.
 * @param si Stripe information pre-set with stripes to test.
 * @param sfs Files that should be compacted.
 * @param dropDeletesFrom Row from which to drop deletes.
 * @param dropDeletesTo Row to which to drop deletes.
 * @param boundaries Expected target stripe boundaries.
 */
private void verifyCompaction(StripeCompactionPolicy policy, StripeInformationProvider si,
    Collection<StoreFile> sfs, byte[] dropDeletesFrom, byte[] dropDeletesTo,
    final List<byte[]> boundaries) throws Exception {
  StripeCompactor sc = mock(StripeCompactor.class);
  assertTrue(policy.needsCompactions(si, al()));
  StripeCompactionPolicy.StripeCompactionRequest scr = policy.selectCompaction(si, al(), false);
  verifyCollectionsEqual(sfs, scr.getRequest().getFiles());
  scr.execute(sc, NoLimitCompactionThroughputController.INSTANCE, null);
  verify(sc, times(1)).compact(eq(scr.getRequest()), argThat(new ArgumentMatcher<List<byte[]>>() {
    @Override
    public boolean matches(Object argument) {
      @SuppressWarnings("unchecked")
      List<byte[]> other = (List<byte[]>) argument;
      if (other.size() != boundaries.size()) return false;
      for (int i = 0; i < other.size(); ++i) {
        if (!Bytes.equals(other.get(i), boundaries.get(i))) return false;
      }
      return true;
    }
  }), dropDeletesFrom == null ? isNull(byte[].class) : aryEq(dropDeletesFrom),
    dropDeletesTo == null ? isNull(byte[].class) : aryEq(dropDeletesTo),
    any(NoLimitCompactionThroughputController.class), any(User.class));
}

private Dispatcher getDispatcher() {
  Dispatcher dispatcher = new AsyncDispatcher() {
    @SuppressWarnings({ "rawtypes", "unchecked" })
    @Override
    public EventHandler getEventHandler() {

      class EventArgMatcher extends ArgumentMatcher<AbstractEvent> {
        @Override
        public boolean matches(Object argument) {
          if (argument instanceof RMAppNodeUpdateEvent) {
            ApplicationId appid =
                ((RMAppNodeUpdateEvent) argument).getApplicationId();
            applist.add(appid);
          }
          return false;
        }
      }

      EventHandler handler = spy(super.getEventHandler());
      doNothing().when(handler).handle(argThat(new EventArgMatcher()));
      return handler;
    }
  };
  return dispatcher;
}

@Test
public void shouldCreateAdminUser() throws Exception {
  Injector injector = Guice.createInjector(new OrgModule());
  UserManager userManager = injector.getInstance(UserManager.class);
  when(userManager.getByName(NAME)).thenThrow(new NotFoundException("nfex"));
  when(userManager.create(any(UserImpl.class), anyBoolean())).thenReturn(user);
  injector.getInstance(AdminUserCreator.class);

  verify(userManager).getByName(NAME);
  verify(userManager).create(new UserImpl(NAME, EMAIL, NAME, PASSWORD, emptyList()), false);
  verify(permissionsManager)
      .storePermission(
          argThat(
              (ArgumentMatcher<SystemPermissionsImpl>)
                  argument -> argument.getUserId().equals("qwe")));
}

public static TableModelEvent matches(final TableModelEvent example) {
    return Mockito.argThat(new ArgumentMatcher<TableModelEvent>() {
        @Override
        public void describeTo(Description description) {
            description.appendText(example.getClass().getName())
                    .appendText("[source=").appendText(example.getSource().toString())
                    .appendText(",type=").appendValue(example.getType())
                    .appendText(",column=").appendValue(example.getColumn())
                    .appendText(",firstRow=").appendValue(example.getFirstRow())
                    .appendText(",lastRow=").appendValue(example.getLastRow())
                    .appendText("]");
        }

        @Override
        public boolean matches(Object argument) {
            TableModelEvent actual = (TableModelEvent) argument;
            return actual.getSource() == example.getSource() &&
                    actual.getType() == example.getType() &&
                    actual.getColumn() == example.getColumn() &&
                    actual.getFirstRow() == example.getFirstRow() &&
                    actual.getLastRow() == example.getLastRow();
        }
    });
}

/**
 * A matcher call which matches if an argument contains all the given text
 * 
 * @param expectedParts
 * @return true if all the expected parts match
 */
default String containsAllOf(final CharSequence... expectedParts) {
    return argThat(new ArgumentMatcher<String>() {

        /*
         * (non-Javadoc)
         * 
         * @see org.mockito.ArgumentMatcher#matches(java.lang.Object)
         */
        @Override
        public boolean matches(String argument) {
            return StringUtil.containsAll(argument, expectedParts);
        }

        /*
         * (non-Javadoc)
         * 
         * @see java.lang.Object#toString()
         */
        @Override
        public String toString() {
            return "{String containing all of: " + StringUtil.charSequenceArrayToString(expectedParts) + "}";
        }
    });
}

/**
 * A matcher call which matches if an argument's toString() result contains
 * all of the given text
 * 
 * @param expectedParts
 * @return true if all of the expected parts match, false if one does not
 *         match
 */
default <T> T toStringContainsAllOf(final CharSequence... expectedParts) {
    return argThat(new ArgumentMatcher<T>() {

        /*
         * (non-Javadoc)
         * 
         * @see org.mockito.ArgumentMatcher#matches(java.lang.Object)
         */
        @Override
        public boolean matches(T argument) {
            return StringUtil.containsAll(argument, expectedParts);
        }

        /*
         * (non-Javadoc)
         * 
         * @see java.lang.Object#toString()
         */
        @Override
        public String toString() {
            return "{Object with toString() containing all of: "
                    + StringUtil.charSequenceArrayToString(expectedParts) + "}";
        }
    });
}

/**
 * A matcher call which matches if an argument contains at least one of the
 * given text parts
 * 
 * @param expectedParts
 * @return true if any of the expected parts match, false if none match
 */
default String containsOneOrMoreOf(final CharSequence... expectedParts) {
    return argThat(new ArgumentMatcher<String>() {

        /*
         * (non-Javadoc)
         * 
         * @see org.mockito.ArgumentMatcher#matches(java.lang.Object)
         */
        @Override
        public boolean matches(String argument) {
            return StringUtil.containsOneOrMoreOf(argument, expectedParts);
        }

        /*
         * (non-Javadoc)
         * 
         * @see java.lang.Object#toString()
         */
        @Override
        public String toString() {
            return "{String containing one or more of: " + StringUtil.charSequenceArrayToString(expectedParts)
                    + "}";
        }
    });
}

/**
 * A matcher call which matches if an argument's toString() result contains
 * at least one of the given text
 * 
 * @param expectedParts
 * @return true if any of the expected parts match, false if none match
 */
default <T> T toStringContainsOneOrMoreOf(final CharSequence... expectedParts) {
    return argThat(new ArgumentMatcher<T>() {

        /*
         * (non-Javadoc)
         * 
         * @see org.mockito.ArgumentMatcher#matches(java.lang.Object)
         */
        @Override
        public boolean matches(T argument) {
            return StringUtil.containsOneOrMoreOf(argument, expectedParts);
        }

        /*
         * (non-Javadoc)
         * 
         * @see java.lang.Object#toString()
         */
        @Override
        public String toString() {
            return "{Object with toString() containing one or more of: "
                    + StringUtil.charSequenceArrayToString(expectedParts) + "}";
        }
    });
}

/**
 * Matcher for a map argument
 * 
 * @param predicate
 *            lambda for assessing the map argument
 * @return null
 */
default <K, V> Map<K, V> mapThat(Predicate<Map<K, V>> predicate) {
    // return argThat(map -> predicate.test((Map<K, V>) map));
    return argThat(new ArgumentMatcher<Map<K, V>>() {

        @Override
        public boolean matches(Map<K, V> argument) {
            return predicate.test(argument);
        }

        /*
         * (non-Javadoc)
         * 
         * @see java.lang.Object#toString()
         */
        @Override
        public String toString() {
            return "[Map matching the given Predicate]";
        }
    });
}

/**
 * Matcher for a map argument
 * 
 * @param predicate
 *            lambda for assessing the map argument
 * @param description
 *            Description of expected argument - will appear in verify()
 *            failures
 * @return null
 */
default <K, V> Map<K, V> mapThat(Predicate<Map<K, V>> predicate, final String description) {
    // return argThat(map -> predicate.test((Map<K, V>) map));
    return argThat(new ArgumentMatcher<Map<K, V>>() {

        @Override
        public boolean matches(Map<K, V> argument) {
            return predicate.test(argument);
        }

        /*
         * (non-Javadoc)
         * 
         * @see java.lang.Object#toString()
         */
        @Override
        public String toString() {
            return description;
        }
    });
}

/**
 * A predicate-based matcher for set arguments - all items must match
 * 
 * @param predicate
 * @return null
 */
default <T extends Object> Set<T> allSetItemsMatch(Predicate<T> predicate) {
    return argThat(new ArgumentMatcher<Set<T>>() {

        @Override
        public boolean matches(Set<T> argument) {
            return argument.stream().allMatch(predicate);
        }

        /*
         * (non-Javadoc)
         * 
         * @see java.lang.Object#toString()
         */
        @Override
        public String toString() {
            return "[All items matching the given Predicate]";
        }
    });
}

@Test
public void skipTests() throws Exception {
    releaseInvoker.setSkipTests(true);
    releaseInvoker.runMavenBuild(reactor);
    verify(request).setProperties(Mockito.argThat(new ArgumentMatcher<Properties>() {

        @Override
        public boolean matches(final Properties env) {
            return env.containsKey(SKIP_TESTS);
        }
    }));
    verify(request).setGoals(Mockito.argThat(new ArgumentMatcher<List<String>>() {

        @Override
        public boolean matches(final List<String> goals) {
            return goals.size() == 1 && goals.contains(DEPLOY);
        }
    }));
}