?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
align ARM cpu.h importing & using armreg.h
[minix3.git] / tests / lib / libbluetooth / t_sdp_put.c
blobfff4119ecef2e9f5c9713637bc1ca6ebd03c360e
1 /* $NetBSD: t_sdp_put.c,v 1.3 2011/04/16 07:32:27 plunky Exp $ */
2
3 /*-
4 * Copyright (c) 2011 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Iain Hibbert.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #include <atf-c.h>
33
34 #include <limits.h>
35 #include <sdp.h>
36 #include <string.h>
37
38 ATF_TC(check_sdp_put_data);
39
40 ATF_TC_HEAD(check_sdp_put_data, tc)
41 {
42
43 atf_tc_set_md_var(tc, "descr", "Test sdp_put_data results");
44 }
45
46 ATF_TC_BODY(check_sdp_put_data, tc)
47 {
48 uint8_t buf[256];
49 sdp_data_t test = { buf, buf + sizeof(buf) };
50 uint8_t data[] = {
51 0x35, 0x05, // seq8(5)
52 0x08, 0x00, // uint8 0x00
53 0x09, 0x12, 0x34, // uint16 0x1234
54 };
55 sdp_data_t value = { data, data + sizeof(data) };
56
57 ATF_REQUIRE(sdp_put_data(&test, &value));
58 test.end = test.next;
59 test.next = buf;
60
61 const uint8_t expect[] = {
62 0x35, 0x05, // seq8(5)
63 0x08, 0x00, // uint8 0x00
64 0x09, 0x12, 0x34, // uint16 0x1234
65 };
66
67 ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
68 ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
69 }
70
71 ATF_TC(check_sdp_put_attr);
72
73 ATF_TC_HEAD(check_sdp_put_attr, tc)
74 {
75
76 atf_tc_set_md_var(tc, "descr", "Test sdp_put_attr results");
77 }
78
79 ATF_TC_BODY(check_sdp_put_attr, tc)
80 {
81 uint8_t buf[256];
82 sdp_data_t test = { buf, buf + sizeof(buf) };
83 uint8_t data[] = {
84 0x00, // nil
85 0x19, 0x33, 0x44, // uuid16 0x3344
86 };
87 sdp_data_t value = { data, data + sizeof(data) };
88
89 ATF_REQUIRE_EQ(sdp_put_attr(&test, 0xabcd, &value), false);
90 value.next += 1; // skip "nil"
91 ATF_REQUIRE(sdp_put_attr(&test, 0x1337, &value));
92 test.end = test.next;
93 test.next = buf;
94
95 const uint8_t expect[] = {
96 0x09, 0x13, 0x37, // uint16 0x1337
97 0x19, 0x33, 0x44, // uuid16 0x3344
98 };
99
100 ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
101 ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
102 }
103
104 ATF_TC(check_sdp_put_uuid);
105
106 ATF_TC_HEAD(check_sdp_put_uuid, tc)
107 {
108
109 atf_tc_set_md_var(tc, "descr", "Test sdp_put_uuid results");
110 }
111
112 ATF_TC_BODY(check_sdp_put_uuid, tc)
113 {
114 uint8_t buf[256];
115 sdp_data_t test = { buf, buf + sizeof(buf) };
116 const uuid_t u16 = {
117 0x00001234,
118 0x0000,
119 0x1000,
120 0x80,
121 0x00,
122 { 0x00, 0x80, 0x5f, 0x9b, 0x34, 0xfb }
123 };
124 const uuid_t u32 = {
125 0x12345678,
126 0x0000,
127 0x1000,
128 0x80,
129 0x00,
130 { 0x00, 0x80, 0x5f, 0x9b, 0x34, 0xfb }
131 };
132 const uuid_t u128 = {
133 0x00112233,
134 0x4444,
135 0x5555,
136 0x66,
137 0x77,
138 { 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd }
139 };
140
141 ATF_REQUIRE(sdp_put_uuid(&test, &u16));
142 ATF_REQUIRE(sdp_put_uuid(&test, &u32));
143 ATF_REQUIRE(sdp_put_uuid(&test, &u128));
144 test.end = test.next;
145 test.next = buf;
146
147 const uint8_t expect[] = {
148 0x19, 0x12, 0x34, // uuid16 0x1234
149 0x1a, 0x12, 0x34, 0x56, // uuid32 0x12345678
150 0x78,
151 0x1c, 0x00, 0x11, 0x22, // uuid128 00112233-4444-5555-6677-8899aabbccdd
152 0x33, 0x44, 0x44, 0x55,
153 0x55, 0x66, 0x77, 0x88,
154 0x99, 0xaa, 0xbb, 0xcc,
155 0xdd,
156 };
157
158 ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
159 ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
160 }
161
162 ATF_TC(check_sdp_put_uuid16);
163
164 ATF_TC_HEAD(check_sdp_put_uuid16, tc)
165 {
166
167 atf_tc_set_md_var(tc, "descr", "Test sdp_put_uuid16 results");
168 }
169
170 ATF_TC_BODY(check_sdp_put_uuid16, tc)
171 {
172 uint8_t buf[256];
173 sdp_data_t test = { buf, buf + sizeof(buf) };
174
175 ATF_REQUIRE(sdp_put_uuid16(&test, 0x4567));
176 test.end = test.next;
177 test.next = buf;
178
179 const uint8_t expect[] = {
180 0x19, 0x45, 0x67, // uuid16 0x4567
181 };
182
183 ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
184 ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
185 }
186
187 ATF_TC(check_sdp_put_uuid32);
188
189 ATF_TC_HEAD(check_sdp_put_uuid32, tc)
190 {
191
192 atf_tc_set_md_var(tc, "descr", "Test sdp_put_uuid32 results");
193 }
194
195 ATF_TC_BODY(check_sdp_put_uuid32, tc)
196 {
197 uint8_t buf[256];
198 sdp_data_t test = { buf, buf + sizeof(buf) };
199
200 ATF_REQUIRE(sdp_put_uuid32(&test, 0xabcdef00));
201 test.end = test.next;
202 test.next = buf;
203
204 const uint8_t expect[] = {
205 0x1a, 0xab, 0xcd, 0xef, // uuid32 0xabcdef00
206 0x00,
207 };
208
209 ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
210 ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
211 }
212
213 ATF_TC(check_sdp_put_uuid128);
214
215 ATF_TC_HEAD(check_sdp_put_uuid128, tc)
216 {
217
218 atf_tc_set_md_var(tc, "descr", "Test sdp_put_uuid128 results");
219 }
220
221 ATF_TC_BODY(check_sdp_put_uuid128, tc)
222 {
223 uint8_t buf[256];
224 sdp_data_t test = { buf, buf + sizeof(buf) };
225 uuid_t value = {
226 0x00000100,
227 0x0000,
228 0x1000,
229 0x80,
230 0x00,
231 { 0x00, 0x80, 0x5f, 0x9b, 0x34, 0xfb }
232 };
233
234 ATF_REQUIRE(sdp_put_uuid128(&test, &value));
235 test.end = test.next;
236 test.next = buf;
237
238 const uint8_t expect[] = {
239 0x1c, 0x00, 0x00, 0x01, // uuid128 0000100-0000-1000-8000-00805f9b34fb
240 0x00, 0x00, 0x00, 0x10, // (L2CAP protocol)
241 0x00, 0x80, 0x00, 0x00,
242 0x80, 0x5f, 0x9b, 0x34,
243 0xfb,
244 };
245
246 ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
247 ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
248 }
249
250 ATF_TC(check_sdp_put_bool);
251
252 ATF_TC_HEAD(check_sdp_put_bool, tc)
253 {
254
255 atf_tc_set_md_var(tc, "descr", "Test sdp_put_bool results");
256 }
257
258 ATF_TC_BODY(check_sdp_put_bool, tc)
259 {
260 uint8_t buf[256];
261 sdp_data_t test = { buf, buf + sizeof(buf) };
262
263 ATF_REQUIRE(sdp_put_bool(&test, true));
264 ATF_REQUIRE(sdp_put_bool(&test, false));
265 test.end = test.next;
266 test.next = buf;
267
268 const uint8_t expect[] = {
269 0x28, 0x01, // bool true
270 0x28, 0x00, // bool false
271 };
272
273 ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
274 ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
275 }
276
277 ATF_TC(check_sdp_put_uint);
278
279 ATF_TC_HEAD(check_sdp_put_uint, tc)
280 {
281
282 atf_tc_set_md_var(tc, "descr", "Test sdp_put_uint results");
283 }
284
285 ATF_TC_BODY(check_sdp_put_uint, tc)
286 {
287 uint8_t buf[256];
288 sdp_data_t test = { buf, buf + sizeof(buf) };
289
290 ATF_REQUIRE(sdp_put_uint(&test, (uintmax_t)0));
291 ATF_REQUIRE(sdp_put_uint(&test, (uintmax_t)UINT8_MAX));
292 ATF_REQUIRE(sdp_put_uint(&test, (uintmax_t)UINT8_MAX + 1));
293 ATF_REQUIRE(sdp_put_uint(&test, (uintmax_t)UINT16_MAX));
294 ATF_REQUIRE(sdp_put_uint(&test, (uintmax_t)UINT16_MAX + 1));
295 ATF_REQUIRE(sdp_put_uint(&test, (uintmax_t)UINT32_MAX));
296 ATF_REQUIRE(sdp_put_uint(&test, (uintmax_t)UINT32_MAX + 1));
297 ATF_REQUIRE(sdp_put_uint(&test, (uintmax_t)UINT64_MAX));
298 test.end = test.next;
299 test.next = buf;
300
301 const uint8_t expect[] = {
302 0x08, 0x00, // uint8 0x00
303 0x08, 0xff, // uint8 0xff
304 0x09, 0x01, 0x00, // uint16 0x0100
305 0x09, 0xff, 0xff, // uint16 0xffff
306 0x0a, 0x00, 0x01, 0x00, // uint32 0x00010000
307 0x00,
308 0x0a, 0xff, 0xff, 0xff, // uint32 0xffffffff
309 0xff,
310 0x0b, 0x00, 0x00, 0x00, // uint64 0x0000000100000000
311 0x01, 0x00, 0x00, 0x00,
312 0x00,
313 0x0b, 0xff, 0xff, 0xff, // uint64 0xffffffffffffffff
314 0xff, 0xff, 0xff, 0xff,
315 0xff,
316 };
317
318 ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
319 ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
320 }
321
322 ATF_TC(check_sdp_put_uint8);
323
324 ATF_TC_HEAD(check_sdp_put_uint8, tc)
325 {
326
327 atf_tc_set_md_var(tc, "descr", "Test sdp_put_uint8 results");
328 }
329
330 ATF_TC_BODY(check_sdp_put_uint8, tc)
331 {
332 uint8_t buf[256];
333 sdp_data_t test = { buf, buf + sizeof(buf) };
334
335 ATF_REQUIRE(sdp_put_uint8(&test, (uint8_t)0));
336 ATF_REQUIRE(sdp_put_uint8(&test, (uint8_t)UINT8_MAX));
337 test.end = test.next;
338 test.next = buf;
339
340 const uint8_t expect[] = {
341 0x08, 0x00, // uint8 0x00
342 0x08, 0xff, // uint8 0xff
343 };
344
345 ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
346 ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
347 }
348
349 ATF_TC(check_sdp_put_uint16);
350
351 ATF_TC_HEAD(check_sdp_put_uint16, tc)
352 {
353
354 atf_tc_set_md_var(tc, "descr", "Test sdp_put_uint16 results");
355 }
356
357 ATF_TC_BODY(check_sdp_put_uint16, tc)
358 {
359 uint8_t buf[256];
360 sdp_data_t test = { buf, buf + sizeof(buf) };
361
362 ATF_REQUIRE(sdp_put_uint16(&test, (uint16_t)0));
363 ATF_REQUIRE(sdp_put_uint16(&test, (uint16_t)UINT8_MAX));
364 ATF_REQUIRE(sdp_put_uint16(&test, (uint16_t)UINT16_MAX));
365 ATF_REQUIRE(sdp_put_uint16(&test, (uint16_t)0xabcd));
366 test.end = test.next;
367 test.next = buf;
368
369 const uint8_t expect[] = {
370 0x09, 0x00, 0x00, // uint16 0x0000
371 0x09, 0x00, 0xff, // uint16 0x00ff
372 0x09, 0xff, 0xff, // uint16 0xffff
373 0x09, 0xab, 0xcd, // uint16 0xabcd
374 };
375
376 ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
377 ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
378 }
379
380 ATF_TC(check_sdp_put_uint32);
381
382 ATF_TC_HEAD(check_sdp_put_uint32, tc)
383 {
384
385 atf_tc_set_md_var(tc, "descr", "Test sdp_put_uint32 results");
386 }
387
388 ATF_TC_BODY(check_sdp_put_uint32, tc)
389 {
390 uint8_t buf[256];
391 sdp_data_t test = { buf, buf + sizeof(buf) };
392
393 ATF_REQUIRE(sdp_put_uint32(&test, (uint32_t)0));
394 ATF_REQUIRE(sdp_put_uint32(&test, (uint32_t)UINT8_MAX));
395 ATF_REQUIRE(sdp_put_uint32(&test, (uint32_t)UINT16_MAX));
396 ATF_REQUIRE(sdp_put_uint32(&test, (uint32_t)UINT32_MAX));
397 ATF_REQUIRE(sdp_put_uint32(&test, (uint32_t)0xdeadbeef));
398 test.end = test.next;
399 test.next = buf;
400
401 const uint8_t expect[] = {
402 0x0a, 0x00, 0x00, 0x00, // uint32 0x00000000
403 0x00,
404 0x0a, 0x00, 0x00, 0x00, // uint32 0x000000ff
405 0xff,
406 0x0a, 0x00, 0x00, 0xff, // uint32 0x0000ffff
407 0xff,
408 0x0a, 0xff, 0xff, 0xff, // uint32 0xffffffff
409 0xff,
410 0x0a, 0xde, 0xad, 0xbe, // uint32 0xdeadbeef
411 0xef,
412 };
413
414 ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
415 ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
416 }
417
418 ATF_TC(check_sdp_put_uint64);
419
420 ATF_TC_HEAD(check_sdp_put_uint64, tc)
421 {
422
423 atf_tc_set_md_var(tc, "descr", "Test sdp_put_uint64 results");
424 }
425
426 ATF_TC_BODY(check_sdp_put_uint64, tc)
427 {
428 uint8_t buf[256];
429 sdp_data_t test = { buf, buf + sizeof(buf) };
430
431 ATF_REQUIRE(sdp_put_uint64(&test, (uint64_t)0));
432 ATF_REQUIRE(sdp_put_uint64(&test, (uint64_t)UINT8_MAX));
433 ATF_REQUIRE(sdp_put_uint64(&test, (uint64_t)UINT16_MAX));
434 ATF_REQUIRE(sdp_put_uint64(&test, (uint64_t)UINT32_MAX));
435 ATF_REQUIRE(sdp_put_uint64(&test, (uint64_t)UINT64_MAX));
436 ATF_REQUIRE(sdp_put_uint64(&test, (uint64_t)0xc0ffeecafec0ffee));
437 test.end = test.next;
438 test.next = buf;
439
440 const uint8_t expect[] = {
441 0x0b, 0x00, 0x00, 0x00, // uint64 0x0000000000000000
442 0x00, 0x00, 0x00, 0x00,
443 0x00,
444 0x0b, 0x00, 0x00, 0x00, // uint64 0x00000000000000ff
445 0x00, 0x00, 0x00, 0x00,
446 0xff,
447 0x0b, 0x00, 0x00, 0x00, // uint64 0x000000000000ffff
448 0x00, 0x00, 0x00, 0xff,
449 0xff,
450 0x0b, 0x00, 0x00, 0x00, // uint64 0x00000000ffffffff
451 0x00, 0xff, 0xff, 0xff,
452 0xff,
453 0x0b, 0xff, 0xff, 0xff, // uint64 0xffffffffffffffff
454 0xff, 0xff, 0xff, 0xff,
455 0xff,
456 0x0b, 0xc0, 0xff, 0xee, // uint64 0xc0ffeecafec0ffee
457 0xca, 0xfe, 0xc0, 0xff,
458 0xee,
459 };
460
461 ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
462 ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
463 }
464
465 ATF_TC(check_sdp_put_int);
466
467 ATF_TC_HEAD(check_sdp_put_int, tc)
468 {
469
470 atf_tc_set_md_var(tc, "descr", "Test sdp_put_int results");
471 }
472
473 ATF_TC_BODY(check_sdp_put_int, tc)
474 {
475 uint8_t buf[256];
476 sdp_data_t test = { buf, buf + sizeof(buf) };
477
478 ATF_REQUIRE(sdp_put_int(&test, (intmax_t)0));
479 ATF_REQUIRE(sdp_put_int(&test, (intmax_t)INT8_MIN));
480 ATF_REQUIRE(sdp_put_int(&test, (intmax_t)INT8_MAX));
481 ATF_REQUIRE(sdp_put_int(&test, (intmax_t)INT8_MIN - 1));
482 ATF_REQUIRE(sdp_put_int(&test, (intmax_t)INT8_MAX + 1));
483 ATF_REQUIRE(sdp_put_int(&test, (intmax_t)INT16_MIN));
484 ATF_REQUIRE(sdp_put_int(&test, (intmax_t)INT16_MAX));
485 ATF_REQUIRE(sdp_put_int(&test, (intmax_t)INT16_MIN - 1));
486 ATF_REQUIRE(sdp_put_int(&test, (intmax_t)INT16_MAX + 1));
487 ATF_REQUIRE(sdp_put_int(&test, (intmax_t)INT32_MIN));
488 ATF_REQUIRE(sdp_put_int(&test, (intmax_t)INT32_MAX));
489 ATF_REQUIRE(sdp_put_int(&test, (intmax_t)INT32_MIN - 1));
490 ATF_REQUIRE(sdp_put_int(&test, (intmax_t)INT32_MAX + 1));
491 ATF_REQUIRE(sdp_put_int(&test, (intmax_t)INT64_MIN));
492 ATF_REQUIRE(sdp_put_int(&test, (intmax_t)INT64_MAX));
493 test.end = test.next;
494 test.next = buf;
495
496 const uint8_t expect[] = {
497 0x10, 0x00, // int8 0
498 0x10, 0x80, // int8 -128
499 0x10, 0x7f, // int8 127
500 0x11, 0xff, 0x7f, // int16 -129
501 0x11, 0x00, 0x80, // int16 128
502 0x11, 0x80, 0x00, // int16 -32768
503 0x11, 0x7f, 0xff, // int16 32767
504 0x12, 0xff, 0xff, 0x7f, // int32 -32769
505 0xff,
506 0x12, 0x00, 0x00, 0x80, // int32 32768
507 0x00,
508 0x12, 0x80, 0x00, 0x00, // int32 -2147483648
509 0x00,
510 0x12, 0x7f, 0xff, 0xff, // int32 2147483647
511 0xff,
512 0x13, 0xff, 0xff, 0xff, // int64 -2147483649
513 0xff, 0x7f, 0xff, 0xff,
514 0xff,
515 0x13, 0x00, 0x00, 0x00, // int64 2147483648
516 0x00, 0x80, 0x00, 0x00,
517 0x00,
518 0x13, 0x80, 0x00, 0x00, // int64 -9223372036854775808
519 0x00, 0x00, 0x00, 0x00,
520 0x00,
521 0x13, 0x7f, 0xff, 0xff, // int64 9223372036854775807
522 0xff, 0xff, 0xff, 0xff,
523 0xff,
524 };
525
526 ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
527 ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
528 }
529
530 ATF_TC(check_sdp_put_int8);
531
532 ATF_TC_HEAD(check_sdp_put_int8, tc)
533 {
534
535 atf_tc_set_md_var(tc, "descr", "Test sdp_put_int8 results");
536 }
537
538 ATF_TC_BODY(check_sdp_put_int8, tc)
539 {
540 uint8_t buf[256];
541 sdp_data_t test = { buf, buf + sizeof(buf) };
542
543 ATF_REQUIRE(sdp_put_int8(&test, (int8_t)0));
544 ATF_REQUIRE(sdp_put_int8(&test, (int8_t)INT8_MIN));
545 ATF_REQUIRE(sdp_put_int8(&test, (int8_t)INT8_MAX));
546 test.end = test.next;
547 test.next = buf;
548
549 const uint8_t expect[] = {
550 0x10, 0x00, // int8 0
551 0x10, 0x80, // int8 -128
552 0x10, 0x7f, // int8 127
553 };
554
555 ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
556 ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
557 }
558
559 ATF_TC(check_sdp_put_int16);
560
561 ATF_TC_HEAD(check_sdp_put_int16, tc)
562 {
563
564 atf_tc_set_md_var(tc, "descr", "Test sdp_put_int16 results");
565 }
566
567 ATF_TC_BODY(check_sdp_put_int16, tc)
568 {
569 uint8_t buf[256];
570 sdp_data_t test = { buf, buf + sizeof(buf) };
571
572 ATF_REQUIRE(sdp_put_int16(&test, (int16_t)0));
573 ATF_REQUIRE(sdp_put_int16(&test, (int16_t)INT8_MIN));
574 ATF_REQUIRE(sdp_put_int16(&test, (int16_t)INT8_MAX));
575 ATF_REQUIRE(sdp_put_int16(&test, (int16_t)INT16_MIN));
576 ATF_REQUIRE(sdp_put_int16(&test, (int16_t)INT16_MAX));
577 test.end = test.next;
578 test.next = buf;
579
580 const uint8_t expect[] = {
581 0x11, 0x00, 0x00, // int16 0
582 0x11, 0xff, 0x80, // int16 -128
583 0x11, 0x00, 0x7f, // int16 127
584 0x11, 0x80, 0x00, // int16 -32768
585 0x11, 0x7f, 0xff, // int16 32767
586 };
587
588 ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
589 ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
590 }
591
592 ATF_TC(check_sdp_put_int32);
593
594 ATF_TC_HEAD(check_sdp_put_int32, tc)
595 {
596
597 atf_tc_set_md_var(tc, "descr", "Test sdp_put_int32 results");
598 }
599
600 ATF_TC_BODY(check_sdp_put_int32, tc)
601 {
602 uint8_t buf[256];
603 sdp_data_t test = { buf, buf + sizeof(buf) };
604
605 ATF_REQUIRE(sdp_put_int32(&test, (int32_t)0));
606 ATF_REQUIRE(sdp_put_int32(&test, (int32_t)INT8_MIN));
607 ATF_REQUIRE(sdp_put_int32(&test, (int32_t)INT8_MAX));
608 ATF_REQUIRE(sdp_put_int32(&test, (int32_t)INT16_MIN));
609 ATF_REQUIRE(sdp_put_int32(&test, (int32_t)INT16_MAX));
610 ATF_REQUIRE(sdp_put_int32(&test, (int32_t)INT32_MIN));
611 ATF_REQUIRE(sdp_put_int32(&test, (int32_t)INT32_MAX));
612 test.end = test.next;
613 test.next = buf;
614
615 const uint8_t expect[] = {
616 0x12, 0x00, 0x00, 0x00, // int32 0
617 0x00,
618 0x12, 0xff, 0xff, 0xff, // int32 -128
619 0x80,
620 0x12, 0x00, 0x00, 0x00, // int32 127
621 0x7f,
622 0x12, 0xff, 0xff, 0x80, // int32 -32768
623 0x00,
624 0x12, 0x00, 0x00, 0x7f, // int32 32767
625 0xff,
626 0x12, 0x80, 0x00, 0x00, // int32 -2147483648
627 0x00,
628 0x12, 0x7f, 0xff, 0xff, // int32 2147483647
629 0xff,
630 };
631
632 ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
633 ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
634 }
635
636 ATF_TC(check_sdp_put_int64);
637
638 ATF_TC_HEAD(check_sdp_put_int64, tc)
639 {
640
641 atf_tc_set_md_var(tc, "descr", "Test sdp_put_int64 results");
642 }
643
644 ATF_TC_BODY(check_sdp_put_int64, tc)
645 {
646 uint8_t buf[256];
647 sdp_data_t test = { buf, buf + sizeof(buf) };
648
649 ATF_REQUIRE(sdp_put_int64(&test, (int64_t)0));
650 ATF_REQUIRE(sdp_put_int64(&test, (int64_t)INT8_MIN));
651 ATF_REQUIRE(sdp_put_int64(&test, (int64_t)INT8_MAX));
652 ATF_REQUIRE(sdp_put_int64(&test, (int64_t)INT16_MIN));
653 ATF_REQUIRE(sdp_put_int64(&test, (int64_t)INT16_MAX));
654 ATF_REQUIRE(sdp_put_int64(&test, (int64_t)INT32_MIN));
655 ATF_REQUIRE(sdp_put_int64(&test, (int64_t)INT32_MAX));
656 ATF_REQUIRE(sdp_put_int64(&test, (int64_t)INT64_MIN));
657 ATF_REQUIRE(sdp_put_int64(&test, (int64_t)INT64_MAX));
658 test.end = test.next;
659 test.next = buf;
660
661 const uint8_t expect[] = {
662 0x13, 0x00, 0x00, 0x00, // int64 0
663 0x00, 0x00, 0x00, 0x00,
664 0x00,
665 0x13, 0xff, 0xff, 0xff, // int64 -128
666 0xff, 0xff, 0xff, 0xff,
667 0x80,
668 0x13, 0x00, 0x00, 0x00, // int64 127
669 0x00, 0x00, 0x00, 0x00,
670 0x7f,
671 0x13, 0xff, 0xff, 0xff, // int64 -32768
672 0xff, 0xff, 0xff, 0x80,
673 0x00,
674 0x13, 0x00, 0x00, 0x00, // int64 32767
675 0x00, 0x00, 0x00, 0x7f,
676 0xff,
677 0x13, 0xff, 0xff, 0xff, // int64 -2147483648
678 0xff, 0x80, 0x00, 0x00,
679 0x00,
680 0x13, 0x00, 0x00, 0x00, // int64 2147483647
681 0x00, 0x7f, 0xff, 0xff,
682 0xff,
683 0x13, 0x80, 0x00, 0x00, // int64 -9223372036854775808
684 0x00, 0x00, 0x00, 0x00,
685 0x00,
686 0x13, 0x7f, 0xff, 0xff, // int64 9223372036854775807
687 0xff, 0xff, 0xff, 0xff,
688 0xff,
689 };
690
691 ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
692 ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
693 }
694
695 ATF_TC(check_sdp_put_seq);
696
697 ATF_TC_HEAD(check_sdp_put_seq, tc)
698 {
699
700 atf_tc_set_md_var(tc, "descr", "Test sdp_put_seq results");
701 }
702
703 ATF_TC_BODY(check_sdp_put_seq, tc)
704 {
705 uint8_t buf[512];
706 sdp_data_t test = { buf, buf + sizeof(buf) };
707
708 ATF_REQUIRE(sdp_put_seq(&test, (ssize_t)0));
709 ATF_REQUIRE(sdp_put_seq(&test, (ssize_t)UINT8_MAX));
710 ATF_REQUIRE(sdp_put_seq(&test, (ssize_t)UINT8_MAX + 1));
711 ATF_REQUIRE(sdp_put_seq(&test, (ssize_t)-1));
712 ATF_CHECK_EQ(sdp_put_seq(&test, (ssize_t)UINT16_MAX), false); /* no room */
713 ATF_CHECK_EQ(sdp_put_seq(&test, (ssize_t)SSIZE_MAX), false); /* no room */
714 test.end = test.next;
715 test.next = buf;
716
717 /* (not a valid element list) */
718 const uint8_t expect[] = {
719 0x35, 0x00, // seq8(0)
720 0x35, 0xff, // seq8(255)
721 0x36, 0x01, 0x00, // seq16(256)
722 0x36, 0x01, 0xf6, // seq16(502) <- sizeof(buf) - 7 - 3
723 };
724
725 ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
726 ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
727 }
728
729 ATF_TC(check_sdp_put_alt);
730
731 ATF_TC_HEAD(check_sdp_put_alt, tc)
732 {
733
734 atf_tc_set_md_var(tc, "descr", "Test sdp_put_alt results");
735 }
736
737 ATF_TC_BODY(check_sdp_put_alt, tc)
738 {
739 uint8_t buf[512];
740 sdp_data_t test = { buf, buf + sizeof(buf) };
741
742 ATF_REQUIRE(sdp_put_alt(&test, (ssize_t)0));
743 ATF_REQUIRE(sdp_put_alt(&test, (ssize_t)UINT8_MAX));
744 ATF_REQUIRE(sdp_put_alt(&test, (ssize_t)UINT8_MAX + 1));
745 ATF_REQUIRE(sdp_put_alt(&test, (ssize_t)-1));
746 ATF_CHECK_EQ(sdp_put_alt(&test, (ssize_t)UINT16_MAX), false); /* no room */
747 ATF_CHECK_EQ(sdp_put_alt(&test, (ssize_t)SSIZE_MAX), false); /* no room */
748 test.end = test.next;
749 test.next = buf;
750
751 /* (not a valid element list) */
752 const uint8_t expect[] = {
753 0x3d, 0x00, // alt8(0)
754 0x3d, 0xff, // alt8(255)
755 0x3e, 0x01, 0x00, // alt16(256)
756 0x3e, 0x01, 0xf6, // alt16(502) <- sizeof(buf) - 7 - 3
757 };
758
759 ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
760 ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
761 }
762
763 ATF_TC(check_sdp_put_str);
764
765 ATF_TC_HEAD(check_sdp_put_str, tc)
766 {
767
768 atf_tc_set_md_var(tc, "descr", "Test sdp_put_str results");
769 }
770
771 ATF_TC_BODY(check_sdp_put_str, tc)
772 {
773 uint8_t buf[512];
774 sdp_data_t test = { buf, buf + sizeof(buf) };
775
776 /*
777 * this does not test str16 or str32, but that is
778 * handled by the same code as sdp_put_seq above..
779 */
780
781 ATF_REQUIRE(sdp_put_str(&test, "Hello World!", 5));
782 ATF_REQUIRE(sdp_put_str(&test, "Hello\0World", 11));
783 ATF_REQUIRE(sdp_put_str(&test, "Hello World!", -1));
784 ATF_REQUIRE(sdp_put_str(&test, "Hello\0World", -1));
785 test.end = test.next;
786 test.next = buf;
787
788 const uint8_t expect[] = {
789 0x25, 0x05, 0x48, 0x65, // str8 "Hello"
790 0x6c, 0x6c, 0x6f,
791 0x25, 0x0b, 0x48, 0x65, // str8 "Hello\0World"
792 0x6c, 0x6c, 0x6f, 0x00,
793 0x57, 0x6f, 0x72, 0x6c,
794 0x64,
795 0x25, 0x0c, 0x48, 0x65, // str8 "Hello World!"
796 0x6c, 0x6c, 0x6f, 0x20,
797 0x57, 0x6f, 0x72, 0x6c,
798 0x64, 0x21,
799 0x25, 0x05, 0x48, 0x65, // str8 "Hello"
800 0x6c, 0x6c, 0x6f,
801 };
802
803 ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
804 ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
805 }
806
807 ATF_TC(check_sdp_put_url);
808
809 ATF_TC_HEAD(check_sdp_put_url, tc)
810 {
811
812 atf_tc_set_md_var(tc, "descr", "Test sdp_put_url results");
813 }
814
815 ATF_TC_BODY(check_sdp_put_url, tc)
816 {
817 uint8_t buf[512];
818 sdp_data_t test = { buf, buf + sizeof(buf) };
819
820 /*
821 * this does not test url16 or url32, but that is
822 * handled by the same code as sdp_put_seq above..
823 */
824
825 ATF_REQUIRE(sdp_put_url(&test, "http://www.netbsd.org/", 21));
826 ATF_REQUIRE(sdp_put_url(&test, "http://www.netbsd.org/", -1));
827 test.end = test.next;
828 test.next = buf;
829
830 const uint8_t expect[] = {
831 0x45, 0x15, 0x68, 0x74, // url8 "http://www.netbsd.org"
832 0x74, 0x70, 0x3a, 0x2f,
833 0x2f, 0x77, 0x77, 0x77,
834 0x2e, 0x6e, 0x65, 0x74,
835 0x62, 0x73, 0x64, 0x2e,
836 0x6f, 0x72, 0x67,
837 0x45, 0x16, 0x68, 0x74, // url8 "http://www.netbsd.org/"
838 0x74, 0x70, 0x3a, 0x2f,
839 0x2f, 0x77, 0x77, 0x77,
840 0x2e, 0x6e, 0x65, 0x74,
841 0x62, 0x73, 0x64, 0x2e,
842 0x6f, 0x72, 0x67, 0x2f,
843 };
844
845 ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
846 ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
847 }
848
849 ATF_TP_ADD_TCS(tp)
850 {
851
852 ATF_TP_ADD_TC(tp, check_sdp_put_data);
853 ATF_TP_ADD_TC(tp, check_sdp_put_attr);
854 ATF_TP_ADD_TC(tp, check_sdp_put_uuid);
855 ATF_TP_ADD_TC(tp, check_sdp_put_uuid16);
856 ATF_TP_ADD_TC(tp, check_sdp_put_uuid32);
857 ATF_TP_ADD_TC(tp, check_sdp_put_uuid128);
858 ATF_TP_ADD_TC(tp, check_sdp_put_bool);
859 ATF_TP_ADD_TC(tp, check_sdp_put_uint);
860 ATF_TP_ADD_TC(tp, check_sdp_put_uint8);
861 ATF_TP_ADD_TC(tp, check_sdp_put_uint16);
862 ATF_TP_ADD_TC(tp, check_sdp_put_uint32);
863 ATF_TP_ADD_TC(tp, check_sdp_put_uint64);
864 ATF_TP_ADD_TC(tp, check_sdp_put_int);
865 ATF_TP_ADD_TC(tp, check_sdp_put_int8);
866 ATF_TP_ADD_TC(tp, check_sdp_put_int16);
867 ATF_TP_ADD_TC(tp, check_sdp_put_int32);
868 ATF_TP_ADD_TC(tp, check_sdp_put_int64);
869 ATF_TP_ADD_TC(tp, check_sdp_put_seq);
870 ATF_TP_ADD_TC(tp, check_sdp_put_alt);
871 ATF_TP_ADD_TC(tp, check_sdp_put_str);
872 ATF_TP_ADD_TC(tp, check_sdp_put_url);
873
874 return atf_no_error();
875 }
MINIX 3 (repo.or.cz mirror)