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 void setup(void){ 99 transport_count_packets = 0; 100 can_send_now = 1; 101 next_hci_packet = 0; 102 hci_init(&hci_transport_test, NULL); 103 hci_simulate_working_fuzz(); 104 hci_setup_test_connections_fuzz(); 105 // register for HCI events 106 mock().expectOneCall("hci_can_send_packet_now_using_packet_buffer").andReturnValue(1); 107 } 108 void teardown(void){ 109 mock().clear(); 110 } 111 }; 112 113 TEST(HCI, GetSetConnectionRange){ 114 le_connection_parameter_range_t range; 115 gap_get_connection_parameter_range(&range); 116 gap_set_connection_parameter_range(&range); 117 } 118 119 TEST(HCI, ConnectionRangeValid){ 120 le_connection_parameter_range_t range = { 121 .le_conn_interval_min = 1, 122 .le_conn_interval_max = 10, 123 .le_conn_latency_min = 1, 124 .le_conn_latency_max = 10, 125 .le_supervision_timeout_min = 1, 126 .le_supervision_timeout_max = 10 127 }; 128 CHECK_EQUAL( 0, gap_connection_parameter_range_included(&range, 0, 0, 0, 0)); 129 CHECK_EQUAL( 0, gap_connection_parameter_range_included(&range, 2, 11, 0, 0)); 130 CHECK_EQUAL( 0, gap_connection_parameter_range_included(&range, 2, 9, 11, 0)); 131 CHECK_EQUAL( 0, gap_connection_parameter_range_included(&range, 2, 0, 0, 0)); 132 CHECK_EQUAL( 0, gap_connection_parameter_range_included(&range, 2, 9, 0, 0)); 133 CHECK_EQUAL( 0, gap_connection_parameter_range_included(&range, 2, 9, 10, 0)); 134 CHECK_EQUAL( 0, gap_connection_parameter_range_included(&range, 2, 9, 5, 0)); 135 CHECK_EQUAL( 0, gap_connection_parameter_range_included(&range, 2, 9, 5, 11)); 136 CHECK_EQUAL( 1, gap_connection_parameter_range_included(&range, 2, 9, 5, 5)); 137 } 138 139 TEST(HCI, other_functions){ 140 gap_set_scan_phys(1); 141 gap_set_connection_phys(1); 142 hci_enable_custom_pre_init(); 143 gap_whitelist_clear(); 144 } 145 146 TEST(HCI, gap_whitelist_add_remove){ 147 bd_addr_type_t addr_type = BD_ADDR_TYPE_ACL; 148 bd_addr_t addr = { 0 }; 149 150 uint8_t status = gap_whitelist_add(addr_type, addr); 151 CHECK_EQUAL(ERROR_CODE_SUCCESS, status); 152 153 status = gap_whitelist_add(addr_type, addr); 154 CHECK_EQUAL(ERROR_CODE_COMMAND_DISALLOWED, status); 155 156 status = gap_whitelist_remove(addr_type, addr); 157 CHECK_EQUAL(ERROR_CODE_SUCCESS, status); 158 159 status = gap_whitelist_remove(addr_type, addr); 160 CHECK_EQUAL(ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER, status); 161 162 status = gap_whitelist_remove(BD_ADDR_TYPE_SCO, addr); 163 CHECK_EQUAL(ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER, status); 164 } 165 166 TEST(HCI, gap_connect_with_whitelist){ 167 uint8_t status = gap_connect_with_whitelist(); 168 CHECK_EQUAL(ERROR_CODE_SUCCESS, status); 169 170 bd_addr_type_t addr_type = BD_ADDR_TYPE_LE_PUBLIC; 171 bd_addr_t addr = { 0 }; 172 gap_auto_connection_start(addr_type, addr); 173 174 status = gap_connect_with_whitelist(); 175 CHECK_EQUAL(ERROR_CODE_COMMAND_DISALLOWED, status); 176 } 177 178 TEST(HCI, gap_auto_connection_start_stop){ 179 bd_addr_type_t addr_type = BD_ADDR_TYPE_LE_PUBLIC; 180 bd_addr_t addr = { 0 }; 181 182 uint8_t status = gap_auto_connection_start(addr_type, addr); 183 CHECK_EQUAL(ERROR_CODE_SUCCESS, status); 184 185 status = gap_auto_connection_stop(addr_type, addr); 186 CHECK_EQUAL(ERROR_CODE_SUCCESS, status); 187 } 188 189 TEST(HCI, gap_auto_connection_stop_all){ 190 bd_addr_type_t addr_type = BD_ADDR_TYPE_LE_PUBLIC; 191 bd_addr_t addr = { 0 }; 192 193 uint8_t status = gap_auto_connection_start(addr_type, addr); 194 CHECK_EQUAL(ERROR_CODE_SUCCESS, status); 195 196 status = gap_auto_connection_stop_all(); 197 CHECK_EQUAL(ERROR_CODE_SUCCESS, status); 198 } 199 200 TEST(HCI, gap_read_rssi){ 201 int status = gap_read_rssi(HCI_CON_HANDLE_INVALID); 202 CHECK_EQUAL(0, status); 203 204 status = gap_read_rssi(0x01); 205 CHECK_EQUAL(1, status); 206 } 207 208 TEST(HCI, gap_le_connection_interval){ 209 uint16_t con_interval = gap_le_connection_interval(HCI_CON_HANDLE_INVALID); 210 CHECK_EQUAL(0, con_interval); 211 212 con_interval = gap_le_connection_interval(0x01); 213 CHECK_EQUAL(0, con_interval); 214 } 215 216 217 TEST(HCI, gap_get_connection_type){ 218 gap_connection_type_t type = gap_get_connection_type(HCI_CON_HANDLE_INVALID); 219 CHECK_EQUAL(GAP_CONNECTION_INVALID, type); 220 221 type = gap_get_connection_type(0x01); 222 CHECK_EQUAL(GAP_CONNECTION_ACL, type); 223 } 224 225 TEST(HCI, gap_le_set_phy){ 226 uint8_t status = gap_le_set_phy(HCI_CON_HANDLE_INVALID, 0, 0, 0, 0); 227 CHECK_EQUAL(ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER, status); 228 229 status = gap_le_set_phy(0x01, 0, 0, 0, 0); 230 CHECK_EQUAL(ERROR_CODE_SUCCESS, status); 231 } 232 233 TEST(HCI, hci_connection_for_bd_addr_and_type){ 234 bd_addr_type_t addr_type = BD_ADDR_TYPE_ACL; 235 bd_addr_t addr = { 0 }; 236 237 hci_connection_t * con = hci_connection_for_bd_addr_and_type(addr , addr_type); 238 CHECK_EQUAL(NULL, con); 239 } 240 241 TEST(HCI, hci_number_free_acl_slots_for_handle){ 242 int free_acl_slots_num = hci_number_free_acl_slots_for_handle(HCI_CON_HANDLE_INVALID); 243 CHECK_EQUAL(0, free_acl_slots_num); 244 } 245 246 TEST(HCI, hci_send_acl_packet_buffer){ 247 hci_reserve_packet_buffer(); 248 uint8_t status = hci_send_acl_packet_buffer(HCI_CON_HANDLE_INVALID); 249 CHECK_EQUAL(ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER, status); 250 } 251 252 TEST(HCI, hci_send_cmd_packet){ 253 bd_addr_t addr = { 0 }; 254 255 uint8_t status = hci_send_cmd(&hci_write_loopback_mode, 1); 256 CHECK_EQUAL(0, status); 257 258 uint8_t i; 259 for (i = 0; i < 3; i++){ 260 status = hci_send_cmd(&hci_le_create_connection, 261 1000, // scan interval: 625 ms 262 1000, // scan interval: 625 ms 263 i, // don't use whitelist 264 0, // peer address type: public 265 addr, // remote bd addr 266 0, // random or public 267 80, // conn interval min 268 80, // conn interval max (3200 * 0.625) 269 0, // conn latency 270 2000, // supervision timeout 271 0, // min ce length 272 1000 // max ce length 273 ); 274 CHECK_EQUAL(0, status); 275 } 276 } 277 278 TEST(HCI, hci_send_cmd_va_arg){ 279 hci_reserve_packet_buffer(); 280 uint8_t status = hci_send_cmd(&hci_write_loopback_mode, 1); 281 CHECK_EQUAL(ERROR_CODE_COMMAND_DISALLOWED, status); 282 } 283 284 TEST(HCI, hci_power_control){ 285 int status = hci_power_control(HCI_POWER_ON); 286 CHECK_EQUAL(0, status); 287 } 288 289 TEST(HCI, NumPeripherals){ 290 gap_set_max_number_peripheral_connections(1); 291 } 292 293 TEST(HCI, MaxAclLen){ 294 hci_max_acl_data_packet_length(); 295 } 296 297 TEST(HCI, Flushable){ 298 hci_non_flushable_packet_boundary_flag_supported(); 299 } 300 301 TEST(HCI, RemovePacketHandler){ 302 hci_remove_event_handler(NULL); 303 } 304 305 static void dummy_fn(const void * config){}; 306 TEST(HCI, SetChipset){ 307 hci_set_chipset(NULL); 308 btstack_chipset_t chipset_driver = { 0 }; 309 hci_set_chipset(NULL); 310 chipset_driver.init = dummy_fn; 311 } 312 313 TEST(HCI, SetControl){ 314 btstack_control_t hardware_control = { .init = &dummy_fn}; 315 hci_set_control(&hardware_control); 316 } 317 318 //TEST(HCI, Close){ 319 // hci_close(); 320 //} 321 322 TEST(HCI, SetPublicAddress){ 323 bd_addr_t addr = { 0 }; 324 hci_set_bd_addr(addr); 325 } 326 327 TEST(HCI, DisconnectSecurityBlock){ 328 hci_disconnect_security_block(HCI_CON_HANDLE_INVALID); 329 hci_disconnect_security_block(3); 330 } 331 332 TEST(HCI, SetDuplicateFilter){ 333 gap_set_scan_duplicate_filter(true); 334 } 335 336 TEST(HCI, ConnectCancel){ 337 uint8_t status; 338 status = gap_connect_with_whitelist(); 339 CHECK_EQUAL(ERROR_CODE_SUCCESS, status); 340 gap_connect_cancel(); 341 342 bd_addr_type_t addr_type = BD_ADDR_TYPE_LE_PUBLIC; 343 bd_addr_t addr = { 0 }; 344 gap_connect(addr, addr_type); 345 gap_connect_cancel(); 346 } 347 348 TEST(HCI, SetGapConnParams){ 349 gap_set_connection_parameters(0, 0, 0, 0, 0, 0, 0, 0); 350 } 351 352 TEST(HCI, UpdateConnParams){ 353 gap_update_connection_parameters(HCI_CON_HANDLE_INVALID, 0, 0, 0, 0); 354 gap_update_connection_parameters(5, 0, 0, 0, 0); 355 } 356 357 TEST(HCI, RequestConnParamUpdate){ 358 gap_request_connection_parameter_update(HCI_CON_HANDLE_INVALID, 0, 0, 0, 0); 359 gap_request_connection_parameter_update(5, 0, 0, 0, 0); 360 } 361 362 TEST(HCI, SetScanResponse){ 363 gap_scan_response_set_data(0, NULL); 364 } 365 366 TEST(HCI, SetAddrType){ 367 hci_le_set_own_address_type(0); 368 hci_le_set_own_address_type(1); 369 } 370 371 TEST(HCI, AdvEnable){ 372 gap_advertisements_enable(0); 373 gap_advertisements_enable(1); 374 } 375 376 TEST(HCI, SetRandomAddr){ 377 bd_addr_t addr = { 0 }; 378 hci_le_random_address_set(addr); 379 } 380 381 TEST(HCI, Disconnect){ 382 gap_disconnect(HCI_CON_HANDLE_INVALID); 383 gap_disconnect(5); 384 } 385 386 TEST(HCI, GetRole){ 387 gap_get_role(HCI_CON_HANDLE_INVALID); 388 gap_get_role(5); 389 } 390 TEST(HCI, hci_is_le_identity_address_type_other){ 391 hci_is_le_identity_address_type(BD_ADDR_TYPE_LE_PUBLIC_IDENTITY); 392 hci_is_le_identity_address_type(BD_ADDR_TYPE_LE_RANDOM); 393 } 394 395 TEST(HCI, hci_can_send_command_packet_now){ 396 can_send_now = 0; 397 hci_can_send_command_packet_now(); 398 can_send_now = 1; 399 hci_can_send_command_packet_now(); 400 } 401 402 TEST(HCI, hci_can_send_prepared_acl_packet_now){ 403 can_send_now = 0; 404 hci_can_send_prepared_acl_packet_now(0); 405 can_send_now = 1; 406 hci_can_send_prepared_acl_packet_now(0); 407 } 408 409 TEST(HCI, hci_can_send_acl_le_packet_now) { 410 can_send_now = 0; 411 hci_can_send_acl_le_packet_now(); 412 can_send_now = 1; 413 hci_can_send_acl_le_packet_now(); 414 } 415 416 TEST(HCI, hci_close) { 417 hci_close(); 418 } 419 420 TEST(HCI, gap_connect) { 421 bd_addr_type_t addr_type = BD_ADDR_TYPE_LE_PUBLIC; 422 bd_addr_t addr = { 0 }; 423 424 uint8_t status; 425 status = gap_connect(addr, addr_type); 426 CHECK_EQUAL(ERROR_CODE_SUCCESS, status); 427 status = gap_connect(addr, addr_type); 428 CHECK_EQUAL(ERROR_CODE_COMMAND_DISALLOWED, status); 429 } 430 431 TEST(HCI, hci_emit_state) { 432 hci_emit_state(); 433 } 434 435 TEST(HCI, gap_request_connection_subrating) { 436 int status = gap_request_connection_subrating(HCI_CON_HANDLE_INVALID, 0, 0, 0, 0, 0); 437 CHECK_EQUAL(ERROR_CODE_UNKNOWN_CONNECTION_IDENTIFIER, status); 438 status = gap_request_connection_subrating(0x01, 0, 0, 0, 0, 0); 439 CHECK_EQUAL(ERROR_CODE_SUCCESS, status); 440 } 441 442 443 TEST(HCI, hci_set_hardware_error_callback) { 444 hci_set_hardware_error_callback(NULL); 445 } 446 447 TEST(HCI, hci_disconnect_all) { 448 hci_disconnect_all(); 449 } 450 451 TEST(HCI, hci_get_manufacturer) { 452 hci_get_manufacturer(); 453 } 454 TEST(HCI, gap_authorization_state) { 455 gap_authorization_state(HCI_CON_HANDLE_INVALID); 456 } 457 #ifdef ENABLE_LE_PRIVACY_ADDRESS_RESOLUTION 458 TEST(HCI, hci_load_le_device_db_entry_into_resolving_list) { 459 hci_load_le_device_db_entry_into_resolving_list(0); 460 } 461 462 TEST(HCI, hci_remove_le_device_db_entry_from_resolving_list) { 463 hci_remove_le_device_db_entry_from_resolving_list(0); 464 } 465 466 TEST(HCI, gap_load_resolving_list_from_le_device_db) { 467 gap_load_resolving_list_from_le_device_db(); 468 } 469 #endif 470 471 TEST(HCI, gap_privacy_client) { 472 gap_privacy_client_t client; 473 gap_privacy_client_register(&client); 474 gap_privacy_client_ready(&client); 475 gap_privacy_client_unregister(&client); 476 } 477 478 int main (int argc, const char * argv[]){ 479 btstack_run_loop_init(btstack_run_loop_posix_get_instance()); 480 return CommandLineTestRunner::RunAllTests(argc, argv); 481 } 482