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
hci_transport_test_set_baudrate(uint32_t baudrate)62 static int hci_transport_test_set_baudrate(uint32_t baudrate){
63 return 0;
64 }
65
hci_transport_test_send_packet(uint8_t packet_type,uint8_t * packet,int size)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
hci_transport_test_init(const void * transport_config)75 static void hci_transport_test_init(const void * transport_config){
76 }
77
hci_transport_test_open(void)78 static int hci_transport_test_open(void){
79 return 0;
80 }
81
hci_transport_test_close(void)82 static int hci_transport_test_close(void){
83 return 0;
84 }
85
hci_transport_test_register_packet_handler(void (* handler)(uint8_t packet_type,uint8_t * packet,uint16_t size))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
CHECK_EQUAL_ARRAY(const uint8_t * expected,const uint8_t * actual,int size)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
CHECK_HCI_COMMAND(const hci_cmd_t * expected_hci_command)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
TEST_GROUP(HCI)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
TEST(HCI,GetSetConnectionRange)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
TEST(HCI,ConnectionRangeValid)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
TEST(HCI,other_functions)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
TEST(HCI,gap_whitelist_add_remove)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
TEST(HCI,gap_connect_with_whitelist)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
TEST(HCI,gap_auto_connection_start_stop)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
TEST(HCI,gap_auto_connection_stop_all)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
TEST(HCI,gap_read_rssi)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
TEST(HCI,gap_le_connection_interval)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
TEST(HCI,gap_get_connection_type)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
TEST(HCI,gap_le_set_phy)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
TEST(HCI,hci_connection_for_bd_addr_and_type)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
TEST(HCI,hci_number_free_acl_slots_for_handle)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
TEST(HCI,hci_send_acl_packet_buffer_no_connection)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
TEST(HCI,hci_send_acl_packet_buffer)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
TEST(HCI,hci_send_cmd_packet)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
TEST(HCI,hci_send_cmd_va_arg)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
TEST(HCI,hci_power_control)320 TEST(HCI, hci_power_control){
321 int status = hci_power_control(HCI_POWER_ON);
322 CHECK_EQUAL(0, status);
323 }
324
TEST(HCI,NumPeripherals)325 TEST(HCI, NumPeripherals){
326 gap_set_max_number_peripheral_connections(1);
327 }
328
TEST(HCI,MaxAclLen)329 TEST(HCI, MaxAclLen){
330 hci_max_acl_data_packet_length();
331 }
332
TEST(HCI,Flushable)333 TEST(HCI, Flushable){
334 hci_non_flushable_packet_boundary_flag_supported();
335 }
336
TEST(HCI,RemovePacketHandler)337 TEST(HCI, RemovePacketHandler){
338 hci_remove_event_handler(NULL);
339 }
340
dummy_fn(const void * config)341 static void dummy_fn(const void * config){};
TEST(HCI,SetChipset)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
TEST(HCI,SetControl)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
TEST(HCI,SetPublicAddress)358 TEST(HCI, SetPublicAddress){
359 bd_addr_t addr = { 0 };
360 hci_set_bd_addr(addr);
361 }
362
TEST(HCI,DisconnectSecurityBlock)363 TEST(HCI, DisconnectSecurityBlock){
364 hci_disconnect_security_block(HCI_CON_HANDLE_INVALID);
365 hci_disconnect_security_block(3);
366 }
367
TEST(HCI,SetDuplicateFilter)368 TEST(HCI, SetDuplicateFilter){
369 gap_set_scan_duplicate_filter(true);
370 }
371
TEST(HCI,ConnectCancel)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
TEST(HCI,SetGapConnParams)384 TEST(HCI, SetGapConnParams){
385 gap_set_connection_parameters(0, 0, 0, 0, 0, 0, 0, 0);
386 }
387
TEST(HCI,UpdateConnParams)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
TEST(HCI,RequestConnParamUpdate)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
TEST(HCI,SetScanResponse)398 TEST(HCI, SetScanResponse){
399 gap_scan_response_set_data(0, NULL);
400 }
401
TEST(HCI,SetAddrType)402 TEST(HCI, SetAddrType){
403 hci_le_set_own_address_type(0);
404 hci_le_set_own_address_type(1);
405 }
406
TEST(HCI,AdvEnable)407 TEST(HCI, AdvEnable){
408 gap_advertisements_enable(0);
409 gap_advertisements_enable(1);
410 }
411
TEST(HCI,SetRandomAddr)412 TEST(HCI, SetRandomAddr){
413 bd_addr_t addr = { 0 };
414 hci_le_random_address_set(addr);
415 }
416
TEST(HCI,Disconnect)417 TEST(HCI, Disconnect){
418 gap_disconnect(HCI_CON_HANDLE_INVALID);
419 gap_disconnect(5);
420 }
421
TEST(HCI,GetRole)422 TEST(HCI, GetRole){
423 gap_get_role(HCI_CON_HANDLE_INVALID);
424 gap_get_role(5);
425 }
TEST(HCI,hci_is_le_identity_address_type_other)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
TEST(HCI,hci_can_send_command_packet_now)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
TEST(HCI,hci_can_send_prepared_acl_packet_now)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
TEST(HCI,hci_can_send_acl_le_packet_now)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 }
TEST(HCI,hci_number_free_acl_slots_for_connection_type)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
TEST(HCI,gap_connect)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
TEST(HCI,hci_emit_state)476 TEST(HCI, hci_emit_state) {
477 hci_emit_state();
478 }
479
TEST(HCI,gap_request_connection_subrating)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
TEST(HCI,hci_set_hardware_error_callback)488 TEST(HCI, hci_set_hardware_error_callback) {
489 hci_set_hardware_error_callback(NULL);
490 }
491
TEST(HCI,hci_disconnect_all)492 TEST(HCI, hci_disconnect_all) {
493 hci_disconnect_all();
494 }
495
TEST(HCI,hci_get_manufacturer)496 TEST(HCI, hci_get_manufacturer) {
497 hci_get_manufacturer();
498 }
TEST(HCI,gap_authorization_state)499 TEST(HCI, gap_authorization_state) {
500 gap_authorization_state(HCI_CON_HANDLE_INVALID);
501 }
502 #ifdef ENABLE_LE_PRIVACY_ADDRESS_RESOLUTION
TEST(HCI,hci_load_le_device_db_entry_into_resolving_list)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
TEST(HCI,hci_remove_le_device_db_entry_from_resolving_list)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
TEST(HCI,gap_load_resolving_list_from_le_device_db)511 TEST(HCI, gap_load_resolving_list_from_le_device_db) {
512 gap_load_resolving_list_from_le_device_db();
513 }
514 #endif
515
TEST(HCI,gap_privacy_client)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
TEST(HCI,acl_handling)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 }
TEST(HCI,gap_le_get_own_address)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
simulate_hci_command_complete(uint16_t opcode,uint8_t status,uint8_t variant)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
TEST(HCI,handle_command_complete_event)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
simulate_hci_command_status(uint16_t opcode,uint8_t status,uint8_t variant)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
TEST(HCI,handle_command_status_event)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
main(int argc,const char * argv[])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