@Test
public void verificationInOrderIgnoringStubs(
@Mocked final MockedClass mock, @Mocked final MockedClass mockTwo) {
// Stubbings, with an invocation count constraint for later (automatic) verification:
new Expectations() {
{
mock.getItem(1);
result = "ignored";
times = 1;
}
};
// In tested code:
mock.doSomething("a", true);
mockTwo.someMethod("b");
mock.getItem(1);
// Verify all invocations, except those verified implicitly through recorded invocation
// count constraints.
// There is no support for ignoring stubbings that were not verified in any way.
// That said, note the API does not require any code duplication.
new FullVerificationsInOrder() {
{
mock.doSomething("a", true);
mockTwo.someMethod("b");
}
};
}
@Test // Uses of JMockit API: 2
public void verifyBehavior(@Mocked final MockedClass mock) {
// Mock is used (replay phase):
mock.doSomething("one", true);
mock.someMethod("test");
// Invocations to mock are verified (verify phase):
new Verifications() {
{
mock.doSomething("one", true);
mock.someMethod("test");
}
};
}
@Test // Uses of JMockit API: 4
public void stubbingWithCallbacksUsingMockUp() {
final MockedClass mock = new MockedClass();
new MockUp<MockedClass>() {
@Mock
String someMethod(Invocation inv, String s) {
assertSame(mock, inv.getInvokedInstance());
return "called with arguments: " + s;
}
};
assertEquals("called with arguments: foo", mock.someMethod("foo"));
}
@Test // Uses of JMockit API: 3
public void stubbingConsecutiveCallsToReturnASequenceOfValues(@Mocked final MockedClass mock) {
new Expectations() {
{
mock.someMethod("some arg");
returns("one", "two", "three");
}
};
assertEquals("one", mock.someMethod("some arg"));
assertEquals("two", mock.someMethod("some arg"));
assertEquals("three", mock.someMethod("some arg"));
assertEquals("three", mock.someMethod("some arg"));
}
@Test // Uses of JMockit API: 2
public void nonGreedyVerificationInOrder(@Mocked final MockedClass mock) {
mock.someMethod("some arg");
mock.someMethod("some arg");
mock.someMethod("some arg");
mock.doSomething("testing", true);
mock.someMethod("some arg");
new VerificationsInOrder() {
{
mock.someMethod("some arg");
minTimes = 2;
mock.doSomething("testing", true);
}
};
}
@Test // Uses of JMockit API: 4
public void stubInvocations(@Mocked final MockedClass mock) {
new Expectations() {
{
mock.getItem(0);
result = "first";
mock.getItem(1);
result = new RuntimeException();
}
};
assertEquals("first", mock.getItem(0));
try {
mock.getItem(1);
} catch (RuntimeException ignore) {
// OK
}
assertNull(mock.getItem(999));
}
@Test // Uses of JMockit API: 3
public void capturingArgumentForVerification(@Mocked final MockedClass mock) {
mock.doSomething(new Person("John"));
new Verifications() {
{
Person argument;
mock.doSomething(argument = withCapture());
assertEquals("John", argument.getName());
}
};
}
@Test // Uses of JMockit API: 4
public void capturingMultipleArgumentsForVerification(@Mocked final MockedClass mock) {
mock.doSomething("test", true);
new Verifications() {
{
String captor1;
boolean captor2;
mock.doSomething(captor1 = withCapture(), captor2 = withCapture());
assertEquals("test", captor1);
assertTrue(captor2);
}
};
}
@Test // Uses of JMockit API: 5
public void returningFirstArgument(@Mocked final MockedClass mock) {
new Expectations() {
{
mock.someMethod(anyString);
result =
new Delegate() {
String firstArg(String s) {
return s;
}
};
}
};
assertEquals("test", mock.someMethod("test"));
}
@Test // Uses of JMockit API: 5
public void stubbingWithCallbacksUsingDelegate(@Mocked final MockedClass mock) {
new Expectations() {
{
mock.someMethod(anyString);
result =
new Delegate() {
String delegate(String s) {
return "called with arguments: " + s;
}
};
}
};
assertEquals("called with arguments: foo", mock.someMethod("foo"));
}
@Test // Uses of JMockit API: 3
public void capturingArgumentsForVerification(@Mocked final MockedClass mock) {
mock.doSomething(new Person("John"));
mock.doSomething(new Person("Jane"));
new Verifications() {
{
List<Person> capturedPeople = new ArrayList<>();
mock.doSomething(withCapture(capturedPeople));
times = 2;
assertEquals("John", capturedPeople.get(0).getName());
assertEquals("Jane", capturedPeople.get(1).getName());
}
};
}
@Test // Uses of JMockit API: 7
public void callingRealMethodFromDelegate(@Injectable final MockedClass mock) {
new Expectations() {
{
mock.someMethod(anyString);
result =
new Delegate() {
String delegate(Invocation invocation, String s) {
String actualResult = invocation.proceed();
return "Res=" + actualResult;
}
};
}
};
assertEquals("Res=3", mock.someMethod("3"));
}
@Test // Uses of JMockit API: 4
public void chainingMethodCallsWithCascading(@Mocked final MockedClass mock) {
new Expectations() {
{
mock.getPerson().getName();
result = "deep";
}
};
assertEquals("deep", mock.getPerson().getName());
new Verifications() {
{
// Not likely to be useful often, but such verifications do work:
mock.getPerson();
mock.getPerson().getName();
}
};
}
// Equivalent to "spyingOnRealObjects", but real implementations execute only on replay.
@Test // Uses of JMockit API: 7
public void dynamicPartialMocking() {
final MockedClass mock = new MockedClass();
// Mocks a real object:
new Expectations(mock) {};
// Optionally, you can record some invocations:
new Expectations() {
{
mock.getSomeValue();
result = 100;
}
};
// When recording invocations on any mocked instance, partially mocked or not, real
// implementations
// are never executed, so this call would never throw an exception:
new Expectations() {
{
mock.getItem(1);
result = "an item";
}
};
// Using the mock calls real methods, except for calls which match recorded expectations:
mock.doSomething("one", true);
mock.doSomething("two", false);
assertEquals("one", mock.getItem(0));
assertEquals("an item", mock.getItem(1));
assertEquals(100, mock.getSomeValue());
// Optionally, you can verify invocations to the dynamically mocked types/objects:
new Verifications() {
{ // when verifying invocations, real implementations are never executed
mock.doSomething("one", true);
mock.doSomething("two", anyBoolean);
}
};
}