Java 类org.mockito.hamcrest.MockitoHamcrest 实例源码

/**
 * Exec can catch in case of an error.
 * @throws Exception If some problem inside
 */
@Test
public void catchesExceptions() throws Exception {
    final Agent agent = Mockito.mock(Agent.class);
    final Events events = Mockito.mock(Events.class);
    Mockito.doThrow(new IOException("<bug>")).when(agent).push(events);
    new Exec(agent, events, new FkPipe()).run();
    Mockito.verify(events).post(
        MockitoHamcrest.argThat(
            Matchers.startsWith(
                "Internal error (java.io.IOException): \"&lt;bug&gt;\""
            )
        ),
        MockitoHamcrest.argThat(
            Matchers.containsString(
                "java.io.IOException: &lt;bug&gt;\n"
            )
        )
    );
}

@Test
public void testWarningSink() {
    final List<String> reasons = new ArrayList<>();
    reasons.add("reason1");
    reasons.add("reason2");

    final Logger logger = Mockito.mock(Logger.class);
    final Event event = Mockito.mock(Event.class);
    final Sink sink = new WarningSink.Builder()
            .setReasons(reasons)
            .setLogger(logger)
            .build();

    final String asString = sink.toString();
    Assert.assertNotNull(asString);
    Assert.assertFalse(asString.isEmpty());
    Assert.assertTrue(asString.contains(reasons.get(0)));
    Assert.assertTrue(asString.contains(reasons.get(1)));

    sink.record(event);

    Mockito.verifyZeroInteractions(event);
    Mockito.verify(logger).warn(MockitoHamcrest.argThat(
            Matchers.containsString(reasons.toString())));
}

@Test
@SuppressFBWarnings("NP_NONNULL_PARAM_VIOLATION")
public void testWarningSinkBuilderNullReasons() {
    final Logger logger = Mockito.mock(Logger.class);
    final Event event = Mockito.mock(Event.class);
    final Sink sink = new WarningSink.Builder()
            .setReasons(null)
            .setLogger(logger)
            .build();

    sink.record(event);

    Mockito.verifyZeroInteractions(event);
    Mockito.verify(logger).warn(MockitoHamcrest.argThat(
            Matchers.containsString("Reasons must be a non-null list")));
}

/**
 * ExceptionDecor can transform exception to text.
 * @throws Exception If some problem
 */
@Test
public void convertsExceptionToText() throws Exception {
    final Formattable decor = new ExceptionDecor(new IOException("ouch!"));
    final Appendable dest = Mockito.mock(Appendable.class);
    final Formatter fmt = new Formatter(dest);
    decor.formatTo(fmt, 0, 0, 0);
    Mockito.verify(dest).append(
        MockitoHamcrest.argThat(
            Matchers.allOf(
                Matchers.containsString(
                    "java.io.IOException: ouch!"
                ),
                Matchers.containsString(
                    "at com.jcabi.log.ExceptionDecorTest."
                )
            )
        )
    );
}

private static DeliveryOptions withTimeout(final Long expectedTimeout) {
    return MockitoHamcrest.argThat(new FeatureMatcher<DeliveryOptions, Long>(IsEqual.equalTo(expectedTimeout), "timeout", "timeout") {
        @Override
        protected Long featureValueOf(DeliveryOptions deliveryOptions) {
            return deliveryOptions.getSendTimeout();
        }
    });
}

private static DeliveryOptions withTimeout(final Long expectedTimeout) {
    return MockitoHamcrest.argThat(new FeatureMatcher<DeliveryOptions, Long>(IsEqual.equalTo(expectedTimeout), "timeout", "timeout") {
        @Override
        protected Long featureValueOf(DeliveryOptions deliveryOptions) {
            return deliveryOptions.getSendTimeout();
        }
    });
}

@Test
public void testCreateCounterNotOpen() {
    final org.slf4j.Logger logger = createSlf4jLoggerMock();
    final Sink sink = Mockito.mock(Sink.class);
    @SuppressWarnings("resource")
    final TsdMetrics metrics = createTsdMetrics(logger, sink);
    metrics.close();
    final Counter counter = metrics.createCounter("counter-closed");
    Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class)));
    Assert.assertNotNull(counter);
}

@Test
public void testIncrementCounterNotOpen() {
    final org.slf4j.Logger logger = createSlf4jLoggerMock();
    final Sink sink = Mockito.mock(Sink.class);
    @SuppressWarnings("resource")
    final TsdMetrics metrics = createTsdMetrics(logger, sink);
    metrics.close();
    metrics.incrementCounter("counter-closed");
    Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class)));
}

@Test
public void testResetCounterNotOpen() {
    final org.slf4j.Logger logger = createSlf4jLoggerMock();
    final Sink sink = Mockito.mock(Sink.class);
    @SuppressWarnings("resource")
    final TsdMetrics metrics = createTsdMetrics(logger, sink);
    metrics.close();
    metrics.resetCounter("counter-closed");
    Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class)));
}

@Test
public void testSetGaugeDoubleNotOpen() {
    final org.slf4j.Logger logger = createSlf4jLoggerMock();
    final Sink sink = Mockito.mock(Sink.class);
    @SuppressWarnings("resource")
    final TsdMetrics metrics = createTsdMetrics(logger, sink);
    metrics.close();
    metrics.setGauge("gauge-closed", 1.23);
    Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class)));
}

@Test
public void testSetGaugeLongNotOpen() {
    final org.slf4j.Logger logger = createSlf4jLoggerMock();
    final Sink sink = Mockito.mock(Sink.class);
    @SuppressWarnings("resource")
    final TsdMetrics metrics = createTsdMetrics(logger, sink);
    metrics.close();
    metrics.setGauge("gauge-closed", 10L);
    Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class)));
}

@Test
public void testCreateTimerNotOpen() {
    final org.slf4j.Logger logger = createSlf4jLoggerMock();
    final Sink sink = Mockito.mock(Sink.class);
    @SuppressWarnings("resource")
    final TsdMetrics metrics = createTsdMetrics(logger, sink);
    metrics.close();
    final Timer timer = metrics.createTimer("timer-closed");
    Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class)));
    Assert.assertNotNull(timer);
}

@Test
public void testSetTimerNotOpenTimeUnit() {
    final org.slf4j.Logger logger = createSlf4jLoggerMock();
    final Sink sink = Mockito.mock(Sink.class);
    @SuppressWarnings("resource")
    final TsdMetrics metrics = createTsdMetrics(logger, sink);
    metrics.close();
    metrics.setTimer("timer-closed", 1L, TimeUnit.MILLISECONDS);
    Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class)));
}

@Test
public void testStartTimerNotOpen() {
    final org.slf4j.Logger logger = createSlf4jLoggerMock();
    final Sink sink = Mockito.mock(Sink.class);
    @SuppressWarnings("resource")
    final TsdMetrics metrics = createTsdMetrics(logger, sink);
    metrics.close();
    metrics.startTimer("timer-closed");
    Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class)));
}

@Test
public void testStopTimerNotOpen() {
    final org.slf4j.Logger logger = createSlf4jLoggerMock();
    final Sink sink = Mockito.mock(Sink.class);
    @SuppressWarnings("resource")
    final TsdMetrics metrics = createTsdMetrics(logger, sink);
    metrics.close();
    metrics.stopTimer("timer-closed");
    Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class)));
}

@Test
public void testAddAnnotationNotOpen() {
    final org.slf4j.Logger logger = createSlf4jLoggerMock();
    final Sink sink = Mockito.mock(Sink.class);
    @SuppressWarnings("resource")
    final TsdMetrics metrics = createTsdMetrics(logger, sink);
    metrics.close();
    metrics.addAnnotation("key", "value");
    Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class)));
}

@Test
public void testAddAnnotationsNotOpen() {
    final org.slf4j.Logger logger = createSlf4jLoggerMock();
    final Sink sink = Mockito.mock(Sink.class);
    @SuppressWarnings("resource")
    final TsdMetrics metrics = createTsdMetrics(logger, sink);
    metrics.close();
    // CHECKSTYLE.OFF: IllegalInstantiation - No Guava
    final Map<String, String> annotations = new HashMap<>();
    // CHECKSTYLE.ON: IllegalInstantiation
    annotations.put("key1", "value1");
    annotations.put("key2", "value2");
    metrics.addAnnotations(annotations);
    Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class)));
}

@Test
public void testCloseNotOpen() {
    final org.slf4j.Logger logger = createSlf4jLoggerMock();
    final Sink sink = Mockito.mock(Sink.class);
    @SuppressWarnings("resource")
    final TsdMetrics metrics = createTsdMetrics(logger, sink);
    metrics.close();
    Mockito.verifyZeroInteractions(logger);
    metrics.close();
    Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class)));
}

@Test
public void testStartTimerAlreadyStarted() {
    final org.slf4j.Logger logger = createSlf4jLoggerMock();
    final Sink sink = Mockito.mock(Sink.class);
    final TsdMetrics metrics = createTsdMetrics(logger, sink);
    metrics.startTimer("timer-already-started");
    metrics.startTimer("timer-already-started");
    Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class)));
}

@Test
public void testStopTimerNotStarted() {
    final org.slf4j.Logger logger = createSlf4jLoggerMock();
    final Sink sink = Mockito.mock(Sink.class);
    final TsdMetrics metrics = createTsdMetrics(logger, sink);
    metrics.stopTimer("timer-not-started");
    Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class)));
}

@Test
public void testStopTimerAlreadyStopped() {
    final org.slf4j.Logger logger = createSlf4jLoggerMock();
    final Sink sink = Mockito.mock(Sink.class);
    final TsdMetrics metrics = createTsdMetrics(logger, sink);
    metrics.startTimer("timer-already-stopped");
    metrics.stopTimer("timer-already-stopped");
    Mockito.verifyZeroInteractions(logger);
    metrics.stopTimer("timer-already-stopped");
    Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class)));
}

@Test
public void testIncrementAfterClose() {
    final AtomicBoolean isOpen = new AtomicBoolean(true);
    final Logger logger = Mockito.mock(Logger.class);
    final TsdCounter counter = new TsdCounter("counterName", isOpen, logger);
    counter.increment();
    isOpen.set(false);
    Mockito.verifyZeroInteractions(logger);
    counter.increment();
    Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class)));
}

@Test
public void testIncrementByValueAfterClose() {
    final AtomicBoolean isOpen = new AtomicBoolean(true);
    final Logger logger = Mockito.mock(Logger.class);
    final TsdCounter counter = new TsdCounter("counterName", isOpen, logger);
    counter.increment(2L);
    isOpen.set(false);
    Mockito.verifyZeroInteractions(logger);
    counter.increment(2L);
    Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class)));
}

@Test
public void testDecrementAfterClose() {
    final AtomicBoolean isOpen = new AtomicBoolean(true);
    final Logger logger = Mockito.mock(Logger.class);
    final TsdCounter counter = new TsdCounter("counterName", isOpen, logger);
    counter.decrement();
    isOpen.set(false);
    Mockito.verifyZeroInteractions(logger);
    counter.decrement();
    Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class)));
}

@Test
public void testDecrementByValueAfterClose() {
    final AtomicBoolean isOpen = new AtomicBoolean(true);
    final Logger logger = Mockito.mock(Logger.class);
    final TsdCounter counter = new TsdCounter("counterName", isOpen, logger);
    counter.decrement(2L);
    isOpen.set(false);
    Mockito.verifyZeroInteractions(logger);
    counter.decrement(2L);
    Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class)));
}

@Test
public void testAlreadyStopped() {
    final AtomicBoolean isOpen = new AtomicBoolean(true);
    final Logger logger = createSlf4jLoggerMock();
    @SuppressWarnings("resource")
    final TsdTimer timer = new TsdTimer("timerName", isOpen, logger);
    timer.close();
    Mockito.verifyZeroInteractions(logger);
    timer.close();
    Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class)));
}

@Test
public void testAlreadyStoppedRaceCondition() {
    final AtomicBoolean isOpen = new AtomicBoolean(true);
    final Logger logger = createSlf4jLoggerMock();
    final StopWatch stopWatch = Mockito.mock(StopWatch.class);
    Mockito.doReturn(true).when(stopWatch).isRunning();
    Mockito.doThrow(new IllegalStateException("Stopwatch already stopped")).when(stopWatch).stop();
    @SuppressWarnings("resource")
    final TsdTimer timer = new TsdTimer("timerName", isOpen, stopWatch, logger);
    timer.close();
    Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class)));
}

@Test
public void testAlreadyAborted() {
    final AtomicBoolean isOpen = new AtomicBoolean(true);
    final Logger logger = createSlf4jLoggerMock();
    @SuppressWarnings("resource")
    final TsdTimer timer = new TsdTimer("timerName", isOpen, logger);
    timer.abort();
    Mockito.verifyZeroInteractions(logger);
    timer.abort();
    Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class)));
}

@Test
public void testStopAfterAbort() {
    final AtomicBoolean isOpen = new AtomicBoolean(true);
    final Logger logger = createSlf4jLoggerMock();
    @SuppressWarnings("resource")
    final TsdTimer timer = new TsdTimer("timerName", isOpen, logger);
    timer.abort();
    Mockito.verifyZeroInteractions(logger);
    timer.close();
    Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class)));
}

@Test
public void testAbortAfterStop() {
    final AtomicBoolean isOpen = new AtomicBoolean(true);
    final Logger logger = createSlf4jLoggerMock();
    @SuppressWarnings("resource")
    final TsdTimer timer = new TsdTimer("timerName", isOpen, logger);
    timer.close();
    Mockito.verifyZeroInteractions(logger);
    timer.abort();
    Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class)));
}

@Test
public void testStopAfterMetricsClosed() {
    final org.slf4j.Logger logger = createSlf4jLoggerMock();
    final AtomicBoolean isOpen = new AtomicBoolean(true);
    @SuppressWarnings("resource")
    final TsdTimer timer = new TsdTimer("timerName", isOpen, logger);
    isOpen.set(false);
    Mockito.verify(logger, Mockito.never()).warn(MockitoHamcrest.argThat(Matchers.any(String.class)));
    timer.close();
    Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class)));
}

@Test
public void testAbortAfterMetricsClosed() {
    final org.slf4j.Logger logger = createSlf4jLoggerMock();
    final AtomicBoolean isOpen = new AtomicBoolean(true);
    @SuppressWarnings("resource")
    final TsdTimer timer = new TsdTimer("timerName", isOpen, logger);
    isOpen.set(false);
    Mockito.verify(logger, Mockito.never()).warn(MockitoHamcrest.argThat(Matchers.any(String.class)));
    timer.abort();
    Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class)));
}

@Test
public void testGetElapsedAfterStop() {
    final org.slf4j.Logger logger = createSlf4jLoggerMock();
    final AtomicBoolean isOpen = new AtomicBoolean(true);
    @SuppressWarnings("resource")
    final TsdTimer timer = new TsdTimer("timerName", isOpen, logger);
    Mockito.verify(logger, Mockito.never()).warn(MockitoHamcrest.argThat(Matchers.any(String.class)));
    timer.getValue();
    Mockito.verify(logger).warn(MockitoHamcrest.argThat(Matchers.any(String.class)));
    timer.getUnit();
    Mockito.verify(logger, Mockito.times(2)).warn(MockitoHamcrest.argThat(Matchers.any(String.class)));
}

@Test
public void testWarningSinkBuilderEmptyReasons() {
    final Logger logger = Mockito.mock(Logger.class);
    final Event event = Mockito.mock(Event.class);
    final Sink sink = new WarningSink.Builder()
            .setReasons(Collections.emptyList())
            .setLogger(logger)
            .build();

    sink.record(event);

    Mockito.verifyZeroInteractions(event);
    Mockito.verify(logger).warn(MockitoHamcrest.argThat(
            Matchers.containsString("Reasons must be a non-empty list")));
}

@Test
@SuppressWarnings({"unchecked", "rawtypes"})
public void testStandardLogSecondTimeAfterDuration() throws InterruptedException {
    final Logger rateLimitLogger = new RateLimitLogger(_slf4jLogger, Duration.ofSeconds(1), Clock.systemUTC());
    final Instant beforeLastLog = Instant.now();
    rateLimitLogger.info("m1");
    final Instant afterLastLog = Instant.now();
    Mockito.verify(_slf4jLogger, Mockito.atLeastOnce()).isInfoEnabled();
    Mockito.verify(_slf4jLogger).info(
            StenoMarker.ARRAY_MARKER,
            null,
            new String[]{"message", "_skipped", "_lastLogTime"},
            new Object[]{"m1", 0, null});

    Mockito.verifyNoMoreInteractions(_slf4jLogger);
    Thread.sleep(500);
    rateLimitLogger.info("m2");  // Rate limited but counted
    rateLimitLogger.debug("m3"); // Dropped and not counted
    Mockito.reset(_slf4jLogger);
    Mockito.doReturn(Boolean.TRUE).when(_slf4jLogger).isInfoEnabled();
    Thread.sleep(1500);

    rateLimitLogger.info("m4");
    Mockito.verify(_slf4jLogger, Mockito.atLeastOnce()).isInfoEnabled();
    Mockito.verify(_slf4jLogger).info(
            MockitoHamcrest.argThat(Matchers.sameInstance(StenoMarker.ARRAY_MARKER)),
            MockitoHamcrest.argThat(Matchers.nullValue(String.class)),
            MockitoHamcrest.argThat(Matchers.arrayContaining("message", "_skipped", "_lastLogTime")),
            MockitoHamcrest.argThat(
                    Matchers.array(new org.hamcrest.Matcher[]{
                            Matchers.<Object>equalTo("m4"),
                            Matchers.<Object>equalTo(1),
                            isBetween(beforeLastLog, afterLastLog)})));
}

/**
 * DocumentDecor can transform Document to text.
 * @throws Exception If some problem
 */
@Test
public void convertsDocumentToText() throws Exception {
    final Document doc = DocumentBuilderFactory.newInstance()
        .newDocumentBuilder().newDocument();
    doc.appendChild(doc.createElement("root"));
    final Formattable decor = new DomDecor(doc);
    final Appendable dest = Mockito.mock(Appendable.class);
    final Formatter fmt = new Formatter(dest);
    decor.formatTo(fmt, 0, 0, 0);
    Mockito.verify(dest).append(
        MockitoHamcrest.argThat(Matchers.containsString("<root/>"))
    );
}

public static Predicate predicateWithSelection(CharSequence expectedSelection)
{
    return MockitoHamcrest.argThat(new PredicateMatcher.Selection(Absent.<TransactionContext>absent(), expectedSelection));
}

public static Predicate predicateWithSelection(TransactionContext tc, CharSequence expectedSelection)
{
    return MockitoHamcrest.argThat(new PredicateMatcher.Selection(new Present<>(tc), expectedSelection));
}

@Test
public void testLogBuilderSecondTimeAfterDuration() throws InterruptedException {
    final Logger rateLimitLogger = new RateLimitLogger(_slf4jLogger, Duration.ofSeconds(1), Clock.systemUTC());
    final Instant beforeLastLog = Instant.now();
    rateLimitLogger.info().setMessage("m1").log();
    final Instant afterLastLog = Instant.now();
    Mockito.verify(_slf4jLogger, Mockito.atLeastOnce()).isInfoEnabled();
    Mockito.verify(_slf4jLogger).info(
            StenoMarker.LISTS_MARKER,
            null,
            Arrays.asList("message", "_skipped", "_lastLogTime"),
            Arrays.asList("m1", 0, null),
            Collections.emptyList(),
            Collections.emptyList());

    Mockito.verifyNoMoreInteractions(_slf4jLogger);
    Thread.sleep(500);
    rateLimitLogger.info().setMessage("m2").log();  // Rate limited but counted
    rateLimitLogger.debug().setMessage("m3").log(); // Dropped and not counted
    Mockito.reset(_slf4jLogger);
    Mockito.doReturn(Boolean.TRUE).when(_slf4jLogger).isInfoEnabled();
    Thread.sleep(1500);

    rateLimitLogger.info().setMessage("m4").log();
    Mockito.verify(_slf4jLogger, Mockito.atLeastOnce()).isInfoEnabled();
    Mockito.verify(_slf4jLogger).info(
            MockitoHamcrest.argThat(Matchers.sameInstance(StenoMarker.LISTS_MARKER)),
            MockitoHamcrest.argThat(Matchers.nullValue(String.class)),
            MockitoHamcrest.argThat(Matchers.contains("message", "_skipped", "_lastLogTime")),
            // This is brutal; for some reason a capture would not work here and the
            // contains(Matcher...) was getting mapped to contains(E...) even with
            // casting. So the matcher chain below manually asserts that the list
            // contains the three items in question.
            MockitoHamcrest.argThat(
                    Matchers.allOf(
                            Matchers.iterableWithSize(3),
                            Matchers.hasItem("m4"),
                            Matchers.hasItem(1),
                            Matchers.hasItem(isBetween(beforeLastLog, afterLastLog)))),
            MockitoHamcrest.argThat(Matchers.equalTo(Collections.emptyList())),
            MockitoHamcrest.argThat(Matchers.equalTo(Collections.emptyList())));
}

@Test
public void strikesWeakestCandidateIfNoCandidateReachedTheQuorum() {
    ImmutableList<VoteState<Candidate>> voteStates = ImmutableList.of(
        stateFor(AC_BALLOT),
        stateFor(A_BALLOT),
        stateFor(ACGH_BALLOT),
        stateFor(BC_BALLOT)
    );

    ElectionStepResult<Candidate> electionStepResult = step
        .declareWinnerOrStrikeCandidate(FIVE, voteStates, redistributorMock, 1, CANDIDATE_STATES);

    verify(electionCalculationListenerMock).nobodyReachedTheQuorumYet(FIVE);

    verify(electionCalculationListenerMock).candidateDropped(
        argThat(
            is(aVoteDistribution(withVotesForCandidate(A, THREE), withVotesForCandidate(B, ONE),
                                 withVotesForCandidate(C, ZERO)))),
        eq(C)
    );

    Matcher<Iterable<? extends VoteState<Candidate>>> newVoteStatesMatcher = containsInAnyOrder(
        aVoteState(allOf(
            withPreferredCandidate(A),
            withVoteWeight(ONE)
        )),
        aVoteState(allOf(
            withPreferredCandidate(A),
            withVoteWeight(ONE)
        )),
        aVoteState(allOf(
            withPreferredCandidate(A),
            withVoteWeight(ONE)
        )),
        aVoteState(allOf(
            withPreferredCandidate(B),
            withVoteWeight(ONE)
        ))
    );
    verify(electionCalculationListenerMock)
        .voteWeightRedistributionCompleted(eq(voteStates),
                                           MockitoHamcrest.<ImmutableCollection>argThat((Matcher) newVoteStatesMatcher),
                                           argThat(is(aVoteDistribution(
                                               withVotesForCandidate(A, THREE),
                                               withVotesForCandidate(B, ONE),
                                               withNoVotes(ZERO),
                                               withInvalidVotes(ZERO)))));

    assertThat(electionStepResult, is(anElectionStepResult(allOf(
        withCandidateStates(withLooser(C)),
        withNumberOfElectedCandidates(is(1L)),
        withVoteStates(newVoteStatesMatcher)
    ))));
}