EasyMock 快速指南

上一頁
下一頁

EasyMock - 概述

什麼是模擬（Mocking）？

模擬是一種隔離測試類功能的方法。模擬不需要資料庫連線或屬性檔案讀取或檔案伺服器讀取來測試功能。模擬物件模擬真實服務。模擬物件返回與傳遞給它的某些虛擬輸入相對應的虛擬資料。

EasyMock

EasyMock 方便無縫建立模擬物件。它使用 Java 反射來為給定的介面建立模擬物件。模擬物件只是實際實現的代理。考慮一個返回股票價格詳情的股票服務案例。在開發過程中，無法使用實際的股票服務來獲取即時資料。因此，我們需要股票服務的虛擬實現。EasyMock 可以像其名稱所暗示的那樣輕鬆地做到這一點。

EasyMock 的優勢

  • 無需手動編寫 − 無需自行編寫模擬物件。

  • 重構安全 − 重新命名介面方法名稱或重新排序引數不會破壞測試程式碼，因為模擬物件是在執行時建立的。

  • 支援返回值 − 支援返回值。

  • 支援異常 − 支援異常。

  • 支援順序檢查 − 支援檢查方法呼叫的順序。

  • 支援註解 − 支援使用註解建立模擬物件。

示例

考慮以下程式碼片段。

package com.tutorialspoint.mock;

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

public class PortfolioTester {
   public static void main(String[] args){
      //Create a portfolio object which is to be tested		
      Portfolio portfolio = new Portfolio();

      //Creates a list of stocks to be added to the portfolio
      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 portfolio
      portfolio.setStocks(stocks);

      //set the stockService to the portfolio
      portfolio.setStockService(stockServiceMock);
      double marketValue = portfolio.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 portfolio: "+ marketValue);
   }
}

讓我們瞭解上述程式的重要概念。完整程式碼可在第一個應用程式章節中找到。

  • 投資組合（Portfolio） − 一個物件，用於攜帶股票列表並使用股票價格和股票數量計算市值。

  • 股票（Stock） − 一個物件，用於攜帶股票的詳細資訊，例如其 ID、名稱、數量等。

  • 股票服務（StockService） − 股票服務返回股票的當前價格。

  • EasyMock.createMock(...) − EasyMock 建立了一個股票服務的模擬物件。

  • EasyMock.expect(...).andReturn(...) − StockService 介面的 getPrice 方法的模擬實現。對於 googleStock，返回 50.00 作為價格。

  • EasyMock.replay(...) − EasyMock 準備模擬物件，使其可以用於測試。

  • portfolio.setStocks(...) − 投資組合現在包含兩個股票的列表。

  • portfolio.setStockService(...) − 將 stockService 模擬物件分配給投資組合。

  • portfolio.getMarketValue() − 投資組合使用模擬股票服務根據其股票返回市值。

EasyMock - 環境搭建

本章將引導您完成在基於 Windows 和 Linux 的系統上設定 EasyMock 的過程。EasyMock 可以輕鬆安裝並與您當前的 Java 環境整合，只需遵循幾個簡單的步驟，無需任何複雜的設定程式。安裝期間需要使用者管理許可權。

系統要求

JDK Java SE 2 JDK 1.5 或更高版本
記憶體 1 GB RAM（推薦）
磁碟空間 無最低要求
作業系統版本 Windows XP 或更高版本，Linux

現在讓我們繼續安裝 EasyMock 的步驟。

步驟 1：驗證您的 Java 安裝

首先，您需要在系統上安裝 Java 軟體開發工具包 (SDK)。要驗證這一點，請根據您正在使用的平臺執行以下兩個命令中的任何一個。

如果 Java 安裝已正確完成，則它將顯示 Java 安裝的當前版本和規範。樣本輸出如下表所示。

平臺 命令 示例輸出
Windows

開啟命令控制檯並輸入

\>java –version

java version "11.0.11" 2021-04-20 LTS

Java(TM) SE Runtime Environment 18.9 (build 11.0.11+9-LTS-194)

Java HotSpot(TM) 64-Bit Server VM 18.9 (build 11.0.11+9-LTS-194, mixed mode)
Linux

開啟命令終端並輸入

$java –version

java version "11.0.11" 2021-04-20 LTS

Open JDK Runtime Environment 18.9 (build 11.0.11+9-LTS-194)

Open JDK 64-Bit Server VM (build 11.0.11+9-LTS-194, mixed mode)

步驟 2：設定您的 Java 環境

設定環境變數 JAVA_HOME 以指向 Java 安裝在您機器上的基本目錄位置。例如：

序號 平臺和描述
1

Windows

將 JAVA_HOME 設定為 C:\ProgramFiles\java\jdk11.0.11
2

Linux

export JAVA_HOME = /usr/local/java-current

將 Java 編譯器位置的完整路徑附加到系統路徑。

序號 平臺和描述
1

Windows

將字串 "C:\Program Files\Java\jdk11.0.11\bin" 附加到系統變數 PATH 的末尾。
2

Linux

export PATH = $PATH:$JAVA_HOME/bin/

從命令提示符執行命令java -version，如上所述。

步驟 3：安裝 EasyMock 庫

從https://easymock.org/下載最新版本的 EasyMock 並將其內容解壓縮到一個資料夾中，從中可以將所需的庫連結到您的 Java 程式。讓我們假設這些檔案收集在 C 盤上的一個資料夾中。

將所需jars的完整路徑新增到 CLASSPATH，如下所示。

序號 平臺和描述
1

Windows

將以下字串附加到使用者變數的末尾

CLASSPATH −

C:\easymock\easymock-4.3.jar;
2

Linux

export CLASSPATH = $CLASSPATH

/usr/share/easymock\easymock-4.3.tar

步驟 4：下載 JUnit 存檔

從Github下載最新版本的 JUnit jar 檔案。將資料夾儲存到 C:\>Junit 位置。

作業系統 存檔名稱
Windows junit4.13.2.jar, hamcrest-core-1.3.jar
Linux junit4.13.2.jar, hamcrest-core-1.3.jar

步驟 5：設定 JUnit 環境

設定JUNIT_HOME環境變數以指向 JUnit jar 檔案儲存在您機器上的基本目錄位置。下表顯示瞭如何在不同的作業系統上設定此環境變數，假設我們已將 junit4.13.2.jar 和 hamcrest-core-1.3.jar 儲存在 C:\>Junit。

作業系統 輸出
Windows 將環境變數 JUNIT_HOME 設定為 C:\JUNIT
Linux export JUNIT_HOME=/usr/local/JUNIT

步驟 6：設定 CLASSPATH 變數

設定 CLASSPATH 環境變數以指向 JUNIT jar 檔案位置。下表顯示瞭如何在不同的作業系統上執行此操作。

作業系統 輸出
Windows 將環境變數 CLASSPATH 設定為 %CLASSPATH%;%JUNIT_HOME%\junit4.13.2.jar;%JUNIT_HOME%\hamcrest-core-1.3.jar;.
Linux Export CLASSPATH=$CLASSPATH:$JUNIT_HOME/junit4.13.2.jar:$JUNIT_HOME/hamcrest-core-1.3.jar:.

EasyMock - 第一個應用程式

在詳細介紹 EasyMock 框架之前，讓我們看看一個實際應用。在這個示例中，我們建立了一個股票服務的模擬物件來獲取一些股票的虛擬價格，並對名為 Portfolio 的 Java 類進行了單元測試。

該過程將在下面分步驟討論。

示例

步驟 1：建立一個 JAVA 類來表示股票

檔案：Stock.java

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

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

步驟 2：建立一個 StockService 介面來獲取股票的價格。

檔案：StockService.java

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

步驟 3：建立一個 Portfolio 類來表示任何客戶的投資組合。

檔案：Portfolio.java

import java.util.List;

public class Portfolio {
   private StockService stockService;
   private List<Stock> stocks;

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

步驟 4：測試 Portfolio 類

讓我們透過向其中注入 stockservice 的模擬物件來測試 Portfolio 類。模擬物件將由 EasyMock 建立。

檔案：PortfolioTester.java

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

public class PortfolioTester {
   Portfolio portfolio;	
   StockService stockService;

   public static void main(String[] args){
      PortfolioTester tester = new PortfolioTester();
      tester.setUp();
      System.out.println(tester.testMarketValue()?"pass":"fail");
   }
   public void setUp(){
      //Create a portfolio object which is to be tested		
      portfolio = new Portfolio();		
      
      //Create the mock object of stock service
      stockService = EasyMock.createMock(StockService.class);		
      
      //set the stockService to the portfolio
      portfolio.setStockService(stockService);
   }
   public boolean testMarketValue(){
      //Creates a list of stocks to be added to the portfolio
      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 portfolio
      portfolio.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 = portfolio.getMarketValue();		
      return marketValue == 100500.0;
   }
}

步驟 5：驗證結果

使用javac編譯器編譯類，如下所示：

C:\EasyMock_WORKSPACE>javac Stock.java StockService.java Portfolio.java PortfolioTester.java

現在執行 PortfolioTester 以檢視結果：

C:\EasyMock_WORKSPACE>java PortfolioTester

輸出

驗證輸出

pass

EasyMock - JUnit 整合

在本章中，我們將學習如何將 JUnit 和 EasyMock 整合在一起。在這裡，我們將建立一個數學應用程式，它使用 CalculatorService 執行基本的數學運算，例如加法、減法、乘法和除法。我們將使用 EasyMock 模擬 CalculatorService 的虛擬實現。此外，我們還廣泛使用了註解來展示它們與 JUnit 和 EasyMock 的相容性。

示例

該過程將在下面分步驟討論。

步驟 1：建立一個名為 CalculatorService 的介面來提供數學函式

檔案：CalculatorService.java

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);
}

步驟 2：建立一個 JAVA 類來表示 MathApplication

檔案：MathApplication.java

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);
   }
}

步驟 3：測試 MathApplication 類

讓我們透過向其中注入 calculatorService 的模擬物件來測試 MathApplication 類。模擬物件將由 EasyMock 建立。

檔案：MathApplicationTester.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 initialize the test data
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
   // @TestSubject annotation is used to identify class which is going to use the mock object
   @TestSubject
   MathApplication mathApplication = new MathApplication();

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

   @Test
   public 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 functionality
      Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);
   }
}

步驟 4：建立一個類來執行測試用例。

在C:\>EasyMock_WORKSPACE中建立一個名為 TestRunner 的 java 類檔案來執行測試用例。

檔案：TestRunner.java

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()) {
         System.out.println(failure.toString());
      }
      System.out.println(result.wasSuccessful());
   }
}

步驟 5：驗證結果

使用javac編譯器編譯類，如下所示：

C:\EasyMock_WORKSPACE>javac CalculatorService.java MathApplication.java MathApplicationTester.java TestRunner.java

現在執行測試執行器以檢視結果：

C:\EasyMock_WORKSPACE>java TestRunner

輸出

驗證輸出。

true

要了解有關 JUnit 的更多資訊，請參閱 Tutorials Point 上的 JUnit 教程。

EasyMock - 新增行為

EasyMock 使用expect()和expectLassCall()方法向模擬物件新增功能。檢視以下程式碼片段。

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

在這裡，我們指示 EasyMock 為 calcService 的 add 方法新增 10 和 20 的行為，並因此返回 30.00 的值。

此時，Mock 只記錄了行為，但它並沒有作為模擬物件工作。呼叫 replay 後，它按預期工作。

//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);

無 EasyMock.Replay() 的示例

步驟 1：建立一個名為 CalculatorService 的介面來提供數學函式

檔案：CalculatorService.java

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);
}

步驟 2：建立一個 JAVA 類來表示 MathApplication

檔案：MathApplication.java

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);
   }
}

步驟 3：測試 MathApplication 類

讓我們透過向其中注入 calculatorService 的模擬物件來測試 MathApplication 類。模擬物件將由 EasyMock 建立。

檔案：MathApplicationTester.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 initialize the test data
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
   // @TestSubject annotation is used to identify the class which is going to use the mock object
   @TestSubject
   MathApplication mathApplication = new MathApplication();

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

   @Test
   public 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 functionality
      Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);
   }
}

步驟 4：執行測試用例

在C:\>EasyMock_WORKSPACE中建立一個名為 TestRunner 的 java 類檔案來執行測試用例。

檔案：TestRunner.java

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()) {
         System.out.println(failure.toString());
      }
      System.out.println(result.wasSuccessful());
   }
}

步驟 5：驗證結果

使用javac編譯器編譯類，如下所示：

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

現在執行測試執行器以檢視結果：

C:\EasyMock_WORKSPACE>java TestRunner

輸出

驗證輸出。

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

有 EasyMock.Replay() 的示例

步驟 1：建立一個名為 CalculatorService 的介面來提供數學函式。

檔案：CalculatorService.java

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);
}

步驟 2：建立一個 JAVA 類來表示 MathApplication。

檔案：MathApplication.java

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);
   }
}

步驟 3：測試 MathApplication 類

讓我們透過向其中注入 calculatorService 的模擬物件來測試 MathApplication 類。模擬物件將由 EasyMock 建立。

檔案：MathApplicationTester.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 initialize the test data
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
   // @TestSubject annotation is used to identify class which is going to use the mock object
   @TestSubject
   MathApplication mathApplication = new MathApplication();

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

   @Test
   public 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 functionality
      Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);
   }
}

步驟 4：執行測試用例

在C:\>EasyMock_WORKSPACE中建立一個名為 TestRunner 的 java 類檔案來執行測試用例。

檔案：TestRunner.java

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()) {
         System.out.println(failure.toString());
      }
      System.out.println(result.wasSuccessful());
   }
}

步驟 5：驗證結果

使用javac編譯器編譯類，如下所示：

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

現在執行測試執行器以檢視結果。

C:\EasyMock_WORKSPACE>java TestRunner

輸出

驗證輸出。

true

EasyMock - 驗證行為

EasyMock 可以確保是否正在使用模擬物件。這是使用verify()方法完成的。檢視以下程式碼片段。

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

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

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

無 EasyMock.Verify() 的示例

步驟 1：建立一個名為 CalculatorService 的介面來提供數學函式

檔案：CalculatorService.java

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);
}

步驟 2：建立一個 JAVA 類來表示 MathApplication

檔案：MathApplication.java

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);
      return 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);
   }
}

步驟 3：測試 MathApplication 類

讓我們透過向其中注入 calculatorService 的模擬物件來測試 MathApplication 類。模擬物件將由 EasyMock 建立。

檔案：MathApplicationTester.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 initialize the test data
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
   // @TestSubject annotation is used to identify class which is going to use the mock object
   @TestSubject
   MathApplication mathApplication = new MathApplication();

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

   @Test
   public 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 functionality
      Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);

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

步驟 4：執行測試用例

在C:\>EasyMock_WORKSPACE中建立一個名為 TestRunner 的 java 類檔案來執行測試用例。

檔案：TestRunner.java

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()) {
         System.out.println(failure.toString());
      }
      System.out.println(result.wasSuccessful());
   }
}

步驟 5：驗證結果

使用javac編譯器編譯類，如下所示：

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

現在執行測試執行器以檢視結果。

C:\EasyMock_WORKSPACE>java TestRunner

輸出

驗證輸出。

true

有 EasyMock.Verify() 的示例

步驟 1：建立一個 CalculatorService 介面來提供數學函式

檔案：CalculatorService.java

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);
}

步驟 2：建立一個 JAVA 類來表示 MathApplication

檔案：MathApplication.java

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);
      return 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);
   }
}

步驟 3：測試 MathApplication 類

讓我們透過向其中注入 calculatorService 的模擬物件來測試 MathApplication 類。模擬物件將由 EasyMock 建立。

檔案：MathApplicationTester.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 initialize the test data
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
   // @TestSubject annotation is used to identify class which is going to use the mock object
   @TestSubject
   MathApplication mathApplication = new MathApplication();

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

   @Test
   public 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 functionality
      Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);

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

步驟 4：執行測試用例

在C:\>EasyMock_WORKSPACE中建立一個名為 TestRunner 的 java 類檔案來執行測試用例。

檔案：TestRunner.java

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()) {
         System.out.println(failure.toString());
      }
      System.out.println(result.wasSuccessful());
   }
}

步驟 5：驗證結果

使用javac編譯器編譯類，如下所示：

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

現在執行測試執行器以檢視結果：

C:\EasyMock_WORKSPACE>java TestRunner

輸出

驗證輸出。

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

EasyMock - 期望呼叫

EasyMock 對特定方法可以呼叫的次數進行特殊檢查。假設 MathApplication 應該只調用 CalculatorService.serviceUsed() 方法一次，那麼它不應該能夠呼叫 CalculatorService.serviceUsed() 多於一次。

//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();

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

建立 CalculatorService 介面如下所示。

檔案：CalculatorService.java

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);
   public void serviceUsed();
}

calcService.serviceUsed() 呼叫一次的示例

步驟 1：建立一個名為 CalculatorService 的介面來提供數學函式

檔案：CalculatorService.java

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);
   public void serviceUsed();
}

步驟 2：建立一個 JAVA 類來表示 MathApplication

檔案：MathApplication.java

public class MathApplication {
   private CalculatorService calcService;
   public void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   }
   public double add(double input1, double input2){		
      calcService.serviceUsed();
      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);
   }
}

步驟 3：測試 MathApplication 類

讓我們透過向其中注入 calculatorService 的模擬物件來測試 MathApplication 類。模擬物件將由 EasyMock 建立。

檔案：MathApplicationTester.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 initialize the test data
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
   // @TestSubject annotation is used to identify class which is going to use the mock object
   @TestSubject
   MathApplication mathApplication = new MathApplication();

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

   @Test
   public 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 functionality
      Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);

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

步驟 4：執行測試用例

在C:\>EasyMock_WORKSPACE中建立一個名為 TestRunner 的 java 類檔案來執行測試用例。

檔案：TestRunner.java

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()) {
         System.out.println(failure.toString());
      }
      System.out.println(result.wasSuccessful());
   }
}

步驟 5：驗證結果

使用javac編譯器編譯類，如下所示：

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

現在執行測試執行器以檢視結果：

C:\EasyMock_WORKSPACE>java TestRunner

輸出

驗證輸出。

true

calcService.serviceUsed() 呼叫兩次的示例

步驟 1：建立一個名為 CalculatorService 的介面來提供數學函式。

檔案：CalculatorService.java

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);
   public void serviceUsed();
}

步驟 2：建立一個 JAVA 類來表示 MathApplication。

檔案：MathApplication.java

public class MathApplication {
   private CalculatorService calcService;
   public void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   }
   public double add(double input1, double input2){		
      calcService.serviceUsed();
      calcService.serviceUsed();
      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);
   }
}

步驟 3：測試 MathApplication 類

讓我們透過向其中注入 calculatorService 的模擬物件來測試 MathApplication 類。模擬物件將由 EasyMock 建立。

檔案：MathApplicationTester.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 initialize the test data
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
   // @TestSubject annotation is used to identify class which is going to use the mock object
   @TestSubject
   MathApplication mathApplication = new MathApplication();

   //@Mock annotation is used to create the mock object to be injected
   @Mock
   CalculatorService calcService;
	
   @Test
   public 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 functionality
      Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);

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

步驟 4：執行測試用例

在C:\>EasyMock_WORKSPACE中建立一個名為 TestRunner 的 java 類檔案來執行測試用例。

檔案：TestRunner.java

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()) {
         System.out.println(failure.toString());
      }
      System.out.println(result.wasSuccessful()); 
   }
}

步驟 5：驗證結果

使用javac編譯器編譯類，如下所示：

C:\EasyMock_WORKSPACE>javac CalculatorService.java MathApplication.java MathApplicationTester.java TestRunner.java

現在執行測試執行器以檢視結果：

C:\EasyMock_WORKSPACE>java TestRunner

輸出

驗證輸出。

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

不呼叫 calcService.serviceUsed() 的示例

步驟 1：建立一個 Calculator Service 介面來提供數學函式

檔案：CalculatorService.java

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);
   public void serviceUsed();
}

步驟 2：建立一個 JAVA 類來表示 MathApplication

檔案：MathApplication.java

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);
   }
}

步驟 3：測試 MathApplication 類

讓我們透過向其中注入 calculatorService 的模擬物件來測試 MathApplication 類。模擬物件將由 EasyMock 建立。

檔案：MathApplicationTester.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 initialize the test data
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
   // @TestSubject annotation is used to identify class which is going to use the mock object
   @TestSubject
   MathApplication mathApplication = new MathApplication();

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

   @Test
   public 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 functionality
      Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);

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

步驟 4：執行測試用例

在C:\>EasyMock_WORKSPACE中建立一個名為 TestRunner 的 java 類檔案來執行測試用例。

檔案：TestRunner.java

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()) {
         System.out.println(failure.toString());
      }
      System.out.println(result.wasSuccessful());
   }
}

步驟 5：驗證結果

使用javac編譯器編譯類，如下所示：

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

現在執行測試執行器以檢視結果：

C:\EasyMock_WORKSPACE>java TestRunner

輸出

驗證輸出。

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

EasyMock - 多次呼叫

EasyMock 提供以下附加方法來改變預期的呼叫次數。

  • times(int min, int max) − 期望在 min 和 max 呼叫之間。

  • atLeastOnce() − 期望至少一次呼叫。

  • anyTimes() − 期望無限次呼叫。

times(min,max) 的示例

步驟 1：建立一個 CalculatorService 介面來提供數學函式

檔案：CalculatorService.java

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);
   public void serviceUsed();
}

步驟 2：建立一個 JAVA 類來表示 MathApplication

檔案：MathApplication.java

public class MathApplication {
   private CalculatorService calcService;
   public void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   }
   public double add(double input1, double input2){
      calcService.serviceUsed();
      calcService.serviceUsed();
      calcService.serviceUsed();   
      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);
   }
}

步驟 3：測試 MathApplication 類

讓我們透過向其中注入 calculatorService 的模擬物件來測試 MathApplication 類。模擬物件將由 EasyMock 建立。

檔案：MathApplicationTester.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 initialize the test data
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
   // @TestSubject annotation is used to identify class which is going to use the mock object
   @TestSubject
   MathApplication mathApplication = new MathApplication();

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

   @Test
   public 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 functionality
      Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);

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

步驟 4：執行測試用例

在C:\>EasyMock_WORKSPACE中建立一個名為 TestRunner 的 java 類檔案來執行測試用例

檔案：TestRunner.java

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()) {
         System.out.println(failure.toString());
      }
      System.out.println(result.wasSuccessful());
   }
}

步驟 5：驗證結果

使用javac編譯器編譯類，如下所示：

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

現在執行測試執行器以檢視結果：

C:\EasyMock_WORKSPACE>java TestRunner

輸出

驗證輸出。

true

至少一次的示例

步驟 1：建立一個名為 CalculatorService 的介面來提供數學函式

檔案：CalculatorService.java

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);
   public void serviceUsed();
}

步驟 2：建立一個 JAVA 類來表示 MathApplication

檔案：MathApplication.java

public class MathApplication {
   private CalculatorService calcService;
   public void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   }
   public double add(double input1, double input2){
      calcService.serviceUsed();
      calcService.serviceUsed(); 
      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);
   }
}

步驟 3：測試 MathApplication 類

讓我們透過向其中注入 calculatorService 的模擬物件來測試 MathApplication 類。模擬物件將由 EasyMock 建立。

檔案：MathApplicationTester.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 initialize the test data
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
   // @TestSubject annotation is used to identify class which is going to use the mock object
   @TestSubject
   MathApplication mathApplication = new MathApplication();

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

   @Test
   public 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 functionality
      Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);

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

步驟 4：執行測試用例

在C:\>EasyMock_WORKSPACE中建立一個名為 TestRunner 的 java 類檔案來執行測試用例。

檔案：TestRunner.java

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()) {
         System.out.println(failure.toString());
      }
      System.out.println(result.wasSuccessful());
   }
}

步驟 5：驗證結果

使用javac編譯器編譯類，如下所示：

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

現在執行測試執行器以檢視結果：

C:\EasyMock_WORKSPACE>java TestRunner

輸出

驗證輸出。

true

任意次數的示例

步驟 1：建立一個名為 CalculatorService 的介面來提供數學函式

檔案：CalculatorService.java

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);
   public void serviceUsed();
}

步驟 2：建立一個 JAVA 類來表示 MathApplication

檔案：MathApplication.java

public class MathApplication {
   private CalculatorService calcService;
   public void setCalculatorService(CalculatorService calcService){
      this.calcService = calcService;
   }
   public double add(double input1, double input2){
      calcService.serviceUsed();
      calcService.serviceUsed(); 
      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);
   }
}

步驟 3：測試 MathApplication 類

讓我們透過向其中注入 calculatorService 的模擬物件來測試 MathApplication 類。模擬物件將由 EasyMock 建立。

檔案：MathApplicationTester.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 initialize the test data
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
   // @TestSubject annotation is used to identify class which is going to use the mock object
   @TestSubject
   MathApplication mathApplication = new MathApplication();

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

   @Test
   public 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 functionality
      Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);

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

步驟 4：執行測試用例

在C:\>EasyMock_WORKSPACE中建立一個名為 TestRunner 的 java 類檔案來執行測試用例。

檔案：TestRunner.java

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()) {
         System.out.println(failure.toString());
      }
      System.out.println(result.wasSuccessful());
   }
}

步驟 5：驗證結果

使用javac編譯器編譯類，如下所示：

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

現在執行測試執行器以檢視結果：

C:\EasyMock_WORKSPACE>java TestRunner

輸出

驗證輸出。

true

EasyMock - 異常處理

EasyMock 提供了讓 Mock 物件丟擲異常的能力，因此可以測試異常處理。請看下面的程式碼片段。

//add the behavior to throw exception

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

在這裡，我們向 Mock 物件添加了一個異常處理語句。MathApplication 使用 calcService 的 add 方法，並且當呼叫 calcService.add() 方法時，Mock 物件會丟擲一個 RuntimeException。

示例

步驟 1：建立一個名為 CalculatorService 的介面來提供數學函式

檔案：CalculatorService.java

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);
}

步驟 2：建立一個 JAVA 類來表示 MathApplication

檔案：MathApplication.java

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);
   }
}

步驟 3：測試 MathApplication 類

讓我們透過向其中注入 calculatorService 的模擬物件來測試 MathApplication 類。模擬物件將由 EasyMock 建立。

檔案：MathApplicationTester.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 initialize the test data
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
   // @TestSubject annotation is used to identify class which is going to use the mock object
   @TestSubject
   MathApplication mathApplication = new MathApplication();

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

   @Test(expected = RuntimeException.class)
   public 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 functionality
      Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);
      
      //verify call to calcService is made or not
      EasyMock.verify(calcService);
   }
}

步驟 4：執行測試用例

在C:\>EasyMock_WORKSPACE中建立一個名為 TestRunner 的 java 類檔案來執行測試用例。

檔案：TestRunner.java

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()) {
         System.out.println(failure.toString());
      }
      System.out.println(result.wasSuccessful());
   }
}

步驟 5：驗證結果

使用javac編譯器編譯類，如下所示：

C:\EasyMock_WORKSPACE>javac MathApplicationTester.java

現在執行測試執行器以檢視結果：

C:\EasyMock_WORKSPACE>java TestRunner

輸出

驗證輸出。

true

EasyMock - createMock

到目前為止，我們使用註解來建立 Mock 物件。EasyMock 提供了多種建立 Mock 物件的方法。EasyMock.createMock() 建立 Mock 物件，無需考慮 Mock 物件在其操作過程中將要呼叫的方法的順序。

語法

calcService = EasyMock.createMock(CalculatorService.class);

示例

步驟 1：建立一個名為 CalculatorService 的介面來提供數學函式

檔案：CalculatorService.java

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);
}

步驟 2：建立一個 JAVA 類來表示 MathApplication

檔案：MathApplication.java

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);
   }
}

步驟 3：測試 MathApplication 類

讓我們透過向其中注入 calculatorService 的模擬物件來測試 MathApplication 類。模擬物件將由 EasyMock 建立。

在這裡，我們透過 expect() 向 Mock 物件添加了兩個模擬方法呼叫，add() 和 subtract()。但是，在測試期間，我們在呼叫 add() 之前呼叫了 subtract()。當我們使用 EasyMock.createMock() 建立 Mock 物件時，方法的執行順序無關緊要。

檔案：MathApplicationTester.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)
public class MathApplicationTester {
   private MathApplication mathApplication;
   private CalculatorService calcService;
   
   @Before
   public void setUp(){
      mathApplication = new MathApplication();
      calcService = EasyMock.createMock(CalculatorService.class);
      mathApplication.setCalculatorService(calcService);
   }
   @Test
   public 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 functionality
      Assert.assertEquals(mathApplication.subtract(20.0, 10.0),10.0,0);
      
      //test the add functionality
      Assert.assertEquals(mathApplication.add(20.0, 10.0),30.0,0);
      
      //verify call to calcService is made or not
      EasyMock.verify(calcService);
   }
}

步驟 4：執行測試用例

在C:\>EasyMock_WORKSPACE中建立一個名為 TestRunner 的 java 類檔案來執行測試用例。

檔案：TestRunner.java

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()) {
         System.out.println(failure.toString());
      }
      System.out.println(result.wasSuccessful());
   }
}

步驟 5：驗證結果

使用javac編譯器編譯類，如下所示：

C:\EasyMock_WORKSPACE>javac MathApplicationTester.java

現在執行測試執行器以檢視結果：

C:\EasyMock_WORKSPACE>java TestRunner

輸出

驗證輸出。

true

EasyMock - createStrictMock

EasyMock.createStrictMock() 建立一個 Mock 物件，並同時處理 Mock 物件在其操作過程中將要呼叫的方法的順序。

語法

calcService = EasyMock.createStrictMock(CalculatorService.class);

示例

步驟 1：建立一個名為 CalculatorService 的介面來提供數學函式

檔案：CalculatorService.java

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);
}

步驟 2：建立一個 JAVA 類來表示 MathApplication

檔案：MathApplication.java

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);
   }
}

步驟 3：測試 MathApplication 類

讓我們透過向其中注入 calculatorService 的模擬物件來測試 MathApplication 類。模擬物件將由 EasyMock 建立。

在這裡，我們透過 expect() 向 Mock 物件添加了兩個模擬方法呼叫，add() 和 subtract()。但是，在測試期間，我們在呼叫 add() 之前呼叫了 subtract()。當我們使用 EasyMock.createStrictMock() 建立 Mock 物件時，方法的執行順序很重要。

檔案：MathApplicationTester.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)
public class MathApplicationTester {
   private MathApplication mathApplication;
   private CalculatorService calcService;
   
   @Before
   public void setUp(){
      mathApplication = new MathApplication();
      calcService = EasyMock.createStrictMock(CalculatorService.class);
      mathApplication.setCalculatorService(calcService);
   }
   @Test
   public 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 functionality
      Assert.assertEquals(mathApplication.subtract(20.0, 10.0),10.0,0);
      
      //test the add functionality
      Assert.assertEquals(mathApplication.add(20.0, 10.0),30.0,0);
      
      //verify call to calcService is made or not
      EasyMock.verify(calcService);
   }
}

步驟 4：執行測試用例

在C:\>EasyMock_WORKSPACE中建立一個名為 TestRunner 的 java 類檔案來執行測試用例。

檔案：TestRunner.java

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()) {
         System.out.println(failure.toString());
      }
      System.out.println(result.wasSuccessful());
   }
}

步驟 5：驗證結果

使用javac編譯器編譯類，如下所示：

C:\EasyMock_WORKSPACE>javac MathApplicationTester.java

現在執行測試執行器以檢視結果：

C:\EasyMock_WORKSPACE>java TestRunner

輸出

驗證輸出。

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

EasyMock - createNiceMock

EasyMock.createNiceMock() 建立一個 Mock 物件，併為 Mock 物件的每個方法設定預設實現。如果使用 EasyMock.createMock()，則呼叫 Mock 方法會丟擲斷言錯誤。

語法

calcService = EasyMock.createNiceMock(CalculatorService.class);

示例

步驟 1：建立一個名為 CalculatorService 的介面來提供數學函式。

檔案：CalculatorService.java

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);
}

步驟 2：建立一個 JAVA 類來表示 MathApplication

檔案：MathApplication.java

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);
   }
}

步驟 3：測試 MathApplication 類

讓我們透過向其中注入 calculatorService 的模擬物件來測試 MathApplication 類。模擬物件將由 EasyMock 建立。

在這裡，我們透過 expect() 添加了一個模擬方法呼叫 add()。但是，在測試期間，我們也呼叫了 subtract() 和其他方法。當我們使用 EasyMock.createNiceMock() 建立 Mock 物件時，可以使用具有預設值的預設實現。

檔案：MathApplicationTester.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)
public class MathApplicationTester {
   private MathApplication mathApplication;
   private CalculatorService calcService;

   @Before
   public void setUp(){
      mathApplication = new MathApplication();
      calcService = EasyMock.createNiceMock(CalculatorService.class);
      mathApplication.setCalculatorService(calcService);
   }
   @Test
   public 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 functionality
      Assert.assertEquals(mathApplication.add(20.0, 10.0),30.0,0);
      
      //test the subtract functionality
      Assert.assertEquals(mathApplication.subtract(20.0, 10.0),0.0,0);
      
      //test the multiply functionality
      Assert.assertEquals(mathApplication.divide(20.0, 10.0),0.0,0);		
      
      //test the divide functionality
      Assert.assertEquals(mathApplication.multiply(20.0, 10.0),0.0,0);

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

步驟 4：執行測試用例

在 **C:\> EasyMock_WORKSPACE** 建立一個名為 TestRunner 的 Java 類檔案來執行測試用例。

檔案：TestRunner.java 

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()) {
         System.out.println(failure.toString());
      }
      System.out.println(result.wasSuccessful());
   }
}

步驟 5：驗證結果

使用javac編譯器編譯類，如下所示：

C:\EasyMock_WORKSPACE>javac MathApplicationTester.java

現在執行測試執行器以檢視結果：

C:\EasyMock_WORKSPACE>java TestRunner

輸出

驗證輸出。

true
列印頁面
上一頁
下一頁
廣告
© . All rights reserved.