// "Dependency" is mocked for all tests in this test class.
// The "mockInstance" field holds a mocked instance automatically created for use in each test.
@Mocked Dependency mockInstance;@Test
public void doBusinessOperationXyz(@Mocked final AnotherDependency anotherMock)
{...new Expectations() {{ // an "expectation block"
      ...// Record an expectation, with a given value to be returned:mockInstance.mockedMethod(...); result = 123;...}};...// Call the code under test.
   ...new Verifications() {{ // a "verification block"// Verifies an expected invocation:anotherMock.save(any); times = 1;}};...
}

Test
public void doBusinessOperationXyz(@Mocked final Dependency mockInstance)
{...new Expectations() {{...// An expectation for an instance method:mockInstance.someMethod(1, "test"); result = "mocked";...}};// A call to code under test occurs here, leading to mock invocations// that may or may not match specified expectations.
}

@Test
public void someTestMethod()
{// 1. Preparation: whatever is required before the code under test can be exercised.
   ...// 2. The code under test is exercised, usually by calling a public method.
   ...// 3. Verification: whatever needs to be checked to make sure the code exercised by//    the test did its job.
   ...
}

public class UnitUnderTest
{
(1)private final DependencyAbc abc = new DependencyAbc();public void doSomething(){
(2)   int n = abc.intReturningMethod();for (int i = 0; i < n; i++) {String s;try {
(3)         s = abc.stringReturningMethod();}catch (SomeCheckedException e) {// somehow handle the exception
         }// do some other stuff
      }}
}

@Test
public void doSomethingHandlesSomeCheckedException(@Mocked final DependencyAbc abc) throws Exception
{new Expectations() {{
(1)   new DependencyAbc();(2)   abc.intReturningMethod(); result = 3;(3)   abc.stringReturningMethod();returns("str1", "str2");result = new SomeCheckedException();}};new UnitUnderTest().doSomething();
}

public final class ConcatenatingInputStream extends InputStream
{private final Queue<InputStream> sequentialInputs;private InputStream currentInput;public ConcatenatingInputStream(InputStream... sequentialInputs){this.sequentialInputs = new LinkedList<InputStream>(Arrays.asList(sequentialInputs));currentInput = this.sequentialInputs.poll();}@Overridepublic int read() throws IOException{if (currentInput == null) return -1;int nextByte = currentInput.read();if (nextByte >= 0) {return nextByte;}currentInput = sequentialInputs.poll();return read();}
}

@Test
public void concatenateInputStreams(@Injectable final InputStream input1, @Injectable final InputStream input2)throws Exception
{new Expectations() {{input1.read(); returns(1, 2, -1);input2.read(); returns(3, -1);}};InputStream concatenatedInput = new ConcatenatingInputStream(input1, input2);byte[] buf = new byte[3];concatenatedInput.read(buf);assertArrayEquals(new byte[] {1, 2, 3}, buf);
}

@Test
public void matchOnMockInstance(@Mocked final Collaborator mock)
{new Expectations() {{onInstance(mock).getValue(); result = 12;}};// Exercise code under test with mocked instance passed from the test:int result = mock.getValue();assertEquals(12, result);// If another instance is created inside code under test...Collaborator another = new Collaborator();// ...we won't get the recorded result, but the default one:assertEquals(0, another.getValue());
}

@Test
public void newCollaboratorsWithDifferentBehaviors(@Mocked Collaborator anyCollaborator)
{// Record different behaviors for each set of instances:new Expectations() {{// One set, instances created with "a value":Collaborator col1 = new Collaborator("a value");col1.doSomething(anyInt); result = 123;// Another set, instances created with "another value":Collaborator col2 = new Collaborator("another value");col2.doSomething(anyInt); result = new InvalidStateException();}};// Code under test:new Collaborator("a value").doSomething(5); // will return 123
   ...new Collaborator("another value").doSomething(0); // will throw the exception
   ...
}

@Test
public void newCollaboratorsWithDifferentBehaviors(@Mocked final Collaborator col1, @Mocked final Collaborator col2)
{new Expectations() {{// Map separate sets of future instances to separate mock parameters:new Collaborator("a value"); result = col1;new Collaborator("another value"); result = col2;// Record different behaviors for each set of instances:col1.doSomething(anyInt); result = 123;col2.doSomething(anyInt); result = new InvalidStateException();}};// Code under test:new Collaborator("a value").doSomething(5); // will return 123
   ...new Collaborator("another value").doSomething(0); // will throw the exception
   ...
}

@Test
public void someTestMethod(@Mocked final DependencyAbc abc)
{final DataItem item = new DataItem(...);new Expectations() {{// Will match "voidMethod(String, List)" invocations where the first argument is// any string and the second any list.abc.voidMethod(anyString, (List<?>) any);}};new UnitUnderTest().doSomething(item);new Verifications() {{// Matches invocations to the specified method with any value of type long or Long.
      abc.anotherVoidMethod(anyLong);}};
}

@Test
public void verifyingExpectationsInOrder(@Mocked final DependencyAbc abc)
{// Somewhere inside the tested code:
   abc.aMethod();abc.doSomething("blah", 123);abc.anotherMethod(5);...new VerificationsInOrder() {{// The order of these invocations must be the same as the order// of occurrence during replay of the matching invocations.
      abc.aMethod();abc.anotherMethod(anyInt);}};
}

@Mocked DependencyAbc abc;
@Mocked AnotherDependency xyz;@Test
public void verifyingTheOrderOfSomeExpectationsRelativeToAllOthers()
{new UnitUnderTest().doSomething();new VerificationsInOrder() {{abc.methodThatNeedsToExecuteFirst();unverifiedInvocations(); // Invocations not verified must come here...
      xyz.method1();abc.method2();unverifiedInvocations(); // ... and/or here.
      xyz.methodThatNeedsToExecuteLast();}};
}

 1 @Test
 2 public void verifyFirstAndLastCallsWithOthersInBetweenInAnyOrder()
 3 {
 4    // Invocations that occur while exercising the code under test:
 5    mock.prepare();
 6    mock.setSomethingElse("anotherValue");
 7    mock.setSomething(123);
 8    mock.notifyBeforeSave();
 9    mock.save();
10
11    new VerificationsInOrder() {{
12       mock.prepare(); // first expected call
13       unverifiedInvocations(); // others at this point
14       mock.notifyBeforeSave(); // just before last
15       mock.save(); times = 1; // last expected call
16    }};
17
18    // Unordered verification of the invocations previously left unverified.
19    // Could be ordered, but then it would be simpler to just include these invocations
20    // in the previous block, at the place where "unverifiedInvocations()" is called.
21    new Verifications() {{
22       mock.setSomething(123);
23       mock.setSomethingElse(anyString);
24    }};
25 }

 1 @Test
 2 public void verifyAllInvocations(@Mocked final Dependency mock)
 3 {
 4    // Code under test included here for easy reference:
 5    mock.setSomething(123);
 6    mock.setSomethingElse("anotherValue");
 7    mock.setSomething(45);
 8    mock.save();
 9
10    new FullVerifications() {{
11       // Verifications here are unordered, so the following invocations could be in any order.
12       mock.setSomething(anyInt); // verifies two actual invocations
13       mock.setSomethingElse(anyString);
14       mock.save(); // if this verification (or any other above) is removed the test will fail
15    }};
16 }

@Test
public void verifyAllInvocationsInOrder(@Mocked final Dependency mock)
{// Code under test included here for easy reference:mock.setSomething(123);mock.setSomethingElse("anotherValue");mock.setSomething(45);mock.save();new FullVerificationsInOrder() {{mock.setSomething(anyInt);mock.setSomethingElse(anyString);mock.setSomething(anyInt);mock.save();}};
}

@Test
public void verifyAllInvocationsToOnlyOneOfTwoMockedTypes(@Mocked final Dependency mock1, @Mocked AnotherDependency mock2)
{// Inside code under test:
   mock1.prepare();mock1.setSomething(123);mock2.doSomething();mock1.editABunchMoreStuff();mock1.save();new FullVerifications(mock1) {{mock1.prepare();mock1.setSomething(anyInt);mock1.editABunchMoreStuff();mock1.save(); times = 1;}};
}

new Expectations() {{mock.a(); time=1;
}}....new FullVerifications(){{ }};

Test
public void verifyNoInvocationsOnOneOfTwoMockedDependenciesBeyondThoseRecordedAsExpected(@Mocked final Dependency mock1, @Mocked final AnotherDependency mock2)
{new Expectations() {{// These two are recorded as expected:
      mock1.setSomething(anyInt);mock2.doSomething(); times = 1;}};// Inside code under test:
   mock1.prepare();mock1.setSomething(1);mock1.setSomething(2);mock1.save();mock2.doSomething();// Will verify that no invocations other than to "doSomething()" occurred on mock2:new FullVerifications(mock2) {};
}

@Test
public void readOnlyOperation(@Mocked final Dependency mock)
{new Expectations() {{mock.getData(); result = "test data";}};// Code under test:String data = mock.getData();// mock.save() should not be called here
   ...new FullVerifications() {{mock.getData(); minTimes = 0; // calls to getData() are allowed, others are not
   }};
}

@Test
public void capturingArgumentsFromSingleInvocation(@Mocked final Collaborator mock)
{// Inside tested code:new Collaborator().doSomething(0.5, new int[2], "test");new Verifications() {{double d;String s;mock.doSomething(d = withCapture(), null, s = withCapture());assertTrue(d > 0.0);assertTrue(s.length() > 1);}};
}

@Test
public void capturingArgumentsFromMultipleInvocations(@Mocked final Collaborator mock)
{mock.doSomething(dataObject1);mock.doSomething(dataObject2);new Verifications() {{List<DataObject> dataObjects = new ArrayList<>();mock.doSomething(withCapture(dataObjects));assertEquals(2, dataObjects.size());DataObject data1 = dataObjects.get(0);DataObject data2 = dataObjects.get(1);// Perform arbitrary assertions on data1 and data2.
   }};
}

 1 @Test
 2 public void capturingNewInstances(@Mocked Person mockedPerson)
 3 {
 4    // From the code under test:
 5    dao.create(new Person("Paul", 10));
 6    dao.create(new Person("Mary", 15));
 7    dao.create(new Person("Joe", 20));
 8
 9    new Verifications() {{
10       // Captures the new instances created with a specific constructor.
11       List<Person> personsInstantiated = withCapture(new Person(anyString, anyInt));
12
13       // Now captures the instances of the same type passed to a method.
14       List<Person> personsCreated = new ArrayList<>();
15       dao.create(withCapture(personsCreated));
16
17       // Finally, verifies both lists are the same.
18       assertEquals(personsInstantiated, personsCreated);
19    }};
20 }

@Test
public void delegatingInvocationsToACustomDelegate(@Mocked final DependencyAbc anyAbc)
{new Expectations() {{anyAbc.intReturningMethod(anyInt, null);result = new Delegate() {int aDelegateMethod(int i, String s){return i == 1 ? i : s.length();}};}};// Calls to "intReturningMethod(int, String)" will execute the delegate method above.new UnitUnderTest().doSomething();
}

@Test
public void delegatingConstructorInvocations(@Mocked Collaborator anyCollaboratorInstance)
{new Expectations() {{new Collaborator(anyInt);result = new Delegate() {void delegate(int i) { if (i < 1) throw new IllegalArgumentException(); }};}};// The first instantiation using "Collaborator(int)" will execute the delegate above.new Collaborator(4);
}

@Test
public void recordAndVerifyExpectationsOnCascadedMocks(@Mocked Socket anySocket, // will match any new Socket object created during the test@Mocked final SocketChannel cascadedChannel // will match cascaded instances
) throws Exception
{new Expectations() {{// Calls to Socket#getChannel() will automatically return a cascaded SocketChannel;// such an instance will be the same as the second mock parameter, allowing us to// use it for expectations that will match all cascaded channel instances:cascadedChannel.isConnected(); result = false;}};// Inside production code:Socket sk = new Socket(); // mocked as "anySocket"SocketChannel ch = sk.getChannel(); // mocked as "cascadedChannel"if (!ch.isConnected()) {SocketAddress sa = new InetSocketAddress("remoteHost", 123);ch.connect(sa);}InetAddress adr1 = sk.getInetAddress();  // returns a newly created InetAddress instanceInetAddress adr2 = sk.getLocalAddress(); // returns another new instance
   ...// Back in test code:new Verifications() {{ cascadedChannel.connect((SocketAddress) withNotNull()); }};
}

public void postErrorMessageToUIForInvalidInputFields(@Mocked final FacesContext jsf)
{// Set up invalid inputs, somehow.// Code under test which validates input fields from a JSF page, adding// error messages to the JSF context in case of validation failures.FacesContext ctx = FacesContext.getCurrentInstance();if (some input is invalid) {ctx.addMessage(null, new FacesMessage("Input xyz is invalid: blah blah..."));}...// Test code: verify appropriate error message was added to context.new Verifications() {{FacesMessage msg;jsf.addMessage(null, msg = withCapture());assertTrue(msg.getSummary().contains("blah blah"));}};
}

@Test
public void createOSProcessToCopyTempFiles(@Mocked final ProcessBuilder pb) throws Exception
{// Code under test creates a new process to execute an OS-specific command.String cmdLine = "copy /Y *.txt D:\\TEMP";File wrkDir = new File("C:\\TEMP");Process copy = new ProcessBuilder().command(cmdLine).directory(wrkDir).inheritIO().start();int exit = copy.waitFor();...// Verify the desired process was created with the correct command.new Verifications() {{ pb.command(withSubstring("copy")).start(); }};
}

import static mockit.Deencapsulation.*;@Test
public void someTestMethod(@Mocked final DependencyAbc abc)
{final CodeUnderTest tested = new CodeUnderTest();// Defines some necessary state on the tested object:setField(tested, "someIntField", 123);new Expectations() {{// Expectations still recorded, even if the invocations are done through Reflection:newInstance("some.package.AnotherDependency", true, "test"); maxTimes = 1;invoke(abc, "intReturningMethod", 45, ""); result = 1;// other expectations recorded...
   }};tested.doSomething();String result = getField(tested, "result");assertEquals("expected result", result);
}

public class PartialMockingTest
{static class Collaborator{final int value;Collaborator() { value = -1; }Collaborator(int value) { this.value = value; }int getValue() { return value; }final boolean simpleOperation(int a, String b, Date c) { return true; }static void doSomething(boolean b, String s) { throw new IllegalStateException(); }}@Testpublic void partiallyMockingAClassAndItsInstances(){final Collaborator anyInstance = new Collaborator();new Expectations(Collaborator.class) {{anyInstance.getValue(); result = 123;}};// Not mocked, as no constructor expectations were recorded:Collaborator c1 = new Collaborator();Collaborator c2 = new Collaborator(150);// Mocked, as a matching method expectation was recorded:assertEquals(123, c1.getValue());assertEquals(123, c2.getValue());// Not mocked:assertTrue(c1.simpleOperation(1, "b", null));assertEquals(45, new Collaborator(45).value);}@Testpublic void partiallyMockingASingleInstance(){final Collaborator collaborator = new Collaborator(2);new Expectations(collaborator) {{collaborator.getValue(); result = 123;collaborator.simpleOperation(1, "", null); result = false;// Static methods can be dynamically mocked too.Collaborator.doSomething(anyBoolean, "test");}};// Mocked:assertEquals(123, collaborator.getValue());assertFalse(collaborator.simpleOperation(1, "", null));Collaborator.doSomething(true, "test");// Not mocked:assertEquals(2, collaborator.value);assertEquals(45, new Collaborator(45).getValue());assertEquals(-1, new Collaborator().getValue());}
}

   @Testpublic void partiallyMockingAnObjectJustForVerifications(){final Collaborator collaborator = new Collaborator(123);new Expectations(collaborator) {};// No expectations were recorded, so nothing will be mocked.int value = collaborator.getValue(); // value == 123collaborator.simpleOperation(45, "testing", new Date());...// Unmocked methods can still be verified:new Verifications() {{ c1.simpleOperation(anyInt, anyString, (Date) any); }};}

public interface Service { int doSomething(); }
final class ServiceImpl implements Service { public int doSomething() { return 1; } }public final class TestedUnit
{private final Service service1 = new ServiceImpl();private final Service service2 = new Service() { public int doSomething() { return 2; } };public int businessOperation(){return service1.doSomething() + service2.doSomething();}
}

public final class UnitTest
{@Capturing Service anyService;@Testpublic void mockingImplementationClassesFromAGivenBaseType(){new Expectations() {{ anyService.doSomething(); returns(3, 4); }};int result = new TestedUnit().businessOperation();assertEquals(7, result);}
}

@Test
public void testWithDifferentBehaviorForFirstNewInstanceAndRemainingNewInstances(@Capturing(maxInstances = 1) final Buffer firstNewBuffer,@Capturing final Buffer remainingNewBuffers)
{new Expectations() {{firstNewBuffer.position(); result = 10;remainingNewBuffers.position(); result = 20;}};// Code under test creates several buffers...ByteBuffer buffer1 = ByteBuffer.allocate(100);IntBuffer  buffer2 = IntBuffer.wrap(new int[] {1, 2, 3});CharBuffer buffer3 = CharBuffer.wrap("                ");// ... and eventually read their positions, getting 10 for// the first buffer created, and 20 for the remaining ones.assertEquals(10, buffer1.position());assertEquals(20, buffer2.position());assertEquals(20, buffer3.position());
}

public class SomeTest
{@Tested CodeUnderTest tested;@Injectable Dependency dep1;@Injectable AnotherDependency dep2;@Injectable int someIntegralProperty = 123;@Testpublic void someTestMethod(@Injectable("true") boolean flag, @Injectable("Mary") String name){// Record expectations on mocked types, if needed.
tested.exerciseCodeUnderTest();// Verify expectations on mocked types, if required.
   }
}

public final class LoginServiceTest
{@Tested LoginService service;@Mocked UserAccount account;@Beforepublic void init(){new NonStrictExpectations() {{ UserAccount.find("john"); result = account; }};}@Testpublic void setAccountToLoggedInWhenPasswordMatches() throws Exception{willMatchPassword(true);service.login("john", "password");new Verifications() {{ account.setLoggedIn(true); }};}private void willMatchPassword(final boolean match){new Expectations() {{ account.passwordMatches(anyString); result = match; }};}@Testpublic void notSetAccountLoggedInIfPasswordDoesNotMatch() throws Exception{willMatchPassword(false);service.login("john", "password");new Verifications() {{ account.setLoggedIn(true); times = 0; }};}// other tests that use the "account" mock field
}

final class PasswordMatchingExpectations extends Expectations
{PasswordMatchingExpectations(boolean match){account.passwordMatches(anyString); result = match;}
}@Test
public void setAccountToLoggedInWhenPasswordMatches() throws Exception
{new PasswordMatchingExpectations(true);...
}

public interface Dependency
{String doSomething(boolean b);
}public class MultiMocksTest<MultiMock extends Dependency & Runnable>
{@Mocked MultiMock multiMock;@Testpublic void mockFieldWithTwoInterfaces(){new Expectations() {{ multiMock.doSomething(false); result = "test"; }};multiMock.run();assertEquals("test", multiMock.doSomething(false));new Verifications() {{ multiMock.run(); }};}@Testpublic <M extends Dependency & Serializable> void mockParameterWithTwoInterfaces(@Mocked final M mock){new Expectations() {{ mock.doSomething(true); result = "abc"; }};assertEquals("abc", mock.doSomething(true));assertTrue(mock instanceof Serializable);}
}

@Test
public void recordStrictInvocationsInIteratingBlock(@Mocked final Collaborator mock)
{new StrictExpectations(2) {{mock.setSomething(anyInt);mock.save();}};// In the tested code:mock.setSomething(123);mock.save();mock.setSomething(45);mock.save();
}

@Test
public void verifyAllInvocationsInLoop(@Mocked final Dependency mock)
{int numberOfIterations = 3;// Code under test included here for easy reference:for (int i = 0; i < numberOfIterations; i++) {DataItem data = getData(i);mock.setData(data);mock.save();}new Verifications(numberOfIterations) {{mock.setData((DataItem) withNotNull());mock.save();}};new VerificationsInOrder(numberOfIterations) {{mock.setData((DataItem) withNotNull());mock.save();}};
}