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/functional/callback.h> // RepeatingCallback 25 26 #include <cstdint> 27 #include <functional> 28 #include <map> 29 #include <string> 30 31 // Original included files, if any 32 // NOTE: Since this is a mock file with mock definitions some number of 33 // include files may not be required. The include-what-you-use 34 // still applies, but crafting proper inclusion is out of scope 35 // for this effort. This compilation unit may compile as-is, or 36 // may need attention to prune the inclusion set. 37 // 38 #include "stack/btm/security_device_record.h" 39 #include "test/common/mock_functions.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, tBLE_ADDR_TYPE* p_addr_type, 122 bool refresh)> 123 body{[](RawAddress* bd_addr, tBLE_ADDR_TYPE* p_addr_type, bool refresh) { 124 return false; 125 }}; operatorbtm_identity_addr_to_random_pseudo126 bool operator()(RawAddress* bd_addr, tBLE_ADDR_TYPE* p_addr_type, 127 bool refresh) { 128 return body(bd_addr, p_addr_type, refresh); 129 }; 130 }; 131 extern struct btm_identity_addr_to_random_pseudo 132 btm_identity_addr_to_random_pseudo; 133 // Name: btm_identity_addr_to_random_pseudo_from_address_with_type 134 // Params: tBLE_BD_ADDR* address_with_type, bool refresh 135 // Returns: bool 136 struct btm_identity_addr_to_random_pseudo_from_address_with_type { 137 std::function<bool(tBLE_BD_ADDR* address_with_type, bool refresh)> body{ 138 [](tBLE_BD_ADDR* address_with_type, bool refresh) { return false; }}; operatorbtm_identity_addr_to_random_pseudo_from_address_with_type139 bool operator()(tBLE_BD_ADDR* address_with_type, bool refresh) { 140 return body(address_with_type, refresh); 141 }; 142 }; 143 extern struct btm_identity_addr_to_random_pseudo_from_address_with_type 144 btm_identity_addr_to_random_pseudo_from_address_with_type; 145 // Name: btm_random_pseudo_to_identity_addr 146 // Params: RawAddress* random_pseudo, uint8_t* p_identity_addr_type 147 // Returns: bool 148 struct btm_random_pseudo_to_identity_addr { 149 std::function<bool(RawAddress* random_pseudo, 150 tBLE_ADDR_TYPE* p_identity_addr_type)> 151 body{[](RawAddress* random_pseudo, tBLE_ADDR_TYPE* p_identity_addr_type) { 152 return false; 153 }}; operatorbtm_random_pseudo_to_identity_addr154 bool operator()(RawAddress* random_pseudo, 155 tBLE_ADDR_TYPE* p_identity_addr_type) { 156 return body(random_pseudo, p_identity_addr_type); 157 }; 158 }; 159 extern struct btm_random_pseudo_to_identity_addr 160 btm_random_pseudo_to_identity_addr; 161 // Name: btm_ble_refresh_peer_resolvable_private_addr 162 // Params: const RawAddress& pseudo_bda, const RawAddress& rpa, 163 // tBTM_SEC_BLE::tADDRESS_TYPE rra_type Returns: void 164 struct btm_ble_refresh_peer_resolvable_private_addr { 165 std::function<void(const RawAddress& pseudo_bda, const RawAddress& rpa, 166 tBTM_SEC_BLE::tADDRESS_TYPE rra_type)> 167 body{[](const RawAddress& pseudo_bda, const RawAddress& rpa, 168 tBTM_SEC_BLE::tADDRESS_TYPE rra_type) {}}; operatorbtm_ble_refresh_peer_resolvable_private_addr169 void operator()(const RawAddress& pseudo_bda, const RawAddress& rpa, 170 tBTM_SEC_BLE::tADDRESS_TYPE rra_type) { 171 body(pseudo_bda, rpa, rra_type); 172 }; 173 }; 174 extern struct btm_ble_refresh_peer_resolvable_private_addr 175 btm_ble_refresh_peer_resolvable_private_addr; 176 177 } // namespace stack_btm_ble_addr 178 } // namespace mock 179 } // namespace test 180 181 // END mockcify generation 182