1 #include <stdint.h> 2 #include <stdio.h> 3 #include <stdlib.h> 4 #include <string.h> 5 6 #include "CppUTest/TestHarness.h" 7 #include "CppUTest/CommandLineTestRunner.h" 8 #include "CppUTestExt/MockSupport.h" 9 10 #include "hci_cmd.h" 11 12 #include "btstack_memory.h" 13 #include "hci.h" 14 #include "ble/gatt_client.h" 15 #include "btstack_event.h" 16 #include "hci_dump.h" 17 #include "hci_dump_posix_fs.h" 18 #include "btstack_debug.h" 19 #include "btstack_util.h" 20 #include "btstack_run_loop_posix.h" 21 22 typedef struct { 23 uint8_t type; 24 uint16_t size; 25 uint8_t buffer[258]; 26 } hci_packet_t; 27 28 #define MAX_HCI_PACKETS 10 29 static uint16_t transport_count_packets; 30 static hci_packet_t transport_packets[MAX_HCI_PACKETS]; 31 static int can_send_now = 1; 32 static void (*packet_handler)(uint8_t packet_type, uint8_t *packet, uint16_t size); 33 34 static const uint8_t packet_sent_event[] = { HCI_EVENT_TRANSPORT_PACKET_SENT, 0}; 35 36 static int hci_transport_test_set_baudrate(uint32_t baudrate){ 37 return 0; 38 } 39 40 static int hci_transport_test_can_send_now(uint8_t packet_type){ 41 return can_send_now; 42 } 43 44 static int hci_transport_test_send_packet(uint8_t packet_type, uint8_t * packet, int size){ 45 btstack_assert(transport_count_packets < MAX_HCI_PACKETS); 46 memcpy(transport_packets[transport_count_packets].buffer, packet, size); 47 transport_packets[transport_count_packets].type = packet_type; 48 transport_packets[transport_count_packets].size = size; 49 transport_count_packets++; 50 // notify upper stack that it can send again 51 packet_handler(HCI_EVENT_PACKET, (uint8_t *) &packet_sent_event[0], sizeof(packet_sent_event)); 52 return 0; 53 } 54 55 static void hci_transport_test_init(const void * transport_config){ 56 } 57 58 static int hci_transport_test_open(void){ 59 return 0; 60 } 61 62 static int hci_transport_test_close(void){ 63 return 0; 64 } 65 66 static void hci_transport_test_register_packet_handler(void (*handler)(uint8_t packet_type, uint8_t *packet, uint16_t size)){ 67 packet_handler = handler; 68 } 69 70 static const hci_transport_t hci_transport_test = { 71 /* const char * name; */ "TEST", 72 /* void (*init) (const void *transport_config); */ &hci_transport_test_init, 73 /* int (*open)(void); */ &hci_transport_test_open, 74 /* int (*close)(void); */ &hci_transport_test_close, 75 /* void (*register_packet_handler)(void (*handler)(...); */ &hci_transport_test_register_packet_handler, 76 /* int (*can_send_packet_now)(uint8_t packet_type); */ &hci_transport_test_can_send_now, 77 /* int (*send_packet)(...); */ &hci_transport_test_send_packet, 78 /* int (*set_baudrate)(uint32_t baudrate); */ &hci_transport_test_set_baudrate, 79 /* void (*reset_link)(void); */ NULL, 80 /* void (*set_sco_config)(uint16_t voice_setting, int num_connections); */ NULL, 81 }; 82 83 static uint16_t next_hci_packet; 84 85 void CHECK_EQUAL_ARRAY(const uint8_t * expected, uint8_t * actual, int size){ 86 for (int i=0; i<size; i++){ 87 BYTES_EQUAL(expected[i], actual[i]); 88 } 89 } 90 91 void CHECK_HCI_COMMAND(const hci_cmd_t * expected_hci_command){ 92 uint16_t actual_opcode = little_endian_read_16(transport_packets[next_hci_packet].buffer, 0); 93 next_hci_packet++; 94 CHECK_EQUAL(expected_hci_command->opcode, actual_opcode); 95 } 96 97 TEST_GROUP(HCI){ 98 hci_stack_t * hci_stack; 99 100 void setup(void){ 101 transport_count_packets = 0; 102 can_send_now = 1; 103 next_hci_packet = 0; 104 hci_init(&hci_transport_test, NULL); 105 hci_stack = hci_get_stack(); 106 hci_simulate_working_fuzz(); 107 hci_setup_test_connections_fuzz(); 108 // register for HCI events 109 mock().expectOneCall("hci_can_send_packet_now_using_packet_buffer").andReturnValue(1); 110 } 111 void teardown(void){ 112 mock().clear(); 113 } 114 }; 115 116 TEST(HCI, GetSetConnectionRange){ 117 le_connection_parameter_range_t range; 118 gap_get_connection_parameter_range(&range); 119 gap_set_connection_parameter_range(&range); 120 } 121 122 TEST(HCI, ConnectionRangeValid){ 123 le_connection_parameter_range_t range = { 124 .le_conn_interval_min = 1, 125 .le_conn_interval_max = 10, 126 .le_conn_latency_min = 1, 127 .le_conn_latency_max = 10, 128 .le_supervision_timeout_min = 1, 129 .le_supervision_timeout_max = 10 130 }; 131 CHECK_EQUAL( 0, gap_connection_parameter_range_included(&range, 0, 0, 0, 0)); 132 CHECK_EQUAL( 0, gap_connection_parameter_range_included(&range, 2, 11, 0, 0)); 133 CHECK_EQUAL( 0, gap_connection_parameter_range_included(&range, 2, 9, 11, 0)); 134 CHECK_EQUAL( 0, gap_connection_parameter_range_included(&range, 2, 0, 0, 0)); 135 CHECK_EQUAL( 0, gap_connection_parameter_range_included(&range, 2, 9, 0, 0)); 136 CHECK_EQUAL( 0, gap_connection_parameter_range_included(&range, 2, 9, 10, 0)); 137 CHECK_EQUAL( 0, gap_connection_parameter_range_included(&range, 2, 9, 5, 0)); 138 CHECK_EQUAL( 0, gap_connection_parameter_range_included(&range, 2, 9, 5, 11)); 139 CHECK_EQUAL( 1, gap_connection_parameter_range_included(&range, 2, 9, 5, 5)); 140 } 141 142 TEST(HCI, other_functions){ 143 gap_set_scan_phys(1); 144 gap_set_connection_phys(1); 145 hci_enable_custom_pre_init(); 146 gap_whitelist_clear(); 147 } 148 149 TEST(HCI, gap_whitelist_add_remove){ 150 bd_addr_type_t addr_type = BD_ADDR_TYPE_ACL; 151 bd_addr_t addr = { 0 }; 152 153 uint8_t status = gap_whitelist_add(addr_type, addr); 154 CHECK_EQUAL(ERROR_CODE_SUCCESS, status); 155 156 status = gap_whitelist_add(addr_type, addr); 157 CHECK_EQUAL(ERROR_CODE_COMMAND_DISALLOWED, status); 158 159 status = gap_whitelist_remove(addr_type, addr); 160 CHECK_EQUAL(ERROR_CODE_SUCCESS, status); 161 162 status = gap_whitelist_remove(addr_type, addr); 163 CHECK_EQUAL(ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER, status); 164 165 status = gap_whitelist_remove(BD_ADDR_TYPE_SCO, addr); 166 CHECK_EQUAL(ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER, status); 167 } 168 169 TEST(HCI, gap_connect_with_whitelist){ 170 uint8_t status = gap_connect_with_whitelist(); 171 CHECK_EQUAL(ERROR_CODE_SUCCESS, status); 172 173 bd_addr_type_t addr_type = BD_ADDR_TYPE_LE_PUBLIC; 174 bd_addr_t addr = { 0 }; 175 gap_auto_connection_start(addr_type, addr); 176 177 status = gap_connect_with_whitelist(); 178 CHECK_EQUAL(ERROR_CODE_COMMAND_DISALLOWED, status); 179 } 180 181 TEST(HCI, gap_auto_connection_start_stop){ 182 bd_addr_type_t addr_type = BD_ADDR_TYPE_LE_PUBLIC; 183 bd_addr_t addr = { 0 }; 184 185 uint8_t status = gap_auto_connection_start(addr_type, addr); 186 CHECK_EQUAL(ERROR_CODE_SUCCESS, status); 187 188 status = gap_auto_connection_stop(addr_type, addr); 189 CHECK_EQUAL(ERROR_CODE_SUCCESS, status); 190 } 191 192 TEST(HCI, gap_auto_connection_stop_all){ 193 bd_addr_type_t addr_type = BD_ADDR_TYPE_LE_PUBLIC; 194 bd_addr_t addr = { 0 }; 195 196 uint8_t status = gap_auto_connection_start(addr_type, addr); 197 CHECK_EQUAL(ERROR_CODE_SUCCESS, status); 198 199 status = gap_auto_connection_stop_all(); 200 CHECK_EQUAL(ERROR_CODE_SUCCESS, status); 201 } 202 203 TEST(HCI, gap_read_rssi){ 204 int status = gap_read_rssi(HCI_CON_HANDLE_INVALID); 205 CHECK_EQUAL(0, status); 206 207 status = gap_read_rssi(0x01); 208 CHECK_EQUAL(1, status); 209 } 210 211 TEST(HCI, gap_le_connection_interval){ 212 uint16_t con_interval = gap_le_connection_interval(HCI_CON_HANDLE_INVALID); 213 CHECK_EQUAL(0, con_interval); 214 215 con_interval = gap_le_connection_interval(0x01); 216 CHECK_EQUAL(0, con_interval); 217 } 218 219 220 TEST(HCI, gap_get_connection_type){ 221 gap_connection_type_t type = gap_get_connection_type(HCI_CON_HANDLE_INVALID); 222 CHECK_EQUAL(GAP_CONNECTION_INVALID, type); 223 224 type = gap_get_connection_type(0x01); 225 CHECK_EQUAL(GAP_CONNECTION_ACL, type); 226 } 227 228 TEST(HCI, gap_le_set_phy){ 229 uint8_t status = gap_le_set_phy(HCI_CON_HANDLE_INVALID, 0, 0, 0, 0); 230 CHECK_EQUAL(ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER, status); 231 232 status = gap_le_set_phy(0x01, 0, 0, 0, 0); 233 CHECK_EQUAL(ERROR_CODE_SUCCESS, status); 234 } 235 236 TEST(HCI, hci_connection_for_bd_addr_and_type){ 237 bd_addr_type_t addr_type = BD_ADDR_TYPE_ACL; 238 bd_addr_t addr = { 0 }; 239 240 hci_connection_t * con = hci_connection_for_bd_addr_and_type(addr , addr_type); 241 CHECK_EQUAL(NULL, con); 242 } 243 244 TEST(HCI, hci_number_free_acl_slots_for_handle){ 245 int free_acl_slots_num = hci_number_free_acl_slots_for_handle(HCI_CON_HANDLE_INVALID); 246 CHECK_EQUAL(0, free_acl_slots_num); 247 } 248 249 TEST(HCI, hci_send_acl_packet_buffer_no_connection){ 250 hci_reserve_packet_buffer(); 251 uint8_t status = hci_send_acl_packet_buffer(16); 252 CHECK_EQUAL(ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER, status); 253 } 254 255 TEST(HCI, hci_send_acl_packet_buffer){ 256 hci_reserve_packet_buffer(); 257 uint8_t * packet = hci_get_outgoing_packet_buffer(); 258 uint8_t flags = 0x02; 259 // LE Packet 260 uint16_t acl_len = 50; 261 hci_stack->le_data_packets_length = acl_len - 10;; 262 little_endian_store_16(packet, 0, 0x05 | (flags << 12)); 263 uint8_t status = hci_send_acl_packet_buffer(acl_len); 264 CHECK_EQUAL(ERROR_CODE_SUCCESS, status); 265 hci_stack->le_data_packets_length = 0; 266 } 267 268 TEST(HCI, hci_send_cmd_packet){ 269 bd_addr_t addr = { 0 }; 270 271 uint8_t status = hci_send_cmd(&hci_write_loopback_mode, 1); 272 CHECK_EQUAL(0, status); 273 274 uint8_t i; 275 for (i = 0; i < 3; i++){ 276 status = hci_send_cmd(&hci_le_create_connection, 277 1000, // scan interval: 625 ms 278 1000, // scan interval: 625 ms 279 i, // don't use whitelist 280 0, // peer address type: public 281 addr, // remote bd addr 282 0, // random or public 283 80, // conn interval min 284 80, // conn interval max (3200 * 0.625) 285 0, // conn latency 286 2000, // supervision timeout 287 0, // min ce length 288 1000 // max ce length 289 ); 290 CHECK_EQUAL(0, status); 291 } 292 } 293 294 TEST(HCI, hci_send_cmd_va_arg){ 295 hci_reserve_packet_buffer(); 296 uint8_t status = hci_send_cmd(&hci_write_loopback_mode, 1); 297 CHECK_EQUAL(ERROR_CODE_COMMAND_DISALLOWED, status); 298 } 299 300 TEST(HCI, hci_power_control){ 301 int status = hci_power_control(HCI_POWER_ON); 302 CHECK_EQUAL(0, status); 303 } 304 305 TEST(HCI, NumPeripherals){ 306 gap_set_max_number_peripheral_connections(1); 307 } 308 309 TEST(HCI, MaxAclLen){ 310 hci_max_acl_data_packet_length(); 311 } 312 313 TEST(HCI, Flushable){ 314 hci_non_flushable_packet_boundary_flag_supported(); 315 } 316 317 TEST(HCI, RemovePacketHandler){ 318 hci_remove_event_handler(NULL); 319 } 320 321 static void dummy_fn(const void * config){}; 322 TEST(HCI, SetChipset){ 323 hci_set_chipset(NULL); 324 btstack_chipset_t chipset_driver = { 0 }; 325 hci_set_chipset(NULL); 326 chipset_driver.init = dummy_fn; 327 } 328 329 TEST(HCI, SetControl){ 330 btstack_control_t hardware_control = { .init = &dummy_fn}; 331 hci_set_control(&hardware_control); 332 } 333 334 //TEST(HCI, Close){ 335 // hci_close(); 336 //} 337 338 TEST(HCI, SetPublicAddress){ 339 bd_addr_t addr = { 0 }; 340 hci_set_bd_addr(addr); 341 } 342 343 TEST(HCI, DisconnectSecurityBlock){ 344 hci_disconnect_security_block(HCI_CON_HANDLE_INVALID); 345 hci_disconnect_security_block(3); 346 } 347 348 TEST(HCI, SetDuplicateFilter){ 349 gap_set_scan_duplicate_filter(true); 350 } 351 352 TEST(HCI, ConnectCancel){ 353 uint8_t status; 354 status = gap_connect_with_whitelist(); 355 CHECK_EQUAL(ERROR_CODE_SUCCESS, status); 356 gap_connect_cancel(); 357 358 bd_addr_type_t addr_type = BD_ADDR_TYPE_LE_PUBLIC; 359 bd_addr_t addr = { 0 }; 360 gap_connect(addr, addr_type); 361 gap_connect_cancel(); 362 } 363 364 TEST(HCI, SetGapConnParams){ 365 gap_set_connection_parameters(0, 0, 0, 0, 0, 0, 0, 0); 366 } 367 368 TEST(HCI, UpdateConnParams){ 369 gap_update_connection_parameters(HCI_CON_HANDLE_INVALID, 0, 0, 0, 0); 370 gap_update_connection_parameters(5, 0, 0, 0, 0); 371 } 372 373 TEST(HCI, RequestConnParamUpdate){ 374 gap_request_connection_parameter_update(HCI_CON_HANDLE_INVALID, 0, 0, 0, 0); 375 gap_request_connection_parameter_update(5, 0, 0, 0, 0); 376 } 377 378 TEST(HCI, SetScanResponse){ 379 gap_scan_response_set_data(0, NULL); 380 } 381 382 TEST(HCI, SetAddrType){ 383 hci_le_set_own_address_type(0); 384 hci_le_set_own_address_type(1); 385 } 386 387 TEST(HCI, AdvEnable){ 388 gap_advertisements_enable(0); 389 gap_advertisements_enable(1); 390 } 391 392 TEST(HCI, SetRandomAddr){ 393 bd_addr_t addr = { 0 }; 394 hci_le_random_address_set(addr); 395 } 396 397 TEST(HCI, Disconnect){ 398 gap_disconnect(HCI_CON_HANDLE_INVALID); 399 gap_disconnect(5); 400 } 401 402 TEST(HCI, GetRole){ 403 gap_get_role(HCI_CON_HANDLE_INVALID); 404 gap_get_role(5); 405 } 406 TEST(HCI, hci_is_le_identity_address_type_other){ 407 hci_is_le_identity_address_type(BD_ADDR_TYPE_LE_PUBLIC_IDENTITY); 408 hci_is_le_identity_address_type(BD_ADDR_TYPE_LE_RANDOM); 409 } 410 411 TEST(HCI, hci_can_send_command_packet_now){ 412 can_send_now = 0; 413 hci_can_send_command_packet_now(); 414 can_send_now = 1; 415 hci_can_send_command_packet_now(); 416 } 417 418 TEST(HCI, hci_can_send_prepared_acl_packet_now){ 419 can_send_now = 0; 420 hci_can_send_prepared_acl_packet_now(0); 421 can_send_now = 1; 422 hci_can_send_prepared_acl_packet_now(0); 423 } 424 425 TEST(HCI, hci_can_send_acl_le_packet_now) { 426 can_send_now = 0; 427 hci_can_send_acl_le_packet_now(); 428 can_send_now = 1; 429 hci_can_send_acl_le_packet_now(); 430 } 431 TEST(HCI, hci_number_free_acl_slots_for_connection_type) { 432 CHECK_EQUAL(0, hci_number_free_acl_slots_for_connection_type(BD_ADDR_TYPE_UNKNOWN)); 433 CHECK_EQUAL(255, hci_number_free_acl_slots_for_connection_type(BD_ADDR_TYPE_ACL)); 434 CHECK_EQUAL(255, hci_number_free_acl_slots_for_connection_type(BD_ADDR_TYPE_LE_PUBLIC)); 435 // tweak stack 436 hci_stack_t * hci_stack = hci_get_stack(); 437 hci_stack->le_acl_packets_total_num = 1; 438 CHECK_EQUAL(1, hci_number_free_acl_slots_for_connection_type(BD_ADDR_TYPE_LE_PUBLIC)); 439 } 440 441 // TEST(HCI, hci_close) { 442 // hci_close(); 443 // } 444 445 TEST(HCI, gap_connect) { 446 bd_addr_type_t addr_type = BD_ADDR_TYPE_LE_PUBLIC; 447 bd_addr_t addr = { 0 }; 448 449 uint8_t status; 450 status = gap_connect(addr, addr_type); 451 CHECK_EQUAL(ERROR_CODE_SUCCESS, status); 452 status = gap_connect(addr, addr_type); 453 CHECK_EQUAL(ERROR_CODE_COMMAND_DISALLOWED, status); 454 } 455 456 TEST(HCI, hci_emit_state) { 457 hci_emit_state(); 458 } 459 460 TEST(HCI, gap_request_connection_subrating) { 461 int status = gap_request_connection_subrating(HCI_CON_HANDLE_INVALID, 0, 0, 0, 0, 0); 462 CHECK_EQUAL(ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER, status); 463 status = gap_request_connection_subrating(0x01, 0, 0, 0, 0, 0); 464 CHECK_EQUAL(ERROR_CODE_SUCCESS, status); 465 } 466 467 468 TEST(HCI, hci_set_hardware_error_callback) { 469 hci_set_hardware_error_callback(NULL); 470 } 471 472 TEST(HCI, hci_disconnect_all) { 473 hci_disconnect_all(); 474 } 475 476 TEST(HCI, hci_get_manufacturer) { 477 hci_get_manufacturer(); 478 } 479 TEST(HCI, gap_authorization_state) { 480 gap_authorization_state(HCI_CON_HANDLE_INVALID); 481 } 482 #ifdef ENABLE_LE_PRIVACY_ADDRESS_RESOLUTION 483 TEST(HCI, hci_load_le_device_db_entry_into_resolving_list) { 484 hci_load_le_device_db_entry_into_resolving_list(0); 485 } 486 487 TEST(HCI, hci_remove_le_device_db_entry_from_resolving_list) { 488 hci_remove_le_device_db_entry_from_resolving_list(0); 489 } 490 491 TEST(HCI, gap_load_resolving_list_from_le_device_db) { 492 gap_load_resolving_list_from_le_device_db(); 493 } 494 #endif 495 496 TEST(HCI, gap_privacy_client) { 497 gap_privacy_client_t client; 498 gap_privacy_client_register(&client); 499 gap_privacy_client_ready(&client); 500 gap_privacy_client_unregister(&client); 501 } 502 503 TEST(HCI, acl_handling) { 504 uint16_t con_handle = 1; 505 uint8_t flags = 0; 506 507 uint8_t packet[16]; 508 // no connection for invalid handle 509 memset(packet, 0xff, sizeof(packet)); 510 packet_handler(HCI_ACL_DATA_PACKET, packet, sizeof(packet)); 511 // invalid length 512 little_endian_store_16(packet, 0, con_handle | (flags << 12)); 513 packet_handler(HCI_ACL_DATA_PACKET, packet, sizeof(packet)); 514 // fix length 515 little_endian_store_16(packet, 2, 12); 516 little_endian_store_16(packet, 6, 8); 517 518 // unexpected acl continuation 519 flags = 0x01; 520 little_endian_store_16(packet, 0, con_handle | (flags << 12)); 521 packet_handler(HCI_ACL_DATA_PACKET, packet, sizeof(packet)); 522 // invalid packet boundary flags 523 flags = 0x03; 524 little_endian_store_16(packet, 0, con_handle | (flags << 12)); 525 packet_handler(HCI_ACL_DATA_PACKET, packet, sizeof(packet)); 526 // oversized first fragment 527 flags = 0x02; 528 little_endian_store_16(packet, 0, con_handle | (flags << 12)); 529 little_endian_store_16(packet, 2, 1996); 530 packet_handler(HCI_ACL_DATA_PACKET, packet, 2000); 531 532 // 1a store first flushable fragment 533 flags = 0x02; 534 little_endian_store_16(packet, 0, con_handle | (flags << 12)); 535 little_endian_store_16(packet, 2, 12); 536 little_endian_store_16(packet, 4, 20); 537 packet_handler(HCI_ACL_DATA_PACKET, packet, sizeof(packet)); 538 539 // 1b another first non-flushable 540 flags = 0x06; 541 little_endian_store_16(packet, 0, con_handle | (flags << 12)); 542 packet_handler(HCI_ACL_DATA_PACKET, packet, sizeof(packet)); 543 544 // 1c another first 545 packet_handler(HCI_ACL_DATA_PACKET, packet, sizeof(packet)); 546 547 // oversized continuation fragment 548 flags = 0x01; 549 little_endian_store_16(packet, 0, con_handle | (flags << 12)); 550 little_endian_store_16(packet, 2, 1996); 551 packet_handler(HCI_ACL_DATA_PACKET, packet, 2000); 552 } 553 TEST(HCI, gap_le_get_own_address) { 554 uint8_t addr_type; 555 bd_addr_t addr; 556 hci_stack->le_own_addr_type = BD_ADDR_TYPE_LE_PUBLIC; 557 gap_le_get_own_address(&addr_type, addr); 558 hci_stack->le_own_addr_type = BD_ADDR_TYPE_LE_RANDOM; 559 gap_le_get_own_address(&addr_type, addr); 560 } 561 562 static void simulate_hci_command_complete(uint16_t opcode, uint8_t status) { 563 uint8_t packet[30]; 564 packet[0] = HCI_EVENT_COMMAND_COMPLETE; 565 packet[1] = sizeof(packet)-2; 566 packet[2] = 1; 567 little_endian_store_16(packet, 3, opcode); 568 packet[5] = status; 569 packet_handler(HCI_EVENT_PACKET, packet, sizeof(packet)); 570 } 571 572 TEST(HCI, handle_command_complete_event) { 573 struct { 574 uint16_t opcode; 575 uint8_t status; 576 } variations[] = { 577 {HCI_OPCODE_HCI_READ_LOCAL_NAME, ERROR_CODE_SUCCESS}, 578 {HCI_OPCODE_HCI_READ_LOCAL_NAME, ERROR_CODE_UNKNOWN_HCI_COMMAND }, 579 {HCI_OPCODE_HCI_READ_BUFFER_SIZE, ERROR_CODE_SUCCESS}, 580 {HCI_OPCODE_HCI_READ_RSSI, ERROR_CODE_SUCCESS}, 581 {HCI_OPCODE_HCI_READ_RSSI, ERROR_CODE_UNKNOWN_HCI_COMMAND}, 582 }; 583 for (uint8_t i = 0; i < sizeof(variations) / sizeof(variations[0]); i++) { 584 // extras 585 uint16_t opcode = variations[i].opcode; 586 uint8_t status = variations[i].status; 587 switch (opcode) { 588 default: 589 break; 590 } 591 simulate_hci_command_complete(opcode, status); 592 switch (opcode) { 593 default: 594 break; 595 } 596 } 597 } 598 599 int main (int argc, const char * argv[]){ 600 btstack_run_loop_init(btstack_run_loop_posix_get_instance()); 601 return CommandLineTestRunner::RunAllTests(argc, argv); 602 } 603