HTML CSS JAVASCRIPT JQUERY AI PHP SQL EXCEL LINUX C# C++ C PYTHON JAVA 教程库 参考手册 技术文章 测验 练习 HOWTO FAQ
❮ EasyMock createNiceMock EasyMock 有用的资源 ❯

EasyMock - 快速指南

EasyMock - 概述

什么是 Mocking?

Mocking 是一种单独测试类功能的方法。模拟不需要数据库连接或属性文件读取或文件服务器读取来测试功能。Mocking 模拟对象模拟实际服务。Mocking 模拟对象返回与传递给它的某些虚拟输入相对应的虚拟数据。

EasyMock

EasyMock 有助于无缝创建Mocking 模拟对象。它使用 Java 反射来为给定接口创建Mocking 模拟对象。Mocking 模拟对象只是实际实现的代理。考虑一个股票服务案例，它返回股票的价格详情。在开发过程中，实际的股票服务不能用于获取实时数据。所以我们需要股票服务的虚拟实现。 EasyMock 可以非常轻松地完成相同的操作，正如其名称所示。

EasyMock 的优势

  • 无需手写 − 无需自行编写Mocking 模拟对象。

  • 重构安全 − 重命名接口方法名称或重新排序参数不会破坏测试代码，因为模拟是在运行时创建的。

  • 返回值支持 − 支持返回值。

  • 异常支持 − 支持异常。

  • 顺序检查支持 − 支持检查方法调用的顺序。

  • 注释支持 − 支持使用注释创建模拟。

示例

请考虑以下代码片段。

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){
        //创建要测试的投资组合对象
        Portfolio portfolio = new 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);
        
        //创建股票服务的Mocking 模拟对象
        StockService stockServiceMock = EasyMock.createMock(StockService.class);
        
        // 模拟股票服务的行为以返回各种股票的价值
        EasyMock.expect(stockServiceMock.getPrice(googleStock)).andReturn(50.00);
        EasyMock.expect(stockServiceMock.getPrice(microsoftStock)).andReturn(1000.00);
        EasyMock.replay(stockServiceMock);
        
        //将股票添加到投资组合
        portfolio.setStocks(stocks);
        
        //将 stockService 设置为投资组合
        portfolio.setStockService(stockServiceMock);
        double marketValue = portfolio.getMarketValue();
        
        //验证市场价值为
        //10*50.00 + 100* 1000.00 = 500.00 + 100000.00 = 100500
        System.out.println("投资组合的市场价值:"+ marketValue);
    }
}

让我们了解上述程序的重要概念。完整代码可在第一个应用程序章中找到。

  • Portfolio − 一个对象，用于携带股票列表并获取使用股票价格和股票数量计算出的市场价值。

  • Stock − 一个对象，用于携带股票的详细信息，例如其 ID、名称、数量等。

  • StockService −股票服务返回股票的当前价格。

  • EasyMock.createMock(...) − EasyMock 创建了股票服务的模拟。

  • EasyMock.expect(...).andReturn(...) − stockService 接口的 getPrice 方法的模拟实现。对于 googleStock，返回 50.00 作为价格。

  • EasyMock.replay(...) − EasyMock 准备 Mock 对象，以便可以用于测试。

  • portfolio.setStocks(...) − 投资组合现在包含两只股票的列表。

  • portfolio.setStockService(...) −将 stockService Mock 对象分配给投资组合。

  • 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 的基本目录位置。例如，

Sr.No. 平台和描述
1

Windows

将 JAVA_HOME 设置为 C:\ProgramFiles\java\jdk11.0.11
2

Linux

导出 JAVA_HOME = /usr/local/java-current

将 Java 编译器位置的完整路径附加到系统路径。

Sr.No. 平台 &描述
1

Windows

将字符串"C:\Program Files\Java\jdk11.0.11\bin"附加到系统变量 PATH 的末尾。
2

Linux

导出 PATH = $PATH:$JAVA_HOME/bin/

按照上述说明从命令提示符执行命令 java -version。

步骤 3:安装 EasyMock 库

从 https://easymock.org/ 并将其内容解压到一个文件夹中，从该文件夹中可以将所需的库链接到您的 Java 程序。我们假设文件收集在 C 盘上的一个文件夹中。

将所需 jars 的完整路径添加到 CLASSPATH，如下所示。

Sr.No. 平台和说明
1

Windows

将以下字符串附加到用户变量的末尾

CLASSPATH −

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

Linux

导出 CLASSPATH = $CLASSPATH:

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

步骤 4:下载 JUnit 存档

从 Github 下载最新版本的 JUnit jar 文件。将文件夹保存在 C:\>Junit 位置。

OS 存档名称
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。

OS Output
Windows 将环境变量 JUNIT_HOME 设置为 C:\JUNIT
Linux export JUNIT_HOME=/usr/local/JUNIT

步骤 6:设置 CLASSPATH 变量

将 CLASSPATH 环境变量设置为指向 JUNIT jar 位置。下表显示了如何在不同的操作系统上执行此操作。

OS 输出
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 框架的细节之前，让我们先看一个实际的应用程序。在这个例子中，我们创建了一个 Stock Service 模拟来获取一些股票的虚拟价格，并对名为 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 类

让我们通过向 Portfolio 类中注入 stockservice 的模拟来测试该类。模拟将由 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(){
    //创建要测试的投资组合对象
    portfolio = new Portfolio();
    
    //创建股票服务的模拟对象
    stockService = EasyMock.createMock(StockService.class);
    
    //将 stockService 设置为投资组合
    portfolio.setStockService(stockService);
   }
   public boolean testMarketValue(){
    //创建要添加到投资组合的股票列表
    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);
    
    //将股票添加到投资组合
    portfolio.setStocks(stocks);
    
    // 模拟股票服务的行为以返回各种股票的价值
    EasyMock.expect(stockService.getPrice(googleStock)).andReturn(50.00);
    EasyMock.expect(stockService.getPrice(microsoftStock)).andReturn(1000.00);
    
    // 激活模拟
    EasyMock.replay(stockService);
    
    double marketValue = portfolio.getMarketValue();
    r​​eturn 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 类

让我们通过向 MathApplication 类中注入 calculatorService 的模拟来测试它。模拟将由 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 将运行器与测试类关联以初始化测试数据
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
    // @TestSubject 注释用于标识将使用模拟对象的类
    @TestSubject
    MathApplication mathApplication = new MathApplication();
    
    //@Mock 注释用于创建要注入的模拟对象
    @Mock
    CalculatorService calcService;
    
    @Test
    public void testAdd(){
        //添加计算服务的行为以添加两个数字
        EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);
        
        //激活模拟
        EasyMock.replay(calcService);
        
        //测试添加功能
        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

现在运行 Test Runner 以查看结果 −

C:\EasyMock_WORKSPACE>java TestRunner

输出

验证输出。

true

要了解有关 JUnit 的更多信息，请参阅 Tutorials Point 上的 JUnit 教程。

EasyMock - 添加行为

EasyMock 使用方法 expect() 和 expectLassCall() 向模拟对象添加功能。查看以下代码片段。

//添加 calc 服务的行为以添加两个数字
EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);

在这里，我们指示 EasyMock 为 calcService 的 add 方法提供将 10 和 20 相加的行为，并因此返回 30.00 的值。

此时，Mock 只是记录了行为，但它不能作为模拟对象工作。调用 replay 后，它按预期工作。

//添加 calc 服务的行为以添加两个数字
EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);

//激活模拟
//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);
}

Step 2: Create a JAVA class to represent MathApplication

File: 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 类

让我们通过向 MathApplication 类中注入 calculatorService 的模拟来测试它。模拟将由 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 将运行器与测试类关联以初始化测试数据
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
    // @TestSubject 注释用于标识将要使用模拟对象的类
    @TestSubject
    MathApplication mathApplication = new MathApplication();
    
    //@Mock 注释用于创建要注入的模拟对象
    @Mock
    CalculatorService calcService;
    
    @Test
    public void testAdd(){
        //添加计算服务的行为以添加两个数字
        EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);
        
        //激活模拟
        //EasyMock.replay(calcService);
        
        //测试添加功能
        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

现在运行 Test Runner 以查看结果 −

C:\EasyMock_WORKSPACE>java TestRunner

输出

验证输出。

testAdd(MathApplicationTester): 预期结果为:<0.0> 但实际结果为:<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 将运行器与测试类关联，以初始化测试数据
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
    // @TestSubject 注释用于标识将使用模拟对象的类
    @TestSubject
    MathApplication mathApplication = new MathApplication();
    
    // @Mock 注释用于创建要注入的模拟对象
    @Mock
    CalculatorService calcService;
    
    @Test
    public void testAdd(){
        // 添加计算服务的行为以添加两个数字
        EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);
        
        //激活模拟
        EasyMock.replay(calcService);
        
        // 测试添加功能
        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

现在运行 Test Runner 以查看结果。

C:\EasyMock_WORKSPACE>java TestRunner

输出

验证输出。

true

EasyMock - 验证行为

EasyMock 可以确保是否正在使用模拟。这是使用 verify() 方法完成的。请查看以下代码片段。

//激活模拟
EasyMock.replay(calcService);

//测试添加功能
Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);

//验证是否调用了 calcService
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 将运行器与测试类关联起来，以初始化测试数据
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
    // @TestSubject 注释用于标识将使用模拟对象的类
    @TestSubject
    MathApplication mathApplication = new MathApplication();
    
    //@Mock 注释用于创建要注入的模拟对象
    @Mock
    CalculatorService calcService;
    
    @Test
    public void testAdd(){
        //添加计算服务的行为以添加两个数字
        EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);
        
        //激活模拟
        EasyMock.replay(calcService);
        
        //测试添加功能
        Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);
        
        //验证是否调用了 calcService
        //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

现在运行 Test Runner 以查看结果。

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 将运行器与测试类关联起来，以初始化测试数据
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
    // @TestSubject 注释用于标识将使用模拟对象的类
    @TestSubject
    MathApplication mathApplication = new MathApplication();
    
    //@Mock 注释用于创建要注入的模拟对象
    @Mock
    CalculatorService calcService;
    
    @Test
    public void testAdd(){
    //添加 calc 服务的行为以添加两个数字
    EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);
    
    //激活模拟
    EasyMock.replay(calcService);
    
    //测试添加功能
    Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);
    
    //验证是否调用了 calcService
    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

现在运行 Test Runner 以查看结果 −

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()。

//添加 calc 服务的行为以将两个数字和 serviceUsed 相加。
EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);
calcService.serviceUsed();

//将方法调用限制为 1，不允许调用更少或更多
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 类

让我们通过向 MathApplication 类中注入 calculatorService 的模拟来测试它。模拟将由 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 将运行器与测试类关联以初始化测试数据
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
    // @TestSubject 注释用于标识将使用模拟对象的类
    @TestSubject
    MathApplication mathApplication = new MathApplication();
    
    // @Mock 注释用于创建要注入的模拟对象
    @Mock
    CalculatorService calcService;
    
    @Test
    public void testAdd(){
        //添加计算服务的行为以添加两个数字
        EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);
        calcService.serviceUsed();
        EasyMock.expectLastCall().times(1);
        
        //激活模拟
        EasyMock.replay(calcService);
        
        //测试添加功能
        Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);
        
        //验证是否调用了 calcService
        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

现在运行 Test Runner 以查看结果 −

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 类

让我们通过向 MathApplication 类中注入 calculatorService 的模拟来测试它。模拟将由 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 将运行器与测试类关联以初始化测试数据
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
    // @TestSubject 注释用于标识将使用模拟对象的类
    @TestSubject
    MathApplication mathApplication = new MathApplication();
    
    //@Mock 注释用于创建要注入的模拟对象
    @Mock
    CalculatorService calcService;
    
    @Test
    public void testAdd(){
        //添加计算服务的行为以添加两个数字
        EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);
        calcService.serviceUsed();
        EasyMock.expectLastCall().times(1);
        
        //激活模拟
        EasyMock.replay(calcService);
        
        //测试添加功能
        Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);
        
        //验证是否调用了 calcService
        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

现在运行 Test Runner 以查看结果 −

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:创建一个接口计算器服务以提供数学函数

文件: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 将运行器与测试类关联，以初始化测试数据
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
    // @TestSubject 注释用于标识将使用模拟对象的类
    @TestSubject
    MathApplication mathApplication = new MathApplication();
    
    //@Mock 注释用于创建要注入的模拟对象
    @Mock
    CalculatorService calcService;
    
    @Test
    public void testAdd(){
        //添加计算服务的行为以将两个数字相加
        EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);
        calcService.serviceUsed();
        EasyMock.expectLastCall().times(1);
        
        //激活模拟
        EasyMock.replay(calcService);
        
        //测试添加功能
        Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);
        
        //验证是否调用了 calcService
        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

现在运行 Test Runner 以查看结果 −

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) − 期望最小和最大调用次数之间。

  • atLeastOnce () − 期望至少有一次调用。

  • anyTimes () −期望调用次数不受限制。

带有时间的示例(最小值、最大值)

步骤 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 类

让我们通过向 MathApplication 类中注入 calculatorService 的模拟来测试它。模拟将由 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 将运行器与测试类关联以初始化测试数据
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
    // @TestSubject 注释用于标识将使用模拟对象的类
    @TestSubject
    MathApplication mathApplication = new MathApplication();
    
    //@Mock 注释用于创建要注入的模拟对象
    @Mock
    CalculatorService calcService;
    
    @Test
    public void testAdd(){
        //添加计算服务的行为以添加两个数字
        EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);
        calcService.serviceUsed();
        EasyMock.expectLastCall().times(1,3);
        
        //激活模拟
        EasyMock.replay(calcService);
        
        //测试添加功能
        Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);
        
        //验证是否调用了 calcService
        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

现在运行 Test Runner 以查看结果 −

C:\EasyMock_WORKSPACE>java TestRunner

输出

验证输出。

true

具有 atLeastOnce 的示例

步骤 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 将运行器与测试类关联以初始化测试数据
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
    // @TestSubject 注释用于标识将使用模拟对象的类
    @TestSubject
    MathApplication mathApplication = new MathApplication();
    
    //@Mock 注释用于创建要注入的模拟对象
    @Mock
    CalculatorService calcService;
    
    @Test
    public void testAdd(){
        //添加计算服务的行为以添加两个数字
        EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);
        calcService.serviceUsed();
        EasyMock.expectLastCall().atLeastOnce();
        
        //激活模拟
        EasyMock.replay(calcService);
        
        //测试添加功能
        Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);
        
        //验证是否调用了 calcService
        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

现在运行 Test Runner 以查看结果 −

C:\EasyMock_WORKSPACE>java TestRunner

输出

验证输出。

true

带有 anyTimes 的示例

步骤 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 类

让我们通过向 MathApplication 类中注入 calculatorService 的模拟来测试它。模拟将由 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 将运行器与测试类关联以初始化测试数据
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
    // @TestSubject 注释用于标识将使用模拟对象的类
    @TestSubject
    MathApplication mathApplication = new MathApplication();
    
    //@Mock 注释用于创建要注入的模拟对象
    @Mock
    CalculatorService calcService;
    
    @Test
    public void testAdd(){
        //添加计算服务的行为以添加两个数字
        EasyMock.expect(calcService.add(10.0,20.0)).andReturn(30.00);
        calcService.serviceUsed();
        EasyMock.expectLastCall().anyTimes();
        
        //激活模拟
        EasyMock.replay(calcService);
        
        //测试添加功能
        Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);
        
        //验证是否调用了 calcService
        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

现在运行 Test Runner 以查看结果 −

C:\EasyMock_WORKSPACE>java TestRunner

输出

验证输出。

true

EasyMock - 异常处理

EasyMock 为模拟提供了抛出异常的能力，因此可以测试异常处理。请查看以下代码片段。

//添加抛出异常的行为

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

这里我们向模拟对象添加了一个异常子句。 MathApplication 使用 calcService 的 add 方法，并且每当调用 calcService.add() 方法时，模拟都会抛出 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 将运行器与测试类关联起来，以初始化测试数据
@RunWith(EasyMockRunner.class)
public class MathApplicationTester {
    // @TestSubject 注释用于标识将使用模拟对象的类
    @TestSubject
    MathApplication mathApplication = new MathApplication();
    
    //@Mock 注释用于创建要注入的模拟对象
    @Mock
    CalculatorService calcService;
    
    @Test(expected = RuntimeException.class)
    public void testAdd(){
        //添加抛出异常的行为
        EasyMock.expect(calcService.add(10.0,20.0)).andThrow(
        new RuntimeException("Add operation not implement")
        );
        //激活模拟
        EasyMock.replay(calcService);
        
        //测试添加功能
        Assert.assertEquals(mathApplication.add(10.0, 20.0),30.0,0);
        
        //验证是否调用了 calcService
        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

现在运行 Test Runner 以查看结果 −

C:\EasyMock_WORKSPACE>java TestRunner

输出

验证输出。

true

EasyMock - createMock

到目前为止，我们已经使用注释来创建模拟。EasyMock 提供了各种方法来创建模拟对象。EasyMock.createMock() 创建模拟时无需考虑模拟在其操作过程中将要进行的方法调用顺序。

语法

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 类

让我们通过向 MathApplication 类中注入 calculatorService 的模拟来测试它。模拟将由 EasyMock 创建。

在这里，我们通过 expect() 向模拟对象添加了两个模拟方法调用，add() 和 subtract()。但是在测试期间，我们在调用 add() 之前调用了 subtract()。当我们使用 EasyMock.createMock() 创建模拟对象时，方法的执行顺序无关紧要。

文件: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(){
    //添加行为以添加数字
    EasyMock.expect(calcService.add(20.0,10.0)).andReturn(30.0);
    
    //减去行为以减去数字
    EasyMock.expect(calcService.subtract(20.0,10.0)).andReturn(10.0);
    
    //激活模拟
    EasyMock.replay(calcService);
    
    //测试减法功能
    Assert.assertEquals(mathApplication.subtract(20.0, 10.0),10.0,0);
    
    //测试添加功能
    Assert.assertEquals(mathApplication.add(20.0, 10.0),30.0,0);
    
    //验证是否调用了 calcService
    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

现在运行 Test Runner 以查看结果 −

C:\EasyMock_WORKSPACE>java TestRunner

输出

验证输出。

true

EasyMock - createStrictMock

EasyMock.createStrictMock() 创建一个模拟，并负责模拟在其操作过程中进行的方法调用的顺序。

语法

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 类

让我们通过向 MathApplication 类中注入 calculatorService 的模拟来测试它。模拟将由 EasyMock 创建。

在这里，我们通过 expect() 向模拟对象添加了两个模拟方法调用，add() 和 subtract()。但是在测试期间，我们在调用 add() 之前调用了 subtract()。当我们使用 EasyMock.createStrictMock() 创建模拟对象时，方法的执行顺序很重要。

文件: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(){
    //添加行为以添加数字
    EasyMock.expect(calcService.add(20.0,10.0)).andReturn(30.0);
    
    //减去行为以减去数字
    EasyMock.expect(calcService.subtract(20.0,10.0)).andReturn(10.0);
    
    //激活模拟
    EasyMock.replay(calcService);
    
    //测试减法功能
    Assert.assertEquals(mathApplication.subtract(20.0, 10.0),10.0,0);
    
    //测试添加功能
    Assert.assertEquals(mathApplication.add(20.0, 10.0),30.0,0);
    
    //验证是否调用了 calcService
    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;

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

现在运行 Test Runner 以查看结果 −

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() 创建一个模拟并设置模拟的每个方法的默认实现。如果使用 EasyMock.createMock()，则调用模拟方法会引发断言错误。

语法

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 类

让我们通过向 MathApplication 类中注入 calculatorService 的模拟来测试它。模拟将由 EasyMock 创建。

在这里，我们通过 expect() 添加了一个模拟方法调用 add()。但是在测试期间，我们还调用了 subtract() 和其他方法。当我们使用 EasyMock.createNiceMock() 创建模拟对象时，可以使用具有默认值的默认实现。

文件: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(){
//添加添加数字的行为
EasyMock.expect(calcService.add(20.0,10.0)).andReturn(30.0);

//激活模拟
EasyMock.replay(calcService);

//测试添加功能
Assert.assertEquals(mathApplication.add(20.0, 10.0),30.0,0);

//测试减法功能
Assert.assertEquals(mathApplication.subtract(20.0, 10.0),0.0,0);

//测试乘法功能
Assert.assertEquals(mathApplication.divide(20.0, 10.0),0.0,0);

//测试除法功能
Assert.assertEquals(mathApplication.multiply(20.0, 10.0),0.0,0);

//验证是否调用了 calcService
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

现在运行 Test Runner 以查看结果 −

C:\EasyMock_WORKSPACE>java TestRunner

输出

验证输出。

true
❮ EasyMock createNiceMock EasyMock 有用的资源 ❯