Googletest Mock示例

wxmtwfx2026-05-23 10:06

Googletest Mock 示例：硬件适配层与应用层测试

1. 概述

本示例展示如何使用 Googletest 和 Googlemock 框架来测试一个包含硬件适配层（HAL）和应用层的系统。通过模拟（Mock）硬件适配层，我们可以在不依赖实际硬件的情况下测试应用层的逻辑。

在嵌入式系统开发中，硬件依赖是测试的主要障碍之一。传统的测试方法需要实际的硬件设备，这不仅增加了测试成本，还限制了测试的灵活性和速度。通过使用模拟技术，我们可以创建虚拟的硬件接口实现，从而在开发环境中进行全面的测试。

本文将详细介绍如何设计硬件适配层接口、实现应用层逻辑、创建 Mock 对象以及编写全面的测试用例，为嵌入式系统的测试提供全面的参考。

2. 系统架构

2.1 架构图

复制代码 
+-------------+      +-------------+      +-------------+
|  应用层     | <---> | 硬件适配层  | <---> | 实际硬件    |
+-------------+      +-------------+      +-------------+
        ^                      ^
        | 依赖                 | 抽象接口
        |                      |
+-------------+      +-------------+
|  测试用例   | <---> |  Mock对象   |
+-------------+      +-------------+

2.2 架构说明

  1. 应用层：负责业务逻辑，如光功率计算。
  2. 硬件适配层：提供抽象接口，隔离应用层与实际硬件。
  3. 实际硬件：物理设备，如ADC芯片。
  4. Mock对象：模拟硬件行为的虚拟实现，用于测试。
  5. 测试用例：验证应用层逻辑的正确性。

这种架构设计的核心优势在于：

  • 隔离性：应用层与硬件完全解耦
  • 可测试性：无需实际硬件即可进行测试
  • 可维护性：硬件变更时只需修改适配层
  • 灵活性：易于模拟各种硬件行为和异常情况

3. 核心概念

3.1 依赖注入模式

依赖注入是一种设计模式，它允许我们将对象的依赖关系从对象内部移到外部。在本示例中，应用层通过构造函数接收硬件适配层接口，而不是直接创建具体实现。

优点：

  • 提高代码的可测试性
  • 降低组件间的耦合度
  • 提高代码的可维护性
  • 便于替换实现

实现方式：

cpp 复制代码 
explicit Application(HardwareInterface* hardware);

3.2 模拟（Mock）技术原理

Mock 是一种特殊的测试替身，用于模拟真实对象的行为。在 Googlemock 中，我们可以：

  1. 定义期望：指定方法调用的参数和返回值
  2. 验证行为：确保预期的方法调用发生
  3. 模拟异常：测试错误处理逻辑

工作原理：

  • Mock 对象继承自被测接口
  • 使用宏定义模拟方法（如 MOCK_METHOD）
  • 通过 EXPECT_CALL 设置期望行为
  • 在测试结束时自动验证所有期望

3.3 测试金字塔模型

测试金字塔模型将测试分为三个层次：

  1. 单元测试（底层）：测试单个组件，如本示例中的应用层
  2. 集成测试（中层）：测试组件间的交互
  3. 端到端测试（顶层）：测试整个系统

比例建议：

  • 单元测试：70%
  • 集成测试：20%
  • 端到端测试：10%

本示例属于单元测试范畴，通过 Mock 硬件适配层来隔离测试应用层。

4. 代码实现

4.1 硬件适配层接口

首先定义硬件适配层的抽象接口，该接口提供读取ADC数值的方法：

cpp 复制代码 
// hardware_interface.h
#ifndef HARDWARE_INTERFACE_H
#define HARDWARE_INTERFACE_H

/**
 * @brief 硬件适配层抽象接口
 * 定义了与硬件交互的基本方法
 */
class HardwareInterface {
public:
    /**
     * @brief 虚析构函数，确保派生类正确析构
     */
    virtual ~HardwareInterface() = default;
    
    /**
     * @brief 读取ADC数值
     * @return ADC转换结果（0-1023）
     */
    virtual int readADC() = 0;
};

#endif // HARDWARE_INTERFACE_H

4.2 应用层实现

应用层依赖于硬件适配层的接口，用于计算光功率值。

应用层头文件 application.h：

cpp 复制代码 
// application.h
#ifndef APPLICATION_H
#define APPLICATION_H

#include "hardware_interface.h"

/**
 * @brief 应用层类，负责光功率计算
 */
class Application {
public:
    /**
     * @brief 构造函数
     * @param hardware 硬件适配层接口指针
     */
    explicit Application(HardwareInterface* hardware);
    
    /**
     * @brief 获取光功率值
     * 同时执行ADC读取和光功率计算
     * @return 光功率值（dBm），超出范围返回INVALID_POWER
     */
    double getOpticalPower();
    
    /**
     * @brief 无效光功率值
     * 当ADC值超出范围时返回
     */
    static constexpr double INVALID_POWER = -999.9;
    
private:
    /**
     * @brief 档位校准结构体
     * 保存AD值范围、斜率和截距
     */
    struct PowerCalibration {
        int adcStart;  // AD值起始
        int adcEnd;    // AD值结束
        double k;      // 斜率
        double b;      // 截距
    };
    
    HardwareInterface* hardware_;  // 硬件接口指针
    const PowerCalibration calibrations[2];  // 两档校准参数（const表）
};

#endif // APPLICATION_H

应用层实现文件 application.cpp：

cpp 复制代码 
// application.cpp
#include "application.h"
#include <iostream>

/**
 * @brief 构造函数实现
 * 初始化硬件接口和校准参数
 * @param hardware 硬件适配层接口指针
 */
Application::Application(HardwareInterface* hardware)
    : hardware_(hardware),
      calibrations{
          {0, 511, 8.0 / 511.0, -10.0},   // 第一档：AD 0-511，光功率 -10.0 到 -2.0 dBm
          {512, 1023, 12.0 / 511.0, -8.0}  // 第二档：AD 512-1023，光功率 -2.0 到 10.0 dBm
      } {
}

/**
 * @brief 获取光功率值
 * @return 光功率值（dBm）
 */
double Application::getOpticalPower() {
    // 读取ADC数值
    int adcValue = hardware_->readADC();
    std::cout << "ADC value: " << adcValue << std::endl;
    
    // 确定使用哪个档位
    const PowerCalibration* selectedCal = nullptr;
    for (int i = 0; i < 2; i++) {
        if (adcValue >= calibrations[i].adcStart && adcValue <= calibrations[i].adcEnd) {
            selectedCal = &calibrations[i];
            break;
        }
    }
    
    // 计算光功率值（kx + b）
    double opticalPower = Application::INVALID_POWER;
    if (selectedCal) {
        opticalPower = selectedCal->k * adcValue + selectedCal->b;
        std::cout << "Using calibration range " << selectedCal->adcStart << "-" << selectedCal->adcEnd
                  << ", k=" << selectedCal->k << ", b=" << selectedCal->b << std::endl;
    } else {
        // AD值超出范围，返回无效值
        std::cout << "ADC value out of range!" << std::endl;
    }

    std::cout << "Optical power: " << opticalPower << " dBm" << std::endl;
    return opticalPower;
}

4.3 Mock 硬件适配层

使用 Googlemock 创建硬件适配层的模拟实现：

cpp 复制代码 
// mock_hardware.h
#ifndef MOCK_HARDWARE_H
#define MOCK_HARDWARE_H

#include "hardware_interface.h"
#include <gmock/gmock.h>

/**
 * @brief Mock硬件适配层
 * 用于测试时模拟硬件行为
 */
class MockHardware : public HardwareInterface {
public:
    /**
     * @brief 模拟readADC方法
     * 使用GMOCK宏定义模拟方法
     */
    MOCK_METHOD(int, readADC, (), (override));
};

#endif // MOCK_HARDWARE_H

4.4 测试用例设计

编写测试用例来验证应用层的逻辑，包括正常情况、边界情况和异常情况：

cpp 复制代码 
// application_test.cpp
#include "application.h"
#include "mock_hardware.h"
#include <gtest/gtest.h>
#include <gmock/gmock.h>
#include <memory>

using ::testing::Return;
using ::testing::StrictMock;

/**
 * @brief 应用层测试类
 * 继承自gtest的Test类
 */
class ApplicationTest : public ::testing::Test {
protected:
    /**
     * @brief 测试前初始化
     * 创建Mock硬件和应用实例
     */
    void SetUp() override {
        mockHardware = std::make_unique<StrictMock<MockHardware>>();
        application = std::make_unique<Application>(mockHardware.get());
    }

    std::unique_ptr<StrictMock<MockHardware>> mockHardware;  // Mock硬件实例
    std::unique_ptr<Application> application;  // 应用实例
};

/**
 * @brief 测试第一档（AD 0-511）的光功率计算
 */
TEST_F(ApplicationTest, ShouldCalculateFirstRangeOpticalPower) {
    // 期望行为：返回ADC值255
    EXPECT_CALL(*mockHardware, readADC()).WillOnce(Return(255));
    
    // 执行并验证（光功率 = (8.0/511.0)*255 + (-10.0) ≈ -6.0 dBm）
    double expectedPower = (8.0 / 511.0) * 255 + (-10.0);
    EXPECT_DOUBLE_EQ(application->getOpticalPower(), expectedPower);
}

/**
 * @brief 测试第二档（AD 512-1023）的光功率计算
 */
TEST_F(ApplicationTest, ShouldCalculateSecondRangeOpticalPower) {
    // 期望行为：返回ADC值768
    EXPECT_CALL(*mockHardware, readADC()).WillOnce(Return(768));
    
    // 执行并验证（光功率 = (12.0/511.0)*768 + (-8.0) ≈ 10.0 dBm）
    double expectedPower = (12.0 / 511.0) * 768 + (-8.0);
    EXPECT_DOUBLE_EQ(application->getOpticalPower(), expectedPower);
}

/**
 * @brief 测试第一档边界值（AD 511）
 */
TEST_F(ApplicationTest, ShouldCalculateFirstRangeBoundary) {
    // 期望行为：返回ADC值511
    EXPECT_CALL(*mockHardware, readADC()).WillOnce(Return(511));
    
    // 执行并验证（光功率 = (8.0/511.0)*511 + (-10.0) = -2.0 dBm）
    double expectedPower = (8.0 / 511.0) * 511 + (-10.0);
    EXPECT_DOUBLE_EQ(application->getOpticalPower(), expectedPower);
}

/**
 * @brief 测试第二档边界值（AD 512）
 */
TEST_F(ApplicationTest, ShouldCalculateSecondRangeBoundary) {
    // 期望行为：返回ADC值512
    EXPECT_CALL(*mockHardware, readADC()).WillOnce(Return(512));
    
    // 执行并验证（光功率 = (12.0/511.0)*512 + (-8.0) ≈ -2.0 dBm）
    double expectedPower = (12.0 / 511.0) * 512 + (-8.0);
    EXPECT_DOUBLE_EQ(application->getOpticalPower(), expectedPower);
}

/**
 * @brief 测试超出范围值（AD < 0）
 */
TEST_F(ApplicationTest, ShouldReturnInvalidPowerForNegativeAD) {
    // 期望行为：返回ADC值-1
    EXPECT_CALL(*mockHardware, readADC()).WillOnce(Return(-1));
    
    // 执行并验证（返回无效值）
    EXPECT_DOUBLE_EQ(application->getOpticalPower(), Application::INVALID_POWER);
}

/**
 * @brief 测试超出范围值（AD > 1023）
 */
TEST_F(ApplicationTest, ShouldReturnInvalidPowerForADAboveRange) {
    // 期望行为：返回ADC值1024
    EXPECT_CALL(*mockHardware, readADC()).WillOnce(Return(1024));
    
    // 执行并验证（返回无效值）
    EXPECT_DOUBLE_EQ(application->getOpticalPower(), Application::INVALID_POWER);
}

5. 错误案例分析

5.1 常见错误场景

  1. 接口设计不当

    • 问题：接口过于复杂，难以Mock
    • 影响：测试代码复杂，维护困难

  2. Mock使用错误

    • 问题：未正确设置期望，导致测试失败
    • 影响：测试结果不可靠，可能漏测

  3. 依赖管理问题

    • 问题：应用层直接依赖具体实现，而非接口
    • 影响：无法使用Mock，测试需要实际硬件

  4. 边界条件处理

    • 问题：未处理ADC值超出范围的情况
    • 影响：可能导致计算错误或系统崩溃

5.2 解决方案

  1. 接口设计优化

    • 建议：遵循单一职责原则，接口简洁明了
    • 示例：每个接口只负责一个功能

  2. Mock使用最佳实践

    • 建议：使用StrictMock，确保所有期望都被调用
    • 示例：EXPECT_CALL(*mock, method()).WillOnce(Return(value));

  3. 依赖注入实现

    • 建议：通过构造函数或 setter 注入依赖
    • 示例：explicit Application(HardwareInterface* hardware);

  4. 边界条件处理

    • 建议：使用常量定义无效值，明确处理边界情况
    • 示例：static constexpr double INVALID_POWER = -999.9;

6. 扩展与最佳实践

6.1 接口设计最佳实践

  1. 接口简洁：每个接口只负责一个功能
  2. 抽象层次：根据功能划分合理的抽象层次
  3. 版本管理：使用版本号管理接口变更
  4. 错误处理：在接口中定义错误处理机制

6.2 Mock 使用技巧

  1. 使用StrictMock：确保所有期望都被调用
  2. 序列设置：使用InSequence确保方法调用顺序
  3. 参数匹配：使用匹配器（如_、Eq()、Ge()等）匹配参数
  4. 返回值设置：使用WillRepeatedly为重复调用设置返回值

6.3 测试覆盖率优化

  1. 边界测试：测试所有边界条件
  2. 异常测试：测试错误处理逻辑
  3. 分支测试：确保所有代码分支都被测试
  4. 集成测试：测试组件间的交互

7. 总结

通过使用 Googletest 和 Googlemock，我们可以：

  1. 隔离测试：不依赖实际硬件即可测试应用层逻辑
  2. 可控测试：精确控制硬件行为，测试各种场景
  3. 快速测试：测试执行速度快，适合持续集成
  4. 提高质量：通过全面的测试覆盖，提高代码质量和可靠性

这种测试方法特别适合嵌入式系统开发，其中硬件依赖可能会限制测试的灵活性和速度。通过合理的架构设计和测试策略，我们可以在开发早期发现并解决问题，从而提高产品质量和开发效率。

相关推荐
ch3nyuyu4 小时前
网络编程拟面试题
linux·网络
无限进步_4 小时前
【Linux】Makefile：让编译自动化
linux·运维·自动化
猫头虎4 小时前
【Trea】Trea国内版｜国际版｜海外版下载｜Mac版｜Windows版|Linux下载配置教程
linux·人工智能·windows·macos·aigc·ai编程·agi
流浪0014 小时前
告别静态打印：Linux C 实现实时刷新进度条
linux·运维·c语言
小此方4 小时前
Re：Linux系统篇（二十）进程篇·五：深入理解 Linux 进程优先级：从底层逻辑到实战修改
linux·运维·服务器
路溪非溪4 小时前
Linux下物理总线驱动模型之SDIO驱动框架
linux·驱动开发
深圳市九鼎创展科技4 小时前
九鼎创展 X7110 开发板（JH7110）：国产 RISC-V 多媒体平台全解析
大数据·linux·人工智能·嵌入式硬件·ubuntu·risc-v
流浪0014 小时前
Linux篇（八） Make 与 Makefile 超详细入门教程｜从零基础到手写自动化编译
linux·运维·自动化
爱莉希雅&&&4 小时前
Redis哨兵模式和主从复制和集群模式搭建与扩容缩容
linux·redis·缓存·集群·哨兵·数据库同步
热门推荐
01GitHub 镜像站点02Codex 接入 DeepSeek API 完整配置文档03【踩坑记录 | 第一篇】微软商店无法使用时，如何手动安装 OpenAI Codex？附`.msix`文件系统错误解决方法04装上就回不去了：CodeGraph 让 AI 编程效率飙升 92%，它到底做了什么？05裂开！ChatGPT 居然开始要手机号验证，附详细解决方法06CC-Switch & Claude 基于 Linux 服务器安装使用指南07【AI】2026 年具身智能模型和世界模型总结08几个好用的ip纯净度检测网站09用了半年 OpenRouter，我换到了 Ofox.ai — 两个 AI API 聚合平台的真实对比10codex app每次打开重连5次Reconnecting问题解决