Mockito - Ordered Verification

Mockito provides Inorder class which takes care of the order of method calls that the mock is going to make in due course of its action.


//create an inOrder verifier for a single mock

InOrder inOrder = inOrder(calcService);

//following will make sure that add is first called then subtract is called.




Step 1 − Create an interface called CalculatorService to provide mathematical functions


public interface CalculatorService {
   public double add(double input1, double input2);
   public double subtract(double input1, double input2);
   public double multiply(double input1, double input2);
   public double divide(double input1, double input2);

Step 2 − Create a JAVA class to represent MathApplication


public class MathApplication {
   private CalculatorService calcService;
   public void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   public double add(double input1, double input2){
      return calcService.add(input1, input2);
   public double subtract(double input1, double input2){
      return calcService.subtract(input1, input2);
   public double multiply(double input1, double input2){
      return calcService.multiply(input1, input2);
   public double divide(double input1, double input2){
      return calcService.divide(input1, input2);

Step 3 − Test the MathApplication class

Let's test the MathApplication class, by injecting a mock of calculatorService  in it. Mock will be created by Mockito.

Here we've added two mock method calls, add() and subtract(), to the mock object via when(). However during testing, we've called subtract() before calling add(). 

When we create a mock object using Mockito, the order of execution of the method does not matter. Using InOrder class, we can ensure call order.


import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.inOrder;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InOrder;
import org.mockito.runners.MockitoJUnitRunner;

// @RunWith attaches a runner with the test class to initialize the test data
public class MathApplicationTester {
   private MathApplication mathApplication;
   private CalculatorService calcService;

   public void setUp(){
      mathApplication = new MathApplication();
      calcService = mock(CalculatorService.class);

   public void testAddAndSubtract(){
      //add the behavior to add numbers

      //subtract the behavior to subtract numbers

      //test the add functionality
      Assert.assertEquals(mathApplication.add(20.0, 10.0),30.0,0);

      //test the subtract functionality
      Assert.assertEquals(mathApplication.subtract(20.0, 10.0),10.0,0);

      //create an inOrder verifier for a single mock
      InOrder inOrder = inOrder(calcService);

      //following will make sure that add is first called then subtract is called.

Step 4 − Execute test cases

Create a java class file named TestRunner in C:\> Mockito_WORKSPACE to execute Test case(s).


import org.junit.runner.JUnitCore;
import org.junit.runner.Result;
import org.junit.runner.notification.Failure;

public class TestRunner {

   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(MathApplicationTester.class);
      for (Failure failure : result.getFailures()) {

Step 5 − Verify the Result

Compile the classes using javac compiler as follows −

C:\Mockito_WORKSPACE>javac MathApplication.


Now run the Test Runner to see the result −

C:\Mockito_WORKSPACE>java TestRunner

Verify the output.


Verification in order failure

Wanted but not invoked:

calculatorService.add(20.0, 10.0);

-> at MathApplicationTester.testAddAndSubtract(

Wanted anywhere AFTER following interaction:

calculatorService.subtract(20.0, 10.0);

-> at MathApplication.subtract(