xref: /freebsd/contrib/netbsd-tests/lib/libbluetooth/t_sdp_put.c (revision a0b9e2e854027e6ff61fb075a1309dbc71c42b54)
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 }
876