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