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