1 /*
2 * Licensed to the Apache Software Foundation (ASF) under one
3 * or more contributor license agreements. See the NOTICE file
4 * distributed with this work for additional information
5 * regarding copyright ownership. The ASF licenses this file
6 * to you under the Apache License, Version 2.0 (the
7 * "License"); you may not use this file except in compliance
8 * with the License. You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing,
13 * software distributed under the License is distributed on an
14 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15 * KIND, either express or implied. See the License for the
16 * specific language governing permissions and limitations
17 * under the License.
18 */
19
20 #include <stddef.h>
21 #include <errno.h>
22 #include <string.h>
23 #include "testutil/testutil.h"
24 #include "nimble/hci_common.h"
25 #include "host/ble_hs_adv.h"
26 #include "host/ble_hs_test.h"
27 #include "ble_hs_test_util.h"
28
29 #define BLE_ADV_TEST_DATA_OFF 4
30
31 static void
ble_hs_adv_test_misc_verify_tx_adv_data_hdr(uint8_t * cmd,int data_len)32 ble_hs_adv_test_misc_verify_tx_adv_data_hdr(uint8_t *cmd, int data_len)
33 {
34 uint16_t opcode;
35
36 opcode = get_le16(cmd + 0);
37 TEST_ASSERT(BLE_HCI_OGF(opcode) == BLE_HCI_OGF_LE);
38 TEST_ASSERT(BLE_HCI_OCF(opcode) == BLE_HCI_OCF_LE_SET_ADV_DATA);
39
40 TEST_ASSERT(cmd[2] == BLE_HCI_SET_ADV_DATA_LEN);
41 TEST_ASSERT(cmd[3] == data_len);
42 }
43
44 static void
ble_hs_adv_test_misc_verify_tx_rsp_data_hdr(uint8_t * cmd,int data_len)45 ble_hs_adv_test_misc_verify_tx_rsp_data_hdr(uint8_t *cmd, int data_len)
46 {
47 uint16_t opcode;
48
49 opcode = get_le16(cmd + 0);
50 TEST_ASSERT(BLE_HCI_OGF(opcode) == BLE_HCI_OGF_LE);
51 TEST_ASSERT(BLE_HCI_OCF(opcode) == BLE_HCI_OCF_LE_SET_SCAN_RSP_DATA);
52
53 TEST_ASSERT(cmd[2] == BLE_HCI_SET_SCAN_RSP_DATA_LEN);
54 TEST_ASSERT(cmd[3] == data_len);
55 }
56
57 static void
ble_hs_adv_test_misc_verify_tx_field(uint8_t * cmd,uint8_t type,uint8_t val_len,void * val)58 ble_hs_adv_test_misc_verify_tx_field(uint8_t *cmd, uint8_t type,
59 uint8_t val_len, void *val)
60 {
61 TEST_ASSERT(cmd[0] == val_len + 1);
62 TEST_ASSERT(cmd[1] == type);
63 TEST_ASSERT(memcmp(cmd + 2, val, val_len) == 0);
64 }
65
66 struct ble_hs_adv_test_field {
67 uint8_t type; /* 0 indicates end of array. */
68 uint8_t *val;
69 uint8_t val_len;
70 };
71
72 static int
ble_hs_adv_test_misc_calc_data_len(struct ble_hs_adv_test_field * fields)73 ble_hs_adv_test_misc_calc_data_len(struct ble_hs_adv_test_field *fields)
74 {
75 struct ble_hs_adv_test_field *field;
76 int len;
77
78 len = 0;
79 if (fields != NULL) {
80 for (field = fields; field->type != 0; field++) {
81 len += 2 + field->val_len;
82 }
83 }
84
85 return len;
86 }
87
88 static void
ble_hs_adv_test_misc_verify_tx_fields(uint8_t * cmd,struct ble_hs_adv_test_field * fields)89 ble_hs_adv_test_misc_verify_tx_fields(uint8_t *cmd,
90 struct ble_hs_adv_test_field *fields)
91 {
92 struct ble_hs_adv_test_field *field;
93
94 for (field = fields; field->type != 0; field++) {
95 ble_hs_adv_test_misc_verify_tx_field(cmd, field->type, field->val_len,
96 field->val);
97 cmd += 2 + field->val_len;
98 }
99 }
100
101 static void
ble_hs_adv_test_misc_verify_tx_adv_data(struct ble_hs_adv_test_field * fields)102 ble_hs_adv_test_misc_verify_tx_adv_data(struct ble_hs_adv_test_field *fields)
103 {
104 int data_len;
105 uint8_t *cmd;
106
107 cmd = ble_hs_test_util_hci_out_last();
108 TEST_ASSERT_FATAL(cmd != NULL);
109
110 data_len = ble_hs_adv_test_misc_calc_data_len(fields);
111 ble_hs_adv_test_misc_verify_tx_adv_data_hdr(cmd, data_len);
112 if (fields != NULL) {
113 ble_hs_adv_test_misc_verify_tx_fields(cmd + BLE_ADV_TEST_DATA_OFF,
114 fields);
115 }
116 }
117
118 static void
ble_hs_adv_test_misc_verify_tx_rsp_data(struct ble_hs_adv_test_field * fields)119 ble_hs_adv_test_misc_verify_tx_rsp_data(struct ble_hs_adv_test_field *fields)
120 {
121 int data_len;
122 uint8_t *cmd;
123
124 cmd = ble_hs_test_util_hci_out_last();
125 TEST_ASSERT_FATAL(cmd != NULL);
126
127 data_len = ble_hs_adv_test_misc_calc_data_len(fields);
128 ble_hs_adv_test_misc_verify_tx_rsp_data_hdr(cmd, data_len);
129 if (fields != NULL) {
130 ble_hs_adv_test_misc_verify_tx_fields(cmd + BLE_ADV_TEST_DATA_OFF,
131 fields);
132 }
133 }
134
135 static void
ble_hs_adv_test_misc_tx_and_verify_data(uint8_t disc_mode,struct ble_hs_adv_fields * adv_fields,struct ble_hs_adv_test_field * test_adv_fields,struct ble_hs_adv_fields * rsp_fields,struct ble_hs_adv_test_field * test_rsp_fields)136 ble_hs_adv_test_misc_tx_and_verify_data(
137 uint8_t disc_mode,
138 struct ble_hs_adv_fields *adv_fields,
139 struct ble_hs_adv_test_field *test_adv_fields,
140 struct ble_hs_adv_fields *rsp_fields,
141 struct ble_hs_adv_test_field *test_rsp_fields)
142 {
143 struct ble_gap_adv_params adv_params;
144 int rc;
145
146 ble_hs_test_util_init();
147
148 adv_params = ble_hs_test_util_adv_params;
149 adv_params.disc_mode = disc_mode;
150
151 rc = ble_hs_test_util_adv_set_fields(adv_fields, 0, 0);
152 TEST_ASSERT_FATAL(rc == 0);
153 ble_hs_adv_test_misc_verify_tx_adv_data(test_adv_fields);
154
155 if (test_rsp_fields != NULL) {
156 rc = ble_hs_test_util_adv_rsp_set_fields(rsp_fields, 0, 0);
157 TEST_ASSERT_FATAL(rc == 0);
158 ble_hs_adv_test_misc_verify_tx_rsp_data(test_rsp_fields);
159 }
160
161 rc = ble_hs_test_util_adv_start(BLE_OWN_ADDR_PUBLIC, NULL, &adv_params,
162 BLE_HS_FOREVER, NULL, NULL, 0, 0);
163 TEST_ASSERT_FATAL(rc == 0);
164
165 /* Discard the adv-enable command. */
166 ble_hs_test_util_hci_out_last();
167
168 /* Ensure the same data gets sent on repeated advertise procedures. */
169 rc = ble_hs_test_util_adv_stop(0);
170 TEST_ASSERT_FATAL(rc == 0);
171
172 rc = ble_hs_test_util_adv_start(BLE_OWN_ADDR_PUBLIC, NULL, &adv_params,
173 BLE_HS_FOREVER, NULL, NULL, 0, 0);
174 TEST_ASSERT_FATAL(rc == 0);
175
176 /* Discard the adv-enable command. */
177 ble_hs_test_util_hci_out_last();
178 }
179
TEST_CASE(ble_hs_adv_test_case_user)180 TEST_CASE(ble_hs_adv_test_case_user)
181 {
182 struct ble_hs_adv_fields adv_fields;
183 struct ble_hs_adv_fields rsp_fields;
184
185 memset(&rsp_fields, 0, sizeof rsp_fields);
186
187 /*** Complete 16-bit service class UUIDs. */
188 memset(&adv_fields, 0, sizeof adv_fields);
189 adv_fields.flags = BLE_HS_ADV_F_BREDR_UNSUP;
190 adv_fields.tx_pwr_lvl_is_present = 1;
191 adv_fields.tx_pwr_lvl = BLE_HS_ADV_TX_PWR_LVL_AUTO;
192 adv_fields.uuids16 = (ble_uuid16_t[]) {
193 BLE_UUID16_INIT(0x0001),
194 BLE_UUID16_INIT(0x1234),
195 BLE_UUID16_INIT(0x54ab)
196 };
197 adv_fields.num_uuids16 = 3;
198 adv_fields.uuids16_is_complete = 1;
199
200 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
201 (struct ble_hs_adv_test_field[]) {
202 {
203 .type = BLE_HS_ADV_TYPE_FLAGS,
204 .val = (uint8_t[]){ BLE_HS_ADV_F_BREDR_UNSUP },
205 .val_len = 1,
206 },
207 {
208 .type = BLE_HS_ADV_TYPE_COMP_UUIDS16,
209 .val = (uint8_t[]) { 0x01, 0x00, 0x34, 0x12, 0xab, 0x54 },
210 .val_len = 6,
211 },
212 {
213 .type = BLE_HS_ADV_TYPE_TX_PWR_LVL,
214 .val = (uint8_t[]){ 0 },
215 .val_len = 1,
216 },
217 { 0 },
218 }, &rsp_fields, NULL);
219
220 /*** Incomplete 16-bit service class UUIDs. */
221 memset(&adv_fields, 0, sizeof adv_fields);
222 adv_fields.flags = BLE_HS_ADV_F_BREDR_UNSUP;
223 adv_fields.tx_pwr_lvl_is_present = 1;
224 adv_fields.uuids16 = (ble_uuid16_t[]) {
225 BLE_UUID16_INIT(0x0001),
226 BLE_UUID16_INIT(0x1234),
227 BLE_UUID16_INIT(0x54ab)
228 };
229 adv_fields.num_uuids16 = 3;
230 adv_fields.uuids16_is_complete = 0;
231
232 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
233 (struct ble_hs_adv_test_field[]) {
234 {
235 .type = BLE_HS_ADV_TYPE_FLAGS,
236 .val = (uint8_t[]){ BLE_HS_ADV_F_BREDR_UNSUP },
237 .val_len = 1,
238 },
239 {
240 .type = BLE_HS_ADV_TYPE_INCOMP_UUIDS16,
241 .val = (uint8_t[]) { 0x01, 0x00, 0x34, 0x12, 0xab, 0x54 },
242 .val_len = 6,
243 },
244 {
245 .type = BLE_HS_ADV_TYPE_TX_PWR_LVL,
246 .val = (uint8_t[]){ 0 },
247 .val_len = 1,
248 },
249 { 0 },
250 }, &rsp_fields, NULL);
251
252 /*** Complete 32-bit service class UUIDs. */
253 memset(&adv_fields, 0, sizeof adv_fields);
254 adv_fields.flags = BLE_HS_ADV_F_BREDR_UNSUP;
255 adv_fields.tx_pwr_lvl_is_present = 1;
256 adv_fields.uuids32 = (ble_uuid32_t[]) {
257 BLE_UUID32_INIT(0x12345678),
258 BLE_UUID32_INIT(0xabacadae)
259 };
260 adv_fields.num_uuids32 = 2;
261 adv_fields.uuids32_is_complete = 1;
262
263 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
264 (struct ble_hs_adv_test_field[]) {
265 {
266 .type = BLE_HS_ADV_TYPE_FLAGS,
267 .val = (uint8_t[]){ BLE_HS_ADV_F_BREDR_UNSUP },
268 .val_len = 1,
269 },
270 {
271 .type = BLE_HS_ADV_TYPE_COMP_UUIDS32,
272 .val = (uint8_t[]) { 0x78,0x56,0x34,0x12,0xae,0xad,0xac,0xab },
273 .val_len = 8,
274 },
275 {
276 .type = BLE_HS_ADV_TYPE_TX_PWR_LVL,
277 .val = (uint8_t[]){ 0 },
278 .val_len = 1,
279 },
280 { 0 },
281 }, &rsp_fields, NULL);
282
283 /*** Incomplete 32-bit service class UUIDs. */
284 memset(&adv_fields, 0, sizeof adv_fields);
285 adv_fields.flags = BLE_HS_ADV_F_BREDR_UNSUP;
286 adv_fields.tx_pwr_lvl_is_present = 1;
287 adv_fields.uuids32 = (ble_uuid32_t[]) {
288 BLE_UUID32_INIT(0x12345678),
289 BLE_UUID32_INIT(0xabacadae)
290 };
291 adv_fields.num_uuids32 = 2;
292 adv_fields.uuids32_is_complete = 0;
293
294 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
295 (struct ble_hs_adv_test_field[]) {
296 {
297 .type = BLE_HS_ADV_TYPE_FLAGS,
298 .val = (uint8_t[]){ BLE_HS_ADV_F_BREDR_UNSUP },
299 .val_len = 1,
300 },
301 {
302 .type = BLE_HS_ADV_TYPE_INCOMP_UUIDS32,
303 .val = (uint8_t[]) { 0x78,0x56,0x34,0x12,0xae,0xad,0xac,0xab },
304 .val_len = 8,
305 },
306 {
307 .type = BLE_HS_ADV_TYPE_TX_PWR_LVL,
308 .val = (uint8_t[]){ 0 },
309 .val_len = 1,
310 },
311 { 0 },
312 }, &rsp_fields, NULL);
313
314 /*** Complete 128-bit service class UUIDs. */
315 memset(&adv_fields, 0, sizeof adv_fields);
316 adv_fields.flags = BLE_HS_ADV_F_BREDR_UNSUP;
317 adv_fields.tx_pwr_lvl_is_present = 1;
318 adv_fields.uuids128 = (ble_uuid128_t[]) {
319 BLE_UUID128_INIT(0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
320 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff)
321 };
322 adv_fields.num_uuids128 = 1;
323 adv_fields.uuids128_is_complete = 1;
324
325 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
326 (struct ble_hs_adv_test_field[]) {
327 {
328 .type = BLE_HS_ADV_TYPE_FLAGS,
329 .val = (uint8_t[]){ BLE_HS_ADV_F_BREDR_UNSUP },
330 .val_len = 1,
331 },
332 {
333 .type = BLE_HS_ADV_TYPE_COMP_UUIDS128,
334 .val = (uint8_t[]) {
335 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
336 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
337 },
338 .val_len = 16,
339 },
340 {
341 .type = BLE_HS_ADV_TYPE_TX_PWR_LVL,
342 .val = (uint8_t[]){ 0 },
343 .val_len = 1,
344 },
345 { 0 },
346 }, &rsp_fields, NULL);
347
348 /*** Incomplete 128-bit service class UUIDs. */
349 memset(&adv_fields, 0, sizeof adv_fields);
350 adv_fields.flags = BLE_HS_ADV_F_BREDR_UNSUP;
351 adv_fields.tx_pwr_lvl_is_present = 1;
352 adv_fields.uuids128 = BLE_UUID128(BLE_UUID128_DECLARE(
353 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
354 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
355 ));
356 adv_fields.num_uuids128 = 1;
357 adv_fields.uuids128_is_complete = 0;
358
359 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
360 (struct ble_hs_adv_test_field[]) {
361 {
362 .type = BLE_HS_ADV_TYPE_FLAGS,
363 .val = (uint8_t[]){ BLE_HS_ADV_F_BREDR_UNSUP },
364 .val_len = 1,
365 },
366 {
367 .type = BLE_HS_ADV_TYPE_INCOMP_UUIDS128,
368 .val = (uint8_t[]) {
369 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
370 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
371 },
372 .val_len = 16,
373 },
374 {
375 .type = BLE_HS_ADV_TYPE_TX_PWR_LVL,
376 .val = (uint8_t[]){ 0 },
377 .val_len = 1,
378 },
379 { 0 },
380 }, &rsp_fields, NULL);
381
382 /*** Complete name. */
383 memset(&adv_fields, 0, sizeof adv_fields);
384 adv_fields.flags = BLE_HS_ADV_F_BREDR_UNSUP;
385 adv_fields.tx_pwr_lvl_is_present = 1;
386 adv_fields.name = (uint8_t *)"myname";
387 adv_fields.name_len = 6;
388 adv_fields.name_is_complete = 1;
389
390 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
391 (struct ble_hs_adv_test_field[]) {
392 {
393 .type = BLE_HS_ADV_TYPE_FLAGS,
394 .val = (uint8_t[]){ BLE_HS_ADV_F_BREDR_UNSUP },
395 .val_len = 1,
396 },
397 {
398 .type = BLE_HS_ADV_TYPE_COMP_NAME,
399 .val = (uint8_t*)"myname",
400 .val_len = 6,
401 },
402 {
403 .type = BLE_HS_ADV_TYPE_TX_PWR_LVL,
404 .val = (uint8_t[]){ 0 },
405 .val_len = 1,
406 },
407 { 0 },
408 }, &rsp_fields, NULL);
409
410 /*** Incomplete name. */
411 memset(&adv_fields, 0, sizeof adv_fields);
412 adv_fields.flags = BLE_HS_ADV_F_BREDR_UNSUP;
413 adv_fields.tx_pwr_lvl_is_present = 1;
414 adv_fields.name = (uint8_t *)"myname";
415 adv_fields.name_len = 6;
416 adv_fields.name_is_complete = 0;
417
418 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
419 (struct ble_hs_adv_test_field[]) {
420 {
421 .type = BLE_HS_ADV_TYPE_FLAGS,
422 .val = (uint8_t[]){ BLE_HS_ADV_F_BREDR_UNSUP },
423 .val_len = 1,
424 },
425 {
426 .type = BLE_HS_ADV_TYPE_INCOMP_NAME,
427 .val = (uint8_t*)"myname",
428 .val_len = 6,
429 },
430 {
431 .type = BLE_HS_ADV_TYPE_TX_PWR_LVL,
432 .val = (uint8_t[]){ 0 },
433 .val_len = 1,
434 },
435 { 0 },
436 }, &rsp_fields, NULL);
437
438 /*** Slave interval range. */
439 memset(&adv_fields, 0, sizeof adv_fields);
440 adv_fields.flags = BLE_HS_ADV_F_BREDR_UNSUP;
441 adv_fields.tx_pwr_lvl_is_present = 1;
442 adv_fields.slave_itvl_range = (uint8_t[]){ 1,2,3,4 };
443
444 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
445 (struct ble_hs_adv_test_field[]) {
446 {
447 .type = BLE_HS_ADV_TYPE_FLAGS,
448 .val = (uint8_t[]){ BLE_HS_ADV_F_BREDR_UNSUP },
449 .val_len = 1,
450 },
451 {
452 .type = BLE_HS_ADV_TYPE_TX_PWR_LVL,
453 .val = (uint8_t[]){ 0 },
454 .val_len = 1,
455 },
456 {
457 .type = BLE_HS_ADV_TYPE_SLAVE_ITVL_RANGE,
458 .val = (uint8_t[]) { 1,2,3,4 },
459 .val_len = BLE_HS_ADV_SLAVE_ITVL_RANGE_LEN,
460 },
461 { 0 },
462 }, &rsp_fields, NULL);
463
464 /*** 0x16 - Service data - 16-bit UUID. */
465 memset(&adv_fields, 0, sizeof adv_fields);
466 adv_fields.flags = BLE_HS_ADV_F_BREDR_UNSUP;
467 adv_fields.tx_pwr_lvl_is_present = 1;
468 adv_fields.svc_data_uuid16 = (uint8_t[]){ 1,2,3,4 };
469 adv_fields.svc_data_uuid16_len = 4;
470
471 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
472 (struct ble_hs_adv_test_field[]) {
473 {
474 .type = BLE_HS_ADV_TYPE_FLAGS,
475 .val = (uint8_t[]){ BLE_HS_ADV_F_BREDR_UNSUP },
476 .val_len = 1,
477 },
478 {
479 .type = BLE_HS_ADV_TYPE_TX_PWR_LVL,
480 .val = (uint8_t[]){ 0 },
481 .val_len = 1,
482 },
483 {
484 .type = BLE_HS_ADV_TYPE_SVC_DATA_UUID16,
485 .val = (uint8_t[]) { 1,2,3,4 },
486 .val_len = 4,
487 },
488 { 0 },
489 }, &rsp_fields, NULL);
490
491 /*** 0x17 - Public target address. */
492 memset(&adv_fields, 0, sizeof adv_fields);
493 adv_fields.flags = BLE_HS_ADV_F_BREDR_UNSUP;
494 adv_fields.tx_pwr_lvl_is_present = 1;
495 adv_fields.public_tgt_addr = (uint8_t[]){ 1,2,3,4,5,6, 6,5,4,3,2,1 };
496 adv_fields.num_public_tgt_addrs = 2;
497
498 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
499 (struct ble_hs_adv_test_field[]) {
500 {
501 .type = BLE_HS_ADV_TYPE_FLAGS,
502 .val = (uint8_t[]){ BLE_HS_ADV_F_BREDR_UNSUP },
503 .val_len = 1,
504 },
505 {
506 .type = BLE_HS_ADV_TYPE_TX_PWR_LVL,
507 .val = (uint8_t[]){ 0 },
508 .val_len = 1,
509 },
510 {
511 .type = BLE_HS_ADV_TYPE_PUBLIC_TGT_ADDR,
512 .val = (uint8_t[]){ 1,2,3,4,5,6, 6,5,4,3,2,1 },
513 .val_len = 2 * BLE_HS_ADV_PUBLIC_TGT_ADDR_ENTRY_LEN,
514 },
515 { 0 },
516 }, &rsp_fields, NULL);
517
518 /*** 0x19 - Appearance. */
519 memset(&adv_fields, 0, sizeof adv_fields);
520 adv_fields.flags = BLE_HS_ADV_F_BREDR_UNSUP;
521 adv_fields.tx_pwr_lvl_is_present = 1;
522 adv_fields.appearance = 0x1234;
523 adv_fields.appearance_is_present = 1;
524
525 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
526 (struct ble_hs_adv_test_field[]) {
527 {
528 .type = BLE_HS_ADV_TYPE_FLAGS,
529 .val = (uint8_t[]){ BLE_HS_ADV_F_BREDR_UNSUP },
530 .val_len = 1,
531 },
532 {
533 .type = BLE_HS_ADV_TYPE_TX_PWR_LVL,
534 .val = (uint8_t[]){ 0 },
535 .val_len = 1,
536 },
537 {
538 .type = BLE_HS_ADV_TYPE_APPEARANCE,
539 .val = (uint8_t[]){ 0x34, 0x12 },
540 .val_len = BLE_HS_ADV_APPEARANCE_LEN,
541 },
542 { 0 },
543 }, &rsp_fields, NULL);
544
545 /*** 0x1a - Advertising interval. */
546 memset(&adv_fields, 0, sizeof adv_fields);
547 adv_fields.flags = BLE_HS_ADV_F_BREDR_UNSUP;
548 adv_fields.tx_pwr_lvl_is_present = 1;
549 adv_fields.adv_itvl = 0x1234;
550 adv_fields.adv_itvl_is_present = 1;
551
552 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
553 (struct ble_hs_adv_test_field[]) {
554 {
555 .type = BLE_HS_ADV_TYPE_FLAGS,
556 .val = (uint8_t[]){ BLE_HS_ADV_F_BREDR_UNSUP },
557 .val_len = 1,
558 },
559 {
560 .type = BLE_HS_ADV_TYPE_TX_PWR_LVL,
561 .val = (uint8_t[]){ 0 },
562 .val_len = 1,
563 },
564 {
565 .type = BLE_HS_ADV_TYPE_ADV_ITVL,
566 .val = (uint8_t[]){ 0x34, 0x12 },
567 .val_len = BLE_HS_ADV_ADV_ITVL_LEN,
568 },
569 { 0 },
570 }, &rsp_fields, NULL);
571
572 /*** 0x20 - Service data - 32-bit UUID. */
573 memset(&adv_fields, 0, sizeof adv_fields);
574 adv_fields.flags = BLE_HS_ADV_F_BREDR_UNSUP;
575 adv_fields.tx_pwr_lvl_is_present = 1;
576 adv_fields.svc_data_uuid32 = (uint8_t[]){ 1,2,3,4,5 };
577 adv_fields.svc_data_uuid32_len = 5;
578
579 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
580 (struct ble_hs_adv_test_field[]) {
581 {
582 .type = BLE_HS_ADV_TYPE_FLAGS,
583 .val = (uint8_t[]){ BLE_HS_ADV_F_BREDR_UNSUP },
584 .val_len = 1,
585 },
586 {
587 .type = BLE_HS_ADV_TYPE_TX_PWR_LVL,
588 .val = (uint8_t[]){ 0 },
589 .val_len = 1,
590 },
591 {
592 .type = BLE_HS_ADV_TYPE_SVC_DATA_UUID32,
593 .val = (uint8_t[]) { 1,2,3,4,5 },
594 .val_len = 5,
595 },
596 { 0 },
597 }, &rsp_fields, NULL);
598
599 /*** 0x21 - Service data - 128-bit UUID. */
600 memset(&adv_fields, 0, sizeof adv_fields);
601 adv_fields.flags = BLE_HS_ADV_F_BREDR_UNSUP;
602 adv_fields.tx_pwr_lvl_is_present = 1;
603 adv_fields.svc_data_uuid128 =
604 (uint8_t[]){ 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18 };
605 adv_fields.svc_data_uuid128_len = 18;
606
607 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
608 (struct ble_hs_adv_test_field[]) {
609 {
610 .type = BLE_HS_ADV_TYPE_FLAGS,
611 .val = (uint8_t[]){ BLE_HS_ADV_F_BREDR_UNSUP },
612 .val_len = 1,
613 },
614 {
615 .type = BLE_HS_ADV_TYPE_TX_PWR_LVL,
616 .val = (uint8_t[]){ 0 },
617 .val_len = 1,
618 },
619 {
620 .type = BLE_HS_ADV_TYPE_SVC_DATA_UUID128,
621 .val = (uint8_t[]){ 1,2,3,4,5,6,7,8,9,10,
622 11,12,13,14,15,16,17,18 },
623 .val_len = 18,
624 },
625 { 0 },
626 }, &rsp_fields, NULL);
627
628 /*** 0x24 - URI. */
629 memset(&adv_fields, 0, sizeof adv_fields);
630 adv_fields.flags = BLE_HS_ADV_F_BREDR_UNSUP;
631 adv_fields.tx_pwr_lvl_is_present = 1;
632 adv_fields.uri = (uint8_t[]){ 1,2,3,4 };
633 adv_fields.uri_len = 4;
634
635 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
636 (struct ble_hs_adv_test_field[]) {
637 {
638 .type = BLE_HS_ADV_TYPE_FLAGS,
639 .val = (uint8_t[]){ BLE_HS_ADV_F_BREDR_UNSUP },
640 .val_len = 1,
641 },
642 {
643 .type = BLE_HS_ADV_TYPE_TX_PWR_LVL,
644 .val = (uint8_t[]){ 0 },
645 .val_len = 1,
646 },
647 {
648 .type = BLE_HS_ADV_TYPE_URI,
649 .val = (uint8_t[]) { 1,2,3,4 },
650 .val_len = 4,
651 },
652 { 0 },
653 }, &rsp_fields, NULL);
654
655 /*** 0xff - Manufacturer specific data. */
656 memset(&adv_fields, 0, sizeof adv_fields);
657 adv_fields.flags = BLE_HS_ADV_F_BREDR_UNSUP;
658 adv_fields.tx_pwr_lvl_is_present = 1;
659 adv_fields.mfg_data = (uint8_t[]){ 1,2,3,4 };
660 adv_fields.mfg_data_len = 4;
661
662 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
663 (struct ble_hs_adv_test_field[]) {
664 {
665 .type = BLE_HS_ADV_TYPE_FLAGS,
666 .val = (uint8_t[]){ BLE_HS_ADV_F_BREDR_UNSUP },
667 .val_len = 1,
668 },
669 {
670 .type = BLE_HS_ADV_TYPE_TX_PWR_LVL,
671 .val = (uint8_t[]){ 0 },
672 .val_len = 1,
673 },
674 {
675 .type = BLE_HS_ADV_TYPE_MFG_DATA,
676 .val = (uint8_t[]) { 1,2,3,4 },
677 .val_len = 4,
678 },
679 { 0 },
680 }, &rsp_fields, NULL);
681 }
682
TEST_CASE(ble_hs_adv_test_case_user_rsp)683 TEST_CASE(ble_hs_adv_test_case_user_rsp)
684 {
685 struct ble_hs_adv_fields rsp_fields;
686 struct ble_hs_adv_fields adv_fields;
687
688 memset(&adv_fields, 0, sizeof adv_fields);
689 adv_fields.flags = BLE_HS_ADV_F_BREDR_UNSUP;
690 adv_fields.tx_pwr_lvl_is_present = 1;
691
692 /*** Complete 16-bit service class UUIDs. */
693 memset(&rsp_fields, 0, sizeof rsp_fields);
694 rsp_fields.uuids16 = (ble_uuid16_t[]) {
695 BLE_UUID16_INIT(0x0001),
696 BLE_UUID16_INIT(0x1234),
697 BLE_UUID16_INIT(0x54ab)
698 };
699 rsp_fields.num_uuids16 = 3;
700 rsp_fields.uuids16_is_complete = 1;
701
702 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
703 (struct ble_hs_adv_test_field[]) {
704 {
705 .type = BLE_HS_ADV_TYPE_FLAGS,
706 .val = (uint8_t[]){ BLE_HS_ADV_F_BREDR_UNSUP },
707 .val_len = 1,
708 },
709 {
710 .type = BLE_HS_ADV_TYPE_TX_PWR_LVL,
711 .val = (uint8_t[]){ 0 },
712 .val_len = 1,
713 },
714 { 0 },
715 },
716 &rsp_fields,
717 (struct ble_hs_adv_test_field[]) {
718 {
719 .type = BLE_HS_ADV_TYPE_COMP_UUIDS16,
720 .val = (uint8_t[]) { 0x01, 0x00, 0x34, 0x12, 0xab, 0x54 },
721 .val_len = 6,
722 },
723 { 0 },
724 });
725
726 /*** Incomplete 16-bit service class UUIDs. */
727 memset(&rsp_fields, 0, sizeof rsp_fields);
728 rsp_fields.uuids16 = (ble_uuid16_t[]) {
729 BLE_UUID16_INIT(0x0001),
730 BLE_UUID16_INIT(0x1234),
731 BLE_UUID16_INIT(0x54ab)
732 };
733 rsp_fields.num_uuids16 = 3;
734 rsp_fields.uuids16_is_complete = 0;
735
736 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
737 (struct ble_hs_adv_test_field[]) {
738 {
739 .type = BLE_HS_ADV_TYPE_FLAGS,
740 .val = (uint8_t[]){ BLE_HS_ADV_F_BREDR_UNSUP },
741 .val_len = 1,
742 },
743 {
744 .type = BLE_HS_ADV_TYPE_TX_PWR_LVL,
745 .val = (uint8_t[]){ 0 },
746 .val_len = 1,
747 },
748 { 0 },
749 },
750 &rsp_fields,
751 (struct ble_hs_adv_test_field[]) {
752 {
753 .type = BLE_HS_ADV_TYPE_INCOMP_UUIDS16,
754 .val = (uint8_t[]) { 0x01, 0x00, 0x34, 0x12, 0xab, 0x54 },
755 .val_len = 6,
756 },
757 { 0 },
758 });
759
760 /*** Complete 32-bit service class UUIDs. */
761 memset(&rsp_fields, 0, sizeof rsp_fields);
762 rsp_fields.uuids32 = (ble_uuid32_t[]) {
763 BLE_UUID32_INIT(0x12345678),
764 BLE_UUID32_INIT(0xabacadae)
765 };
766 rsp_fields.num_uuids32 = 2;
767 rsp_fields.uuids32_is_complete = 1;
768
769 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
770 (struct ble_hs_adv_test_field[]) {
771 {
772 .type = BLE_HS_ADV_TYPE_FLAGS,
773 .val = (uint8_t[]){ BLE_HS_ADV_F_BREDR_UNSUP },
774 .val_len = 1,
775 },
776 {
777 .type = BLE_HS_ADV_TYPE_TX_PWR_LVL,
778 .val = (uint8_t[]){ 0 },
779 .val_len = 1,
780 },
781 { 0 },
782 },
783 &rsp_fields,
784 (struct ble_hs_adv_test_field[]) {
785 {
786 .type = BLE_HS_ADV_TYPE_COMP_UUIDS32,
787 .val = (uint8_t[]) { 0x78,0x56,0x34,0x12,0xae,0xad,0xac,0xab },
788 .val_len = 8,
789 },
790 { 0 },
791 });
792
793 /*** Incomplete 32-bit service class UUIDs. */
794 memset(&rsp_fields, 0, sizeof rsp_fields);
795 rsp_fields.uuids32 = (ble_uuid32_t[]) {
796 BLE_UUID32_INIT(0x12345678),
797 BLE_UUID32_INIT(0xabacadae)
798 };
799 rsp_fields.num_uuids32 = 2;
800 rsp_fields.uuids32_is_complete = 0;
801
802 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
803 (struct ble_hs_adv_test_field[]) {
804 {
805 .type = BLE_HS_ADV_TYPE_FLAGS,
806 .val = (uint8_t[]){ BLE_HS_ADV_F_BREDR_UNSUP },
807 .val_len = 1,
808 },
809 {
810 .type = BLE_HS_ADV_TYPE_TX_PWR_LVL,
811 .val = (uint8_t[]){ 0 },
812 .val_len = 1,
813 },
814 { 0 },
815 },
816 &rsp_fields,
817 (struct ble_hs_adv_test_field[]) {
818 {
819 .type = BLE_HS_ADV_TYPE_INCOMP_UUIDS32,
820 .val = (uint8_t[]) { 0x78,0x56,0x34,0x12,0xae,0xad,0xac,0xab },
821 .val_len = 8,
822 },
823 { 0 },
824 });
825
826 /*** Complete 128-bit service class UUIDs. */
827 memset(&rsp_fields, 0, sizeof rsp_fields);
828 rsp_fields.uuids128 = (ble_uuid128_t[]) {
829 BLE_UUID128_INIT(0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
830 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff)
831 };
832 rsp_fields.num_uuids128 = 1;
833 rsp_fields.uuids128_is_complete = 1;
834
835 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
836 (struct ble_hs_adv_test_field[]) {
837 {
838 .type = BLE_HS_ADV_TYPE_FLAGS,
839 .val = (uint8_t[]){ BLE_HS_ADV_F_BREDR_UNSUP },
840 .val_len = 1,
841 },
842 {
843 .type = BLE_HS_ADV_TYPE_TX_PWR_LVL,
844 .val = (uint8_t[]){ 0 },
845 .val_len = 1,
846 },
847 { 0 },
848 },
849 &rsp_fields,
850 (struct ble_hs_adv_test_field[]) {
851 {
852 .type = BLE_HS_ADV_TYPE_COMP_UUIDS128,
853 .val = (uint8_t[]) {
854 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
855 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
856 },
857 .val_len = 16,
858 },
859 { 0 },
860 });
861
862 /*** Incomplete 128-bit service class UUIDs. */
863 memset(&rsp_fields, 0, sizeof rsp_fields);
864 rsp_fields.uuids128 = (ble_uuid128_t[]) {
865 BLE_UUID128_INIT(0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
866 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff)
867 };
868 rsp_fields.num_uuids128 = 1;
869 rsp_fields.uuids128_is_complete = 0;
870
871 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
872 (struct ble_hs_adv_test_field[]) {
873 {
874 .type = BLE_HS_ADV_TYPE_FLAGS,
875 .val = (uint8_t[]){ BLE_HS_ADV_F_BREDR_UNSUP },
876 .val_len = 1,
877 },
878 {
879 .type = BLE_HS_ADV_TYPE_TX_PWR_LVL,
880 .val = (uint8_t[]){ 0 },
881 .val_len = 1,
882 },
883 { 0 },
884 },
885 &rsp_fields,
886 (struct ble_hs_adv_test_field[]) {
887 {
888 .type = BLE_HS_ADV_TYPE_INCOMP_UUIDS128,
889 .val = (uint8_t[]) {
890 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
891 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
892 },
893 .val_len = 16,
894 },
895 { 0 },
896 });
897
898 /*** Complete name. */
899 memset(&rsp_fields, 0, sizeof rsp_fields);
900 rsp_fields.name = (uint8_t *)"myname";
901 rsp_fields.name_len = 6;
902 rsp_fields.name_is_complete = 1;
903
904 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
905 (struct ble_hs_adv_test_field[]) {
906 {
907 .type = BLE_HS_ADV_TYPE_FLAGS,
908 .val = (uint8_t[]){ BLE_HS_ADV_F_BREDR_UNSUP },
909 .val_len = 1,
910 },
911 {
912 .type = BLE_HS_ADV_TYPE_TX_PWR_LVL,
913 .val = (uint8_t[]){ 0 },
914 .val_len = 1,
915 },
916 { 0 },
917 },
918 &rsp_fields,
919 (struct ble_hs_adv_test_field[]) {
920 {
921 .type = BLE_HS_ADV_TYPE_COMP_NAME,
922 .val = (uint8_t*)"myname",
923 .val_len = 6,
924 },
925 { 0 },
926 });
927
928 /*** Incomplete name. */
929 memset(&rsp_fields, 0, sizeof rsp_fields);
930 rsp_fields.name = (uint8_t *)"myname";
931 rsp_fields.name_len = 6;
932 rsp_fields.name_is_complete = 0;
933
934 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
935 (struct ble_hs_adv_test_field[]) {
936 {
937 .type = BLE_HS_ADV_TYPE_FLAGS,
938 .val = (uint8_t[]){ BLE_HS_ADV_F_BREDR_UNSUP },
939 .val_len = 1,
940 },
941 {
942 .type = BLE_HS_ADV_TYPE_TX_PWR_LVL,
943 .val = (uint8_t[]){ 0 },
944 .val_len = 1,
945 },
946 { 0 },
947 },
948 &rsp_fields,
949 (struct ble_hs_adv_test_field[]) {
950 {
951 .type = BLE_HS_ADV_TYPE_INCOMP_NAME,
952 .val = (uint8_t*)"myname",
953 .val_len = 6,
954 },
955 { 0 },
956 });
957
958 /*** Slave interval range. */
959 memset(&rsp_fields, 0, sizeof rsp_fields);
960 rsp_fields.slave_itvl_range = (uint8_t[]){ 1,2,3,4 };
961
962 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
963 (struct ble_hs_adv_test_field[]) {
964 {
965 .type = BLE_HS_ADV_TYPE_FLAGS,
966 .val = (uint8_t[]){ BLE_HS_ADV_F_BREDR_UNSUP },
967 .val_len = 1,
968 },
969 {
970 .type = BLE_HS_ADV_TYPE_TX_PWR_LVL,
971 .val = (uint8_t[]){ 0 },
972 .val_len = 1,
973 },
974 { 0 },
975 },
976 &rsp_fields,
977 (struct ble_hs_adv_test_field[]) {
978 {
979 .type = BLE_HS_ADV_TYPE_SLAVE_ITVL_RANGE,
980 .val = (uint8_t[]) { 1,2,3,4 },
981 .val_len = BLE_HS_ADV_SLAVE_ITVL_RANGE_LEN,
982 },
983 { 0 },
984 });
985
986 /*** 0x16 - Service data - 16-bit UUID. */
987 memset(&rsp_fields, 0, sizeof rsp_fields);
988 rsp_fields.svc_data_uuid16 = (uint8_t[]){ 1,2,3,4 };
989 rsp_fields.svc_data_uuid16_len = 4;
990
991 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
992 (struct ble_hs_adv_test_field[]) {
993 {
994 .type = BLE_HS_ADV_TYPE_FLAGS,
995 .val = (uint8_t[]){ BLE_HS_ADV_F_BREDR_UNSUP },
996 .val_len = 1,
997 },
998 {
999 .type = BLE_HS_ADV_TYPE_TX_PWR_LVL,
1000 .val = (uint8_t[]){ 0 },
1001 .val_len = 1,
1002 },
1003 { 0 },
1004 },
1005 &rsp_fields,
1006 (struct ble_hs_adv_test_field[]) {
1007 {
1008 .type = BLE_HS_ADV_TYPE_SVC_DATA_UUID16,
1009 .val = (uint8_t[]) { 1,2,3,4 },
1010 .val_len = 4,
1011 },
1012 { 0 },
1013 });
1014
1015 /*** 0x17 - Public target address. */
1016 memset(&rsp_fields, 0, sizeof rsp_fields);
1017 rsp_fields.public_tgt_addr = (uint8_t[]){ 1,2,3,4,5,6, 6,5,4,3,2,1 };
1018 rsp_fields.num_public_tgt_addrs = 2;
1019
1020 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
1021 (struct ble_hs_adv_test_field[]) {
1022 {
1023 .type = BLE_HS_ADV_TYPE_FLAGS,
1024 .val = (uint8_t[]){ BLE_HS_ADV_F_BREDR_UNSUP },
1025 .val_len = 1,
1026 },
1027 {
1028 .type = BLE_HS_ADV_TYPE_TX_PWR_LVL,
1029 .val = (uint8_t[]){ 0 },
1030 .val_len = 1,
1031 },
1032 { 0 },
1033 },
1034 &rsp_fields,
1035 (struct ble_hs_adv_test_field[]) {
1036 {
1037 .type = BLE_HS_ADV_TYPE_PUBLIC_TGT_ADDR,
1038 .val = (uint8_t[]){ 1,2,3,4,5,6, 6,5,4,3,2,1 },
1039 .val_len = 2 * BLE_HS_ADV_PUBLIC_TGT_ADDR_ENTRY_LEN,
1040 },
1041 { 0 },
1042 });
1043
1044 /*** 0x19 - Appearance. */
1045 memset(&rsp_fields, 0, sizeof rsp_fields);
1046 rsp_fields.appearance = 0x1234;
1047 rsp_fields.appearance_is_present = 1;
1048
1049 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
1050 (struct ble_hs_adv_test_field[]) {
1051 {
1052 .type = BLE_HS_ADV_TYPE_FLAGS,
1053 .val = (uint8_t[]){ BLE_HS_ADV_F_BREDR_UNSUP },
1054 .val_len = 1,
1055 },
1056 {
1057 .type = BLE_HS_ADV_TYPE_TX_PWR_LVL,
1058 .val = (uint8_t[]){ 0 },
1059 .val_len = 1,
1060 },
1061 { 0 },
1062 },
1063 &rsp_fields,
1064 (struct ble_hs_adv_test_field[]) {
1065 {
1066 .type = BLE_HS_ADV_TYPE_APPEARANCE,
1067 .val = (uint8_t[]){ 0x34, 0x12 },
1068 .val_len = BLE_HS_ADV_APPEARANCE_LEN,
1069 },
1070 { 0 },
1071 });
1072
1073 /*** 0x1a - Advertising interval. */
1074 memset(&rsp_fields, 0, sizeof rsp_fields);
1075 rsp_fields.adv_itvl = 0x1234;
1076 rsp_fields.adv_itvl_is_present = 1;
1077
1078 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
1079 (struct ble_hs_adv_test_field[]) {
1080 {
1081 .type = BLE_HS_ADV_TYPE_FLAGS,
1082 .val = (uint8_t[]){ BLE_HS_ADV_F_BREDR_UNSUP },
1083 .val_len = 1,
1084 },
1085 {
1086 .type = BLE_HS_ADV_TYPE_TX_PWR_LVL,
1087 .val = (uint8_t[]){ 0 },
1088 .val_len = 1,
1089 },
1090 { 0 },
1091 },
1092 &rsp_fields,
1093 (struct ble_hs_adv_test_field[]) {
1094 {
1095 .type = BLE_HS_ADV_TYPE_ADV_ITVL,
1096 .val = (uint8_t[]){ 0x34, 0x12 },
1097 .val_len = BLE_HS_ADV_ADV_ITVL_LEN,
1098 },
1099 { 0 },
1100 });
1101
1102 /*** 0x20 - Service data - 32-bit UUID. */
1103 memset(&rsp_fields, 0, sizeof rsp_fields);
1104 rsp_fields.svc_data_uuid32 = (uint8_t[]){ 1,2,3,4,5 };
1105 rsp_fields.svc_data_uuid32_len = 5;
1106
1107 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
1108 (struct ble_hs_adv_test_field[]) {
1109 {
1110 .type = BLE_HS_ADV_TYPE_FLAGS,
1111 .val = (uint8_t[]){ BLE_HS_ADV_F_BREDR_UNSUP },
1112 .val_len = 1,
1113 },
1114 {
1115 .type = BLE_HS_ADV_TYPE_TX_PWR_LVL,
1116 .val = (uint8_t[]){ 0 },
1117 .val_len = 1,
1118 },
1119 { 0 },
1120 },
1121 &rsp_fields,
1122 (struct ble_hs_adv_test_field[]) {
1123 {
1124 .type = BLE_HS_ADV_TYPE_SVC_DATA_UUID32,
1125 .val = (uint8_t[]) { 1,2,3,4,5 },
1126 .val_len = 5,
1127 },
1128 { 0 },
1129 });
1130
1131 /*** 0x21 - Service data - 128-bit UUID. */
1132 memset(&rsp_fields, 0, sizeof rsp_fields);
1133 rsp_fields.svc_data_uuid128 =
1134 (uint8_t[]){ 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18 };
1135 rsp_fields.svc_data_uuid128_len = 18;
1136
1137 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
1138 (struct ble_hs_adv_test_field[]) {
1139 {
1140 .type = BLE_HS_ADV_TYPE_FLAGS,
1141 .val = (uint8_t[]){ BLE_HS_ADV_F_BREDR_UNSUP },
1142 .val_len = 1,
1143 },
1144 {
1145 .type = BLE_HS_ADV_TYPE_TX_PWR_LVL,
1146 .val = (uint8_t[]){ 0 },
1147 .val_len = 1,
1148 },
1149 { 0 },
1150 },
1151 &rsp_fields,
1152 (struct ble_hs_adv_test_field[]) {
1153 {
1154 .type = BLE_HS_ADV_TYPE_SVC_DATA_UUID128,
1155 .val = (uint8_t[]){ 1,2,3,4,5,6,7,8,9,10,
1156 11,12,13,14,15,16,17,18 },
1157 .val_len = 18,
1158 },
1159 { 0 },
1160 });
1161
1162 /*** 0x24 - URI. */
1163 memset(&rsp_fields, 0, sizeof rsp_fields);
1164 rsp_fields.uri = (uint8_t[]){ 1,2,3,4 };
1165 rsp_fields.uri_len = 4;
1166
1167 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
1168 (struct ble_hs_adv_test_field[]) {
1169 {
1170 .type = BLE_HS_ADV_TYPE_FLAGS,
1171 .val = (uint8_t[]){ BLE_HS_ADV_F_BREDR_UNSUP },
1172 .val_len = 1,
1173 },
1174 {
1175 .type = BLE_HS_ADV_TYPE_TX_PWR_LVL,
1176 .val = (uint8_t[]){ 0 },
1177 .val_len = 1,
1178 },
1179 { 0 },
1180 },
1181 &rsp_fields,
1182 (struct ble_hs_adv_test_field[]) {
1183 {
1184 .type = BLE_HS_ADV_TYPE_URI,
1185 .val = (uint8_t[]) { 1,2,3,4 },
1186 .val_len = 4,
1187 },
1188 { 0 },
1189 });
1190
1191 /*** 0xff - Manufacturer specific data. */
1192 memset(&rsp_fields, 0, sizeof rsp_fields);
1193 rsp_fields.mfg_data = (uint8_t[]){ 1,2,3,4 };
1194 rsp_fields.mfg_data_len = 4;
1195
1196 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
1197 (struct ble_hs_adv_test_field[]) {
1198 {
1199 .type = BLE_HS_ADV_TYPE_FLAGS,
1200 .val = (uint8_t[]){ BLE_HS_ADV_F_BREDR_UNSUP },
1201 .val_len = 1,
1202 },
1203 {
1204 .type = BLE_HS_ADV_TYPE_TX_PWR_LVL,
1205 .val = (uint8_t[]){ 0 },
1206 .val_len = 1,
1207 },
1208 { 0 },
1209 },
1210 &rsp_fields,
1211 (struct ble_hs_adv_test_field[]) {
1212 {
1213 .type = BLE_HS_ADV_TYPE_MFG_DATA,
1214 .val = (uint8_t[]) { 1,2,3,4 },
1215 .val_len = 4,
1216 },
1217 { 0 },
1218 });
1219 }
1220
TEST_CASE(ble_hs_adv_test_case_user_full_payload)1221 TEST_CASE(ble_hs_adv_test_case_user_full_payload)
1222 {
1223 /* Intentionally allocate an extra byte. */
1224 static const uint8_t mfg_data[30] = {
1225 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
1226 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
1227 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
1228 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e,
1229 };
1230
1231 struct ble_hs_adv_fields adv_fields;
1232 struct ble_hs_adv_fields rsp_fields;
1233 int rc;
1234
1235 ble_hs_test_util_init();
1236
1237 memset(&rsp_fields, 0, sizeof rsp_fields);
1238
1239 /***
1240 * An advertisement should allow 31 bytes of user data. Each field has a
1241 * two-byte header, leaving 29 bytes of payload.
1242 */
1243 memset(&adv_fields, 0, sizeof adv_fields);
1244 adv_fields.mfg_data = (void *)mfg_data;
1245 adv_fields.mfg_data_len = 29;
1246
1247 ble_hs_adv_test_misc_tx_and_verify_data(BLE_GAP_DISC_MODE_NON, &adv_fields,
1248 (struct ble_hs_adv_test_field[]) {
1249 {
1250 .type = BLE_HS_ADV_TYPE_MFG_DATA,
1251 .val = (void *)mfg_data,
1252 .val_len = 29,
1253 },
1254 { 0 },
1255 }, &rsp_fields, NULL);
1256
1257 /*** Fail with 30 bytes. */
1258 rc = ble_hs_test_util_adv_stop(0);
1259 TEST_ASSERT_FATAL(rc == 0);
1260
1261 adv_fields.mfg_data_len = 30;
1262 rc = ble_gap_adv_set_fields(&adv_fields);
1263 TEST_ASSERT(rc == BLE_HS_EMSGSIZE);
1264 }
1265
TEST_SUITE(ble_hs_adv_test_suite)1266 TEST_SUITE(ble_hs_adv_test_suite)
1267 {
1268 tu_suite_set_post_test_cb(ble_hs_test_util_post_test, NULL);
1269
1270 ble_hs_adv_test_case_user();
1271 ble_hs_adv_test_case_user_rsp();
1272 ble_hs_adv_test_case_user_full_payload();
1273 }
1274
1275 int
ble_hs_adv_test_all(void)1276 ble_hs_adv_test_all(void)
1277 {
1278 ble_hs_adv_test_suite();
1279
1280 return tu_any_failed;
1281 }
1282
1283