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