1 /* 2 * Copyright 2023 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 #pragma once 17 18 /* 19 * Generated mock file from original source file 20 * Functions generated:43 21 * 22 * mockcify.pl ver 0.6.0 23 */ 24 25 #include <cstdint> 26 #include <functional> 27 28 // Original included files, if any 29 30 #include "bta/include/bta_av_api.h" 31 #include "btif/include/btif_av.h" 32 #include "include/hardware/bt_av.h" 33 #include "types/raw_address.h" 34 35 // Original usings 36 typedef enum { 37 /* Reuse BTA_AV_XXX_EVT - No need to redefine them here */ 38 BTIF_AV_CONNECT_REQ_EVT = BTA_AV_MAX_EVT, 39 BTIF_AV_DISCONNECT_REQ_EVT, 40 BTIF_AV_START_STREAM_REQ_EVT, 41 BTIF_AV_STOP_STREAM_REQ_EVT, 42 BTIF_AV_SUSPEND_STREAM_REQ_EVT, 43 BTIF_AV_SINK_CONFIG_REQ_EVT, 44 BTIF_AV_ACL_DISCONNECTED, 45 BTIF_AV_OFFLOAD_START_REQ_EVT, 46 BTIF_AV_AVRCP_OPEN_EVT, 47 BTIF_AV_AVRCP_CLOSE_EVT, 48 BTIF_AV_AVRCP_REMOTE_PLAY_EVT, 49 BTIF_AV_SET_LATENCY_REQ_EVT, 50 } btif_av_sm_event_t; 51 52 // Mocked compile conditionals, if any 53 54 namespace test { 55 namespace mock { 56 namespace btif_av { 57 58 // Shared state between mocked functions and tests 59 // Name: btif_av_acl_disconnected 60 // Params: const RawAddress& peer_address 61 // Params: const A2dpType local_a2dp_type. 62 // Return: void 63 struct btif_av_acl_disconnected { 64 std::function<void(const RawAddress& peer_address, 65 const A2dpType local_a2dp_type)> 66 body{[](const RawAddress& /* peer_address */, 67 const A2dpType /* local_a2dp_type */) {}}; operatorbtif_av_acl_disconnected68 void operator()(const RawAddress& peer_address, 69 const A2dpType local_a2dp_type) { 70 body(peer_address, local_a2dp_type); 71 }; 72 }; 73 extern struct btif_av_acl_disconnected btif_av_acl_disconnected; 74 75 // Name: btif_av_clear_remote_suspend_flag 76 // Params: const A2dpType local_a2dp_type. 77 // Return: void 78 struct btif_av_clear_remote_suspend_flag { 79 std::function<void(const A2dpType local_a2dp_type)> body{ 80 [](const A2dpType /* local_a2dp_type */) {}}; operatorbtif_av_clear_remote_suspend_flag81 void operator()(const A2dpType local_a2dp_type) { body(local_a2dp_type); }; 82 }; 83 extern struct btif_av_clear_remote_suspend_flag 84 btif_av_clear_remote_suspend_flag; 85 86 // Name: btif_av_find_by_handle 87 // Params: tBTA_AV_HNDL bta_handle 88 // Return: const RawAddress& 89 struct btif_av_find_by_handle { 90 static const RawAddress& return_value; 91 std::function<const RawAddress&(tBTA_AV_HNDL bta_handle)> body{ 92 [](tBTA_AV_HNDL /* bta_handle */) { return return_value; }}; operatorbtif_av_find_by_handle93 const RawAddress& operator()(tBTA_AV_HNDL bta_handle) { 94 return body(bta_handle); 95 }; 96 }; 97 extern struct btif_av_find_by_handle btif_av_find_by_handle; 98 99 // Name: btif_av_get_audio_delay 100 // Params: const A2dpType local_a2dp_type. 101 // Return: uint16_t 102 struct btif_av_get_audio_delay { 103 static uint16_t return_value; 104 std::function<uint16_t(const A2dpType local_a2dp_type)> body{ 105 [](const A2dpType /* local_a2dp_type */) { return return_value; }}; operatorbtif_av_get_audio_delay106 uint16_t operator()(const A2dpType local_a2dp_type) { 107 return body(local_a2dp_type); 108 }; 109 }; 110 extern struct btif_av_get_audio_delay btif_av_get_audio_delay; 111 112 // Name: btif_av_get_peer_sep 113 // Params: const A2dpType local_a2dp_type. 114 // Return: uint8_t 115 struct btif_av_get_peer_sep { 116 static uint8_t return_value; 117 std::function<uint8_t(const A2dpType local_a2dp_type)> body{ 118 [](const A2dpType /* local_a2dp_type */) { return return_value; }}; operatorbtif_av_get_peer_sep119 uint8_t operator()(const A2dpType local_a2dp_type) { 120 return body(local_a2dp_type); 121 }; 122 }; 123 extern struct btif_av_get_peer_sep btif_av_get_peer_sep; 124 125 // Name: btif_av_get_sink_interface 126 // Params: void 127 // Return: const btav_sink_interface_t* 128 struct btif_av_get_sink_interface { 129 static const btav_sink_interface_t* return_value; 130 std::function<const btav_sink_interface_t*(void)> body{ 131 [](void) { return return_value; }}; operatorbtif_av_get_sink_interface132 const btav_sink_interface_t* operator()(void) { return body(); }; 133 }; 134 extern struct btif_av_get_sink_interface btif_av_get_sink_interface; 135 136 // Name: btif_av_get_src_interface 137 // Params: void 138 // Return: const btav_source_interface_t* 139 struct btif_av_get_src_interface { 140 static const btav_source_interface_t* return_value; 141 std::function<const btav_source_interface_t*(void)> body{ 142 [](void) { return return_value; }}; operatorbtif_av_get_src_interface143 const btav_source_interface_t* operator()(void) { return body(); }; 144 }; 145 extern struct btif_av_get_src_interface btif_av_get_src_interface; 146 147 // Name: btif_av_is_a2dp_offload_enabled 148 // Params: 149 // Return: bool 150 struct btif_av_is_a2dp_offload_enabled { 151 static bool return_value; 152 std::function<bool()> body{[]() { return return_value; }}; operatorbtif_av_is_a2dp_offload_enabled153 bool operator()() { return body(); }; 154 }; 155 extern struct btif_av_is_a2dp_offload_enabled btif_av_is_a2dp_offload_enabled; 156 157 // Name: btif_av_is_a2dp_offload_running 158 // Params: 159 // Return: bool 160 struct btif_av_is_a2dp_offload_running { 161 static bool return_value; 162 std::function<bool()> body{[]() { return return_value; }}; operatorbtif_av_is_a2dp_offload_running163 bool operator()() { return body(); }; 164 }; 165 extern struct btif_av_is_a2dp_offload_running btif_av_is_a2dp_offload_running; 166 167 // Name: btif_av_is_connected 168 // Params: const A2dpType local_a2dp_type. 169 // Return: bool 170 struct btif_av_is_connected { 171 static bool return_value; 172 std::function<bool(const A2dpType local_a2dp_type)> body{ 173 [](const A2dpType /* local_a2dp_type */) { return return_value; }}; operatorbtif_av_is_connected174 bool operator()(const A2dpType local_a2dp_type) { 175 return body(local_a2dp_type); 176 }; 177 }; 178 extern struct btif_av_is_connected btif_av_is_connected; 179 180 // Name: btif_av_is_connected_addr 181 // Params: const RawAddress& peer_address, const A2dpType local_a2dp_type 182 // Return: bool 183 struct btif_av_is_connected_addr { 184 static bool return_value; 185 std::function<bool(const RawAddress& peer_address, 186 const A2dpType local_a2dp_type)> 187 body{[](const RawAddress& /* peer_address */, 188 const A2dpType /* local_a2dp_type */) { return return_value; }}; operatorbtif_av_is_connected_addr189 bool operator()(const RawAddress& peer_address, 190 const A2dpType local_a2dp_type) { 191 return body(peer_address, local_a2dp_type); 192 }; 193 }; 194 extern struct btif_av_is_connected_addr btif_av_is_connected_addr; 195 196 // Name: btif_av_is_peer_edr 197 // Params: const RawAddress& peer_address, const A2dpType local_a2dp_type 198 // Return: bool 199 struct btif_av_is_peer_edr { 200 static bool return_value; 201 std::function<bool(const RawAddress& peer_address, 202 const A2dpType local_a2dp_type)> 203 body{[](const RawAddress& /* peer_address */, 204 const A2dpType /* local_a2dp_type */) { return return_value; }}; operatorbtif_av_is_peer_edr205 bool operator()(const RawAddress& peer_address, 206 const A2dpType local_a2dp_type) { 207 return body(peer_address, local_a2dp_type); 208 }; 209 }; 210 extern struct btif_av_is_peer_edr btif_av_is_peer_edr; 211 212 // Name: btif_av_is_peer_silenced 213 // Params: const RawAddress& peer_address 214 // Return: bool 215 struct btif_av_is_peer_silenced { 216 static bool return_value; 217 std::function<bool(const RawAddress& peer_address)> body{ 218 [](const RawAddress& /* peer_address */) { return return_value; }}; operatorbtif_av_is_peer_silenced219 bool operator()(const RawAddress& peer_address) { 220 return body(peer_address); 221 }; 222 }; 223 extern struct btif_av_is_peer_silenced btif_av_is_peer_silenced; 224 225 // Name: btif_av_is_sink_enabled 226 // Params: void 227 // Return: bool 228 struct btif_av_is_sink_enabled { 229 static bool return_value; 230 std::function<bool(void)> body{[](void) { return return_value; }}; operatorbtif_av_is_sink_enabled231 bool operator()(void) { return body(); }; 232 }; 233 extern struct btif_av_is_sink_enabled btif_av_is_sink_enabled; 234 235 // Name: btif_av_is_source_enabled 236 // Params: void 237 // Return: bool 238 struct btif_av_is_source_enabled { 239 static bool return_value; 240 std::function<bool(void)> body{[](void) { return return_value; }}; operatorbtif_av_is_source_enabled241 bool operator()(void) { return body(); }; 242 }; 243 extern struct btif_av_is_source_enabled btif_av_is_source_enabled; 244 245 // Name: btif_av_peer_is_connected_sink 246 // Params: const RawAddress& peer_address 247 // Return: bool 248 struct btif_av_peer_is_connected_sink { 249 static bool return_value; 250 std::function<bool(const RawAddress& peer_address)> body{ 251 [](const RawAddress& /* peer_address */) { return return_value; }}; operatorbtif_av_peer_is_connected_sink252 bool operator()(const RawAddress& peer_address) { 253 return body(peer_address); 254 }; 255 }; 256 extern struct btif_av_peer_is_connected_sink btif_av_peer_is_connected_sink; 257 258 // Name: btif_av_peer_is_connected_source 259 // Params: const RawAddress& peer_address 260 // Return: bool 261 struct btif_av_peer_is_connected_source { 262 static bool return_value; 263 std::function<bool(const RawAddress& peer_address)> body{ 264 [](const RawAddress& /* peer_address */) { return return_value; }}; operatorbtif_av_peer_is_connected_source265 bool operator()(const RawAddress& peer_address) { 266 return body(peer_address); 267 }; 268 }; 269 extern struct btif_av_peer_is_connected_source btif_av_peer_is_connected_source; 270 271 // Name: btif_av_peer_is_sink 272 // Params: const RawAddress& peer_address 273 // Return: bool 274 struct btif_av_peer_is_sink { 275 static bool return_value; 276 std::function<bool(const RawAddress& peer_address)> body{ 277 [](const RawAddress& /* peer_address */) { return return_value; }}; operatorbtif_av_peer_is_sink278 bool operator()(const RawAddress& peer_address) { 279 return body(peer_address); 280 }; 281 }; 282 extern struct btif_av_peer_is_sink btif_av_peer_is_sink; 283 284 // Name: btif_av_peer_is_source 285 // Params: const RawAddress& peer_address 286 // Return: bool 287 struct btif_av_peer_is_source { 288 static bool return_value; 289 std::function<bool(const RawAddress& peer_address)> body{ 290 [](const RawAddress& /* peer_address */) { return return_value; }}; operatorbtif_av_peer_is_source291 bool operator()(const RawAddress& peer_address) { 292 return body(peer_address); 293 }; 294 }; 295 extern struct btif_av_peer_is_source btif_av_peer_is_source; 296 297 // Name: btif_av_peer_prefers_mandatory_codec 298 // Params: const RawAddress& peer_address, const A2dpType local_a2dp_type 299 // Return: bool 300 struct btif_av_peer_prefers_mandatory_codec { 301 static bool return_value; 302 std::function<bool(const RawAddress& peer_address, 303 const A2dpType local_a2dp_type)> 304 body{[](const RawAddress& /* peer_address */, 305 const A2dpType /* local_a2dp_type */) { 306 ; 307 return return_value; 308 }}; operatorbtif_av_peer_prefers_mandatory_codec309 bool operator()(const RawAddress& peer_address, 310 const A2dpType local_a2dp_type) { 311 return body(peer_address, local_a2dp_type); 312 }; 313 }; 314 extern struct btif_av_peer_prefers_mandatory_codec 315 btif_av_peer_prefers_mandatory_codec; 316 317 // Name: btif_av_peer_supports_3mbps 318 // Params: const RawAddress& peer_address, const A2dpType local_a2dp_type 319 // Return: bool 320 struct btif_av_peer_supports_3mbps { 321 static bool return_value; 322 std::function<bool(const RawAddress& peer_address, 323 const A2dpType local_a2dp_type)> 324 body{[](const RawAddress& /* peer_address */, 325 const A2dpType /* local_a2dp_type */) { 326 ; 327 return return_value; 328 }}; operatorbtif_av_peer_supports_3mbps329 bool operator()(const RawAddress& peer_address, 330 const A2dpType local_a2dp_type) { 331 return body(peer_address, local_a2dp_type); 332 }; 333 }; 334 extern struct btif_av_peer_supports_3mbps btif_av_peer_supports_3mbps; 335 336 // Name: btif_av_report_source_codec_state 337 // Params: const RawAddress& peer_address, const btav_a2dp_codec_config_t& 338 // codec_config, const std::vector<btav_a2dp_codec_config_t>& 339 // codecs_local_capabilities, const std::vector<btav_a2dp_codec_config_t>& 340 // codecs_selectable_capabilities Return: void 341 struct btif_av_report_source_codec_state { 342 std::function<void( 343 const RawAddress& peer_address, 344 const btav_a2dp_codec_config_t& codec_config, 345 const std::vector<btav_a2dp_codec_config_t>& codecs_local_capabilities, 346 const std::vector<btav_a2dp_codec_config_t>& 347 codecs_selectable_capabilities)> 348 body{[](const RawAddress& /* peer_address */, 349 const btav_a2dp_codec_config_t& /* codec_config */, 350 const std::vector<btav_a2dp_codec_config_t>& 351 /* codecs_local_capabilities */, 352 const std::vector<btav_a2dp_codec_config_t>& 353 /* codecs_selectable_capabilities */) {}}; operatorbtif_av_report_source_codec_state354 void operator()( 355 const RawAddress& peer_address, 356 const btav_a2dp_codec_config_t& codec_config, 357 const std::vector<btav_a2dp_codec_config_t>& codecs_local_capabilities, 358 const std::vector<btav_a2dp_codec_config_t>& 359 codecs_selectable_capabilities) { 360 body(peer_address, codec_config, codecs_local_capabilities, 361 codecs_selectable_capabilities); 362 }; 363 }; 364 extern struct btif_av_report_source_codec_state 365 btif_av_report_source_codec_state; 366 367 // Name: btif_av_reset_audio_delay 368 // Params: void 369 // Return: void 370 struct btif_av_reset_audio_delay { 371 std::function<void(void)> body{[](void) {}}; operatorbtif_av_reset_audio_delay372 void operator()(void) { body(); }; 373 }; 374 extern struct btif_av_reset_audio_delay btif_av_reset_audio_delay; 375 376 // Name: btif_av_set_audio_delay 377 // Params: const RawAddress& peer_address, uint16_t delay, const A2dpType 378 // local_a2dp_type Return: void 379 struct btif_av_set_audio_delay { 380 std::function<void(const RawAddress& peer_address, uint16_t delay, 381 const A2dpType local_a2dp_type)> 382 body{[](const RawAddress& /* peer_address */, uint16_t /* delay */, 383 const A2dpType /* local_a2dp_type */) {}}; operatorbtif_av_set_audio_delay384 void operator()(const RawAddress& peer_address, uint16_t delay, 385 const A2dpType local_a2dp_type) { 386 body(peer_address, delay, local_a2dp_type); 387 }; 388 }; 389 extern struct btif_av_set_audio_delay btif_av_set_audio_delay; 390 391 // Name: btif_av_set_dynamic_audio_buffer_size 392 // Params: uint8_t dynamic_audio_buffer_size 393 // Return: void 394 struct btif_av_set_dynamic_audio_buffer_size { 395 std::function<void(uint8_t dynamic_audio_buffer_size)> body{ 396 [](uint8_t /* dynamic_audio_buffer_size */) {}}; operatorbtif_av_set_dynamic_audio_buffer_size397 void operator()(uint8_t dynamic_audio_buffer_size) { 398 body(dynamic_audio_buffer_size); 399 }; 400 }; 401 extern struct btif_av_set_dynamic_audio_buffer_size 402 btif_av_set_dynamic_audio_buffer_size; 403 404 // Name: btif_av_set_low_latency 405 // Params: bool is_low_latency 406 // Return: void 407 struct btif_av_set_low_latency { 408 std::function<void(bool is_low_latency)> body{ 409 [](bool /* is_low_latency */) {}}; operatorbtif_av_set_low_latency410 void operator()(bool is_low_latency) { body(is_low_latency); }; 411 }; 412 extern struct btif_av_set_low_latency btif_av_set_low_latency; 413 414 // Name: btif_av_sink_active_peer 415 // Params: void 416 // Return: RawAddress 417 struct btif_av_sink_active_peer { 418 static RawAddress return_value; 419 std::function<RawAddress(void)> body{[](void) { return return_value; }}; operatorbtif_av_sink_active_peer420 RawAddress operator()(void) { return body(); }; 421 }; 422 extern struct btif_av_sink_active_peer btif_av_sink_active_peer; 423 424 // Name: btif_av_sink_execute_service 425 // Params: bool enable 426 // Return: bt_status_t 427 struct btif_av_sink_execute_service { 428 static bt_status_t return_value; 429 std::function<bt_status_t(bool enable)> body{ 430 [](bool /* enable */) { return return_value; }}; operatorbtif_av_sink_execute_service431 bt_status_t operator()(bool enable) { return body(enable); }; 432 }; 433 extern struct btif_av_sink_execute_service btif_av_sink_execute_service; 434 435 // Name: btif_av_source_active_peer 436 // Params: void 437 // Return: RawAddress 438 struct btif_av_source_active_peer { 439 static RawAddress return_value; 440 std::function<RawAddress(void)> body{[](void) { return return_value; }}; operatorbtif_av_source_active_peer441 RawAddress operator()(void) { return body(); }; 442 }; 443 extern struct btif_av_source_active_peer btif_av_source_active_peer; 444 445 // Name: btif_av_source_execute_service 446 // Params: bool enable 447 // Return: bt_status_t 448 struct btif_av_source_execute_service { 449 static bt_status_t return_value; 450 std::function<bt_status_t(bool enable)> body{ 451 [](bool /* enable */) { return return_value; }}; operatorbtif_av_source_execute_service452 bt_status_t operator()(bool enable) { return body(enable); }; 453 }; 454 extern struct btif_av_source_execute_service btif_av_source_execute_service; 455 456 // Name: btif_av_src_disconnect_sink 457 // Params: const RawAddress& peer_address 458 // Return: void 459 struct btif_av_src_disconnect_sink { 460 std::function<void(const RawAddress& peer_address)> body{ 461 [](const RawAddress& /* peer_address */) {}}; operatorbtif_av_src_disconnect_sink462 void operator()(const RawAddress& peer_address) { body(peer_address); }; 463 }; 464 extern struct btif_av_src_disconnect_sink btif_av_src_disconnect_sink; 465 466 // Name: btif_av_src_sink_coexist_enabled 467 // Params: void 468 // Return: bool 469 struct btif_av_src_sink_coexist_enabled { 470 static bool return_value; 471 std::function<bool(void)> body{[](void) { return return_value; }}; operatorbtif_av_src_sink_coexist_enabled472 bool operator()(void) { return body(); }; 473 }; 474 extern struct btif_av_src_sink_coexist_enabled btif_av_src_sink_coexist_enabled; 475 476 // Name: btif_av_stream_ready 477 // Params: const A2dpType local_a2dp_type 478 // Return: bool 479 struct btif_av_stream_ready { 480 static bool return_value; 481 std::function<bool(const A2dpType local_a2dp_type)> body{ 482 [](const A2dpType /* local_a2dp_type */) { return return_value; }}; operatorbtif_av_stream_ready483 bool operator()(const A2dpType local_a2dp_type) { 484 return body(local_a2dp_type); 485 }; 486 }; 487 extern struct btif_av_stream_ready btif_av_stream_ready; 488 489 // Name: btif_av_stream_start 490 // Params: const A2dpType local_a2dp_type 491 // Return: void 492 struct btif_av_stream_start { 493 std::function<void(const A2dpType local_a2dp_type)> body{ 494 [](const A2dpType /* local_a2dp_type */) {}}; operatorbtif_av_stream_start495 void operator()(const A2dpType local_a2dp_type) { body(local_a2dp_type); }; 496 }; 497 extern struct btif_av_stream_start btif_av_stream_start; 498 499 // Name: btif_av_stream_start_offload 500 // Params: void 501 // Return: void 502 struct btif_av_stream_start_offload { 503 std::function<void(void)> body{[](void) {}}; operatorbtif_av_stream_start_offload504 void operator()(void) { body(); }; 505 }; 506 extern struct btif_av_stream_start_offload btif_av_stream_start_offload; 507 508 // Name: btif_av_stream_start_with_latency 509 // Params: bool use_latency_mode 510 // Return: void 511 struct btif_av_stream_start_with_latency { 512 std::function<void(bool use_latency_mode)> body{ 513 [](bool /* use_latency_mode */) {}}; operatorbtif_av_stream_start_with_latency514 void operator()(bool use_latency_mode) { body(use_latency_mode); }; 515 }; 516 extern struct btif_av_stream_start_with_latency 517 btif_av_stream_start_with_latency; 518 519 // Name: btif_av_stream_started_ready 520 // Params: const A2dpType local_a2dp_type 521 // Return: bool 522 struct btif_av_stream_started_ready { 523 static bool return_value; 524 std::function<bool(const A2dpType local_a2dp_type)> body{ 525 [](const A2dpType /* local_a2dp_type */) { return return_value; }}; operatorbtif_av_stream_started_ready526 bool operator()(const A2dpType local_a2dp_type) { 527 return body(local_a2dp_type); 528 }; 529 }; 530 extern struct btif_av_stream_started_ready btif_av_stream_started_ready; 531 532 // Name: btif_av_stream_stop 533 // Params: const RawAddress& peer_address 534 // Return: void 535 struct btif_av_stream_stop { 536 std::function<void(const RawAddress& peer_address)> body{ 537 [](const RawAddress& /* peer_address */) {}}; operatorbtif_av_stream_stop538 void operator()(const RawAddress& peer_address) { body(peer_address); }; 539 }; 540 extern struct btif_av_stream_stop btif_av_stream_stop; 541 542 // Name: btif_av_stream_suspend 543 // Params: void 544 // Return: void 545 struct btif_av_stream_suspend { 546 std::function<void(void)> body{[](void) {}}; operatorbtif_av_stream_suspend547 void operator()(void) { body(); }; 548 }; 549 extern struct btif_av_stream_suspend btif_av_stream_suspend; 550 551 // Name: btif_debug_av_dump 552 // Params: int fd 553 // Return: void 554 struct btif_debug_av_dump { 555 std::function<void(int fd)> body{[](int /* fd */) {}}; operatorbtif_debug_av_dump556 void operator()(int fd) { body(fd); }; 557 }; 558 extern struct btif_debug_av_dump btif_debug_av_dump; 559 560 // Name: dump_av_sm_event_name 561 // Params: int event 562 // Return: const char* 563 struct dump_av_sm_event_name { 564 static const char* return_value; 565 std::function<const char*(int event)> body{ 566 [](int /* event */) { return return_value; }}; operatordump_av_sm_event_name567 const char* operator()(int event) { return body(event); }; 568 }; 569 extern struct dump_av_sm_event_name dump_av_sm_event_name; 570 571 } // namespace btif_av 572 } // namespace mock 573 } // namespace test 574 575 // END mockcify generation 576