1 /* 2 * Copyright 2021 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 /* 18 * Generated mock file from original source file 19 * Functions generated:10 20 * 21 * mockcify.pl ver 0.2 22 */ 23 24 #include <base/callback.h> // RepeatingCallback 25 #include <cstdint> 26 #include <functional> 27 #include <map> 28 #include <string> 29 30 extern std::map<std::string, int> mock_function_count_map; 31 32 // Original included files, if any 33 // NOTE: Since this is a mock file with mock definitions some number of 34 // include files may not be required. The include-what-you-use 35 // still applies, but crafting proper inclusion is out of scope 36 // for this effort. This compilation unit may compile as-is, or 37 // may need attention to prune the inclusion set. 38 // 39 #include "stack/btm/security_device_record.h" 40 #include "types/ble_address_with_type.h" 41 #include "types/raw_address.h" 42 43 // Mocked compile conditionals, if any 44 #ifndef UNUSED_ATTR 45 #define UNUSED_ATTR 46 #endif 47 48 namespace test { 49 namespace mock { 50 namespace stack_btm_ble_addr { 51 52 // Shared state between mocked functions and tests 53 // Name: btm_gen_resolve_paddr_low 54 // Params: const RawAddress& address 55 // Returns: void 56 struct btm_gen_resolve_paddr_low { 57 std::function<void(const RawAddress& address)> body{ 58 [](const RawAddress& address) {}}; operatorbtm_gen_resolve_paddr_low59 void operator()(const RawAddress& address) { body(address); }; 60 }; 61 extern struct btm_gen_resolve_paddr_low btm_gen_resolve_paddr_low; 62 // Name: btm_gen_resolvable_private_addr 63 // Params: base::Callback<void(const RawAddress&)> cb 64 // Returns: void 65 struct btm_gen_resolvable_private_addr { 66 std::function<void(base::Callback<void(const RawAddress&)> cb)> body{ 67 [](base::Callback<void(const RawAddress&)> cb) {}}; operatorbtm_gen_resolvable_private_addr68 void operator()(base::Callback<void(const RawAddress&)> cb) { body(cb); }; 69 }; 70 extern struct btm_gen_resolvable_private_addr btm_gen_resolvable_private_addr; 71 // Name: btm_get_next_private_addrress_interval_ms 72 // Params: 73 // Returns: uint64_t 74 struct btm_get_next_private_addrress_interval_ms { 75 std::function<uint64_t()> body{[]() { return 0; }}; operatorbtm_get_next_private_addrress_interval_ms76 uint64_t operator()() { return body(); }; 77 }; 78 extern struct btm_get_next_private_addrress_interval_ms 79 btm_get_next_private_addrress_interval_ms; 80 // Name: btm_ble_init_pseudo_addr 81 // Params: tBTM_SEC_DEV_REC* p_dev_rec, const RawAddress& new_pseudo_addr 82 // Returns: bool 83 struct btm_ble_init_pseudo_addr { 84 std::function<bool(tBTM_SEC_DEV_REC* p_dev_rec, 85 const RawAddress& new_pseudo_addr)> 86 body{[](tBTM_SEC_DEV_REC* p_dev_rec, const RawAddress& new_pseudo_addr) { 87 return false; 88 }}; operatorbtm_ble_init_pseudo_addr89 bool operator()(tBTM_SEC_DEV_REC* p_dev_rec, 90 const RawAddress& new_pseudo_addr) { 91 return body(p_dev_rec, new_pseudo_addr); 92 }; 93 }; 94 extern struct btm_ble_init_pseudo_addr btm_ble_init_pseudo_addr; 95 // Name: btm_ble_addr_resolvable 96 // Params: const RawAddress& rpa, tBTM_SEC_DEV_REC* p_dev_rec 97 // Returns: bool 98 struct btm_ble_addr_resolvable { 99 std::function<bool(const RawAddress& rpa, tBTM_SEC_DEV_REC* p_dev_rec)> body{ 100 [](const RawAddress& rpa, tBTM_SEC_DEV_REC* p_dev_rec) { return false; }}; operatorbtm_ble_addr_resolvable101 bool operator()(const RawAddress& rpa, tBTM_SEC_DEV_REC* p_dev_rec) { 102 return body(rpa, p_dev_rec); 103 }; 104 }; 105 extern struct btm_ble_addr_resolvable btm_ble_addr_resolvable; 106 // Name: btm_ble_resolve_random_addr 107 // Params: const RawAddress& random_bda 108 // Returns: tBTM_SEC_DEV_REC* 109 struct btm_ble_resolve_random_addr { 110 std::function<tBTM_SEC_DEV_REC*(const RawAddress& random_bda)> body{ 111 [](const RawAddress& random_bda) { return nullptr; }}; operatorbtm_ble_resolve_random_addr112 tBTM_SEC_DEV_REC* operator()(const RawAddress& random_bda) { 113 return body(random_bda); 114 }; 115 }; 116 extern struct btm_ble_resolve_random_addr btm_ble_resolve_random_addr; 117 // Name: btm_identity_addr_to_random_pseudo 118 // Params: RawAddress* bd_addr, uint8_t* p_addr_type, bool refresh 119 // Returns: bool 120 struct btm_identity_addr_to_random_pseudo { 121 std::function<bool(RawAddress* bd_addr, uint8_t* p_addr_type, bool refresh)> 122 body{[](RawAddress* bd_addr, uint8_t* p_addr_type, bool refresh) { 123 return false; 124 }}; operatorbtm_identity_addr_to_random_pseudo125 bool operator()(RawAddress* bd_addr, uint8_t* p_addr_type, bool refresh) { 126 return body(bd_addr, p_addr_type, refresh); 127 }; 128 }; 129 extern struct btm_identity_addr_to_random_pseudo 130 btm_identity_addr_to_random_pseudo; 131 // Name: btm_identity_addr_to_random_pseudo_from_address_with_type 132 // Params: tBLE_BD_ADDR* address_with_type, bool refresh 133 // Returns: bool 134 struct btm_identity_addr_to_random_pseudo_from_address_with_type { 135 std::function<bool(tBLE_BD_ADDR* address_with_type, bool refresh)> body{ 136 [](tBLE_BD_ADDR* address_with_type, bool refresh) { return false; }}; operatorbtm_identity_addr_to_random_pseudo_from_address_with_type137 bool operator()(tBLE_BD_ADDR* address_with_type, bool refresh) { 138 return body(address_with_type, refresh); 139 }; 140 }; 141 extern struct btm_identity_addr_to_random_pseudo_from_address_with_type 142 btm_identity_addr_to_random_pseudo_from_address_with_type; 143 // Name: btm_random_pseudo_to_identity_addr 144 // Params: RawAddress* random_pseudo, uint8_t* p_identity_addr_type 145 // Returns: bool 146 struct btm_random_pseudo_to_identity_addr { 147 std::function<bool(RawAddress* random_pseudo, uint8_t* p_identity_addr_type)> 148 body{[](RawAddress* random_pseudo, uint8_t* p_identity_addr_type) { 149 return false; 150 }}; operatorbtm_random_pseudo_to_identity_addr151 bool operator()(RawAddress* random_pseudo, uint8_t* p_identity_addr_type) { 152 return body(random_pseudo, p_identity_addr_type); 153 }; 154 }; 155 extern struct btm_random_pseudo_to_identity_addr 156 btm_random_pseudo_to_identity_addr; 157 // Name: btm_ble_refresh_peer_resolvable_private_addr 158 // Params: const RawAddress& pseudo_bda, const RawAddress& rpa, 159 // tBTM_SEC_BLE::tADDRESS_TYPE rra_type Returns: void 160 struct btm_ble_refresh_peer_resolvable_private_addr { 161 std::function<void(const RawAddress& pseudo_bda, const RawAddress& rpa, 162 tBTM_SEC_BLE::tADDRESS_TYPE rra_type)> 163 body{[](const RawAddress& pseudo_bda, const RawAddress& rpa, 164 tBTM_SEC_BLE::tADDRESS_TYPE rra_type) {}}; operatorbtm_ble_refresh_peer_resolvable_private_addr165 void operator()(const RawAddress& pseudo_bda, const RawAddress& rpa, 166 tBTM_SEC_BLE::tADDRESS_TYPE rra_type) { 167 body(pseudo_bda, rpa, rra_type); 168 }; 169 }; 170 extern struct btm_ble_refresh_peer_resolvable_private_addr 171 btm_ble_refresh_peer_resolvable_private_addr; 172 173 } // namespace stack_btm_ble_addr 174 } // namespace mock 175 } // namespace test 176 177 // END mockcify generation 178