1 /*
2 * Copyright 2022 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16 /*
17 * Generated mock file from original source file
18 * Functions generated:26
19 *
20 * mockcify.pl ver 0.5.0
21 */
22 // Mock include file to share data between tests and mock
23 #include "test/mock/mock_stack_gatt_api.h"
24
25 #include <cstdint>
26 #include <string>
27
28 #include "test/common/mock_functions.h"
29
30 // Original usings
31 using bluetooth::Uuid;
32
33 // Mocked internal structures, if any
34
35 namespace test {
36 namespace mock {
37 namespace stack_gatt_api {
38
39 // Function state capture and return values, if needed
40 struct GATTC_GetAndRemoveListOfConnIdsWaitingForMtuRequest
41 GATTC_GetAndRemoveListOfConnIdsWaitingForMtuRequest;
42 struct GATTC_TryMtuRequest GATTC_TryMtuRequest;
43 struct GATTC_UpdateUserAttMtuIfNeeded GATTC_UpdateUserAttMtuIfNeeded;
44 struct GATTC_ConfigureMTU GATTC_ConfigureMTU;
45 struct GATTC_Discover GATTC_Discover;
46 struct GATTC_ExecuteWrite GATTC_ExecuteWrite;
47 struct GATTC_Read GATTC_Read;
48 struct GATTC_SendHandleValueConfirm GATTC_SendHandleValueConfirm;
49 struct GATTC_Write GATTC_Write;
50 struct GATTS_AddService GATTS_AddService;
51 struct GATTS_DeleteService GATTS_DeleteService;
52 struct GATTS_HandleValueIndication GATTS_HandleValueIndication;
53 struct GATTS_HandleValueNotification GATTS_HandleValueNotification;
54 struct GATTS_NVRegister GATTS_NVRegister;
55 struct GATTS_SendRsp GATTS_SendRsp;
56 struct GATTS_StopService GATTS_StopService;
57 struct GATT_CancelConnect GATT_CancelConnect;
58 struct GATT_Connect GATT_Connect;
59 struct GATT_Deregister GATT_Deregister;
60 struct GATT_Disconnect GATT_Disconnect;
61 struct GATT_GetConnIdIfConnected GATT_GetConnIdIfConnected;
62 struct GATT_GetConnectionInfor GATT_GetConnectionInfor;
63 struct GATT_Register GATT_Register;
64 struct GATT_SetIdleTimeout GATT_SetIdleTimeout;
65 struct GATT_StartIf GATT_StartIf;
66 // struct gatt_add_an_item_to_list gatt_add_an_item_to_list;
67 struct is_active_service is_active_service;
68
69 } // namespace stack_gatt_api
70 } // namespace mock
71 } // namespace test
72
73 // Mocked function return values, if any
74 namespace test {
75 namespace mock {
76 namespace stack_gatt_api {
77
78 std::list<uint16_t>
79 GATTC_GetAndRemoveListOfConnIdsWaitingForMtuRequest::return_value =
80 std::list<uint16_t>();
81 tGATTC_TryMtuRequestResult GATTC_TryMtuRequest::return_value =
82 MTU_EXCHANGE_NOT_DONE_YET;
83 tGATT_STATUS GATTC_ConfigureMTU::return_value = GATT_SUCCESS;
84 tGATT_STATUS GATTC_Discover::return_value = GATT_SUCCESS;
85 tGATT_STATUS GATTC_ExecuteWrite::return_value = GATT_SUCCESS;
86 tGATT_STATUS GATTC_Read::return_value = GATT_SUCCESS;
87 tGATT_STATUS GATTC_SendHandleValueConfirm::return_value = GATT_SUCCESS;
88 tGATT_STATUS GATTC_Write::return_value = GATT_SUCCESS;
89 tGATT_STATUS GATTS_AddService::return_value = GATT_SUCCESS;
90 bool GATTS_DeleteService::return_value = false;
91 tGATT_STATUS GATTS_HandleValueIndication::return_value = GATT_SUCCESS;
92 tGATT_STATUS GATTS_HandleValueNotification::return_value = GATT_SUCCESS;
93 bool GATTS_NVRegister::return_value = false;
94 tGATT_STATUS GATTS_SendRsp::return_value = GATT_SUCCESS;
95 bool GATT_CancelConnect::return_value = false;
96 bool GATT_Connect::return_value = false;
97 tGATT_STATUS GATT_Disconnect::return_value = GATT_SUCCESS;
98 bool GATT_GetConnIdIfConnected::return_value = false;
99 bool GATT_GetConnectionInfor::return_value = false;
100 tGATT_IF GATT_Register::return_value = 0;
101 // tGATT_HDL_LIST_ELEM gatt_add_an_item_to_list::return_value = { .svc_db = {},
102 // .asgn_range = {}};
103 bool is_active_service::return_value = false;
104
105 } // namespace stack_gatt_api
106 } // namespace mock
107 } // namespace test
108
109 // Mocked functions, if any
GATTC_GetAndRemoveListOfConnIdsWaitingForMtuRequest(const RawAddress & remote_bda)110 std::list<uint16_t> GATTC_GetAndRemoveListOfConnIdsWaitingForMtuRequest(
111 const RawAddress& remote_bda) {
112 inc_func_call_count(__func__);
113 return test::mock::stack_gatt_api::
114 GATTC_GetAndRemoveListOfConnIdsWaitingForMtuRequest(remote_bda);
115 }
GATTC_TryMtuRequest(const RawAddress & remote_bda,tBT_TRANSPORT transport,uint16_t conn_id,uint16_t * current_mtu)116 tGATTC_TryMtuRequestResult GATTC_TryMtuRequest(const RawAddress& remote_bda,
117 tBT_TRANSPORT transport,
118 uint16_t conn_id,
119 uint16_t* current_mtu) {
120 inc_func_call_count(__func__);
121 return test::mock::stack_gatt_api::GATTC_TryMtuRequest(remote_bda, transport,
122 conn_id, current_mtu);
123 }
GATTC_UpdateUserAttMtuIfNeeded(const RawAddress & remote_bda,tBT_TRANSPORT transport,uint16_t user_mtu)124 void GATTC_UpdateUserAttMtuIfNeeded(const RawAddress& remote_bda,
125 tBT_TRANSPORT transport,
126 uint16_t user_mtu) {
127 inc_func_call_count(__func__);
128 test::mock::stack_gatt_api::GATTC_UpdateUserAttMtuIfNeeded(
129 remote_bda, transport, user_mtu);
130 }
GATTC_ConfigureMTU(uint16_t conn_id,uint16_t mtu)131 tGATT_STATUS GATTC_ConfigureMTU(uint16_t conn_id, uint16_t mtu) {
132 inc_func_call_count(__func__);
133 return test::mock::stack_gatt_api::GATTC_ConfigureMTU(conn_id, mtu);
134 }
GATTC_Discover(uint16_t conn_id,tGATT_DISC_TYPE disc_type,uint16_t start_handle,uint16_t end_handle)135 tGATT_STATUS GATTC_Discover(uint16_t conn_id, tGATT_DISC_TYPE disc_type,
136 uint16_t start_handle, uint16_t end_handle) {
137 inc_func_call_count(__func__);
138 return test::mock::stack_gatt_api::GATTC_Discover(conn_id, disc_type,
139 start_handle, end_handle);
140 }
GATTC_ExecuteWrite(uint16_t conn_id,bool is_execute)141 tGATT_STATUS GATTC_ExecuteWrite(uint16_t conn_id, bool is_execute) {
142 inc_func_call_count(__func__);
143 return test::mock::stack_gatt_api::GATTC_ExecuteWrite(conn_id, is_execute);
144 }
GATTC_Read(uint16_t conn_id,tGATT_READ_TYPE type,tGATT_READ_PARAM * p_read)145 tGATT_STATUS GATTC_Read(uint16_t conn_id, tGATT_READ_TYPE type,
146 tGATT_READ_PARAM* p_read) {
147 inc_func_call_count(__func__);
148 return test::mock::stack_gatt_api::GATTC_Read(conn_id, type, p_read);
149 }
GATTC_SendHandleValueConfirm(uint16_t conn_id,uint16_t cid)150 tGATT_STATUS GATTC_SendHandleValueConfirm(uint16_t conn_id, uint16_t cid) {
151 inc_func_call_count(__func__);
152 return test::mock::stack_gatt_api::GATTC_SendHandleValueConfirm(conn_id, cid);
153 }
GATTC_Write(uint16_t conn_id,tGATT_WRITE_TYPE type,tGATT_VALUE * p_write)154 tGATT_STATUS GATTC_Write(uint16_t conn_id, tGATT_WRITE_TYPE type,
155 tGATT_VALUE* p_write) {
156 inc_func_call_count(__func__);
157 return test::mock::stack_gatt_api::GATTC_Write(conn_id, type, p_write);
158 }
GATTS_AddService(tGATT_IF gatt_if,btgatt_db_element_t * service,int count)159 tGATT_STATUS GATTS_AddService(tGATT_IF gatt_if, btgatt_db_element_t* service,
160 int count) {
161 inc_func_call_count(__func__);
162 return test::mock::stack_gatt_api::GATTS_AddService(gatt_if, service, count);
163 }
GATTS_DeleteService(tGATT_IF gatt_if,Uuid * p_svc_uuid,uint16_t svc_inst)164 bool GATTS_DeleteService(tGATT_IF gatt_if, Uuid* p_svc_uuid,
165 uint16_t svc_inst) {
166 inc_func_call_count(__func__);
167 return test::mock::stack_gatt_api::GATTS_DeleteService(gatt_if, p_svc_uuid,
168 svc_inst);
169 }
GATTS_HandleValueIndication(uint16_t conn_id,uint16_t attr_handle,uint16_t val_len,uint8_t * p_val)170 tGATT_STATUS GATTS_HandleValueIndication(uint16_t conn_id, uint16_t attr_handle,
171 uint16_t val_len, uint8_t* p_val) {
172 inc_func_call_count(__func__);
173 return test::mock::stack_gatt_api::GATTS_HandleValueIndication(
174 conn_id, attr_handle, val_len, p_val);
175 }
GATTS_HandleValueNotification(uint16_t conn_id,uint16_t attr_handle,uint16_t val_len,uint8_t * p_val)176 tGATT_STATUS GATTS_HandleValueNotification(uint16_t conn_id,
177 uint16_t attr_handle,
178 uint16_t val_len, uint8_t* p_val) {
179 inc_func_call_count(__func__);
180 return test::mock::stack_gatt_api::GATTS_HandleValueNotification(
181 conn_id, attr_handle, val_len, p_val);
182 }
GATTS_NVRegister(tGATT_APPL_INFO * p_cb_info)183 bool GATTS_NVRegister(tGATT_APPL_INFO* p_cb_info) {
184 inc_func_call_count(__func__);
185 return test::mock::stack_gatt_api::GATTS_NVRegister(p_cb_info);
186 }
GATTS_SendRsp(uint16_t conn_id,uint32_t trans_id,tGATT_STATUS status,tGATTS_RSP * p_msg)187 tGATT_STATUS GATTS_SendRsp(uint16_t conn_id, uint32_t trans_id,
188 tGATT_STATUS status, tGATTS_RSP* p_msg) {
189 inc_func_call_count(__func__);
190 return test::mock::stack_gatt_api::GATTS_SendRsp(conn_id, trans_id, status,
191 p_msg);
192 }
GATTS_StopService(uint16_t service_handle)193 void GATTS_StopService(uint16_t service_handle) {
194 inc_func_call_count(__func__);
195 test::mock::stack_gatt_api::GATTS_StopService(service_handle);
196 }
GATT_CancelConnect(tGATT_IF gatt_if,const RawAddress & bd_addr,bool is_direct)197 bool GATT_CancelConnect(tGATT_IF gatt_if, const RawAddress& bd_addr,
198 bool is_direct) {
199 inc_func_call_count(__func__);
200 return test::mock::stack_gatt_api::GATT_CancelConnect(gatt_if, bd_addr,
201 is_direct);
202 }
GATT_Connect(tGATT_IF gatt_if,const RawAddress & bd_addr,tBLE_ADDR_TYPE addr_type,tBTM_BLE_CONN_TYPE connection_type,tBT_TRANSPORT transport,bool opportunistic,uint8_t initiating_phys)203 bool GATT_Connect(tGATT_IF gatt_if, const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type,
204 tBTM_BLE_CONN_TYPE connection_type, tBT_TRANSPORT transport,
205 bool opportunistic, uint8_t initiating_phys) {
206 inc_func_call_count(__func__);
207 return test::mock::stack_gatt_api::GATT_Connect(
208 gatt_if, bd_addr, addr_type, connection_type, transport, opportunistic,
209 initiating_phys);
210 }
GATT_Deregister(tGATT_IF gatt_if)211 void GATT_Deregister(tGATT_IF gatt_if) {
212 inc_func_call_count(__func__);
213 test::mock::stack_gatt_api::GATT_Deregister(gatt_if);
214 }
GATT_Disconnect(uint16_t conn_id)215 tGATT_STATUS GATT_Disconnect(uint16_t conn_id) {
216 inc_func_call_count(__func__);
217 return test::mock::stack_gatt_api::GATT_Disconnect(conn_id);
218 }
GATT_GetConnIdIfConnected(tGATT_IF gatt_if,const RawAddress & bd_addr,uint16_t * p_conn_id,tBT_TRANSPORT transport)219 bool GATT_GetConnIdIfConnected(tGATT_IF gatt_if, const RawAddress& bd_addr,
220 uint16_t* p_conn_id, tBT_TRANSPORT transport) {
221 inc_func_call_count(__func__);
222 return test::mock::stack_gatt_api::GATT_GetConnIdIfConnected(
223 gatt_if, bd_addr, p_conn_id, transport);
224 }
GATT_GetConnectionInfor(uint16_t conn_id,tGATT_IF * p_gatt_if,RawAddress & bd_addr,tBT_TRANSPORT * p_transport)225 bool GATT_GetConnectionInfor(uint16_t conn_id, tGATT_IF* p_gatt_if,
226 RawAddress& bd_addr, tBT_TRANSPORT* p_transport) {
227 inc_func_call_count(__func__);
228 return test::mock::stack_gatt_api::GATT_GetConnectionInfor(
229 conn_id, p_gatt_if, bd_addr, p_transport);
230 }
GATT_Register(const Uuid & app_uuid128,const std::string & name,tGATT_CBACK * p_cb_info,bool eatt_support)231 tGATT_IF GATT_Register(const Uuid& app_uuid128, const std::string& name,
232 tGATT_CBACK* p_cb_info, bool eatt_support) {
233 inc_func_call_count(__func__);
234 return test::mock::stack_gatt_api::GATT_Register(app_uuid128, name, p_cb_info,
235 eatt_support);
236 }
GATT_SetIdleTimeout(const RawAddress & bd_addr,uint16_t idle_tout,tBT_TRANSPORT transport,bool is_active)237 void GATT_SetIdleTimeout(const RawAddress& bd_addr, uint16_t idle_tout,
238 tBT_TRANSPORT transport, bool is_active) {
239 inc_func_call_count(__func__);
240 test::mock::stack_gatt_api::GATT_SetIdleTimeout(bd_addr, idle_tout, transport,
241 is_active);
242 }
GATT_StartIf(tGATT_IF gatt_if)243 void GATT_StartIf(tGATT_IF gatt_if) {
244 inc_func_call_count(__func__);
245 test::mock::stack_gatt_api::GATT_StartIf(gatt_if);
246 }
247 // tGATT_HDL_LIST_ELEM& gatt_add_an_item_to_list(uint16_t s_handle) {
248 // inc_func_call_count(__func__);
249 // return test::mock::stack_gatt_api::gatt_add_an_item_to_list(s_handle);
250 // }
is_active_service(const Uuid & app_uuid128,Uuid * p_svc_uuid,uint16_t start_handle)251 bool is_active_service(const Uuid& app_uuid128, Uuid* p_svc_uuid,
252 uint16_t start_handle) {
253 inc_func_call_count(__func__);
254 return test::mock::stack_gatt_api::is_active_service(app_uuid128, p_svc_uuid,
255 start_handle);
256 }
257 // Mocked functions complete
258 //
GATT_Connect(tGATT_IF gatt_if,const RawAddress & bd_addr,tBTM_BLE_CONN_TYPE connection_type,tBT_TRANSPORT transport,bool opportunistic)259 bool GATT_Connect(tGATT_IF gatt_if, const RawAddress& bd_addr,
260 tBTM_BLE_CONN_TYPE connection_type, tBT_TRANSPORT transport,
261 bool opportunistic) {
262 inc_func_call_count(__func__);
263 return test::mock::stack_gatt_api::GATT_Connect(
264 gatt_if, bd_addr, 0, connection_type, transport, opportunistic, 0);
265 }
266
267 // END mockcify generation
268