1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
/** @file
This header allows the mocking of free (C style) functions using gmock.
Copyright (c) 2023, Intel Corporation. All rights reserved.
SPDX-License-Identifier: BSD-2-Clause-Patent
**/
#ifndef FUNCTION_MOCK_LIB_H_
#define FUNCTION_MOCK_LIB_H_
#include <Library/GoogleTestLib.h>
#include <Library/SubhookLib.h>
#include <type_traits>
//////////////////////////////////////////////////////////////////////////////
// The below macros are the public function mock interface that are intended
// to be used outside this file.
#define MOCK_INTERFACE_DECLARATION(MOCK) \
static MOCK * Instance; \
MOCK (); \
~MOCK ();
#define MOCK_INTERFACE_DEFINITION(MOCK) \
MOCK_STATIC_INSTANCE_DEFINITION (MOCK) \
MOCK_INTERFACE_CONSTRUCTOR (MOCK) \
MOCK_INTERFACE_DECONSTRUCTOR (MOCK)
// Mock function declaration for external functions (i.e. functions to
// mock that do not exist in the compilation unit).
#define MOCK_FUNCTION_DECLARATION(RET_TYPE, FUNC, ARGS) \
MOCK_FUNCTION_TYPE_DEFINITIONS(RET_TYPE, FUNC, ARGS) \
MOCK_METHOD (RET_TYPE, FUNC, ARGS);
// Mock function definition for external functions (i.e. functions to
// mock that do not exist in the compilation unit).
#define MOCK_FUNCTION_DEFINITION(MOCK, FUNC, NUM_ARGS, CALL_TYPE) \
FUNCTION_DEFINITION_TO_CALL_MOCK(MOCK, FUNC, FUNC, NUM_ARGS, CALL_TYPE)
// Mock function declaration for internal functions (i.e. functions to
// mock that already exist in the compilation unit).
#define MOCK_FUNCTION_INTERNAL_DECLARATION(RET_TYPE, FUNC, ARGS) \
MOCK_FUNCTION_DECLARATION(RET_TYPE, FUNC, ARGS) \
MOCK_FUNCTION_HOOK_DECLARATIONS(FUNC)
// Mock function definition for internal functions (i.e. functions to
// mock that already exist in the compilation unit). This definition also
// implements MOCK_FUNC() which is later hooked as FUNC().
#define MOCK_FUNCTION_INTERNAL_DEFINITION(MOCK, FUNC, NUM_ARGS, CALL_TYPE) \
FUNCTION_DEFINITION_TO_CALL_MOCK(MOCK, FUNC, MOCK##_##FUNC, NUM_ARGS, CALL_TYPE) \
MOCK_FUNCTION_HOOK_DEFINITIONS(MOCK, FUNC)
//////////////////////////////////////////////////////////////////////////////
// The below macros are private and should not be used outside this file.
#define MOCK_FUNCTION_HOOK_DECLARATIONS(FUNC) \
static subhook::Hook Hook##FUNC; \
struct MockContainer_##FUNC { \
MockContainer_##FUNC (); \
~MockContainer_##FUNC (); \
}; \
MockContainer_##FUNC MockContainerInst_##FUNC;
// This definition implements a constructor and destructor inside a nested
// class to enable automatic installation of the hooks to the associated
// MOCK_FUNC() when the mock object is instantiated in scope and automatic
// removal when the instantiated mock object goes out of scope.
#define MOCK_FUNCTION_HOOK_DEFINITIONS(MOCK, FUNC) \
subhook :: Hook MOCK :: Hook##FUNC; \
MOCK :: MockContainer_##FUNC :: MockContainer_##FUNC () { \
if (MOCK :: Instance == NULL) \
MOCK :: Hook##FUNC .Install( \
(FUNC##_ret_type *) ::FUNC, \
(FUNC##_ret_type *) MOCK##_##FUNC); \
} \
MOCK :: MockContainer_##FUNC :: ~MockContainer_##FUNC () { \
MOCK :: Hook##FUNC .Remove(); \
} \
static_assert( \
std::is_same<decltype(&::FUNC), decltype(&MOCK##_##FUNC)>::value, \
"Function signature from 'MOCK_FUNCTION_INTERNAL_DEFINITION' macro " \
"invocation for '" #FUNC "' does not match the function signature " \
"of '" #FUNC "' function it is mocking. Mismatch could be due to " \
"different return type, arguments, or calling convention. See " \
"associated 'MOCK_FUNCTION_INTERNAL_DECLARATION' macro invocation " \
"for more details.");
#define MOCK_FUNCTION_TYPE_DEFINITIONS(RET_TYPE, FUNC, ARGS) \
using FUNC##_ret_type = RET_TYPE; \
using FUNC##_type = FUNC##_ret_type ARGS;
// This function definition simply calls MOCK::Instance->FUNC() which is the
// mocked counterpart of the original function. This allows using gmock with
// C free functions (since by default gmock only works with object methods).
#define FUNCTION_DEFINITION_TO_CALL_MOCK(MOCK, FUNC, FUNC_DEF_NAME, NUM_ARGS, CALL_TYPE) \
extern "C" { \
typename MOCK :: FUNC##_ret_type CALL_TYPE FUNC_DEF_NAME( \
GMOCK_PP_REPEAT(GMOCK_INTERNAL_PARAMETER, \
(MOCK :: FUNC##_type), \
NUM_ARGS)) \
{ \
EXPECT_TRUE(MOCK :: Instance != NULL) \
<< "Called '" #FUNC "' in '" #MOCK "' function mock object before " \
<< "an instance of '" #MOCK "' was created in test '" \
<< ::testing::UnitTest::GetInstance()->current_test_info()->name() \
<< "'."; \
return MOCK :: Instance->FUNC( \
GMOCK_PP_REPEAT(GMOCK_INTERNAL_FORWARD_ARG, \
(MOCK :: FUNC##_type), \
NUM_ARGS)); \
} \
}
#define MOCK_STATIC_INSTANCE_DEFINITION(MOCK) MOCK * MOCK :: Instance = NULL;
#define MOCK_INTERFACE_CONSTRUCTOR(MOCK) \
MOCK :: MOCK () { \
EXPECT_TRUE(MOCK :: Instance == NULL) \
<< "Multiple instances of '" #MOCK "' function mock object were " \
<< "created and only one instance is allowed in test '" \
<< ::testing::UnitTest::GetInstance()->current_test_info()->name() \
<< "'."; \
MOCK :: Instance = this; \
}
#define MOCK_INTERFACE_DECONSTRUCTOR(MOCK) \
MOCK :: ~ MOCK () { \
MOCK :: Instance = NULL; \
}
#endif // FUNCTION_MOCK_LIB_H_
|
