Import the NetBSD test suite from ^/vendor/NetBSD/tests/09.30.2014_20.45 ,

minus the vendor Makefiles

Provide directions for how to bootstrap the vendor sources in
FREEBSD-upgrade

MFC after 2 weeks
Discussed with: rpaulo
Sponsored by: EMC / Isilon Storage Division

6 files changed, 2187 insertions, 0 deletions

diff --git a/contrib/netbsd-tests/lib/libbluetooth/t_bluetooth.c b/contrib/netbsd-tests/lib/libbluetooth/t_bluetooth.c
new file mode 100644
index 0000000..066f8d9
--- /dev/null
+++ b/contrib/netbsd-tests/lib/libbluetooth/t_bluetooth.c
@@ -0,0 +1,87 @@
+/*	$NetBSD: t_bluetooth.c,v 1.2 2011/04/07 08:29:50 plunky Exp $	*/
+
+/*-
+ * Copyright (c) 2011 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Iain Hibbert.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <atf-c.h>
+
+#include <bluetooth.h>
+#include <string.h>
+
+ATF_TC(check_bt_aton);
+
+ATF_TC_HEAD(check_bt_aton, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test bt_aton results");
+}
+
+ATF_TC_BODY(check_bt_aton, tc)
+{
+	bdaddr_t bdaddr;
+
+	ATF_CHECK_EQ(bt_aton("0a:0b:0c:0d:0e", &bdaddr), 0);
+	ATF_CHECK_EQ(bt_aton("0a:0b:0c:0d0:0e:0f", &bdaddr), 0);
+	ATF_CHECK_EQ(bt_aton("0a:0b:0c:0d:0e:0f:00", &bdaddr), 0);
+	ATF_CHECK_EQ(bt_aton("0a:0b:0c:0d:0e:0f\n", &bdaddr), 0);
+	ATF_CHECK_EQ(bt_aton(" 0a:0b:0c:0d:0e:0f", &bdaddr), 0);
+	ATF_CHECK_EQ(bt_aton("0a:0b:0x:0d:0e:0f", &bdaddr), 0);
+
+	ATF_REQUIRE(bt_aton("0a:0b:0c:0d:0e:0f", &bdaddr));
+	ATF_CHECK_EQ(bdaddr.b[0], 0x0f);
+	ATF_CHECK_EQ(bdaddr.b[1], 0x0e);
+	ATF_CHECK_EQ(bdaddr.b[2], 0x0d);
+	ATF_CHECK_EQ(bdaddr.b[3], 0x0c);
+	ATF_CHECK_EQ(bdaddr.b[4], 0x0b);
+	ATF_CHECK_EQ(bdaddr.b[5], 0x0a);
+}
+
+ATF_TC(check_bt_ntoa);
+
+ATF_TC_HEAD(check_bt_ntoa, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test bt_ntoa results");
+}
+
+ATF_TC_BODY(check_bt_ntoa, tc)
+{
+	bdaddr_t bdaddr = { { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55 } };
+
+	ATF_CHECK_STREQ(bt_ntoa(&bdaddr, NULL), "55:44:33:22:11:00");
+}
+
+ATF_TP_ADD_TCS(tp)
+{
+
+	ATF_TP_ADD_TC(tp, check_bt_aton);
+	ATF_TP_ADD_TC(tp, check_bt_ntoa);
+
+	return atf_no_error();
+}
diff --git a/contrib/netbsd-tests/lib/libbluetooth/t_sdp_data.c b/contrib/netbsd-tests/lib/libbluetooth/t_sdp_data.c
new file mode 100644
index 0000000..cff6627
--- /dev/null
+++ b/contrib/netbsd-tests/lib/libbluetooth/t_sdp_data.c
@@ -0,0 +1,136 @@
+/*	$NetBSD: t_sdp_data.c,v 1.2 2011/04/07 08:29:50 plunky Exp $	*/
+
+/*-
+ * Copyright (c) 2011 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Iain Hibbert.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <atf-c.h>
+
+#include <sdp.h>
+
+ATF_TC(check_sdp_data_type);
+
+ATF_TC_HEAD(check_sdp_data_type, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_data_type results");
+}
+
+ATF_TC_BODY(check_sdp_data_type, tc)
+{
+	uint8_t data[] = {
+		0x00,			// nil
+		0x08, 0x00,		// uint8	0x00
+	};
+	sdp_data_t test = { data, data + sizeof(data) };
+	sdp_data_t value;
+
+	ATF_REQUIRE(sdp_get_data(&test, &value));
+	ATF_CHECK_EQ(sdp_data_type(&value), SDP_DATA_NIL);
+
+	ATF_REQUIRE(sdp_get_data(&test, &value));
+	ATF_CHECK_EQ(sdp_data_type(&value), SDP_DATA_UINT8);
+
+	ATF_CHECK_EQ(test.next, test.end);
+}
+
+ATF_TC(check_sdp_data_size);
+
+ATF_TC_HEAD(check_sdp_data_size, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_data_size results");
+}
+
+ATF_TC_BODY(check_sdp_data_size, tc)
+{
+	uint8_t data[] = {
+		0x00,			// nil
+		0x08, 0x00,		// uint8
+		0x11, 0x00, 0x00,	// int16
+		0x1a, 0x00, 0x00, 0x00,	// uuid32
+		0x00,
+		0x28, 0x00,		// bool
+		0x25, 0x00,		// str8(0)
+		0x25, 0x02, 0x00, 0x00,	// str8(2)
+		0x36, 0x00, 0x00,	// seq16(0)
+		0x3e, 0x00, 0x05, 0x00,	// alt16(5)
+		0x00, 0x00, 0x00, 0x00,
+		0x37, 0x00, 0x00, 0x00,	// seq32(0)
+		0x00,
+		0x47, 0x00, 0x00, 0x00,	// url32(7)
+		0x07, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00,
+	};
+	sdp_data_t test = { data, data + sizeof(data) };
+	sdp_data_t value;
+
+	ATF_REQUIRE(sdp_get_data(&test, &value));
+	ATF_CHECK_EQ(sdp_data_size(&value), 1);
+
+	ATF_REQUIRE(sdp_get_data(&test, &value));
+	ATF_CHECK_EQ(sdp_data_size(&value), 2);
+
+	ATF_REQUIRE(sdp_get_data(&test, &value));
+	ATF_CHECK_EQ(sdp_data_size(&value), 3);
+
+	ATF_REQUIRE(sdp_get_data(&test, &value));
+	ATF_CHECK_EQ(sdp_data_size(&value), 5);
+
+	ATF_REQUIRE(sdp_get_data(&test, &value));
+	ATF_CHECK_EQ(sdp_data_size(&value), 2);
+
+	ATF_REQUIRE(sdp_get_data(&test, &value));
+	ATF_CHECK_EQ(sdp_data_size(&value), 2);
+
+	ATF_REQUIRE(sdp_get_data(&test, &value));
+	ATF_CHECK_EQ(sdp_data_size(&value), 4);
+
+	ATF_REQUIRE(sdp_get_data(&test, &value));
+	ATF_CHECK_EQ(sdp_data_size(&value), 3);
+
+	ATF_REQUIRE(sdp_get_data(&test, &value));
+	ATF_CHECK_EQ(sdp_data_size(&value), 8);
+
+	ATF_REQUIRE(sdp_get_data(&test, &value));
+	ATF_CHECK_EQ(sdp_data_size(&value), 5);
+
+	ATF_REQUIRE(sdp_get_data(&test, &value));
+	ATF_CHECK_EQ(sdp_data_size(&value), 12);
+
+	ATF_CHECK_EQ(test.next, test.end);
+}
+
+ATF_TP_ADD_TCS(tp)
+{
+
+	ATF_TP_ADD_TC(tp, check_sdp_data_type);
+	ATF_TP_ADD_TC(tp, check_sdp_data_size);
+
+	return atf_no_error();
+}
diff --git a/contrib/netbsd-tests/lib/libbluetooth/t_sdp_get.c b/contrib/netbsd-tests/lib/libbluetooth/t_sdp_get.c
new file mode 100644
index 0000000..3ad8070
--- /dev/null
+++ b/contrib/netbsd-tests/lib/libbluetooth/t_sdp_get.c
@@ -0,0 +1,643 @@
+/*	$NetBSD: t_sdp_get.c,v 1.2 2011/04/07 08:29:50 plunky Exp $	*/
+
+/*-
+ * Copyright (c) 2011 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Iain Hibbert.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <atf-c.h>
+
+#include <limits.h>
+#include <sdp.h>
+#include <string.h>
+
+ATF_TC(check_sdp_get_data);
+
+ATF_TC_HEAD(check_sdp_get_data, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_get_data results");
+}
+
+ATF_TC_BODY(check_sdp_get_data, tc)
+{
+	uint8_t data[] = {
+		0x09, 0x00, 0x00,	// uint16	0x0000
+		0x35, 0x05,		// seq8(5)
+		0x19, 0x00, 0x00,	//   uuid16	0x0000
+		0x08, 0x00,		//   uint8	0x00
+		0x36, 0x00, 0x01,	// seq16(1)
+		0x19,			//   uint16	/* invalid */
+		0x25, 0x04, 0x54, 0x45,	// str8(4)	"TEST"
+		0x53, 0x54,
+	};
+	sdp_data_t test = { data, data + sizeof(data) };
+	sdp_data_t value, seq;
+
+	/*
+	 * sdp_get_data constructs a new sdp_data_t containing
+	 * the next data element, advancing test if successful
+	 */
+	ATF_REQUIRE(sdp_get_data(&test, &value));
+	ATF_CHECK_EQ(sdp_data_type(&value), SDP_DATA_UINT16);
+	ATF_CHECK_EQ(sdp_data_size(&value), 3);
+
+	ATF_REQUIRE(sdp_get_data(&test, &value));
+	ATF_CHECK_EQ(sdp_data_type(&value), SDP_DATA_SEQ8);
+	ATF_CHECK_EQ(sdp_data_size(&value), 7);
+
+	ATF_REQUIRE(sdp_get_data(&test, &value));
+	ATF_CHECK_EQ(sdp_data_type(&value), SDP_DATA_SEQ16);
+	ATF_CHECK_EQ(sdp_data_size(&value), 4);
+	ATF_REQUIRE_EQ(sdp_get_seq(&value, &seq), true);
+	ATF_REQUIRE_EQ(sdp_get_data(&seq, &value), false);	/* invalid */
+
+	ATF_REQUIRE(sdp_get_data(&test, &value));
+	ATF_CHECK_EQ(sdp_data_type(&value), SDP_DATA_STR8);
+	ATF_CHECK_EQ(sdp_data_size(&value), 6);
+
+	ATF_CHECK_EQ(test.next, test.end);
+}
+
+ATF_TC(check_sdp_get_attr);
+
+ATF_TC_HEAD(check_sdp_get_attr, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_get_attr results");
+}
+
+ATF_TC_BODY(check_sdp_get_attr, tc)
+{
+	uint8_t data[] = {
+		0x09, 0x00, 0x00,	// uint16	0x0000
+		0x35, 0x05,		// seq8(5)
+		0x19, 0x00, 0x00,	//   uuid16	0x0000
+		0x08, 0x00,		//   uint8	0x00
+		0x08, 0x00,		// uint8	0x00
+		0x09, 0x00, 0x01,	// uint16	0x0001
+		0x19, 0x12, 0x34,	// uuid16	0x1234
+	};
+	sdp_data_t test = { data, data + sizeof(data) };
+	sdp_data_t value;
+	uint16_t attr;
+
+	/*
+	 * sdp_get_attr expects a UINT16 followed by any data item
+	 * and advances test if successful
+	 */
+	ATF_REQUIRE(sdp_get_attr(&test, &attr, &value));
+	ATF_CHECK_EQ(attr, 0x0000);
+	ATF_CHECK_EQ(sdp_data_type(&value), SDP_DATA_SEQ8);
+	ATF_CHECK_EQ(sdp_data_size(&value), 7);
+
+	ATF_REQUIRE_EQ(sdp_get_attr(&test, &attr, &value), false);
+	ATF_REQUIRE(sdp_get_data(&test, &value));
+	ATF_CHECK_EQ(sdp_data_type(&value), SDP_DATA_UINT8);
+	ATF_CHECK_EQ(sdp_data_size(&value), 2);
+
+	ATF_REQUIRE(sdp_get_attr(&test, &attr, &value));
+	ATF_CHECK_EQ(attr, 0x0001);
+	ATF_CHECK_EQ(sdp_data_type(&value), SDP_DATA_UUID16);
+	ATF_CHECK_EQ(sdp_data_size(&value), 3);
+
+	ATF_CHECK_EQ(test.next, test.end);
+}
+
+ATF_TC(check_sdp_get_uuid);
+
+ATF_TC_HEAD(check_sdp_get_uuid, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_get_uuid results");
+}
+
+ATF_TC_BODY(check_sdp_get_uuid, tc)
+{
+	uint8_t data[] = {
+		0x19, 0x12, 0x34,	// uuid16	0x1234
+		0x1a, 0x11, 0x22, 0x33,	// uuid32	0x11223344
+		0x44,
+		0x00,			// nil
+		0x1c,			// uuid128	0x00112233-4444--5555-6666-778899aabbcc
+		0x00, 0x11, 0x22, 0x33,
+		0x44, 0x44, 0x55, 0x55,
+		0x66, 0x66, 0x77, 0x88,
+		0x99, 0xaa, 0xbb, 0xcc,
+	};
+	sdp_data_t test = { data, data + sizeof(data) };
+	uuid_t u16 = {
+		0x00001234,
+		0x0000,
+		0x1000,
+		0x80,
+		0x00,
+		{ 0x00, 0x80, 0x5f, 0x9b, 0x34, 0xfb }
+	};
+	uuid_t u32 = {
+		0x11223344,
+		0x0000,
+		0x1000,
+		0x80,
+		0x00,
+		{ 0x00, 0x80, 0x5f, 0x9b, 0x34, 0xfb }
+	};
+	uuid_t u128 = {
+		0x00112233,
+		0x4444,
+		0x5555,
+		0x66,
+		0x66,
+		{ 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc }
+	};
+	sdp_data_t nil;
+	uuid_t value;
+
+	/*
+	 * sdp_get_uuid expects any UUID type returns the full uuid
+	 * advancing test if successful
+	 */
+	ATF_REQUIRE(sdp_get_uuid(&test, &value));
+	ATF_CHECK(uuid_equal(&value, &u16, NULL));
+
+	ATF_REQUIRE(sdp_get_uuid(&test, &value));
+	ATF_CHECK(uuid_equal(&value, &u32, NULL));
+
+	ATF_REQUIRE_EQ(sdp_get_uuid(&test, &value), false);	/* not uuid */
+	ATF_REQUIRE(sdp_get_data(&test, &nil));			/* (skip) */
+	ATF_CHECK_EQ(sdp_data_type(&nil), SDP_DATA_NIL);
+
+	ATF_REQUIRE(sdp_get_uuid(&test, &value));
+	ATF_CHECK(uuid_equal(&value, &u128, NULL));
+
+	ATF_CHECK_EQ(test.next, test.end);
+}
+
+ATF_TC(check_sdp_get_bool);
+
+ATF_TC_HEAD(check_sdp_get_bool, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_get_bool results");
+}
+
+ATF_TC_BODY(check_sdp_get_bool, tc)
+{
+	uint8_t data[] = {
+		0x28, 0x00,	// bool		false
+		0x00,		// nil
+		0x28, 0x01,	// bool		true
+	};
+	sdp_data_t test = { data, data + sizeof(data) };
+	sdp_data_t nil;
+	bool value;
+
+	/*
+	 * sdp_get_bool expects a BOOL type
+	 * advancing test if successful
+	 */
+	ATF_REQUIRE(sdp_get_bool(&test, &value));
+	ATF_CHECK_EQ(value, false);
+
+	ATF_REQUIRE_EQ(sdp_get_bool(&test, &value), false);	/* not bool */
+	ATF_REQUIRE(sdp_get_data(&test, &nil));			/* (skip) */
+	ATF_CHECK_EQ(sdp_data_type(&nil), SDP_DATA_NIL);
+
+	ATF_REQUIRE(sdp_get_bool(&test, &value));
+	ATF_CHECK_EQ(value, true);
+
+	ATF_CHECK_EQ(test.next, test.end);
+}
+
+ATF_TC(check_sdp_get_uint);
+
+ATF_TC_HEAD(check_sdp_get_uint, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_get_uint results");
+}
+
+ATF_TC_BODY(check_sdp_get_uint, tc)
+{
+	uint8_t data[] = {
+		0x08, 0x00,		// uint8	0x00
+		0x08, 0xff,		// uint8	0xff
+		0x09, 0x01, 0x02,	// uint16	0x0102
+		0x09, 0xff, 0xff,	// uint16	0xffff
+		0x00,			// nil
+		0x0a, 0x01, 0x02, 0x03,	// uint32	0x01020304
+		0x04,
+		0x0a, 0xff, 0xff, 0xff,	// uint32	0xffffffff
+		0xff,
+		0x0b, 0x01, 0x02, 0x03,	// uint64	0x0102030405060708
+		0x04, 0x05, 0x06, 0x07,
+		0x08,
+		0x0b, 0xff, 0xff, 0xff,	// uint64	0xffffffffffffffff
+		0xff, 0xff, 0xff, 0xff,
+		0xff,
+		0x0c, 0x00, 0x00, 0x00,	// uint128	0x00000000000000000000000000000000
+		0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00,
+		0x00,
+		0x0c, 0x00, 0x00, 0x00,	// uint128	0x00000000000000010000000000000000
+		0x00, 0x00, 0x00, 0x00,
+		0x01, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00,
+		0x00,
+		0x0c, 0x00, 0x00, 0x00,	// uint128	0x0000000000000000ffffffffffffffff
+		0x00, 0x00, 0x00, 0x00,
+		0x00, 0xff, 0xff, 0xff,
+		0xff, 0xff, 0xff, 0xff,
+		0xff,
+	};
+	sdp_data_t test = { data, data + sizeof(data) };
+	sdp_data_t nil;
+	uintmax_t value;
+
+	/*
+	 * sdp_get_uint expects any UINT type, advancing test if successful
+	 */
+	ATF_REQUIRE(sdp_get_uint(&test, &value));
+	ATF_CHECK_EQ(value, 0x00);
+
+	ATF_REQUIRE(sdp_get_uint(&test, &value));
+	ATF_CHECK_EQ(value, UINT8_MAX);
+
+	ATF_REQUIRE(sdp_get_uint(&test, &value));
+	ATF_CHECK_EQ(value, 0x0102);
+
+	ATF_REQUIRE(sdp_get_uint(&test, &value));
+	ATF_CHECK_EQ(value, UINT16_MAX);
+
+	ATF_REQUIRE_EQ(sdp_get_uint(&test, &value), false);	/* not uint */
+	ATF_REQUIRE(sdp_get_data(&test, &nil));			/* (skip) */
+	ATF_CHECK_EQ(sdp_data_type(&nil), SDP_DATA_NIL);
+
+	ATF_REQUIRE(sdp_get_uint(&test, &value));
+	ATF_CHECK_EQ(value, 0x01020304);
+
+	ATF_REQUIRE(sdp_get_uint(&test, &value));
+	ATF_CHECK_EQ(value, UINT32_MAX);
+
+	ATF_REQUIRE(sdp_get_uint(&test, &value));
+	ATF_CHECK_EQ(value, 0x0102030405060708);
+
+	ATF_REQUIRE(sdp_get_uint(&test, &value));
+	ATF_CHECK_EQ(value, UINT64_MAX);
+
+	/*
+	 * expected failure is that we cannot decode UINT128 values larger than UINT64
+	 */
+	ATF_REQUIRE(sdp_get_uint(&test, &value));
+	ATF_CHECK_EQ(value, 0x00000000000000000000000000000000);
+
+	ATF_REQUIRE_EQ(sdp_get_uint(&test, &value), false);	/* overflow */
+	ATF_REQUIRE(sdp_get_data(&test, &nil));			/* (skip) */
+	ATF_CHECK_EQ(sdp_data_type(&nil), SDP_DATA_UINT128);
+
+	ATF_REQUIRE(sdp_get_uint(&test, &value));
+	ATF_CHECK_EQ(value, UINT64_MAX);
+
+	ATF_CHECK_EQ(test.next, test.end);
+}
+
+ATF_TC(check_sdp_get_int);
+
+ATF_TC_HEAD(check_sdp_get_int, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_get_int results");
+}
+
+ATF_TC_BODY(check_sdp_get_int, tc)
+{
+	uint8_t data[] = {
+		0x10, 0x00,		// int8		0x00
+		0x10, 0x7f,		// int8		0x7f
+		0x10, 0x80,		// int8		0x80
+		0x11, 0x01, 0x02,	// int16	0x0102
+		0x11, 0x7f, 0xff,	// int16	0x7fff
+		0x11, 0x80, 0x00,	// int16	0x8000
+		0x00,			// nil
+		0x12, 0x01, 0x02, 0x03,	// int32	0x01020304
+		0x04,
+		0x12, 0x7f, 0xff, 0xff,	// int32	0x7fffffff
+		0xff,
+		0x12, 0x80, 0x00, 0x00,	// int32	0x80000000
+		0x00,
+		0x13, 0x01, 0x02, 0x03,	// int64	0x0102030405060708
+		0x04, 0x05, 0x06, 0x07,
+		0x08,
+		0x13, 0x7f, 0xff, 0xff,	// int64	0x7fffffffffffffff
+		0xff, 0xff, 0xff, 0xff,
+		0xff,
+		0x13, 0x80, 0x00, 0x00,	// int64	0x8000000000000000
+		0x00, 0x00, 0x00, 0x00,
+		0x00,
+		0x14, 0x00, 0x00, 0x00,	// int128	0x00000000000000000000000000000000
+		0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00,
+		0x00,
+		0x14, 0x00, 0x00, 0x00,	// int128	0x00000000000000007fffffffffffffff
+		0x00, 0x00, 0x00, 0x00,	//			(INT64_MAX)
+		0x00, 0x7f, 0xff, 0xff,
+		0xff, 0xff, 0xff, 0xff,
+		0xff,
+		0x14, 0x00, 0x00, 0x00,	// int128	0x00000000000000008000000000000000
+		0x00, 0x00, 0x00, 0x00,	//			(INT64_MAX + 1)
+		0x00, 0x80, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00,
+		0x00,
+		0x14, 0xff, 0xff, 0xff,	// int128	0xffffffffffffffff8000000000000000
+		0xff, 0xff, 0xff, 0xff,	//			(INT64_MIN)
+		0xff, 0x80, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x00,
+		0x00,
+		0x14, 0xff, 0xff, 0xff,	// int128	0xffffffffffffffff7fffffffffffffff
+		0xff, 0xff, 0xff, 0xff,	//			(INT64_MIN - 1)
+		0xff, 0x7f, 0xff, 0xff,
+		0xff, 0xff, 0xff, 0xff,
+		0xff,
+	};
+	sdp_data_t test = { data, data + sizeof(data) };
+	sdp_data_t nil;
+	intmax_t value;
+
+	/*
+	 * sdp_get_int expects any INT type, advancing test if successful
+	 */
+	ATF_REQUIRE(sdp_get_int(&test, &value));
+	ATF_CHECK_EQ(value, 0);
+
+	ATF_REQUIRE(sdp_get_int(&test, &value));
+	ATF_CHECK_EQ(value, INT8_MAX);
+
+	ATF_REQUIRE(sdp_get_int(&test, &value));
+	ATF_CHECK_EQ(value, INT8_MIN);
+
+	ATF_REQUIRE(sdp_get_int(&test, &value));
+	ATF_CHECK_EQ(value, 0x0102);
+
+	ATF_REQUIRE(sdp_get_int(&test, &value));
+	ATF_CHECK_EQ(value, INT16_MAX);
+
+	ATF_REQUIRE(sdp_get_int(&test, &value));
+	ATF_CHECK_EQ(value, INT16_MIN);
+
+	ATF_REQUIRE_EQ(sdp_get_int(&test, &value), false);	/* not int */
+	ATF_REQUIRE(sdp_get_data(&test, &nil));			/* (skip) */
+	ATF_CHECK_EQ(sdp_data_type(&nil), SDP_DATA_NIL);
+
+	ATF_REQUIRE(sdp_get_int(&test, &value));
+	ATF_CHECK_EQ(value, 0x01020304);
+
+	ATF_REQUIRE(sdp_get_int(&test, &value));
+	ATF_CHECK_EQ(value, INT32_MAX);
+
+	ATF_REQUIRE(sdp_get_int(&test, &value));
+	ATF_CHECK_EQ(value, INT32_MIN);
+
+	ATF_REQUIRE(sdp_get_int(&test, &value));
+	ATF_CHECK_EQ(value, 0x0102030405060708);
+
+	ATF_REQUIRE(sdp_get_int(&test, &value));
+	ATF_CHECK_EQ(value, INT64_MAX);
+
+	ATF_REQUIRE(sdp_get_int(&test, &value));
+	ATF_CHECK_EQ(value, INT64_MIN);
+
+	/*
+	 * expected failure is that we cannot decode INT128 values larger than INT64
+	 */
+	ATF_REQUIRE(sdp_get_int(&test, &value));
+	ATF_CHECK_EQ(value, 0);
+
+	ATF_REQUIRE(sdp_get_int(&test, &value));
+	ATF_CHECK_EQ(value, INT64_MAX);
+
+	ATF_REQUIRE_EQ(sdp_get_int(&test, &value), false);	/* overflow */
+	ATF_REQUIRE(sdp_get_data(&test, &nil));			/* (skip) */
+	ATF_CHECK_EQ(sdp_data_type(&nil), SDP_DATA_INT128);
+
+	ATF_REQUIRE(sdp_get_int(&test, &value));
+	ATF_CHECK_EQ(value, INT64_MIN);
+
+	ATF_REQUIRE_EQ(sdp_get_int(&test, &value), false);	/* underflow */
+	ATF_REQUIRE(sdp_get_data(&test, &nil));			/* (skip) */
+	ATF_CHECK_EQ(sdp_data_type(&nil), SDP_DATA_INT128);
+
+	ATF_CHECK_EQ(test.next, test.end);
+}
+
+ATF_TC(check_sdp_get_seq);
+
+ATF_TC_HEAD(check_sdp_get_seq, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_get_seq results");
+}
+
+ATF_TC_BODY(check_sdp_get_seq, tc)
+{
+	uint8_t data[] = {
+		0x35, 0x00,		// seq8(0)
+		0x00,			// nil
+		0x36, 0x00, 0x00,	// seq16(0)
+		0x37, 0x00, 0x00, 0x00,	// seq32(0)
+		0x00,
+	};
+	sdp_data_t test = { data, data + sizeof(data) };
+	sdp_data_t value;
+
+	/*
+	 * sdp_get_seq expects a SEQ type
+	 * advancing test if successful
+	 */
+	ATF_REQUIRE(sdp_get_seq(&test, &value));
+	ATF_CHECK_EQ(value.next, value.end);
+
+	ATF_REQUIRE_EQ(sdp_get_seq(&test, &value), false);	/* not seq */
+	ATF_REQUIRE(sdp_get_data(&test, &value));		/* (skip) */
+	ATF_CHECK_EQ(sdp_data_type(&value), SDP_DATA_NIL);
+
+	ATF_REQUIRE(sdp_get_seq(&test, &value));
+	ATF_CHECK_EQ(value.next, value.end);
+
+	ATF_REQUIRE(sdp_get_seq(&test, &value));
+	ATF_CHECK_EQ(value.next, value.end);
+
+	ATF_CHECK_EQ(test.next, test.end);
+}
+
+ATF_TC(check_sdp_get_alt);
+
+ATF_TC_HEAD(check_sdp_get_alt, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_get_alt results");
+}
+
+ATF_TC_BODY(check_sdp_get_alt, tc)
+{
+	uint8_t data[] = {
+		0x3d, 0x00,		// alt8(0)
+		0x00,			// nil
+		0x3e, 0x00, 0x00,	// alt16(0)
+		0x3f, 0x00, 0x00, 0x00,	// alt32(0)
+		0x00,
+	};
+	sdp_data_t test = { data, data + sizeof(data) };
+	sdp_data_t value;
+
+	/*
+	 * sdp_get_alt expects a ALT type
+	 * advancing test if successful
+	 */
+	ATF_REQUIRE(sdp_get_alt(&test, &value));
+	ATF_CHECK_EQ(value.next, value.end);
+
+	ATF_REQUIRE_EQ(sdp_get_alt(&test, &value), false);	/* not alt */
+	ATF_REQUIRE(sdp_get_data(&test, &value));		/* (skip) */
+	ATF_CHECK_EQ(sdp_data_type(&value), SDP_DATA_NIL);
+
+	ATF_REQUIRE(sdp_get_alt(&test, &value));
+	ATF_CHECK_EQ(value.next, value.end);
+
+	ATF_REQUIRE(sdp_get_alt(&test, &value));
+	ATF_CHECK_EQ(value.next, value.end);
+
+	ATF_CHECK_EQ(test.next, test.end);
+}
+
+ATF_TC(check_sdp_get_str);
+
+ATF_TC_HEAD(check_sdp_get_str, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_get_str results");
+}
+
+ATF_TC_BODY(check_sdp_get_str, tc)
+{
+	uint8_t data[] = {
+		0x25, 0x04, 0x53, 0x54, // str8(4)	"STR8"
+		0x52, 0x38,
+		0x00,			// nil
+		0x26, 0x00, 0x05, 0x53,	// str16(5)	"STR16"
+		0x54, 0x52, 0x31, 0x36,
+		0x27, 0x00, 0x00, 0x00,	// str32(5)	"STR32"
+		0x05, 0x53, 0x54, 0x52,
+		0x33, 0x32,
+	};
+	sdp_data_t test = { data, data + sizeof(data) };
+	sdp_data_t nil;
+	char *str;
+	size_t len;
+
+	/*
+	 * sdp_get_str expects a STR type
+	 * advancing test if successful
+	 */
+	ATF_REQUIRE(sdp_get_str(&test, &str, &len));
+	ATF_CHECK(len == 4 && strncmp(str, "STR8", 4) == 0);
+
+	ATF_REQUIRE_EQ(sdp_get_str(&test, &str, &len), false);	/* not str */
+	ATF_REQUIRE(sdp_get_data(&test, &nil));			/* (skip) */
+	ATF_CHECK_EQ(sdp_data_type(&nil), SDP_DATA_NIL);
+
+	ATF_REQUIRE(sdp_get_str(&test, &str, &len));
+	ATF_CHECK(len == 5 && strncmp(str, "STR16", 5) == 0);
+
+	ATF_REQUIRE(sdp_get_str(&test, &str, &len));
+	ATF_CHECK(len == 5 && strncmp(str, "STR32", 5) == 0);
+
+	ATF_CHECK_EQ(test.next, test.end);
+}
+
+ATF_TC(check_sdp_get_url);
+
+ATF_TC_HEAD(check_sdp_get_url, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_get_url results");
+}
+
+ATF_TC_BODY(check_sdp_get_url, tc)
+{
+	uint8_t data[] = {
+		0x45, 0x04, 0x55, 0x52, // url8(4)	"URL8"
+		0x4c, 0x38,
+		0x00,			// nil
+		0x46, 0x00, 0x05, 0x55,	// url16(5)	"URL16"
+		0x52, 0x4c, 0x31, 0x36,
+		0x47, 0x00, 0x00, 0x00,	// url32(5)	"URL32"
+		0x05, 0x55, 0x52, 0x4c,
+		0x33, 0x32,
+	};
+	sdp_data_t test = { data, data + sizeof(data) };
+	sdp_data_t nil;
+	char *url;
+	size_t len;
+
+	/*
+	 * sdp_get_url expects a URL type
+	 * advancing test if successful
+	 */
+	ATF_REQUIRE(sdp_get_url(&test, &url, &len));
+	ATF_CHECK(len == 4 && strncmp(url, "URL8", 4) == 0);
+
+	ATF_REQUIRE_EQ(sdp_get_url(&test, &url, &len), false);	/* not url */
+	ATF_REQUIRE(sdp_get_data(&test, &nil));			/* (skip) */
+	ATF_CHECK_EQ(sdp_data_type(&nil), SDP_DATA_NIL);
+
+	ATF_REQUIRE(sdp_get_url(&test, &url, &len));
+	ATF_CHECK(len == 5 && strncmp(url, "URL16", 5) == 0);
+
+	ATF_REQUIRE(sdp_get_url(&test, &url, &len));
+	ATF_CHECK(len == 5 && strncmp(url, "URL32", 5) == 0);
+
+	ATF_CHECK_EQ(test.next, test.end);
+}
+
+ATF_TP_ADD_TCS(tp)
+{
+
+	ATF_TP_ADD_TC(tp, check_sdp_get_data);
+	ATF_TP_ADD_TC(tp, check_sdp_get_attr);
+	ATF_TP_ADD_TC(tp, check_sdp_get_uuid);
+	ATF_TP_ADD_TC(tp, check_sdp_get_bool);
+	ATF_TP_ADD_TC(tp, check_sdp_get_uint);
+	ATF_TP_ADD_TC(tp, check_sdp_get_int);
+	ATF_TP_ADD_TC(tp, check_sdp_get_seq);
+	ATF_TP_ADD_TC(tp, check_sdp_get_alt);
+	ATF_TP_ADD_TC(tp, check_sdp_get_str);
+	ATF_TP_ADD_TC(tp, check_sdp_get_url);
+
+	return atf_no_error();
+}
diff --git a/contrib/netbsd-tests/lib/libbluetooth/t_sdp_match.c b/contrib/netbsd-tests/lib/libbluetooth/t_sdp_match.c
new file mode 100644
index 0000000..54a5bd5
--- /dev/null
+++ b/contrib/netbsd-tests/lib/libbluetooth/t_sdp_match.c
@@ -0,0 +1,87 @@
+/*	$NetBSD: t_sdp_match.c,v 1.2 2011/04/07 08:29:50 plunky Exp $	*/
+
+/*-
+ * Copyright (c) 2011 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Iain Hibbert.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <atf-c.h>
+
+#include <sdp.h>
+
+ATF_TC(check_sdp_match_uuid16);
+
+ATF_TC_HEAD(check_sdp_match_uuid16, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_match_uuid16 results");
+}
+
+ATF_TC_BODY(check_sdp_match_uuid16, tc)
+{
+	uint8_t data[] = {
+		0x19, 0x11, 0x11,	// uuid16	0x1111
+		0x00,			// nil
+		0x19, 0x12, 0x34,	// uuid16	0x1234
+		0x1a, 0x00, 0x00, 0x34,	// uuid32	0x00003456
+		0x56,
+		0x1c, 0x00, 0x00, 0x43,	// uuid128	00004321-0000-1000-8000-00805f9b34fb
+		0x21, 0x00, 0x00, 0x10,
+		0x00, 0x80, 0x00, 0x00,
+		0x80, 0x5f, 0x9b, 0x34,
+		0xfb,
+	};
+	sdp_data_t test = { data, data + sizeof(data) };
+	sdp_data_t nil;
+
+	/*
+	 * sdp_match_uuid16 advances if the UUID matches the 16-bit short alias given
+	 */
+
+	ATF_REQUIRE_EQ(sdp_match_uuid16(&test, 0x1100), false);	/* mismatch */
+	ATF_REQUIRE(sdp_match_uuid16(&test, 0x1111));
+
+	ATF_REQUIRE_EQ(sdp_match_uuid16(&test, 0x1234), false);	/* not uuid */
+	ATF_REQUIRE(sdp_get_data(&test, &nil));			/* (skip) */
+	ATF_CHECK_EQ(sdp_data_type(&nil), SDP_DATA_NIL);
+	ATF_REQUIRE(sdp_match_uuid16(&test, 0x1234));
+
+	ATF_REQUIRE(sdp_match_uuid16(&test, 0x3456));
+
+	ATF_REQUIRE_EQ(sdp_match_uuid16(&test, 0x1234), false);	/* mismatch */
+	ATF_REQUIRE(sdp_match_uuid16(&test, 0x4321));
+
+	ATF_CHECK_EQ(test.next, test.end);
+}
+
+ATF_TP_ADD_TCS(tp)
+{
+
+	ATF_TP_ADD_TC(tp, check_sdp_match_uuid16);
+
+	return atf_no_error();
+}
diff --git a/contrib/netbsd-tests/lib/libbluetooth/t_sdp_put.c b/contrib/netbsd-tests/lib/libbluetooth/t_sdp_put.c
new file mode 100644
index 0000000..fff4119
--- /dev/null
+++ b/contrib/netbsd-tests/lib/libbluetooth/t_sdp_put.c
@@ -0,0 +1,875 @@
+/*	$NetBSD: t_sdp_put.c,v 1.3 2011/04/16 07:32:27 plunky Exp $	*/
+
+/*-
+ * Copyright (c) 2011 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Iain Hibbert.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <atf-c.h>
+
+#include <limits.h>
+#include <sdp.h>
+#include <string.h>
+
+ATF_TC(check_sdp_put_data);
+
+ATF_TC_HEAD(check_sdp_put_data, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_put_data results");
+}
+
+ATF_TC_BODY(check_sdp_put_data, tc)
+{
+	uint8_t buf[256];
+	sdp_data_t test = { buf, buf + sizeof(buf) };
+	uint8_t data[] = {
+		0x35, 0x05,		// seq8(5)
+		0x08, 0x00,		//   uint8	0x00
+		0x09, 0x12, 0x34,	//   uint16	0x1234
+	};
+	sdp_data_t value = { data, data + sizeof(data) };
+
+	ATF_REQUIRE(sdp_put_data(&test, &value));
+	test.end = test.next;
+	test.next = buf;
+
+	const uint8_t expect[] = {
+		0x35, 0x05,		// seq8(5)
+		0x08, 0x00,		//   uint8	0x00
+		0x09, 0x12, 0x34,	//   uint16	0x1234
+	};
+
+	ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
+	ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
+}
+
+ATF_TC(check_sdp_put_attr);
+
+ATF_TC_HEAD(check_sdp_put_attr, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_put_attr results");
+}
+
+ATF_TC_BODY(check_sdp_put_attr, tc)
+{
+	uint8_t buf[256];
+	sdp_data_t test = { buf, buf + sizeof(buf) };
+	uint8_t data[] = {
+		0x00,			// nil
+		0x19, 0x33, 0x44,	// uuid16	0x3344
+	};
+	sdp_data_t value = { data, data + sizeof(data) };
+
+	ATF_REQUIRE_EQ(sdp_put_attr(&test, 0xabcd, &value), false);
+	value.next += 1; // skip "nil"
+	ATF_REQUIRE(sdp_put_attr(&test, 0x1337, &value));
+	test.end = test.next;
+	test.next = buf;
+
+	const uint8_t expect[] = {
+		0x09, 0x13, 0x37,	// uint16	0x1337
+		0x19, 0x33, 0x44,	// uuid16	0x3344
+	};
+
+	ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
+	ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
+}
+
+ATF_TC(check_sdp_put_uuid);
+
+ATF_TC_HEAD(check_sdp_put_uuid, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_put_uuid results");
+}
+
+ATF_TC_BODY(check_sdp_put_uuid, tc)
+{
+	uint8_t buf[256];
+	sdp_data_t test = { buf, buf + sizeof(buf) };
+	const uuid_t u16 = {
+		0x00001234,
+		0x0000,
+		0x1000,
+		0x80,
+		0x00,
+		{ 0x00, 0x80, 0x5f, 0x9b, 0x34, 0xfb }
+	};
+	const uuid_t u32 = {
+		0x12345678,
+		0x0000,
+		0x1000,
+		0x80,
+		0x00,
+		{ 0x00, 0x80, 0x5f, 0x9b, 0x34, 0xfb }
+	};
+	const uuid_t u128 = {
+		0x00112233,
+		0x4444,
+		0x5555,
+		0x66,
+		0x77,
+		{ 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd }
+	};
+
+	ATF_REQUIRE(sdp_put_uuid(&test, &u16));
+	ATF_REQUIRE(sdp_put_uuid(&test, &u32));
+	ATF_REQUIRE(sdp_put_uuid(&test, &u128));
+	test.end = test.next;
+	test.next = buf;
+
+	const uint8_t expect[] = {
+		0x19, 0x12, 0x34,	// uuid16	0x1234
+		0x1a, 0x12, 0x34, 0x56, // uuid32	0x12345678
+		0x78,
+		0x1c, 0x00, 0x11, 0x22,	// uuid128	00112233-4444-5555-6677-8899aabbccdd
+		0x33, 0x44, 0x44, 0x55,
+		0x55, 0x66, 0x77, 0x88,
+		0x99, 0xaa, 0xbb, 0xcc,
+		0xdd,
+	};
+
+	ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
+	ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
+}
+
+ATF_TC(check_sdp_put_uuid16);
+
+ATF_TC_HEAD(check_sdp_put_uuid16, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_put_uuid16 results");
+}
+
+ATF_TC_BODY(check_sdp_put_uuid16, tc)
+{
+	uint8_t buf[256];
+	sdp_data_t test = { buf, buf + sizeof(buf) };
+
+	ATF_REQUIRE(sdp_put_uuid16(&test, 0x4567));
+	test.end = test.next;
+	test.next = buf;
+
+	const uint8_t expect[] = {
+		0x19, 0x45, 0x67,	// uuid16	0x4567
+	};
+
+	ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
+	ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
+}
+
+ATF_TC(check_sdp_put_uuid32);
+
+ATF_TC_HEAD(check_sdp_put_uuid32, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_put_uuid32 results");
+}
+
+ATF_TC_BODY(check_sdp_put_uuid32, tc)
+{
+	uint8_t buf[256];
+	sdp_data_t test = { buf, buf + sizeof(buf) };
+
+	ATF_REQUIRE(sdp_put_uuid32(&test, 0xabcdef00));
+	test.end = test.next;
+	test.next = buf;
+
+	const uint8_t expect[] = {
+		0x1a, 0xab, 0xcd, 0xef, // uuid32	0xabcdef00
+		0x00,
+	};
+
+	ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
+	ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
+}
+
+ATF_TC(check_sdp_put_uuid128);
+
+ATF_TC_HEAD(check_sdp_put_uuid128, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_put_uuid128 results");
+}
+
+ATF_TC_BODY(check_sdp_put_uuid128, tc)
+{
+	uint8_t buf[256];
+	sdp_data_t test = { buf, buf + sizeof(buf) };
+	uuid_t value = {
+		0x00000100,
+		0x0000,
+		0x1000,
+		0x80,
+		0x00,
+		{ 0x00, 0x80, 0x5f, 0x9b, 0x34, 0xfb }
+	};
+
+	ATF_REQUIRE(sdp_put_uuid128(&test, &value));
+	test.end = test.next;
+	test.next = buf;
+
+	const uint8_t expect[] = {
+		0x1c, 0x00, 0x00, 0x01,	// uuid128	0000100-0000-1000-8000-00805f9b34fb
+		0x00, 0x00, 0x00, 0x10,	//			(L2CAP protocol)
+		0x00, 0x80, 0x00, 0x00,
+		0x80, 0x5f, 0x9b, 0x34,
+		0xfb,
+	};
+
+	ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
+	ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
+}
+
+ATF_TC(check_sdp_put_bool);
+
+ATF_TC_HEAD(check_sdp_put_bool, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_put_bool results");
+}
+
+ATF_TC_BODY(check_sdp_put_bool, tc)
+{
+	uint8_t buf[256];
+	sdp_data_t test = { buf, buf + sizeof(buf) };
+
+	ATF_REQUIRE(sdp_put_bool(&test, true));
+	ATF_REQUIRE(sdp_put_bool(&test, false));
+	test.end = test.next;
+	test.next = buf;
+
+	const uint8_t expect[] = {
+		0x28, 0x01,		// bool	true
+		0x28, 0x00,		// bool	false
+	};
+
+	ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
+	ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
+}
+
+ATF_TC(check_sdp_put_uint);
+
+ATF_TC_HEAD(check_sdp_put_uint, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_put_uint results");
+}
+
+ATF_TC_BODY(check_sdp_put_uint, tc)
+{
+	uint8_t buf[256];
+	sdp_data_t test = { buf, buf + sizeof(buf) };
+
+	ATF_REQUIRE(sdp_put_uint(&test, (uintmax_t)0));
+	ATF_REQUIRE(sdp_put_uint(&test, (uintmax_t)UINT8_MAX));
+	ATF_REQUIRE(sdp_put_uint(&test, (uintmax_t)UINT8_MAX + 1));
+	ATF_REQUIRE(sdp_put_uint(&test, (uintmax_t)UINT16_MAX));
+	ATF_REQUIRE(sdp_put_uint(&test, (uintmax_t)UINT16_MAX + 1));
+	ATF_REQUIRE(sdp_put_uint(&test, (uintmax_t)UINT32_MAX));
+	ATF_REQUIRE(sdp_put_uint(&test, (uintmax_t)UINT32_MAX + 1));
+	ATF_REQUIRE(sdp_put_uint(&test, (uintmax_t)UINT64_MAX));
+	test.end = test.next;
+	test.next = buf;
+
+	const uint8_t expect[] = {
+		0x08, 0x00,		// uint8	0x00
+		0x08, 0xff,		// uint8	0xff
+		0x09, 0x01, 0x00,	// uint16	0x0100
+		0x09, 0xff, 0xff,	// uint16	0xffff
+		0x0a, 0x00, 0x01, 0x00,	// uint32	0x00010000
+		0x00,
+		0x0a, 0xff, 0xff, 0xff,	// uint32	0xffffffff
+		0xff,
+		0x0b, 0x00, 0x00, 0x00,	// uint64	0x0000000100000000
+		0x01, 0x00, 0x00, 0x00,
+		0x00,
+		0x0b, 0xff, 0xff, 0xff,	// uint64	0xffffffffffffffff
+		0xff, 0xff, 0xff, 0xff,
+		0xff,
+	};
+
+	ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
+	ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
+}
+
+ATF_TC(check_sdp_put_uint8);
+
+ATF_TC_HEAD(check_sdp_put_uint8, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_put_uint8 results");
+}
+
+ATF_TC_BODY(check_sdp_put_uint8, tc)
+{
+	uint8_t buf[256];
+	sdp_data_t test = { buf, buf + sizeof(buf) };
+
+	ATF_REQUIRE(sdp_put_uint8(&test, (uint8_t)0));
+	ATF_REQUIRE(sdp_put_uint8(&test, (uint8_t)UINT8_MAX));
+	test.end = test.next;
+	test.next = buf;
+
+	const uint8_t expect[] = {
+		0x08, 0x00,		// uint8	0x00
+		0x08, 0xff,		// uint8	0xff
+	};
+
+	ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
+	ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
+}
+
+ATF_TC(check_sdp_put_uint16);
+
+ATF_TC_HEAD(check_sdp_put_uint16, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_put_uint16 results");
+}
+
+ATF_TC_BODY(check_sdp_put_uint16, tc)
+{
+	uint8_t buf[256];
+	sdp_data_t test = { buf, buf + sizeof(buf) };
+
+	ATF_REQUIRE(sdp_put_uint16(&test, (uint16_t)0));
+	ATF_REQUIRE(sdp_put_uint16(&test, (uint16_t)UINT8_MAX));
+	ATF_REQUIRE(sdp_put_uint16(&test, (uint16_t)UINT16_MAX));
+	ATF_REQUIRE(sdp_put_uint16(&test, (uint16_t)0xabcd));
+	test.end = test.next;
+	test.next = buf;
+
+	const uint8_t expect[] = {
+		0x09, 0x00, 0x00,	// uint16	0x0000
+		0x09, 0x00, 0xff,	// uint16	0x00ff
+		0x09, 0xff, 0xff,	// uint16	0xffff
+		0x09, 0xab, 0xcd,	// uint16	0xabcd
+	};
+
+	ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
+	ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
+}
+
+ATF_TC(check_sdp_put_uint32);
+
+ATF_TC_HEAD(check_sdp_put_uint32, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_put_uint32 results");
+}
+
+ATF_TC_BODY(check_sdp_put_uint32, tc)
+{
+	uint8_t buf[256];
+	sdp_data_t test = { buf, buf + sizeof(buf) };
+
+	ATF_REQUIRE(sdp_put_uint32(&test, (uint32_t)0));
+	ATF_REQUIRE(sdp_put_uint32(&test, (uint32_t)UINT8_MAX));
+	ATF_REQUIRE(sdp_put_uint32(&test, (uint32_t)UINT16_MAX));
+	ATF_REQUIRE(sdp_put_uint32(&test, (uint32_t)UINT32_MAX));
+	ATF_REQUIRE(sdp_put_uint32(&test, (uint32_t)0xdeadbeef));
+	test.end = test.next;
+	test.next = buf;
+
+	const uint8_t expect[] = {
+		0x0a, 0x00, 0x00, 0x00,	// uint32	0x00000000
+		0x00,
+		0x0a, 0x00, 0x00, 0x00,	// uint32	0x000000ff
+		0xff,
+		0x0a, 0x00, 0x00, 0xff,	// uint32	0x0000ffff
+		0xff,
+		0x0a, 0xff, 0xff, 0xff,	// uint32	0xffffffff
+		0xff,
+		0x0a, 0xde, 0xad, 0xbe,	// uint32	0xdeadbeef
+		0xef,
+	};
+
+	ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
+	ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
+}
+
+ATF_TC(check_sdp_put_uint64);
+
+ATF_TC_HEAD(check_sdp_put_uint64, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_put_uint64 results");
+}
+
+ATF_TC_BODY(check_sdp_put_uint64, tc)
+{
+	uint8_t buf[256];
+	sdp_data_t test = { buf, buf + sizeof(buf) };
+
+	ATF_REQUIRE(sdp_put_uint64(&test, (uint64_t)0));
+	ATF_REQUIRE(sdp_put_uint64(&test, (uint64_t)UINT8_MAX));
+	ATF_REQUIRE(sdp_put_uint64(&test, (uint64_t)UINT16_MAX));
+	ATF_REQUIRE(sdp_put_uint64(&test, (uint64_t)UINT32_MAX));
+	ATF_REQUIRE(sdp_put_uint64(&test, (uint64_t)UINT64_MAX));
+	ATF_REQUIRE(sdp_put_uint64(&test, (uint64_t)0xc0ffeecafec0ffee));
+	test.end = test.next;
+	test.next = buf;
+
+	const uint8_t expect[] = {
+		0x0b, 0x00, 0x00, 0x00,	// uint64	0x0000000000000000
+		0x00, 0x00, 0x00, 0x00,
+		0x00,
+		0x0b, 0x00, 0x00, 0x00,	// uint64	0x00000000000000ff
+		0x00, 0x00, 0x00, 0x00,
+		0xff,
+		0x0b, 0x00, 0x00, 0x00,	// uint64	0x000000000000ffff
+		0x00, 0x00, 0x00, 0xff,
+		0xff,
+		0x0b, 0x00, 0x00, 0x00,	// uint64	0x00000000ffffffff
+		0x00, 0xff, 0xff, 0xff,
+		0xff,
+		0x0b, 0xff, 0xff, 0xff,	// uint64	0xffffffffffffffff
+		0xff, 0xff, 0xff, 0xff,
+		0xff,
+		0x0b, 0xc0, 0xff, 0xee,	// uint64	0xc0ffeecafec0ffee
+		0xca, 0xfe, 0xc0, 0xff,
+		0xee,
+	};
+
+	ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
+	ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
+}
+
+ATF_TC(check_sdp_put_int);
+
+ATF_TC_HEAD(check_sdp_put_int, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_put_int results");
+}
+
+ATF_TC_BODY(check_sdp_put_int, tc)
+{
+	uint8_t buf[256];
+	sdp_data_t test = { buf, buf + sizeof(buf) };
+
+	ATF_REQUIRE(sdp_put_int(&test, (intmax_t)0));
+	ATF_REQUIRE(sdp_put_int(&test, (intmax_t)INT8_MIN));
+	ATF_REQUIRE(sdp_put_int(&test, (intmax_t)INT8_MAX));
+	ATF_REQUIRE(sdp_put_int(&test, (intmax_t)INT8_MIN - 1));
+	ATF_REQUIRE(sdp_put_int(&test, (intmax_t)INT8_MAX + 1));
+	ATF_REQUIRE(sdp_put_int(&test, (intmax_t)INT16_MIN));
+	ATF_REQUIRE(sdp_put_int(&test, (intmax_t)INT16_MAX));
+	ATF_REQUIRE(sdp_put_int(&test, (intmax_t)INT16_MIN - 1));
+	ATF_REQUIRE(sdp_put_int(&test, (intmax_t)INT16_MAX + 1));
+	ATF_REQUIRE(sdp_put_int(&test, (intmax_t)INT32_MIN));
+	ATF_REQUIRE(sdp_put_int(&test, (intmax_t)INT32_MAX));
+	ATF_REQUIRE(sdp_put_int(&test, (intmax_t)INT32_MIN - 1));
+	ATF_REQUIRE(sdp_put_int(&test, (intmax_t)INT32_MAX + 1));
+	ATF_REQUIRE(sdp_put_int(&test, (intmax_t)INT64_MIN));
+	ATF_REQUIRE(sdp_put_int(&test, (intmax_t)INT64_MAX));
+	test.end = test.next;
+	test.next = buf;
+
+	const uint8_t expect[] = {
+		0x10, 0x00,		// int8		0
+		0x10, 0x80,		// int8		-128
+		0x10, 0x7f,		// int8		127
+		0x11, 0xff, 0x7f,	// int16	-129
+		0x11, 0x00, 0x80,	// int16	128
+		0x11, 0x80, 0x00,	// int16	-32768
+		0x11, 0x7f, 0xff,	// int16	32767
+		0x12, 0xff, 0xff, 0x7f,	// int32	-32769
+		0xff,
+		0x12, 0x00, 0x00, 0x80,	// int32	32768
+		0x00,
+		0x12, 0x80, 0x00, 0x00,	// int32	-2147483648
+		0x00,
+		0x12, 0x7f, 0xff, 0xff,	// int32	2147483647
+		0xff,
+		0x13, 0xff, 0xff, 0xff,	// int64	-2147483649
+		0xff, 0x7f, 0xff, 0xff,
+		0xff,
+		0x13, 0x00, 0x00, 0x00,	// int64	2147483648
+		0x00, 0x80, 0x00, 0x00,
+		0x00,
+		0x13, 0x80, 0x00, 0x00,	// int64	-9223372036854775808
+		0x00, 0x00, 0x00, 0x00,
+		0x00,
+		0x13, 0x7f, 0xff, 0xff,	// int64	9223372036854775807
+		0xff, 0xff, 0xff, 0xff,
+		0xff,
+	};
+
+	ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
+	ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
+}
+
+ATF_TC(check_sdp_put_int8);
+
+ATF_TC_HEAD(check_sdp_put_int8, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_put_int8 results");
+}
+
+ATF_TC_BODY(check_sdp_put_int8, tc)
+{
+	uint8_t buf[256];
+	sdp_data_t test = { buf, buf + sizeof(buf) };
+
+	ATF_REQUIRE(sdp_put_int8(&test, (int8_t)0));
+	ATF_REQUIRE(sdp_put_int8(&test, (int8_t)INT8_MIN));
+	ATF_REQUIRE(sdp_put_int8(&test, (int8_t)INT8_MAX));
+	test.end = test.next;
+	test.next = buf;
+
+	const uint8_t expect[] = {
+		0x10, 0x00,		// int8		0
+		0x10, 0x80,		// int8		-128
+		0x10, 0x7f,		// int8		127
+	};
+
+	ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
+	ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
+}
+
+ATF_TC(check_sdp_put_int16);
+
+ATF_TC_HEAD(check_sdp_put_int16, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_put_int16 results");
+}
+
+ATF_TC_BODY(check_sdp_put_int16, tc)
+{
+	uint8_t buf[256];
+	sdp_data_t test = { buf, buf + sizeof(buf) };
+
+	ATF_REQUIRE(sdp_put_int16(&test, (int16_t)0));
+	ATF_REQUIRE(sdp_put_int16(&test, (int16_t)INT8_MIN));
+	ATF_REQUIRE(sdp_put_int16(&test, (int16_t)INT8_MAX));
+	ATF_REQUIRE(sdp_put_int16(&test, (int16_t)INT16_MIN));
+	ATF_REQUIRE(sdp_put_int16(&test, (int16_t)INT16_MAX));
+	test.end = test.next;
+	test.next = buf;
+
+	const uint8_t expect[] = {
+		0x11, 0x00, 0x00,	// int16	0
+		0x11, 0xff, 0x80,	// int16	-128
+		0x11, 0x00, 0x7f,	// int16	127
+		0x11, 0x80, 0x00,	// int16	-32768
+		0x11, 0x7f, 0xff,	// int16	32767
+	};
+
+	ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
+	ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
+}
+
+ATF_TC(check_sdp_put_int32);
+
+ATF_TC_HEAD(check_sdp_put_int32, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_put_int32 results");
+}
+
+ATF_TC_BODY(check_sdp_put_int32, tc)
+{
+	uint8_t buf[256];
+	sdp_data_t test = { buf, buf + sizeof(buf) };
+
+	ATF_REQUIRE(sdp_put_int32(&test, (int32_t)0));
+	ATF_REQUIRE(sdp_put_int32(&test, (int32_t)INT8_MIN));
+	ATF_REQUIRE(sdp_put_int32(&test, (int32_t)INT8_MAX));
+	ATF_REQUIRE(sdp_put_int32(&test, (int32_t)INT16_MIN));
+	ATF_REQUIRE(sdp_put_int32(&test, (int32_t)INT16_MAX));
+	ATF_REQUIRE(sdp_put_int32(&test, (int32_t)INT32_MIN));
+	ATF_REQUIRE(sdp_put_int32(&test, (int32_t)INT32_MAX));
+	test.end = test.next;
+	test.next = buf;
+
+	const uint8_t expect[] = {
+		0x12, 0x00, 0x00, 0x00,	// int32	0
+		0x00,
+		0x12, 0xff, 0xff, 0xff,	// int32	-128
+		0x80,
+		0x12, 0x00, 0x00, 0x00,	// int32	127
+		0x7f,
+		0x12, 0xff, 0xff, 0x80,	// int32	-32768
+		0x00,
+		0x12, 0x00, 0x00, 0x7f,	// int32	32767
+		0xff,
+		0x12, 0x80, 0x00, 0x00,	// int32	-2147483648
+		0x00,
+		0x12, 0x7f, 0xff, 0xff,	// int32	2147483647
+		0xff,
+	};
+
+	ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
+	ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
+}
+
+ATF_TC(check_sdp_put_int64);
+
+ATF_TC_HEAD(check_sdp_put_int64, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_put_int64 results");
+}
+
+ATF_TC_BODY(check_sdp_put_int64, tc)
+{
+	uint8_t buf[256];
+	sdp_data_t test = { buf, buf + sizeof(buf) };
+
+	ATF_REQUIRE(sdp_put_int64(&test, (int64_t)0));
+	ATF_REQUIRE(sdp_put_int64(&test, (int64_t)INT8_MIN));
+	ATF_REQUIRE(sdp_put_int64(&test, (int64_t)INT8_MAX));
+	ATF_REQUIRE(sdp_put_int64(&test, (int64_t)INT16_MIN));
+	ATF_REQUIRE(sdp_put_int64(&test, (int64_t)INT16_MAX));
+	ATF_REQUIRE(sdp_put_int64(&test, (int64_t)INT32_MIN));
+	ATF_REQUIRE(sdp_put_int64(&test, (int64_t)INT32_MAX));
+	ATF_REQUIRE(sdp_put_int64(&test, (int64_t)INT64_MIN));
+	ATF_REQUIRE(sdp_put_int64(&test, (int64_t)INT64_MAX));
+	test.end = test.next;
+	test.next = buf;
+
+	const uint8_t expect[] = {
+		0x13, 0x00, 0x00, 0x00,	// int64	0
+		0x00, 0x00, 0x00, 0x00,
+		0x00,
+		0x13, 0xff, 0xff, 0xff,	// int64	-128
+		0xff, 0xff, 0xff, 0xff,
+		0x80,
+		0x13, 0x00, 0x00, 0x00,	// int64	127
+		0x00, 0x00, 0x00, 0x00,
+		0x7f,
+		0x13, 0xff, 0xff, 0xff,	// int64	-32768
+		0xff, 0xff, 0xff, 0x80,
+		0x00,
+		0x13, 0x00, 0x00, 0x00,	// int64	32767
+		0x00, 0x00, 0x00, 0x7f,
+		0xff,
+		0x13, 0xff, 0xff, 0xff,	// int64	-2147483648
+		0xff, 0x80, 0x00, 0x00,
+		0x00,
+		0x13, 0x00, 0x00, 0x00,	// int64	2147483647
+		0x00, 0x7f, 0xff, 0xff,
+		0xff,
+		0x13, 0x80, 0x00, 0x00,	// int64	-9223372036854775808
+		0x00, 0x00, 0x00, 0x00,
+		0x00,
+		0x13, 0x7f, 0xff, 0xff,	// int64	9223372036854775807
+		0xff, 0xff, 0xff, 0xff,
+		0xff,
+	};
+
+	ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
+	ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
+}
+
+ATF_TC(check_sdp_put_seq);
+
+ATF_TC_HEAD(check_sdp_put_seq, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_put_seq results");
+}
+
+ATF_TC_BODY(check_sdp_put_seq, tc)
+{
+	uint8_t buf[512];
+	sdp_data_t test = { buf, buf + sizeof(buf) };
+
+	ATF_REQUIRE(sdp_put_seq(&test, (ssize_t)0));
+	ATF_REQUIRE(sdp_put_seq(&test, (ssize_t)UINT8_MAX));
+	ATF_REQUIRE(sdp_put_seq(&test, (ssize_t)UINT8_MAX + 1));
+	ATF_REQUIRE(sdp_put_seq(&test, (ssize_t)-1));
+	ATF_CHECK_EQ(sdp_put_seq(&test, (ssize_t)UINT16_MAX), false);	/* no room */
+	ATF_CHECK_EQ(sdp_put_seq(&test, (ssize_t)SSIZE_MAX), false);	/* no room */
+	test.end = test.next;
+	test.next = buf;
+
+	/* (not a valid element list) */
+	const uint8_t expect[] = {
+		0x35, 0x00,		// seq8(0)
+		0x35, 0xff,		// seq8(255)
+		0x36, 0x01, 0x00,	// seq16(256)
+		0x36, 0x01, 0xf6,	// seq16(502)	<- sizeof(buf) - 7 - 3
+	};
+
+	ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
+	ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
+}
+
+ATF_TC(check_sdp_put_alt);
+
+ATF_TC_HEAD(check_sdp_put_alt, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_put_alt results");
+}
+
+ATF_TC_BODY(check_sdp_put_alt, tc)
+{
+	uint8_t buf[512];
+	sdp_data_t test = { buf, buf + sizeof(buf) };
+
+	ATF_REQUIRE(sdp_put_alt(&test, (ssize_t)0));
+	ATF_REQUIRE(sdp_put_alt(&test, (ssize_t)UINT8_MAX));
+	ATF_REQUIRE(sdp_put_alt(&test, (ssize_t)UINT8_MAX + 1));
+	ATF_REQUIRE(sdp_put_alt(&test, (ssize_t)-1));
+	ATF_CHECK_EQ(sdp_put_alt(&test, (ssize_t)UINT16_MAX), false);	/* no room */
+	ATF_CHECK_EQ(sdp_put_alt(&test, (ssize_t)SSIZE_MAX), false);	/* no room */
+	test.end = test.next;
+	test.next = buf;
+
+	/* (not a valid element list) */
+	const uint8_t expect[] = {
+		0x3d, 0x00,		// alt8(0)
+		0x3d, 0xff,		// alt8(255)
+		0x3e, 0x01, 0x00,	// alt16(256)
+		0x3e, 0x01, 0xf6,	// alt16(502)	<- sizeof(buf) - 7 - 3
+	};
+
+	ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
+	ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
+}
+
+ATF_TC(check_sdp_put_str);
+
+ATF_TC_HEAD(check_sdp_put_str, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_put_str results");
+}
+
+ATF_TC_BODY(check_sdp_put_str, tc)
+{
+	uint8_t buf[512];
+	sdp_data_t test = { buf, buf + sizeof(buf) };
+
+	/*
+	 * this does not test str16 or str32, but that is
+	 * handled by the same code as sdp_put_seq above..
+	 */
+
+	ATF_REQUIRE(sdp_put_str(&test, "Hello World!", 5));
+	ATF_REQUIRE(sdp_put_str(&test, "Hello\0World", 11));
+	ATF_REQUIRE(sdp_put_str(&test, "Hello World!", -1));
+	ATF_REQUIRE(sdp_put_str(&test, "Hello\0World", -1));
+	test.end = test.next;
+	test.next = buf;
+
+	const uint8_t expect[] = {
+		0x25, 0x05, 0x48, 0x65,	// str8		"Hello"
+		0x6c, 0x6c, 0x6f,
+		0x25, 0x0b, 0x48, 0x65,	// str8		"Hello\0World"
+		0x6c, 0x6c, 0x6f, 0x00,
+		0x57, 0x6f, 0x72, 0x6c,
+		0x64,
+		0x25, 0x0c, 0x48, 0x65,	// str8		"Hello World!"
+		0x6c, 0x6c, 0x6f, 0x20,
+		0x57, 0x6f, 0x72, 0x6c,
+		0x64, 0x21,
+		0x25, 0x05, 0x48, 0x65,	// str8		"Hello"
+		0x6c, 0x6c, 0x6f,
+	};
+
+	ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
+	ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
+}
+
+ATF_TC(check_sdp_put_url);
+
+ATF_TC_HEAD(check_sdp_put_url, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_put_url results");
+}
+
+ATF_TC_BODY(check_sdp_put_url, tc)
+{
+	uint8_t buf[512];
+	sdp_data_t test = { buf, buf + sizeof(buf) };
+
+	/*
+	 * this does not test url16 or url32, but that is
+	 * handled by the same code as sdp_put_seq above..
+	 */
+
+	ATF_REQUIRE(sdp_put_url(&test, "http://www.netbsd.org/", 21));
+	ATF_REQUIRE(sdp_put_url(&test, "http://www.netbsd.org/", -1));
+	test.end = test.next;
+	test.next = buf;
+
+	const uint8_t expect[] = {
+		0x45, 0x15, 0x68, 0x74,	// url8	"http://www.netbsd.org"
+		0x74, 0x70, 0x3a, 0x2f,
+		0x2f, 0x77, 0x77, 0x77,
+		0x2e, 0x6e, 0x65, 0x74,
+		0x62, 0x73, 0x64, 0x2e,
+		0x6f, 0x72, 0x67,
+		0x45, 0x16, 0x68, 0x74,	// url8	"http://www.netbsd.org/"
+		0x74, 0x70, 0x3a, 0x2f,
+		0x2f, 0x77, 0x77, 0x77,
+		0x2e, 0x6e, 0x65, 0x74,
+		0x62, 0x73, 0x64, 0x2e,
+		0x6f, 0x72, 0x67, 0x2f,
+	};
+
+	ATF_REQUIRE_EQ(test.end - test.next, sizeof(expect));
+	ATF_CHECK(memcmp(expect, test.next, sizeof(expect)) == 0);
+}
+
+ATF_TP_ADD_TCS(tp)
+{
+
+	ATF_TP_ADD_TC(tp, check_sdp_put_data);
+	ATF_TP_ADD_TC(tp, check_sdp_put_attr);
+	ATF_TP_ADD_TC(tp, check_sdp_put_uuid);
+	ATF_TP_ADD_TC(tp, check_sdp_put_uuid16);
+	ATF_TP_ADD_TC(tp, check_sdp_put_uuid32);
+	ATF_TP_ADD_TC(tp, check_sdp_put_uuid128);
+	ATF_TP_ADD_TC(tp, check_sdp_put_bool);
+	ATF_TP_ADD_TC(tp, check_sdp_put_uint);
+	ATF_TP_ADD_TC(tp, check_sdp_put_uint8);
+	ATF_TP_ADD_TC(tp, check_sdp_put_uint16);
+	ATF_TP_ADD_TC(tp, check_sdp_put_uint32);
+	ATF_TP_ADD_TC(tp, check_sdp_put_uint64);
+	ATF_TP_ADD_TC(tp, check_sdp_put_int);
+	ATF_TP_ADD_TC(tp, check_sdp_put_int8);
+	ATF_TP_ADD_TC(tp, check_sdp_put_int16);
+	ATF_TP_ADD_TC(tp, check_sdp_put_int32);
+	ATF_TP_ADD_TC(tp, check_sdp_put_int64);
+	ATF_TP_ADD_TC(tp, check_sdp_put_seq);
+	ATF_TP_ADD_TC(tp, check_sdp_put_alt);
+	ATF_TP_ADD_TC(tp, check_sdp_put_str);
+	ATF_TP_ADD_TC(tp, check_sdp_put_url);
+
+	return atf_no_error();
+}
diff --git a/contrib/netbsd-tests/lib/libbluetooth/t_sdp_set.c b/contrib/netbsd-tests/lib/libbluetooth/t_sdp_set.c
new file mode 100644
index 0000000..be5d953
--- /dev/null
+++ b/contrib/netbsd-tests/lib/libbluetooth/t_sdp_set.c
@@ -0,0 +1,359 @@
+/*	$NetBSD: t_sdp_set.c,v 1.2 2011/04/07 08:29:50 plunky Exp $	*/
+
+/*-
+ * Copyright (c) 2011 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Iain Hibbert.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <atf-c.h>
+
+#include <limits.h>
+#include <sdp.h>
+#include <string.h>
+
+ATF_TC(check_sdp_set_bool);
+
+ATF_TC_HEAD(check_sdp_set_bool, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_set_bool results");
+}
+
+ATF_TC_BODY(check_sdp_set_bool, tc)
+{
+	uint8_t data[] = {
+		0x28, 0x00,	// bool	false
+		0x00,		// nil
+		0x28,		// bool <invalid>
+	};
+	sdp_data_t test = { data, data + sizeof(data) };
+	sdp_data_t discard;
+
+	ATF_CHECK_EQ(sdp_data_type(&test), SDP_DATA_BOOL);
+	ATF_REQUIRE(sdp_set_bool(&test, true));
+	ATF_CHECK_EQ(test.next[1], 0x01);
+	ATF_REQUIRE(sdp_set_bool(&test, false));
+	ATF_CHECK_EQ(test.next[1], 0x00);
+	ATF_REQUIRE(sdp_get_data(&test, &discard));
+
+	ATF_CHECK_EQ(sdp_data_type(&test), SDP_DATA_NIL);
+	ATF_CHECK_EQ(sdp_set_bool(&test, true), false);		/* not bool */
+	ATF_REQUIRE(sdp_get_data(&test, &discard));
+
+	ATF_CHECK_EQ(sdp_data_type(&test), SDP_DATA_BOOL);
+	ATF_CHECK_EQ(sdp_set_bool(&test, true), false);		/* no value */
+}
+
+ATF_TC(check_sdp_set_uint);
+
+ATF_TC_HEAD(check_sdp_set_uint, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_set_uint results");
+}
+
+ATF_TC_BODY(check_sdp_set_uint, tc)
+{
+	uint8_t data[] = {
+		0x08, 0x00,		// uint8	0x00
+		0x00,			// nil
+		0x09, 0x00, 0x00,	// uint16	0x0000
+		0x0a, 0x00, 0x00, 0x00,	// uint32	0x00000000
+		0x00,
+		0x0b, 0x00, 0x00, 0x00,	// uint64	0x0000000000000000
+		0x00, 0x00, 0x00, 0x00,
+		0x00,
+		0x0c, 0x00, 0x44, 0x00,	// uint128	0x00440044004400440044004400440044
+		0x44, 0x00, 0x44, 0x00,
+		0x44, 0x00, 0x44, 0x00,
+		0x44, 0x00, 0x44, 0x00,
+		0x00,
+		0x09, 0x00,		// uint16	<invalid>
+	};
+	sdp_data_t test = { data, data + sizeof(data) };
+	sdp_data_t discard;
+
+	ATF_CHECK_EQ(sdp_data_type(&test), SDP_DATA_UINT8);
+	ATF_REQUIRE(sdp_set_uint(&test, 0x44));
+	ATF_CHECK_EQ(sdp_set_uint(&test, UINT8_MAX + 1), false);	/* too big */
+	ATF_REQUIRE(sdp_get_data(&test, &discard));
+
+	ATF_CHECK_EQ(sdp_data_type(&test), SDP_DATA_NIL);
+	ATF_CHECK_EQ(sdp_set_uint(&test, 0x00), false);			/* not uint */
+	ATF_REQUIRE(sdp_get_data(&test, &discard));
+
+	ATF_CHECK_EQ(sdp_data_type(&test), SDP_DATA_UINT16);
+	ATF_REQUIRE(sdp_set_uint(&test, 0xabcd));
+	ATF_CHECK_EQ(sdp_set_uint(&test, UINT16_MAX + 1), false);	/* too big */
+	ATF_REQUIRE(sdp_get_data(&test, &discard));
+
+	ATF_CHECK_EQ(sdp_data_type(&test), SDP_DATA_UINT32);
+	ATF_REQUIRE(sdp_set_uint(&test, 0xdeadbeef));
+	ATF_CHECK_EQ(sdp_set_uint(&test, (uintmax_t)UINT32_MAX + 1), false);	/* too big */
+	ATF_REQUIRE(sdp_get_data(&test, &discard));
+
+	ATF_CHECK_EQ(sdp_data_type(&test), SDP_DATA_UINT64);
+	ATF_REQUIRE(sdp_set_uint(&test, 0xc0ffeecafec0ffee));
+	ATF_REQUIRE(sdp_get_data(&test, &discard));
+
+	ATF_CHECK_EQ(sdp_data_type(&test), SDP_DATA_UINT128);
+	ATF_REQUIRE(sdp_set_uint(&test, 0xabcdef0123456789));
+	ATF_REQUIRE(sdp_get_data(&test, &discard));
+
+	ATF_CHECK_EQ(sdp_data_type(&test), SDP_DATA_UINT16);
+	ATF_CHECK_EQ(sdp_set_uint(&test, 0x3344), false);		/* no value */
+
+	const uint8_t expect[] = {
+		0x08, 0x44,		// uint8	0x44
+		0x00,			// nil
+		0x09, 0xab, 0xcd,	// uint16	0xabcd
+		0x0a, 0xde, 0xad, 0xbe,	// uint32	0xdeadbeef
+		0xef,
+		0x0b, 0xc0, 0xff, 0xee,	// uint64	0xc0ffeecafec0ffee
+		0xca, 0xfe, 0xc0, 0xff,
+		0xee,
+		0x0c, 0x00, 0x00, 0x00,	// uint128	0x0000000000000000abcdef0123456789
+		0x00, 0x00, 0x00, 0x00,
+		0x00, 0xab, 0xcd, 0xef,
+		0x01, 0x23, 0x45, 0x67,
+		0x89,
+		0x09, 0x00,		// uint16	<invalid>
+	};
+
+	ATF_REQUIRE_EQ(sizeof(data), sizeof(expect));
+	ATF_CHECK(memcmp(expect, data, sizeof(expect)) == 0);
+}
+
+ATF_TC(check_sdp_set_int);
+
+ATF_TC_HEAD(check_sdp_set_int, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_set_int results");
+}
+
+ATF_TC_BODY(check_sdp_set_int, tc)
+{
+	uint8_t data[] = {
+		0x10, 0x00,		// int8		0
+		0x00,			// nil
+		0x11, 0x00, 0x00,	// int16	0
+		0x12, 0x00, 0x00, 0x00,	// int32	0
+		0x00,
+		0x13, 0x00, 0x00, 0x00,	// int64	0
+		0x00, 0x00, 0x00, 0x00,
+		0x00,
+		0x14, 0x00, 0x44, 0x00,	// int128	0x00440044004400440044004400440044
+		0x44, 0x00, 0x44, 0x00,
+		0x44, 0x00, 0x44, 0x00,
+		0x44, 0x00, 0x44, 0x00,
+		0x00,
+		0x11, 0x00,		// int16	<invalid>
+	};
+	sdp_data_t test = { data, data + sizeof(data) };
+	sdp_data_t discard;
+
+	ATF_CHECK_EQ(sdp_data_type(&test), SDP_DATA_INT8);
+	ATF_REQUIRE(sdp_set_int(&test, -1));
+	ATF_CHECK_EQ(sdp_set_int(&test, INT8_MAX + 1), false);	/* too big */
+	ATF_REQUIRE(sdp_get_data(&test, &discard));
+
+	ATF_CHECK_EQ(sdp_data_type(&test), SDP_DATA_NIL);
+	ATF_CHECK_EQ(sdp_set_int(&test, 33), false);		/* not int */
+	ATF_REQUIRE(sdp_get_data(&test, &discard));
+
+	ATF_CHECK_EQ(sdp_data_type(&test), SDP_DATA_INT16);
+	ATF_REQUIRE(sdp_set_int(&test, 789));
+	ATF_CHECK_EQ(sdp_set_int(&test, INT16_MIN - 1), false);	/* too big */
+	ATF_REQUIRE(sdp_get_data(&test, &discard));
+
+	ATF_CHECK_EQ(sdp_data_type(&test), SDP_DATA_INT32);
+	ATF_REQUIRE(sdp_set_int(&test, -4567));
+	ATF_CHECK_EQ(sdp_set_int(&test, (intmax_t)INT32_MAX + 1), false);	/* too big */
+	ATF_REQUIRE(sdp_get_data(&test, &discard));
+
+	ATF_CHECK_EQ(sdp_data_type(&test), SDP_DATA_INT64);
+	ATF_REQUIRE(sdp_set_int(&test, -3483738234));
+	ATF_REQUIRE(sdp_get_data(&test, &discard));
+
+	ATF_CHECK_EQ(sdp_data_type(&test), SDP_DATA_INT128);
+	ATF_REQUIRE(sdp_set_int(&test, 3423489463464));
+	ATF_REQUIRE(sdp_get_data(&test, &discard));
+
+	ATF_CHECK_EQ(sdp_data_type(&test), SDP_DATA_INT16);
+	ATF_CHECK_EQ(sdp_set_int(&test, 1234), false);		/* no value */
+
+	const uint8_t expect[] = {
+		0x10, 0xff,		// int8		-1
+		0x00,			// nil
+		0x11, 0x03, 0x15,	// int16	789
+		0x12, 0xff, 0xff, 0xee,	// int32	-4567
+		0x29,
+		0x13, 0xff, 0xff, 0xff,	// int64	-3483738234
+		0xff, 0x30, 0x5a, 0x5f,
+		0x86,
+		0x14, 0x00, 0x00, 0x00,	// int128	3423489463464
+		0x00, 0x00, 0x00, 0x00,
+		0x00, 0x00, 0x00, 0x03,
+		0x1d, 0x17, 0xdf, 0x94,
+		0xa8,
+		0x11, 0x00,		// int16	<invalid>
+	};
+
+	ATF_REQUIRE_EQ(sizeof(data), sizeof(expect));
+	ATF_CHECK(memcmp(expect, data, sizeof(expect)) == 0);
+}
+
+ATF_TC(check_sdp_set_seq);
+
+ATF_TC_HEAD(check_sdp_set_seq, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_set_seq results");
+}
+
+ATF_TC_BODY(check_sdp_set_seq, tc)
+{
+	uint8_t data[] = {
+		0x35, 0x03,		// seq8(3)
+		0x11, 0xff, 0xff,	//   int16	-1
+		0x36, 0x01, 0x00,	// seq16(256)
+		0x09, 0xff, 0xff,	// uint16	0xffff
+		0x37, 0x01, 0x02, 0x03,	// seq32(16909060)
+		0x04,
+		0x36, 0x00,		// seq16(<invalid>)
+	};
+	sdp_data_t test = { data, data + sizeof(data) };
+	sdp_data_t discard;
+
+	ATF_CHECK_EQ(sdp_data_type(&test), SDP_DATA_SEQ8);
+	ATF_REQUIRE(sdp_set_seq(&test, 0));
+	ATF_CHECK_EQ(sdp_set_seq(&test, UINT8_MAX), false);	/* data too big */
+	ATF_CHECK_EQ(sdp_set_seq(&test, UINT16_MAX), false);	/* size too big */
+	ATF_REQUIRE(sdp_get_data(&test, &discard));
+
+	ATF_CHECK_EQ(sdp_data_type(&test), SDP_DATA_INT16);
+	ATF_CHECK_EQ(sdp_set_seq(&test, 33), false);		/* not seq */
+	ATF_REQUIRE(sdp_get_data(&test, &discard));
+
+	ATF_CHECK_EQ(sdp_data_type(&test), SDP_DATA_SEQ16);
+	ATF_REQUIRE(sdp_set_seq(&test, 3));
+	ATF_CHECK_EQ(sdp_set_seq(&test, SSIZE_MAX), false);	/* size too big */
+	ATF_REQUIRE(sdp_get_data(&test, &discard));
+
+	ATF_CHECK_EQ(sdp_data_type(&test), SDP_DATA_SEQ32);
+	ATF_REQUIRE(sdp_set_seq(&test, 0));
+	ATF_REQUIRE(sdp_get_data(&test, &discard));
+
+	ATF_CHECK_EQ(sdp_data_type(&test), SDP_DATA_SEQ16);
+	ATF_CHECK_EQ(sdp_set_seq(&test, 22), false);		/* no size */
+
+	const uint8_t expect[] = {
+		0x35, 0x00,		// seq8(0)
+		0x11, 0xff, 0xff,	// int16	-1
+		0x36, 0x00, 0x03,	// seq16(3)
+		0x09, 0xff, 0xff,	//   uint16	0xffff
+		0x37, 0x00, 0x00, 0x00,	// seq32(0)
+		0x00,
+		0x36, 0x00,		// seq16(<invalid>)
+	};
+
+	ATF_REQUIRE_EQ(sizeof(data), sizeof(expect));
+	ATF_CHECK(memcmp(expect, data, sizeof(expect)) == 0);
+}
+
+ATF_TC(check_sdp_set_alt);
+
+ATF_TC_HEAD(check_sdp_set_alt, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr", "Test sdp_set_alt results");
+}
+
+ATF_TC_BODY(check_sdp_set_alt, tc)
+{
+	uint8_t data[] = {
+		0x3d, 0x06,		// alt8(6)
+		0x11, 0xff, 0xff,	//   int16	-1
+		0x3e, 0xff, 0xff,	//   alt16(65535)
+		0x3f, 0x01, 0x02, 0x03,	// alt32(16909060)
+		0x04,
+		0x0a, 0x00, 0x00, 0x00,	// uint32	0x00000003
+		0x03,
+		0x3e, 0x00,		// alt16(<invalid>)
+	};
+	sdp_data_t test = { data, data + sizeof(data) };
+	sdp_data_t discard;
+
+	ATF_CHECK_EQ(sdp_data_type(&test), SDP_DATA_ALT8);
+	ATF_REQUIRE(sdp_set_alt(&test, 0));
+	ATF_CHECK_EQ(sdp_set_alt(&test, UINT8_MAX), false);	/* data too big */
+	ATF_CHECK_EQ(sdp_set_alt(&test, UINT16_MAX), false);	/* size too big */
+	ATF_REQUIRE(sdp_get_data(&test, &discard));
+
+	ATF_CHECK_EQ(sdp_data_type(&test), SDP_DATA_INT16);
+	ATF_CHECK_EQ(sdp_set_alt(&test, 27), false);		/* not alt */
+	ATF_REQUIRE(sdp_get_data(&test, &discard));
+
+	ATF_CHECK_EQ(sdp_data_type(&test), SDP_DATA_ALT16);
+	ATF_REQUIRE(sdp_set_alt(&test, 10));
+	ATF_CHECK_EQ(sdp_set_alt(&test, SSIZE_MAX), false);	/* size too big */
+	ATF_REQUIRE(sdp_get_alt(&test, &discard));
+	ATF_CHECK_EQ(sdp_data_type(&discard), SDP_DATA_ALT32);
+	ATF_CHECK(sdp_set_alt(&discard, -1));			/* end of alt16 */
+	ATF_CHECK_EQ(sdp_set_alt(&discard, 6), false);		/* data too big */
+
+	ATF_CHECK_EQ(sdp_data_type(&test), SDP_DATA_ALT16);
+	ATF_CHECK_EQ(sdp_set_alt(&test, 22), false);		/* no size */
+
+	const uint8_t expect[] = {
+		0x3d, 0x00,		// alt8(0)
+		0x11, 0xff, 0xff,	// int16	-1
+		0x3e, 0x00, 0x0a,	// alt16(10)
+		0x3f, 0x00, 0x00, 0x00,	//   alt32(5)
+		0x05,
+		0x0a, 0x00, 0x00, 0x00,	//     uint32	0x00000003
+		0x03,
+		0x3e, 0x00,		// alt16(<invalid>)
+	};
+
+	ATF_REQUIRE_EQ(sizeof(data), sizeof(expect));
+	ATF_CHECK(memcmp(expect, data, sizeof(expect)) == 0);
+}
+
+
+ATF_TP_ADD_TCS(tp)
+{
+
+	ATF_TP_ADD_TC(tp, check_sdp_set_bool);
+	ATF_TP_ADD_TC(tp, check_sdp_set_uint);
+	ATF_TP_ADD_TC(tp, check_sdp_set_int);
+	ATF_TP_ADD_TC(tp, check_sdp_set_seq);
+	ATF_TP_ADD_TC(tp, check_sdp_set_alt);
+
+	return atf_no_error();
+}