verifyZeroInteractions guarantees zero interactions instead of just delegating to verifyNoMoreInteractions (#995)
* Fixes #989
Introducing verifyNoInteractions, that checks if the number of
invocations on given mock(s) is zero, failing otherwise
* Added missing (?) @Test annotation
* Removed try catch block by using isMock
diff --git a/src/main/java/org/mockito/BDDMockito.java b/src/main/java/org/mockito/BDDMockito.java
index 9090fa8..ef478a1 100644
--- a/src/main/java/org/mockito/BDDMockito.java
+++ b/src/main/java/org/mockito/BDDMockito.java
@@ -259,6 +259,12 @@
* @since 2.1.0
*/
void shouldHaveNoMoreInteractions();
+
+ /**
+ * @see #verifyNoInteractions(Object...)
+ * @since 3.0.0
+ */
+ void shouldHaveNoInteractions();
}
private static class ThenImpl<T> implements Then<T> {
@@ -304,12 +310,22 @@
/**
* @see #verifyZeroInteractions(Object...)
* @since 2.1.0
+ * @deprecated Since 3.0.0. Please migrate your code to {@link #shouldHaveNoInteractions()}
*/
+ @Deprecated
public void shouldHaveZeroInteractions() {
verifyZeroInteractions(mock);
}
/**
+ * @see #verifyNoInteractions(Object...)
+ * @since 3.0.0
+ */
+ public void shouldHaveNoInteractions() {
+ verifyNoInteractions(mock);
+ }
+
+ /**
* @see #verifyNoMoreInteractions(Object...)
* @since 2.1.0
*/
diff --git a/src/main/java/org/mockito/Mockito.java b/src/main/java/org/mockito/Mockito.java
index 73ff1f2..c469ac0 100644
--- a/src/main/java/org/mockito/Mockito.java
+++ b/src/main/java/org/mockito/Mockito.java
@@ -2010,12 +2010,34 @@
* See examples in javadoc for {@link Mockito} class
*
* @param mocks to be verified
+ * @deprecated Since 3.0.0. Please migrate your code to {@link #verifyNoInteractions(Object...)}
*/
+ @Deprecated
public static void verifyZeroInteractions(Object... mocks) {
MOCKITO_CORE.verifyNoMoreInteractions(mocks);
}
/**
+ * Verifies that no interactions happened on given mocks.
+ * <pre class="code"><code class="java">
+ * verifyNoInteractions(mockOne, mockTwo);
+ * </code></pre>
+ * This method will also detect invocations
+ * that occurred before the test method, for example: in <code>setUp()</code>, <code>@Before</code> method or in constructor.
+ * Consider writing nice code that makes interactions only in test methods.
+ * <p>
+ * See also {@link Mockito#never()} - it is more explicit and communicates the intent well.
+ * <p>
+ * See examples in javadoc for {@link Mockito} class
+ *
+ * @since 3.0.0
+ * @param mocks to be verified
+ */
+ public static void verifyNoInteractions(Object... mocks) {
+ MOCKITO_CORE.verifyNoInteractions(mocks);
+ }
+
+ /**
* Use <code>doThrow()</code> when you want to stub the void method with an exception.
* <p>
* Stubbing voids requires different approach from {@link Mockito#when(Object)} because the compiler
diff --git a/src/main/java/org/mockito/internal/MockitoCore.java b/src/main/java/org/mockito/internal/MockitoCore.java
index 791e0d1..ba93131 100644
--- a/src/main/java/org/mockito/internal/MockitoCore.java
+++ b/src/main/java/org/mockito/internal/MockitoCore.java
@@ -19,6 +19,7 @@
import static org.mockito.internal.util.MockUtil.isMock;
import static org.mockito.internal.util.MockUtil.resetMock;
import static org.mockito.internal.util.MockUtil.typeMockabilityOf;
+import static org.mockito.internal.verification.VerificationModeFactory.noInteractions;
import static org.mockito.internal.verification.VerificationModeFactory.noMoreInteractions;
import java.util.Arrays;
@@ -137,6 +138,28 @@
VerificationModeFactory.noMoreInteractions().verifyInOrder(data);
}
+ /**
+ * Verifies that given mocks have been invoked zero times, failing otherwise
+ *
+ * @since 3.0.0
+ * @param mocks the mocks to verify
+ */
+ public void verifyNoInteractions(Object... mocks) {
+ assertMocksNotEmpty(mocks);
+ mockingProgress().validateState();
+ for (Object mock : mocks) {
+ if (mock == null) {
+ throw nullPassedToVerifyNoMoreInteractions();
+ }
+ if (!isMock(mock)) {
+ throw notAMockPassedToVerifyNoMoreInteractions();
+ }
+ InvocationContainer invocations = getMockHandler(mock).getInvocationContainer();
+ VerificationDataImpl data = new VerificationDataImpl(invocations, null);
+ noInteractions().verify(data);
+ }
+ }
+
private void assertMocksNotEmpty(Object[] mocks) {
if (mocks == null || mocks.length == 0) {
throw mocksHaveToBePassedToVerifyNoMoreInteractions();
diff --git a/src/main/java/org/mockito/internal/exceptions/Reporter.java b/src/main/java/org/mockito/internal/exceptions/Reporter.java
index 7544557..05db983 100644
--- a/src/main/java/org/mockito/internal/exceptions/Reporter.java
+++ b/src/main/java/org/mockito/internal/exceptions/Reporter.java
@@ -185,7 +185,7 @@
"Method requires argument(s)!",
"Pass mocks that should be verified, e.g:",
" verifyNoMoreInteractions(mockOne, mockTwo);",
- " verifyZeroInteractions(mockOne, mockTwo);",
+ " verifyNoInteractions(mockOne, mockTwo);",
""
));
}
@@ -195,7 +195,7 @@
"Argument(s) passed is not a mock!",
"Examples of correct verifications:",
" verifyNoMoreInteractions(mockOne, mockTwo);",
- " verifyZeroInteractions(mockOne, mockTwo);",
+ " verifyNoInteractions(mockOne, mockTwo);",
""
));
}
@@ -205,7 +205,7 @@
"Argument(s) passed is null!",
"Examples of correct verifications:",
" verifyNoMoreInteractions(mockOne, mockTwo);",
- " verifyZeroInteractions(mockOne, mockTwo);"
+ " verifyNoInteractions(mockOne, mockTwo);"
));
}
@@ -443,6 +443,23 @@
));
}
+ public static MockitoAssertionError noInteractionsWanted(Object mock, List<VerificationAwareInvocation> invocations) {
+ ScenarioPrinter scenarioPrinter = new ScenarioPrinter();
+ String scenario = scenarioPrinter.print(invocations);
+
+ List<Location> locations = new ArrayList<Location>();
+ for (VerificationAwareInvocation invocation : invocations) {
+ locations.add(invocation.getLocation());
+ }
+ return new NoInteractionsWanted(join(
+ "No interactions wanted here:",
+ new LocationImpl(),
+ "But found these interactions on mock '" + safelyGetMockName(mock) + "':",
+ join("", locations),
+ scenario
+ ));
+ }
+
public static MockitoAssertionError noMoreInteractionsWantedInOrder(Invocation undesired) {
return new VerificationInOrderFailure(join(
"No interactions wanted here:",
diff --git a/src/main/java/org/mockito/internal/verification/NoInteractions.java b/src/main/java/org/mockito/internal/verification/NoInteractions.java
new file mode 100644
index 0000000..854a77c
--- /dev/null
+++ b/src/main/java/org/mockito/internal/verification/NoInteractions.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+
+package org.mockito.internal.verification;
+
+import java.util.List;
+
+import org.mockito.internal.verification.api.VerificationData;
+import org.mockito.invocation.Invocation;
+import org.mockito.verification.VerificationMode;
+
+import static org.mockito.internal.exceptions.Reporter.noInteractionsWanted;
+
+public class NoInteractions implements VerificationMode {
+
+ @SuppressWarnings("unchecked")
+ public void verify(VerificationData data) {
+ List<Invocation> invocations = data.getAllInvocations();
+ if (!invocations.isEmpty()) {
+ throw noInteractionsWanted(invocations.get(0).getMock(), (List) invocations);
+ }
+ }
+
+ @Override
+ public VerificationMode description(String description) {
+ return VerificationModeFactory.description(this, description);
+ }
+}
diff --git a/src/main/java/org/mockito/internal/verification/VerificationModeFactory.java b/src/main/java/org/mockito/internal/verification/VerificationModeFactory.java
index 1f8e8b6..9ba2499 100644
--- a/src/main/java/org/mockito/internal/verification/VerificationModeFactory.java
+++ b/src/main/java/org/mockito/internal/verification/VerificationModeFactory.java
@@ -33,6 +33,10 @@
return new NoMoreInteractions();
}
+ public static NoInteractions noInteractions() {
+ return new NoInteractions();
+ }
+
public static VerificationMode atMost(int maxNumberOfInvocations) {
return new AtMost(maxNumberOfInvocations);
}
diff --git a/src/test/java/org/mockito/MockitoTest.java b/src/test/java/org/mockito/MockitoTest.java
index 3b96aff..c25be8d 100644
--- a/src/test/java/org/mockito/MockitoTest.java
+++ b/src/test/java/org/mockito/MockitoTest.java
@@ -12,6 +12,7 @@
import java.util.List;
import org.junit.Test;
import org.mockito.exceptions.misusing.NotAMockException;
+import org.mockito.exceptions.misusing.NullInsteadOfMockException;
import org.mockito.internal.creation.MockSettingsImpl;
@SuppressWarnings("unchecked")
@@ -46,6 +47,16 @@
}
@Test(expected=NotAMockException.class)
+ public void shouldValidateMockWhenVerifyingNoInteractions() {
+ Mockito.verifyNoInteractions("notMock");
+ }
+
+ @Test(expected=NullInsteadOfMockException.class)
+ public void shouldValidateNullMockWhenVerifyingNoInteractions() {
+ Mockito.verifyNoInteractions(new Object[] { null });
+ }
+
+ @Test(expected=NotAMockException.class)
public void shouldValidateMockWhenCreatingInOrderObject() {
Mockito.inOrder("notMock");
}
diff --git a/src/test/java/org/mockito/internal/InvalidStateDetectionTest.java b/src/test/java/org/mockito/internal/InvalidStateDetectionTest.java
index 850b949..d326409 100644
--- a/src/test/java/org/mockito/internal/InvalidStateDetectionTest.java
+++ b/src/test/java/org/mockito/internal/InvalidStateDetectionTest.java
@@ -64,6 +64,9 @@
detectsAndCleansUp(new OnVerifyZeroInteractions(), UnfinishedStubbingException.class);
when(mock.simpleMethod());
+ detectsAndCleansUp(new OnVerifyNoInteractions(), UnfinishedStubbingException.class);
+
+ when(mock.simpleMethod());
detectsAndCleansUp(new OnVerifyNoMoreInteractions(), UnfinishedStubbingException.class);
when(mock.simpleMethod());
@@ -88,6 +91,9 @@
detectsAndCleansUp(new OnVerifyZeroInteractions(), UnfinishedStubbingException.class);
doAnswer(null);
+ detectsAndCleansUp(new OnVerifyNoInteractions(), UnfinishedStubbingException.class);
+
+ doAnswer(null);
detectsAndCleansUp(new OnVerifyNoMoreInteractions(), UnfinishedStubbingException.class);
doAnswer(null);
@@ -109,6 +115,9 @@
detectsAndCleansUp(new OnVerifyZeroInteractions(), UnfinishedVerificationException.class);
verify(mock);
+ detectsAndCleansUp(new OnVerifyNoInteractions(), UnfinishedVerificationException.class);
+
+ verify(mock);
detectsAndCleansUp(new OnVerifyNoMoreInteractions(), UnfinishedVerificationException.class);
verify(mock);
@@ -127,6 +136,9 @@
detectsAndCleansUp(new OnVerifyZeroInteractions(), InvalidUseOfMatchersException.class);
anyObject();
+ detectsAndCleansUp(new OnVerifyNoInteractions(), InvalidUseOfMatchersException.class);
+
+ anyObject();
detectsAndCleansUp(new OnVerifyNoMoreInteractions(), InvalidUseOfMatchersException.class);
anyObject();
@@ -184,6 +196,12 @@
}
}
+ private static class OnVerifyNoInteractions implements DetectsInvalidState {
+ public void detect(IMethods mock) {
+ verifyNoInteractions(mock);
+ }
+ }
+
private static class OnVerifyNoMoreInteractions implements DetectsInvalidState {
public void detect(IMethods mock) {
verifyNoMoreInteractions(mock);
diff --git a/src/test/java/org/mockito/internal/verification/NoInteractionsTest.java b/src/test/java/org/mockito/internal/verification/NoInteractionsTest.java
new file mode 100644
index 0000000..9d268d7
--- /dev/null
+++ b/src/test/java/org/mockito/internal/verification/NoInteractionsTest.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2017 Mockito contributors
+ * This program is made available under the terms of the MIT License.
+ */
+package org.mockito.internal.verification;
+
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+import org.mockito.exceptions.verification.NoInteractionsWanted;
+import org.mockito.internal.creation.MockSettingsImpl;
+import org.mockito.internal.invocation.InvocationBuilder;
+import org.mockito.internal.invocation.InvocationMatcher;
+import org.mockito.internal.stubbing.InvocationContainerImpl;
+import org.mockitousage.IMethods;
+import org.mockitoutil.TestBase;
+
+import static junit.framework.TestCase.*;
+import static org.mockito.Mockito.mock;
+
+public class NoInteractionsTest extends TestBase {
+
+ @Test
+ public void noInteractionsExceptionMessageShouldDescribeMock() {
+ //given
+ NoInteractions n = new NoInteractions();
+ IMethods mock = mock(IMethods.class, "a mock");
+ InvocationMatcher i = new InvocationBuilder().mock(mock).toInvocationMatcher();
+
+ InvocationContainerImpl invocations =
+ new InvocationContainerImpl( new MockSettingsImpl());
+ invocations.setInvocationForPotentialStubbing(i);
+
+ try {
+ //when
+ n.verify(new VerificationDataImpl(invocations, null));
+ //then
+ fail();
+ } catch (NoInteractionsWanted e) {
+ Assertions.assertThat(e.toString()).contains(mock.toString());
+ }
+ }
+
+}
diff --git a/src/test/java/org/mockitousage/basicapi/ResetTest.java b/src/test/java/org/mockitousage/basicapi/ResetTest.java
index 5ec69cc..09f893e 100644
--- a/src/test/java/org/mockitousage/basicapi/ResetTest.java
+++ b/src/test/java/org/mockitousage/basicapi/ResetTest.java
@@ -63,6 +63,13 @@
}
@Test
+ public void shouldRemoveAllInteractionsVerifyNoInteractions() throws Exception {
+ mock.simpleMethod(1);
+ reset(mock);
+ verifyNoInteractions(mock);
+ }
+
+ @Test
public void shouldRemoveStubbingToString() throws Exception {
IMethods mockTwo = mock(IMethods.class);
when(mockTwo.toString()).thenReturn("test");
@@ -79,6 +86,14 @@
}
@Test
+ public void shouldStubbingNotBeTreatedAsInteractionVerifyNoInteractions() {
+ when(mock.simpleMethod("one")).thenThrow(new RuntimeException());
+ doThrow(new RuntimeException()).when(mock).simpleMethod("two");
+ reset(mock);
+ verifyNoInteractions(mock);
+ }
+
+ @Test
public void shouldNotAffectMockName() {
IMethods mock = mock(IMethods.class, "mockie");
IMethods mockTwo = mock(IMethods.class);
diff --git a/src/test/java/org/mockitousage/customization/BDDMockitoTest.java b/src/test/java/org/mockitousage/customization/BDDMockitoTest.java
index 6830765..bc3bfb6 100644
--- a/src/test/java/org/mockitousage/customization/BDDMockitoTest.java
+++ b/src/test/java/org/mockitousage/customization/BDDMockitoTest.java
@@ -269,6 +269,11 @@
}
@Test
+ public void should_validate_that_mock_had_no_interactions() {
+ then(mock).shouldHaveNoInteractions();
+ }
+
+ @Test
public void should_fail_when_mock_had_unwanted_interactions() {
mock.booleanObjectReturningMethod();
diff --git a/src/test/java/org/mockitousage/misuse/InvalidUsageTest.java b/src/test/java/org/mockitousage/misuse/InvalidUsageTest.java
index 1ba6e99..c2342d7 100644
--- a/src/test/java/org/mockitousage/misuse/InvalidUsageTest.java
+++ b/src/test/java/org/mockitousage/misuse/InvalidUsageTest.java
@@ -38,6 +38,11 @@
}
@Test(expected=MockitoException.class)
+ public void shouldRequireArgumentsWhenVerifyingNoInteractions() {
+ verifyNoInteractions();
+ }
+
+ @Test(expected=MockitoException.class)
public void shouldNotCreateInOrderObjectWithoutMocks() {
inOrder();
}
@@ -104,6 +109,18 @@
verifyZeroInteractions(inter);
}
+ @Test
+ public void shouldNotMockObjectMethodsOnInterfaceVerifyNoInteractions() throws Exception {
+ ObjectLikeInterface inter = mock(ObjectLikeInterface.class);
+
+ inter.equals(null);
+ inter.toString();
+ inter.hashCode();
+
+ verifyNoInteractions(inter);
+ }
+
+ @Test
public void shouldNotMockObjectMethodsOnClass() throws Exception {
Object clazz = mock(ObjectLikeInterface.class);
@@ -113,4 +130,15 @@
verifyZeroInteractions(clazz);
}
+
+ @Test
+ public void shouldNotMockObjectMethodsOnClassVerifyNoInteractions() throws Exception {
+ Object clazz = mock(ObjectLikeInterface.class);
+
+ clazz.equals(null);
+ clazz.toString();
+ clazz.hashCode();
+
+ verifyNoInteractions(clazz);
+ }
}
diff --git a/src/test/java/org/mockitousage/stacktrace/StackTraceFilteringTest.java b/src/test/java/org/mockitousage/stacktrace/StackTraceFilteringTest.java
index 8ad5ae0..2da4492 100644
--- a/src/test/java/org/mockitousage/stacktrace/StackTraceFilteringTest.java
+++ b/src/test/java/org/mockitousage/stacktrace/StackTraceFilteringTest.java
@@ -19,11 +19,7 @@
import org.mockitoutil.TestBase;
import static junit.framework.TestCase.fail;
-import static org.mockito.Mockito.inOrder;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.verifyZeroInteractions;
-import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.*;
import static org.mockitoutil.Conditions.firstMethodInStackTrace;
public class StackTraceFilteringTest extends TestBase {
@@ -73,6 +69,17 @@
}
@Test
+ public void shouldFilterStackTraceOnVerifyNoInteractions() {
+ mock.oneArg(true);
+ try {
+ verifyNoInteractions(mock);
+ fail();
+ } catch (NoInteractionsWanted e) {
+ Assertions.assertThat(e).has(firstMethodInStackTrace("shouldFilterStackTraceOnVerifyNoInteractions"));
+ }
+ }
+
+ @Test
public void shouldFilterStacktraceOnMockitoException() {
verify(mock);
try {
diff --git a/src/test/java/org/mockitousage/stubbing/BasicStubbingTest.java b/src/test/java/org/mockitousage/stubbing/BasicStubbingTest.java
index faf250d..688b12a 100644
--- a/src/test/java/org/mockitousage/stubbing/BasicStubbingTest.java
+++ b/src/test/java/org/mockitousage/stubbing/BasicStubbingTest.java
@@ -67,6 +67,14 @@
}
@Test
+ public void should_stubbing_not_be_treated_as_interaction_verify_no_interactions() {
+ when(mock.simpleMethod("one")).thenThrow(new RuntimeException());
+ doThrow(new RuntimeException()).when(mock).simpleMethod("two");
+
+ verifyNoInteractions(mock);
+ }
+
+ @Test
public void unfinished_stubbing_cleans_up_the_state() {
reset(mock);
try {
@@ -79,6 +87,18 @@
}
@Test
+ public void unfinished_stubbing_cleans_up_the_state_verify_no_interactions() {
+ reset(mock);
+ try {
+ when("").thenReturn("");
+ fail();
+ } catch (MissingMethodInvocationException e) {}
+
+ //anything that can cause state validation
+ verifyNoInteractions(mock);
+ }
+
+ @Test
public void should_to_string_mock_name() {
IMethods mock = mock(IMethods.class, "mockie");
IMethods mockTwo = mock(IMethods.class);
diff --git a/src/test/java/org/mockitousage/stubbing/StubbingWithThrowablesTest.java b/src/test/java/org/mockitousage/stubbing/StubbingWithThrowablesTest.java
index 0ccf14f..b651604 100644
--- a/src/test/java/org/mockitousage/stubbing/StubbingWithThrowablesTest.java
+++ b/src/test/java/org/mockitousage/stubbing/StubbingWithThrowablesTest.java
@@ -212,7 +212,7 @@
when(mock.size()).thenThrow(new RuntimeException());
doThrow(new RuntimeException()).when(mock).clone();
- verifyZeroInteractions(mock);
+ verifyNoInteractions(mock);
mock.add("test");
diff --git a/src/test/java/org/mockitousage/verification/BasicVerificationInOrderTest.java b/src/test/java/org/mockitousage/verification/BasicVerificationInOrderTest.java
index 4268b59..d94794e 100644
--- a/src/test/java/org/mockitousage/verification/BasicVerificationInOrderTest.java
+++ b/src/test/java/org/mockitousage/verification/BasicVerificationInOrderTest.java
@@ -264,6 +264,11 @@
verifyZeroInteractions(mockOne);
}
+ @Test(expected = NoInteractionsWanted.class)
+ public void shouldFailOnVerifyNoInteractions() {
+ verifyNoInteractions(mockOne);
+ }
+
@SuppressWarnings("all")
@Test(expected = MockitoException.class)
public void shouldScreamWhenNullPassed() {
diff --git a/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java b/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java
index 72cd98d..c81f97a 100644
--- a/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java
+++ b/src/test/java/org/mockitousage/verification/DescriptiveMessagesWhenVerificationFailsTest.java
@@ -211,6 +211,33 @@
}
@Test
+ public void should_print_first_unexpected_invocation_when_verifying_no_interactions() {
+ mock.twoArgumentMethod(1, 2);
+ mock.threeArgumentMethod(1, "2", "3");
+
+ try {
+ verifyNoInteractions(mock);
+ fail();
+ } catch (NoInteractionsWanted e) {
+ String expected =
+ "\n" +
+ "No interactions wanted here:" +
+ "\n" +
+ "-> at";
+
+ assertThat(e).hasMessageContaining(expected);
+
+ String expectedCause =
+ "\n" +
+ "But found these interactions on mock '" + mock + "':" +
+ "\n" +
+ "-> at";
+
+ assertThat(e).hasMessageContaining(expectedCause);
+ }
+ }
+
+ @Test
public void should_print_method_name_when_verifying_at_least_once() throws Exception {
try {
verify(mock, atLeastOnce()).twoArgumentMethod(1, 2);
diff --git a/src/test/java/org/mockitousage/verification/NoMoreInteractionsVerificationTest.java b/src/test/java/org/mockitousage/verification/NoMoreInteractionsVerificationTest.java
index 6382df3..04aef9a 100644
--- a/src/test/java/org/mockitousage/verification/NoMoreInteractionsVerificationTest.java
+++ b/src/test/java/org/mockitousage/verification/NoMoreInteractionsVerificationTest.java
@@ -58,6 +58,9 @@
verifyZeroInteractions(mock);
verifyZeroInteractions(mock);
+
+ verifyNoInteractions(mock);
+ verifyNoInteractions(mock);
}
@Test
@@ -71,6 +74,16 @@
}
@Test
+ public void shouldFailNoInteractionsVerification() throws Exception {
+ mock.clear();
+
+ try {
+ verifyNoInteractions(mock);
+ fail();
+ } catch (NoInteractionsWanted e) {}
+ }
+
+ @Test
public void shouldFailNoMoreInteractionsVerification() throws Exception {
mock.clear();
@@ -126,6 +139,25 @@
} catch (NoInteractionsWanted e) {}
}
+ @Test
+ public void shouldVerifyOneMockButFailOnOtherVerifyNoInteractions() throws Exception {
+ List<String> list = mock(List.class);
+ Map<String, Integer> map = mock(Map.class);
+
+ list.add("one");
+ list.add("one");
+
+ map.put("one", 1);
+
+ verify(list, times(2)).add("one");
+
+ verifyNoMoreInteractions(list);
+ try {
+ verifyNoInteractions(map);
+ fail();
+ } catch (NoInteractionsWanted e) {}
+ }
+
@SuppressWarnings("all")
@Test(expected=MockitoException.class)
public void verifyNoMoreInteractionsShouldScreamWhenNullPassed() throws Exception {
diff --git a/src/test/java/org/mockitousage/verification/VerificationOnMultipleMocksUsingMatchersTest.java b/src/test/java/org/mockitousage/verification/VerificationOnMultipleMocksUsingMatchersTest.java
index 45bf19d..5a6610a 100644
--- a/src/test/java/org/mockitousage/verification/VerificationOnMultipleMocksUsingMatchersTest.java
+++ b/src/test/java/org/mockitousage/verification/VerificationOnMultipleMocksUsingMatchersTest.java
@@ -60,5 +60,6 @@
verifyNoMoreInteractions(list, map);
verifyZeroInteractions(set);
+ verifyNoInteractions(set);
}
}
diff --git a/subprojects/testng/src/test/java/org/mockitousage/testng/ResetMocksInParentTestClassTooTest.java b/subprojects/testng/src/test/java/org/mockitousage/testng/ResetMocksInParentTestClassTooTest.java
index e9dd50a..55fef7a 100644
--- a/subprojects/testng/src/test/java/org/mockitousage/testng/ResetMocksInParentTestClassTooTest.java
+++ b/subprojects/testng/src/test/java/org/mockitousage/testng/ResetMocksInParentTestClassTooTest.java
@@ -2,6 +2,7 @@
import org.testng.annotations.Test;
+import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.verifyZeroInteractions;
public class ResetMocksInParentTestClassTooTest extends ParentTest {
@@ -15,4 +16,9 @@
public void verify__zero_interaction_with_parent_mock() throws Exception {
verifyZeroInteractions(parentMockField);
}
+
+ @Test
+ public void verify__no_interaction_with_parent_mock() throws Exception {
+ verifyNoInteractions(parentMockField);
+ }
}
