由于工作原因，之前在CI这一块一直是依照公司流程走的，LLT这一块都是照猫画虎，对于整体框架自己没有一个完整的概念，最近有时间，研究了一下整体的逻辑框架，在此记录一下。

关于gtest，gmock和mockcpp，这里不再细讲，知道gtest，gmock是google的一套用于C/C++ LLT的框架即可，要用到mockcpp是因为gmock其实只能用于对对象函数的mocker，不能对C代码中的一般函数进行mcoker，这个在后面的代码中可以看出来。

一、准备工作

1. googletest、googlemock

下载： https://github.com/google/googletest

2. mockcpp

https://code.google.com/archive/p/mockcpp/downloads

3. 编译mockcpp

最新的2.6版本的mockcpp只需要解压然后进入根目录，然后：

cmake .  //生成Makefile

make install

这里需要把libmockcpp.a保存下来，后面会用到；

/usr/local/include/文件夹下面的所有文件也需要保存下来；

4. 编译googletest

直接在下载地根目录进行

cmke .

即可得到gmock， gtest编译结果和静态库：

保存libgtest.a和libgmock.a后面用于静态链接；

二、建立测试工程

1. 创建GtestLearn工程，这里是我们需要测试的代码，目录结构如下：

mian.c

 1 #include <stdio.h>
 2 #include "func.h"
 4 int main(int argc, char **argv) {
 5     int ret = 0;
 6     struct test_t test;
 8     ret = add(1, 2);
 9     printf("Get add result: %d\n", ret);
11     test.a = 10;
12     test.b = 12;
13     ret = add_struct(&test);
14     printf("Get add struct result: %d\n", ret);
16     test.p_func = NULL;
17     ret = test_struct_func(&test);
18     printf("Get test struct result: %d\n", ret);
20     ret = test_stub_func();
21     printf("Get test stub func result: %d\n", ret);
23     return 0;
func.h
#ifndef GTESTLEARN_FUNC_H
#define GTESTLEARN_FUNC_H
struct test_t {
    int a;
    int b;
    int (*p_func)(struct test_t *test);
int add(int a, int b);
int multi(int a, int b);
int add_struct(struct test_t *test);
int test_struct_func(struct test_t *test);
int test_stub_func();
#endif //GTESTLEARN_FUNC_H
func.c
#include <stdio.h>
#include "ex_func.h"
#include "func.h"
int add(int a, int b)
    printf("start to compute the sum of a %d and b %d\n", a, b);
    return a + b;
int multi(int a, int b)
    printf("start to compute the multi of a %d and b %d\n", a, b);
    return a * b;
int add_struct(struct test_t *test)
    int sum;
    int multi_v;
    printf("start to compute the sum of a %d and b %d\n", test->a, test->b);
    sum = test->a + test->b;
    multi_v = multi(test->a, test->b);
    if (sum > multi_v) {
        return sum;
    return multi_v;
int test_struct_func(struct test_t *test)
    if (test->p_func == NULL) {
        printf("get null func pointer\n");
        return 0xFFFF;
    printf("start ro run test_struct_func with a %d b %d\n", test->a, test->b);
    return test->p_func(test);
int test_stub_func()
    int ret;
    int a = 0;
    ret = ex_get_value(&a);
    if (ret == 0xFFFF) {
        printf("get extern value failed, ret %d\n", ret);
        return ret;
    printf("get extern value succeed, ex value %d\n", a);
    return ret;
ex_func.h
#ifndef GTESTLEARN_EX_FUNC_H
#define GTESTLEARN_EX_FUNC_H
int ex_get_value(int *a);
#endif //GTESTLEARN_EX_FUNC_H
ex_func.c
#include "ex_func.h"
int ex_get_value(int *a)
    *a = 101010;
    return 0;
CMakeLists.txt
cmake_minimum_required(VERSION 3.15)
project(GtestLearn C)

set(CMAKE_C_STANDARD 99)
set(CMAKE_C_FLAGS "${CAMKE_C_FLAGS} -fprofile-arcs -ftest-coverage")
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include/)
set(SOURCE_FILES
    main.c
    include/func.h
    func.c
    include/ex_func.h
    include/ex_func.c)

add_executable(GtestLearn ${SOURCE_FILES})
target_link_libraries(GtestLearn ${LIBRARIES})
这里保证通过
cmake .
然后执行，预期正确。
2. 创建测试工程GtestLearnLLT
独立一个工程是因为在正式开发环境中，做LLT的代码往往是与业务代码分离的，更好的模拟真实使用环境。
目录结构：
这里将googlemock，googletest和mockcpp放在third_party文件夹，都是由之前下载的源码解压而来，其中：
mockcpp只需要保留3rdparty文件夹，include文件用之前编译的头文件代替（准备工作第3步）；lib目录里为之前编译产生的静态库；
stubs文件夹保存的是桩函数；
googlemock和googletest新建lib目录，存放之前编译的静态库；
main.cpp
#include <stdio.h>
#include "gtest/gtest.h"
GTEST_API_ int main(int argc, char **argv) {
    printf("Running main() from gtest_main.cc\n");
    testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
gtest_ut.cpp
extern "C" {
#include <stdio.h>
#include <stdlib.h>
#include "func.h"
#include <limits.h>
#include <mockcpp/mockcpp.hpp>
#include "gmock/gmock.h"
#include "gtest/gtest.h"
// using namespace std;
using namespace testing;
class GtestUt : public testing::Test
protected:
    void SetUp() override
        std::cout << "--Gtest_Ut SetUP--" << std::endl;
    void TearDown() override
        std::cout << "--Gtest_Ut TearDown--" << std::endl;
class Mock_FOO {
public:
    MOCK_METHOD1(mock_test_struct_func, int(struct test_t *test));
Mock_FOO mocker;
int mock_test_struct_func(struct test_t *test)
    return mocker.mock_test_struct_func(test);
TEST_F(GtestUt, ut_add_01)
    int ret;
    ret = add(1, 2);
    EXPECT_EQ(3, ret);
TEST_F(GtestUt, ut_add_02)
    int ret;
    struct test_t test;
    test.a = 1;
    test.b = 1;
    MOCKER(multi)
    .expects(atMost(20))
    .will(returnValue(100));
    ret = add_struct(&test);
    EXPECT_EQ(ret, 100);
    GlobalMockObject::verify();
TEST_F(GtestUt, ut_add_03)
    int ret;
    struct test_t test;
    test.a = 10;
    test.b = 11;
    MOCKER(multi)
    .expects(atMost(20))
    .will(returnValue(20));
    ret = add_struct(&test);
    EXPECT_EQ(ret, 21);
    GlobalMockObject::verify();
TEST_F(GtestUt, ut_add_04)
    int ret;
    int a, b;
    struct test_t test;
    test.a = 10;
    test.b = 11;
    test.p_func = mock_test_struct_func;
    EXPECT_CALL(mocker, mock_test_struct_func(&test)).WillRepeatedly(Return(10));
    ret = test_struct_func(&test);
    EXPECT_EQ(ret, 10);
    GlobalMockObject::verify();
TEST_F(GtestUt, ut_add_05)
    int ret;
    int ex_value;
    ret = test_stub_func();
    EXPECT_EQ(ret, 1011);
my_stubs.c
#include <stdio.h>
#include "ex_func.h"
int ex_get_value(int *a)
    if (a == NULL) {
        printf("get null pointer %p\n", a);
        return 0xFFFF;
    *a = 1011;
    printf("run stub func, get value %d\n", *a);
    return *a;
CMakeLists.txt
cmake_minimum_required(VERSION 3.15)
project(GtestLearnLLT)

set(CMAKE_CXX_STANDARD 14)
set(CMAKE_CXX_FLAGS "${CAMKE_CXX_FLAGS} -std=c++11 -pthread -fprofile-arcs -ftest-coverage")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DCONFIG_LLT -fprofile-arcs -ftest-coverage")
set(THIRD_PARTY_PATH ${CMAKE_CURRENT_SOURCE_DIR}/third_party)

link_directories(${THIRD_PARTY_PATH}/mockcpp/lib
                ${THIRD_PARTY_PATH}/googlemock/lib
                ${THIRD_PARTY_PATH}/googletest/lib)

#${THIRD_PARTY_PATH}/googletest/
include_directories(${THIRD_PARTY_PATH}/googletest/include/
        ${THIRD_PARTY_PATH}/googlemock/include/
        ${THIRD_PARTY_PATH}/mockcpp/include/
        ${THIRD_PARTY_PATH}/mockcpp/3rdparty/
        ${THIRD_PARTY_PATH}/googlemock/
        ${CMAKE_CURRENT_SOURCE_DIR}/../GtestLearn/include/
        ${CMAKE_CURRENT_SOURCE_DIR}/stubs/)

#${THIRD_PARTY_PATH}/googletest/src/gtest-all.cc
set(SRC_FILES
        ${CMAKE_CURRENT_SOURCE_DIR}/../GtestLearn/func.c
        ${CMAKE_CURRENT_SOURCE_DIR}/../GtestLearn/main.c
        ${CMAKE_CURRENT_SOURCE_DIR}/stubs/my_stubs.c
        ${THIRD_PARTY_PATH}/googlemock/src/gmock-all.cc
        gtest_ut.cpp
        main.cpp)

set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/bin")

add_executable(GtestLearnLLT ${SRC_FILES})
target_link_libraries(GtestLearnLLT libmockcpp.a libgmock.a libgtest.a)
编译执行：
cmake .
执行结果：
 注意：这里还是在编译的时候编译了gmock而不是直接链接，是因为直接使用静态库，会导致mock对象泄露的问题，目前没有定位到原因：
 三、代码分析
1. 不需要打桩的普通函数LLT：
TEST_F(GtestUt, ut_add_01)
    int ret;
    ret = add(1, 2);
    EXPECT_EQ(3, ret);
这个比较简单，没有什么说的，依靠gtest框架，检查函数功能的正确性；
2. 使用mockcpp来mocker一般C函数：
TEST_F(GtestUt, ut_add_02)
    int ret;
    struct test_t test;
    test.a = 1;
    test.b = 1;
    MOCKER(multi)
    .expects(atMost(20))
    .will(returnValue(100));
    ret = add_struct(&test);
    EXPECT_EQ(ret, 100);
    GlobalMockObject::verify();
使用mockcpp提供的MOCKER来对需要验证的目标函数add_struct中的multi来进行mocker，进行打桩，常用来覆盖不同的异常分支。
3. 使用自定义桩函数
int ex_get_value(int *a)
    if (a == NULL) {
        printf("get null pointer %p\n", a);
        return 0xFFFF;
    *a = 1011;
    printf("run stub func, get value %d\n", *a);
    return *a;
TEST_F(GtestUt, ut_add_05)
    int ret;
    int ex_value;
    ret = test_stub_func();
    EXPECT_EQ(ret, 1011);
对test_stub_func里面调用的ex_get_value来进行打桩，来实现自己想要完成的代码逻辑；
4. 使用gmock来打桩对象类函数，本例中的对象类函数是放在结构体test_t中的：
struct test_t {
    int a;
    int b;
    int (*p_func)(struct test_t *test);
使用gmock打桩：
class Mock_FOO {
public:
    MOCK_METHOD1(mock_test_struct_func, int(struct test_t *test));
Mock_FOO mocker;
int mock_test_struct_func(struct test_t *test)
    return mocker.mock_test_struct_func(test);
用Mock_FOO类的mock_test_struct_func函数来mocker结构体test_t的成员函数p_func：
TEST_F(GtestUt, ut_add_04)
    int ret;
    int a, b;
    struct test_t test;
    test.a = 10;
    test.b = 11;
    test.p_func = mock_test_struct_func;
    EXPECT_CALL(mocker, mock_test_struct_func(&test)).WillRepeatedly(Return(10));
    ret = test_struct_func(&test);
    EXPECT_EQ(ret, 10);
    GlobalMockObject::verify();
代码中 test.p_func = mock_test_struct_func; 使用Mock_FOO的函数来替代原结构体中的成员函数，通过 EXPECT_CALL  在test_struct_func函数调用结构体成员函数p_func的时候使用Mock_FOO的 mock_test_struct_func 来代替，达到打桩的目的。
四、使用Lcov来查看LLT覆盖率
1、lcov下载与安装
wget http://downloads.sourceforge.net/ltp/lcov-1.9.tar.gz
tar -zxvf lcov-1.9.tar.gz
cd lcov-1.9
make install
2、LLT工程CMakeLists.txt修改
添加 -fprofile-arcs -ftest-coverage 为lcov的工作生成.gcda .gcno文件
set(CMAKE_CXX_FLAGS "${CAMKE_CXX_FLAGS} -std=c++11 -pthread -fprofile-arcs -ftest-coverage")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DCONFIG_LLT -fprofile-arcs -ftest-coverage")
3、lcov需要代码运行之后才能生成.gcda和.gcno文件
编译运行LLT工程之后可以看到生成的文件：
可以看到我们需要进行LLT的代码main.c和func.c的gcda和gcno文件再CMakeFiles文件下；
4、使用lcov获取代码被执行次数的信息：
lcov -d ./CMakeFiles/GtestLearnLLT.dir/home/xxxx/GtestLearn/ -t bin/GtestLearnLLT -o test.info -b . -c
-d  指向你需要进行统计覆盖率代码所在的目录
-t  为测试工程可执行文件所在目录
-o 生成的输出文件
-b 相对路径，之前的路径基于此路径
-c 获取覆盖率信息
 5、使用genhtml生成网页
genhtml -o result/ test.info
-o 指向生成的html信息存放的目录
test.info是之前生成的包含覆盖率信息的文件
6、查看生成的目录
7、使用浏览器打开index.html
点开一个文件查看LLT覆盖情况：
遇到的问题：
*.gcda:stamp mismatch with notes file
解决方法:
当.gcda文件比.gcno文件更新时,您可能会收到“戳记不匹配”.
使用 hexdump -e '"%x\n"' -s8 -n4 main.c.gcda 查看时间戳，会发现gcda文件和gcno文件时间戳不一致；
它主要有两个原因：
1.您可能在运行测试之后和跟踪文件生成之前重新构建代码.
2.二进制文件可以在一台机器上构建,测试在其他机器上运行,其时间早于构建机器.
我的解决方法：
rm -rf CMakeFiles/    彻底删除这个文件夹，删除所有.gcda和 .gcno文件
然后重新编译和执行LLT工程就可以了