Adding upstream version 0.3.65.upstream/0.3.65upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1043 insertions, 0 deletions

diff --git a/test/test-spa-utils.c b/test/test-spa-utils.c
new file mode 100644
index 0000000..4184f43
--- /dev/null
+++ b/test/test-spa-utils.c
@@ -0,0 +1,1043 @@
+/* Simple Plugin API
+ * Copyright © 2018 Collabora Ltd.
+ *   @author George Kiagiadakis <george.kiagiadakis@collabora.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include <locale.h>
+#include <unistd.h>
+#include <sys/wait.h>
+
+#include <valgrind/valgrind.h>
+
+#include <spa/utils/defs.h>
+#include <spa/utils/result.h>
+#include <spa/utils/dict.h>
+#include <spa/utils/list.h>
+#include <spa/utils/hook.h>
+#include <spa/utils/ringbuffer.h>
+#include <spa/utils/string.h>
+#include <spa/utils/type.h>
+#include <spa/utils/ansi.h>
+
+#include "pwtest.h"
+
+PWTEST(utils_abi_sizes)
+{
+#if defined(__x86_64__) && defined(__LP64__)
+	/* dict */
+	pwtest_int_eq(sizeof(struct spa_dict_item), 16U);
+	pwtest_int_eq(sizeof(struct spa_dict), 16U);
+
+	/* hook */
+	pwtest_int_eq(sizeof(struct spa_hook_list), sizeof(struct spa_list));
+	pwtest_int_eq(sizeof(struct spa_hook), 48U);
+
+	/* list */
+	pwtest_int_eq(sizeof(struct spa_list), 16U);
+
+	return PWTEST_PASS;
+#endif
+
+	return PWTEST_SKIP;
+}
+
+PWTEST(utils_abi)
+{
+	/* defs */
+	pwtest_int_eq(SPA_DIRECTION_INPUT, 0);
+	pwtest_int_eq(SPA_DIRECTION_OUTPUT, 1);
+
+	pwtest_int_eq(sizeof(struct spa_rectangle), 8U);
+	pwtest_int_eq(sizeof(struct spa_point), 8U);
+	pwtest_int_eq(sizeof(struct spa_region), 16U);
+	pwtest_int_eq(sizeof(struct spa_fraction), 8U);
+
+	{
+		struct spa_rectangle r = SPA_RECTANGLE(12, 14);
+		pwtest_int_eq(r.width, 12U);
+		pwtest_int_eq(r.height, 14U);
+	}
+	{
+		struct spa_point p = SPA_POINT(8, 34);
+		pwtest_int_eq(p.x, 8);
+		pwtest_int_eq(p.y, 34);
+	}
+	{
+		struct spa_region r = SPA_REGION(4, 5, 12, 13);
+		pwtest_int_eq(r.position.x, 4);
+		pwtest_int_eq(r.position.y, 5);
+		pwtest_int_eq(r.size.width, 12U);
+		pwtest_int_eq(r.size.height, 13U);
+	}
+	{
+		struct spa_fraction f = SPA_FRACTION(56, 125);
+		pwtest_int_eq(f.num, 56U);
+		pwtest_int_eq(f.denom, 125U);
+	}
+
+	/* ringbuffer */
+	pwtest_int_eq(sizeof(struct spa_ringbuffer), 8U);
+
+	/* type */
+	pwtest_int_eq(SPA_TYPE_START, 0);
+	pwtest_int_eq(SPA_TYPE_None, 1);
+	pwtest_int_eq(SPA_TYPE_Bool, 2);
+	pwtest_int_eq(SPA_TYPE_Id, 3);
+	pwtest_int_eq(SPA_TYPE_Int, 4);
+	pwtest_int_eq(SPA_TYPE_Long, 5);
+	pwtest_int_eq(SPA_TYPE_Float, 6);
+	pwtest_int_eq(SPA_TYPE_Double, 7);
+	pwtest_int_eq(SPA_TYPE_String, 8);
+	pwtest_int_eq(SPA_TYPE_Bytes, 9);
+	pwtest_int_eq(SPA_TYPE_Rectangle, 10);
+	pwtest_int_eq(SPA_TYPE_Fraction, 11);
+	pwtest_int_eq(SPA_TYPE_Bitmap, 12);
+	pwtest_int_eq(SPA_TYPE_Array, 13);
+	pwtest_int_eq(SPA_TYPE_Struct, 14);
+	pwtest_int_eq(SPA_TYPE_Object, 15);
+	pwtest_int_eq(SPA_TYPE_Sequence, 16);
+	pwtest_int_eq(SPA_TYPE_Pointer, 17);
+	pwtest_int_eq(SPA_TYPE_Fd, 18);
+	pwtest_int_eq(SPA_TYPE_Choice, 19);
+	pwtest_int_eq(SPA_TYPE_Pod, 20);
+	pwtest_int_eq(_SPA_TYPE_LAST, 21);
+
+	pwtest_int_eq(SPA_TYPE_EVENT_START, 0x20000);
+	pwtest_int_eq(SPA_TYPE_EVENT_Device, 0x20001);
+	pwtest_int_eq(SPA_TYPE_EVENT_Node, 0x20002);
+	pwtest_int_eq(_SPA_TYPE_EVENT_LAST, 0x20003);
+
+	pwtest_int_eq(SPA_TYPE_COMMAND_START, 0x30000);
+	pwtest_int_eq(SPA_TYPE_COMMAND_Device, 0x30001);
+	pwtest_int_eq(SPA_TYPE_COMMAND_Node, 0x30002);
+	pwtest_int_eq(_SPA_TYPE_COMMAND_LAST, 0x30003);
+
+	pwtest_int_eq(SPA_TYPE_OBJECT_START, 0x40000);
+	pwtest_int_eq(SPA_TYPE_OBJECT_PropInfo, 0x40001);
+	pwtest_int_eq(SPA_TYPE_OBJECT_Props, 0x40002);
+	pwtest_int_eq(SPA_TYPE_OBJECT_Format, 0x40003);
+	pwtest_int_eq(SPA_TYPE_OBJECT_ParamBuffers, 0x40004);
+	pwtest_int_eq(SPA_TYPE_OBJECT_ParamMeta, 0x40005);
+	pwtest_int_eq(SPA_TYPE_OBJECT_ParamIO, 0x40006);
+	pwtest_int_eq(SPA_TYPE_OBJECT_ParamProfile, 0x40007);
+	pwtest_int_eq(SPA_TYPE_OBJECT_ParamPortConfig, 0x40008);
+	pwtest_int_eq(SPA_TYPE_OBJECT_ParamRoute, 0x40009);
+	pwtest_int_eq(SPA_TYPE_OBJECT_Profiler, 0x4000a);
+	pwtest_int_eq(SPA_TYPE_OBJECT_ParamLatency, 0x4000b);
+	pwtest_int_eq(SPA_TYPE_OBJECT_ParamProcessLatency, 0x4000c);
+	pwtest_int_eq(_SPA_TYPE_OBJECT_LAST, 0x4000d);
+
+	pwtest_int_eq(SPA_TYPE_VENDOR_PipeWire, 0x02000000);
+	pwtest_int_eq(SPA_TYPE_VENDOR_Other, 0x7f000000);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(utils_macros)
+{
+	uint8_t ptr[64];
+	uint16_t i16[14];
+	uint32_t i32[10];
+	uint64_t i64[12];
+	unsigned char c[16];
+
+	pwtest_int_eq(SPA_MIN(1, 2), 1);
+	pwtest_int_eq(SPA_MIN(1, -2), -2);
+	pwtest_int_eq(SPA_MAX(1, 2), 2);
+	pwtest_int_eq(SPA_MAX(1, -2), 1);
+	pwtest_int_eq(SPA_CLAMP(23, 1, 16), 16);
+	pwtest_int_eq(SPA_CLAMP(-1, 1, 16), 1);
+	pwtest_int_eq(SPA_CLAMP(8, 1, 16), 8);
+
+	/* SPA_MEMBER exists for backwards compatibility but should no
+	 * longer be used, let's make sure it does what we expect it to */
+	pwtest_ptr_eq(SPA_MEMBER(ptr, 4, void), SPA_PTROFF(ptr, 4, void));
+	pwtest_ptr_eq(SPA_MEMBER(ptr, 32, void), SPA_PTROFF(ptr, 32, void));
+	pwtest_ptr_eq(SPA_MEMBER(ptr, 0, void), SPA_PTROFF(ptr, 0, void));
+	pwtest_ptr_eq(SPA_MEMBER_ALIGN(ptr, 0, 4, void), SPA_PTROFF_ALIGN(ptr, 0, 4, void));
+	pwtest_ptr_eq(SPA_MEMBER_ALIGN(ptr, 4, 32, void), SPA_PTROFF_ALIGN(ptr, 4, 32, void));
+
+	pwtest_int_eq(SPA_N_ELEMENTS(ptr), 64U);
+	pwtest_int_eq(SPA_N_ELEMENTS(i32), 10U);
+	pwtest_int_eq(SPA_N_ELEMENTS(i64), 12U);
+	pwtest_int_eq(SPA_N_ELEMENTS(i16), 14U);
+	pwtest_int_eq(SPA_N_ELEMENTS(c), 16U);
+
+#define check_traversal(array_) \
+	{ \
+		int count = 0; \
+		SPA_FOR_EACH_ELEMENT_VAR(array_, it) \
+			*it = count++; \
+		for (size_t i = 0; i < SPA_N_ELEMENTS(array_); i++) \
+			pwtest_int_eq(array_[i], i); \
+	}
+	check_traversal(ptr);
+	check_traversal(i64);
+	check_traversal(i32);
+	check_traversal(i16);
+	check_traversal(c);
+	return PWTEST_PASS;
+}
+
+PWTEST(utils_result)
+{
+	int res;
+	pwtest_int_eq(SPA_RESULT_IS_OK(0), true);
+	pwtest_int_eq(SPA_RESULT_IS_OK(1), true);
+	pwtest_int_eq(SPA_RESULT_IS_ERROR(0), false);
+	pwtest_int_eq(SPA_RESULT_IS_ERROR(1), false);
+	pwtest_int_eq(SPA_RESULT_IS_ERROR(-1), true);
+	pwtest_int_eq(SPA_RESULT_IS_ASYNC(-1), false);
+	pwtest_int_eq(SPA_RESULT_IS_ASYNC(0), false);
+	res = SPA_RESULT_RETURN_ASYNC(11);
+	pwtest_int_eq(SPA_RESULT_IS_ASYNC(res), true);
+	pwtest_int_eq(SPA_RESULT_IS_ERROR(res), false);
+	pwtest_int_eq(SPA_RESULT_IS_OK(res), true);
+	pwtest_int_eq(SPA_RESULT_ASYNC_SEQ(res), 11);
+	return PWTEST_PASS;
+}
+
+PWTEST(utils_dict)
+{
+	struct spa_dict_item items[5] = {
+		SPA_DICT_ITEM_INIT("key", "value"),
+		SPA_DICT_ITEM_INIT("pipe", "wire"),
+		SPA_DICT_ITEM_INIT("test", "Works!"),
+		SPA_DICT_ITEM_INIT("123", ""),
+		SPA_DICT_ITEM_INIT("SPA", "Simple Plugin API"),
+	};
+	struct spa_dict dict = SPA_DICT_INIT_ARRAY (items);
+	const struct spa_dict_item *it;
+	int i = 0;
+
+	pwtest_int_eq(dict.n_items, 5U);
+	pwtest_str_eq(spa_dict_lookup(&dict, "pipe"), "wire");
+	pwtest_str_eq(spa_dict_lookup(&dict, "123"), "");
+	pwtest_str_eq(spa_dict_lookup(&dict, "key"), "value");
+	pwtest_str_eq(spa_dict_lookup(&dict, "SPA"), "Simple Plugin API");
+	pwtest_str_eq(spa_dict_lookup(&dict, "test"), "Works!");
+	pwtest_ptr_null(spa_dict_lookup(&dict, "nonexistent"));
+
+	pwtest_ptr_eq(spa_dict_lookup_item(&dict, "123"), &items[3]);
+	pwtest_ptr_null(spa_dict_lookup_item(&dict, "foobar"));
+
+	spa_dict_for_each(it, &dict) {
+		pwtest_ptr_eq(it, &items[i++]);
+	}
+	pwtest_int_eq(i, 5);
+	return PWTEST_PASS;
+}
+
+struct string_list {
+	char string[20];
+	struct spa_list node;
+};
+
+PWTEST(utils_list)
+{
+	struct string_list list;
+	struct spa_list *head = &list.node;
+	struct string_list *e;
+	int i;
+
+	spa_list_init(head);
+	pwtest_bool_true(spa_list_is_empty(head));
+
+	e = malloc(sizeof(struct string_list));
+	strcpy(e->string, "test");
+	spa_list_insert(head, &e->node);
+	pwtest_bool_false(spa_list_is_empty(head));
+	pwtest_ptr_eq(spa_list_first(head, struct string_list, node), e);
+	pwtest_ptr_eq(spa_list_last(head, struct string_list, node), e);
+
+	e = malloc(sizeof(struct string_list));
+	strcpy(e->string, "pipewire!");
+	spa_list_append(head, &e->node);
+	pwtest_bool_false(spa_list_is_empty(head));
+	pwtest_ptr_eq(spa_list_last(head, struct string_list, node), e);
+
+	e = malloc(sizeof(struct string_list));
+	strcpy(e->string, "First element");
+	spa_list_prepend(head, &e->node);
+	pwtest_bool_false(spa_list_is_empty(head));
+	pwtest_ptr_eq(spa_list_first(head, struct string_list, node), e);
+
+	i = 0;
+	spa_list_for_each(e, head, node) {
+		switch (i++) {
+			case 0:
+				pwtest_str_eq(e->string, "First element");
+				break;
+			case 1:
+				pwtest_str_eq(e->string, "test");
+				break;
+			case 2:
+				pwtest_str_eq(e->string, "pipewire!");
+				break;
+			default:
+				pwtest_fail_if_reached();
+				break;
+		}
+	}
+
+	i = 0;
+	spa_list_consume(e, head, node) {
+		spa_list_remove(&e->node);
+		free(e);
+		i++;
+	}
+	pwtest_int_eq(i, 3);
+	pwtest_bool_true(spa_list_is_empty(head));
+
+	return PWTEST_PASS;
+}
+
+
+struct my_hook {
+	int version;
+	void (*invoke) (void *);
+};
+
+struct my_hook_data {
+	bool cb1;
+	bool cb2;
+	bool cb3;
+};
+
+static void test_hook_callback_1(void *data)
+{
+	((struct my_hook_data *) data)->cb1 = true;
+}
+
+static void test_hook_callback_2(void *data)
+{
+	((struct my_hook_data *) data)->cb2 = true;
+}
+
+static void test_hook_callback_3(void *data)
+{
+	((struct my_hook_data *) data)->cb3 = true;
+}
+
+static void test_hook_callback_4(void *data)
+{
+	pwtest_fail_if_reached();
+}
+
+static int hook_free_count = 0;
+
+static void hook_removed_cb(struct spa_hook *h)
+{
+	free(h);
+	hook_free_count++;
+}
+
+PWTEST(utils_hook)
+{
+	const int HOOK_VERSION = 2;
+	struct spa_hook_list hl;
+	struct my_hook callbacks[4] = {
+		{2, test_hook_callback_1},
+		{3, test_hook_callback_2},
+		{2, test_hook_callback_3},
+		/* version 1 should not be called */
+		{1, test_hook_callback_4}
+	};
+	struct my_hook_data data = {0};
+	struct spa_hook *h;
+	int count = 0;
+
+	spa_hook_list_init(&hl);
+
+	h = malloc(sizeof(struct spa_hook));
+	spa_hook_list_append(&hl, h, &callbacks[1], &data);
+	h->removed = hook_removed_cb;
+
+	h = malloc(sizeof(struct spa_hook));
+	spa_hook_list_append(&hl, h, &callbacks[2], &data);
+	h->removed = hook_removed_cb;
+
+	/* iterate with the simple API */
+	spa_hook_list_call_simple(&hl, struct my_hook, invoke, HOOK_VERSION);
+	pwtest_bool_eq(data.cb1, false);
+	pwtest_bool_eq(data.cb2, true);
+	pwtest_bool_eq(data.cb3, true);
+
+	/* reset cb* booleans to false */
+	memset(&data, 0, sizeof(struct my_hook_data));
+
+	h = malloc(sizeof(struct spa_hook));
+	spa_hook_list_prepend(&hl, h, &callbacks[0], &data);
+	h->removed = hook_removed_cb;
+
+	/* call only the first hook - this should be callback_1 */
+	count = spa_hook_list_call_once(&hl, struct my_hook, invoke, HOOK_VERSION);
+	pwtest_int_eq(count, 1);
+	pwtest_bool_eq(data.cb1, true);
+	pwtest_bool_eq(data.cb2, false);
+	pwtest_bool_eq(data.cb3, false);
+
+	/* reset cb* booleans to false */
+	memset(&data, 0, sizeof(struct my_hook_data));
+
+	/* add callback_4 - this is version 1, so it shouldn't be executed */
+	h = malloc(sizeof(struct spa_hook));
+	spa_hook_list_append(&hl, h, &callbacks[3], &data);
+	h->removed = hook_removed_cb;
+
+	count = spa_hook_list_call(&hl, struct my_hook, invoke, HOOK_VERSION);
+	pwtest_int_eq(count, 3);
+	pwtest_bool_eq(data.cb1, true);
+	pwtest_bool_eq(data.cb2, true);
+	pwtest_bool_eq(data.cb3, true);
+
+	count = 0;
+	hook_free_count = 0;
+	spa_list_consume(h, &hl.list, link) {
+		spa_hook_remove(h);
+		count++;
+	}
+	pwtest_int_eq(count, 4);
+	pwtest_int_eq(hook_free_count, 4);
+
+	/* remove a zeroed hook */
+	struct spa_hook hook;
+	spa_zero(hook);
+	spa_hook_remove(&hook);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(utils_ringbuffer)
+{
+	struct spa_ringbuffer rb;
+	char buffer[20];
+	char readbuf[20];
+	uint32_t idx;
+	int32_t fill;
+
+	spa_ringbuffer_init(&rb);
+	fill = spa_ringbuffer_get_write_index(&rb, &idx);
+	pwtest_int_eq(idx, 0U);
+	pwtest_int_eq(fill, 0);
+
+	spa_ringbuffer_write_data(&rb, buffer, 20, idx, "hello pipewire", 14);
+	spa_ringbuffer_write_update(&rb, idx + 14);
+
+	fill = spa_ringbuffer_get_write_index(&rb, &idx);
+	pwtest_int_eq(idx, 14U);
+	pwtest_int_eq(fill, 14);
+	fill = spa_ringbuffer_get_read_index(&rb, &idx);
+	pwtest_int_eq(idx, 0U);
+	pwtest_int_eq(fill, 14);
+
+	spa_ringbuffer_read_data(&rb, buffer, 20, idx, readbuf, 6);
+	spa_ringbuffer_read_update(&rb, idx + 6);
+	pwtest_int_eq(memcmp(readbuf, "hello ", 6), 0);
+
+	fill = spa_ringbuffer_get_read_index(&rb, &idx);
+	pwtest_int_eq(idx, 6U);
+	pwtest_int_eq(fill, 8);
+	fill = spa_ringbuffer_get_write_index(&rb, &idx);
+	pwtest_int_eq(idx, 14U);
+	pwtest_int_eq(fill, 8);
+
+	spa_ringbuffer_write_data(&rb, buffer, 20, idx, " rocks !!!", 10);
+	spa_ringbuffer_write_update(&rb, idx + 10);
+
+	fill = spa_ringbuffer_get_write_index(&rb, &idx);
+	pwtest_int_eq(idx, 24U);
+	pwtest_int_eq(fill, 18);
+	fill = spa_ringbuffer_get_read_index(&rb, &idx);
+	pwtest_int_eq(idx, 6U);
+	pwtest_int_eq(fill, 18);
+
+	spa_ringbuffer_read_data(&rb, buffer, 20, idx, readbuf, 18);
+	spa_ringbuffer_read_update(&rb, idx + 18);
+	pwtest_str_eq_n(readbuf, "pipewire rocks !!!", 18);
+
+	fill = spa_ringbuffer_get_read_index(&rb, &idx);
+	pwtest_int_eq(idx, 24U);
+	pwtest_int_eq(fill, 0);
+	fill = spa_ringbuffer_get_write_index(&rb, &idx);
+	pwtest_int_eq(idx, 24U);
+	pwtest_int_eq(fill, 0);
+
+	/* actual buffer must have wrapped around */
+	pwtest_str_eq_n(buffer, " !!!o pipewire rocks", 20);
+	return PWTEST_PASS;
+}
+
+PWTEST(utils_strtol)
+{
+	int32_t v = 0xabcd;
+
+	pwtest_bool_true(spa_atoi32("0", &v, 0));		pwtest_int_eq(v, 0);
+	pwtest_bool_true(spa_atoi32("0", &v, 16));		pwtest_int_eq(v, 0);
+	pwtest_bool_true(spa_atoi32("0", &v, 32));		pwtest_int_eq(v, 0);
+	pwtest_bool_true(spa_atoi32("-1", &v, 0));		pwtest_int_eq(v, -1);
+	pwtest_bool_true(spa_atoi32("-1234", &v, 0));		pwtest_int_eq(v, -1234);
+	pwtest_bool_true(spa_atoi32("-2147483648", &v, 0));	pwtest_int_eq(v, -2147483648);
+	pwtest_bool_true(spa_atoi32("+1", &v, 0));		pwtest_int_eq(v, 1);
+	pwtest_bool_true(spa_atoi32("+1234", &v, 0));		pwtest_int_eq(v, 1234);
+	pwtest_bool_true(spa_atoi32("+2147483647", &v, 0));	pwtest_int_eq(v, 2147483647);
+	pwtest_bool_true(spa_atoi32("65535", &v, 0));		pwtest_int_eq(v, 0xffff);
+	pwtest_bool_true(spa_atoi32("65535", &v, 10));		pwtest_int_eq(v, 0xffff);
+	pwtest_bool_true(spa_atoi32("65535", &v, 16));		pwtest_int_eq(v, 0x65535);
+	pwtest_bool_true(spa_atoi32("0xff", &v, 0));		pwtest_int_eq(v, 0xff);
+	pwtest_bool_true(spa_atoi32("0xff", &v, 16));		pwtest_int_eq(v, 0xff);
+
+	v = 0xabcd;
+	pwtest_bool_false(spa_atoi32("0xff", &v, 10));		pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atoi32("fabc", &v, 10));		pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atoi32("fabc", &v, 0));		pwtest_int_eq(v, 0xabcd);
+
+	pwtest_bool_false(spa_atoi32("124bogus", &v, 0));	pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atoi32("124bogus", &v, 10));	pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atoi32("124bogus", &v, 16));	pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atoi32("0xbogus", &v, 0));	pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atoi32("bogus", &v, 10));		pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atoi32("bogus", &v, 16));		pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atoi32("", &v, 0));		pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atoi32("", &v, 10));		pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atoi32("", &v, 16));		pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atoi32("  ", &v, 0));		pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atoi32(" ", &v, 0));		pwtest_int_eq(v, 0xabcd);
+
+	pwtest_bool_false(spa_atoi32("-2147483649", &v, 0));	pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atoi32("2147483648", &v, 0));	pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atoi32("9223372036854775807", &v, 0));		pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atoi32("-9223372036854775808", &v, 0));		pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atoi32("9223372036854775808999", &v, 0));		pwtest_int_eq(v, 0xabcd);
+
+	pwtest_bool_false(spa_atoi32(NULL, &v, 0));		pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atoi32(NULL, &v, 10));		pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atoi32(NULL, &v, 16));		pwtest_int_eq(v, 0xabcd);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(utils_strtoul)
+{
+	uint32_t v = 0xabcd;
+
+	pwtest_bool_true(spa_atou32("0", &v, 0));		pwtest_int_eq(v, 0U);
+	pwtest_bool_true(spa_atou32("0", &v, 16));		pwtest_int_eq(v, 0U);
+	pwtest_bool_true(spa_atou32("0", &v, 32));		pwtest_int_eq(v, 0U);
+	pwtest_bool_true(spa_atou32("+1", &v, 0));		pwtest_int_eq(v, 1U);
+	pwtest_bool_true(spa_atou32("+1234", &v, 0));		pwtest_int_eq(v, 1234U);
+	pwtest_bool_true(spa_atou32("+4294967295", &v, 0));	pwtest_int_eq(v, 4294967295U);
+	pwtest_bool_true(spa_atou32("4294967295", &v, 0));	pwtest_int_eq(v, 4294967295U);
+	pwtest_bool_true(spa_atou32("65535", &v, 0));		pwtest_int_eq(v, 0xffffU);
+	pwtest_bool_true(spa_atou32("65535", &v, 10));		pwtest_int_eq(v, 0xffffU);
+	pwtest_bool_true(spa_atou32("65535", &v, 16));		pwtest_int_eq(v, 0x65535U);
+	pwtest_bool_true(spa_atou32("0xff", &v, 0));		pwtest_int_eq(v, 0xffU);
+	pwtest_bool_true(spa_atou32("0xff", &v, 16));		pwtest_int_eq(v, 0xffU);
+
+	v = 0xabcd;
+	pwtest_bool_false(spa_atou32("-1", &v, 0));		pwtest_int_eq(v, 0xabcdU);
+	pwtest_bool_false(spa_atou32("-1234", &v, 0));		pwtest_int_eq(v, 0xabcdU);
+	pwtest_bool_false(spa_atou32("-2147483648", &v, 0));	pwtest_int_eq(v, 0xabcdU);
+	pwtest_bool_false(spa_atou32("0xff", &v, 10));		pwtest_int_eq(v, 0xabcdU);
+	pwtest_bool_false(spa_atou32("fabc", &v, 10));		pwtest_int_eq(v, 0xabcdU);
+	pwtest_bool_false(spa_atou32("fabc", &v, 0));		pwtest_int_eq(v, 0xabcdU);
+
+	pwtest_bool_false(spa_atou32("124bogus", &v, 0));	pwtest_int_eq(v, 0xabcdU);
+	pwtest_bool_false(spa_atou32("124bogus", &v, 10));	pwtest_int_eq(v, 0xabcdU);
+	pwtest_bool_false(spa_atou32("124bogus", &v, 16));	pwtest_int_eq(v, 0xabcdU);
+	pwtest_bool_false(spa_atou32("0xbogus", &v, 0));	pwtest_int_eq(v, 0xabcdU);
+	pwtest_bool_false(spa_atou32("bogus", &v, 10));		pwtest_int_eq(v, 0xabcdU);
+	pwtest_bool_false(spa_atou32("bogus", &v, 16));		pwtest_int_eq(v, 0xabcdU);
+	pwtest_bool_false(spa_atou32("", &v, 0));		pwtest_int_eq(v, 0xabcdU);
+	pwtest_bool_false(spa_atou32("", &v, 10));		pwtest_int_eq(v, 0xabcdU);
+	pwtest_bool_false(spa_atou32("", &v, 16));		pwtest_int_eq(v, 0xabcdU);
+	pwtest_bool_false(spa_atou32("  ", &v, 0));		pwtest_int_eq(v, 0xabcdU);
+	pwtest_bool_false(spa_atou32(" ", &v, 0));		pwtest_int_eq(v, 0xabcdU);
+
+	pwtest_bool_false(spa_atou32("-2147483649", &v, 0));	pwtest_int_eq(v, 0xabcdU);
+	pwtest_bool_false(spa_atou32("4294967296", &v, 0));	pwtest_int_eq(v, 0xabcdU);
+	pwtest_bool_false(spa_atou32("9223372036854775807", &v, 0));		pwtest_int_eq(v, 0xabcdU);
+	pwtest_bool_false(spa_atou32("-9223372036854775808", &v, 0));		pwtest_int_eq(v, 0xabcdU);
+	pwtest_bool_false(spa_atou32("9223372036854775808999", &v, 0));		pwtest_int_eq(v, 0xabcdU);
+
+	pwtest_bool_false(spa_atou32(NULL, &v, 0));		pwtest_int_eq(v, 0xabcdU);
+	pwtest_bool_false(spa_atou32(NULL, &v, 10));		pwtest_int_eq(v, 0xabcdU);
+	pwtest_bool_false(spa_atou32(NULL, &v, 16));		pwtest_int_eq(v, 0xabcdU);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(utils_strtoll)
+{
+	int64_t v = 0xabcd;
+
+	pwtest_bool_true(spa_atoi64("0", &v, 0));		pwtest_int_eq(v, 0);
+	pwtest_bool_true(spa_atoi64("0", &v, 16));		pwtest_int_eq(v, 0);
+	pwtest_bool_true(spa_atoi64("0", &v, 32));		pwtest_int_eq(v, 0);
+	pwtest_bool_true(spa_atoi64("-1", &v, 0));		pwtest_int_eq(v, -1);
+	pwtest_bool_true(spa_atoi64("-1234", &v, 0));		pwtest_int_eq(v, -1234);
+	pwtest_bool_true(spa_atoi64("-2147483648", &v, 0));	pwtest_int_eq(v, -2147483648);
+	pwtest_bool_true(spa_atoi64("+1", &v, 0));		pwtest_int_eq(v, 1);
+	pwtest_bool_true(spa_atoi64("+1234", &v, 0));		pwtest_int_eq(v, 1234);
+	pwtest_bool_true(spa_atoi64("+2147483647", &v, 0));	pwtest_int_eq(v, 2147483647);
+	pwtest_bool_true(spa_atoi64("65535", &v, 0));		pwtest_int_eq(v, 0xffff);
+	pwtest_bool_true(spa_atoi64("65535", &v, 10));		pwtest_int_eq(v, 0xffff);
+	pwtest_bool_true(spa_atoi64("65535", &v, 16));		pwtest_int_eq(v, 0x65535);
+	pwtest_bool_true(spa_atoi64("0xff", &v, 0));		pwtest_int_eq(v, 0xff);
+	pwtest_bool_true(spa_atoi64("0xff", &v, 16));		pwtest_int_eq(v, 0xff);
+	pwtest_bool_true(spa_atoi64("9223372036854775807", &v, 0));	pwtest_int_eq(v, 0x7fffffffffffffff);
+	pwtest_bool_true(spa_atoi64("-9223372036854775808", &v, 0));	pwtest_int_eq((uint64_t)v, 0x8000000000000000);
+
+	v = 0xabcd;
+	pwtest_bool_false(spa_atoi64("0xff", &v, 10));		pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atoi64("fabc", &v, 10));		pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atoi64("fabc", &v, 0));		pwtest_int_eq(v, 0xabcd);
+
+	pwtest_bool_false(spa_atoi64("124bogus", &v, 0));	pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atoi64("124bogus", &v, 10));	pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atoi64("124bogus", &v, 16));	pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atoi64("0xbogus", &v, 0));	pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atoi64("bogus", &v, 10));		pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atoi64("bogus", &v, 16));		pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atoi64("", &v, 0));		pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atoi64("", &v, 10));		pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atoi64("", &v, 16));		pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atoi64("  ", &v, 0));		pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atoi64(" ", &v, 0));		pwtest_int_eq(v, 0xabcd);
+
+	pwtest_bool_false(spa_atoi64("9223372036854775808999", &v, 0));	pwtest_int_eq(v, 0xabcd);
+
+	pwtest_bool_false(spa_atoi64(NULL, &v, 0));		pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atoi64(NULL, &v, 10));		pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atoi64(NULL, &v, 16));		pwtest_int_eq(v, 0xabcd);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(utils_strtof)
+{
+	float v = 0xabcd;
+
+	setlocale(LC_NUMERIC, "C"); /* For decimal number parsing */
+
+	pwtest_bool_true(spa_atof("0", &v));	pwtest_double_eq(v, 0.0f);
+	pwtest_bool_true(spa_atof("0.00", &v));	pwtest_double_eq(v, 0.0f);
+	pwtest_bool_true(spa_atof("1", &v));	pwtest_double_eq(v, 1.0f);
+	pwtest_bool_true(spa_atof("-1", &v));	pwtest_double_eq(v, -1.0f);
+	pwtest_bool_true(spa_atof("0x1", &v));	pwtest_double_eq(v, 1.0f);
+
+	v = 0xabcd;
+	pwtest_bool_false(spa_atof("0,00", &v));  pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atof("fabc", &v));  pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atof("1.bogus", &v));pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atof("1.0a", &v));  pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atof("  ", &v));	  pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atof(" ", &v));	  pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atof("", &v));	  pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atof(NULL, &v));	  pwtest_int_eq(v, 0xabcd);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(utils_strtod)
+{
+	double v = 0xabcd;
+
+	pwtest_bool_true(spa_atod("0", &v));		pwtest_double_eq(v, 0.0);
+	pwtest_bool_true(spa_atod("0.00", &v));		pwtest_double_eq(v, 0.0);
+	pwtest_bool_true(spa_atod("1", &v));		pwtest_double_eq(v, 1.0);
+	pwtest_bool_true(spa_atod("-1", &v));		pwtest_double_eq(v, -1.0);
+	pwtest_bool_true(spa_atod("0x1", &v));		pwtest_double_eq(v, 1.0);
+
+	v = 0xabcd;
+	pwtest_bool_false(spa_atod("0,00", &v));	pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atod("fabc", &v));	pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atod("1.bogus", &v));	pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atod("1.0a", &v));	pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atod("  ", &v));		pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atod(" ", &v));		pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atod("", &v));		pwtest_int_eq(v, 0xabcd);
+	pwtest_bool_false(spa_atod(NULL, &v));		pwtest_int_eq(v, 0xabcd);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(utils_streq)
+{
+	pwtest_bool_true(spa_streq(NULL, NULL));
+	pwtest_bool_true(spa_streq("", ""));
+	pwtest_bool_true(spa_streq("a", "a"));
+	pwtest_bool_true(spa_streq("abc", "abc"));
+	pwtest_bool_false(spa_streq(NULL, "abc"));
+	pwtest_bool_false(spa_streq("abc", NULL));
+
+	pwtest_bool_true(spa_strneq("abc", "aaa", 1));
+	pwtest_bool_true(spa_strneq("abc", "abc", 7));
+	pwtest_bool_false(spa_strneq("abc", "aaa", 2));
+	pwtest_bool_false(spa_strneq("abc", NULL, 7));
+	pwtest_bool_false(spa_strneq(NULL, "abc", 7));
+
+	return PWTEST_PASS;
+}
+
+PWTEST(utils_strendswith)
+{
+	pwtest_bool_true(spa_strendswith("foo", "o"));
+	pwtest_bool_true(spa_strendswith("foobar", "bar"));
+
+	pwtest_bool_false(spa_strendswith(NULL, "bar"));
+	pwtest_bool_false(spa_strendswith("foo", "f"));
+	pwtest_bool_false(spa_strendswith("foo", "fo"));
+	pwtest_bool_false(spa_strendswith("foo", "foobar"));
+
+	return PWTEST_PASS;
+}
+
+PWTEST(utils_strendswith_null_suffix)
+{
+	spa_strendswith("foo", NULL);
+
+	return PWTEST_FAIL;
+}
+
+PWTEST(utils_atob)
+{
+	pwtest_bool_true(spa_atob("true"));
+	pwtest_bool_true(spa_atob("1"));
+	pwtest_bool_false(spa_atob("0"));
+	pwtest_bool_false(spa_atob("-1"));
+	pwtest_bool_false(spa_atob("10"));
+	pwtest_bool_false(spa_atob("11"));
+	pwtest_bool_false(spa_atob("t"));
+	pwtest_bool_false(spa_atob("yes"));
+	pwtest_bool_false(spa_atob("no"));
+	pwtest_bool_false(spa_atob(NULL));
+	pwtest_bool_false(spa_atob("True")); /* lower-case required */
+	pwtest_bool_false(spa_atob("TRUE"));
+
+	return PWTEST_PASS;
+}
+
+PWTEST(utils_ansi)
+{
+	/* Visual test only */
+	printf("%sBOLD%s\n", SPA_ANSI_BOLD, SPA_ANSI_RESET);
+	printf("%sUNDERLINE%s\n", SPA_ANSI_UNDERLINE, SPA_ANSI_RESET);
+	printf("%sITALIC%s\n", SPA_ANSI_ITALIC, SPA_ANSI_RESET);
+
+	printf("%sBLACK%s\n", SPA_ANSI_BLACK, SPA_ANSI_RESET);
+	printf("%sBRIGHT_BLACK%s\n", SPA_ANSI_BRIGHT_BLACK, SPA_ANSI_RESET);
+	printf("%sDARK_BLACK%s\n", SPA_ANSI_DARK_BLACK, SPA_ANSI_RESET);
+	printf("%sBOLD_BLACK%s\n", SPA_ANSI_BOLD_BLACK, SPA_ANSI_RESET);
+
+	printf("%sRED%s\n", SPA_ANSI_RED, SPA_ANSI_RESET);
+	printf("%sBRIGHT_RED%s\n", SPA_ANSI_BRIGHT_RED, SPA_ANSI_RESET);
+	printf("%sDARK_RED%s\n", SPA_ANSI_DARK_RED, SPA_ANSI_RESET);
+	printf("%sBOLD_RED%s\n", SPA_ANSI_BOLD_RED, SPA_ANSI_RESET);
+
+	printf("%sGREEN%s\n", SPA_ANSI_GREEN, SPA_ANSI_RESET);
+	printf("%sBRIGHT_GREEN%s\n", SPA_ANSI_BRIGHT_GREEN, SPA_ANSI_RESET);
+	printf("%sDARK_GREEN%s\n", SPA_ANSI_DARK_GREEN, SPA_ANSI_RESET);
+	printf("%sBOLD_GREEN%s\n", SPA_ANSI_BOLD_GREEN, SPA_ANSI_RESET);
+
+	printf("%sYELLOW%s\n", SPA_ANSI_YELLOW, SPA_ANSI_RESET);
+	printf("%sBRIGHT_YELLOW%s\n", SPA_ANSI_BRIGHT_YELLOW, SPA_ANSI_RESET);
+	printf("%sDARK_YELLOW%s\n", SPA_ANSI_DARK_YELLOW, SPA_ANSI_RESET);
+	printf("%sBOLD_YELLOW%s\n", SPA_ANSI_BOLD_YELLOW, SPA_ANSI_RESET);
+
+	printf("%sBLUE%s\n", SPA_ANSI_BLUE, SPA_ANSI_RESET);
+	printf("%sBRIGHT_BLUE%s\n", SPA_ANSI_BRIGHT_BLUE, SPA_ANSI_RESET);
+	printf("%sDARK_BLUE%s\n", SPA_ANSI_DARK_BLUE, SPA_ANSI_RESET);
+	printf("%sBOLD_BLUE%s\n", SPA_ANSI_BOLD_BLUE, SPA_ANSI_RESET);
+
+	printf("%sMAGENTA%s\n", SPA_ANSI_MAGENTA, SPA_ANSI_RESET);
+	printf("%sBRIGHT_MAGENTA%s\n", SPA_ANSI_BRIGHT_MAGENTA, SPA_ANSI_RESET);
+	printf("%sDARK_MAGENTA%s\n", SPA_ANSI_DARK_MAGENTA, SPA_ANSI_RESET);
+	printf("%sBOLD_MAGENTA%s\n", SPA_ANSI_BOLD_MAGENTA, SPA_ANSI_RESET);
+
+	printf("%sCYAN%s\n", SPA_ANSI_CYAN, SPA_ANSI_RESET);
+	printf("%sBRIGHT_CYAN%s\n", SPA_ANSI_BRIGHT_CYAN, SPA_ANSI_RESET);
+	printf("%sDARK_CYAN%s\n", SPA_ANSI_DARK_CYAN, SPA_ANSI_RESET);
+	printf("%sBOLD_CYAN%s\n", SPA_ANSI_BOLD_CYAN, SPA_ANSI_RESET);
+
+	printf("%sWHITE%s\n", SPA_ANSI_WHITE, SPA_ANSI_RESET);
+	printf("%sBRIGHT_WHITE%s\n", SPA_ANSI_BRIGHT_WHITE, SPA_ANSI_RESET);
+	printf("%sDARK_WHITE%s\n", SPA_ANSI_DARK_WHITE, SPA_ANSI_RESET);
+	printf("%sBOLD_WHITE%s\n", SPA_ANSI_BOLD_WHITE, SPA_ANSI_RESET);
+
+
+	/* Background colors */
+
+	printf("%sBG_BLACK%s\n", SPA_ANSI_BG_BLACK, SPA_ANSI_RESET);
+	printf("%sBG_BRIGHT_BLACK%s\n", SPA_ANSI_BG_BRIGHT_BLACK, SPA_ANSI_RESET);
+
+	printf("%sBG_RED%s\n", SPA_ANSI_BG_RED, SPA_ANSI_RESET);
+	printf("%sBG_BRIGHT_RED%s\n", SPA_ANSI_BG_BRIGHT_RED, SPA_ANSI_RESET);
+
+	printf("%sBG_GREEN%s\n", SPA_ANSI_BG_GREEN, SPA_ANSI_RESET);
+	printf("%sBG_BRIGHT_GREEN%s\n", SPA_ANSI_BG_BRIGHT_GREEN, SPA_ANSI_RESET);
+
+	printf("%sBG_YELLOW%s\n", SPA_ANSI_BG_YELLOW, SPA_ANSI_RESET);
+	printf("%sBG_BRIGHT_YELLOW%s\n", SPA_ANSI_BG_BRIGHT_YELLOW, SPA_ANSI_RESET);
+
+	printf("%sBG_BLUE%s\n", SPA_ANSI_BG_BLUE, SPA_ANSI_RESET);
+	printf("%sBG_BRIGHT_BLUE%s\n", SPA_ANSI_BG_BRIGHT_BLUE, SPA_ANSI_RESET);
+
+	printf("%sBG_MAGENTA%s\n", SPA_ANSI_BG_MAGENTA, SPA_ANSI_RESET);
+	printf("%sBG_BRIGHT_MAGENTA%s\n", SPA_ANSI_BG_BRIGHT_MAGENTA, SPA_ANSI_RESET);
+
+	printf("%sBG_CYAN%s\n", SPA_ANSI_BG_CYAN, SPA_ANSI_RESET);
+	printf("%sBG_BRIGHT_CYAN%s\n", SPA_ANSI_BG_BRIGHT_CYAN, SPA_ANSI_RESET);
+
+	printf("%sBG_WHITE%s\n", SPA_ANSI_BG_WHITE, SPA_ANSI_RESET);
+	printf("%sBG_BRIGHT_WHITE%s\n", SPA_ANSI_BG_BRIGHT_WHITE, SPA_ANSI_RESET);
+
+	/* A combo */
+	printf("normal%s%s%sBG_BLUE,ITALIC,BOLD_YELLOW%snormal\n", SPA_ANSI_BG_BLUE,
+	       SPA_ANSI_ITALIC, SPA_ANSI_BOLD_YELLOW, SPA_ANSI_RESET);
+	return PWTEST_PASS;
+}
+
+PWTEST(utils_snprintf)
+{
+	char dest[8];
+	int len;
+
+	/* Basic printf */
+	pwtest_int_eq(spa_scnprintf(dest, sizeof(dest), "foo%d%s", 10, "2"), 6);
+	pwtest_str_eq(dest, "foo102");
+	/* Print a few strings, make sure dest is truncated and return value
+	 * is the length of the returned string */
+	pwtest_int_eq(spa_scnprintf(dest, sizeof(dest), "1234567"), 7);
+	pwtest_str_eq(dest, "1234567");
+	pwtest_int_eq(spa_scnprintf(dest, sizeof(dest), "12345678"), 7);
+	pwtest_str_eq(dest, "1234567");
+	pwtest_int_eq(spa_scnprintf(dest, sizeof(dest), "123456789"), 7);
+	pwtest_str_eq(dest, "1234567");
+	/* Same as above, but with printf %s expansion */
+	pwtest_int_eq(spa_scnprintf(dest, sizeof(dest), "%s", "1234567"), 7);
+	pwtest_str_eq(dest, "1234567");
+	pwtest_int_eq(spa_scnprintf(dest, sizeof(dest), "%s", "12345678"), 7);
+	pwtest_str_eq(dest, "1234567");
+	pwtest_int_eq(spa_scnprintf(dest, sizeof(dest), "%s", "123456789"), 7);
+	pwtest_str_eq(dest, "1234567");
+
+	pwtest_int_eq(spa_scnprintf(dest, 2, "1234567"), 1);
+	pwtest_str_eq(dest, "1");
+	pwtest_int_eq(spa_scnprintf(dest, 1, "1234567"), 0);
+	pwtest_str_eq(dest, "");
+
+	/* The "append until buffer is full" use-case */
+	len = 0;
+	while ((size_t)len < sizeof(dest) - 1)
+		len += spa_scnprintf(dest + len, sizeof(dest) - len, "123");
+	/* and once more for good measure, this should print 0 characters */
+	len = spa_scnprintf(dest + len, sizeof(dest) - len, "abc");
+	pwtest_int_eq(len, 0);
+	pwtest_str_eq(dest, "1231231");
+
+	return PWTEST_PASS;
+}
+
+PWTEST(utils_snprintf_abort_neg_size)
+{
+	size_t size = pwtest_get_iteration(current_test);
+	char dest[8];
+
+	if (RUNNING_ON_VALGRIND)
+		return PWTEST_SKIP;
+
+	spa_scnprintf(dest, size, "1234"); /* expected to abort() */
+
+	return PWTEST_FAIL;
+}
+
+struct cbtest_data {
+	bool invoked;
+	const char *data;
+};
+
+static void cbtest_func(void *object, const char *msg)
+{
+	struct cbtest_data *data = object;
+	data->invoked = true;
+	data->data = msg;
+}
+
+PWTEST(utils_callback)
+{
+	struct cbtest_methods {
+		uint32_t version;
+		void (*func_v0)(void *object, const char *msg);
+		void (*func_v1)(void *object, const char *msg);
+	} methods = { 0, cbtest_func, cbtest_func };
+	struct cbtest {
+		struct spa_interface iface;
+	} cbtest;
+	struct cbtest_data data;
+
+	/* Interface version doesn't matter for this test */
+	cbtest.iface = SPA_INTERFACE_INIT("cbtest type", 0, &methods, &data);
+
+	/* Methods are version 0 */
+	methods.version = 0;
+	data.invoked = false;
+	spa_interface_call(&cbtest.iface,
+			   struct cbtest_methods,
+			   func_v0, 0, "cbtest v0");
+	pwtest_bool_true(data.invoked);
+	pwtest_str_eq(data.data, "cbtest v0");
+
+	/* v1 call should be silently filtered */
+	data.invoked = false;
+	spa_interface_call(&cbtest.iface,
+			   struct cbtest_methods,
+			   func_v1, 1, "cbtest v1");
+	pwtest_bool_false(data.invoked);
+
+	/* Methods are version 1 */
+	methods.version = 1;
+	data.invoked = false;
+	spa_interface_call(&cbtest.iface,
+			   struct cbtest_methods,
+			   func_v0, 0, "cbtest v0");
+	pwtest_bool_true(data.invoked);
+	pwtest_str_eq(data.data, "cbtest v0");
+
+	/* v1 call expected to be called */
+	data.invoked = false;
+	spa_interface_call(&cbtest.iface,
+			   struct cbtest_methods,
+			   func_v1, 1, "cbtest v1");
+	pwtest_bool_true(data.invoked);
+	pwtest_str_eq(data.data, "cbtest v1");
+
+	return PWTEST_PASS;
+}
+
+PWTEST(utils_callback_func_is_null)
+{
+	struct cbtest_methods {
+		uint32_t version;
+		void (*func_v0)(void *object, const char *msg);
+		void (*func_v1)(void *object, const char *msg);
+	} methods = { 0, NULL, NULL };
+	struct cbtest {
+		struct spa_interface iface;
+	} cbtest;
+	struct cbtest_data data;
+
+	/* Interface version doesn't matter for this test */
+	cbtest.iface = SPA_INTERFACE_INIT("cbtest type", 0, &methods, &data);
+
+	/* Methods are version 0 */
+	methods.version = 0;
+
+	/* func_v0 and func_v1 are NULL so this shouldn't crash */
+	data.invoked = false;
+	spa_interface_call(&cbtest.iface,
+			   struct cbtest_methods,
+			   func_v0, 0, "cbtest v0");
+	pwtest_bool_false(data.invoked);
+	spa_interface_call(&cbtest.iface,
+			   struct cbtest_methods,
+			   func_v1, 0, "cbtest v1");
+	pwtest_bool_false(data.invoked);
+
+	/* func_v1 is NULL so this shouldn't crash, though the call should get
+	 * filtered anyway due to version mismatch */
+	spa_interface_call(&cbtest.iface,
+			   struct cbtest_methods,
+			   func_v1, 1, "cbtest v1");
+	pwtest_bool_false(data.invoked);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(utils_callback_version)
+{
+	struct cbtest_methods {
+		uint32_t version;
+		void (*func_v0)(void *object, const char *msg);
+	} methods = { 0, cbtest_func };
+	struct cbtest {
+		struct spa_interface iface;
+	} cbtest;
+	struct cbtest_data data;
+
+	/* Interface version doesn't matter for this test */
+	cbtest.iface = SPA_INTERFACE_INIT("cbtest type", 0, &methods, &data);
+
+	/* Methods are version 0 */
+	methods.version = 0;
+	pwtest_bool_true(spa_interface_callback_version_min(&cbtest.iface,
+							    struct cbtest_methods,
+							    0));
+	pwtest_bool_false(spa_interface_callback_version_min(&cbtest.iface,
+							     struct cbtest_methods,
+							     1));
+	/* Methods are version 1 */
+	methods.version = 1;
+	pwtest_bool_true(spa_interface_callback_version_min(&cbtest.iface,
+							    struct cbtest_methods,
+							    0));
+	pwtest_bool_true(spa_interface_callback_version_min(&cbtest.iface,
+							    struct cbtest_methods,
+							    1));
+	pwtest_bool_false(spa_interface_callback_version_min(&cbtest.iface,
+							     struct cbtest_methods,
+							     2));
+
+	return PWTEST_PASS;
+}
+
+PWTEST_SUITE(spa_utils)
+{
+	pwtest_add(utils_abi_sizes, PWTEST_NOARG);
+	pwtest_add(utils_abi, PWTEST_NOARG);
+	pwtest_add(utils_macros, PWTEST_NOARG);
+	pwtest_add(utils_result, PWTEST_NOARG);
+	pwtest_add(utils_dict, PWTEST_NOARG);
+	pwtest_add(utils_list, PWTEST_NOARG);
+	pwtest_add(utils_hook, PWTEST_NOARG);
+	pwtest_add(utils_ringbuffer, PWTEST_NOARG);
+	pwtest_add(utils_strtol, PWTEST_NOARG);
+	pwtest_add(utils_strtoul, PWTEST_NOARG);
+	pwtest_add(utils_strtoll, PWTEST_NOARG);
+	pwtest_add(utils_strtof, PWTEST_NOARG);
+	pwtest_add(utils_strtod, PWTEST_NOARG);
+	pwtest_add(utils_streq, PWTEST_NOARG);
+	pwtest_add(utils_strendswith, PWTEST_NOARG);
+	pwtest_add(utils_strendswith_null_suffix,
+		   PWTEST_ARG_SIGNAL, SIGABRT);
+	pwtest_add(utils_snprintf, PWTEST_NOARG);
+	pwtest_add(utils_snprintf_abort_neg_size,
+		   PWTEST_ARG_SIGNAL, SIGABRT,
+		   PWTEST_ARG_RANGE, -2, 0);
+	pwtest_add(utils_atob, PWTEST_NOARG);
+	pwtest_add(utils_ansi, PWTEST_NOARG);
+	pwtest_add(utils_callback, PWTEST_NOARG);
+	pwtest_add(utils_callback_func_is_null, PWTEST_NOARG);
+	pwtest_add(utils_callback_version, PWTEST_NOARG);
+
+	return PWTEST_PASS;
+}