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:12
20  *
21  *  mockcify.pl ver 0.2
22  */
23 
24 #include <cstdint>
25 #include <functional>
26 #include <map>
27 #include <string>
28 
29 extern std::map<std::string, int> mock_function_count_map;
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 #include "gd/hci/address.h"
38 #include "gd/os/metrics.h"
39 #include "main/shim/helpers.h"
40 #include "main/shim/metrics_api.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 main_shim_metrics_api {
51 
52 // Shared state between mocked functions and tests
53 // Name: LogMetricLinkLayerConnectionEvent
54 // Params: const RawAddress* raw_address, uint32_t connection_handle,
55 // android::bluetooth::DirectionEnum direction, uint16_t link_type, uint32_t
56 // hci_cmd, uint16_t hci_event, uint16_t hci_ble_event, uint16_t cmd_status,
57 // uint16_t reason_code Returns: void
58 struct LogMetricLinkLayerConnectionEvent {
59   std::function<void(const RawAddress* raw_address, uint32_t connection_handle,
60                      android::bluetooth::DirectionEnum direction,
61                      uint16_t link_type, uint32_t hci_cmd, uint16_t hci_event,
62                      uint16_t hci_ble_event, uint16_t cmd_status,
63                      uint16_t reason_code)>
64       body{[](const RawAddress* raw_address, uint32_t connection_handle,
65               android::bluetooth::DirectionEnum direction, uint16_t link_type,
66               uint32_t hci_cmd, uint16_t hci_event, uint16_t hci_ble_event,
67               uint16_t cmd_status, uint16_t reason_code) {}};
operatorLogMetricLinkLayerConnectionEvent68   void operator()(const RawAddress* raw_address, uint32_t connection_handle,
69                   android::bluetooth::DirectionEnum direction,
70                   uint16_t link_type, uint32_t hci_cmd, uint16_t hci_event,
71                   uint16_t hci_ble_event, uint16_t cmd_status,
72                   uint16_t reason_code) {
73     body(raw_address, connection_handle, direction, link_type, hci_cmd,
74          hci_event, hci_ble_event, cmd_status, reason_code);
75   };
76 };
77 extern struct LogMetricLinkLayerConnectionEvent
78     LogMetricLinkLayerConnectionEvent;
79 // Name: LogMetricA2dpAudioUnderrunEvent
80 // Params: const RawAddress& raw_address, uint64_t encoding_interval_millis, int
81 // num_missing_pcm_bytes Returns: void
82 struct LogMetricA2dpAudioUnderrunEvent {
83   std::function<void(const RawAddress& raw_address,
84                      uint64_t encoding_interval_millis,
85                      int num_missing_pcm_bytes)>
86       body{[](const RawAddress& raw_address, uint64_t encoding_interval_millis,
87               int num_missing_pcm_bytes) {}};
operatorLogMetricA2dpAudioUnderrunEvent88   void operator()(const RawAddress& raw_address,
89                   uint64_t encoding_interval_millis,
90                   int num_missing_pcm_bytes) {
91     body(raw_address, encoding_interval_millis, num_missing_pcm_bytes);
92   };
93 };
94 extern struct LogMetricA2dpAudioUnderrunEvent LogMetricA2dpAudioUnderrunEvent;
95 // Name: LogMetricA2dpAudioOverrunEvent
96 // Params: const RawAddress& raw_address, uint64_t encoding_interval_millis, int
97 // num_dropped_buffers, int num_dropped_encoded_frames, int
98 // num_dropped_encoded_bytes Returns: void
99 struct LogMetricA2dpAudioOverrunEvent {
100   std::function<void(const RawAddress& raw_address,
101                      uint64_t encoding_interval_millis, int num_dropped_buffers,
102                      int num_dropped_encoded_frames,
103                      int num_dropped_encoded_bytes)>
104       body{[](const RawAddress& raw_address, uint64_t encoding_interval_millis,
105               int num_dropped_buffers, int num_dropped_encoded_frames,
106               int num_dropped_encoded_bytes) {}};
operatorLogMetricA2dpAudioOverrunEvent107   void operator()(const RawAddress& raw_address,
108                   uint64_t encoding_interval_millis, int num_dropped_buffers,
109                   int num_dropped_encoded_frames,
110                   int num_dropped_encoded_bytes) {
111     body(raw_address, encoding_interval_millis, num_dropped_buffers,
112          num_dropped_encoded_frames, num_dropped_encoded_bytes);
113   };
114 };
115 extern struct LogMetricA2dpAudioOverrunEvent LogMetricA2dpAudioOverrunEvent;
116 // Name: LogMetricA2dpPlaybackEvent
117 // Params: const RawAddress& raw_address, int playback_state, int
118 // audio_coding_mode Returns: void
119 struct LogMetricA2dpPlaybackEvent {
120   std::function<void(const RawAddress& raw_address, int playback_state,
121                      int audio_coding_mode)>
122       body{[](const RawAddress& raw_address, int playback_state,
123               int audio_coding_mode) {}};
operatorLogMetricA2dpPlaybackEvent124   void operator()(const RawAddress& raw_address, int playback_state,
125                   int audio_coding_mode) {
126     body(raw_address, playback_state, audio_coding_mode);
127   };
128 };
129 extern struct LogMetricA2dpPlaybackEvent LogMetricA2dpPlaybackEvent;
130 // Name: LogMetricReadRssiResult
131 // Params: const RawAddress& raw_address, uint16_t handle, uint32_t cmd_status,
132 // int8_t rssi Returns: void
133 struct LogMetricReadRssiResult {
134   std::function<void(const RawAddress& raw_address, uint16_t handle,
135                      uint32_t cmd_status, int8_t rssi)>
136       body{[](const RawAddress& raw_address, uint16_t handle,
137               uint32_t cmd_status, int8_t rssi) {}};
operatorLogMetricReadRssiResult138   void operator()(const RawAddress& raw_address, uint16_t handle,
139                   uint32_t cmd_status, int8_t rssi) {
140     body(raw_address, handle, cmd_status, rssi);
141   };
142 };
143 extern struct LogMetricReadRssiResult LogMetricReadRssiResult;
144 // Name: LogMetricReadFailedContactCounterResult
145 // Params: const RawAddress& raw_address, uint16_t handle, uint32_t cmd_status,
146 // int32_t failed_contact_counter Returns: void
147 struct LogMetricReadFailedContactCounterResult {
148   std::function<void(const RawAddress& raw_address, uint16_t handle,
149                      uint32_t cmd_status, int32_t failed_contact_counter)>
150       body{[](const RawAddress& raw_address, uint16_t handle,
151               uint32_t cmd_status, int32_t failed_contact_counter) {}};
operatorLogMetricReadFailedContactCounterResult152   void operator()(const RawAddress& raw_address, uint16_t handle,
153                   uint32_t cmd_status, int32_t failed_contact_counter) {
154     body(raw_address, handle, cmd_status, failed_contact_counter);
155   };
156 };
157 extern struct LogMetricReadFailedContactCounterResult
158     LogMetricReadFailedContactCounterResult;
159 // Name: LogMetricReadTxPowerLevelResult
160 // Params: const RawAddress& raw_address, uint16_t handle, uint32_t cmd_status,
161 // int32_t transmit_power_level Returns: void
162 struct LogMetricReadTxPowerLevelResult {
163   std::function<void(const RawAddress& raw_address, uint16_t handle,
164                      uint32_t cmd_status, int32_t transmit_power_level)>
165       body{[](const RawAddress& raw_address, uint16_t handle,
166               uint32_t cmd_status, int32_t transmit_power_level) {}};
operatorLogMetricReadTxPowerLevelResult167   void operator()(const RawAddress& raw_address, uint16_t handle,
168                   uint32_t cmd_status, int32_t transmit_power_level) {
169     body(raw_address, handle, cmd_status, transmit_power_level);
170   };
171 };
172 extern struct LogMetricReadTxPowerLevelResult LogMetricReadTxPowerLevelResult;
173 // Name: LogMetricSmpPairingEvent
174 // Params: const RawAddress& raw_address, uint8_t smp_cmd,
175 // android::bluetooth::DirectionEnum direction, uint8_t smp_fail_reason Returns:
176 // void
177 struct LogMetricSmpPairingEvent {
178   std::function<void(const RawAddress& raw_address, uint8_t smp_cmd,
179                      android::bluetooth::DirectionEnum direction,
180                      uint8_t smp_fail_reason)>
181       body{[](const RawAddress& raw_address, uint8_t smp_cmd,
182               android::bluetooth::DirectionEnum direction,
183               uint8_t smp_fail_reason) {}};
operatorLogMetricSmpPairingEvent184   void operator()(const RawAddress& raw_address, uint8_t smp_cmd,
185                   android::bluetooth::DirectionEnum direction,
186                   uint8_t smp_fail_reason) {
187     body(raw_address, smp_cmd, direction, smp_fail_reason);
188   };
189 };
190 extern struct LogMetricSmpPairingEvent LogMetricSmpPairingEvent;
191 // Name: LogMetricClassicPairingEvent
192 // Params: const RawAddress& raw_address, uint16_t handle, uint32_t hci_cmd,
193 // uint16_t hci_event, uint16_t cmd_status, uint16_t reason_code, int64_t
194 // event_value Returns: void
195 struct LogMetricClassicPairingEvent {
196   std::function<void(const RawAddress& raw_address, uint16_t handle,
197                      uint32_t hci_cmd, uint16_t hci_event, uint16_t cmd_status,
198                      uint16_t reason_code, int64_t event_value)>
199       body{[](const RawAddress& raw_address, uint16_t handle, uint32_t hci_cmd,
200               uint16_t hci_event, uint16_t cmd_status, uint16_t reason_code,
201               int64_t event_value) {}};
operatorLogMetricClassicPairingEvent202   void operator()(const RawAddress& raw_address, uint16_t handle,
203                   uint32_t hci_cmd, uint16_t hci_event, uint16_t cmd_status,
204                   uint16_t reason_code, int64_t event_value) {
205     body(raw_address, handle, hci_cmd, hci_event, cmd_status, reason_code,
206          event_value);
207   };
208 };
209 extern struct LogMetricClassicPairingEvent LogMetricClassicPairingEvent;
210 // Name: LogMetricSdpAttribute
211 // Params: const RawAddress& raw_address, uint16_t protocol_uuid, uint16_t
212 // attribute_id, size_t attribute_size, const char* attribute_value Returns:
213 // void
214 struct LogMetricSdpAttribute {
215   std::function<void(const RawAddress& raw_address, uint16_t protocol_uuid,
216                      uint16_t attribute_id, size_t attribute_size,
217                      const char* attribute_value)>
218       body{[](const RawAddress& raw_address, uint16_t protocol_uuid,
219               uint16_t attribute_id, size_t attribute_size,
220               const char* attribute_value) {}};
operatorLogMetricSdpAttribute221   void operator()(const RawAddress& raw_address, uint16_t protocol_uuid,
222                   uint16_t attribute_id, size_t attribute_size,
223                   const char* attribute_value) {
224     body(raw_address, protocol_uuid, attribute_id, attribute_size,
225          attribute_value);
226   };
227 };
228 extern struct LogMetricSdpAttribute LogMetricSdpAttribute;
229 // Name: LogMetricSocketConnectionState
230 // Params: const RawAddress& raw_address, int port, int type,
231 // android::bluetooth::SocketConnectionstateEnum connection_state, int64_t
232 // tx_bytes, int64_t rx_bytes, int uid, int server_port,
233 // android::bluetooth::SocketRoleEnum socket_role Returns: void
234 struct LogMetricSocketConnectionState {
235   std::function<void(
236       const RawAddress& raw_address, int port, int type,
237       android::bluetooth::SocketConnectionstateEnum connection_state,
238       int64_t tx_bytes, int64_t rx_bytes, int uid, int server_port,
239       android::bluetooth::SocketRoleEnum socket_role)>
240       body{[](const RawAddress& raw_address, int port, int type,
241               android::bluetooth::SocketConnectionstateEnum connection_state,
242               int64_t tx_bytes, int64_t rx_bytes, int uid, int server_port,
243               android::bluetooth::SocketRoleEnum socket_role) {}};
operatorLogMetricSocketConnectionState244   void operator()(
245       const RawAddress& raw_address, int port, int type,
246       android::bluetooth::SocketConnectionstateEnum connection_state,
247       int64_t tx_bytes, int64_t rx_bytes, int uid, int server_port,
248       android::bluetooth::SocketRoleEnum socket_role) {
249     body(raw_address, port, type, connection_state, tx_bytes, rx_bytes, uid,
250          server_port, socket_role);
251   };
252 };
253 extern struct LogMetricSocketConnectionState LogMetricSocketConnectionState;
254 // Name: LogMetricManufacturerInfo
255 // Params: const RawAddress& raw_address, android::bluetooth::DeviceInfoSrcEnum
256 // source_type, const std::string& source_name, const std::string& manufacturer,
257 // const std::string& model, const std::string& hardware_version, const
258 // std::string& software_version Returns: void
259 struct LogMetricManufacturerInfo {
260   std::function<void(const RawAddress& raw_address,
261                      android::bluetooth::DeviceInfoSrcEnum source_type,
262                      const std::string& source_name,
263                      const std::string& manufacturer, const std::string& model,
264                      const std::string& hardware_version,
265                      const std::string& software_version)>
266       body{[](const RawAddress& raw_address,
267               android::bluetooth::DeviceInfoSrcEnum source_type,
268               const std::string& source_name, const std::string& manufacturer,
269               const std::string& model, const std::string& hardware_version,
270               const std::string& software_version) {}};
operatorLogMetricManufacturerInfo271   void operator()(const RawAddress& raw_address,
272                   android::bluetooth::DeviceInfoSrcEnum source_type,
273                   const std::string& source_name,
274                   const std::string& manufacturer, const std::string& model,
275                   const std::string& hardware_version,
276                   const std::string& software_version) {
277     body(raw_address, source_type, source_name, manufacturer, model,
278          hardware_version, software_version);
279   };
280 };
281 extern struct LogMetricManufacturerInfo LogMetricManufacturerInfo;
282 
283 }  // namespace main_shim_metrics_api
284 }  // namespace mock
285 }  // namespace test
286 
287 // END mockcify generation