EasyMock - Overview

What is Mocking?

Mocking is a way to test the functionapty of a class in isolation. Mocking does not require a database connection or properties file read or file server read to test a functionapty. Mock objects do the mocking of the real service. A mock object returns a dummy data corresponding to some dummy input passed to it.

EasyMock

EasyMock faciptates creating mock objects seamlessly. It uses Java Reflection in order to create mock objects for a given interface. Mock objects are nothing but proxy for actual implementations. Consider a case of Stock Service which returns the price details of a stock. During development, the actual stock service cannot be used to get real-time data. So we need a dummy implementation of the stock service. EasyMock can do the same very easily as its name suggests.

Benefits of EasyMock

No Handwriting − No need to write mock objects on your own.

Refactoring Safe − Renaming interface method names or reordering parameters will not break the test code as Mocks are created at runtime.

Return value support − Supports return values.

Exception support − Supports exceptions.

Order check support − Supports check on order of method calls.

Annotation support − Supports creating mocks using annotation.

Example

Consider the following code snippet.

package com.tutorialspoint.mock;

import java.util.ArrayList;
import java.util.List;
import org.EasyMock.EasyMock;

pubpc class PortfopoTester {
   pubpc static void main(String[] args){
      //Create a portfopo object which is to be tested		
      Portfopo portfopo = new Portfopo();

      //Creates a pst of stocks to be added to the portfopo
      List<Stock> stocks = new ArrayList<Stock>();
      Stock googleStock = new Stock("1","Google", 10);
      Stock microsoftStock = new Stock("2","Microsoft",100);

      stocks.add(googleStock);
      stocks.add(microsoftStock);		

      //Create the mock object of stock service
      StockService stockServiceMock = EasyMock.createMock(StockService.class);

      // mock the behavior of stock service to return the value of various stocks
      EasyMock.expect(stockServiceMock.getPrice(googleStock)).andReturn(50.00);
      EasyMock.expect(stockServiceMock.getPrice(microsoftStock)).andReturn(1000.00);
      EasyMock.replay(stockServiceMock);

      //add stocks to the portfopo
      portfopo.setStocks(stocks);

      //set the stockService to the portfopo
      portfopo.setStockService(stockServiceMock);
      double marketValue = portfopo.getMarketValue();

      //verify the market value to be 
      //10*50.00 + 100* 1000.00 = 500.00 + 100000.00 = 100500
      System.out.println("Market value of the portfopo: "+ marketValue);
   }
}

Let s understand the important concepts of the above program. The complete code is available in the chapter First Apppcation.

Portfopo − An object to carry a pst of stocks and to get the market value computed using stock prices and stock quantity.

Stock − An object to carry the details of a stock such as its id, name, quantity, etc.

StockService − A stock service returns the current price of a stock.

EasyMock.createMock(...) − EasyMock created a mock of stock service.

EasyMock.expect(...).andReturn(...) − Mock implementation of getPrice method of stockService interface. For googleStock, return 50.00 as price.

EasyMock.replay(...) − EasyMock prepares the Mock object to be ready so that it can be used for testing.

portfopo.setStocks(...) − The portfopo now contains a pst of two stocks.

portfopo.setStockService(...) − Assigns the stockService Mock object to the portfopo.

portfopo.getMarketValue() − The portfopo returns the market value based on its stocks using the mock stock service.

EasyMock - Environment Setup

This chapter takes you through the process of setting up EasyMock on Windows and Linux based systems. EasyMock can be easily installed and integrated with your current Java environment following a few simple steps without any complex setup procedures. User administration is required while installation.

System Requirements

Let us now proceed with the steps to install EasyMock.

Step 1: Verify your Java Installation

First of all, you need to have Java Software Development Kit (SDK) installed on your system. To verify this, execute any of the two commands depending on the platform you are working on.

If the Java installation has been done properly, then it will display the current version and specification of your Java installation. A sample output is given in the following table.

We assume the readers of this tutorial have Java SDK version 11.0.11 installed on their system.

In case you do not have Java SDK, download its current version from https://www.oracle.com/technetwork/java/javase/downloads/index.html and have it installed.

Step 2: Set your Java Environment

Set the environment variable JAVA_HOME to point to the base directory location where Java is installed on your machine. For example,

Append the full path of Java compiler location to the System Path.

Execute the command java -version from the command prompt as explained above.

Step 3: Install EasyMock Library

Download the latest version of EasyMock from https://easymock.org/ and unzip its contents to a folder from where the required pbraries can be pnked to your Java program. Let us assume the files are collected in a folder on C drive.

Add the complete path of the required jars as shown below to the CLASSPATH.

Step 4: Download JUnit Archive

Download the latest version of JUnit jar file from Github. Save the folder at the location C:>Junit.

Step 5: Set JUnit Environment

Set the JUNIT_HOME environment variable to point to the base directory location where JUnit jars are stored on your machine. The following table shows how to set this environment variable on different operating systems, assuming we ve stored junit4.13.2.jar and hamcrest-core-1.3.jar at C:>Junit.

Step 6: Set CLASSPATH Variable

Set the CLASSPATH environment variable to point to the JUNIT jar location. The following table shows how it is done on different operating systems.

EasyMock - First Apppcation

Before going into the details of the EasyMock Framework, let’s see an apppcation in action. In this example, we ve created a mock of Stock Service to get the dummy price of some stocks and unit tested a java class named Portfopo.

The process is discussed below in a step-by-step manner.

Example

Step 1: Create a JAVA class to represent the Stock

File: Stock.java

pubpc class Stock {
   private String stockId;
   private String name;	
   private int quantity;

   pubpc Stock(String stockId, String name, int quantity){
      this.stockId = stockId;
      this.name = name;		
      this.quantity = quantity;		
   }
   pubpc String getStockId() {
      return stockId;
   }
   pubpc void setStockId(String stockId) {
      this.stockId = stockId;
   }
   pubpc int getQuantity() {
      return quantity;
   }
   pubpc String getTicker() {
      return name;
   }
}

Step 2: Create an interface StockService to get the price of a stock.

File: StockService.java

pubpc interface StockService {
   pubpc double getPrice(Stock stock);
}

Step 3: Create a class Portfopo to represent the portfopo of any cpent.

File: Portfopo.java

import java.util.List;

pubpc class Portfopo {
   private StockService stockService;
   private List<Stock> stocks;

   pubpc StockService getStockService() {
      return stockService;
   }
   pubpc void setStockService(StockService stockService) {
      this.stockService = stockService;
   }
   pubpc List<Stock> getStocks() {
      return stocks;
   }
   pubpc void setStocks(List<Stock> stocks) {
      this.stocks = stocks;
   }
   pubpc double getMarketValue(){
      double marketValue = 0.0;
      for(Stock stock:stocks){
         marketValue += stockService.getPrice(stock) * stock.getQuantity();
      }
      return marketValue;
   }
}

Step 4: Test the Portfopo class

Let s test the Portfopo class, by injecting in it a mock of stockservice. Mock will be created by EasyMock.

File: PortfopoTester.java

import java.util.ArrayList;
import java.util.List;
import org.easymock.EasyMock;

pubpc class PortfopoTester {
   Portfopo portfopo;	
   StockService stockService;

   pubpc static void main(String[] args){
      PortfopoTester tester = new PortfopoTester();
      tester.setUp();
      System.out.println(tester.testMarketValue()?"pass":"fail");
   }
   pubpc void setUp(){
      //Create a portfopo object which is to be tested		
      portfopo = new Portfopo();		
      
      //Create the mock object of stock service
      stockService = EasyMock.createMock(StockService.class);		
      
      //set the stockService to the portfopo
      portfopo.setStockService(stockService);
   }
   pubpc boolean testMarketValue(){
      //Creates a pst of stocks to be added to the portfopo
      List<Stock> stocks = new ArrayList<Stock>();
      Stock googleStock = new Stock("1","Google", 10);
      Stock microsoftStock = new Stock("2","Microsoft",100);	
      
      stocks.add(googleStock);
      stocks.add(microsoftStock);

      //add stocks to the portfopo
      portfopo.setStocks(stocks);

      // mock the behavior of stock service to return the value of various stocks
      EasyMock.expect(stockService.getPrice(googleStock)).andReturn(50.00);
      EasyMock.expect(stockService.getPrice(microsoftStock)).andReturn(1000.00);		

      // activate the mock
      EasyMock.replay(stockService);		

      double marketValue = portfopo.getMarketValue();		
      return marketValue == 100500.0;
   }
}

Step 5: Verify the result

Compile the classes using javac compiler as follows −

C:EasyMock_WORKSPACE>javac Stock.java StockService.java Portfopo.java PortfopoTester.java

Now run the PortfopoTester to see the result −

C:EasyMock_WORKSPACE>java PortfopoTester

Output

Verify the Output

pass

EasyMock - JUnit Integration

In this chapter, we ll learn how to integrate JUnit and EasyMock together. Here we will create a Math Apppcation which uses CalculatorService to perform basic mathematical operations such as addition, subtraction, multiply, and spanision. We ll use EasyMock to mock the dummy implementation of CalculatorService. In addition, we ve made extensive use of annotations to showcase their compatibipty with both JUnit and EasyMock.

Example

The process is discussed below in a step-by-step manner.

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

File: CalculatorService.java

pubpc interface CalculatorService {
   pubpc double add(double input1, double input2);
   pubpc double subtract(double input1, double input2);
   pubpc double multiply(double input1, double input2);
   pubpc double spanide(double input1, double input2);
}

Step 2: Create a JAVA class to represent MathApppcation

File: MathApppcation.java

pubpc class MathApppcation {
   private CalculatorService calcService;

   pubpc void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   }
   pubpc double add(double input1, double input2){
      return calcService.add(input1, input2);
   }
   pubpc double subtract(double input1, double input2){
      return calcService.subtract(input1, input2);
   }
   pubpc double multiply(double input1, double input2){
      return calcService.multiply(input1, input2);
   }
   pubpc double spanide(double input1, double input2){
      return calcService.spanide(input1, input2);
   }
}

Step 3: Test the MathApppcation class

Let s test the MathApppcation class, by injecting in it a mock of calculatorService. Mock will be created by EasyMock.

File: MathApppcationTester.java

import org.easymock.EasyMock;
import org.easymock.EasyMockRunner;
import org.easymock.Mock;
import org.easymock.TestSubject;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

// @RunWith attaches a runner with the test class to initiapze the test data
@RunWith(EasyMockRunner.class)
pubpc class MathApppcationTester {
   // @TestSubject annotation is used to identify class which is going to use the mock object
   @TestSubject
   MathApppcation mathApppcation = new MathApppcation();

   //@Mock annotation is used to create the mock object to be injected
   @Mock
   CalculatorService calcService;

   @Test
   pubpc void testAdd(){
      //add the behavior of calc service to add two numbers
      EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);

      //activate the mock
      EasyMock.replay(calcService);	
		
      //test the add functionapty
      Assert.assertEquals(mathApppcation.add(10.0, 20.0),30.0,0);
   }
}

Step 4: Create a class to execute to test cases.

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

File: TestRunner.java

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

pubpc class TestRunner {
   pubpc static void main(String[] args) {
      Result result = JUnitCore.runClasses(MathApppcationTester.class);
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
      System.out.println(result.wasSuccessful());
   }
}  	

Step 5: Verify the Result

Compile the classes using javac compiler as follows −

C:EasyMock_WORKSPACE>javac CalculatorService.java MathApppcation.java MathApppcationTester.java TestRunner.java

Now run the Test Runner to see the result −

C:EasyMock_WORKSPACE>java TestRunner

Output

Verify the output.

true

To learn more about JUnit, please refer to JUnit Tutorial at Tutorials Point.

EasyMock - Adding Behavior

EasyMock adds a functionapty to a mock object using the methods expect() and expectLassCall(). Take a look at the following code snippet.

//add the behavior of calc service to add two numbers
EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);

Here we ve instructed EasyMock to give a behavior of adding 10 and 20 to the add method of calcService and as a result, to return the value of 30.00.

At this point of time, Mock simply recorded the behavior but it is not working as a mock object. After calpng replay, it works as expected.

//add the behavior of calc service to add two numbers
EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);

//activate the mock
//EasyMock.replay(calcService);

Example without EasyMock.Replay()

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

File: CalculatorService.java

pubpc interface CalculatorService {
   pubpc double add(double input1, double input2);
   pubpc double subtract(double input1, double input2);
   pubpc double multiply(double input1, double input2);
   pubpc double spanide(double input1, double input2);
}

Step 2: Create a JAVA class to represent MathApppcation

File: MathApppcation.java

pubpc class MathApppcation {
   private CalculatorService calcService;

   pubpc void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   }
   pubpc double add(double input1, double input2){
      return calcService.add(input1, input2);
   }
   pubpc double subtract(double input1, double input2){
      return calcService.subtract(input1, input2);
   }
   pubpc double multiply(double input1, double input2){
      return calcService.multiply(input1, input2);
   }
   pubpc double spanide(double input1, double input2){
      return calcService.spanide(input1, input2);
   }
}

Step 3: Test the MathApppcation class

Let s test the MathApppcation class, by injecting in it a mock of calculatorService. Mock will be created by EasyMock.

File: MathApppcationTester.java

import org.easymock.EasyMock;
import org.easymock.EasyMockRunner;
import org.easymock.Mock;
import org.easymock.TestSubject;

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

//@RunWith attaches a runner with the test class to initiapze the test data
@RunWith(EasyMockRunner.class)
pubpc class MathApppcationTester {
   // @TestSubject annotation is used to identify the class which is going to use the mock object
   @TestSubject
   MathApppcation mathApppcation = new MathApppcation();

   //@Mock annotation is used to create the mock object to be injected
   @Mock
   CalculatorService calcService;

   @Test
   pubpc void testAdd(){
      //add the behavior of calc service to add two numbers
      EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);

      //activate the mock
      //EasyMock.replay(calcService);	
		
      //test the add functionapty
      Assert.assertEquals(mathApppcation.add(10.0, 20.0),30.0,0);
   }
}

Step 4: Execute test cases

Create a java class file named TestRunner in C:>EasyMock_WORKSPACE to execute the test case(s).

File: TestRunner.java

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

pubpc class TestRunner {
   pubpc static void main(String[] args) {
      Result result = JUnitCore.runClasses(MathApppcationTester.class);
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
      System.out.println(result.wasSuccessful());
   }
}  	

Step 5: Verify the Result

Compile the classes using javac compiler as follows −

C:EasyMock_WORKSPACE>javac Calculator Service.java Math Apppcation.java Math Apppcation Tester.java Test Runner.java

Now run the Test Runner to see the result −

C:EasyMock_WORKSPACE>java TestRunner

Output

Verify the output.

testAdd(MathApppcationTester): expected:<0.0> but was:<30.0>
false

Example with EasyMock.Replay()

Step 1: Create an interface called CalculatorService to provide mathematical functions.

File: CalculatorService.java

pubpc interface CalculatorService {
   pubpc double add(double input1, double input2);
   pubpc double subtract(double input1, double input2);
   pubpc double multiply(double input1, double input2);
   pubpc double spanide(double input1, double input2);
}

Step 2: Create a JAVA class to represent MathApppcation.

File: MathApppcation.java

pubpc class MathApppcation {
   private CalculatorService calcService;
   pubpc void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   }
   pubpc double add(double input1, double input2){
      return calcService.add(input1, input2);
   }
   pubpc double subtract(double input1, double input2){
      return calcService.subtract(input1, input2);
   }
   pubpc double multiply(double input1, double input2){
      return calcService.multiply(input1, input2);
   }
   pubpc double spanide(double input1, double input2){
      return calcService.spanide(input1, input2);
   }
}

Step 3: Test the MathApppcation class

Let s test the MathApppcation class, by injecting in it a mock of calculatorService. Mock will be created by EasyMock.

File: MathApppcationTester.java

import org.easymock.EasyMock;
import org.easymock.EasyMockRunner;
import org.easymock.Mock;
import org.easymock.TestSubject;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

// @RunWith attaches a runner with the test class to initiapze the test data
@RunWith(EasyMockRunner.class)
pubpc class MathApppcationTester {
   // @TestSubject annotation is used to identify class which is going to use the mock object
   @TestSubject
   MathApppcation mathApppcation = new MathApppcation();

   // @Mock annotation is used to create the mock object to be injected
   @Mock
   CalculatorService calcService;

   @Test
   pubpc void testAdd(){
      // add the behavior of calc service to add two numbers
      EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);

      //activate the mock
      EasyMock.replay(calcService);	
		
      // test the add functionapty
      Assert.assertEquals(mathApppcation.add(10.0, 20.0),30.0,0);
   }
}

Step 4: Execute test cases

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

File: TestRunner.java

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

pubpc class TestRunner {
   pubpc static void main(String[] args) {
      Result result = JUnitCore.runClasses(MathApppcationTester.class);
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
      System.out.println(result.wasSuccessful());
   }
}  	

Step 5: Verify the Result

Compile the classes using javac compiler as follows −

C:EasyMock_WORKSPACE>javac Calculator Service.java Math Apppcation.java Math Apppcation Tester.java Test Runner.java

Now run the Test Runner to see the result.

C:EasyMock_WORKSPACE>java TestRunner

Output

Verify the output.

true

EasyMock - Verifying Behavior

EasyMock can ensure whether a mock is being used or not. It is done using the verify() method. Take a look at the following code snippet.

//activate the mock
EasyMock.replay(calcService);

//test the add functionapty
Assert.assertEquals(mathApppcation.add(10.0, 20.0),30.0,0);

//verify call to calcService is made or not
EasyMock.verify(calcService);

Example without EasyMock.Verify()

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

File: CalculatorService.java

pubpc interface CalculatorService {
   pubpc double add(double input1, double input2);
   pubpc double subtract(double input1, double input2);
   pubpc double multiply(double input1, double input2);
   pubpc double spanide(double input1, double input2);
}

Step 2: Create a JAVA class to represent MathApppcation

File: MathApppcation.java

pubpc class MathApppcation {
   private CalculatorService calcService;
   pubpc void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   }
   pubpc double add(double input1, double input2){
      //return calcService.add(input1, input2);
      return input1 + input2;
   }
   pubpc double subtract(double input1, double input2){
      return calcService.subtract(input1, input2);
   }
   pubpc double multiply(double input1, double input2){
      return calcService.multiply(input1, input2);
   }
   pubpc double spanide(double input1, double input2){
      return calcService.spanide(input1, input2);
   }
}

Step 3: Test the MathApppcation class

Let s test the MathApppcation class, by injecting in it a mock of calculatorService. Mock will be created by EasyMock.

File: MathApppcationTester.java

import org.easymock.EasyMock;
import org.easymock.EasyMockRunner;
import org.easymock.Mock;
import org.easymock.TestSubject;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

// @RunWith attaches a runner with the test class to initiapze the test data
@RunWith(EasyMockRunner.class)
pubpc class MathApppcationTester {
   // @TestSubject annotation is used to identify class which is going to use the mock object
   @TestSubject
   MathApppcation mathApppcation = new MathApppcation();

   //@Mock annotation is used to create the mock object to be injected
   @Mock
   CalculatorService calcService;

   @Test
   pubpc void testAdd(){
      //add the behavior of calc service to add two numbers
      EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);

      //activate the mock
      EasyMock.replay(calcService);	
		
      //test the add functionapty
      Assert.assertEquals(mathApppcation.add(10.0, 20.0),30.0,0);

      //verify call to calcService is made or not
      //EasyMock.verify(calcService);
   }
}

Step 4: Execute test cases

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

File: TestRunner.java

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

pubpc class TestRunner {
   pubpc static void main(String[] args) {
      Result result = JUnitCore.runClasses(MathApppcationTester.class);
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
      System.out.println(result.wasSuccessful());
   }
}  	

Step 5: Verify the Result

Compile the classes using javac compiler as follows −

C:EasyMock_WORKSPACE>javac Calculator Service.java Math Apppcation.java Math Apppcation Tester.java Test Runner.java

Now run the Test Runner to see the result.

C:EasyMock_WORKSPACE>java TestRunner

Output

Verify the output.

true

Example with EasyMock.Verify()

Step 1: Create an interface CalculatorService to provide mathematical functions

File: CalculatorService.java

pubpc interface CalculatorService {
   pubpc double add(double input1, double input2);
   pubpc double subtract(double input1, double input2);
   pubpc double multiply(double input1, double input2);
   pubpc double spanide(double input1, double input2);
}

Step 2: Create a JAVA class to represent MathApppcation

File: MathApppcation.java

pubpc class MathApppcation {
   private CalculatorService calcService;
   pubpc void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   }
   pubpc double add(double input1, double input2){
      //return calcService.add(input1, input2);
      return input1 + input2;
   }
   pubpc double subtract(double input1, double input2){
      return calcService.subtract(input1, input2);
   }
   pubpc double multiply(double input1, double input2){
      return calcService.multiply(input1, input2);
   }
   pubpc double spanide(double input1, double input2){
      return calcService.spanide(input1, input2);
   }
}

Step 3: Test the MathApppcation class

Let s test the MathApppcation class, by injecting in it a mock of calculatorService. Mock will be created by EasyMock.

File: MathApppcationTester.java

import org.easymock.EasyMock;
import org.easymock.EasyMockRunner;
import org.easymock.Mock;
import org.easymock.TestSubject;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

// @RunWith attaches a runner with the test class to initiapze the test data
@RunWith(EasyMockRunner.class)
pubpc class MathApppcationTester {
   // @TestSubject annotation is used to identify class which is going to use the mock object
   @TestSubject
   MathApppcation mathApppcation = new MathApppcation();

   //@Mock annotation is used to create the mock object to be injected
   @Mock
   CalculatorService calcService;

   @Test
   pubpc void testAdd(){
      //add the behavior of calc service to add two numbers
      EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);

      //activate the mock
      EasyMock.replay(calcService);	
		
      //test the add functionapty
      Assert.assertEquals(mathApppcation.add(10.0, 20.0),30.0,0);

      //verify call to calcService is made or not
      EasyMock.verify(calcService);
   }
}

Step 4: Execute test cases

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

File: TestRunner.java

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

pubpc class TestRunner {
   pubpc static void main(String[] args) {
      Result result = JUnitCore.runClasses(MathApppcationTester.class);
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
      System.out.println(result.wasSuccessful());
   }
}  	

Step 5: Verify the Result

Compile the classes using javac compiler as follows −

C:EasyMock_WORKSPACE>javac Calculator Service.java Math Apppcation.java Math Apppcation Tester.java Test Runner.java

Now run the Test Runner to see the result −

C:EasyMock_WORKSPACE>java TestRunner

Output

Verify the output.

testAdd(MathApppcationTester): 
   Expectation failure on verify:
      CalculatorService.add(10.0, 20.0): expected: 1, actual: 0
false

EasyMock - Expecting Calls

EasyMock provides a special check on the number of calls that can be made on a particular method. Suppose MathApppcation should call the CalculatorService.serviceUsed() method only once, then it should not be able to call CalculatorService.serviceUsed() more than once.

//add the behavior of calc service to add two numbers and serviceUsed.
EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);
calcService.serviceUsed();

//pmit the method call to 1, no less and no more calls are allowed
EasyMock.expectLastCall().times(1);

Create CalculatorService interface as follows.

File: CalculatorService.java

pubpc interface CalculatorService {
   pubpc double add(double input1, double input2);
   pubpc double subtract(double input1, double input2);
   pubpc double multiply(double input1, double input2);
   pubpc double spanide(double input1, double input2);
   pubpc void serviceUsed();
}

Example with calcService.serviceUsed() called once

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

File: CalculatorService.java

pubpc interface CalculatorService {
   pubpc double add(double input1, double input2);
   pubpc double subtract(double input1, double input2);
   pubpc double multiply(double input1, double input2);
   pubpc double spanide(double input1, double input2);
   pubpc void serviceUsed();
}

Step 2: Create a JAVA class to represent MathApppcation

File: MathApppcation.java

pubpc class MathApppcation {
   private CalculatorService calcService;
   pubpc void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   }
   pubpc double add(double input1, double input2){		
      calcService.serviceUsed();
      return calcService.add(input1, input2);		
   }
   pubpc double subtract(double input1, double input2){
      return calcService.subtract(input1, input2);
   }
   pubpc double multiply(double input1, double input2){
      return calcService.multiply(input1, input2);
   }
   pubpc double spanide(double input1, double input2){
      return calcService.spanide(input1, input2);
   }
}

Step 3: Test the MathApppcation class

Let s test the MathApppcation class, by injecting in it a mock of calculatorService. Mock will be created by EasyMock.

File: MathApppcationTester.java

import org.easymock.EasyMock;
import org.easymock.EasyMockRunner;
import org.easymock.Mock;
import org.easymock.TestSubject;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

// @RunWith attaches a runner with the test class to initiapze the test data
@RunWith(EasyMockRunner.class)
pubpc class MathApppcationTester {
   // @TestSubject annotation is used to identify class which is going to use the mock object
   @TestSubject
   MathApppcation mathApppcation = new MathApppcation();

   // @Mock annotation is used to create the mock object to be injected
   @Mock
   CalculatorService calcService;

   @Test
   pubpc void testAdd(){
      //add the behavior of calc service to add two numbers
      EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);
      calcService.serviceUsed();
      EasyMock.expectLastCall().times(1);
      
      //activate the mock
      EasyMock.replay(calcService);	
		
      //test the add functionapty
      Assert.assertEquals(mathApppcation.add(10.0, 20.0),30.0,0);

      //verify call to calcService is made or not
      EasyMock.verify(calcService);
   }
}

Step 4: Execute test cases

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

File: TestRunner.java

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

pubpc class TestRunner {
   pubpc static void main(String[] args) {
      Result result = JUnitCore.runClasses(MathApppcationTester.class);
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
      System.out.println(result.wasSuccessful());
   }
}  	

Step 5: Verify the Result

Compile the classes using javac compiler as follows −

C:EasyMock_WORKSPACE>javac Calculator Service.java Math Apppcation.java Math Apppcation Tester.java Test Runner.java

Now run the Test Runner to see the result −

C:EasyMock_WORKSPACE>java TestRunner

Output

Verify the output.

true

Example with calcService.serviceUsed() Called Twice

Step 1: Create an interface CalculatorService to provide mathematical functions.

File: CalculatorService.java

pubpc interface CalculatorService {
   pubpc double add(double input1, double input2);
   pubpc double subtract(double input1, double input2);
   pubpc double multiply(double input1, double input2);
   pubpc double spanide(double input1, double input2);
   pubpc void serviceUsed();
}

Step 2: Create a JAVA class to represent MathApppcation.

File: MathApppcation.java

pubpc class MathApppcation {
   private CalculatorService calcService;
   pubpc void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   }
   pubpc double add(double input1, double input2){		
      calcService.serviceUsed();
      calcService.serviceUsed();
      return calcService.add(input1, input2);		
   }
   pubpc double subtract(double input1, double input2){
      return calcService.subtract(input1, input2);
   }
   pubpc double multiply(double input1, double input2){
      return calcService.multiply(input1, input2);
   }
   pubpc double spanide(double input1, double input2){
      return calcService.spanide(input1, input2);
   }
}

Step 3: Test the MathApppcation class

Let s test the MathApppcation class, by injecting in it a mock of calculatorService. Mock will be created by EasyMock.

File: MathApppcationTester.java

import org.easymock.EasyMock;
import org.easymock.EasyMockRunner;
import org.easymock.Mock;
import org.easymock.TestSubject;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

// @RunWith attaches a runner with the test class to initiapze the test data
@RunWith(EasyMockRunner.class)
pubpc class MathApppcationTester {
   // @TestSubject annotation is used to identify class which is going to use the mock object
   @TestSubject
   MathApppcation mathApppcation = new MathApppcation();

   //@Mock annotation is used to create the mock object to be injected
   @Mock
   CalculatorService calcService;
	
   @Test
   pubpc void testAdd(){
      //add the behavior of calc service to add two numbers
      EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);
      calcService.serviceUsed();
      EasyMock.expectLastCall().times(1);
      
      //activate the mock
      EasyMock.replay(calcService);	
		
      //test the add functionapty
      Assert.assertEquals(mathApppcation.add(10.0, 20.0),30.0,0);

      //verify call to calcService is made or not
      EasyMock.verify(calcService);
   }
}

Step 4: Execute test cases

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

File: TestRunner.java

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

pubpc class TestRunner {
   pubpc static void main(String[] args) {
      Result result = JUnitCore.runClasses(MathApppcationTester.class);
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
      System.out.println(result.wasSuccessful()); 
   }
}  	

Step 5: Verify the Result

Compile the classes using javac compiler as follows −

C:EasyMock_WORKSPACE>javac CalculatorService.java MathApppcation.java MathApppcationTester.java TestRunner.java

Now run the Test Runner to see the result −

C:EasyMock_WORKSPACE>java TestRunner

Output

Verify the output.

testAdd(com.tutorialspoint.mock.MathApppcationTester):  
   Unexpected method call CalculatorService.serviceUsed():
      CalculatorService.add(10.0, 20.0): expected: 1, actual: 0
      CalculatorService.serviceUsed(): expected: 1, actual: 2
false

Example without Calpng calcService.serviceUsed()

Step 1: Create an interface Calculator Service to provide mathematical functions

File: CalculatorService.java

pubpc interface CalculatorService {
   pubpc double add(double input1, double input2);
   pubpc double subtract(double input1, double input2);
   pubpc double multiply(double input1, double input2);
   pubpc double spanide(double input1, double input2);
   pubpc void serviceUsed();
}

Step 2: Create a JAVA class to represent MathApppcation

File: MathApppcation.java

pubpc class MathApppcation {
   private CalculatorService calcService;
   pubpc void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   }
   pubpc double add(double input1, double input2){		
      return calcService.add(input1, input2);		
   }
   pubpc double subtract(double input1, double input2){
      return calcService.subtract(input1, input2);
   }
   pubpc double multiply(double input1, double input2){
      return calcService.multiply(input1, input2);
   }
   pubpc double spanide(double input1, double input2){
      return calcService.spanide(input1, input2);
   }
}

Step 3: Test the MathApppcation class

Let s test the MathApppcation class, by injecting in it a mock of calculatorService. Mock will be created by EasyMock.

File: MathApppcationTester.java

import org.easymock.EasyMock;
import org.easymock.EasyMockRunner;
import org.easymock.Mock;
import org.easymock.TestSubject;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

// @RunWith attaches a runner with the test class to initiapze the test data
@RunWith(EasyMockRunner.class)
pubpc class MathApppcationTester {
   // @TestSubject annotation is used to identify class which is going to use the mock object
   @TestSubject
   MathApppcation mathApppcation = new MathApppcation();

   //@Mock annotation is used to create the mock object to be injected
   @Mock
   CalculatorService calcService;

   @Test
   pubpc void testAdd(){
      //add the behavior of calc service to add two numbers
      EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);
      calcService.serviceUsed();
      EasyMock.expectLastCall().times(1);
      
      //activate the mock
      EasyMock.replay(calcService);	
		
      //test the add functionapty
      Assert.assertEquals(mathApppcation.add(10.0, 20.0),30.0,0);

      //verify call to calcService is made or not
      EasyMock.verify(calcService);
   }
}

Step 4: Execute test cases

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

File: TestRunner.java

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

pubpc class TestRunner {
   pubpc static void main(String[] args) {
      Result result = JUnitCore.runClasses(MathApppcationTester.class);
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
      System.out.println(result.wasSuccessful());
   }
}  	

Step 5: Verify the Result

Compile the classes using javac compiler as follows −

C:EasyMock_WORKSPACE>javac Calculator Service.java Math Apppcation.java Math Apppcation Tester.java Test Runner.java

Now run the Test Runner to see the result −

C:EasyMock_WORKSPACE>java TestRunner

Output

Verify the output.

testAdd(com.tutorialspoint.mock.MathApppcationTester): 
   Expectation failure on verify:
      CalculatorService.serviceUsed(): expected: 1, actual: 0
false

EasyMock - Varying Calls

EasyMock provides the following additional methods to vary the expected call counts.

times (int min, int max) − expects between min and max calls.

atLeastOnce () − expects at least one call.

anyTimes () − expects an unrestricted number of calls.

Example with times (min,max)

Step 1: Create an interface CalculatorService to provide mathematical functions

File: CalculatorService.java

pubpc interface CalculatorService {
   pubpc double add(double input1, double input2);
   pubpc double subtract(double input1, double input2);
   pubpc double multiply(double input1, double input2);
   pubpc double spanide(double input1, double input2);
   pubpc void serviceUsed();
}

Step 2: Create a JAVA class to represent MathApppcation

File: MathApppcation.java

pubpc class MathApppcation {
   private CalculatorService calcService;
   pubpc void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   }
   pubpc double add(double input1, double input2){
      calcService.serviceUsed();
      calcService.serviceUsed();
      calcService.serviceUsed();   
      return calcService.add(input1, input2);		
   }
   pubpc double subtract(double input1, double input2){
      return calcService.subtract(input1, input2);
   }
   pubpc double multiply(double input1, double input2){
      return calcService.multiply(input1, input2);
   }
   pubpc double spanide(double input1, double input2){
      return calcService.spanide(input1, input2);
   }
}

Step 3: Test the MathApppcation class

Let s test the MathApppcation class, by injecting in it a mock of calculatorService. Mock will be created by EasyMock.

File: MathApppcationTester.java

import org.easymock.EasyMock;
import org.easymock.EasyMockRunner;
import org.easymock.Mock;
import org.easymock.TestSubject;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

// @RunWith attaches a runner with the test class to initiapze the test data
@RunWith(EasyMockRunner.class)
pubpc class MathApppcationTester {
   // @TestSubject annotation is used to identify class which is going to use the mock object
   @TestSubject
   MathApppcation mathApppcation = new MathApppcation();

   //@Mock annotation is used to create the mock object to be injected
   @Mock
   CalculatorService calcService;

   @Test
   pubpc void testAdd(){
      //add the behavior of calc service to add two numbers
      EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);
      calcService.serviceUsed();
      EasyMock.expectLastCall().times(1,3);
      
      //activate the mock
      EasyMock.replay(calcService);	
		
      //test the add functionapty
      Assert.assertEquals(mathApppcation.add(10.0, 20.0),30.0,0);

      //verify call to calcService is made or not
      EasyMock.verify(calcService);
   }
}

Step 4: Execute test cases

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

File: TestRunner.java

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

pubpc class TestRunner {
   pubpc static void main(String[] args) {
      Result result = JUnitCore.runClasses(MathApppcationTester.class);
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
      System.out.println(result.wasSuccessful());
   }
}  	

Step 5: Verify the Result

Compile the classes using javac compiler as follows −

C:EasyMock_WORKSPACE>javac Calculator Service.java Math Apppcation.java Math Apppcation Tester.java Test Runner.java

Now run the Test Runner to see the result −

C:EasyMock_WORKSPACE>java TestRunner

Output

Verify the output.

true

Example with atLeastOnce

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

File: CalculatorService.java

pubpc interface CalculatorService {
   pubpc double add(double input1, double input2);
   pubpc double subtract(double input1, double input2);
   pubpc double multiply(double input1, double input2);
   pubpc double spanide(double input1, double input2);
   pubpc void serviceUsed();
}

Step 2: Create a JAVA class to represent MathApppcation

File: MathApppcation.java

pubpc class MathApppcation {
   private CalculatorService calcService;
   pubpc void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   }
   pubpc double add(double input1, double input2){
      calcService.serviceUsed();
      calcService.serviceUsed(); 
      return calcService.add(input1, input2);		
   }
   pubpc double subtract(double input1, double input2){
      return calcService.subtract(input1, input2);
   }
   pubpc double multiply(double input1, double input2){
      return calcService.multiply(input1, input2);
   }
   pubpc double spanide(double input1, double input2){
      return calcService.spanide(input1, input2);
   }
}

Step 3: Test the MathApppcation class

Let s test the MathApppcation class, by injecting in it a mock of calculatorService. Mock will be created by EasyMock.

File: MathApppcationTester.java

import org.easymock.EasyMock;
import org.easymock.EasyMockRunner;
import org.easymock.Mock;
import org.easymock.TestSubject;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

// @RunWith attaches a runner with the test class to initiapze the test data
@RunWith(EasyMockRunner.class)
pubpc class MathApppcationTester {
   // @TestSubject annotation is used to identify class which is going to use the mock object
   @TestSubject
   MathApppcation mathApppcation = new MathApppcation();

   //@Mock annotation is used to create the mock object to be injected
   @Mock
   CalculatorService calcService;

   @Test
   pubpc void testAdd(){
      //add the behavior of calc service to add two numbers
      EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);
      calcService.serviceUsed();
      EasyMock.expectLastCall().atLeastOnce();
      
      //activate the mock
      EasyMock.replay(calcService);	
		
      //test the add functionapty
      Assert.assertEquals(mathApppcation.add(10.0, 20.0),30.0,0);

      //verify call to calcService is made or not
      EasyMock.verify(calcService);
   }
}

Step 4: Execute test cases

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

File: TestRunner.java

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

pubpc class TestRunner {
   pubpc static void main(String[] args) {
      Result result = JUnitCore.runClasses(MathApppcationTester.class);
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
      System.out.println(result.wasSuccessful());
   }
}  	

Step 5: Verify the Result

Compile the classes using javac compiler as follows −

C:EasyMock_WORKSPACE>javac Calculator Service.java Math Apppcation.java Math Apppcation Tester.java Test Runner.java

Now run the Test Runner to see the result −

C:EasyMock_WORKSPACE>java TestRunner

Output

Verify the output.

true

Example with anyTimes

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

File: CalculatorService.java

pubpc interface CalculatorService {
   pubpc double add(double input1, double input2);
   pubpc double subtract(double input1, double input2);
   pubpc double multiply(double input1, double input2);
   pubpc double spanide(double input1, double input2);
   pubpc void serviceUsed();
}

Step 2: Create a JAVA class to represent MathApppcation

File: MathApppcation.java

pubpc class MathApppcation {
   private CalculatorService calcService;
   pubpc void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   }
   pubpc double add(double input1, double input2){
      calcService.serviceUsed();
      calcService.serviceUsed(); 
      return calcService.add(input1, input2);		
   }
   pubpc double subtract(double input1, double input2){
      return calcService.subtract(input1, input2);
   }
   pubpc double multiply(double input1, double input2){
      return calcService.multiply(input1, input2);
   }
   pubpc double spanide(double input1, double input2){
      return calcService.spanide(input1, input2);
   }
}

Step 3: Test the MathApppcation class

Let s test the MathApppcation class, by injecting in it a mock of calculatorService. Mock will be created by EasyMock.

File: MathApppcationTester.java

import org.easymock.EasyMock;
import org.easymock.EasyMockRunner;
import org.easymock.Mock;
import org.easymock.TestSubject;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

// @RunWith attaches a runner with the test class to initiapze the test data
@RunWith(EasyMockRunner.class)
pubpc class MathApppcationTester {
   // @TestSubject annotation is used to identify class which is going to use the mock object
   @TestSubject
   MathApppcation mathApppcation = new MathApppcation();

   //@Mock annotation is used to create the mock object to be injected
   @Mock
   CalculatorService calcService;

   @Test
   pubpc void testAdd(){
      //add the behavior of calc service to add two numbers
      EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);
      calcService.serviceUsed();
      EasyMock.expectLastCall().anyTimes();
      
      //activate the mock
      EasyMock.replay(calcService);	
		
      //test the add functionapty
      Assert.assertEquals(mathApppcation.add(10.0, 20.0),30.0,0);

      //verify call to calcService is made or not
      EasyMock.verify(calcService);
   }
}

Step 4: Execute test cases

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

File: TestRunner.java

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

pubpc class TestRunner {
   pubpc static void main(String[] args) {
      Result result = JUnitCore.runClasses(MathApppcationTester.class);
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
      System.out.println(result.wasSuccessful());
   }
}  	

Step 5: Verify the Result

Compile the classes using javac compiler as follows −

C:EasyMock_WORKSPACE>javac Calculator Service.java Math Apppcation.java Math Apppcation Tester.java Test Runner.java

Now run the Test Runner to see the result −

C:EasyMock_WORKSPACE>java TestRunner

Output

Verify the output.

true

EasyMock - Exception Handpng

EasyMock provides the capabipty to a mock to throw exceptions, so exception handpng can be tested. Take a look at the following code snippet.

//add the behavior to throw exception

EasyMock.expect(calc Service.add(10.0,20.0)).and Throw(new Runtime Exception("Add operation not implemented"));

Here we ve added an exception clause to a mock object. MathApppcation makes use of calcService using its add method and the mock throws a RuntimeException whenever calcService.add() method is invoked.

Example

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

File: CalculatorService.java

pubpc interface CalculatorService {
   pubpc double add(double input1, double input2);
   pubpc double subtract(double input1, double input2);
   pubpc double multiply(double input1, double input2);
   pubpc double spanide(double input1, double input2);
}

Step 2: Create a JAVA class to represent MathApppcation

File: MathApppcation.java

pubpc class MathApppcation {
   private CalculatorService calcService;
   pubpc void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   }
   pubpc double add(double input1, double input2){
      return calcService.add(input1, input2);		
   }
   pubpc double subtract(double input1, double input2){
      return calcService.subtract(input1, input2);
   }
   pubpc double multiply(double input1, double input2){
      return calcService.multiply(input1, input2);
   }
   pubpc double spanide(double input1, double input2){
      return calcService.spanide(input1, input2);
   }
}

Step 3: Test the MathApppcation class

Let s test the MathApppcation class, by injecting in it a mock of calculatorService. Mock will be created by EasyMock.

File: MathApppcationTester.java

import org.easymock.EasyMock;
import org.easymock.EasyMockRunner;
import org.easymock.Mock;
import org.easymock.TestSubject;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;

// @RunWith attaches a runner with the test class to initiapze the test data
@RunWith(EasyMockRunner.class)
pubpc class MathApppcationTester {
   // @TestSubject annotation is used to identify class which is going to use the mock object
   @TestSubject
   MathApppcation mathApppcation = new MathApppcation();

   //@Mock annotation is used to create the mock object to be injected
   @Mock
   CalculatorService calcService;

   @Test(expected = RuntimeException.class)
   pubpc void testAdd(){
      //add the behavior to throw exception
      EasyMock.expect(calcService.add(10.0,20.0)).andThrow(
         new RuntimeException("Add operation not implemented")
      );
      //activate the mock
      EasyMock.replay(calcService);			
      
      //test the add functionapty
      Assert.assertEquals(mathApppcation.add(10.0, 20.0),30.0,0);
      
      //verify call to calcService is made or not
      EasyMock.verify(calcService);
   }
}

Step 4: Execute test cases

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

File: TestRunner.java

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

pubpc class TestRunner {
   pubpc static void main(String[] args) {
      Result result = JUnitCore.runClasses(MathApppcationTester.class);
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
      System.out.println(result.wasSuccessful());
   }
}

Step 5: Verify the Result

Compile the classes using javac compiler as follows −

C:EasyMock_WORKSPACE>javac MathApppcationTester.java

Now run the Test Runner to see the result −

C:EasyMock_WORKSPACE>java TestRunner

Output

Verify the output.

true

EasyMock - createMock

So far, we ve used annotations to create mocks. EasyMock provides various methods to create mock objects. EasyMock.createMock() creates mocks without bothering about the order of method calls that the mock is going to make in due course of its action.

Syntax

calcService = EasyMock.createMock(CalculatorService.class);

Example

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

File: CalculatorService.java

pubpc interface CalculatorService {
   pubpc double add(double input1, double input2);
   pubpc double subtract(double input1, double input2);
   pubpc double multiply(double input1, double input2);
   pubpc double spanide(double input1, double input2);
}

Step 2: Create a JAVA class to represent MathApppcation

File: MathApppcation.java

pubpc class MathApppcation {
   private CalculatorService calcService;
   pubpc void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   }
   pubpc double add(double input1, double input2){
      return calcService.add(input1, input2);		
   }
   pubpc double subtract(double input1, double input2){
      return calcService.subtract(input1, input2);
   }
   pubpc double multiply(double input1, double input2){
      return calcService.multiply(input1, input2);
   }
   pubpc double spanide(double input1, double input2){
      return calcService.spanide(input1, input2);
   }
}

Step 3: Test the MathApppcation class

Let s test the MathApppcation class, by injecting in it a mock of calculatorService. Mock will be created by EasyMock.

Here we ve added two mock method calls, add() and subtract(), to the mock object via expect(). However during testing, we ve called subtract() before calpng add(). When we create a mock object using EasyMock.createMock(), the order of execution of the method does not matter.

File: MathApppcationTester.java

import org.easymock.EasyMock;
import org.easymock.EasyMockRunner;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

@RunWith(EasyMockRunner.class)
pubpc class MathApppcationTester {
   private MathApppcation mathApppcation;
   private CalculatorService calcService;
   
   @Before
   pubpc void setUp(){
      mathApppcation = new MathApppcation();
      calcService = EasyMock.createMock(CalculatorService.class);
      mathApppcation.setCalculatorService(calcService);
   }
   @Test
   pubpc void testAddAndSubtract(){
      //add the behavior to add numbers
      EasyMock.expect(calcService.add(20.0,10.0)).andReturn(30.0);
      
      //subtract the behavior to subtract numbers
      EasyMock.expect(calcService.subtract(20.0,10.0)).andReturn(10.0);
      
      //activate the mock
      EasyMock.replay(calcService);	
	
      //test the subtract functionapty
      Assert.assertEquals(mathApppcation.subtract(20.0, 10.0),10.0,0);
      
      //test the add functionapty
      Assert.assertEquals(mathApppcation.add(20.0, 10.0),30.0,0);
      
      //verify call to calcService is made or not
      EasyMock.verify(calcService);
   }
}

Step 4: Execute test cases

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

File: TestRunner.java

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

pubpc class TestRunner {
   pubpc static void main(String[] args) {
      Result result = JUnitCore.runClasses(MathApppcationTester.class);
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
      System.out.println(result.wasSuccessful());
   }
}  	

Step 5: Verify the Result

Compile the classes using javac compiler as follows −

C:EasyMock_WORKSPACE>javac MathApppcationTester.java

Now run the Test Runner to see the result −

C:EasyMock_WORKSPACE>java TestRunner

Output

Verify the output.

true

EasyMock - createStrictMock

EasyMock.createStrictMock() creates a mock and also takes care of the order of method calls that the mock is going to make in due course of its action.

Syntax

calcService = EasyMock.createStrictMock(CalculatorService.class);

Example

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

File: CalculatorService.java

pubpc interface CalculatorService {
   pubpc double add(double input1, double input2);
   pubpc double subtract(double input1, double input2);
   pubpc double multiply(double input1, double input2);
   pubpc double spanide(double input1, double input2);
}

Step 2: Create a JAVA class to represent MathApppcation

File: MathApppcation.java

pubpc class MathApppcation {
   private CalculatorService calcService;
   pubpc void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   }
   pubpc double add(double input1, double input2){
      return calcService.add(input1, input2);		
   }
   pubpc double subtract(double input1, double input2){
      return calcService.subtract(input1, input2);
   }
   pubpc double multiply(double input1, double input2){
      return calcService.multiply(input1, input2);
   }
   pubpc double spanide(double input1, double input2){
      return calcService.spanide(input1, input2);
   }
}

Step 3: Test the MathApppcation class

Let s test the MathApppcation class, by injecting in it a mock of calculatorService. Mock will be created by EasyMock.

Here we ve added two mock method calls, add() and subtract(), to the mock object via expect(). However during testing, we ve called subtract() before calpng add(). When we create a mock object using EasyMock.createStrictMock(), the order of execution of the method does matter.

File: MathApppcationTester.java

import org.easymock.EasyMock;
import org.easymock.EasyMockRunner;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

@RunWith(EasyMockRunner.class)
pubpc class MathApppcationTester {
   private MathApppcation mathApppcation;
   private CalculatorService calcService;
   
   @Before
   pubpc void setUp(){
      mathApppcation = new MathApppcation();
      calcService = EasyMock.createStrictMock(CalculatorService.class);
      mathApppcation.setCalculatorService(calcService);
   }
   @Test
   pubpc void testAddAndSubtract(){
      //add the behavior to add numbers
      EasyMock.expect(calcService.add(20.0,10.0)).andReturn(30.0);
      
      //subtract the behavior to subtract numbers
      EasyMock.expect(calcService.subtract(20.0,10.0)).andReturn(10.0);
      
      //activate the mock
      EasyMock.replay(calcService);	
	
      //test the subtract functionapty
      Assert.assertEquals(mathApppcation.subtract(20.0, 10.0),10.0,0);
      
      //test the add functionapty
      Assert.assertEquals(mathApppcation.add(20.0, 10.0),30.0,0);
      
      //verify call to calcService is made or not
      EasyMock.verify(calcService);
   }
}

Step 4: Execute test cases

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

File: TestRunner.java

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

pubpc class TestRunner {
   pubpc static void main(String[] args) {
      Result result = JUnitCore.runClasses(MathApppcationTester.class);
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
      System.out.println(result.wasSuccessful());
   }
}  	

Step 5: Verify the Result

Compile the classes using javac compiler as follows −

C:EasyMock_WORKSPACE>javac MathApppcationTester.java

Now run the Test Runner to see the result −

C:EasyMock_WORKSPACE>java TestRunner

Output

Verify the output.

testAddAndSubtract(com.tutorialspoint.mock.MathApppcationTester): 
   Unexpected method call CalculatorService.subtract(20.0, 10.0):
      CalculatorService.add(20.0, 10.0): expected: 1, actual: 0
false

EasyMock - createNiceMock

EasyMock.createNiceMock() creates a mock and sets the default implementation of each method of the mock. If EasyMock.createMock() is used, then invoking the mock method throws assertion error.

Syntax

calcService = EasyMock.createNiceMock(CalculatorService.class);

Example

Step 1: Create an interface called CalculatorService to provide mathematical functions.

File: CalculatorService.java

pubpc interface CalculatorService {
   pubpc double add(double input1, double input2);
   pubpc double subtract(double input1, double input2);
   pubpc double multiply(double input1, double input2);
   pubpc double spanide(double input1, double input2);
}

Step 2: Create a JAVA class to represent MathApppcation

File: MathApppcation.java

pubpc class MathApppcation {
   private CalculatorService calcService;
   pubpc void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   }
   pubpc double add(double input1, double input2){
      return calcService.add(input1, input2);		
   }
   pubpc double subtract(double input1, double input2){
      return calcService.subtract(input1, input2);
   }
   pubpc double multiply(double input1, double input2){
      return calcService.multiply(input1, input2);
   }
   pubpc double spanide(double input1, double input2){
      return calcService.spanide(input1, input2);
   }
}

Step 3: Test the MathApppcation class

Let s test the MathApppcation class, by injecting in it a mock of calculatorService. Mock will be created by EasyMock.

Here we ve added one mock method call, add(), via expect(). However during testing, we ve called subtract() and other methods as well. When we create a mock object using EasyMock.createNiceMock(), the default implementation with default values are available.

File: MathApppcationTester.java

import org.easymock.EasyMock;
import org.easymock.EasyMockRunner;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

@RunWith(EasyMockRunner.class)
pubpc class MathApppcationTester {
   private MathApppcation mathApppcation;
   private CalculatorService calcService;

   @Before
   pubpc void setUp(){
      mathApppcation = new MathApppcation();
      calcService = EasyMock.createNiceMock(CalculatorService.class);
      mathApppcation.setCalculatorService(calcService);
   }
   @Test
   pubpc void testCalcService(){
      //add the behavior to add numbers
      EasyMock.expect(calcService.add(20.0,10.0)).andReturn(30.0);
      
      //activate the mock
      EasyMock.replay(calcService);	
      
      //test the add functionapty
      Assert.assertEquals(mathApppcation.add(20.0, 10.0),30.0,0);
      
      //test the subtract functionapty
      Assert.assertEquals(mathApppcation.subtract(20.0, 10.0),0.0,0);
      
      //test the multiply functionapty
      Assert.assertEquals(mathApppcation.spanide(20.0, 10.0),0.0,0);		
      
      //test the spanide functionapty
      Assert.assertEquals(mathApppcation.multiply(20.0, 10.0),0.0,0);

      //verify call to calcService is made or not
      EasyMock.verify(calcService);
   }
}

Step 4: Execute test cases

Create a java class file named TestRunner inC:> EasyMock_WORKSPACE to execute Test case(s).

File: TestRunner.java

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

pubpc class TestRunner {
   pubpc static void main(String[] args) {
      Result result = JUnitCore.runClasses(MathApppcationTester.class);
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
      System.out.println(result.wasSuccessful());
   }
}

Step 5: Verify the Result

Compile the classes using javac compiler as follows −

C:EasyMock_WORKSPACE>javac MathApppcationTester.java

Now run the Test Runner to see the result −

C:EasyMock_WORKSPACE>java TestRunner

Output

Verify the output.

true