Adding upstream version 0.3.65.upstream/0.3.65upstream

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

25 files changed, 9480 insertions, 0 deletions

diff --git a/test/meson.build b/test/meson.build
new file mode 100644
index 0000000..1ce7d00
--- /dev/null
+++ b/test/meson.build
@@ -0,0 +1,156 @@
+pwtest_sources = [
+  'pwtest.h',
+  'pwtest-implementation.h',
+  'pwtest.c',
+  'pwtest-compat.c',
+]
+
+pwtest_deps = [
+  pipewire_dep,
+  mathlib,
+  dl_lib,
+  cap_lib,
+  epoll_shim_dep
+]
+
+pwtest_c_args = [
+  '-DBUILD_ROOT="@0@"'.format(meson.project_build_root()),
+  '-DSOURCE_ROOT="@0@"'.format(meson.project_source_root()),
+]
+
+pwtest_inc = [
+  pipewire_inc,
+  configinc,
+  includes_inc,
+]
+
+pwtest_lib = static_library(
+  'pwtest',
+  pwtest_sources,
+  c_args: pwtest_c_args,
+  dependencies: pwtest_deps,
+  include_directories: pwtest_inc,
+)
+
+test('test-pwtest',
+    executable('test-pwtest',
+               'test-pwtest.c',
+               include_directories: pwtest_inc,
+               dependencies: [ spa_dep ],
+               link_with: pwtest_lib)
+)
+
+# Compilation only, this is the example file for how pwtest works and most
+# of its tests will fail.
+executable('test-example',
+  'test-example.c',
+  include_directories: pwtest_inc,
+  dependencies: [ spa_dep ],
+  link_with: pwtest_lib)
+
+test('test-pw-utils',
+    executable('test-pw-utils',
+               'test-properties.c',
+               'test-array.c',
+               'test-map.c',
+               'test-utils.c',
+               include_directories: pwtest_inc,
+               dependencies: [ spa_dep ],
+               link_with: pwtest_lib)
+)
+
+test('test-lib',
+    executable('test-lib',
+               'test-lib.c',
+               include_directories: pwtest_inc,
+               dependencies: [ spa_dep ],
+               link_with: pwtest_lib)
+)
+
+test('test-client',
+    executable('test-client',
+               'test-client.c',
+               include_directories: pwtest_inc,
+               dependencies: [ spa_dep ],
+               link_with: pwtest_lib)
+)
+
+test('test-loop',
+    executable('test-loop',
+               'test-loop.c',
+               include_directories: pwtest_inc,
+               dependencies: [ spa_dep ],
+               link_with: pwtest_lib)
+)
+
+test('test-context',
+    executable('test-context',
+               'test-context.c',
+               'test-config.c',
+               include_directories: pwtest_inc,
+               dependencies: [spa_dep, spa_support_dep, spa_dbus_dep],
+               link_with: [pwtest_lib,
+                            pipewire_module_protocol_native,
+                            pipewire_module_client_node,
+                            pipewire_module_client_device,
+                            pipewire_module_adapter,
+                            pipewire_module_metadata,
+                            pipewire_module_session_manager])
+)
+
+test('test-support',
+    executable('test-support',
+               'test-support.c',
+               'test-logger.c',
+               include_directories: pwtest_inc,
+               dependencies: [spa_dep, systemd_dep, spa_support_dep, spa_journal_dep],
+               link_with: [pwtest_lib])
+)
+test('test-spa',
+    executable('test-spa',
+               'test-spa-buffer.c',
+               'test-spa-json.c',
+               'test-spa-utils.c',
+               'test-spa-log.c',
+               'test-spa-node.c',
+               'test-spa-pod.c',
+               include_directories: pwtest_inc,
+               dependencies: [ spa_dep ],
+               link_with: pwtest_lib)
+)
+
+openal_info = find_program('openal-info', required: false)
+if openal_info.found()
+    cdata.set_quoted('OPENAL_INFO_PATH', openal_info.full_path())
+endif
+summary({'openal-info': openal_info.found()}, bool_yn: true, section: 'Functional test programs')
+
+pactl = find_program('pactl', required: false)
+if pactl.found()
+    cdata.set_quoted('PACTL_PATH', pactl.full_path())
+endif
+summary({'pactl': pactl.found()}, bool_yn: true, section: 'Functional test programs')
+
+if default_sm == 'media-session' or default_sm == 'wireplumber'
+  test('test-functional',
+    executable('test-functional',
+               'test-functional.c',
+               include_directories: pwtest_inc,
+               dependencies: [ spa_dep ],
+               link_with: pwtest_lib)
+  )
+endif
+
+valgrind = find_program('valgrind', required: false)
+summary({'valgrind (test setup)': valgrind.found()}, bool_yn: true, section: 'Optional programs')
+if valgrind.found()
+  valgrind_env = environment({'PIPEWIRE_DEBUG': 'D'})
+  add_test_setup('valgrind',
+                 exe_wrapper : [ valgrind,
+                   '--leak-check=full',
+                   '--gen-suppressions=all',
+                   '--error-exitcode=3',
+                   ],
+                 env :  valgrind_env,
+                 timeout_multiplier : 3)
+endif
diff --git a/test/pwtest-compat.c b/test/pwtest-compat.c
new file mode 100644
index 0000000..fa89756
--- /dev/null
+++ b/test/pwtest-compat.c
@@ -0,0 +1,55 @@
+/* PipeWire
+ *
+ * Copyright © 2021 Red Hat, Inc.
+ *
+ * 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 "config.h"
+
+#ifndef HAVE_SIGABBREV_NP
+#include <stddef.h>
+#include <signal.h>
+
+/* glibc >= 2.32 */
+static inline const char *sigabbrev_np(int sig)
+{
+#define SIGABBREV(a_) case SIG##a_: return #a_
+	switch(sig) {
+	SIGABBREV(INT);
+	SIGABBREV(ABRT);
+	SIGABBREV(BUS);
+	SIGABBREV(SEGV);
+	SIGABBREV(ALRM);
+	SIGABBREV(CHLD);
+	SIGABBREV(HUP);
+	SIGABBREV(PIPE);
+	SIGABBREV(CONT);
+	SIGABBREV(STOP);
+	SIGABBREV(ILL);
+	SIGABBREV(KILL);
+	SIGABBREV(TERM);
+	}
+#undef SIGABBREV
+
+	return NULL;
+}
+
+#endif /* HAVE_SIGABBREV_NP */
diff --git a/test/pwtest-implementation.h b/test/pwtest-implementation.h
new file mode 100644
index 0000000..1525d20
--- /dev/null
+++ b/test/pwtest-implementation.h
@@ -0,0 +1,137 @@
+/* PipeWire
+ *
+ * Copyright © 2021 Red Hat, Inc.
+ *
+ * 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.
+ */
+
+#ifndef PWTEST_IMPLEMENTATION_H
+#define PWTEST_IMPLEMENTATION_H
+
+#include <math.h>
+
+/* This header should never be included on its own, it merely exists to make
+ * the user-visible pwtest.h header more readable */
+
+void
+_pwtest_fail_condition(int exitstatus, const char *file, int line, const char *func,
+		      const char *condition, const char *message, ...);
+void
+_pwtest_fail_comparison_int(const char *file, int line, const char *func,
+			   const char *operator, int a, int b,
+			   const char *astr, const char *bstr);
+void
+_pwtest_fail_comparison_double(const char *file, int line, const char *func,
+			      const char *operator, double a, double b,
+			      const char *astr, const char *bstr);
+void
+_pwtest_fail_comparison_ptr(const char *file, int line, const char *func,
+			   const char *comparison);
+
+void
+_pwtest_fail_comparison_str(const char *file, int line, const char *func,
+			   const char *comparison, const char *a, const char *b);
+
+void
+_pwtest_fail_comparison_bool(const char *file, int line, const char *func,
+			     const char *operator, bool a, bool b,
+			     const char *astr, const char *bstr);
+
+void
+_pwtest_fail_errno(const char *file, int line, const char *func,
+		   int expected, int err_no);
+
+#define pwtest_errno_check(r_, errno_) \
+	do { \
+		int _r = r_; \
+		int _e = errno_; \
+		if (_e == 0) { \
+			if (_r == -1) \
+				_pwtest_fail_errno(__FILE__, __LINE__, __func__, _e, errno); \
+		} else { \
+			if (_r != -1 || errno != _e) \
+				_pwtest_fail_errno(__FILE__, __LINE__, __func__, _e, errno); \
+		} \
+	} while(0)
+
+#define pwtest_neg_errno_check(r_, errno_) \
+	do { \
+		int _r = r_; \
+		int _e = errno_; \
+		if (_e == 0) { \
+			if (_r < 0) \
+				_pwtest_fail_errno(__FILE__, __LINE__, __func__, _e, -_r); \
+		} else { \
+			if (_r >= 0 || _r != _e) \
+				_pwtest_fail_errno(__FILE__, __LINE__, __func__, -_e, _r >= 0 ? 0 : -_r); \
+		} \
+	} while(0)
+
+#define pwtest_comparison_bool_(a_, op_, b_) \
+	do { \
+		bool _a = !!(a_); \
+		bool _b = !!(b_); \
+		if (!(_a op_ _b)) \
+			_pwtest_fail_comparison_bool(__FILE__, __LINE__, __func__,\
+						#op_, _a, _b, #a_, #b_); \
+	} while(0)
+
+#define pwtest_comparison_int_(a_, op_, b_) \
+	do { \
+		__typeof__(a_) _a = a_; \
+		__typeof__(b_) _b = b_; \
+		if (trunc(_a) != _a || trunc(_b) != _b) \
+			pwtest_error_with_msg("pwtest_int_* used for non-integer value\n"); \
+		if (!((_a) op_ (_b))) \
+			_pwtest_fail_comparison_int(__FILE__, __LINE__, __func__,\
+						#op_, _a, _b, #a_, #b_); \
+	} while(0)
+
+#define pwtest_comparison_ptr_(a_, op_, b_) \
+	do { \
+		__typeof__(a_) _a = a_; \
+		__typeof__(b_) _b = b_; \
+		if (!((_a) op_ (_b))) \
+			_pwtest_fail_comparison_ptr(__FILE__, __LINE__, __func__,\
+						#a_ " " #op_ " " #b_); \
+	} while(0)
+
+#define pwtest_comparison_double_(a_, op_, b_) \
+	do { \
+		const double EPSILON = 1.0/256; \
+		__typeof__(a_) _a = a_; \
+		__typeof__(b_) _b = b_; \
+		if (!((_a) op_ (_b)) && fabs((_a) - (_b)) > EPSILON)  \
+			_pwtest_fail_comparison_double(__FILE__, __LINE__, __func__,\
+						#op_, _a, _b, #a_, #b_); \
+	} while(0)
+
+void _pwtest_add(struct pwtest_context *ctx,
+		 struct pwtest_suite *suite,
+		 const char *funcname, const void *func,
+		 ...) SPA_SENTINEL;
+
+struct pwtest_suite_decl {
+	const char *name;
+	enum pwtest_result (*setup)(struct pwtest_context *, struct pwtest_suite *);
+};
+
+
+#endif /* PWTEST_IMPLEMENTATION_H */
diff --git a/test/pwtest.c b/test/pwtest.c
new file mode 100644
index 0000000..968805b
--- /dev/null
+++ b/test/pwtest.c
@@ -0,0 +1,1486 @@
+/* PipeWire
+ *
+ * Copyright © 2021 Red Hat, Inc.
+ *
+ * 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 "config.h"
+
+#include <assert.h>
+#include <dlfcn.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <fnmatch.h>
+#include <ftw.h>
+#include <getopt.h>
+#include <limits.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <signal.h>
+#ifdef HAVE_PIDFD_OPEN
+#include <sys/syscall.h>
+#endif
+#ifdef HAVE_LIBCAP
+#include <sys/capability.h>
+#endif
+#include <sys/epoll.h>
+#include <sys/ptrace.h>
+#include <sys/resource.h>
+#include <sys/stat.h>
+#include <sys/timerfd.h>
+#include <sys/wait.h>
+#include <time.h>
+
+#include <valgrind/valgrind.h>
+
+#include "spa/utils/ansi.h"
+#include "spa/utils/string.h"
+#include "spa/utils/defs.h"
+#include "spa/utils/list.h"
+#include "spa/support/plugin.h"
+
+#include "pipewire/array.h"
+#include "pipewire/utils.h"
+#include "pipewire/properties.h"
+
+#include "pwtest.h"
+
+#include "pwtest-compat.c"
+
+#define pwtest_log(...) dprintf(testlog_fd, __VA_ARGS__)
+#define pwtest_vlog(format_, args_) vdprintf(testlog_fd, format_, args_)
+
+static bool verbose = false;
+
+/** the global context object */
+static struct pwtest_context *ctx;
+
+/**
+ * The various pwtest_assert() etc. functions write to this fd, collected
+ * separately in the log.
+ */
+static int testlog_fd = STDOUT_FILENO;
+
+enum pwtest_logfds {
+	FD_STDOUT,
+	FD_STDERR,
+	FD_LOG,
+	FD_DAEMON,
+	_FD_LAST,
+};
+
+struct pwtest_test {
+	struct spa_list link;
+	const char *name;
+	enum pwtest_result (*func)(struct pwtest_test *test);
+
+	int iteration;
+
+	/* env vars changed by pwtest. These will be restored after the test
+	 * run to get close to the original environment. */
+	struct pw_properties *env;
+
+	/* Arguments during pwtest_add() */
+	struct {
+		int signal;
+		struct {
+			int min, max;
+		} range;
+		struct pw_properties *props;
+		struct pw_properties *env;
+		bool pw_daemon;
+	} args;
+
+	/* Results */
+	enum pwtest_result result;
+	int sig_or_errno;
+	struct pw_array logs[_FD_LAST];
+};
+
+struct pwtest_suite {
+	struct spa_list link;
+	const struct pwtest_suite_decl *decl;
+	enum pwtest_result result;
+
+	struct spa_list tests;
+};
+
+struct pwtest_context {
+	struct spa_list suites;
+	unsigned int timeout;
+	bool no_fork;
+	bool terminate;
+	struct spa_list cleanup_pids;
+
+	const char *test_filter;
+	bool has_iteration_filter;
+	int iteration_filter;
+	char *xdg_dir;
+};
+
+struct cleanup_pid {
+	struct spa_list link;
+	pid_t pid;
+};
+
+struct pwtest_context *pwtest_get_context(struct pwtest_test *t)
+{
+	return ctx;
+}
+
+int pwtest_get_iteration(struct pwtest_test *t)
+{
+	return t->iteration;
+}
+
+struct pw_properties *pwtest_get_props(struct pwtest_test *t)
+{
+	return t->args.props;
+}
+
+static void replace_env(struct pwtest_test *t, const char *prop, const char *value)
+{
+	const char *oldval = getenv(prop);
+
+	pw_properties_set(t->env, prop, oldval ? oldval : "pwtest-null");
+	if (value)
+		setenv(prop, value, 1);
+	else
+		unsetenv(prop);
+}
+
+static void restore_env(struct pwtest_test *t)
+{
+	const char *env;
+	void *state = NULL;
+
+	while ((env = pw_properties_iterate(t->env, &state))) {
+		const char *value = pw_properties_get(t->env, env);
+		if (spa_streq(value, "pwtest-null"))
+			unsetenv(env);
+		else
+			setenv(env, value, 1);
+	}
+}
+
+static int add_cleanup_pid(struct pwtest_context *ctx, pid_t pid)
+{
+	struct cleanup_pid *cpid;
+
+	if (pid == 0)
+		return -EINVAL;
+
+	cpid = calloc(1, sizeof(struct cleanup_pid));
+	if (cpid == NULL)
+		return -errno;
+
+	cpid->pid = pid;
+	spa_list_append(&ctx->cleanup_pids, &cpid->link);
+
+	return 0;
+}
+
+static void remove_cleanup_pid(struct pwtest_context *ctx, pid_t pid)
+{
+	struct cleanup_pid *cpid, *t;
+
+	spa_list_for_each_safe(cpid, t, &ctx->cleanup_pids, link) {
+		if (cpid->pid == pid) {
+			spa_list_remove(&cpid->link);
+			free(cpid);
+		}
+	}
+}
+
+static void terminate_cleanup_pids(struct pwtest_context *ctx)
+{
+	struct cleanup_pid *cpid;
+	spa_list_for_each(cpid, &ctx->cleanup_pids, link) {
+		/* Don't free here, to be signal-safe */
+		if (cpid->pid != 0) {
+			kill(cpid->pid, SIGTERM);
+			cpid->pid = 0;
+		}
+	}
+}
+
+static void free_cleanup_pids(struct pwtest_context *ctx)
+{
+	struct cleanup_pid *cpid;
+	spa_list_consume(cpid, &ctx->cleanup_pids, link) {
+		spa_list_remove(&cpid->link);
+		free(cpid);
+	}
+}
+
+static void pwtest_backtrace(pid_t p)
+{
+#ifdef HAVE_GSTACK
+	char pid[11];
+	pid_t parent, child;
+	int status;
+
+	if (RUNNING_ON_VALGRIND)
+		return;
+
+	parent = p == 0 ? getpid() : p;
+	child = fork();
+	if (child == 0) {
+		assert(testlog_fd > 0);
+		/* gstack writes the backtrace to stdout, we re-route to our
+		 * custom fd */
+		dup2(testlog_fd, STDOUT_FILENO);
+
+		spa_scnprintf(pid, sizeof(pid), "%d", (uint32_t)parent);
+		execlp("gstack", "gstack", pid, NULL);
+		exit(errno);
+	}
+
+	/* parent */
+	waitpid(child, &status, 0);
+#endif
+}
+
+SPA_PRINTF_FUNC(6, 7)
+SPA_NORETURN
+void _pwtest_fail_condition(int exitstatus,
+			    const char *file, int line, const char *func,
+			    const char *condition, const char *message, ...)
+{
+	pwtest_log("FAILED: %s\n", condition);
+
+	if (message) {
+		va_list args;
+		va_start(args, message);
+		pwtest_vlog(message, args);
+		va_end(args);
+		pwtest_log("\n");
+	}
+
+	pwtest_log("in %s() (%s:%d)\n", func, file, line);
+	pwtest_backtrace(0);
+	exit(exitstatus);
+}
+
+SPA_NORETURN
+void _pwtest_fail_comparison_bool(const char *file, int line, const char *func,
+				 const char *operator, bool a, bool b,
+				 const char *astr, const char *bstr)
+{
+	pwtest_log("FAILED COMPARISON: %s %s %s\n", astr, operator, bstr);
+	pwtest_log("Resolved to: %s %s %s\n", a ? "true" : "false", operator, b ? "true" : "false");
+	pwtest_log("in %s() (%s:%d)\n", func, file, line);
+	pwtest_backtrace(0);
+	exit(PWTEST_FAIL);
+}
+
+SPA_NORETURN
+void _pwtest_fail_errno(const char *file, int line, const char *func,
+			int expected, int err_no)
+{
+	pwtest_log("FAILED ERRNO CHECK: expected %d (%s), got %d (%s)\n",
+		   expected, strerror(expected), err_no, strerror(err_no));
+	pwtest_log("in %s() (%s:%d)\n", func, file, line);
+	pwtest_backtrace(0);
+	exit(PWTEST_FAIL);
+}
+
+
+SPA_NORETURN
+void _pwtest_fail_comparison_int(const char *file, int line, const char *func,
+				 const char *operator, int a, int b,
+				 const char *astr, const char *bstr)
+{
+	pwtest_log("FAILED COMPARISON: %s %s %s\n", astr, operator, bstr);
+	pwtest_log("Resolved to: %d %s %d\n", a, operator, b);
+	pwtest_log("in %s() (%s:%d)\n", func, file, line);
+	pwtest_backtrace(0);
+	exit(PWTEST_FAIL);
+}
+
+SPA_NORETURN
+void _pwtest_fail_comparison_double(const char *file, int line, const char *func,
+				   const char *operator, double a, double b,
+				   const char *astr, const char *bstr)
+{
+	pwtest_log("FAILED COMPARISON: %s %s %s\n", astr, operator, bstr);
+	pwtest_log("Resolved to: %.3f %s %.3f\n", a, operator, b);
+	pwtest_log("in %s() (%s:%d)\n", func, file, line);
+	pwtest_backtrace(0);
+	exit(PWTEST_FAIL);
+}
+
+SPA_NORETURN
+void _pwtest_fail_comparison_ptr(const char *file, int line, const char *func,
+				const char *comparison)
+{
+	pwtest_log("FAILED COMPARISON: %s\n", comparison);
+	pwtest_log("in %s() (%s:%d)\n", func, file, line);
+	pwtest_backtrace(0);
+	exit(PWTEST_FAIL);
+}
+
+SPA_NORETURN
+void _pwtest_fail_comparison_str(const char *file, int line, const char *func,
+				 const char *comparison, const char *a, const char *b)
+{
+	pwtest_log("FAILED COMPARISON: %s, expanded (\"%s\" vs \"%s\")\n", comparison, a, b);
+	pwtest_log("in %s() (%s:%d)\n", func, file, line);
+	pwtest_backtrace(0);
+	exit(PWTEST_FAIL);
+}
+
+struct pwtest_spa_plugin *
+pwtest_spa_plugin_new(void)
+{
+	return calloc(1, sizeof(struct pwtest_spa_plugin));
+}
+
+void
+pwtest_spa_plugin_destroy(struct pwtest_spa_plugin *plugin)
+{
+	SPA_FOR_EACH_ELEMENT_VAR(plugin->handles, hnd) {
+		if (*hnd) {
+			spa_handle_clear(*hnd);
+			free(*hnd);
+		}
+	}
+	SPA_FOR_EACH_ELEMENT_VAR(plugin->dlls, dll) {
+		if (*dll)
+			dlclose(*dll);
+	}
+	free(plugin);
+}
+
+int
+pwtest_spa_plugin_try_load_interface(struct pwtest_spa_plugin *plugin,
+				     void **iface_return,
+				     const char *libname,
+				     const char *factory_name,
+				     const char *interface_name,
+				     const struct spa_dict *info)
+{
+	char *libdir = getenv("SPA_PLUGIN_DIR");
+	char path[PATH_MAX];
+	void *hnd, *iface;
+	spa_handle_factory_enum_func_t enum_func;
+	const struct spa_handle_factory *factory;
+	uint32_t index = 0;
+	int r;
+	bool found = false;
+	struct spa_handle *handle;
+
+	spa_assert_se(libdir != NULL);
+	spa_scnprintf(path, sizeof(path), "%s/%s.so", libdir, libname);
+
+        hnd = dlopen(path, RTLD_NOW);
+	if (hnd == NULL)
+		return -ENOENT;
+
+	enum_func = dlsym(hnd, SPA_HANDLE_FACTORY_ENUM_FUNC_NAME);
+	pwtest_ptr_notnull(enum_func);
+
+	while ((r = enum_func(&factory, &index)) > 0) {
+		pwtest_int_ge(factory->version, 1U);
+		if (spa_streq(factory->name, factory_name)) {
+			found = true;
+			break;
+		}
+	}
+	pwtest_neg_errno_ok(r);
+	if (!found) {
+		dlclose(hnd);
+		return -EINVAL;
+	}
+
+	handle = calloc(1, spa_handle_factory_get_size(factory, info));
+	pwtest_ptr_notnull(handle);
+
+	r = spa_handle_factory_init(factory, handle, info, plugin->support, plugin->nsupport);
+	pwtest_neg_errno_ok(r);
+	if ((r = spa_handle_get_interface(handle, interface_name, &iface)) != 0) {
+		spa_handle_clear(handle);
+		free(handle);
+		dlclose(hnd);
+		return -ENOSYS;
+	}
+
+	plugin->dlls[plugin->ndlls++] = hnd;
+	plugin->handles[plugin->nhandles++] = handle;
+	plugin->support[plugin->nsupport++] = SPA_SUPPORT_INIT(interface_name, iface);
+
+	*iface_return = iface;
+	return 0;
+}
+
+void *
+pwtest_spa_plugin_load_interface(struct pwtest_spa_plugin *plugin,
+				 const char *libname,
+				 const char *factory_name,
+				 const char *interface_name,
+				 const struct spa_dict *info)
+{
+	void *iface;
+	int r = pwtest_spa_plugin_try_load_interface(plugin, &iface, libname,
+						     factory_name, interface_name, info);
+	pwtest_neg_errno_ok(r);
+	return iface;
+}
+
+void
+pwtest_mkstemp(char path[PATH_MAX])
+{
+	const char *tmpdir = getenv("TMPDIR");
+	int r;
+
+	if (tmpdir == NULL)
+		pwtest_error_with_msg("tmpdir is unset");
+
+	spa_scnprintf(path, PATH_MAX, "%s/%s", tmpdir, "tmp.XXXXXX");
+	r = mkstemp(path);
+	if (r == -1)
+		pwtest_error_with_msg("Unable to create temporary file: %s", strerror(errno));
+}
+
+int
+pwtest_spawn(const char *file, char *const argv[])
+{
+	int r;
+	int status = -1;
+	pid_t pid;
+	const int fail_code = 121;
+
+	pid = fork();
+	if (pid == 0) {
+		/* child process */
+		execvp(file, (char **)argv);
+		exit(fail_code);
+	} else if (pid < 0)
+		pwtest_error_with_msg("Unable to fork: %s", strerror(errno));
+
+	add_cleanup_pid(ctx, pid);
+	r = waitpid(pid, &status, 0);
+	remove_cleanup_pid(ctx, pid);
+	if (r <= 0)
+		pwtest_error_with_msg("waitpid failed: %s", strerror(errno));
+
+	if (WEXITSTATUS(status) == fail_code)
+		pwtest_error_with_msg("exec %s failed", file);
+
+	return status;
+}
+
+void _pwtest_add(struct pwtest_context *ctx, struct pwtest_suite *suite,
+		 const char *funcname, const void *func, ...)
+{
+	struct pwtest_test *t;
+	va_list args;
+
+	if (ctx->test_filter != NULL && fnmatch(ctx->test_filter, funcname, 0) != 0)
+		return;
+
+	t = calloc(1, sizeof *t);
+	t->result = PWTEST_SYSTEM_ERROR;
+	t->name = funcname;
+	t->func = func;
+	t->args.range.min = 0;
+	t->args.range.max = 1;
+	t->args.env = pw_properties_new("PWTEST", "1", NULL);
+	t->env = pw_properties_new(NULL, NULL);
+	for (size_t i = 0; i < SPA_N_ELEMENTS(t->logs); i++)
+		pw_array_init(&t->logs[i], 1024);
+
+	va_start(args, func);
+	while (true) {
+		const char *key, *value;
+
+		enum pwtest_arg arg = va_arg(args, enum pwtest_arg);
+		if (!arg)
+			break;
+		switch (arg) {
+		case PWTEST_NOARG:
+			break;
+		case PWTEST_ARG_SIGNAL:
+			if (RUNNING_ON_VALGRIND)
+				t->result = PWTEST_SKIP;
+			t->args.signal = va_arg(args, int);
+			break;
+		case PWTEST_ARG_RANGE:
+			t->args.range.min = va_arg(args, int);
+			t->args.range.max = va_arg(args, int);
+			break;
+		case PWTEST_ARG_PROP:
+			key = va_arg(args, const char *);
+			value = va_arg(args, const char *);
+			if (t->args.props == NULL) {
+				t->args.props = pw_properties_new(key, value, NULL);
+			} else {
+				pw_properties_set(t->args.props, key, value);
+			}
+			break;
+		case PWTEST_ARG_ENV:
+			key = va_arg(args, const char *);
+			value = va_arg(args, const char *);
+			pw_properties_set(t->args.env, key, value);
+			break;
+		case PWTEST_ARG_DAEMON:
+			if (RUNNING_ON_VALGRIND)
+				t->result = PWTEST_SKIP;
+			t->args.pw_daemon = true;
+			break;
+		}
+	}
+	va_end(args);
+
+	spa_list_append(&suite->tests, &t->link);
+}
+
+extern const struct pwtest_suite_decl __start_pwtest_suite_section;
+extern const struct pwtest_suite_decl __stop_pwtest_suite_section;
+
+static void add_suite(struct pwtest_context *ctx,
+		      const struct pwtest_suite_decl *decl)
+{
+	struct pwtest_suite *c = calloc(1, sizeof *c);
+
+	c->decl = decl;
+	spa_list_init(&c->tests);
+	spa_list_append(&ctx->suites, &c->link);
+}
+
+static void free_test(struct pwtest_test *t)
+{
+	spa_list_remove(&t->link);
+	for (size_t i = 0; i < SPA_N_ELEMENTS(t->logs); i++)
+		pw_array_clear(&t->logs[i]);
+	pw_properties_free(t->args.props);
+	pw_properties_free(t->args.env);
+	pw_properties_free(t->env);
+	free(t);
+}
+
+static void free_suite(struct pwtest_suite *c)
+{
+	struct pwtest_test *t, *tmp;
+
+	spa_list_for_each_safe(t, tmp, &c->tests, link)
+		free_test(t);
+
+	spa_list_remove(&c->link);
+	free(c);
+}
+
+static void find_suites(struct pwtest_context *ctx, const char *suite_filter)
+{
+	const struct pwtest_suite_decl *c;
+
+	for (c = &__start_pwtest_suite_section; c < &__stop_pwtest_suite_section; c++) {
+		if (suite_filter == NULL || fnmatch(suite_filter, c->name, 0) == 0)
+			add_suite(ctx, c);
+	}
+}
+
+static void add_tests(struct pwtest_context *ctx)
+{
+	struct pwtest_suite *c;
+
+	spa_list_for_each(c, &ctx->suites, link) {
+		c->result = c->decl->setup(ctx, c);
+		spa_assert_se(c->result >= PWTEST_PASS && c->result <= PWTEST_SYSTEM_ERROR);
+	}
+}
+
+static int remove_file(const char *fpath, const struct stat *sb, int typeflag, struct FTW *ftwbuf)
+{
+	char *tmpdir = getenv("TMPDIR");
+	int r;
+
+	/* Safety check: bail out if somehow we left TMPDIR */
+	spa_assert_se(tmpdir != NULL);
+	spa_assert_se(spa_strneq(fpath, tmpdir, strlen(tmpdir)));
+
+	r = remove(fpath);
+	if (r)
+		fprintf(stderr, "Failed to remove %s: %m", fpath);
+
+	return r;
+}
+
+static void remove_xdg_runtime_dir(const char *xdg_dir)
+{
+	char *tmpdir = getenv("TMPDIR");
+	char path[PATH_MAX];
+	int r;
+
+	if (xdg_dir == NULL)
+		return;
+
+	/* Safety checks, we really don't want to recursively remove a
+	 * random directory due to a bug */
+	spa_assert_se(tmpdir != NULL);
+	spa_assert_se(spa_strneq(xdg_dir, tmpdir, strlen(tmpdir)));
+	r = spa_scnprintf(path, sizeof(path), "%s/pwtest.dir", xdg_dir);
+	spa_assert_se((size_t)r == strlen(xdg_dir) + 11);
+	if (access(path, F_OK) != 0) {
+		fprintf(stderr, "XDG_RUNTIME_DIR changed, cannot clean up\n");
+		return;
+	}
+
+	nftw(xdg_dir, remove_file, 16, FTW_DEPTH | FTW_PHYS);
+}
+
+static void cleanup(struct pwtest_context *ctx)
+{
+	struct pwtest_suite *c, *tmp;
+
+	terminate_cleanup_pids(ctx);
+	free_cleanup_pids(ctx);
+
+	spa_list_for_each_safe(c, tmp, &ctx->suites, link) {
+		free_suite(c);
+	}
+
+	remove_xdg_runtime_dir(ctx->xdg_dir);
+	free(ctx->xdg_dir);
+}
+
+static void sighandler(int signal)
+{
+	struct sigaction act;
+	sigemptyset(&act.sa_mask);
+	act.sa_flags = 0;
+	act.sa_handler = SIG_DFL;
+	sigaction(signal, &act, NULL);
+
+	pwtest_backtrace(0);
+	terminate_cleanup_pids(ctx);
+	raise(signal);
+}
+
+static inline void log_append(struct pw_array *buffer, int fd)
+{
+	int r = 0;
+	const int sz = 65536;
+
+	while (true) {
+		r = pw_array_ensure_size(buffer, sz);
+		spa_assert_se(r == 0);
+		r = read(fd, pw_array_end(buffer), sz);
+		if (r <= 0)
+			break;
+		/* We've read directly into the array's buffer, we just add
+		 * now to update the array */
+		pw_array_add(buffer, r);
+	}
+}
+
+static bool collect_child(struct pwtest_test *t, pid_t pid)
+{
+	int r;
+	int status;
+
+	r = waitpid(pid, &status, WNOHANG);
+	if (r <= 0)
+		return false;
+
+	if (WIFEXITED(status)) {
+		t->result = WEXITSTATUS(status);
+		switch (t->result) {
+			case PWTEST_PASS:
+			case PWTEST_SKIP:
+			case PWTEST_FAIL:
+			case PWTEST_TIMEOUT:
+			case PWTEST_SYSTEM_ERROR:
+				break;
+			default:
+				spa_assert_se(!"Invalid test result");
+				break;
+		}
+		return true;
+	}
+
+	if (WIFSIGNALED(status)) {
+		t->sig_or_errno = WTERMSIG(status);
+		t->result = (t->sig_or_errno == t->args.signal) ? PWTEST_PASS : PWTEST_FAIL;
+	} else {
+		t->result = PWTEST_FAIL;
+	}
+	return true;
+}
+
+static pid_t start_pwdaemon(struct pwtest_test *t, int stderr_fd, int log_fd)
+{
+	static unsigned int count;
+	const char *daemon = BUILD_ROOT "/src/daemon/pipewire-uninstalled";
+	pid_t pid;
+	char pw_remote[64];
+	int status;
+	int r;
+
+	spa_scnprintf(pw_remote, sizeof(pw_remote), "pwtest-pw-%u\n", count++);
+	replace_env(t, "PIPEWIRE_REMOTE", pw_remote);
+
+	pid = fork();
+	if (pid == 0) {
+		/* child */
+		setpgid(0, 0);
+
+		setenv("PIPEWIRE_CORE", pw_remote, 1);
+		setenv("PIPEWIRE_DEBUG", "4", 0);
+		setenv("WIREPLUMBER_DEBUG", "4", 0);
+
+		r = dup2(stderr_fd, STDERR_FILENO);
+		spa_assert_se(r != -1);
+		r = dup2(stderr_fd, STDOUT_FILENO);
+		spa_assert_se(r != -1);
+
+		execl(daemon, daemon, (char*)NULL);
+		return -errno;
+
+	} else if (pid < 0) {
+		return pid;
+	}
+
+	add_cleanup_pid(ctx, -pid);
+
+	/* parent */
+	sleep(1); /* FIXME how to wait for pw to be ready? */
+	if (waitpid(pid, &status, WNOHANG) > 0) {
+		if (WIFEXITED(status)) {
+			dprintf(log_fd, "pipewire daemon exited with %d before test started\n", WEXITSTATUS(status));
+			return -ESRCH;
+		} else if (WIFSIGNALED(status)) {
+			dprintf(log_fd, "pipewire daemon terminated with %d (SIG%s) before test started\n", WTERMSIG(status),
+				sigabbrev_np(WTERMSIG(status)));
+			return -EHOSTDOWN;
+		}
+	}
+
+	return pid;
+}
+
+static void make_xdg_runtime_test_dir(char dir[PATH_MAX], const char *prefix)
+{
+	static size_t counter;
+	int r;
+
+	r = spa_scnprintf(dir, PATH_MAX, "%s/%zd", prefix, counter++);
+	spa_assert_se(r >= (int)(strlen(prefix) + 2));
+	r = mkdir(dir, 0777);
+	if (r == -1) {
+		fprintf(stderr, "Failed to make XDG_RUNTIME_DIR %s (%m)\n", dir);
+		spa_assert_se(r != -1);
+	}
+}
+
+static void set_test_env(struct pwtest_context *ctx, struct pwtest_test *t)
+{
+	char xdg_runtime_dir[PATH_MAX];
+
+	make_xdg_runtime_test_dir(xdg_runtime_dir, ctx->xdg_dir);
+	replace_env(t, "XDG_RUNTIME_DIR", xdg_runtime_dir);
+	replace_env(t, "TMPDIR", xdg_runtime_dir);
+
+	replace_env(t, "SPA_PLUGIN_DIR", BUILD_ROOT "/spa/plugins");
+	replace_env(t, "SPA_DATA_DIR", SOURCE_ROOT "/spa/plugins");
+	replace_env(t, "PIPEWIRE_CONFIG_DIR", BUILD_ROOT "/src/daemon");
+	replace_env(t, "PIPEWIRE_MODULE_DIR", BUILD_ROOT "/src/modules");
+	replace_env(t, "ACP_PATHS_DIR", SOURCE_ROOT "/spa/plugins/alsa/mixer/paths");
+	replace_env(t, "ACP_PROFILES_DIR", SOURCE_ROOT "/spa/plugins/alsa/mixer/profile-sets");
+	replace_env(t, "PIPEWIRE_LOG_SYSTEMD", "false");
+}
+
+static void close_pipes(int fds[_FD_LAST])
+{
+	for (int i = 0; i < _FD_LAST; i++) {
+		if (fds[i] >= 0)
+			close(fds[i]);
+		fds[i] = -1;
+	}
+}
+
+static int init_pipes(int read_fds[_FD_LAST], int write_fds[_FD_LAST])
+{
+	int r;
+	int i;
+	int pipe_max_size = 4194304;
+
+	for (i = 0; i < _FD_LAST; i++) {
+		read_fds[i] = -1;
+		write_fds[i] = -1;
+	}
+
+#ifdef __linux__
+	{
+		FILE *f;
+		f = fopen("/proc/sys/fs/pipe-max-size", "re");
+		if (f) {
+			if (fscanf(f, "%d", &r) == 1)
+				pipe_max_size = SPA_MIN(r, pipe_max_size);
+			fclose(f);
+		}
+	}
+#endif
+
+	for (i = 0; i < _FD_LAST; i++) {
+		int pipe[2];
+
+		r = pipe2(pipe, O_CLOEXEC | O_NONBLOCK);
+		if (r < 0)
+			goto error;
+		read_fds[i] = pipe[0];
+		write_fds[i] = pipe[1];
+#ifdef __linux__
+		/* Max pipe buffers, to avoid scrambling if reading lags.
+		 * Can't use blocking write fds, since reading too slow
+		 * then affects execution.
+		 */
+		fcntl(write_fds[i], F_SETPIPE_SZ, pipe_max_size);
+#endif
+	}
+
+	return 0;
+error:
+	r = -errno;
+	close_pipes(read_fds);
+	close_pipes(write_fds);
+	return r;
+}
+
+static void start_test_nofork(struct pwtest_test *t)
+{
+	const char *env;
+	void *state = NULL;
+
+	/* This is going to mess with future tests */
+	while ((env = pw_properties_iterate(t->args.env, &state)))
+		replace_env(t, env, pw_properties_get(t->args.env, env));
+
+	/* The actual test function */
+	t->result = t->func(t);
+}
+
+static int start_test_forked(struct pwtest_test *t, int read_fds[_FD_LAST], int write_fds[_FD_LAST])
+{
+	pid_t pid;
+	enum pwtest_result result;
+	struct sigaction act;
+	const char *env;
+	void *state = NULL;
+	int r;
+
+	pid = fork();
+	if (pid < 0) {
+		r = -errno;
+		close_pipes(read_fds);
+		close_pipes(write_fds);
+		return r;
+	}
+
+	if (pid > 0) { /* parent */
+		close_pipes(write_fds);
+		return pid;
+	}
+
+	/* child */
+
+	close_pipes(read_fds);
+
+	/* Reset cleanup pid list */
+	free_cleanup_pids(ctx);
+
+	/* Catch any crashers so we can insert a backtrace */
+	sigemptyset(&act.sa_mask);
+	act.sa_flags = 0;
+	act.sa_handler = sighandler;
+	sigaction(SIGSEGV, &act, NULL);
+	sigaction(SIGBUS, &act, NULL);
+	sigaction(SIGSEGV, &act, NULL);
+	sigaction(SIGABRT, &act, NULL);
+	/* SIGALARM is used for our timeout */
+	sigaction(SIGALRM, &act, NULL);
+
+	r = dup2(write_fds[FD_STDERR], STDERR_FILENO);
+	spa_assert_se(r != -1);
+	setlinebuf(stderr);
+	r = dup2(write_fds[FD_STDOUT], STDOUT_FILENO);
+	spa_assert_se(r != -1);
+	setlinebuf(stdout);
+
+	/* For convenience in the tests, let this be a global variable. */
+	testlog_fd = write_fds[FD_LOG];
+
+	while ((env = pw_properties_iterate(t->args.env, &state)))
+		setenv(env, pw_properties_get(t->args.env, env), 1);
+
+	/* The actual test function */
+	result = t->func(t);
+
+	for (int i = 0; i < _FD_LAST; i++)
+		fsync(write_fds[i]);
+
+	exit(result);
+}
+
+static int monitor_test_forked(struct pwtest_test *t, pid_t pid, int read_fds[_FD_LAST])
+{
+	int pidfd = -1, timerfd = -1, epollfd = -1;
+	struct epoll_event ev[10];
+	size_t nevents = 0;
+	int r;
+
+#ifdef HAVE_PIDFD_OPEN
+	pidfd = syscall(SYS_pidfd_open, pid, 0);
+#else
+	errno = ENOSYS;
+#endif
+	/* If we don't have pidfd, we use a timerfd to ping us every 20ms */
+	if (pidfd < 0 && errno == ENOSYS) {
+		pidfd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK);
+		if (pidfd == -1)
+			goto error;
+		r = timerfd_settime(pidfd, 0,
+				    &((struct itimerspec ){
+				      .it_interval.tv_nsec = 20 * 1000 * 1000,
+				      .it_value.tv_nsec = 20 * 1000 * 1000,
+				      }), NULL);
+		if (r < 0)
+			goto error;
+	}
+
+	/* Each test has an epollfd with:
+	 *   - a timerfd so we can kill() it if it hangs
+	 *   - a pidfd so we get notified when the test exits
+	 *   - a pipe for stdout and a pipe for stderr
+	 *   - a pipe for logging (the various pwtest functions)
+	 *   - a pipe for the daemon's stdout
+	 */
+	timerfd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK);
+	if (timerfd < 0)
+		goto error;
+	timerfd_settime(timerfd, 0, &((struct itimerspec ){ .it_value.tv_sec = ctx->timeout}), NULL);
+
+	epollfd = epoll_create(1);
+	if (epollfd < 0)
+		goto error;
+	ev[nevents++] = (struct epoll_event){ .events = EPOLLIN, .data.fd = pidfd };
+	ev[nevents++] = (struct epoll_event){ .events = EPOLLIN, .data.fd = read_fds[FD_STDOUT] };
+	ev[nevents++] = (struct epoll_event){ .events = EPOLLIN, .data.fd = read_fds[FD_STDERR] };
+	ev[nevents++] = (struct epoll_event){ .events = EPOLLIN, .data.fd = read_fds[FD_LOG] };
+	ev[nevents++] = (struct epoll_event){ .events = EPOLLIN, .data.fd = timerfd };
+	if (t->args.pw_daemon)
+		ev[nevents++] = (struct epoll_event){ .events = EPOLLIN, .data.fd = read_fds[FD_DAEMON] };
+
+	for (size_t i = 0; i < nevents; i++) {
+		r = epoll_ctl(epollfd, EPOLL_CTL_ADD, ev[i].data.fd, &ev[i]);
+		if (r < 0)
+			goto error;
+	}
+
+	while (true) {
+		struct epoll_event e;
+
+		r = epoll_wait(epollfd, &e, 1, (ctx->timeout * 2) * 1000);
+		if (r == 0)
+			break;
+		if (r == -1) {
+			goto error;
+		}
+
+		if (e.data.fd == pidfd) {
+			uint64_t buf;
+			int ignore SPA_UNUSED;
+			ignore = read(pidfd, &buf, sizeof(buf)); /* for timerfd fallback */
+			if (collect_child(t, pid))
+				break;
+		} else if (e.data.fd == timerfd) {
+			/* SIGALARM so we get the backtrace */
+			kill(pid, SIGALRM);
+			t->result = PWTEST_TIMEOUT;
+			waitpid(pid, NULL, 0);
+			break;
+		} else {
+			for (int i = 0; i < _FD_LAST; i++) {
+				if (e.data.fd == read_fds[i]) {
+					log_append(&t->logs[i], e.data.fd);
+				}
+
+			}
+		}
+	}
+	errno = 0;
+error:
+	r = errno;
+	close(epollfd);
+	close(timerfd);
+	close(pidfd);
+
+	return -r;
+}
+
+static void run_test(struct pwtest_context *ctx, struct pwtest_suite *c, struct pwtest_test *t)
+{
+	pid_t pid;
+	pid_t pw_daemon = 0;
+	int read_fds[_FD_LAST], write_fds[_FD_LAST];
+	int r;
+	const char *tmpdir;
+
+	if (t->result == PWTEST_SKIP) {
+		char *buf = pw_array_add(&t->logs[FD_LOG], 64);
+		spa_scnprintf(buf, 64, "pwtest: test skipped by pwtest\n");
+		return;
+	}
+
+	t->result = PWTEST_SYSTEM_ERROR;
+
+	r = init_pipes(read_fds, write_fds);
+	if (r < 0) {
+		t->sig_or_errno = r;
+		return;
+	}
+
+	set_test_env(ctx, t);
+	tmpdir = getenv("TMPDIR");
+	spa_assert_se(tmpdir != NULL);
+	r = chdir(tmpdir);
+	if (r < 0) {
+		char *buf = pw_array_add(&t->logs[FD_LOG], 256);
+		spa_scnprintf(buf, 256, "pwtest: failed to chdir to '%s'\n", tmpdir);
+		t->sig_or_errno = -errno;
+		goto error;
+	}
+
+	if (t->args.pw_daemon) {
+		pw_daemon = start_pwdaemon(t, write_fds[FD_DAEMON], write_fds[FD_LOG]);
+		if (pw_daemon < 0) {
+			errno = -pw_daemon;
+			goto error;
+		}
+	} else {
+		replace_env(t, "PIPEWIRE_REMOTE", "test-has-no-daemon");
+	}
+
+	if (ctx->no_fork) {
+		start_test_nofork(t);
+	} else {
+		pid = start_test_forked(t, read_fds, write_fds);
+		if (pid < 0) {
+			errno = -r;
+			goto error;
+		}
+		add_cleanup_pid(ctx, pid);
+
+		r = monitor_test_forked(t, pid, read_fds);
+		if (r < 0) {
+			errno = -r;
+			goto error;
+		}
+		remove_cleanup_pid(ctx, pid);
+	}
+
+	errno = 0;
+error:
+	if (errno)
+		t->sig_or_errno = -errno;
+
+	if (ctx->terminate) {
+		char *buf = pw_array_add(&t->logs[FD_LOG], 64);
+		spa_scnprintf(buf, 64, "pwtest: tests terminated by signal\n");
+		t->result = PWTEST_SYSTEM_ERROR;
+	}
+
+	for (size_t i = 0; i < SPA_N_ELEMENTS(read_fds); i++) {
+		log_append(&t->logs[i], read_fds[i]);
+	}
+
+	if (pw_daemon > 0) {
+		int status;
+
+		kill(-pw_daemon, SIGTERM);
+		remove_cleanup_pid(ctx, -pw_daemon);
+
+		/* blocking read. the other end closes when done */
+		close_pipes(write_fds);
+		fcntl(read_fds[FD_DAEMON], F_SETFL, O_CLOEXEC);
+		do {
+			log_append(&t->logs[FD_DAEMON], read_fds[FD_DAEMON]);
+		} while ((r = waitpid(pw_daemon, &status, WNOHANG)) == 0);
+
+		if (r > 0) {
+			/* write_fds are closed in the parent process, so we append directly */
+			char *buf = pw_array_add(&t->logs[FD_DAEMON], 64);
+
+			if (WIFEXITED(status)) {
+				spa_scnprintf(buf, 64, "pwtest: pipewire daemon exited with status %d\n",
+					 WEXITSTATUS(status));
+			} else if (WIFSIGNALED(status)) {
+				spa_scnprintf(buf, 64, "pwtest: pipewire daemon crashed with signal %d (SIG%s)\n",
+					WTERMSIG(status), sigabbrev_np(WTERMSIG(status)));
+			}
+		}
+	}
+
+	for (size_t i = 0; i < SPA_N_ELEMENTS(t->logs); i++) {
+		char *e = pw_array_add(&t->logs[i], 1);
+		spa_assert_se(e);
+		*e = '\0';
+	}
+
+	close_pipes(read_fds);
+	close_pipes(write_fds);
+
+	restore_env(t);
+}
+
+static inline void print_lines(FILE *fp, const char *log, const char *prefix)
+{
+	const char *state = NULL;
+	const char *s;
+	size_t len;
+
+	while (true) {
+		if ((s = pw_split_walk(log, "\n", &len, &state)) == NULL)
+			break;
+		fprintf(fp, "%s%.*s\n", prefix, (int)len, s);
+	}
+}
+
+static void log_test_result(struct pwtest_test *t)
+{
+	const struct status *s;
+	const struct status {
+		const char *status;
+		const char *color;
+	} statuses[] = {
+		{ "PASS", SPA_ANSI_BOLD_GREEN },
+		{ "FAIL", SPA_ANSI_BOLD_RED },
+		{ "SKIP", SPA_ANSI_BOLD_YELLOW },
+		{ "TIMEOUT", SPA_ANSI_BOLD_CYAN },
+		{ "ERROR", SPA_ANSI_BOLD_MAGENTA },
+	};
+
+	spa_assert_se(t->result >= PWTEST_PASS);
+	spa_assert_se(t->result <= PWTEST_SYSTEM_ERROR);
+	s = &statuses[t->result - PWTEST_PASS];
+
+	fprintf(stderr, "    status: %s%s%s\n",
+		isatty(STDERR_FILENO) ? s->color : "",
+		s->status,
+		isatty(STDERR_FILENO) ? "\x1B[0m" : "");
+
+	switch (t->result) {
+		case PWTEST_PASS:
+		case PWTEST_SKIP:
+			if (!verbose)
+				return;
+			break;
+		default:
+			break;
+	}
+
+	if (t->sig_or_errno > 0)
+		fprintf(stderr, "    signal: %d # SIG%s \n", t->sig_or_errno,
+			sigabbrev_np(t->sig_or_errno));
+	else if (t->sig_or_errno < 0)
+		fprintf(stderr, "    errno: %d # %s\n", -t->sig_or_errno,
+			strerror(-t->sig_or_errno));
+	if (t->logs[FD_LOG].size) {
+		fprintf(stderr, "    log: |\n");
+		print_lines(stderr, t->logs[FD_LOG].data, "      ");
+	}
+	if (t->logs[FD_STDOUT].size) {
+		fprintf(stderr, "    stdout: |\n");
+		print_lines(stderr, t->logs[FD_STDOUT].data, "      ");
+	}
+	if (t->logs[FD_STDERR].size) {
+		fprintf(stderr, "    stderr: |\n");
+		print_lines(stderr, t->logs[FD_STDERR].data, "      ");
+	}
+	if (t->logs[FD_DAEMON].size) {
+		fprintf(stderr, "    daemon: |\n");
+		print_lines(stderr, t->logs[FD_DAEMON].data, "      ");
+	}
+}
+
+static char* make_xdg_runtime_dir(void)
+{
+	time_t t = time(NULL);
+	struct tm *tm = localtime(&t);
+	char *dir;
+	char *tmpdir = getenv("TMPDIR");
+	char path[PATH_MAX];
+	FILE *fp;
+
+	if (!tmpdir)
+		tmpdir = "/tmp";
+
+	int r = asprintf(&dir, "%s/pwtest-%02d:%02d-XXXXXX", tmpdir, tm->tm_hour, tm->tm_min);
+	spa_assert_se((size_t)r == strlen(tmpdir) + 20); /* rough estimate */
+	spa_assert_se(mkdtemp(dir) != NULL);
+
+	/* Marker file to avoid removing a random directory during cleanup */
+	r = spa_scnprintf(path, sizeof(path), "%s/pwtest.dir", dir);
+	spa_assert_se((size_t)r == strlen(dir) + 11);
+	fp = fopen(path, "we");
+	spa_assert_se(fp);
+	fprintf(fp, "pwtest\n");
+	fclose(fp);
+
+	return dir;
+}
+
+static int run_tests(struct pwtest_context *ctx)
+{
+	int r = EXIT_SUCCESS;
+	struct pwtest_suite *c;
+	struct pwtest_test *t;
+
+	fprintf(stderr, "pwtest:\n");
+	spa_list_for_each(c, &ctx->suites, link) {
+		if (c->result != PWTEST_PASS)
+			continue;
+
+		fprintf(stderr, "- suite: \"%s\"\n", c->decl->name);
+		fprintf(stderr, "  tests:\n");
+		spa_list_for_each(t, &c->tests, link) {
+			int min = t->args.range.min,
+			    max = t->args.range.max;
+			bool have_range = min != 0 || max != 1;
+
+			for (int iteration = min; iteration < max; iteration++) {
+				if (ctx->has_iteration_filter &&
+				    ctx->iteration_filter != iteration)
+					continue;
+
+				fprintf(stderr, "  - name: \"%s\"\n", t->name);
+				if (have_range)
+					fprintf(stderr, "    iteration: %d  # %d - %d\n",
+						iteration, min, max);
+				t->iteration = iteration;
+				run_test(ctx, c, t);
+				log_test_result(t);
+
+				switch (t->result) {
+					case PWTEST_PASS:
+					case PWTEST_SKIP:
+						break;
+					default:
+						r = EXIT_FAILURE;
+						break;
+				}
+
+				if (ctx->terminate) {
+					r = EXIT_FAILURE;
+					return r;
+				}
+			}
+		}
+	}
+	return r;
+}
+
+static void list_tests(struct pwtest_context *ctx)
+{
+	struct pwtest_suite *c;
+	struct pwtest_test *t;
+
+	fprintf(stderr, "pwtest:\n");
+	spa_list_for_each(c, &ctx->suites, link) {
+		fprintf(stderr, "- suite: \"%s\"\n", c->decl->name);
+		fprintf(stderr, "  tests:\n");
+		spa_list_for_each(t, &c->tests, link) {
+			fprintf(stderr, "  - { name: \"%s\" }\n", t->name);
+		}
+	}
+}
+
+static bool is_debugger_attached(void)
+{
+	bool rc = false;
+#ifdef HAVE_LIBCAP
+	int status;
+	int pid = fork();
+
+	if (pid == -1)
+		return 0;
+
+	if (pid == 0) {
+		int ppid = getppid();
+		cap_t caps = cap_get_pid(ppid);
+		cap_flag_value_t cap_val;
+
+		if (cap_get_flag(caps, CAP_SYS_PTRACE, CAP_EFFECTIVE, &cap_val) == -1 ||
+		    cap_val != CAP_SET)
+			_exit(false);
+
+		if (ptrace(PTRACE_ATTACH, ppid, NULL, 0) == 0) {
+			waitpid(ppid, NULL, 0);
+			ptrace(PTRACE_CONT, ppid, NULL, 0);
+			ptrace(PTRACE_DETACH, ppid, NULL, 0);
+			rc = false;
+		} else {
+			rc = true;
+		}
+		_exit(rc);
+	} else {
+		waitpid(pid, &status, 0);
+		rc = WEXITSTATUS(status);
+	}
+
+#endif
+	return !!rc;
+}
+
+static void usage(FILE *fp, const char *progname)
+{
+	fprintf(fp, "Usage: %s [OPTIONS]\n"
+		"  -h, --help		Show this help\n"
+		"  --verbose		Verbose output\n"
+		"  --list		List all available suites and tests\n"
+		"  --timeout=N		Set the test timeout to N seconds (default: 15)\n"
+		"  --filter-test=glob	Run only tests matching the given glob\n"
+		"  --filter-suites=glob	Run only suites matching the given glob\n"
+		"  --filter-iteration=N	Run only iteration N\n"
+		"  --no-fork		Do not fork for the test (see note below)\n"
+		"\n"
+		"Using --no-fork allows for easy debugging of tests but should only be used.\n"
+		"used with --filter-test. A test that modifies the process state will affect\n"
+		"subsequent tests and invalidate test results.\n",
+		progname);
+}
+
+static void sigterm_handler(int signo)
+{
+	terminate_cleanup_pids(ctx);
+	ctx->terminate = true;
+	if (ctx->no_fork) {
+		signal(SIGTERM, SIG_DFL);
+		signal(SIGINT, SIG_DFL);
+		raise(signo);
+	}
+}
+
+int main(int argc, char **argv)
+{
+	int r = EXIT_SUCCESS;
+	enum {
+		OPT_TIMEOUT = 10,
+		OPT_LIST,
+		OPT_VERBOSE,
+		OPT_FILTER_TEST,
+		OPT_FILTER_SUITE,
+		OPT_FILTER_ITERATION,
+		OPT_NOFORK,
+	};
+	static const struct option opts[] = {
+		{ "help",		no_argument,		0, 'h' },
+		{ "timeout",		required_argument,	0, OPT_TIMEOUT },
+		{ "list",		no_argument,		0, OPT_LIST },
+		{ "filter-test",	required_argument,	0, OPT_FILTER_TEST },
+		{ "filter-suite",	required_argument,	0, OPT_FILTER_SUITE },
+		{ "filter-iteration",	required_argument,	0, OPT_FILTER_ITERATION },
+		{ "list",		no_argument,		0, OPT_LIST },
+		{ "verbose",		no_argument,		0, OPT_VERBOSE },
+		{ "no-fork",		no_argument,		0, OPT_NOFORK },
+		{ NULL },
+	};
+	struct pwtest_context test_ctx = {
+		.suites = SPA_LIST_INIT(&test_ctx.suites),
+		.timeout = 15,
+		.has_iteration_filter = false,
+	};
+	enum {
+		MODE_TEST,
+		MODE_LIST,
+	} mode = MODE_TEST;
+	const char *suite_filter = NULL;
+
+	spa_list_init(&test_ctx.cleanup_pids);
+
+	ctx = &test_ctx;
+
+	while (1) {
+		int c;
+		int option_index = 0;
+
+		c = getopt_long(argc, argv, "h", opts, &option_index);
+		if (c == -1)
+			break;
+		switch(c) {
+		case 'h':
+			usage(stdout, argv[0]);
+			exit(EXIT_SUCCESS);
+		case OPT_TIMEOUT:
+			ctx->timeout = atoi(optarg);
+			break;
+		case OPT_LIST:
+			mode = MODE_LIST;
+			break;
+		case OPT_VERBOSE:
+			verbose = true;
+			break;
+		case OPT_FILTER_TEST:
+			ctx->test_filter = optarg;
+			break;
+		case OPT_FILTER_SUITE:
+			suite_filter= optarg;
+			break;
+		case OPT_FILTER_ITERATION:
+			ctx->has_iteration_filter = spa_atoi32(optarg, &ctx->iteration_filter, 10);
+			break;
+		case OPT_NOFORK:
+			ctx->no_fork = true;
+			break;
+		default:
+			usage(stderr, argv[0]);
+			exit(EXIT_FAILURE);
+		}
+	}
+
+	if (RUNNING_ON_VALGRIND || is_debugger_attached())
+		ctx->no_fork = true;
+
+	find_suites(ctx, suite_filter);
+	add_tests(ctx);
+
+	if (getenv("TMPDIR") == NULL)
+		setenv("TMPDIR", "/tmp", 1);
+
+	ctx->xdg_dir = make_xdg_runtime_dir();
+
+	switch (mode) {
+	case MODE_LIST:
+		list_tests(ctx);
+		break;
+	case MODE_TEST:
+		setrlimit(RLIMIT_CORE, &((struct rlimit){0, 0}));
+		signal(SIGTERM, sigterm_handler);
+		signal(SIGINT, sigterm_handler);
+		r = run_tests(ctx);
+		break;
+	}
+
+	cleanup(ctx);
+
+	return r;
+}
diff --git a/test/pwtest.h b/test/pwtest.h
new file mode 100644
index 0000000..6d3070b
--- /dev/null
+++ b/test/pwtest.h
@@ -0,0 +1,577 @@
+/* PipeWire
+ *
+ * Copyright © 2021 Red Hat, Inc.
+ *
+ * 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 "config.h"
+
+#ifndef PWTEST_H
+#define PWTEST_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <limits.h>
+#include <stddef.h>
+#include <stdbool.h>
+#include <math.h>
+
+#include <spa/utils/string.h>
+#include <spa/utils/dict.h>
+#include "spa/support/plugin.h"
+
+/**
+ * \defgroup pwtest Test Suite
+ * \brief `pwtest` is a test runner framework for PipeWire.
+ *
+ * It's modelled after other
+ * test suites like [check](https://libcheck.github.io/check/)
+ * and draws a lot of inspiration from the [libinput test
+ * suite](https://wayland.freedesktop.org/libinput/doc/latest/).
+ *
+ * `pwtest` captures logs from the tests (and the pipewire daemon, if
+ * applicable) and collects the output into YAML files printed to `stderr`.
+ *
+ * ## Tests
+ *
+ * A `pwtest` test is declared with the `PWTEST()` macro and must return one of
+ * the `pwtest` status codes. Those codes are:
+ * - \ref PWTEST_PASS for a successful test
+ * - \ref PWTEST_FAIL for a test case failure. Usually you should not return this
+ *   value but rely on the `pwtest` macros to handle this case.
+ * - \ref PWTEST_SKIP to skip the current test
+ * - \ref PWTEST_SYSTEM_ERROR in case of an error that would cause the test to not run properly. This is not a test case failure but some required precondition not being met.
+ *
+ * ```c
+ * #include "pwtest.h"
+ *
+ * PWTEST(some_test)
+ * {
+ *	int var = 10;
+ *	const char *str = "foo";
+ *
+ *	if (access("/", R_OK))
+ *	    pwtest_error_with_message("Oh dear, no root directory?");
+ *
+ *	if (today_is_monday)
+ *	     return PWTEST_SKIP;
+ *
+ *	pwtest_int_lt(var, 20);
+ *	pwtest_ptr_notnull(&var);
+ *	pwtest_str_ne(str, "bar");
+ *
+ *	return PWTEST_PASS;
+ * }
+ * ...
+ * ```
+ *
+ * `pwtest` provides comparison macros for most basic data types with the `lt`,
+ * `le`, `eq`, `gt`, `ge` suffixes (`<, <=, ==, >, >=`). Tests usually should not
+ * return `PWTEST_FAIL` directly, use the `pwtest_fail()` macros if .
+ *
+ * By default, a test runs in a forked process, any changes to the
+ * process'environment, etc. are discarded in the next test.
+ *
+ * ## Suites
+ *
+ * Tests are grouped into suites and declared with the PWTEST_SUITE() macro.
+ * Each test must be added with the required arguments, it is acceptable to
+ * add the same test multiple times with different arguments.
+ *
+ * ```c
+ * ...
+ * PWTEST_SUITE(misc)
+ * {
+ *	if (today_is_monday)
+ *	     return PWTEST_SKIP;
+ *
+ *	// simple test
+ *	pwtest_add(some_test, PWTEST_NOARG);
+ *	// starts with its own pipewire daemon instance
+ *	pwtest_add(some_test, PWTEST_ARG_DAEMON);
+ *
+ *	return PWTEST_SUCCESS;
+ * }
+ * ```
+ * For a list of potential arguments, see \ref pwtest_arg and the
+ * `test-examples.c` file in the source directory.
+ *
+ * Suites are auto-discovered, they do not have to be manually added to a test run.
+ *
+ * ## Running tests
+ *
+ * The `pwtest` framework is built into each test binary, so just execute the
+ * matching binary. See the `--help` output for the full argument list.
+ *
+ * The most useful arguments when running the test suite:
+ * - `--verbose` to enable logs even when tests pass or are skipped
+ * - `--filter-test=glob`, `--filter-suite=glob` uses an `fnmatch()` glob to limit which tests or suites are run
+ * - `--no-fork` - see "Debugging test-case failures"
+ *
+ * ## Debugging test-case failures
+ *
+ * To debug a single test, disable forking and run the test through gdb:
+ *
+ * ```
+ * $ gdb path/to/test
+ * (gdb) break test_function_name
+ * Breakpoint 1 at 0xfffffffffffff: file ../test/test-file.c, line 123
+ * (gdb) r --no-fork --filter-test=test_function_name
+ * ```
+ * Disabling forking makes it easy to debug but should always be used with
+ * `--filter-test`. Any test that modifies its environment will affect
+ * subsequent tests and may invalidate the test results.
+ *
+ * Where a test has multiple iterations, use `--filter-iteration` to only run
+ * one single iteration.
+ */
+
+/**
+ * \addtogroup pwtest
+ * \{
+ */
+
+
+/** \struct pwtest_context */
+struct pwtest_context;
+/** \struct pwtest_suite */
+struct pwtest_suite;
+/** \struct pwtest_test */
+struct pwtest_test;
+
+#include "pwtest-implementation.h"
+
+/**
+ * Result returned from tests or suites.
+ */
+enum pwtest_result {
+	PWTEST_PASS = 75,		/**< test successful */
+	PWTEST_FAIL = 76,		/**< test failed. Should not be returned directly,
+					     Use the pwtest_ macros instead */
+	PWTEST_SKIP = 77,		/**< test was skipped */
+	PWTEST_TIMEOUT = 78,		/**< test aborted after timeout */
+	PWTEST_SYSTEM_ERROR = 79,	/**< unrelated error occurred */
+};
+
+/**
+ * If the test was added with a range (see \ref PWTEST_ARG_RANGE), this
+ * function returns the current iteration within that range. Otherwise, this
+ * function returns zero.
+ */
+int pwtest_get_iteration(struct pwtest_test *t);
+
+/**
+ * If the test had properties set (see \ref PWTEST_ARG_PROP), this function
+ * returns the \ref pw_properties. Otherwise, this function returns NULL.
+ */
+struct pw_properties *pwtest_get_props(struct pwtest_test *t);
+
+struct pwtest_context *pwtest_get_context(struct pwtest_test *t);
+
+/** Fail the current test */
+#define pwtest_fail() \
+	_pwtest_fail_condition(PWTEST_FAIL, __FILE__, __LINE__, __func__, "aborting", "")
+
+/** Same as above but more expressive in the code */
+#define pwtest_fail_if_reached() \
+	_pwtest_fail_condition(PWTEST_FAIL, __FILE__, __LINE__, __func__, "This line is supposed to be unreachable", "")
+
+/** Fail the current test with the given message */
+#define pwtest_fail_with_msg(...) \
+	_pwtest_fail_condition(PWTEST_FAIL, __FILE__, __LINE__, __func__, \
+			       "aborting", __VA_ARGS__)
+
+/** Error out of the current test with the given message */
+#define pwtest_error_with_msg(...) \
+	_pwtest_fail_condition(PWTEST_SYSTEM_ERROR, __FILE__, __LINE__, __func__, \
+			       "error", __VA_ARGS__)
+
+/** Assert r is not -1 and if it is, print the errno */
+#define pwtest_errno_ok(r_) \
+	pwtest_errno_check(r_, 0);
+
+/** Assert r is -1 and the errno is the given one */
+#define pwtest_errno(r_, errno_) \
+	pwtest_errno_check(r_, errno_);
+
+/** Assert r is not < 0 and if it is assume it's a negative errno */
+#define pwtest_neg_errno_ok(r_) \
+	pwtest_neg_errno_check(r_, 0);
+
+/** Assert r is < 0 and the given negative errno */
+#define pwtest_neg_errno(r_, errno_) \
+	pwtest_neg_errno_check(r_, errno_);
+
+/** Assert boolean (a == b) */
+#define pwtest_bool_eq(a_, b_) \
+	pwtest_comparison_bool_(a_, ==, b_)
+
+/** Assert boolean (a != b) */
+#define pwtest_bool_ne(a_, b_) \
+	pwtest_comparison_bool_(a_, !=, b_)
+
+/** Assert cond to be true. Convenience wrapper for readability */
+#define pwtest_bool_true(cond_) \
+	pwtest_comparison_bool_(cond_, ==, true)
+
+/** Assert cond to be false. Convenience wrapper for readability */
+#define pwtest_bool_false(cond_) \
+	pwtest_comparison_bool_(cond_, ==, false)
+
+/** Assert a == b  */
+#define pwtest_int_eq(a_, b_) \
+	pwtest_comparison_int_(a_, ==, b_)
+
+/** Assert a != b  */
+#define pwtest_int_ne(a_, b_) \
+	pwtest_comparison_int_(a_, !=, b_)
+
+/** Assert a < b  */
+#define pwtest_int_lt(a_, b_) \
+	pwtest_comparison_int_(a_, <, b_)
+
+/** Assert a <= b  */
+#define pwtest_int_le(a_, b_) \
+	pwtest_comparison_int_(a_, <=, b_)
+
+/** Assert a >= b  */
+#define pwtest_int_ge(a_, b_) \
+	pwtest_comparison_int_(a_, >=, b_)
+
+/** Assert a > b  */
+#define pwtest_int_gt(a_, b_) \
+	pwtest_comparison_int_(a_, >, b_)
+
+/** Assert ptr1 == ptr2  */
+#define pwtest_ptr_eq(a_, b_) \
+	pwtest_comparison_ptr_(a_, ==, b_)
+
+/** Assert ptr1 != ptr2  */
+#define pwtest_ptr_ne(a_, b_) \
+	pwtest_comparison_ptr_(a_, !=, b_)
+
+/** Assert ptr == NULL  */
+#define pwtest_ptr_null(a_) \
+	pwtest_comparison_ptr_(a_, ==, NULL)
+
+/** Assert ptr != NULL  */
+#define pwtest_ptr_notnull(a_) \
+	pwtest_comparison_ptr_(a_, !=, NULL)
+
+/** Assert a == b for a (hardcoded) epsilon */
+#define pwtest_double_eq(a_, b_)\
+	pwtest_comparison_double_((a_), ==, (b_))
+
+/** Assert a != b for a (hardcoded) epsilon */
+#define pwtest_double_ne(a_, b_)\
+	pwtest_comparison_double_((a_), !=, (b_))
+
+/** Assert a < b for a (hardcoded) epsilon */
+#define pwtest_double_lt(a_, b_)\
+	pwtest_comparison_double_((a_), <, (b_))
+
+/** Assert a <= b for a (hardcoded) epsilon */
+#define pwtest_double_le(a_, b_)\
+	pwtest_comparison_double_((a_), <=, (b_))
+
+/** Assert a >= b for a (hardcoded) epsilon */
+#define pwtest_double_ge(a_, b_)\
+	pwtest_comparison_double_((a_), >=, (b_))
+
+/** Assert a > b for a (hardcoded) epsilon */
+#define pwtest_double_gt(a_, b_)\
+	pwtest_comparison_double_((a_), >, (b_))
+
+#define pwtest_int(a_, op_, b_) \
+	pwtest_comparison_int_(a_, op_, b_)
+
+
+/** Assert str1 is equal to str2 */
+#define pwtest_str_eq(a_, b_) \
+	do { \
+		const char *_a = a_; \
+		const char *_b = b_; \
+		if (!spa_streq(_a, _b)) \
+			_pwtest_fail_comparison_str(__FILE__, __LINE__, __func__, \
+						     #a_ " equals " #b_, _a, _b); \
+	} while(0)
+
+/** Assert str1 is equal to str2 for l characters */
+#define pwtest_str_eq_n(a_, b_, l_) \
+	do { \
+		const char *_a = a_; \
+		const char *_b = b_; \
+		if (!spa_strneq(_a, _b, l_)) \
+			_pwtest_fail_comparison_str(__FILE__, __LINE__, __func__, \
+						     #a_ " equals " #b_ ", len: " #l_, _a, _b); \
+	} while(0)
+
+/** Assert str1 is not equal to str2 */
+#define pwtest_str_ne(a_, b_) \
+	do { \
+		const char *_a = a_; \
+		const char *_b = b_; \
+		if (spa_streq(_a, _b)) \
+			_pwtest_fail_comparison_str(__FILE__, __LINE__, __func__, \
+						    #a_ " not equal to " #b_, _a, _b); \
+	} while(0)
+
+/** Assert str1 is not equal to str2 for l characters */
+#define pwtest_str_ne_n(a_, b_, l_) \
+	do { \
+		__typeof__(a_) _a = a_; \
+		__typeof__(b_) _b = b_; \
+		if (spa_strneq(_a, _b, l_)) \
+			_pwtest_fail_comparison_str(__FILE__, __LINE__, __func__, \
+						    #a_ " not equal to " #b_ ", len: " #l_, _a, _b); \
+	} while(0)
+
+
+/** Assert haystack contains needle */
+#define pwtest_str_contains(haystack_, needle_) \
+	do { \
+		const char *_h = haystack_; \
+		const char *_n = needle_; \
+		if (!strstr(_h, _n)) \
+			_pwtest_fail_comparison_str(__FILE__, __LINE__, __func__, \
+						     #haystack_ " contains " #needle_, _h, _n); \
+	} while(0)
+
+
+/* Needs to be a #define NULL for SPA_SENTINEL */
+enum pwtest_arg {
+	PWTEST_NOARG = 0,
+	/**
+	 * The next argument is an int specifying the numerical signal number.
+	 * The test is expected to raise that signal. The test fails if none
+	 * or any other signal is raised.
+	 *
+	 * Example:
+	 * ```c
+	 *    pwtest_add(mytest, PWTEST_ARG_SIGNAL, SIGABRT);
+	 * ```
+	 */
+	PWTEST_ARG_SIGNAL,
+	/**
+	 * The next two int arguments are the minimum (inclusive) and
+	 * maximum (exclusive) range for this test.
+	 *
+	 * Example:
+	 * ```c
+	 *    pwtest_add(mytest, PWTEST_ARG_RANGE, -50, 50);
+	 * ```
+	 * Use pwtest_get_iteration() in the test function to obtain the current iteration.
+	 */
+	PWTEST_ARG_RANGE,
+	/**
+	 * The next two const char * arguments are the key and value
+	 * for a property entry. This argument may be specified multiple times
+	 * to add multiple properties.
+	 *
+	 * Use pwtest_get_props() to get the properties within the test function.
+	 *
+	 * Example:
+	 * ```c
+	 *    pwtest_add(mytest,
+	 *               PWTEST_ARG_PROP, "key1", "value1",
+	 *               PWTEST_ARG_PROP, "key2", "value2");
+	 * ```
+	 */
+	PWTEST_ARG_PROP,
+	/**
+	 * The next two const char * arguments are the key and value
+	 * for the environment variable to be set in the test. This argument
+	 * may be specified multiple times to add multiple environment
+	 * variables.
+	 *
+	 * Example:
+	 * ```c
+	 *    pwtest_add(mytest,
+	 *               PWTEST_ARG_ENV, "env1", "value1",
+	 *               PWTEST_ARG_ENV, "env2", "value2");
+	 * ```
+	 *
+	 * These environment variables are only set for the test itself, a
+	 * a pipewire daemon started with \ref PWTEST_ARG_DAEMON does not share
+	 * those variables.
+	 *
+	 */
+	PWTEST_ARG_ENV,
+	/**
+	 * Takes no extra arguments. If provided, the test case will start a
+	 * pipewire daemon and stop the daemon when finished.
+	 *
+	 * The `PIPEWIRE_REMOTE` environment variable will be set in the
+	 * test to point to this daemon.
+	 *
+	 * Example:
+	 * ```c
+	 *    pwtest_add(mytest, PWTEST_ARG_DAEMON);
+	 * ```
+	 *
+	 * Environment variables specified with \ref PWTEST_ARG_ENV are
+	 * **not** available to the daemon, only to the test itself.
+	 */
+	PWTEST_ARG_DAEMON,
+};
+/**
+ * Add function \a func_ to the current test suite.
+ *
+ * This macro should be used within PWTEST_SUITE() to register the test in that suite, for example:
+ *
+ * ```c
+ * PWTEST_SUITE(mysuite)
+ * {
+ *   pwtest_add(test1, PWTEST_NOARG);
+ *   pwtest_add(test2, PWTEST_ARG_DAEMON);
+ *   pwtest_add(test3, PWTEST_ARG_RANGE, 0, 100, PWTEST_ARG_DAEMON);
+ * }
+ *
+ * ```
+ *
+ * If the test matches the given filters and the suite is executed, the test
+ * will be executed with the parameters given to pwtest_add().
+ *
+ * Arguments take a argument-dependent number of extra parameters, see
+ * see the \ref pwtest_arg documentation for details.
+ */
+#define pwtest_add(func_, ...) \
+	_pwtest_add(ctx, suite, #func_, func_, __VA_ARGS__, NULL)
+
+
+/**
+ * Declare a test case. To execute the test, add the test case name with pwtest_add().
+ *
+ * This macro expands so each test has a struct \ref pwtest_test variable
+ * named `current_test` available.
+ *
+ * ```c
+ * PWTEST(mytest)
+ * {
+ *   struct pwtest_test *t = current_test;
+ *
+ *   ... do stuff ...
+ *
+ *   return PWTEST_PASS;
+ * }
+ *
+ * PWTEST_SUITE(mysuite)
+ * {
+ *    pwtest_add(mytest);
+ *
+ *    return PWTEST_PASS;
+ * }
+ * ```
+ */
+#define PWTEST(tname) \
+	static enum pwtest_result tname(struct pwtest_test *current_test)
+
+/**
+ * Initialize a test suite. A test suite is a group of related
+ * tests that filters and other conditions may apply to.
+ *
+ * Test suites are automatically discovered at build-time.
+ */
+#define PWTEST_SUITE(cname) \
+	static enum pwtest_result (cname##__setup)(struct pwtest_context *ctx, struct pwtest_suite *suite); \
+	__attribute__((used)) \
+	__attribute__((retain)) \
+	__attribute__((section("pwtest_suite_section"))) \
+	__attribute__((aligned(__alignof__(struct pwtest_suite_decl)))) \
+	static const struct pwtest_suite_decl _test_suite = { \
+	   .name = #cname, \
+	   .setup = cname##__setup, \
+	}; \
+	static enum pwtest_result (cname##__setup)(struct pwtest_context *ctx, struct pwtest_suite *suite)
+
+struct pwtest_spa_plugin {
+#define PWTEST_PLUGIN_MAX 32
+	size_t nsupport;
+	struct spa_support support[PWTEST_PLUGIN_MAX];
+
+	size_t ndlls;
+	void *dlls[PWTEST_PLUGIN_MAX];
+
+	size_t nhandles;
+	struct spa_handle *handles[PWTEST_PLUGIN_MAX];
+};
+
+struct pwtest_spa_plugin* pwtest_spa_plugin_new(void);
+void pwtest_spa_plugin_destroy(struct pwtest_spa_plugin *plugin);
+
+/**
+ * Identical to pwtest_spa_plugin_try_load_interface() but returns the
+ * interface and fails if the interface is NULL.
+ */
+void*
+pwtest_spa_plugin_load_interface(struct pwtest_spa_plugin *plugin,
+				 const char *libname,
+				 const char *factory_name,
+				 const char *interface_name,
+				 const struct spa_dict *info);
+
+/**
+ * Load \a interface_name from the factory in \a libname.
+ * If successful, the interface is returned and added to \a plugin's
+ * support items, i.e. subsequent loads of an interface will be able to
+ * make use of previously loaded ones.
+ *
+ * \return 0 on success or a negative errno on error
+ * \retval -ENOENT \a libname does not exist
+ * \retval -EINVAL \a factory_name does not exist in \a libname
+ * \retval -ENOSYS \a interface_name does not exist in \a factory_name
+ */
+int
+pwtest_spa_plugin_try_load_interface(struct pwtest_spa_plugin *plugin,
+				     void **iface_return,
+				     const char *libname,
+				     const char *factory_name,
+				     const char *interface_name,
+				     const struct spa_dict *info);
+
+
+
+/**
+ * Create a temporary file and copy its full path to \a path. Fails the test
+ * with \ref PWTEST_SYSTEM_ERROR on error.
+ *
+ * This file does not need to be removed by the test, the pwtest framework
+ * will take care of it on exit.
+ */
+void pwtest_mkstemp(char path[PATH_MAX]);
+
+/**
+ * Run a command and wait for it to return.
+ */
+int pwtest_spawn(const char *file, char *const argv[]);
+
+
+/**
+ * \}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* PWTEST_H */
diff --git a/test/test-array.c b/test/test-array.c
new file mode 100644
index 0000000..1d9ea24
--- /dev/null
+++ b/test/test-array.c
@@ -0,0 +1,146 @@
+/* PipeWire
+ *
+ * Copyright © 2019 Wim Taymans
+ *
+ * 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 "config.h"
+
+#include "pwtest.h"
+#include "pipewire/array.h"
+
+PWTEST(array_test_abi)
+{
+	/* array */
+#if defined(__x86_64__) && defined(__LP64__)
+	pwtest_int_eq(sizeof(struct pw_array), 32U);
+	return PWTEST_PASS;
+#else
+	fprintf(stderr, "Unknown arch: pw_array is size %zd\n", sizeof(struct pw_array));
+	return PWTEST_SKIP;
+#endif
+}
+
+PWTEST(array_test)
+{
+	struct pw_array arr;
+	uint32_t *ptr;
+	uint32_t vals[] = { 0, 100, 0x8a, 0 };
+	size_t i;
+
+	pw_array_init(&arr, 64);
+	pwtest_int_eq(SPA_N_ELEMENTS(vals), 4U);
+
+	pwtest_int_eq(pw_array_get_len(&arr, uint32_t), 0U);
+	pwtest_bool_false(pw_array_check_index(&arr, 0, uint32_t));
+	pwtest_ptr_eq(pw_array_first(&arr), pw_array_end(&arr));
+	pw_array_for_each(ptr, &arr)
+		pwtest_fail_if_reached();
+
+	for (i = 0; i < 4; i++) {
+		ptr = (uint32_t*)pw_array_add(&arr, sizeof(uint32_t));
+		*ptr = vals[i];
+	}
+
+	pwtest_int_eq(pw_array_get_len(&arr, uint32_t), 4U);
+	pwtest_bool_true(pw_array_check_index(&arr, 2, uint32_t));
+	pwtest_bool_true(pw_array_check_index(&arr, 3, uint32_t));
+	pwtest_bool_false(pw_array_check_index(&arr, 4, uint32_t));
+
+	i = 0;
+	pw_array_for_each(ptr, &arr) {
+		pwtest_int_eq(*ptr, vals[i++]);
+	}
+
+	/* remove second */
+	ptr = pw_array_get_unchecked(&arr, 2, uint32_t);
+	pwtest_ptr_notnull(ptr);
+	pw_array_remove(&arr, ptr);
+	pwtest_int_eq(pw_array_get_len(&arr, uint32_t), 3U);
+	pwtest_bool_false(pw_array_check_index(&arr, 3, uint32_t));
+	ptr = pw_array_get_unchecked(&arr, 2, uint32_t);
+	pwtest_ptr_notnull(ptr);
+	pwtest_int_eq(*ptr, vals[3]);
+
+	/* remove first */
+	ptr = pw_array_get_unchecked(&arr, 0, uint32_t);
+	pwtest_ptr_notnull(ptr);
+	pw_array_remove(&arr, ptr);
+	pwtest_int_eq(pw_array_get_len(&arr, uint32_t), 2U);
+	ptr = pw_array_get_unchecked(&arr, 0, uint32_t);
+	pwtest_ptr_notnull(ptr);
+	pwtest_int_eq(*ptr, vals[1]);
+
+	/* iterate */
+	ptr = (uint32_t*)pw_array_first(&arr);
+	pwtest_bool_true(pw_array_check(&arr, ptr));
+	pwtest_int_eq(*ptr, vals[1]);
+	ptr++;
+	pwtest_bool_true(pw_array_check(&arr, ptr));
+	pwtest_int_eq(*ptr, vals[3]);
+	ptr++;
+	pwtest_bool_false(pw_array_check(&arr, ptr));
+
+	pw_array_reset(&arr);
+	pwtest_int_eq(pw_array_get_len(&arr, uint32_t), 0U);
+
+	pw_array_clear(&arr);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(array_clear)
+{
+	struct pw_array arr;
+	uint32_t *ptr;
+	uint32_t vals[] = { 0, 100, 0x8a, 0 };
+	size_t i;
+
+	pw_array_init(&arr, 64);
+
+	for (i = 0; i < 4; i++) {
+		ptr = (uint32_t*)pw_array_add(&arr, sizeof(uint32_t));
+		*ptr = vals[i];
+	}
+	pwtest_int_eq(pw_array_get_len(&arr, uint32_t), 4U);
+	pw_array_clear(&arr);
+	pwtest_int_eq(pw_array_get_len(&arr, uint32_t), 0U);
+
+	for (i = 0; i < 4; i++) {
+		ptr = (uint32_t*)pw_array_add(&arr, sizeof(uint32_t));
+		*ptr = vals[i];
+	}
+	pwtest_int_eq(pw_array_get_len(&arr, uint32_t), 4U);
+	pw_array_clear(&arr);
+	pwtest_int_eq(pw_array_get_len(&arr, uint32_t), 0U);
+
+	return PWTEST_PASS;
+}
+
+PWTEST_SUITE(pw_array)
+{
+	pwtest_add(array_test_abi, PWTEST_NOARG);
+	pwtest_add(array_test, PWTEST_NOARG);
+	pwtest_add(array_clear, PWTEST_NOARG);
+
+	return PWTEST_PASS;
+}
diff --git a/test/test-client.c b/test/test-client.c
new file mode 100644
index 0000000..f912dc9
--- /dev/null
+++ b/test/test-client.c
@@ -0,0 +1,70 @@
+/* PipeWire
+ *
+ * Copyright © 2019 Wim Taymans
+ *
+ * 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 "pwtest.h"
+
+#include <pipewire/pipewire.h>
+#include <pipewire/impl-client.h>
+
+#define TEST_FUNC(a,b,func)	\
+do {				\
+	a.func = b.func;	\
+	pwtest_ptr_eq(SPA_PTRDIFF(&a.func, &a), SPA_PTRDIFF(&b.func, &b)); \
+} while(0)
+
+PWTEST(client_abi)
+{
+	static const struct {
+		uint32_t version;
+		void (*destroy) (void *data);
+		void (*free) (void *data);
+		void (*initialized) (void *data);
+		void (*info_changed) (void *data, const struct pw_client_info *info);
+		void (*resource_added) (void *data, struct pw_resource *resource);
+		void (*resource_removed) (void *data, struct pw_resource *resource);
+		void (*busy_changed) (void *data, bool busy);
+	} test = { PW_VERSION_IMPL_CLIENT_EVENTS, NULL };
+
+	struct pw_impl_client_events ev;
+
+	TEST_FUNC(ev, test, destroy);
+	TEST_FUNC(ev, test, free);
+	TEST_FUNC(ev, test, initialized);
+	TEST_FUNC(ev, test, info_changed);
+	TEST_FUNC(ev, test, resource_added);
+	TEST_FUNC(ev, test, resource_removed);
+	TEST_FUNC(ev, test, busy_changed);
+
+	pwtest_int_eq(PW_VERSION_IMPL_CLIENT_EVENTS, 0);
+	pwtest_int_eq(sizeof(ev), sizeof(test));
+
+	return PWTEST_PASS;
+}
+
+PWTEST_SUITE(client)
+{
+	pwtest_add(client_abi, PWTEST_NOARG);
+
+	return PWTEST_PASS;
+}
diff --git a/test/test-config.c b/test/test-config.c
new file mode 100644
index 0000000..9ebbc26
--- /dev/null
+++ b/test/test-config.c
@@ -0,0 +1,102 @@
+/* PipeWire
+ *
+ * Copyright © 2021 Red Hat, Inc.
+ *
+ * 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 "pwtest.h"
+
+#include <pipewire/conf.h>
+
+PWTEST(config_load_abspath)
+{
+	char path[PATH_MAX];
+	int r;
+	FILE *fp;
+	struct pw_properties *props;
+	char *basename;
+
+	pwtest_mkstemp(path);
+	fp = fopen(path, "we");
+	fputs("data = x", fp);
+	fclose(fp);
+
+	/* Load with NULL prefix and abs path */
+	props = pw_properties_new("ignore", "me", NULL);
+	r = pw_conf_load_conf(NULL, path, props);
+	pwtest_neg_errno_ok(r);
+	pwtest_str_eq(pw_properties_get(props, "data"), "x");
+	pw_properties_free(props);
+
+#if 0
+	/* Load with non-NULL abs prefix and abs path */
+	props = pw_properties_new("ignore", "me", NULL);
+	r = pw_conf_load_conf("/dummy", path, props);
+	pwtest_neg_errno_ok(r);
+	pwtest_str_eq(pw_properties_get(props, "data"), "x");
+	pw_properties_free(props);
+
+	/* Load with non-NULL relative prefix and abs path */
+	props = pw_properties_new("ignore", "me", NULL);
+	r = pw_conf_load_conf("dummy", path, props);
+	pwtest_neg_errno_ok(r);
+	pwtest_str_eq(pw_properties_get(props, "data"), "x");
+	pw_properties_free(props);
+#endif
+
+	/* Load with non-NULL abs prefix and relative path */
+	basename = rindex(path, '/'); /* basename(3) and dirname(3) are terrible */
+	pwtest_ptr_notnull(basename);
+	*basename = '\0';
+	basename++;
+
+	props = pw_properties_new("ignore", "me", NULL);
+	r = pw_conf_load_conf(path, basename, props);
+	pwtest_neg_errno_ok(r);
+	pwtest_str_eq(pw_properties_get(props, "data"), "x");
+	pw_properties_free(props);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(config_load_nullname)
+{
+	struct pw_properties *props = pw_properties_new("ignore", "me", NULL);
+	int r;
+
+	r = pw_conf_load_conf(NULL, NULL, props);
+	pwtest_neg_errno(r, -EINVAL);
+
+	r = pw_conf_load_conf("/dummy", NULL, props);
+	pwtest_neg_errno(r, -EINVAL);
+
+	pw_properties_free(props);
+
+	return PWTEST_PASS;
+}
+
+PWTEST_SUITE(context)
+{
+	pwtest_add(config_load_abspath, PWTEST_NOARG);
+	pwtest_add(config_load_nullname, PWTEST_NOARG);
+
+	return PWTEST_PASS;
+}
diff --git a/test/test-context.c b/test/test-context.c
new file mode 100644
index 0000000..3625d35
--- /dev/null
+++ b/test/test-context.c
@@ -0,0 +1,277 @@
+/* PipeWire
+ *
+ * Copyright © 2019 Wim Taymans
+ *
+ * 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 "pwtest.h"
+
+#include <spa/utils/string.h>
+#include <spa/support/dbus.h>
+#include <spa/support/cpu.h>
+
+#include <pipewire/pipewire.h>
+#include <pipewire/global.h>
+
+#define TEST_FUNC(a,b,func)	\
+do {				\
+	a.func = b.func;	\
+	pwtest_ptr_eq(SPA_PTRDIFF(&a.func, &a), SPA_PTRDIFF(&b.func, &b)); \
+} while(0)
+
+PWTEST(context_abi)
+{
+	struct pw_context_events ev;
+	struct {
+		uint32_t version;
+		void (*destroy) (void *data);
+		void (*free) (void *data);
+		void (*check_access) (void *data, struct pw_impl_client *client);
+		void (*global_added) (void *data, struct pw_global *global);
+		void (*global_removed) (void *data, struct pw_global *global);
+	} test = { PW_VERSION_CONTEXT_EVENTS, NULL };
+
+	pw_init(0, NULL);
+
+	TEST_FUNC(ev, test, destroy);
+	TEST_FUNC(ev, test, free);
+	TEST_FUNC(ev, test, check_access);
+	TEST_FUNC(ev, test, global_added);
+	TEST_FUNC(ev, test, global_removed);
+
+	pwtest_int_eq(PW_VERSION_CONTEXT_EVENTS, 0);
+	pwtest_int_eq(sizeof(ev), sizeof(test));
+
+	pw_deinit();
+
+	return PWTEST_PASS;
+}
+
+static void context_destroy_error(void *data)
+{
+	pwtest_fail_if_reached();
+}
+static void context_free_error(void *data)
+{
+	pwtest_fail_if_reached();
+}
+static void context_check_access_error(void *data, struct pw_impl_client *client)
+{
+	pwtest_fail_if_reached();
+}
+static void context_global_added_error(void *data, struct pw_global *global)
+{
+	pwtest_fail_if_reached();
+}
+static void context_global_removed_error(void *data, struct pw_global *global)
+{
+	pwtest_fail_if_reached();
+}
+
+static const struct pw_context_events context_events_error =
+{
+	PW_VERSION_CONTEXT_EVENTS,
+	.destroy = context_destroy_error,
+	.free = context_free_error,
+	.check_access = context_check_access_error,
+	.global_added = context_global_added_error,
+	.global_removed = context_global_removed_error,
+};
+
+static int destroy_count = 0;
+static void context_destroy_count(void *data)
+{
+	destroy_count++;
+}
+static int free_count = 0;
+static void context_free_count(void *data)
+{
+	free_count++;
+}
+static int global_removed_count = 0;
+static void context_global_removed_count(void *data, struct pw_global *global)
+{
+	global_removed_count++;
+}
+static int context_foreach_count = 0;
+static int context_foreach(void *data, struct pw_global *global)
+{
+	context_foreach_count++;
+	return 0;
+}
+static int context_foreach_error(void *data, struct pw_global *global)
+{
+	context_foreach_count++;
+	return -1;
+}
+PWTEST(context_create)
+{
+	struct pw_main_loop *loop;
+	struct pw_context *context;
+	struct spa_hook listener = { { NULL }, };
+	struct pw_context_events context_events = context_events_error;
+	int res;
+
+	pw_init(0, NULL);
+
+	loop = pw_main_loop_new(NULL);
+	pwtest_ptr_notnull(loop);
+
+	context = pw_context_new(pw_main_loop_get_loop(loop),
+			pw_properties_new(
+				PW_KEY_CONFIG_NAME, "null",
+				NULL), 12);
+	pwtest_ptr_notnull(context);
+	pw_context_add_listener(context, &listener, &context_events, context);
+
+	/* check main loop */
+	pwtest_ptr_eq(pw_context_get_main_loop(context), pw_main_loop_get_loop(loop));
+	/* check user data */
+	pwtest_ptr_notnull(pw_context_get_user_data(context));
+
+	/* iterate globals */
+	pwtest_int_eq(context_foreach_count, 0);
+	res = pw_context_for_each_global(context, context_foreach, context);
+	pwtest_int_eq(res, 0);
+	pwtest_int_eq(context_foreach_count, 2);
+	res = pw_context_for_each_global(context, context_foreach_error, context);
+	pwtest_int_eq(res, -1);
+	pwtest_int_eq(context_foreach_count, 3);
+
+	/* check destroy */
+	context_events.destroy = context_destroy_count;
+	context_events.free = context_free_count;
+	context_events.global_removed = context_global_removed_count;
+
+	pwtest_int_eq(destroy_count, 0);
+	pwtest_int_eq(free_count, 0);
+	pwtest_int_eq(global_removed_count, 0);
+	pw_context_destroy(context);
+	pwtest_int_eq(destroy_count, 1);
+	pwtest_int_eq(free_count, 1);
+	pwtest_int_eq(global_removed_count, 2);
+	pw_main_loop_destroy(loop);
+
+	pw_deinit();
+
+	return PWTEST_PASS;
+}
+
+PWTEST(context_properties)
+{
+	struct pw_main_loop *loop;
+	struct pw_context *context;
+	const struct pw_properties *props;
+	struct spa_hook listener = { { NULL }, };
+	struct pw_context_events context_events = context_events_error;
+	struct spa_dict_item items[3];
+
+	pw_init(0, NULL);
+
+	loop = pw_main_loop_new(NULL);
+	context = pw_context_new(pw_main_loop_get_loop(loop),
+			pw_properties_new("foo", "bar",
+					  "biz", "fuzz",
+					  NULL),
+			0);
+	pwtest_ptr_notnull(context);
+	pwtest_ptr_null(pw_context_get_user_data(context));
+	pw_context_add_listener(context, &listener, &context_events, context);
+
+	props = pw_context_get_properties(context);
+	pwtest_ptr_notnull(props);
+	pwtest_str_eq(pw_properties_get(props, "foo"), "bar");
+	pwtest_str_eq(pw_properties_get(props, "biz"), "fuzz");
+	pwtest_str_eq(pw_properties_get(props, "buzz"), NULL);
+
+	/* remove foo */
+	items[0] = SPA_DICT_ITEM_INIT("foo", NULL);
+	/* change biz */
+	items[1] = SPA_DICT_ITEM_INIT("biz", "buzz");
+	/* add buzz */
+	items[2] = SPA_DICT_ITEM_INIT("buzz", "frizz");
+	pw_context_update_properties(context, &SPA_DICT_INIT(items, 3));
+
+	pwtest_ptr_eq(props, pw_context_get_properties(context));
+	pwtest_str_eq(pw_properties_get(props, "foo"), NULL);
+	pwtest_str_eq(pw_properties_get(props, "biz"), "buzz");
+	pwtest_str_eq(pw_properties_get(props, "buzz"), "frizz");
+
+	spa_hook_remove(&listener);
+	pw_context_destroy(context);
+	pw_main_loop_destroy(loop);
+
+	pw_deinit();
+
+	return PWTEST_PASS;
+}
+
+PWTEST(context_support)
+{
+	static const char * const types[] = {
+		SPA_TYPE_INTERFACE_DataSystem,
+		SPA_TYPE_INTERFACE_DataLoop,
+		SPA_TYPE_INTERFACE_System,
+		SPA_TYPE_INTERFACE_Loop,
+		SPA_TYPE_INTERFACE_LoopUtils,
+		SPA_TYPE_INTERFACE_Log,
+#ifdef HAVE_DBUS
+		SPA_TYPE_INTERFACE_DBus,
+#endif
+		SPA_TYPE_INTERFACE_CPU
+	};
+
+	struct pw_main_loop *loop;
+	struct pw_context *context;
+	const struct spa_support *support;
+	uint32_t n_support;
+	size_t i;
+
+	pw_init(0, NULL);
+
+	loop = pw_main_loop_new(NULL);
+	context = pw_context_new(pw_main_loop_get_loop(loop), NULL, 0);
+
+	support = pw_context_get_support(context, &n_support);
+	pwtest_ptr_notnull(support);
+	pwtest_int_gt(n_support, 0U);
+
+	for (i = 0; i < SPA_N_ELEMENTS(types); i++) {
+		pwtest_ptr_notnull(spa_support_find(support, n_support, types[i]));
+	}
+
+	pw_context_destroy(context);
+	pw_main_loop_destroy(loop);
+
+	pw_deinit();
+
+	return PWTEST_PASS;
+}
+
+PWTEST_SUITE(context)
+{
+	pwtest_add(context_abi, PWTEST_NOARG);
+	pwtest_add(context_create, PWTEST_NOARG);
+	pwtest_add(context_properties, PWTEST_NOARG);
+	pwtest_add(context_support, PWTEST_NOARG);
+
+	return PWTEST_PASS;
+}
diff --git a/test/test-example.c b/test/test-example.c
new file mode 100644
index 0000000..05f9779
--- /dev/null
+++ b/test/test-example.c
@@ -0,0 +1,265 @@
+/* PipeWire
+ *
+ * Copyright © 2021 Red Hat, Inc.
+ *
+ * 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 "config.h"
+
+#include <signal.h>
+#include <unistd.h>
+
+#include <pipewire/pipewire.h>
+
+#include "pwtest.h"
+
+/* The simplest test example (test passes)  */
+PWTEST(successful_test)
+{
+	int x = 10, y = 20, z = 10;
+	bool t = true, f = false;
+	const char *a = "foo", *b = "bar", *c = "baz";
+
+	pwtest_int_lt(x, y);
+	pwtest_int_le(x, y);
+	pwtest_int_gt(y, x);
+	pwtest_int_ge(y, x);
+	pwtest_int_eq(x, z);
+	pwtest_int_ne(y, z);
+
+	pwtest_bool_true(t);
+	pwtest_bool_false(f);
+	pwtest_bool_eq(t, !f);
+	pwtest_bool_ne(t, f);
+
+	pwtest_str_eq(a, a);
+	pwtest_str_ne(a, b);
+	pwtest_str_eq_n(b, c, 2);
+	pwtest_str_ne_n(b, c, 3);
+
+	return PWTEST_PASS;
+}
+
+/* Demo failure of an integer comparison (test will fail) */
+PWTEST(failing_test_int)
+{
+	int x = 10, y = 20;
+	pwtest_int_gt(x, y);
+	return PWTEST_PASS;
+}
+
+/* Demo failure of a bool comparison (test will fail) */
+PWTEST(failing_test_bool)
+{
+	bool oops = true;
+	pwtest_bool_false(oops);
+	return PWTEST_PASS;
+}
+
+/* Demo failure of a string comparison (test will fail) */
+PWTEST(failing_test_string)
+{
+	const char *what = "yes";
+	pwtest_str_eq(what, "no");
+	return PWTEST_PASS;
+}
+
+/* Demo custom failure (test will fail) */
+PWTEST(general_fail_test)
+{
+	/* pwtest_fail(); */
+	pwtest_fail_with_msg("Some condition wasn't met");
+	return PWTEST_PASS;
+}
+
+/* Demo failure (test will fail) */
+PWTEST(failing_test_if_reached)
+{
+	pwtest_fail_if_reached();
+	return PWTEST_SYSTEM_ERROR;
+}
+
+/* Demo a system error (test will fail) */
+PWTEST(system_error_test)
+{
+	return PWTEST_SYSTEM_ERROR;
+}
+
+/* Demo signal handling of SIGSEGV (test will fail) */
+PWTEST(catch_segfault_test)
+{
+	int *x = NULL;
+	*x = 20;
+	return PWTEST_PASS;
+}
+
+/* Demo signal handling of abort (test will fail) */
+PWTEST(catch_abort_signal_test)
+{
+	abort();
+	return PWTEST_PASS;
+}
+
+/* Demo a timeout (test will fail with default timeout of 30) */
+PWTEST(timeout_test)
+{
+	/* run with --timeout=1 to make this less annoying */
+	sleep(60);
+	return PWTEST_PASS;
+}
+
+/* Demo a ranged test (test passes, skips the last 2)  */
+PWTEST(ranged_test)
+{
+	struct pwtest_test *t = current_test;
+	int iteration = pwtest_get_iteration(t);
+
+	pwtest_int_lt(iteration, 10); /* see pwtest_add */
+
+	printf("Ranged test iteration %d\n", iteration);
+	if (iteration >= 8)
+		return PWTEST_SKIP;
+
+	return PWTEST_PASS;
+}
+
+/* Demo the properties passed to tests (test passes)  */
+PWTEST(property_test)
+{
+	struct pwtest_test *t = current_test;
+	struct pw_properties *p = pwtest_get_props(t);
+
+	pwtest_ptr_notnull(p);
+	pwtest_str_eq(pw_properties_get(p, "myprop"), "somevalue");
+	pwtest_str_eq(pw_properties_get(p, "prop2"), "other");
+
+	return PWTEST_PASS;
+}
+
+/* Demo the environment passed to tests (test passes)  */
+PWTEST(env_test)
+{
+	pwtest_str_eq(getenv("myenv"), "envval");
+	pwtest_str_eq(getenv("env2"), "val");
+
+	/* Set by pwtest */
+	pwtest_str_eq(getenv("PWTEST"), "1");
+
+	return PWTEST_PASS;
+}
+
+/* Demo the environment passed to tests (test passes)  */
+PWTEST(env_reset_test)
+{
+	/* If run after env_test even with --no-fork this test should
+	 * succeed */
+	pwtest_str_eq(getenv("myenv"), NULL);
+	pwtest_str_eq(getenv("env2"), NULL);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(default_env_test)
+{
+	/* This one is set automatically */
+	pwtest_str_eq(getenv("PWTEST"), "1");
+	/* Default value */
+	pwtest_str_eq(getenv("PIPEWIRE_REMOTE"), "test-has-no-daemon");
+
+	return PWTEST_PASS;
+}
+
+PWTEST(daemon_test)
+{
+	struct pw_context *ctx;
+        struct pw_core *core;
+	struct pw_loop *loop;
+
+	pwtest_str_eq_n(getenv("PIPEWIRE_REMOTE"), "pwtest-pw-", 10);
+
+	pw_init(0, NULL);
+	loop = pw_loop_new(NULL);
+	ctx = pw_context_new(loop, NULL, 0);
+	pwtest_ptr_notnull(ctx);
+        core = pw_context_connect(ctx, NULL, 0);
+	pwtest_ptr_notnull(core);
+
+	pw_loop_iterate(loop, -1);
+	pw_core_disconnect(core);
+        pw_context_destroy(ctx);
+	pw_loop_destroy(loop);
+
+	return PWTEST_PASS;
+}
+
+/* If not started with a daemon, we can't connect to a daemon (test will fail)  */
+PWTEST(daemon_test_without_daemon)
+{
+	struct pw_context *ctx;
+        struct pw_core *core;
+	struct pw_loop *loop;
+
+	pw_init(0, NULL);
+	loop = pw_loop_new(NULL);
+	ctx = pw_context_new(loop, NULL, 0);
+	pwtest_ptr_notnull(ctx);
+        core = pw_context_connect(ctx, NULL, 0);
+
+	pwtest_ptr_notnull(core); /* Expect this to fail because we don't have a daemon */
+
+	pw_loop_iterate(loop, -1);
+	pw_core_disconnect(core);
+        pw_context_destroy(ctx);
+	pw_loop_destroy(loop);
+
+	return PWTEST_PASS;
+}
+
+PWTEST_SUITE(example_tests)
+{
+	pwtest_add(successful_test, PWTEST_NOARG);
+	pwtest_add(failing_test_int, PWTEST_NOARG);
+	pwtest_add(failing_test_bool, PWTEST_NOARG);
+	pwtest_add(failing_test_string, PWTEST_NOARG);
+	pwtest_add(failing_test_if_reached, PWTEST_NOARG);
+	pwtest_add(general_fail_test, PWTEST_NOARG);
+	pwtest_add(system_error_test, PWTEST_NOARG);
+	pwtest_add(catch_segfault_test, PWTEST_NOARG);
+	pwtest_add(catch_abort_signal_test, PWTEST_ARG_SIGNAL, SIGABRT);
+	pwtest_add(ranged_test, PWTEST_ARG_RANGE, 0, 10);
+	pwtest_add(property_test,
+		   PWTEST_ARG_PROP, "myprop", "somevalue",
+		   PWTEST_ARG_PROP, "prop2", "other");
+	pwtest_add(env_test,
+		   PWTEST_ARG_ENV, "env2", "val",
+		   PWTEST_ARG_ENV, "myenv", "envval");
+	pwtest_add(env_reset_test, PWTEST_NOARG);
+	pwtest_add(default_env_test, PWTEST_NOARG);
+	pwtest_add(daemon_test, PWTEST_ARG_DAEMON);
+	pwtest_add(daemon_test_without_daemon, PWTEST_NOARG);
+
+	/* Run this one last so it doesn't matter if we forget --timeout */
+	pwtest_add(timeout_test, PWTEST_NOARG);
+
+	return PWTEST_PASS;
+}
diff --git a/test/test-functional.c b/test/test-functional.c
new file mode 100644
index 0000000..ae837b4
--- /dev/null
+++ b/test/test-functional.c
@@ -0,0 +1,58 @@
+/* PipeWire
+ *
+ * Copyright © 2019 Wim Taymans
+ *
+ * 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 "config.h"
+
+#include "pwtest.h"
+
+PWTEST(openal_info_test)
+{
+#ifdef OPENAL_INFO_PATH
+	int status = pwtest_spawn(OPENAL_INFO_PATH, (char *[]){ "openal-info", NULL });
+	pwtest_int_eq(WEXITSTATUS(status), 0);
+	return PWTEST_PASS;
+#else
+	return PWTEST_SKIP;
+#endif
+}
+
+PWTEST(pactl_test)
+{
+#ifdef PACTL_PATH
+	int status = pwtest_spawn(PACTL_PATH, (char *[]){ "pactl", "info", NULL });
+	pwtest_int_eq(WEXITSTATUS(status), 0);
+	return PWTEST_PASS;
+#else
+	return PWTEST_SKIP;
+#endif
+}
+
+PWTEST_SUITE(pw_array)
+{
+	pwtest_add(pactl_test, PWTEST_ARG_DAEMON);
+	pwtest_add(openal_info_test, PWTEST_ARG_DAEMON);
+
+	return PWTEST_PASS;
+}
diff --git a/test/test-lib.c b/test/test-lib.c
new file mode 100644
index 0000000..c2d73a4
--- /dev/null
+++ b/test/test-lib.c
@@ -0,0 +1,69 @@
+/* PipeWire
+ *
+ * Copyright © 2021 Red Hat, Inc.
+ *
+ * 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 "config.h"
+
+#include "pwtest.h"
+
+#include "pipewire/pipewire.h"
+
+PWTEST(library_version)
+{
+	const char *libversion, *headerversion;
+	char version_expected[64];
+
+	pw_init(0, NULL);
+	libversion = pw_get_library_version();
+	headerversion = pw_get_headers_version();
+
+	spa_scnprintf(version_expected, sizeof(version_expected),
+		"%d.%d.%d", PW_MAJOR, PW_MINOR, PW_MICRO);
+
+	pwtest_str_eq(headerversion, version_expected);
+	pwtest_str_eq(libversion, version_expected);
+
+	pw_deinit();
+
+	return PWTEST_PASS;
+}
+
+PWTEST(init_deinit)
+{
+	pw_init(0, NULL);
+	pw_deinit();
+	pw_init(0, NULL);
+	pw_init(0, NULL);
+	pw_deinit();
+	pw_deinit();
+	return PWTEST_PASS;
+}
+
+PWTEST_SUITE(properties)
+{
+	pwtest_add(library_version, PWTEST_NOARG);
+	pwtest_add(init_deinit, PWTEST_NOARG);
+
+	return PWTEST_PASS;
+}
diff --git a/test/test-logger.c b/test/test-logger.c
new file mode 100644
index 0000000..b40445a
--- /dev/null
+++ b/test/test-logger.c
@@ -0,0 +1,656 @@
+/* PipeWire
+ *
+ * Copyright © 2021 Red Hat, Inc.
+ *
+ * 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 "pwtest.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include <spa/utils/ansi.h>
+#include <spa/utils/names.h>
+#include <spa/support/plugin.h>
+#include <spa/support/log.h>
+#include <pipewire/pipewire.h>
+
+#ifdef HAVE_SYSTEMD
+#include <systemd/sd-journal.h>
+#endif
+
+PWTEST(logger_truncate_long_lines)
+{
+	struct pwtest_spa_plugin *plugin;
+	void *iface;
+	char fname[PATH_MAX];
+	struct spa_dict_item item;
+	struct spa_dict info;
+	char buffer[1024];
+	FILE *fp;
+	bool mark_line_found = false;
+
+	pw_init(0, NULL);
+
+	pwtest_mkstemp(fname);
+	item = SPA_DICT_ITEM_INIT(SPA_KEY_LOG_FILE, fname);
+	info = SPA_DICT_INIT(&item, 1);
+	plugin = pwtest_spa_plugin_new();
+	iface = pwtest_spa_plugin_load_interface(plugin, "support/libspa-support",
+						 SPA_NAME_SUPPORT_LOG, SPA_TYPE_INTERFACE_Log,
+						 &info);
+	pwtest_ptr_notnull(iface);
+
+	/* Print a line expected to be truncated */
+	spa_log_error(iface, "MARK: %1100s", "foo");
+
+	fp = fopen(fname, "re");
+	while (fgets(buffer, sizeof(buffer), fp) != NULL) {
+		if (strstr(buffer, "MARK:")) {
+			const char *suffix = ".. (truncated)\n";
+			int len = strlen(buffer);
+			pwtest_str_eq(buffer + len - strlen(suffix), suffix);
+			mark_line_found = true;
+			break;
+		}
+	}
+
+	fclose(fp);
+
+	pwtest_bool_true(mark_line_found);
+	pwtest_spa_plugin_destroy(plugin);
+	pw_deinit();
+
+	return PWTEST_PASS;
+}
+
+PWTEST(logger_no_ansi)
+{
+	struct pwtest_spa_plugin *plugin;
+	void *iface;
+	char fname[PATH_MAX];
+	struct spa_dict_item items[2];
+	struct spa_dict info;
+	char buffer[1024];
+	FILE *fp;
+	bool mark_line_found = false;
+
+	pw_init(0, NULL);
+
+	pwtest_mkstemp(fname);
+	items[0] = SPA_DICT_ITEM_INIT(SPA_KEY_LOG_FILE, fname);
+	items[1] = SPA_DICT_ITEM_INIT(SPA_KEY_LOG_COLORS, "true");
+	info = SPA_DICT_INIT(items, 2);
+	plugin = pwtest_spa_plugin_new();
+	iface = pwtest_spa_plugin_load_interface(plugin, "support/libspa-support",
+						 SPA_NAME_SUPPORT_LOG, SPA_TYPE_INTERFACE_Log,
+						 &info);
+	pwtest_ptr_notnull(iface);
+
+	/* Print a line usually containing a color sequence, but we're not a
+	 * tty so expect none despite colors being enabled */
+	spa_log_error(iface, "MARK\n");
+
+	fp = fopen(fname, "re");
+	while (fgets(buffer, sizeof(buffer), fp) != NULL) {
+		if (strstr(buffer, "MARK")) {
+			mark_line_found = true;
+			pwtest_ptr_null(strstr(buffer, SPA_ANSI_RESET));
+			pwtest_ptr_null(strstr(buffer, SPA_ANSI_RED));
+			pwtest_ptr_null(strstr(buffer, SPA_ANSI_BRIGHT_RED));
+			pwtest_ptr_null(strstr(buffer, SPA_ANSI_BOLD_RED));
+		}
+	}
+
+	fclose(fp);
+
+	pwtest_bool_true(mark_line_found);
+	pwtest_spa_plugin_destroy(plugin);
+	pw_deinit();
+
+	return PWTEST_PASS;
+}
+
+static void
+test_log_levels(enum spa_log_level level)
+{
+	char fname[PATH_MAX];
+	char buffer[1024];
+	FILE *fp;
+	bool above_level_found = false;
+	bool below_level_found = false;
+	bool current_level_found = false;
+	char *oldenv = getenv("PIPEWIRE_LOG");
+
+	pwtest_mkstemp(fname);
+	setenv("PIPEWIRE_LOG", fname, 1);
+
+	pw_init(0, NULL);
+
+	/* current level is whatever the iteration is. Log one line
+	 * with our level, one with a level above (should never show up)
+	 * and one with a level below (should show up).
+	 */
+	if (level > SPA_LOG_LEVEL_NONE)
+		pw_log(level, "CURRENT");
+	if (level > SPA_LOG_LEVEL_ERROR)
+		pw_log(level - 1, "BELOW");
+	if (level < SPA_LOG_LEVEL_TRACE)
+		pw_log(level + 1, "ABOVE");
+
+	fp = fopen(fname, "re");
+	while (fgets(buffer, sizeof(buffer), fp) != NULL) {
+		if (strstr(buffer, "CURRENT"))
+			current_level_found = true;
+		else if (strstr(buffer, "ABOVE"))
+			above_level_found = true;
+		else if (strstr(buffer, "BELOW"))
+			below_level_found = true;
+	}
+
+	fclose(fp);
+
+	/* Anything on a higher level than ours should never show up */
+	pwtest_bool_false(above_level_found);
+	if (level == SPA_LOG_LEVEL_NONE) {
+		pwtest_bool_false(current_level_found);
+		pwtest_bool_false(below_level_found);
+	} else if (level == SPA_LOG_LEVEL_ERROR) {
+		pwtest_bool_true(current_level_found);
+		pwtest_bool_false(below_level_found);
+	} else {
+		pwtest_bool_true(current_level_found);
+		pwtest_bool_true(below_level_found);
+	}
+	pw_deinit();
+
+	if (oldenv)
+		setenv("PIPEWIRE_LOG", oldenv, 1);
+	else
+		unsetenv("PIPEWIRE_LOG");
+}
+
+PWTEST(logger_levels)
+{
+	enum spa_log_level level = pwtest_get_iteration(current_test);
+	enum spa_log_level default_level = pw_log_level;
+	struct spa_log *default_logger = pw_log_get();
+	char *oldenv = getenv("PIPEWIRE_DEBUG");
+
+	if (oldenv)
+		oldenv = strdup(oldenv);
+	unsetenv("PIPEWIRE_DEBUG");
+
+	pw_log_set_level(level);
+
+	test_log_levels(level);
+
+	if (oldenv) {
+		setenv("PIPEWIRE_DEBUG", oldenv, 1);
+		free(oldenv);
+	}
+
+	pw_log_set(default_logger);
+	pw_log_set_level(default_level);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(logger_debug_env)
+{
+	enum spa_log_level level = pwtest_get_iteration(current_test);
+	enum spa_log_level default_level = pw_log_level;
+	struct spa_log *default_logger = pw_log_get();
+	char lvl[2] = {0};
+	char *oldenv = getenv("PIPEWIRE_DEBUG");
+
+	if (oldenv)
+		oldenv = strdup(oldenv);
+
+	spa_scnprintf(lvl, sizeof(lvl), "%d", level);
+	setenv("PIPEWIRE_DEBUG", lvl, 1);
+
+	/* Disable logging, let PIPEWIRE_DEBUG set the level */
+	pw_log_set_level(SPA_LOG_LEVEL_NONE);
+
+	test_log_levels(level);
+
+	if (oldenv) {
+		setenv("PIPEWIRE_DEBUG", oldenv, 1);
+		free(oldenv);
+	} else {
+		unsetenv("PIPEWIRE_DEBUG");
+	}
+
+	pw_log_set(default_logger);
+	pw_log_set_level(default_level);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(logger_debug_env_alpha)
+{
+	enum spa_log_level level = pwtest_get_iteration(current_test);
+	enum spa_log_level default_level = pw_log_level;
+	struct spa_log *default_logger = pw_log_get();
+	char *lvl = NULL;
+	char *oldenv = getenv("PIPEWIRE_DEBUG");
+
+	if (oldenv)
+		oldenv = strdup(oldenv);
+
+	switch(level) {
+		case SPA_LOG_LEVEL_NONE:  lvl = "X"; break;
+		case SPA_LOG_LEVEL_ERROR: lvl = "E"; break;
+		case SPA_LOG_LEVEL_WARN:  lvl = "W"; break;
+		case SPA_LOG_LEVEL_INFO:  lvl = "I"; break;
+		case SPA_LOG_LEVEL_DEBUG: lvl = "D"; break;
+		case SPA_LOG_LEVEL_TRACE: lvl = "T"; break;
+		default:
+			pwtest_fail_if_reached();
+			break;
+	}
+	setenv("PIPEWIRE_DEBUG", lvl, 1);
+
+	/* Disable logging, let PIPEWIRE_DEBUG set the level */
+	pw_log_set_level(SPA_LOG_LEVEL_NONE);
+
+	test_log_levels(level);
+
+	if (oldenv) {
+		setenv("PIPEWIRE_DEBUG", oldenv, 1);
+		free(oldenv);
+	} else {
+		unsetenv("PIPEWIRE_DEBUG");
+	}
+
+	pw_log_set(default_logger);
+	pw_log_set_level(default_level);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(logger_debug_env_topic_all)
+{
+	enum spa_log_level level = pwtest_get_iteration(current_test);
+	enum spa_log_level default_level = pw_log_level;
+	struct spa_log *default_logger = pw_log_get();
+	char *oldenv = getenv("PIPEWIRE_DEBUG");
+	char lvlstr[32];
+	char *lvl = "X";
+
+	if (oldenv)
+		oldenv = strdup(oldenv);
+
+	switch(level) {
+		case SPA_LOG_LEVEL_NONE:  lvl = "X"; break;
+		case SPA_LOG_LEVEL_ERROR: lvl = "E"; break;
+		case SPA_LOG_LEVEL_WARN:  lvl = "W"; break;
+		case SPA_LOG_LEVEL_INFO:  lvl = "I"; break;
+		case SPA_LOG_LEVEL_DEBUG: lvl = "D"; break;
+		case SPA_LOG_LEVEL_TRACE: lvl = "T"; break;
+		default:
+			pwtest_fail_if_reached();
+			break;
+	}
+
+	/* Check that the * glob works to enable all topics */
+	spa_scnprintf(lvlstr, sizeof(lvlstr), "*:%s", lvl);
+	setenv("PIPEWIRE_DEBUG", lvlstr, 1);
+
+	/* Disable logging, let PIPEWIRE_DEBUG set the level */
+	pw_log_set_level(SPA_LOG_LEVEL_NONE);
+
+	test_log_levels(level);
+
+	if (oldenv) {
+		setenv("PIPEWIRE_DEBUG", oldenv, 1);
+		free(oldenv);
+	} else {
+		unsetenv("PIPEWIRE_DEBUG");
+	}
+
+	pw_log_set(default_logger);
+	pw_log_set_level(default_level);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(logger_debug_env_invalid)
+{
+	enum spa_log_level default_level = pw_log_level;
+	struct spa_log *default_logger = pw_log_get();
+	char *oldenv = getenv("PIPEWIRE_DEBUG");
+	char fname[PATH_MAX];
+	char buf[1024] = {0};
+	int fd;
+	int rc;
+	bool error_message_found = false;
+	long unsigned int which = pwtest_get_iteration(current_test);
+	const char *envvars[] = {
+		"invalid value",
+		"*:5,some invalid value",
+		"*:W,foo.bar:3,invalid:",
+		"*:W,2,foo.bar:Q",
+		"*:W,7,foo.bar:D",
+		"*:W,Q,foo.bar:5",
+		"*:W,D,foo.bar:8",
+	};
+
+	pwtest_int_lt(which, SPA_N_ELEMENTS(envvars));
+
+	if (oldenv)
+		oldenv = strdup(oldenv);
+
+	/* The error message during pw_init() will go to stderr because no
+	 * logger has been set up yet. Intercept that in our temp file */
+	pwtest_mkstemp(fname);
+	fd = open(fname, O_RDWR);
+	pwtest_errno_ok(fd);
+	rc = dup2(fd, STDERR_FILENO);
+	setlinebuf(stderr);
+	pwtest_errno_ok(rc);
+
+	setenv("PIPEWIRE_DEBUG", envvars[which], 1);
+	pw_init(0, NULL);
+
+	fsync(STDERR_FILENO);
+	lseek(fd, SEEK_SET, 0);
+	while ((rc = read(fd, buf, sizeof(buf) - 1) > 0)) {
+		if (strstr(buf, "Ignoring invalid format in PIPEWIRE_DEBUG")) {
+		    error_message_found = true;
+		    break;
+		}
+	}
+	pwtest_errno_ok(rc);
+	close(fd);
+	pwtest_bool_true(error_message_found);
+
+	if (oldenv) {
+		setenv("PIPEWIRE_DEBUG", oldenv, 1);
+		free(oldenv);
+	} else {
+		unsetenv("PIPEWIRE_DEBUG");
+	}
+
+	pw_log_set(default_logger);
+	pw_log_set_level(default_level);
+	pw_deinit();
+
+	return PWTEST_PASS;
+}
+
+PWTEST(logger_topics)
+{
+	struct pwtest_spa_plugin *plugin;
+	void *iface;
+	char fname[PATH_MAX];
+	struct spa_dict_item items[2];
+	struct spa_dict info;
+	char buffer[1024];
+	FILE *fp;
+	bool mark_line_found = false;
+	struct spa_log_topic topic = {
+		.version = 0,
+		.topic = "my topic",
+		.level = SPA_LOG_LEVEL_DEBUG,
+	};
+
+	pw_init(0, NULL);
+
+	pwtest_mkstemp(fname);
+	items[0] = SPA_DICT_ITEM_INIT(SPA_KEY_LOG_FILE, fname);
+	items[1] = SPA_DICT_ITEM_INIT(SPA_KEY_LOG_COLORS, "true");
+	info = SPA_DICT_INIT(items, 2);
+	plugin = pwtest_spa_plugin_new();
+	iface = pwtest_spa_plugin_load_interface(plugin, "support/libspa-support",
+						 SPA_NAME_SUPPORT_LOG, SPA_TYPE_INTERFACE_Log,
+						 &info);
+	pwtest_ptr_notnull(iface);
+
+	spa_logt_info(iface, &topic, "MARK\n");
+
+	fp = fopen(fname, "re");
+	while (fgets(buffer, sizeof(buffer), fp) != NULL) {
+		if (strstr(buffer, "MARK")) {
+			mark_line_found = true;
+			pwtest_str_contains(buffer, "my topic");
+		}
+	}
+
+	pwtest_bool_true(mark_line_found);
+	pwtest_spa_plugin_destroy(plugin);
+
+	fclose(fp);
+
+	return PWTEST_PASS;
+}
+
+#ifdef HAVE_SYSTEMD
+static enum pwtest_result
+find_in_journal(sd_journal *journal, const char *needle, char *out, size_t out_sz)
+{
+	int rc;
+	int i;
+
+	/* We give ourselves up to a second for our message to appear */
+	for (i = 0; i < 10; i++) {
+		int activity = sd_journal_wait(journal, 100000);
+
+		pwtest_neg_errno_ok(activity);
+		switch (activity) {
+		case SD_JOURNAL_NOP:
+			break;
+		case SD_JOURNAL_INVALIDATE:
+		case SD_JOURNAL_APPEND:
+			while ((rc = sd_journal_next(journal)) > 0) {
+				char buffer[1024] = {0};
+				const char *d;
+				size_t l;
+				int r = sd_journal_get_data(journal, "MESSAGE", (const void **)&d, &l);
+				if (r == -ENOENT || r == -E2BIG || r == -EBADMSG)
+					continue;
+
+				pwtest_neg_errno_ok(r);
+				spa_scnprintf(buffer, sizeof(buffer), "%.*s", (int) l, d);
+				if (strstr(buffer, needle)) {
+					spa_scnprintf(out, out_sz, "%s", buffer);
+					return PWTEST_PASS;
+				}
+			}
+			pwtest_neg_errno_ok(rc);
+			break;
+		default:
+			break;
+		}
+	}
+	return PWTEST_FAIL;
+}
+#endif
+
+PWTEST(logger_journal)
+{
+	enum pwtest_result result = PWTEST_SKIP;
+#ifdef HAVE_SYSTEMD
+	struct pwtest_spa_plugin *plugin;
+	void *iface;
+	struct spa_dict_item items[2];
+	struct spa_dict info;
+	struct spa_log_topic topic = {
+		.version = 0,
+		.topic = "pwtest journal",
+		.level = SPA_LOG_LEVEL_DEBUG,
+	};
+	char buffer[1024] = {0};
+	sd_journal *journal;
+	int rc;
+	char token[64];
+
+	pw_init(0, NULL);
+
+	items[0] = SPA_DICT_ITEM_INIT(SPA_KEY_LOG_LEVEL, "4"); /* debug */
+	info = SPA_DICT_INIT(items, 1);
+	plugin = pwtest_spa_plugin_new();
+	iface = pwtest_spa_plugin_load_interface(plugin, "support/libspa-journal",
+						 SPA_NAME_SUPPORT_LOG, SPA_TYPE_INTERFACE_Log,
+						 &info);
+	pwtest_ptr_notnull(iface);
+
+	rc = sd_journal_open(&journal, SD_JOURNAL_LOCAL_ONLY|SD_JOURNAL_CURRENT_USER);
+	pwtest_neg_errno_ok(rc);
+
+	sd_journal_seek_head(journal);
+	if (sd_journal_next(journal) == 0) { /* No entries? We don't have a journal */
+		goto cleanup;
+	}
+
+	sd_journal_seek_tail(journal);
+	sd_journal_next(journal);
+
+	spa_scnprintf(token, sizeof(token), "MARK %s:%d", __func__, __LINE__);
+	spa_logt_info(iface, &topic, "%s", token);
+
+	result = find_in_journal(journal, token, buffer, sizeof(buffer));
+	pwtest_int_eq((int)result, PWTEST_PASS);
+	pwtest_str_contains(buffer, "pwtest journal");
+
+cleanup:
+	sd_journal_close(journal);
+	pwtest_spa_plugin_destroy(plugin);
+	pw_deinit();
+#endif
+	return result;
+}
+
+PWTEST(logger_journal_chain)
+{
+	enum pwtest_result result = PWTEST_SKIP;
+#ifdef HAVE_SYSTEMD
+	struct pwtest_spa_plugin *plugin;
+	void *iface_log;
+	void *iface;
+	char fname[PATH_MAX];
+	char buffer[1024];
+	FILE *fp;
+	struct spa_dict_item items[2];
+	struct spa_dict info;
+	bool mark_line_found = false;
+	struct spa_log_topic topic = {
+		.version = 0,
+		.topic = "pwtest journal",
+		.level = SPA_LOG_LEVEL_DEBUG,
+	};
+	sd_journal *journal;
+	int rc;
+	char token[64];
+
+	pw_init(0, NULL);
+	pwtest_mkstemp(fname);
+
+	/* Load a normal logger interface first, writing to fname */
+	items[0] = SPA_DICT_ITEM_INIT(SPA_KEY_LOG_FILE, fname);
+	items[1] = SPA_DICT_ITEM_INIT(SPA_KEY_LOG_LEVEL, "4"); /* debug */
+	info = SPA_DICT_INIT(items, 2);
+	plugin = pwtest_spa_plugin_new();
+	iface_log = pwtest_spa_plugin_load_interface(plugin, "support/libspa-support",
+						 SPA_NAME_SUPPORT_LOG, SPA_TYPE_INTERFACE_Log,
+						 &info);
+	pwtest_ptr_notnull(iface_log);
+
+	/* Load the journal logger, it should chain to the above */
+	items[0] = SPA_DICT_ITEM_INIT(SPA_KEY_LOG_LEVEL, "4"); /* debug */
+	info = SPA_DICT_INIT(&items[1], 1);
+	iface = pwtest_spa_plugin_load_interface(plugin, "support/libspa-journal",
+						 SPA_NAME_SUPPORT_LOG, SPA_TYPE_INTERFACE_Log,
+						 &info);
+	pwtest_ptr_notnull(iface);
+
+	rc = sd_journal_open(&journal, SD_JOURNAL_LOCAL_ONLY);
+	pwtest_neg_errno_ok(rc);
+	sd_journal_seek_head(journal);
+	if (sd_journal_next(journal) == 0) { /* No entries? We don't have a journal */
+		goto cleanup;
+	}
+
+	sd_journal_seek_tail(journal);
+	sd_journal_next(journal);
+
+	spa_scnprintf(token, sizeof(token), "MARK %s:%d", __func__, __LINE__);
+
+	spa_logt_info(iface, &topic, "%s", token);
+	result = find_in_journal(journal, token, buffer, sizeof(buffer));
+	pwtest_int_eq((int)result, PWTEST_PASS);
+	pwtest_str_contains(buffer, "pwtest journal");
+
+	/* Now check that the line is in the chained file logger too */
+	spa_memzero(buffer, sizeof(buffer));
+	mark_line_found = false;
+	fp = fopen(fname, "re");
+	while (fgets(buffer, sizeof(buffer), fp) != NULL) {
+		if (strstr(buffer, token)) {
+			mark_line_found = true;
+			pwtest_ptr_null(strstr(buffer, SPA_ANSI_RESET));
+			pwtest_ptr_null(strstr(buffer, SPA_ANSI_RED));
+			pwtest_ptr_null(strstr(buffer, SPA_ANSI_BRIGHT_RED));
+			pwtest_ptr_null(strstr(buffer, SPA_ANSI_BOLD_RED));
+		}
+	}
+
+	fclose(fp);
+
+	result = PWTEST_PASS;
+	pwtest_bool_true(mark_line_found);
+
+cleanup:
+	sd_journal_close(journal);
+	pwtest_spa_plugin_destroy(plugin);
+	pw_deinit();
+
+#endif
+	return result;
+}
+
+PWTEST_SUITE(logger)
+{
+	pwtest_add(logger_truncate_long_lines, PWTEST_NOARG);
+	pwtest_add(logger_no_ansi, PWTEST_NOARG);
+	pwtest_add(logger_levels,
+		   PWTEST_ARG_RANGE, SPA_LOG_LEVEL_NONE, SPA_LOG_LEVEL_TRACE + 1,
+		   PWTEST_NOARG);
+	pwtest_add(logger_debug_env,
+		   PWTEST_ARG_RANGE, SPA_LOG_LEVEL_NONE, SPA_LOG_LEVEL_TRACE + 1,
+		   PWTEST_NOARG);
+	pwtest_add(logger_debug_env_alpha,
+		   PWTEST_ARG_RANGE, SPA_LOG_LEVEL_NONE, SPA_LOG_LEVEL_TRACE + 1,
+		   PWTEST_NOARG);
+	pwtest_add(logger_debug_env_topic_all,
+		   PWTEST_ARG_RANGE, SPA_LOG_LEVEL_NONE, SPA_LOG_LEVEL_TRACE + 1,
+		   PWTEST_NOARG);
+	pwtest_add(logger_debug_env_invalid,
+		   PWTEST_ARG_RANGE, 0, 7, /* see the test */
+		   PWTEST_NOARG);
+	pwtest_add(logger_topics, PWTEST_NOARG);
+	pwtest_add(logger_journal, PWTEST_NOARG);
+	pwtest_add(logger_journal_chain, PWTEST_NOARG);
+
+	return PWTEST_PASS;
+}
diff --git a/test/test-loop.c b/test/test-loop.c
new file mode 100644
index 0000000..bfdb1e4
--- /dev/null
+++ b/test/test-loop.c
@@ -0,0 +1,463 @@
+/* PipeWire
+ *
+ * Copyright © 2022 Wim Taymans <wim.taymans@gmail.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 <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/eventfd.h>
+
+#include "pwtest.h"
+
+#include <pipewire/pipewire.h>
+
+struct obj {
+	int x;
+	struct spa_source source;
+};
+
+struct data {
+	struct pw_main_loop *ml;
+	struct pw_loop *l;
+	struct obj *a, *b;
+	int count;
+};
+
+static inline void write_eventfd(int evfd)
+{
+	uint64_t value = 1;
+	ssize_t r = write(evfd, &value, sizeof(value));
+	pwtest_errno_ok(r);
+	pwtest_int_eq(r, (ssize_t) sizeof(value));
+}
+
+static inline void read_eventfd(int evfd)
+{
+	uint64_t value = 0;
+	ssize_t r = read(evfd, &value, sizeof(value));
+	pwtest_errno_ok(r);
+	pwtest_int_eq(r, (ssize_t) sizeof(value));
+}
+
+static void on_event(struct spa_source *source)
+{
+	struct data *d = source->data;
+
+	pw_loop_remove_source(d->l, &d->a->source);
+	pw_loop_remove_source(d->l, &d->b->source);
+	close(d->a->source.fd);
+	close(d->b->source.fd);
+	free(d->a);
+	free(d->b);
+
+	pw_main_loop_quit(d->ml);
+}
+
+PWTEST(pwtest_loop_destroy2)
+{
+	struct data data;
+
+	pw_init(0, NULL);
+
+	spa_zero(data);
+	data.ml = pw_main_loop_new(NULL);
+	pwtest_ptr_notnull(data.ml);
+
+	data.l = pw_main_loop_get_loop(data.ml);
+	pwtest_ptr_notnull(data.l);
+
+	data.a = calloc(1, sizeof(*data.a));
+	data.b = calloc(1, sizeof(*data.b));
+
+	data.a->source.func = on_event;
+	data.a->source.fd = eventfd(0, 0);
+	data.a->source.mask = SPA_IO_IN;
+	data.a->source.data = &data;
+	data.b->source.func = on_event;
+	data.b->source.fd = eventfd(0, 0);
+	data.b->source.mask = SPA_IO_IN;
+	data.b->source.data = &data;
+
+	pw_loop_add_source(data.l, &data.a->source);
+	pw_loop_add_source(data.l, &data.b->source);
+
+	write_eventfd(data.a->source.fd);
+	write_eventfd(data.b->source.fd);
+
+	pw_main_loop_run(data.ml);
+	pw_main_loop_destroy(data.ml);
+
+	pw_deinit();
+
+	return PWTEST_PASS;
+}
+
+static void
+on_event_recurse1(struct spa_source *source)
+{
+	static bool first = true;
+	struct data *d = source->data;
+
+	++d->count;
+	pwtest_int_lt(d->count, 3);
+
+	read_eventfd(source->fd);
+
+	if (first) {
+		first = false;
+		pw_loop_enter(d->l);
+		pw_loop_iterate(d->l, -1);
+		pw_loop_leave(d->l);
+	}
+	pw_main_loop_quit(d->ml);
+}
+
+PWTEST(pwtest_loop_recurse1)
+{
+	struct data data;
+
+	pw_init(0, NULL);
+
+	spa_zero(data);
+	data.ml = pw_main_loop_new(NULL);
+	pwtest_ptr_notnull(data.ml);
+
+	data.l = pw_main_loop_get_loop(data.ml);
+	pwtest_ptr_notnull(data.l);
+
+	data.a = calloc(1, sizeof(*data.a));
+	data.b = calloc(1, sizeof(*data.b));
+
+	data.a->source.func = on_event_recurse1;
+	data.a->source.fd = eventfd(0, 0);
+	data.a->source.mask = SPA_IO_IN;
+	data.a->source.data = &data;
+	data.b->source.func = on_event_recurse1;
+	data.b->source.fd = eventfd(0, 0);
+	data.b->source.mask = SPA_IO_IN;
+	data.b->source.data = &data;
+
+	pw_loop_add_source(data.l, &data.a->source);
+	pw_loop_add_source(data.l, &data.b->source);
+
+	write_eventfd(data.a->source.fd);
+	write_eventfd(data.b->source.fd);
+
+	pw_main_loop_run(data.ml);
+	pw_main_loop_destroy(data.ml);
+
+	pw_deinit();
+
+	free(data.a);
+	free(data.b);
+
+	return PWTEST_PASS;
+}
+
+static void
+on_event_recurse2(struct spa_source *source)
+{
+	static bool first = true;
+	struct data *d = source->data;
+
+	++d->count;
+	pwtest_int_lt(d->count, 3);
+
+	read_eventfd(source->fd);
+
+	if (first) {
+		first = false;
+		pw_loop_enter(d->l);
+		pw_loop_iterate(d->l, -1);
+		pw_loop_leave(d->l);
+	} else {
+		pw_loop_remove_source(d->l, &d->a->source);
+		pw_loop_remove_source(d->l, &d->b->source);
+		close(d->a->source.fd);
+		close(d->b->source.fd);
+		free(d->a);
+		free(d->b);
+	}
+	pw_main_loop_quit(d->ml);
+}
+
+PWTEST(pwtest_loop_recurse2)
+{
+	struct data data;
+
+	pw_init(0, NULL);
+
+	spa_zero(data);
+	data.ml = pw_main_loop_new(NULL);
+	pwtest_ptr_notnull(data.ml);
+
+	data.l = pw_main_loop_get_loop(data.ml);
+	pwtest_ptr_notnull(data.l);
+
+	data.a = calloc(1, sizeof(*data.a));
+	data.b = calloc(1, sizeof(*data.b));
+
+	data.a->source.func = on_event_recurse2;
+	data.a->source.fd = eventfd(0, 0);
+	data.a->source.mask = SPA_IO_IN;
+	data.a->source.data = &data;
+	data.b->source.func = on_event_recurse2;
+	data.b->source.fd = eventfd(0, 0);
+	data.b->source.mask = SPA_IO_IN;
+	data.b->source.data = &data;
+
+	pw_loop_add_source(data.l, &data.a->source);
+	pw_loop_add_source(data.l, &data.b->source);
+
+	write_eventfd(data.a->source.fd);
+	write_eventfd(data.b->source.fd);
+
+	pw_main_loop_run(data.ml);
+	pw_main_loop_destroy(data.ml);
+
+	pw_deinit();
+
+	return PWTEST_PASS;
+}
+
+static void
+on_event_fail_if_called(void *data, int fd, uint32_t mask)
+{
+	pwtest_fail_if_reached();
+}
+
+struct dmsbd_data {
+	struct pw_loop *l;
+	struct pw_main_loop *ml;
+	struct spa_source *source;
+	struct spa_hook hook;
+};
+
+static void dmsbd_after(void *data)
+{
+	struct dmsbd_data *d = data;
+
+	pw_loop_destroy_source(d->l, d->source);
+	pw_main_loop_quit(d->ml);
+}
+
+static const struct spa_loop_control_hooks dmsbd_hooks = {
+	SPA_VERSION_LOOP_CONTROL_HOOKS,
+	.after = dmsbd_after,
+};
+
+PWTEST(destroy_managed_source_before_dispatch)
+{
+	pw_init(NULL, NULL);
+
+	struct dmsbd_data data = {0};
+
+	data.ml = pw_main_loop_new(NULL);
+	pwtest_ptr_notnull(data.ml);
+
+	data.l = pw_main_loop_get_loop(data.ml);
+	pwtest_ptr_notnull(data.l);
+
+	data.source = pw_loop_add_io(data.l, eventfd(0, 0), SPA_IO_IN, true, on_event_fail_if_called, NULL);
+	pwtest_ptr_notnull(data.source);
+
+	pw_loop_add_hook(data.l, &data.hook, &dmsbd_hooks, &data);
+
+	write_eventfd(data.source->fd);
+
+	pw_main_loop_run(data.ml);
+	pw_main_loop_destroy(data.ml);
+
+	pw_deinit();
+
+	return PWTEST_PASS;
+}
+
+struct dmsbd_recurse_data {
+	struct pw_loop *l;
+	struct pw_main_loop *ml;
+	struct spa_source *a, *b;
+	struct spa_hook hook;
+	bool first;
+};
+
+static void dmsbd_recurse_on_event(void *data, int fd, uint32_t mask)
+{
+	struct dmsbd_recurse_data *d = data;
+
+	read_eventfd(fd);
+
+	pw_loop_enter(d->l);
+	pw_loop_iterate(d->l, 0);
+	pw_loop_leave(d->l);
+
+	pw_main_loop_quit(d->ml);
+}
+
+static void dmswp_recurse_before(void *data)
+{
+	struct dmsbd_recurse_data *d = data;
+
+	if (d->first) {
+		write_eventfd(d->a->fd);
+		write_eventfd(d->b->fd);
+	}
+}
+
+static void dmsbd_recurse_after(void *data)
+{
+	struct dmsbd_recurse_data *d = data;
+
+	if (d->first) {
+		pw_loop_destroy_source(d->l, d->b);
+
+		d->first = false;
+	}
+}
+
+static const struct spa_loop_control_hooks dmsbd_recurse_hooks = {
+	SPA_VERSION_LOOP_CONTROL_HOOKS,
+	.before = dmswp_recurse_before,
+	.after = dmsbd_recurse_after,
+};
+
+PWTEST(destroy_managed_source_before_dispatch_recurse)
+{
+	pw_init(NULL, NULL);
+
+	struct dmsbd_recurse_data data = {
+		.first = true,
+	};
+
+	data.ml = pw_main_loop_new(NULL);
+	pwtest_ptr_notnull(data.ml);
+
+	data.l = pw_main_loop_get_loop(data.ml);
+	pwtest_ptr_notnull(data.l);
+
+	data.l = pw_main_loop_get_loop(data.ml);
+	pwtest_ptr_notnull(data.l);
+
+	data.a = pw_loop_add_io(data.l, eventfd(0, 0), SPA_IO_IN, true, dmsbd_recurse_on_event, &data);
+	data.b = pw_loop_add_io(data.l, eventfd(0, 0), SPA_IO_IN, true, on_event_fail_if_called, NULL);
+	pwtest_ptr_notnull(data.a);
+	pwtest_ptr_notnull(data.b);
+
+	pw_loop_add_hook(data.l, &data.hook, &dmsbd_recurse_hooks, &data);
+
+	pw_main_loop_run(data.ml);
+	pw_main_loop_destroy(data.ml);
+
+	pw_deinit();
+
+	return PWTEST_PASS;
+}
+
+struct ctwd_data {
+	struct spa_source source;
+	int handler_running_barrier;
+};
+
+static void ctwd_event_handler(struct spa_source *source)
+{
+	struct ctwd_data *data = source->data;
+
+	write_eventfd(data->handler_running_barrier);
+
+	for (;;)
+		pause(); /* the purpose of this is to block the loop */
+}
+
+static int ctwd_add_source(struct spa_loop *loop, bool async, uint32_t seq,
+			   const void *d, size_t size, void *user_data)
+{
+	struct ctwd_data *data = user_data;
+
+	pwtest_neg_errno_ok(spa_loop_add_source(loop, &data->source));
+
+	return 0;
+}
+
+PWTEST(cancel_thread_while_dispatching)
+{
+	static const struct spa_dict_item data_loop_props_items[] = {
+		{ "loop.cancel", "true" },
+	};
+	static const struct spa_dict data_loop_props = SPA_DICT_INIT_ARRAY(data_loop_props_items);
+
+	struct ctwd_data data = {
+		.source = {
+			.data = &data,
+			.func = ctwd_event_handler,
+			.mask = SPA_IO_IN,
+			.fd = eventfd(0, 0),
+		},
+		.handler_running_barrier = eventfd(0, 0),
+	};
+
+	pw_init(NULL, NULL);
+
+	struct pw_data_loop *dl = pw_data_loop_new(&data_loop_props);
+	pwtest_ptr_notnull(dl);
+
+	struct pw_loop *l = pw_data_loop_get_loop(dl);
+	pwtest_ptr_notnull(l);
+
+	pwtest_neg_errno_ok(pw_data_loop_start(dl));
+
+	pw_loop_invoke(l, ctwd_add_source, 0, NULL, 0, true, &data);
+	pwtest_ptr_notnull(data.source.loop);
+
+	write_eventfd(data.source.fd);
+	read_eventfd(data.handler_running_barrier);
+
+	pwtest_neg_errno_ok(pw_data_loop_stop(dl));
+
+	/* these are the important checks */
+	pwtest_ptr_null(data.source.priv);
+	pwtest_int_eq(data.source.rmask, UINT32_C(0));
+
+	pw_loop_remove_source(l, &data.source);
+
+	pw_data_loop_destroy(dl);
+
+	close(data.source.fd);
+	close(data.handler_running_barrier);
+
+	pw_deinit();
+
+	return PWTEST_PASS;
+}
+
+PWTEST_SUITE(support)
+{
+	pwtest_add(pwtest_loop_destroy2, PWTEST_NOARG);
+	pwtest_add(pwtest_loop_recurse1, PWTEST_NOARG);
+	pwtest_add(pwtest_loop_recurse2, PWTEST_NOARG);
+	pwtest_add(destroy_managed_source_before_dispatch, PWTEST_NOARG);
+	pwtest_add(destroy_managed_source_before_dispatch_recurse, PWTEST_NOARG);
+	pwtest_add(cancel_thread_while_dispatching, PWTEST_NOARG);
+
+	return PWTEST_PASS;
+}
diff --git a/test/test-map.c b/test/test-map.c
new file mode 100644
index 0000000..b6d7681
--- /dev/null
+++ b/test/test-map.c
@@ -0,0 +1,242 @@
+/* PipeWire
+ *
+ * Copyright © 2021 Red Hat, Inc.
+ *
+ * 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 "pwtest.h"
+
+#include <pipewire/map.h>
+
+
+PWTEST(map_add_remove)
+{
+	struct pw_map map = PW_MAP_INIT(2);
+	int a, b, c;
+	void *p1 = &a, *p2 = &b, *p3 = &c;
+	uint32_t idx1, idx2, idx3;
+
+	idx1 = pw_map_insert_new(&map, p1);
+	idx2 = pw_map_insert_new(&map, p2);
+	idx3 = pw_map_insert_new(&map, p3);
+
+	/* This is implementation-defined behavior and
+	 * may change in the future */
+	pwtest_int_eq(idx1, 0U);
+	pwtest_int_eq(idx2, 1U);
+	pwtest_int_eq(idx3, 2U);
+
+	/* public API */
+	pwtest_ptr_eq(p1, pw_map_lookup(&map, idx1));
+	pwtest_ptr_eq(p2, pw_map_lookup(&map, idx2));
+	pwtest_ptr_eq(p3, pw_map_lookup(&map, idx3));
+
+	pw_map_remove(&map, idx1);
+	pwtest_ptr_null(pw_map_lookup(&map, idx1));
+	pwtest_ptr_eq(p2, pw_map_lookup(&map, idx2));
+	pwtest_ptr_eq(p3, pw_map_lookup(&map, idx3));
+
+	pw_map_remove(&map, idx2);
+	pwtest_ptr_null(pw_map_lookup(&map, idx1));
+	pwtest_ptr_null(pw_map_lookup(&map, idx2));
+	pwtest_ptr_eq(p3, pw_map_lookup(&map, idx3));
+
+	pw_map_remove(&map, idx3);
+	pwtest_ptr_null(pw_map_lookup(&map, idx1));
+	pwtest_ptr_null(pw_map_lookup(&map, idx2));
+	pwtest_ptr_null(pw_map_lookup(&map, idx3));
+
+	idx1 = pw_map_insert_new(&map, p1);
+	idx2 = pw_map_insert_new(&map, p2);
+	idx3 = pw_map_insert_new(&map, p3);
+
+	/* This is implementation-defined behavior and
+	 * may change in the future */
+	pwtest_int_eq(idx3, 0U);
+	pwtest_int_eq(idx2, 1U);
+	pwtest_int_eq(idx1, 2U);
+
+	pw_map_clear(&map);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(map_insert)
+{
+	struct pw_map map = PW_MAP_INIT(2);
+	int a, b, c, d;
+	void *p1 = &a, *p2 = &b, *p3 = &c, *p4 = &d;
+	uint32_t idx1, idx2, idx3;
+	int rc;
+	size_t sz;
+
+	idx1 = pw_map_insert_new(&map, p1);
+	idx2 = pw_map_insert_new(&map, p2);
+	idx3 = pw_map_insert_new(&map, p3);
+
+	pwtest_ptr_eq(p1, pw_map_lookup(&map, idx1));
+	pwtest_ptr_eq(p2, pw_map_lookup(&map, idx2));
+	pwtest_ptr_eq(p3, pw_map_lookup(&map, idx3));
+	sz = pw_map_get_size(&map);
+	pwtest_int_eq(sz, 3U);
+
+	/* overwrite */
+	rc = pw_map_insert_at(&map, idx1, p4);
+	pwtest_neg_errno_ok(rc);
+	pwtest_ptr_eq(p4, pw_map_lookup(&map, idx1));
+	sz = pw_map_get_size(&map);
+	pwtest_int_eq(sz, 3U);
+
+	/* overwrite */
+	rc = pw_map_insert_at(&map, idx2, p4);
+	pwtest_neg_errno_ok(rc);
+	pwtest_ptr_eq(p4, pw_map_lookup(&map, idx2));
+	sz = pw_map_get_size(&map);
+	pwtest_int_eq(sz, 3U);
+
+	/* out of bounds  */
+	rc = pw_map_insert_at(&map, 10000, p4);
+	pwtest_neg_errno(rc, -ENOSPC);
+
+	/* if id is the map size, the item is appended */
+	rc = pw_map_insert_at(&map, idx3 + 1, &p4);
+	pwtest_neg_errno_ok(rc);
+	sz = pw_map_get_size(&map);
+	pwtest_int_eq(sz, 4U);
+
+	pw_map_clear(&map);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(map_size)
+{
+	struct pw_map map = PW_MAP_INIT(2);
+	int a, b, c;
+	void *p1 = &a, *p2 = &b, *p3 = &c;
+	uint32_t idx1;
+	size_t sz;
+
+	idx1 = pw_map_insert_new(&map, p1);
+	sz = pw_map_get_size(&map);
+	pwtest_int_eq(sz, 1U);
+	pw_map_insert_new(&map, p2);
+	sz = pw_map_get_size(&map);
+	pwtest_int_eq(sz, 2U);
+	pw_map_insert_new(&map, p3);
+	sz = pw_map_get_size(&map);
+	pwtest_int_eq(sz, 3U);
+
+	/* Removing does not alter the size */
+	pw_map_remove(&map, idx1);
+	sz = pw_map_get_size(&map);
+	pwtest_int_eq(sz, 3U);
+
+	pw_map_clear(&map);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(map_double_remove)
+{
+	struct pw_map map = PW_MAP_INIT(2);
+	int a, b, c;
+	void *p1 = &a, *p2 = &b, *p3 = &c;
+
+	uint32_t idx1, idx2, idx3;
+
+	idx1 = pw_map_insert_new(&map, p1);
+	idx2 = pw_map_insert_new(&map, p2);
+	idx3 = pw_map_insert_new(&map, p3);
+
+	pw_map_remove(&map, idx1); /* idx1 in the free list */
+	pw_map_remove(&map, idx2); /* idx1 and 2 in the free list */
+	pw_map_remove(&map, idx2); /* should be a noop */
+	idx1 = pw_map_insert_new(&map, p1);
+	idx2 = pw_map_insert_new(&map, p2);
+
+	pwtest_ptr_eq(p1, pw_map_lookup(&map, idx1));
+	pwtest_ptr_eq(p2, pw_map_lookup(&map, idx2));
+	pwtest_ptr_eq(p3, pw_map_lookup(&map, idx3));
+
+	pw_map_clear(&map);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(map_insert_at_free)
+{
+	struct pw_map map = PW_MAP_INIT(2);
+	int data[3] = {1, 2, 3};
+	int new_data = 4;
+	int *ptr[3] = {&data[0], &data[1], &data[3]};
+	int idx[3];
+	int rc;
+
+	/* Test cases, for an item at idx:
+	 * 1. remove at idx, then reinsert
+	 * 2. remove at idx, remove another item, reinsert
+	 * 3. remove another item, remove at idx, reinsert
+	 * 4. remove another item, remove at index, remove another item, reinsert
+	 *
+	 * The indices are the respective 2 bits from the iteration counter,
+	 * we use index 3 to indicate skipping that step to handle cases 1-3.
+	 */
+	int iteration = pwtest_get_iteration(current_test);
+	int item_idx = iteration & 0x3;
+	int before_idx = (iteration >> 2) & 0x3;
+	int after_idx = (iteration >> 4) & 0x3;
+	const int SKIP = 3;
+
+	if (item_idx == SKIP)
+		return PWTEST_PASS;
+
+	idx[0] = pw_map_insert_new(&map, ptr[0]);
+	idx[1] = pw_map_insert_new(&map, ptr[1]);
+	idx[2] = pw_map_insert_new(&map, ptr[2]);
+
+	if (before_idx != SKIP) {
+		before_idx = idx[before_idx];
+		pw_map_remove(&map, before_idx);
+	}
+	pw_map_remove(&map, item_idx);
+	if (after_idx != SKIP) {
+		after_idx = idx[after_idx];
+		pw_map_remove(&map, after_idx);
+	}
+
+	rc = pw_map_insert_at(&map, item_idx, &new_data);
+	pwtest_neg_errno(rc, -EINVAL);
+	pw_map_clear(&map);
+
+	return PWTEST_PASS;
+}
+
+PWTEST_SUITE(pw_map)
+{
+	pwtest_add(map_add_remove, PWTEST_NOARG);
+	pwtest_add(map_insert, PWTEST_NOARG);
+	pwtest_add(map_size, PWTEST_NOARG);
+	pwtest_add(map_double_remove, PWTEST_NOARG);
+	pwtest_add(map_insert_at_free, PWTEST_ARG_RANGE, 0, 63);
+
+	return PWTEST_PASS;
+}
diff --git a/test/test-properties.c b/test/test-properties.c
new file mode 100644
index 0000000..89e66bb
--- /dev/null
+++ b/test/test-properties.c
@@ -0,0 +1,629 @@
+/* PipeWire
+ *
+ * Copyright © 2019 Wim Taymans
+ * Copyright © 2021 Red Hat, Inc.
+ *
+ * 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 "config.h"
+
+#include "pwtest.h"
+
+#include "pipewire/properties.h"
+
+PWTEST(properties_abi)
+{
+#if defined(__x86_64__) && defined(__LP64__)
+	pwtest_int_eq(sizeof(struct pw_properties), 24U);
+	return PWTEST_PASS;
+#else
+	fprintf(stderr, "%zd\n", sizeof(struct pw_properties));
+	return PWTEST_SKIP;
+#endif
+}
+
+PWTEST(properties_empty)
+{
+	struct pw_properties *props, *copy;
+	void *state = NULL;
+
+	props = pw_properties_new(NULL, NULL);
+	pwtest_ptr_notnull(props);
+	pwtest_int_eq(props->flags, 0U);
+
+	pwtest_int_eq(props->dict.n_items, 0U);
+	pwtest_ptr_null(pw_properties_get(props, NULL));
+	pwtest_ptr_null(pw_properties_get(props, "unknown"));
+	pwtest_ptr_null(pw_properties_iterate(props, &state));
+
+	pw_properties_clear(props);
+	pwtest_int_eq(props->dict.n_items, 0U);
+	pwtest_ptr_null(pw_properties_get(props, NULL));
+	pwtest_ptr_null(pw_properties_get(props, ""));
+	pwtest_ptr_null(pw_properties_get(props, "unknown"));
+	pwtest_ptr_null(pw_properties_iterate(props, &state));
+
+	copy = pw_properties_copy(props);
+	pwtest_ptr_notnull(copy);
+	pw_properties_free(props);
+
+	pwtest_int_eq(copy->dict.n_items, 0U);
+	pwtest_ptr_null(pw_properties_get(copy, NULL));
+	pwtest_ptr_null(pw_properties_get(copy, ""));
+	pwtest_ptr_null(pw_properties_get(copy, "unknown"));
+	pwtest_ptr_null(pw_properties_iterate(copy, &state));
+
+	pw_properties_free(copy);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(properties_set)
+{
+	struct pw_properties *props, *copy;
+	void *state = NULL;
+	const char *str;
+
+	props = pw_properties_new(NULL, NULL);
+	pwtest_ptr_notnull(props);
+	pwtest_int_eq(props->flags, 0U);
+
+	pwtest_int_eq(pw_properties_set(props, "foo", "bar"), 1);
+	pwtest_int_eq(props->dict.n_items, 1U);
+	pwtest_str_eq(pw_properties_get(props, "foo"), "bar");
+	pwtest_int_eq(pw_properties_set(props, "foo", "bar"), 0);
+	pwtest_int_eq(props->dict.n_items, 1U);
+	pwtest_str_eq(pw_properties_get(props, "foo"), "bar");
+	pwtest_int_eq(pw_properties_set(props, "foo", "fuz"), 1);
+	pwtest_int_eq(props->dict.n_items, 1U);
+	pwtest_str_eq(pw_properties_get(props, "foo"), "fuz");
+	pwtest_int_eq(pw_properties_set(props, "bar", "foo"), 1);
+	pwtest_int_eq(props->dict.n_items, 2U);
+	pwtest_str_eq(pw_properties_get(props, "bar"), "foo");
+	pwtest_int_eq(pw_properties_set(props, "him", "too"), 1);
+	pwtest_int_eq(props->dict.n_items, 3U);
+	pwtest_str_eq(pw_properties_get(props, "him"), "too");
+	pwtest_int_eq(pw_properties_set(props, "him", NULL), 1);
+	pwtest_int_eq(props->dict.n_items, 2U);
+	pwtest_ptr_null(pw_properties_get(props, "him"));
+	pwtest_int_eq(pw_properties_set(props, "him", NULL), 0);
+	pwtest_int_eq(props->dict.n_items, 2U);
+	pwtest_ptr_null(pw_properties_get(props, "him"));
+
+	pwtest_int_eq(pw_properties_set(props, "", "invalid"), 0);
+	pwtest_int_eq(pw_properties_set(props, NULL, "invalid"), 0);
+
+	str = pw_properties_iterate(props, &state);
+	pwtest_str_ne(str, NULL);
+	pwtest_bool_true((spa_streq(str, "foo") || spa_streq(str, "bar")));
+	str = pw_properties_iterate(props, &state);
+	pwtest_str_ne(str, NULL);
+	pwtest_bool_true((spa_streq(str, "foo") || spa_streq(str, "bar")));
+	str = pw_properties_iterate(props, &state);
+	pwtest_ptr_null(str);
+
+	pwtest_int_eq(pw_properties_set(props, "foo", NULL), 1);
+	pwtest_int_eq(props->dict.n_items, 1U);
+	pwtest_int_eq(pw_properties_set(props, "bar", NULL), 1);
+	pwtest_int_eq(props->dict.n_items, 0U);
+
+	pwtest_int_eq(pw_properties_set(props, "foo", "bar"), 1);
+	pwtest_int_eq(pw_properties_set(props, "bar", "foo"), 1);
+	pwtest_int_eq(pw_properties_set(props, "him", "too"), 1);
+	pwtest_int_eq(props->dict.n_items, 3U);
+
+	pwtest_str_eq(pw_properties_get(props, "foo"), "bar");
+	pwtest_str_eq(pw_properties_get(props, "bar"), "foo");
+	pwtest_str_eq(pw_properties_get(props, "him"), "too");
+
+	pw_properties_clear(props);
+	pwtest_int_eq(props->dict.n_items, 0U);
+
+	pwtest_int_eq(pw_properties_set(props, "foo", "bar"), 1);
+	pwtest_int_eq(pw_properties_set(props, "bar", "foo"), 1);
+	pwtest_int_eq(pw_properties_set(props, "him", "too"), 1);
+	pwtest_int_eq(props->dict.n_items, 3U);
+
+	copy = pw_properties_copy(props);
+	pwtest_ptr_notnull(copy);
+	pwtest_int_eq(copy->dict.n_items, 3U);
+	pwtest_str_eq(pw_properties_get(copy, "foo"), "bar");
+	pwtest_str_eq(pw_properties_get(copy, "bar"), "foo");
+	pwtest_str_eq(pw_properties_get(copy, "him"), "too");
+
+	pwtest_int_eq(pw_properties_set(copy, "bar", NULL), 1);
+	pwtest_int_eq(pw_properties_set(copy, "foo", NULL), 1);
+	pwtest_int_eq(copy->dict.n_items, 1U);
+	pwtest_str_eq(pw_properties_get(copy, "him"), "too");
+
+	pwtest_int_eq(props->dict.n_items, 3U);
+	pwtest_str_eq(pw_properties_get(props, "foo"), "bar");
+	pwtest_str_eq(pw_properties_get(props, "bar"), "foo");
+	pwtest_str_eq(pw_properties_get(props, "him"), "too");
+
+	pw_properties_free(props);
+	pw_properties_free(copy);
+
+	return PWTEST_PASS;
+
+}
+
+PWTEST(properties_new)
+{
+	struct pw_properties *p;
+
+	/* Basic initialization */
+	p = pw_properties_new("k1", "v1", "k2", "v2", NULL);
+	pwtest_ptr_notnull(p);
+	pwtest_str_eq(pw_properties_get(p, "k1"), "v1");
+	pwtest_str_eq(pw_properties_get(p, "k2"), "v2");
+	pwtest_ptr_null(pw_properties_get(p, "k3"));
+	pw_properties_free(p);
+
+	/* Empty initialization should be fine */
+	p = pw_properties_new(NULL, NULL);
+	pwtest_ptr_notnull(p);
+	pwtest_ptr_null(pw_properties_get(p, "k1"));
+	pw_properties_free(p); /* sefault/valgrind only check */
+
+	p = pw_properties_new_string("k1=v1 k2 = v2\tk3\t=\tv3\nk4\n=\nv4");
+	pwtest_str_eq(pw_properties_get(p, "k1"), "v1");
+	pwtest_str_eq(pw_properties_get(p, "k2"), "v2");
+	pwtest_str_eq(pw_properties_get(p, "k3"), "v3");
+	pwtest_str_eq(pw_properties_get(p, "k4"), "v4");
+	pw_properties_free(p);
+
+	p = pw_properties_new("foo", "bar", "bar", "baz", "", "invalid", "him", "too", NULL);
+	pwtest_ptr_notnull(p);
+	pwtest_int_eq(p->flags, 0U);
+	pwtest_int_eq(p->dict.n_items, 3U);
+	pw_properties_free(p);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(properties_new_string)
+{
+	struct pw_properties *props;
+
+	props = pw_properties_new_string("foo=bar bar=baz \"#ignore\"=ignore him=too empty=\"\" =gg");
+	pwtest_ptr_notnull(props);
+	pwtest_int_eq(props->flags, 0U);
+	pwtest_int_eq(props->dict.n_items, 5U);
+
+	pwtest_str_eq(pw_properties_get(props, "foo"), "bar");
+	pwtest_str_eq(pw_properties_get(props, "bar"), "baz");
+	pwtest_str_eq(pw_properties_get(props, "#ignore"), "ignore");
+	pwtest_str_eq(pw_properties_get(props, "him"), "too");
+	pwtest_str_eq(pw_properties_get(props, "empty"), "");
+
+	pw_properties_free(props);
+
+	props = pw_properties_new_string("foo=bar bar=baz");
+	pwtest_ptr_notnull(props);
+	pwtest_int_eq(props->flags, 0U);
+	pwtest_int_eq(props->dict.n_items, 2U);
+
+	pwtest_str_eq(pw_properties_get(props, "foo"), "bar");
+	pwtest_str_eq(pw_properties_get(props, "bar"), "baz");
+
+	pw_properties_free(props);
+
+	props = pw_properties_new_string("foo=bar bar=\"baz");
+	pwtest_ptr_notnull(props);
+	pwtest_int_eq(props->flags, 0U);
+	pwtest_int_eq(props->dict.n_items, 2U);
+
+	pwtest_str_eq(pw_properties_get(props, "foo"), "bar");
+	pwtest_str_eq(pw_properties_get(props, "bar"), "baz");
+
+	pw_properties_free(props);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(properties_free)
+{
+	struct pw_properties *p;
+
+	pw_properties_free(NULL);
+
+	p = pw_properties_new("k1", "v1", "k2", "v2", NULL);
+	pw_properties_clear(p);
+	pw_properties_free(p);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(properties_set_with_alloc)
+{
+	struct pw_properties *p;
+	int nadded;
+
+	/* Set a lot of properties to force reallocation */
+	p = pw_properties_new(NULL, NULL);
+	pwtest_ptr_notnull(p);
+	for (size_t i = 0; i < 1000; i++) {
+		char kbuf[6], vbuf[6];
+		spa_scnprintf(kbuf, sizeof(kbuf), "k%zd", i);
+		spa_scnprintf(vbuf, sizeof(vbuf), "v%zd", i);
+		/* New key, expect 1 */
+		pwtest_int_eq(pw_properties_set(p, kbuf, vbuf), 1);
+		/* No change, expect 0 */
+		pwtest_int_eq(pw_properties_set(p, kbuf, vbuf), 0);
+		pwtest_str_eq(pw_properties_get(p, kbuf), vbuf);
+
+		/* Different value now, expect 1 */
+		pwtest_int_eq(pw_properties_set(p, kbuf, "foo"), 1);
+		pwtest_str_eq(pw_properties_get(p, kbuf), "foo");
+	}
+	pw_properties_free(p);
+
+	/* Adding a NULL value is ignored */
+	p = pw_properties_new(NULL, NULL);
+	nadded = pw_properties_set(p, "key", NULL);
+	pwtest_int_eq(nadded, 0);
+	pw_properties_free(p);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(properties_setf)
+{
+	struct pw_properties *p;
+
+	p = pw_properties_new(NULL, NULL);
+	pwtest_int_eq(pw_properties_setf(p, "foo", "%d.%08x", 657, 0x89342), 1);
+	pwtest_int_eq(p->dict.n_items, 1U);
+	pwtest_str_eq(pw_properties_get(p, "foo"), "657.00089342");
+
+	pwtest_int_eq(pw_properties_setf(p, "", "%f", 189.45f), 0);
+	pwtest_int_eq(pw_properties_setf(p, NULL, "%f", 189.45f), 0);
+	pwtest_int_eq(p->dict.n_items, 1U);
+	pw_properties_free(p);
+
+	/* Set a lot of properties to force reallocation */
+	p = pw_properties_new(NULL, NULL);
+	pwtest_ptr_notnull(p);
+	for (size_t i = 0; i < 1000; i++) {
+		char kbuf[6], vbuf[6];
+		spa_scnprintf(kbuf, sizeof(kbuf), "k%zd", i);
+		spa_scnprintf(vbuf, sizeof(vbuf), "v%zd", i);
+		/* New key, expect 1 */
+		pwtest_int_eq(pw_properties_setf(p, kbuf, "v%zd", i), 1);
+		/* No change, expect 0 */
+		pwtest_int_eq(pw_properties_setf(p, kbuf, "v%zd", i), 0);
+		pwtest_str_eq(pw_properties_get(p, kbuf), vbuf);
+
+		/* Different value now, expect 1 */
+		pwtest_int_eq(pw_properties_set(p, kbuf, "foo"), 1);
+		pwtest_str_eq(pw_properties_get(p, kbuf), "foo");
+	}
+	pw_properties_free(p);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(properties_parse_bool)
+{
+	pwtest_bool_true(pw_properties_parse_bool("true"));
+	pwtest_bool_true(pw_properties_parse_bool("1"));
+	/* only a literal "true" is true */
+	pwtest_bool_false(pw_properties_parse_bool("TRUE"));
+	pwtest_bool_false(pw_properties_parse_bool("True"));
+
+	pwtest_bool_false(pw_properties_parse_bool("false"));
+	pwtest_bool_false(pw_properties_parse_bool("0"));
+	pwtest_bool_false(pw_properties_parse_bool("10"));
+	pwtest_bool_false(pw_properties_parse_bool("-1"));
+	pwtest_bool_false(pw_properties_parse_bool("1x"));
+	pwtest_bool_false(pw_properties_parse_bool("a"));
+
+	return PWTEST_PASS;
+}
+
+
+PWTEST(properties_parse_int)
+{
+	struct test {
+		const char *value;
+		int expected;
+	} tests[] = {
+		{ "1", 1 },
+		{ "0", 0 },
+		{ "-1", -1 },
+		{ "+1", +1 },
+		{ "0xff", 0xff },
+		{ "077", 077 },
+		/* parsing errors */
+		{ "x", 0 },
+		{ "xk", 0 },
+		{ "1k", 0 },
+		{ "abc", 0 },
+		{ "foo", 0 },
+		{ NULL, 0 },
+		{ "", 0 },
+	};
+
+	for (size_t i = 0; i < SPA_N_ELEMENTS(tests); i++) {
+		struct test *t = &tests[i];
+		pwtest_int_eq(pw_properties_parse_int(t->value), t->expected);
+		pwtest_int_eq(pw_properties_parse_int64(t->value), t->expected);
+		pwtest_int_eq(pw_properties_parse_uint64(t->value), (uint64_t)t->expected);
+	}
+
+	pwtest_int_eq(pw_properties_parse_int("0xffffffffff"), 0); /* >32 bit */
+	pwtest_int_eq(pw_properties_parse_int64("0xffffffffff"), 0xffffffffff);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(properties_parse_float)
+{
+	struct test {
+		const char *value;
+		double expected;
+	} tests[] = {
+		{ "1.0", 1.0 },
+		{ "0.0", 0.0 },
+		{ "-1.0", -1.0 },
+		{ "1.234", 1.234 },
+		/* parsing errors */
+		{ "1,0", 0 },
+		{ "x", 0 },
+		{ "xk", 0 },
+		{ "1k", 0 },
+		{ "abc", 0 },
+		{ "foo", 0 },
+		{ NULL, 0 },
+		{ "", 0 },
+	};
+
+	for (size_t i = 0; i < SPA_N_ELEMENTS(tests); i++) {
+		struct test *t = &tests[i];
+		pwtest_double_eq(pw_properties_parse_float(t->value), (float)t->expected);
+		pwtest_double_eq(pw_properties_parse_double(t->value), t->expected);
+	}
+
+	return PWTEST_PASS;
+}
+
+
+PWTEST(properties_copy)
+{
+	struct pw_properties *p1, *p2;
+
+	p1 = pw_properties_new("k1", "v1", "k2", "v2", NULL);
+	p2 = pw_properties_copy(p1);
+	pwtest_str_eq(pw_properties_get(p2, "k1"), "v1");
+	pwtest_str_eq(pw_properties_get(p2, "k2"), "v2");
+	pwtest_ptr_null(pw_properties_get(p2, "k3"));
+
+	/* Change in p2, esure p1 remains the same */
+	pw_properties_set(p2, "k1", "changed");
+	pwtest_str_eq(pw_properties_get(p1, "k1"), "v1");
+	pwtest_str_eq(pw_properties_get(p2, "k1"), "changed");
+
+	/* Add to p1, then to p2, check addition is separate */
+	pw_properties_set(p1, "k3", "v3");
+	pwtest_ptr_null(pw_properties_get(p2, "k3"));
+	pw_properties_set(p2, "k3", "new");
+	pwtest_str_eq(pw_properties_get(p2, "k3"), "new");
+
+	pw_properties_free(p1);
+	pw_properties_free(p2);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(properties_update_string)
+{
+	struct pw_properties *p;
+	const char str[] = "k1 = new1 k3 = new3";
+	int nadded;
+
+	p = pw_properties_new("k1", "v1", "k2", "v2", NULL);
+	nadded = pw_properties_update_string(p, str, sizeof(str));
+	pwtest_int_eq(nadded, 2);
+	pwtest_str_eq(pw_properties_get(p, "k1"), "new1");
+	pwtest_str_eq(pw_properties_get(p, "k2"), "v2");
+	pwtest_str_eq(pw_properties_get(p, "k3"), "new3");
+	pw_properties_free(p);
+
+	/* Updating an empty property should be fine */
+	p = pw_properties_new(NULL, NULL);
+	nadded = pw_properties_update_string(p, str, sizeof(str));
+	pwtest_int_eq(nadded, 2);
+	pwtest_str_eq(pw_properties_get(p, "k1"), "new1");
+	pwtest_ptr_null(pw_properties_get(p, "k2"));
+	pwtest_str_eq(pw_properties_get(p, "k3"), "new3");
+	pw_properties_free(p);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(properties_serialize_dict_stack_overflow)
+{
+	char *long_value = NULL;
+	struct spa_dict_item items[2];
+	struct spa_dict dict;
+	const int sz = 8 * 1024 * 1024;
+	char tmpfile[PATH_MAX];
+	FILE *fp;
+	int r;
+
+	/* Alloc a property value long enough to trigger a stack overflow
+	 * in any variadic arrays (see * e994949d576e93f8c22)
+	 */
+	long_value = calloc(1, sz);
+	if (long_value == 0)
+		return PWTEST_SKIP;
+
+	memset(long_value, 'a', sz - 1);
+	items[0] = SPA_DICT_ITEM_INIT("longval", long_value);
+	items[1] = SPA_DICT_ITEM_INIT(long_value, "longval");
+	dict = SPA_DICT_INIT(items, 2);
+
+	pwtest_mkstemp(tmpfile);
+	fp = fopen(tmpfile, "we");
+	pwtest_ptr_notnull(fp);
+	r = pw_properties_serialize_dict(fp, &dict, 0);
+	pwtest_int_eq(r, 1);
+
+	fclose(fp);
+	free(long_value);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(properties_new_dict)
+{
+	struct pw_properties *props;
+	struct spa_dict_item items[5];
+
+	items[0] = SPA_DICT_ITEM_INIT("foo", "bar");
+	items[1] = SPA_DICT_ITEM_INIT("bar", "baz");
+	items[3] = SPA_DICT_ITEM_INIT("", "invalid");
+	items[4] = SPA_DICT_ITEM_INIT(NULL, "invalid");
+	items[2] = SPA_DICT_ITEM_INIT("him", "too");
+
+	props = pw_properties_new_dict(&SPA_DICT_INIT_ARRAY(items));
+	pwtest_ptr_notnull(props);
+	pwtest_int_eq(props->flags, 0U);
+	pwtest_int_eq(props->dict.n_items, 3U);
+
+	pwtest_str_eq(pw_properties_get(props, "foo"), "bar");
+	pwtest_str_eq(pw_properties_get(props, "bar"), "baz");
+	pwtest_str_eq(pw_properties_get(props, "him"), "too");
+
+	pw_properties_free(props);
+
+	return PWTEST_PASS;
+}
+
+
+PWTEST(properties_new_json)
+{
+	struct pw_properties *props;
+
+	props = pw_properties_new_string("{ \"foo\": \"bar\\n\\t\", \"bar\": 1.8, \"empty\": [ \"foo\", \"bar\" ], \"\": \"gg\"");
+	pwtest_ptr_notnull(props);
+	pwtest_int_eq(props->flags, 0U);
+	pwtest_int_eq(props->dict.n_items, 3U);
+
+	pwtest_str_eq(pw_properties_get(props, "foo"), "bar\n\t");
+	pwtest_str_eq(pw_properties_get(props, "bar"), "1.8");
+	pwtest_str_eq(pw_properties_get(props, "empty"),
+		      "[ \"foo\", \"bar\" ]");
+
+	pw_properties_free(props);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(properties_update)
+{
+	struct pw_properties *props;
+	struct spa_dict_item items[5];
+
+	props = pw_properties_new(NULL, NULL);
+	pwtest_ptr_notnull(props);
+	pwtest_int_eq(props->flags, 0U);
+	pwtest_int_eq(props->dict.n_items, 0U);
+
+	items[0] = SPA_DICT_ITEM_INIT("foo", "bar");
+	items[1] = SPA_DICT_ITEM_INIT("bar", "baz");
+	items[3] = SPA_DICT_ITEM_INIT("", "invalid");
+	items[4] = SPA_DICT_ITEM_INIT(NULL, "invalid");
+	items[2] = SPA_DICT_ITEM_INIT("him", "too");
+	pwtest_int_eq(pw_properties_update(props, &SPA_DICT_INIT_ARRAY(items)),
+		      3);
+	pwtest_int_eq(props->dict.n_items, 3U);
+
+	pwtest_str_eq(pw_properties_get(props, "foo"), "bar");
+	pwtest_str_eq(pw_properties_get(props, "bar"), "baz");
+	pwtest_str_eq(pw_properties_get(props, "him"), "too");
+
+	items[0] = SPA_DICT_ITEM_INIT("foo", "bar");
+	items[1] = SPA_DICT_ITEM_INIT("bar", "baz");
+	pwtest_int_eq(pw_properties_update(props, &SPA_DICT_INIT(items, 2)),
+		      0);
+	pwtest_int_eq(props->dict.n_items, 3U);
+	pwtest_str_eq(pw_properties_get(props, "foo"), "bar");
+	pwtest_str_eq(pw_properties_get(props, "bar"), "baz");
+	pwtest_str_eq(pw_properties_get(props, "him"), "too");
+
+	items[0] = SPA_DICT_ITEM_INIT("bar", "bear");
+	items[1] = SPA_DICT_ITEM_INIT("him", "too");
+	pwtest_int_eq(pw_properties_update(props, &SPA_DICT_INIT(items, 2)),
+		      1);
+	pwtest_int_eq(props->dict.n_items, 3U);
+	pwtest_str_eq(pw_properties_get(props, "foo"), "bar");
+	pwtest_str_eq(pw_properties_get(props, "bar"), "bear");
+	pwtest_str_eq(pw_properties_get(props, "him"), "too");
+
+	items[0] = SPA_DICT_ITEM_INIT("bar", "bear");
+	items[1] = SPA_DICT_ITEM_INIT("him", NULL);
+	pwtest_int_eq(pw_properties_update(props, &SPA_DICT_INIT(items, 2)),
+		      1);
+	pwtest_int_eq(props->dict.n_items, 2U);
+	pwtest_str_eq(pw_properties_get(props, "foo"), "bar");
+	pwtest_str_eq(pw_properties_get(props, "bar"), "bear");
+	pwtest_ptr_null(pw_properties_get(props, "him"));
+
+	items[0] = SPA_DICT_ITEM_INIT("foo", NULL);
+	items[1] = SPA_DICT_ITEM_INIT("bar", "beer");
+	items[2] = SPA_DICT_ITEM_INIT("him", "her");
+	pwtest_int_eq(pw_properties_update(props, &SPA_DICT_INIT(items, 3)),
+		      3);
+	pwtest_int_eq(props->dict.n_items, 2U);
+	pwtest_ptr_null(pw_properties_get(props, "foo"));
+	pwtest_str_eq(pw_properties_get(props, "bar"), "beer");
+	pwtest_str_eq(pw_properties_get(props, "him"), "her");
+
+	pw_properties_free(props);
+
+	return PWTEST_PASS;
+}
+
+PWTEST_SUITE(properties)
+{
+	pwtest_add(properties_abi, PWTEST_NOARG);
+	pwtest_add(properties_empty, PWTEST_NOARG);
+	pwtest_add(properties_new, PWTEST_NOARG);
+	pwtest_add(properties_new_string, PWTEST_NOARG);
+	pwtest_add(properties_free, PWTEST_NOARG);
+	pwtest_add(properties_set, PWTEST_NOARG);
+	pwtest_add(properties_set_with_alloc, PWTEST_NOARG);
+	pwtest_add(properties_setf, PWTEST_NOARG);
+	pwtest_add(properties_parse_bool, PWTEST_NOARG);
+	pwtest_add(properties_parse_int, PWTEST_NOARG);
+	pwtest_add(properties_parse_float, PWTEST_NOARG);
+	pwtest_add(properties_copy, PWTEST_NOARG);
+	pwtest_add(properties_update_string, PWTEST_NOARG);
+	pwtest_add(properties_serialize_dict_stack_overflow, PWTEST_NOARG);
+	pwtest_add(properties_new_dict, PWTEST_NOARG);
+	pwtest_add(properties_new_json, PWTEST_NOARG);
+	pwtest_add(properties_update, PWTEST_NOARG);
+
+	return PWTEST_PASS;
+}
diff --git a/test/test-pwtest.c b/test/test-pwtest.c
new file mode 100644
index 0000000..9242d4c
--- /dev/null
+++ b/test/test-pwtest.c
@@ -0,0 +1,55 @@
+/* PipeWire
+ *
+ * Copyright © 2021 Red Hat, Inc.
+ *
+ * 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 "config.h"
+
+#include "pwtest.h"
+
+#include <signal.h>
+
+#include "pwtest-compat.c"
+
+PWTEST(compat_sigabbrev_np)
+{
+#ifndef HAVE_SIGABBREV_NP
+	pwtest_str_eq(sigabbrev_np(SIGABRT), "ABRT");
+	pwtest_str_eq(sigabbrev_np(SIGSEGV), "SEGV");
+	pwtest_str_eq(sigabbrev_np(SIGSTOP), "STOP");
+	pwtest_str_eq(sigabbrev_np(SIGCHLD), "CHLD");
+	pwtest_str_eq(sigabbrev_np(SIGTERM), "TERM");
+	pwtest_str_eq(sigabbrev_np(SIGKILL), "KILL");
+	pwtest_str_eq(sigabbrev_np(12345), NULL);
+
+	return PWTEST_PASS;
+#else
+	return PWTEST_SKIP;
+#endif
+}
+
+PWTEST_SUITE(pwtest)
+{
+	pwtest_add(compat_sigabbrev_np, PWTEST_NOARG);
+
+	return PWTEST_PASS;
+}
diff --git a/test/test-spa-buffer.c b/test/test-spa-buffer.c
new file mode 100644
index 0000000..89bfabd
--- /dev/null
+++ b/test/test-spa-buffer.c
@@ -0,0 +1,150 @@
+/* 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 "pwtest.h"
+
+#include <spa/buffer/alloc.h>
+#include <spa/buffer/buffer.h>
+#include <spa/buffer/meta.h>
+
+PWTEST(buffer_abi_types)
+{
+	/* buffer */
+	pwtest_int_eq(SPA_DATA_Invalid, 0);
+	pwtest_int_eq(SPA_DATA_MemPtr, 1);
+	pwtest_int_eq(SPA_DATA_MemFd, 2);
+	pwtest_int_eq(SPA_DATA_DmaBuf, 3);
+	pwtest_int_eq(SPA_DATA_MemId, 4);
+	pwtest_int_eq(_SPA_DATA_LAST, 5);
+
+	/* meta */
+	pwtest_int_eq(SPA_META_Invalid, 0);
+	pwtest_int_eq(SPA_META_Header, 1);
+	pwtest_int_eq(SPA_META_VideoCrop, 2);
+	pwtest_int_eq(SPA_META_VideoDamage, 3);
+	pwtest_int_eq(SPA_META_Bitmap, 4);
+	pwtest_int_eq(SPA_META_Cursor, 5);
+	pwtest_int_eq(SPA_META_Control, 6);
+	pwtest_int_eq(SPA_META_Busy, 7);
+	pwtest_int_eq(SPA_META_VideoTransform, 8);
+	pwtest_int_eq(_SPA_META_LAST, 9);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(buffer_abi_sizes)
+{
+#if defined(__x86_64__) && defined(__LP64__)
+	pwtest_int_eq(sizeof(struct spa_chunk), 16U);
+	pwtest_int_eq(sizeof(struct spa_data), 40U);
+	pwtest_int_eq(sizeof(struct spa_buffer), 24U);
+
+	pwtest_int_eq(sizeof(struct spa_meta), 16U);
+	pwtest_int_eq(sizeof(struct spa_meta_header), 32U);
+	pwtest_int_eq(sizeof(struct spa_meta_region), 16U);
+	pwtest_int_eq(sizeof(struct spa_meta_bitmap), 20U);
+	pwtest_int_eq(sizeof(struct spa_meta_cursor), 28U);
+	pwtest_int_eq(sizeof(struct spa_meta_videotransform), 4U);
+
+	return PWTEST_PASS;
+#else
+	fprintf(stderr, "%zd\n", sizeof(struct spa_chunk));
+	fprintf(stderr, "%zd\n", sizeof(struct spa_data));
+	fprintf(stderr, "%zd\n", sizeof(struct spa_buffer));
+	fprintf(stderr, "%zd\n", sizeof(struct spa_meta));
+	fprintf(stderr, "%zd\n", sizeof(struct spa_meta_header));
+	fprintf(stderr, "%zd\n", sizeof(struct spa_meta_region));
+	fprintf(stderr, "%zd\n", sizeof(struct spa_meta_bitmap));
+	fprintf(stderr, "%zd\n", sizeof(struct spa_meta_cursor));
+	fprintf(stderr, "%zd\n", sizeof(struct spa_meta_videotransform));
+	return PWTEST_SKIP;
+#endif
+}
+
+PWTEST(buffer_alloc)
+{
+	struct spa_buffer **buffers;
+	struct spa_meta metas[4];
+	struct spa_data datas[2];
+	uint32_t aligns[2];
+	uint32_t i, j;
+
+	metas[0].type = SPA_META_Header;
+	metas[0].size = sizeof(struct spa_meta_header);
+	metas[1].type = SPA_META_VideoDamage;
+	metas[1].size = sizeof(struct spa_meta_region) * 16;
+#define CURSOR_META_SIZE(w,h,bpp) (sizeof(struct spa_meta_cursor) + \
+                                   sizeof(struct spa_meta_bitmap) + w * h * bpp)
+	metas[2].type = SPA_META_Cursor;
+	metas[2].size = CURSOR_META_SIZE(64,64,4);
+	metas[3].type = 101;
+	metas[3].size = 11;
+
+	datas[0].maxsize = 4000;
+	datas[1].maxsize = 2011;
+
+	aligns[0] = 32;
+	aligns[1] = 16;
+
+	buffers = spa_buffer_alloc_array(16, 0,
+			SPA_N_ELEMENTS(metas), metas,
+			SPA_N_ELEMENTS(datas), datas, aligns);
+
+	fprintf(stderr, "buffers %p\n", buffers);
+
+	for (i = 0; i < 16; i++) {
+		struct spa_buffer *b = buffers[i];
+		fprintf(stderr, "buffer %d %p\n", i, b);
+
+		pwtest_int_eq(b->n_metas, SPA_N_ELEMENTS(metas));
+		pwtest_int_eq(b->n_datas, SPA_N_ELEMENTS(datas));
+
+		for (j = 0; j < SPA_N_ELEMENTS(metas); j++) {
+			pwtest_int_eq(b->metas[j].type, metas[j].type);
+			pwtest_int_eq(b->metas[j].size, metas[j].size);
+			fprintf(stderr, " meta %d %p\n", j, b->metas[j].data);
+			pwtest_bool_true(SPA_IS_ALIGNED(b->metas[j].data, 8));
+		}
+
+		for (j = 0; j < SPA_N_ELEMENTS(datas); j++) {
+			pwtest_int_eq(b->datas[j].maxsize, datas[j].maxsize);
+			fprintf(stderr, " data %d %p %p\n", j, b->datas[j].chunk, b->datas[j].data);
+			pwtest_bool_true(SPA_IS_ALIGNED(b->datas[j].chunk, 8));
+			pwtest_bool_true(SPA_IS_ALIGNED(b->datas[j].data, aligns[j]));
+		}
+	}
+	free(buffers);
+
+	return PWTEST_PASS;
+}
+
+PWTEST_SUITE(spa_buffer)
+{
+	pwtest_add(buffer_abi_types, PWTEST_NOARG);
+	pwtest_add(buffer_abi_sizes, PWTEST_NOARG);
+	pwtest_add(buffer_alloc, PWTEST_NOARG);
+
+	return PWTEST_PASS;
+}
+
diff --git a/test/test-spa-json.c b/test/test-spa-json.c
new file mode 100644
index 0000000..2a57039
--- /dev/null
+++ b/test/test-spa-json.c
@@ -0,0 +1,333 @@
+/* Simple Plugin API
+ *
+ * Copyright © 2020 Wim Taymans <wim.taymans@gmail.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 "pwtest.h"
+
+#include <spa/utils/defs.h>
+#include <spa/utils/json.h>
+#include <spa/utils/string.h>
+
+PWTEST(json_abi)
+{
+#if defined(__x86_64__) && defined(__LP64__)
+	pwtest_int_eq(sizeof(struct spa_json), 32U);
+	return PWTEST_PASS;
+#else
+	fprintf(stderr, "%zd\n", sizeof(struct spa_json));
+	return PWTEST_SKIP;
+#endif
+}
+
+#define TYPE_OBJECT	0
+#define TYPE_ARRAY	1
+#define TYPE_STRING	2
+#define TYPE_BOOL	3
+#define TYPE_NULL	4
+#define TYPE_TRUE	5
+#define TYPE_FALSE	6
+#define TYPE_FLOAT	7
+
+static void check_type(int type, const char *value, int len)
+{
+	pwtest_bool_eq(spa_json_is_object(value, len), (type == TYPE_OBJECT));
+	pwtest_bool_eq(spa_json_is_array(value, len), (type == TYPE_ARRAY));
+	pwtest_bool_eq(spa_json_is_string(value, len), (type == TYPE_STRING));
+	pwtest_bool_eq(spa_json_is_bool(value, len),
+			(type == TYPE_BOOL || type == TYPE_TRUE || type == TYPE_FALSE));
+	pwtest_bool_eq(spa_json_is_null(value, len), (type == TYPE_NULL));
+	pwtest_bool_eq(spa_json_is_true(value, len), (type == TYPE_TRUE || type == TYPE_BOOL));
+	pwtest_bool_eq(spa_json_is_false(value, len), (type == TYPE_FALSE || type == TYPE_BOOL));
+	pwtest_bool_eq(spa_json_is_float(value, len), (type == TYPE_FLOAT));
+}
+
+static void expect_type(struct spa_json *it, int type)
+{
+	const char *value;
+	int len;
+	pwtest_int_gt((len = spa_json_next(it, &value)), 0);
+	check_type(type, value, len);
+}
+
+static void expect_string(struct spa_json *it, const char *str)
+{
+	const char *value;
+	int len;
+	char *s;
+	pwtest_int_gt((len = spa_json_next(it, &value)), 0);
+	check_type(TYPE_STRING, value, len);
+	s = alloca(len+1);
+	spa_json_parse_stringn(value, len, s, len+1);
+	pwtest_str_eq(s, str);
+}
+static void expect_float(struct spa_json *it, float val)
+{
+	const char *value;
+	int len;
+	float f = 0.0f;
+	pwtest_int_gt((len = spa_json_next(it, &value)), 0);
+	check_type(TYPE_FLOAT, value, len);
+	pwtest_int_gt(spa_json_parse_float(value, len, &f), 0);
+	pwtest_double_eq(f, val);
+}
+
+PWTEST(json_parse)
+{
+	struct spa_json it[5];
+	const char *json = " { "
+			"\"foo\": \"bar\","
+			"\"foo\\\"  \":   true,       "
+			"\"foo \\n\\r\\t\": false,"
+			"  \"  arr\": [ true, false, null, 5, 5.7, \"str]\"],"
+			"\"foo 2\":     null,"
+			"\"foo 3\": 1,"
+			"  \"obj\": { \"ba } z\": false, \"empty\": [], \"foo\": { }, \"1.9\", 1.9 },"
+			"\"foo 4\"   : 1.8,   "
+			"\"foo 5\": -1.8  , "
+			"\"foo 6\":   +2.8   ,"
+			" } ", *value;
+
+	spa_json_init(&it[0], json, strlen(json));
+
+	expect_type(&it[0], TYPE_OBJECT);
+	spa_json_enter(&it[0], &it[1]);
+	expect_string(&it[1], "foo");
+	expect_string(&it[1], "bar");
+	expect_string(&it[1], "foo\"  ");
+	expect_type(&it[1], TYPE_TRUE);
+	expect_string(&it[1], "foo \n\r\t");
+	expect_type(&it[1], TYPE_FALSE);
+	expect_string(&it[1], "  arr");
+	expect_type(&it[1], TYPE_ARRAY);
+	spa_json_enter(&it[1], &it[2]);
+	expect_string(&it[1], "foo 2");
+	expect_type(&it[1], TYPE_NULL);
+	expect_string(&it[1], "foo 3");
+	expect_float(&it[1], 1.f);
+	expect_string(&it[1], "obj");
+	expect_type(&it[1], TYPE_OBJECT);
+	spa_json_enter(&it[1], &it[3]);
+	expect_string(&it[1], "foo 4");
+	expect_float(&it[1], 1.8f);
+	expect_string(&it[1], "foo 5");
+	expect_float(&it[1], -1.8f);
+	expect_string(&it[1], "foo 6");
+	expect_float(&it[1], +2.8f);
+	/* in the array */
+	expect_type(&it[2], TYPE_TRUE);
+	expect_type(&it[2], TYPE_FALSE);
+	expect_type(&it[2], TYPE_NULL);
+	expect_float(&it[2], 5.f);
+	expect_float(&it[2], 5.7f);
+	expect_string(&it[2], "str]");
+	/* in the object */
+	expect_string(&it[3], "ba } z");
+	expect_type(&it[3], TYPE_FALSE);
+	expect_string(&it[3], "empty");
+	expect_type(&it[3], TYPE_ARRAY);
+	spa_json_enter(&it[3], &it[4]);
+	pwtest_int_eq(spa_json_next(&it[4], &value), 0);
+	expect_string(&it[3], "foo");
+	expect_type(&it[3], TYPE_OBJECT);
+	spa_json_enter(&it[3], &it[4]);
+	expect_string(&it[3], "1.9");
+	expect_float(&it[3], 1.9f);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(json_encode)
+{
+	char dst[128];
+	char dst4[4];
+	char dst6[6];
+	char result[1024];
+	pwtest_int_eq(spa_json_encode_string(dst, sizeof(dst), "test"), 6);
+	pwtest_str_eq(dst, "\"test\"");
+	pwtest_int_eq(spa_json_encode_string(dst4, sizeof(dst4), "test"), 6);
+	pwtest_int_eq(strncmp(dst4, "\"tes", 4), 0);
+	pwtest_int_eq(spa_json_encode_string(dst6, sizeof(dst6), "test"), 6);
+	pwtest_int_eq(strncmp(dst6, "\"test\"", 6), 0);
+	pwtest_int_eq(spa_json_encode_string(dst, sizeof(dst), "test\"\n\r \t\b\f\'"), 20);
+	pwtest_str_eq(dst, "\"test\\\"\\n\\r \\t\\b\\f'\"");
+	pwtest_int_eq(spa_json_encode_string(dst, sizeof(dst), "\x04\x05\x1f\x20\x01\x7f\x90"), 29);
+	pwtest_str_eq(dst, "\"\\u0004\\u0005\\u001f \\u0001\x7f\x90\"");
+	pwtest_int_eq(spa_json_parse_stringn(dst, sizeof(dst), result, sizeof(result)), 1);
+	pwtest_str_eq(result, "\x04\x05\x1f\x20\x01\x7f\x90");
+	strcpy(dst, "\"\\u03b2a\"");
+	pwtest_int_eq(spa_json_parse_stringn(dst, sizeof(dst), result, sizeof(result)), 1);
+	pwtest_str_eq(result, "\316\262a");
+	strcpy(dst, "\"\\u 03b2a \"");
+	pwtest_int_eq(spa_json_parse_stringn(dst, sizeof(dst), result, sizeof(result)), 1);
+	pwtest_str_eq(result, "u 03b2a ");
+
+	return PWTEST_PASS;
+}
+
+static void test_array(char *str, char **vals)
+{
+	struct spa_json it[2];
+	char val[256];
+	int i;
+
+	spa_json_init(&it[0], str, strlen(str));
+	if (spa_json_enter_array(&it[0], &it[1]) <= 0)
+		spa_json_init(&it[1], str, strlen(str));
+	for (i = 0; vals[i]; i++) {
+		pwtest_int_gt(spa_json_get_string(&it[1], val, sizeof(val)), 0);
+		pwtest_str_eq(val, vals[i]);
+	}
+}
+
+PWTEST(json_array)
+{
+	test_array("FL,FR", (char *[]){ "FL", "FR", NULL });
+	test_array(" FL , FR ", (char *[]){ "FL", "FR", NULL });
+	test_array("[ FL , FR ]", (char *[]){ "FL", "FR", NULL });
+	test_array("[FL FR]", (char *[]){ "FL", "FR", NULL });
+	test_array("FL FR", (char *[]){ "FL", "FR", NULL });
+	test_array("[ FL FR ]", (char *[]){ "FL", "FR", NULL });
+
+	return PWTEST_PASS;
+}
+
+PWTEST(json_overflow)
+{
+	struct spa_json it[2];
+	char val[3];
+	const char *str = "[ F, FR, FRC ]";
+
+	spa_json_init(&it[0], str, strlen(str));
+	pwtest_int_gt(spa_json_enter_array(&it[0], &it[1]), 0);
+
+	pwtest_int_gt(spa_json_get_string(&it[1], val, sizeof(val)), 0);
+	pwtest_str_eq(val, "F");
+	pwtest_int_gt(spa_json_get_string(&it[1], val, sizeof(val)), 0);
+	pwtest_str_eq(val, "FR");
+	pwtest_int_lt(spa_json_get_string(&it[1], val, sizeof(val)), 0);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(json_float)
+{
+	struct {
+		const char *str;
+		double val;
+	} val[] = {
+		{ "0.0", 0.0f },
+		{ ".0", 0.0f },
+		{ ".0E0", 0.0E0f },
+		{ "1.0", 1.0f },
+		{ "1.011", 1.011f },
+		{ "176543.123456", 176543.123456f },
+		{ "-176543.123456", -176543.123456f },
+		{ "-5678.5432E10", -5678.5432E10f },
+		{ "-5678.5432e10", -5678.5432e10f },
+		{ "-5678.5432e-10", -5678.5432e-10f },
+		{ "5678.5432e+10", 5678.5432e+10f },
+		{ "00.000100", 00.000100f },
+		{ "-0.000100", -0.000100f },
+	};
+	float v;
+	unsigned i;
+	char buf1[128], buf2[128], *b1 = buf1, *b2 = buf2;
+
+	pwtest_int_eq(spa_json_parse_float("", 0, &v), 0);
+
+	setlocale(LC_NUMERIC, "C");
+	for (i = 0; i < SPA_N_ELEMENTS(val); i++) {
+		pwtest_int_gt(spa_json_parse_float(val[i].str, strlen(val[i].str), &v), 0);
+		pwtest_double_eq(v, val[i].val);
+	}
+	setlocale(LC_NUMERIC, "fr_FR");
+	for (i = 0; i < SPA_N_ELEMENTS(val); i++) {
+		pwtest_int_gt(spa_json_parse_float(val[i].str, strlen(val[i].str), &v), 0);
+		pwtest_double_eq(v, val[i].val);
+	}
+	pwtest_ptr_eq(spa_json_format_float(buf1, sizeof(buf1), 0.0f), b1);
+	pwtest_str_eq(buf1, "0.000000");
+	pwtest_ptr_eq(spa_json_format_float(buf1, sizeof(buf1), NAN), b1);
+	pwtest_str_eq(buf1, "0.000000");
+	pwtest_ptr_eq(spa_json_format_float(buf1, sizeof(buf1), INFINITY), b1);
+	pwtest_ptr_eq(spa_json_format_float(buf2, sizeof(buf2), FLT_MAX), b2);
+	pwtest_str_eq(buf1, buf2);
+	pwtest_ptr_eq(spa_json_format_float(buf1, sizeof(buf1), -INFINITY), b1);
+	pwtest_ptr_eq(spa_json_format_float(buf2, sizeof(buf2), FLT_MIN), b2);
+	pwtest_str_eq(buf1, buf2);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(json_float_check)
+{
+	struct {
+		const char *str;
+		int res;
+	} val[] = {
+		{ "0.0", 1 },
+		{ ".0", 1 },
+		{ "+.0E0", 1 },
+		{ "-.0e0", 1 },
+
+		{ "0,0", 0 },
+		{ "0.0.5", 0 },
+		{ "0x0", 0 },
+		{ "0x0.0", 0 },
+		{ "E10", 0 },
+		{ "e20", 0 },
+		{ " 0.0", 0 },
+		{ "0.0 ", 0 },
+		{ " 0.0 ", 0 },
+	};
+	unsigned i;
+	float v;
+
+	for (i = 0; i < SPA_N_ELEMENTS(val); i++) {
+		pwtest_int_eq(spa_json_parse_float(val[i].str, strlen(val[i].str), &v), val[i].res);
+	}
+	return PWTEST_PASS;
+}
+
+PWTEST(json_int)
+{
+	int v;
+	pwtest_int_eq(spa_json_parse_int("", 0, &v), 0);
+	return PWTEST_PASS;
+}
+
+PWTEST_SUITE(spa_json)
+{
+	pwtest_add(json_abi, PWTEST_NOARG);
+	pwtest_add(json_parse, PWTEST_NOARG);
+	pwtest_add(json_encode, PWTEST_NOARG);
+	pwtest_add(json_array, PWTEST_NOARG);
+	pwtest_add(json_overflow, PWTEST_NOARG);
+	pwtest_add(json_float, PWTEST_NOARG);
+	pwtest_add(json_float_check, PWTEST_NOARG);
+	pwtest_add(json_int, PWTEST_NOARG);
+
+	return PWTEST_PASS;
+}
diff --git a/test/test-spa-log.c b/test/test-spa-log.c
new file mode 100644
index 0000000..a90ed73
--- /dev/null
+++ b/test/test-spa-log.c
@@ -0,0 +1,213 @@
+/* Simple Plugin API
+ * Copyright © 2021 Red Hat, Inc.
+ *
+ * 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 <spa/support/log.h>
+
+#include "pwtest.h"
+
+#define OTHER_ARGS const char *file, int line, const char *func, const char *fmt
+
+struct data {
+	bool invoked;
+	const char *func;
+	const char *msg;
+	const struct spa_log_topic *topic;
+};
+
+
+static void impl_log_log(void *object, enum spa_log_level level, OTHER_ARGS, ...) {
+	struct data *data = object;
+	*data = (struct data) {
+		.func = __func__,
+		.invoked = true,
+		.msg = fmt,
+		.topic = NULL,
+	};
+};
+
+static void impl_log_logv(void *object, enum spa_log_level level, OTHER_ARGS, va_list args) {
+	struct data *data = object;
+	*data = (struct data) {
+		.func = __func__,
+		.invoked = true,
+		.msg = fmt,
+		.topic = NULL,
+	};
+};
+
+static void impl_log_logt(void *object, enum spa_log_level level, const struct spa_log_topic *topic, OTHER_ARGS, ...) {
+	struct data *data = object;
+	*data = (struct data) {
+		.func = __func__,
+		.invoked = true,
+		.msg = fmt,
+		.topic = topic,
+	};
+};
+
+static void impl_log_logtv(void *object, enum spa_log_level level, const struct spa_log_topic *topic, OTHER_ARGS, va_list args) {
+	struct data *data = object;
+	*data = (struct data) {
+		.func = __func__,
+		.invoked = true,
+		.msg = fmt,
+		.topic = topic,
+	};
+};
+
+PWTEST(utils_log_logt)
+{
+	struct spa_log_methods impl_log = {
+		SPA_VERSION_LOG_METHODS,
+		.log = impl_log_log,
+		.logv = impl_log_logv,
+		.logt = impl_log_logt,
+		.logtv = impl_log_logtv,
+	};
+	struct spa_log log;
+	struct data data;
+	struct spa_log_topic topic = {
+		.version = 0,
+		.topic = "log topic",
+		.level = SPA_LOG_LEVEL_DEBUG,
+	};
+
+	log.level = SPA_LOG_LEVEL_DEBUG;
+	log.iface = SPA_INTERFACE_INIT(SPA_TYPE_INTERFACE_Log, 0, &impl_log, &data);
+
+	impl_log.version = 0;
+
+	/* impl_log is v0 so we expect the non-topic function to be called */
+	spa_log_debug(&log, "call v0");
+	pwtest_bool_true(data.invoked);
+	pwtest_str_eq(data.func, "impl_log_log");
+	pwtest_str_eq(data.msg, "call v0");
+	pwtest_ptr_null(data.topic);
+	data.invoked = false;
+
+	/* impl_log is v0 so we expect the topic to be ignored */
+	spa_logt_debug(&log, &topic, "call v0 logt");
+	pwtest_bool_true(data.invoked);
+	pwtest_str_eq(data.func, "impl_log_log");
+	pwtest_str_eq(data.msg, "call v0 logt");
+	pwtest_ptr_null(data.topic);
+	data.invoked = false;
+
+	impl_log.version = SPA_VERSION_LOG_METHODS;
+
+	/* impl_log is v1 so we expect logt to be called */
+	spa_log_debug(&log, "call v1");
+	pwtest_bool_true(data.invoked);
+	pwtest_str_eq(data.func, "impl_log_logt");
+	pwtest_str_eq(data.msg, "call v1");
+	pwtest_ptr_null(data.topic);
+	data.invoked = false;
+
+	/* impl_log is v1 so we expect the topic to be passed through */
+	spa_logt_debug(&log, &topic, "call v1 logt");
+	pwtest_bool_true(data.invoked);
+	pwtest_str_eq(data.func, "impl_log_logt");
+	pwtest_str_eq(data.msg, "call v1 logt");
+	pwtest_ptr_eq(data.topic, &topic);
+	data.invoked = false;
+
+	/* simulated:
+	 * impl_log is v1 but we have an old caller that uses v0, this goes
+	 * through to the non-topic log function */
+	spa_interface_call(&log.iface, struct spa_log_methods, log, 0,
+			   SPA_LOG_LEVEL_DEBUG, "file", 123, "function", "call from v0");
+	pwtest_bool_true(data.invoked);
+	pwtest_str_eq(data.func, "impl_log_log");
+	pwtest_str_eq(data.msg, "call from v0");
+	pwtest_ptr_null(data.topic);
+	data.invoked = false;
+
+	return PWTEST_PASS;
+}
+
+PWTEST(utils_log_logt_levels)
+{
+	struct spa_log_methods impl_log = {
+		SPA_VERSION_LOG_METHODS,
+		.log = impl_log_log,
+		.logv = impl_log_logv,
+		.logt = impl_log_logt,
+		.logtv = impl_log_logtv,
+	};
+	struct spa_log log;
+	struct data data;
+	struct spa_log_topic topic = {
+		.version = 0,
+		.topic = "log topic",
+		.level = SPA_LOG_LEVEL_INFO,
+		.has_custom_level = true,
+	};
+
+	log.level = SPA_LOG_LEVEL_DEBUG;
+	log.iface = SPA_INTERFACE_INIT(SPA_TYPE_INTERFACE_Log, 0, &impl_log, &data);
+
+	/* Topic is NULL for spa_log_*, so expect this to be invoked */
+	spa_log_debug(&log, "spa_log_debug");
+	pwtest_bool_true(data.invoked);
+	pwtest_str_eq(data.msg, "spa_log_debug");
+	pwtest_ptr_null(data.topic);
+	data.invoked = false;
+
+	spa_log_info(&log, "spa_log_info");
+	pwtest_bool_true(data.invoked);
+	pwtest_str_eq(data.msg, "spa_log_info");
+	pwtest_ptr_null(data.topic);
+	data.invoked = false;
+
+	spa_log_warn(&log, "spa_log_warn");
+	pwtest_bool_true(data.invoked);
+	pwtest_str_eq(data.msg, "spa_log_warn");
+	pwtest_ptr_null(data.topic);
+	data.invoked = false;
+
+	spa_logt_debug(&log, &topic, "spa_logt_debug");
+	pwtest_bool_false(data.invoked);
+	data.invoked = false;
+
+	spa_logt_info(&log, &topic, "spa_logt_info");
+	pwtest_bool_true(data.invoked);
+	pwtest_str_eq(data.msg, "spa_logt_info");
+	pwtest_ptr_eq(data.topic, &topic);
+	data.invoked = false;
+
+	spa_logt_warn(&log, &topic, "spa_logt_warn");
+	pwtest_bool_true(data.invoked);
+	pwtest_str_eq(data.msg, "spa_logt_warn");
+	pwtest_ptr_eq(data.topic, &topic);
+	data.invoked = false;
+
+	return PWTEST_PASS;
+}
+
+PWTEST_SUITE(spa_log)
+{
+	pwtest_add(utils_log_logt, PWTEST_NOARG);
+	pwtest_add(utils_log_logt_levels, PWTEST_NOARG);
+
+	return PWTEST_PASS;
+}
diff --git a/test/test-spa-node.c b/test/test-spa-node.c
new file mode 100644
index 0000000..196bd03
--- /dev/null
+++ b/test/test-spa-node.c
@@ -0,0 +1,251 @@
+/* Simple Plugin API
+ *
+ * Copyright © 2019 Wim Taymans <wim.taymans@gmail.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 <spa/utils/defs.h>
+#include <spa/node/node.h>
+#include <spa/node/io.h>
+#include <spa/node/command.h>
+#include <spa/node/event.h>
+
+#include "pwtest.h"
+
+PWTEST(node_io_abi_sizes)
+{
+#if defined(__x86_64__) && defined(__LP64__)
+	pwtest_int_eq(sizeof(struct spa_io_buffers), 8U);
+	pwtest_int_eq(sizeof(struct spa_io_memory), 16U);
+	pwtest_int_eq(sizeof(struct spa_io_range), 16U);
+	pwtest_int_eq(sizeof(struct spa_io_clock), 160U);
+	pwtest_int_eq(sizeof(struct spa_io_latency), 24U);
+	pwtest_int_eq(sizeof(struct spa_io_sequence), 16U);
+	pwtest_int_eq(sizeof(struct spa_io_segment_bar), 64U);
+	pwtest_int_eq(sizeof(struct spa_io_segment_video), 80U);
+	pwtest_int_eq(sizeof(struct spa_io_segment), 184U);
+
+	pwtest_int_eq(sizeof(struct spa_io_position), 1688U);
+	pwtest_int_eq(sizeof(struct spa_io_rate_match), 48U);
+
+	spa_assert_se(sizeof(struct spa_node_info) == 48);
+	spa_assert_se(sizeof(struct spa_port_info) == 48);
+
+	spa_assert_se(sizeof(struct spa_result_node_error) == 8);
+	spa_assert_se(sizeof(struct spa_result_node_params) == 24);
+
+	return PWTEST_PASS;
+#else
+	fprintf(stderr, "%zd\n", sizeof(struct spa_io_buffers));
+	fprintf(stderr, "%zd\n", sizeof(struct spa_io_memory));
+	fprintf(stderr, "%zd\n", sizeof(struct spa_io_range));
+	fprintf(stderr, "%zd\n", sizeof(struct spa_io_clock));
+	fprintf(stderr, "%zd\n", sizeof(struct spa_io_latency));
+	fprintf(stderr, "%zd\n", sizeof(struct spa_io_sequence));
+	fprintf(stderr, "%zd\n", sizeof(struct spa_io_segment_bar));
+	fprintf(stderr, "%zd\n", sizeof(struct spa_io_segment_video));
+	fprintf(stderr, "%zd\n", sizeof(struct spa_io_segment));
+
+	fprintf(stderr, "%zd\n", sizeof(struct spa_io_position));
+	fprintf(stderr, "%zd\n", sizeof(struct spa_io_rate_match));
+
+	fprintf(stderr, "%zd\n", sizeof(struct spa_node_info));
+	fprintf(stderr, "%zd\n", sizeof(struct spa_port_info));
+
+	fprintf(stderr, "%zd\n", sizeof(struct spa_result_node_error));
+	fprintf(stderr, "%zd\n", sizeof(struct spa_result_node_params));
+
+	return PWTEST_SKIP;
+#endif
+
+}
+
+PWTEST(node_io_abi)
+{
+	/* io */
+	pwtest_int_eq(SPA_IO_Invalid, 0);
+	pwtest_int_eq(SPA_IO_Buffers, 1);
+	pwtest_int_eq(SPA_IO_Range, 2);
+	pwtest_int_eq(SPA_IO_Clock, 3);
+	pwtest_int_eq(SPA_IO_Latency, 4);
+	pwtest_int_eq(SPA_IO_Control, 5);
+	pwtest_int_eq(SPA_IO_Notify, 6);
+	pwtest_int_eq(SPA_IO_Position, 7);
+	pwtest_int_eq(SPA_IO_RateMatch, 8);
+	pwtest_int_eq(SPA_IO_Memory, 9);
+
+	/* position state */
+	pwtest_int_eq(SPA_IO_POSITION_STATE_STOPPED, 0);
+	pwtest_int_eq(SPA_IO_POSITION_STATE_STARTING, 1);
+	pwtest_int_eq(SPA_IO_POSITION_STATE_RUNNING, 2);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(node_command_abi)
+{
+	pwtest_int_eq(SPA_NODE_COMMAND_Suspend, 0);
+	pwtest_int_eq(SPA_NODE_COMMAND_Pause, 1);
+	pwtest_int_eq(SPA_NODE_COMMAND_Start, 2);
+	pwtest_int_eq(SPA_NODE_COMMAND_Enable, 3);
+	pwtest_int_eq(SPA_NODE_COMMAND_Disable, 4);
+	pwtest_int_eq(SPA_NODE_COMMAND_Flush, 5);
+	pwtest_int_eq(SPA_NODE_COMMAND_Drain, 6);
+	pwtest_int_eq(SPA_NODE_COMMAND_Marker, 7);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(node_event_abi)
+{
+	pwtest_int_eq(SPA_NODE_EVENT_Error, 0);
+	pwtest_int_eq(SPA_NODE_EVENT_Buffering, 1);
+	pwtest_int_eq(SPA_NODE_EVENT_RequestRefresh, 2);
+
+	return PWTEST_PASS;
+}
+
+#define TEST_FUNC(a,b,func, id)							\
+do {										\
+	off_t diff = SPA_PTRDIFF(&a.func, &a);					\
+	a.func = b.func;							\
+	pwtest_ptr_eq(diff, SPA_PTRDIFF(&b.func, &b));				\
+	pwtest_bool_true(diff == 0 || (diff-1)/sizeof(void*) == id);		\
+} while(0)
+
+PWTEST(node_node_abi)
+{
+	struct spa_node_events e;
+	struct spa_node_callbacks c;
+	struct spa_node_methods m;
+	struct {
+		uint32_t version;
+		void (*info) (void *data, const struct spa_node_info *info);
+		void (*port_info) (void *data,
+			enum spa_direction direction, uint32_t port,
+			const struct spa_port_info *info);
+		void (*result) (void *data, int seq, int res,
+			uint32_t type, const void *result);
+		void (*event) (void *data, const struct spa_event *event);
+	} events = { SPA_VERSION_NODE_EVENTS, };
+	struct {
+		uint32_t version;
+		int (*ready) (void *data, int state);
+		int (*reuse_buffer) (void *data,
+				uint32_t port_id,
+				uint32_t buffer_id);
+		int (*xrun) (void *data, uint64_t trigger, uint64_t delay,
+				struct spa_pod *info);
+	} callbacks = { SPA_VERSION_NODE_CALLBACKS, };
+	struct {
+		uint32_t version;
+		int (*add_listener) (void *object,
+			struct spa_hook *listener,
+			const struct spa_node_events *events,
+			void *data);
+		int (*set_callbacks) (void *object,
+			const struct spa_node_callbacks *callbacks,
+			void *data);
+		int (*sync) (void *object, int seq);
+		int (*enum_params) (void *object, int seq,
+			uint32_t id, uint32_t start, uint32_t max,
+			const struct spa_pod *filter);
+		int (*set_param) (void *object,
+			uint32_t id, uint32_t flags,
+			const struct spa_pod *param);
+		int (*set_io) (void *object,
+			uint32_t id, void *data, size_t size);
+		int (*send_command) (void *object, const struct spa_command *command);
+		int (*add_port) (void *object,
+			enum spa_direction direction, uint32_t port_id,
+			const struct spa_dict *props);
+		int (*remove_port) (void *object,
+			enum spa_direction direction, uint32_t port_id);
+		int (*port_enum_params) (void *object, int seq,
+			enum spa_direction direction, uint32_t port_id,
+			uint32_t id, uint32_t start, uint32_t max,
+			const struct spa_pod *filter);
+		int (*port_set_param) (void *object,
+			enum spa_direction direction,
+			uint32_t port_id,
+			uint32_t id, uint32_t flags,
+			const struct spa_pod *param);
+		int (*port_use_buffers) (void *object,
+			enum spa_direction direction,
+			uint32_t port_id,
+			uint32_t flags,
+			struct spa_buffer **buffers,
+			uint32_t n_buffers);
+		int (*port_set_io) (void *object,
+			enum spa_direction direction,
+			uint32_t port_id,
+			uint32_t id,
+			void *data, size_t size);
+		int (*port_reuse_buffer) (void *object, uint32_t port_id, uint32_t buffer_id);
+		int (*process) (void *object);
+	} methods = { SPA_VERSION_NODE_METHODS, 0 };
+
+	TEST_FUNC(e, events, version, 0);
+	TEST_FUNC(e, events, info, SPA_NODE_EVENT_INFO);
+	TEST_FUNC(e, events, port_info, SPA_NODE_EVENT_PORT_INFO);
+	TEST_FUNC(e, events, result, SPA_NODE_EVENT_RESULT);
+	TEST_FUNC(e, events, event, SPA_NODE_EVENT_EVENT);
+	pwtest_int_eq(SPA_NODE_EVENT_NUM, 4);
+	pwtest_int_eq(sizeof(e), sizeof(events));
+
+	TEST_FUNC(c, callbacks, version, 0);
+	TEST_FUNC(c, callbacks, ready, SPA_NODE_CALLBACK_READY);
+	TEST_FUNC(c, callbacks, reuse_buffer, SPA_NODE_CALLBACK_REUSE_BUFFER);
+	TEST_FUNC(c, callbacks, xrun, SPA_NODE_CALLBACK_XRUN);
+	pwtest_int_eq(SPA_NODE_CALLBACK_NUM, 3);
+	pwtest_int_eq(sizeof(c), sizeof(callbacks));
+
+	TEST_FUNC(m, methods, version, 0);
+	TEST_FUNC(m, methods, add_listener, SPA_NODE_METHOD_ADD_LISTENER);
+	TEST_FUNC(m, methods, set_callbacks, SPA_NODE_METHOD_SET_CALLBACKS);
+	TEST_FUNC(m, methods, sync, SPA_NODE_METHOD_SYNC);
+	TEST_FUNC(m, methods, enum_params, SPA_NODE_METHOD_ENUM_PARAMS);
+	TEST_FUNC(m, methods, set_param, SPA_NODE_METHOD_SET_PARAM);
+	TEST_FUNC(m, methods, set_io, SPA_NODE_METHOD_SET_IO);
+	TEST_FUNC(m, methods, send_command, SPA_NODE_METHOD_SEND_COMMAND);
+	TEST_FUNC(m, methods, add_port, SPA_NODE_METHOD_ADD_PORT);
+	TEST_FUNC(m, methods, remove_port, SPA_NODE_METHOD_REMOVE_PORT);
+	TEST_FUNC(m, methods, port_enum_params, SPA_NODE_METHOD_PORT_ENUM_PARAMS);
+	TEST_FUNC(m, methods, port_use_buffers, SPA_NODE_METHOD_PORT_USE_BUFFERS);
+	TEST_FUNC(m, methods, port_set_io, SPA_NODE_METHOD_PORT_SET_IO);
+	TEST_FUNC(m, methods, port_reuse_buffer, SPA_NODE_METHOD_PORT_REUSE_BUFFER);
+	TEST_FUNC(m, methods, process, SPA_NODE_METHOD_PROCESS);
+	pwtest_int_eq(SPA_NODE_METHOD_NUM, 15);
+	pwtest_int_eq(sizeof(m), sizeof(methods));
+
+	return PWTEST_PASS;
+}
+
+PWTEST_SUITE(spa_node)
+{
+	pwtest_add(node_io_abi_sizes, PWTEST_NOARG);
+	pwtest_add(node_io_abi, PWTEST_NOARG);
+	pwtest_add(node_command_abi, PWTEST_NOARG);
+	pwtest_add(node_event_abi, PWTEST_NOARG);
+	pwtest_add(node_node_abi, PWTEST_NOARG);
+
+	return PWTEST_PASS;
+}
diff --git a/test/test-spa-pod.c b/test/test-spa-pod.c
new file mode 100644
index 0000000..24c3303
--- /dev/null
+++ b/test/test-spa-pod.c
@@ -0,0 +1,1706 @@
+/* Simple Plugin API
+ * Copyright © 2019 Wim Taymans <wim.taymans@gmail.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 <spa/pod/pod.h>
+#include <spa/pod/builder.h>
+#include <spa/pod/command.h>
+#include <spa/pod/event.h>
+#include <spa/pod/iter.h>
+#include <spa/pod/parser.h>
+#include <spa/pod/vararg.h>
+#include <spa/debug/pod.h>
+#include <spa/param/format.h>
+#include <spa/param/video/raw.h>
+#include <spa/utils/string.h>
+
+#include "pwtest.h"
+
+PWTEST(pod_abi_sizes)
+{
+#if defined(__x86_64__) && defined(__LP64__)
+	spa_assert_se(sizeof(struct spa_pod) == 8);
+	spa_assert_se(sizeof(struct spa_pod_bool) == 16);
+	spa_assert_se(sizeof(struct spa_pod_id) == 16);
+	spa_assert_se(sizeof(struct spa_pod_int) == 16);
+	spa_assert_se(sizeof(struct spa_pod_long) == 16);
+	spa_assert_se(sizeof(struct spa_pod_float) == 16);
+	spa_assert_se(sizeof(struct spa_pod_double) == 16);
+	spa_assert_se(sizeof(struct spa_pod_string) == 8);
+	spa_assert_se(sizeof(struct spa_pod_bytes) == 8);
+	spa_assert_se(sizeof(struct spa_pod_rectangle) == 16);
+	spa_assert_se(sizeof(struct spa_pod_fraction) == 16);
+	spa_assert_se(sizeof(struct spa_pod_bitmap) == 8);
+	spa_assert_se(sizeof(struct spa_pod_array_body) == 8);
+	spa_assert_se(sizeof(struct spa_pod_array) == 16);
+
+	spa_assert_se(sizeof(struct spa_pod_choice_body) == 16);
+	spa_assert_se(sizeof(struct spa_pod_choice) == 24);
+	spa_assert_se(sizeof(struct spa_pod_struct) == 8);
+	spa_assert_se(sizeof(struct spa_pod_object_body) == 8);
+	spa_assert_se(sizeof(struct spa_pod_object) == 16);
+	spa_assert_se(sizeof(struct spa_pod_pointer_body) == 16);
+	spa_assert_se(sizeof(struct spa_pod_pointer) == 24);
+	spa_assert_se(sizeof(struct spa_pod_fd) == 16);
+	spa_assert_se(sizeof(struct spa_pod_prop) == 16);
+	spa_assert_se(sizeof(struct spa_pod_control) == 16);
+	spa_assert_se(sizeof(struct spa_pod_sequence_body) == 8);
+	spa_assert_se(sizeof(struct spa_pod_sequence) == 16);
+
+	/* builder */
+	spa_assert_se(sizeof(struct spa_pod_frame) == 24);
+	spa_assert_se(sizeof(struct spa_pod_builder_state) == 16);
+	spa_assert_se(sizeof(struct spa_pod_builder) == 48);
+
+	/* command */
+	spa_assert_se(sizeof(struct spa_command_body) == 8);
+	spa_assert_se(sizeof(struct spa_command) == 16);
+
+	/* event */
+	spa_assert_se(sizeof(struct spa_event_body) == 8);
+	spa_assert_se(sizeof(struct spa_event) == 16);
+
+	/* parser */
+	spa_assert_se(sizeof(struct spa_pod_parser_state) == 16);
+	spa_assert_se(sizeof(struct spa_pod_parser) == 32);
+
+	return PWTEST_PASS;
+#endif
+	return PWTEST_SKIP;
+}
+
+PWTEST(pod_abi)
+{
+	spa_assert_se(SPA_CHOICE_None == 0);
+	spa_assert_se(SPA_CHOICE_Range == 1);
+	spa_assert_se(SPA_CHOICE_Step == 2);
+	spa_assert_se(SPA_CHOICE_Enum == 3);
+	spa_assert_se(SPA_CHOICE_Flags == 4);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(pod_init)
+{
+	{
+		struct spa_pod pod = SPA_POD_INIT(sizeof(int64_t), SPA_TYPE_Long);
+		int32_t val;
+
+		spa_assert_se(SPA_POD_SIZE(&pod) == sizeof(int64_t) + 8);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Long);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == sizeof(int64_t));
+		spa_assert_se(SPA_POD_CONTENTS_SIZE(struct spa_pod, &pod) == sizeof(int64_t));
+		spa_assert_se(spa_pod_is_long(&pod));
+
+		pod = SPA_POD_INIT(sizeof(int32_t), SPA_TYPE_Int);
+		spa_assert_se(SPA_POD_SIZE(&pod) == sizeof(int32_t) + 8);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Int);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == sizeof(int32_t));
+		spa_assert_se(SPA_POD_CONTENTS_SIZE(struct spa_pod, &pod) == sizeof(int32_t));
+		spa_assert_se(spa_pod_is_int(&pod));
+
+		/** too small */
+		pod = SPA_POD_INIT(0, SPA_TYPE_Int);
+		spa_assert_se(!spa_pod_is_int(&pod));
+		spa_assert_se(spa_pod_get_int(&pod, &val) < 0);
+	}
+	{
+		struct spa_pod pod = SPA_POD_INIT_None();
+
+		spa_assert_se(SPA_POD_SIZE(&pod) == 8);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_None);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 0);
+		spa_assert_se(SPA_POD_CONTENTS_SIZE(struct spa_pod, &pod) == 0);
+		spa_assert_se(spa_pod_is_none(&pod));
+	}
+	{
+		struct spa_pod_bool pod = SPA_POD_INIT_Bool(true);
+		bool val;
+
+		spa_assert_se(SPA_POD_SIZE(&pod) == 12);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Bool);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 4);
+		spa_assert_se(SPA_POD_VALUE(struct spa_pod_bool, &pod) == true);
+		spa_assert_se(spa_pod_is_bool(&pod.pod));
+		spa_assert_se(spa_pod_get_bool(&pod.pod, &val) == 0);
+		spa_assert_se(val == true);
+
+		pod = SPA_POD_INIT_Bool(false);
+		spa_assert_se(SPA_POD_SIZE(&pod) == 12);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Bool);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 4);
+		spa_assert_se(SPA_POD_VALUE(struct spa_pod_bool, &pod) == false);
+		spa_assert_se(spa_pod_is_bool(&pod.pod));
+		spa_assert_se(spa_pod_get_bool(&pod.pod, &val) == 0);
+		spa_assert_se(val == false);
+
+		pod.pod = SPA_POD_INIT(0, SPA_TYPE_Bool);
+		spa_assert_se(!spa_pod_is_bool(&pod.pod));
+		spa_assert_se(spa_pod_get_bool(&pod.pod, &val) < 0);
+	}
+	{
+		struct spa_pod_id pod = SPA_POD_INIT_Id(SPA_TYPE_Int);
+		uint32_t val;
+
+		spa_assert_se(SPA_POD_SIZE(&pod) == 12);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Id);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 4);
+		spa_assert_se(SPA_POD_VALUE(struct spa_pod_id, &pod) == SPA_TYPE_Int);
+		spa_assert_se(spa_pod_is_id(&pod.pod));
+		spa_assert_se(spa_pod_get_id(&pod.pod, &val) == 0);
+		spa_assert_se(val == SPA_TYPE_Int);
+
+		pod = SPA_POD_INIT_Id(SPA_TYPE_Long);
+		spa_assert_se(SPA_POD_SIZE(&pod) == 12);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Id);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 4);
+		spa_assert_se(SPA_POD_VALUE(struct spa_pod_id, &pod) == SPA_TYPE_Long);
+		spa_assert_se(spa_pod_is_id(&pod.pod));
+		spa_assert_se(spa_pod_get_id(&pod.pod, &val) == 0);
+		spa_assert_se(val == SPA_TYPE_Long);
+
+		pod.pod = SPA_POD_INIT(0, SPA_TYPE_Id);
+		spa_assert_se(!spa_pod_is_id(&pod.pod));
+		spa_assert_se(spa_pod_get_id(&pod.pod, &val) < 0);
+	}
+	{
+		struct spa_pod_int pod = SPA_POD_INIT_Int(23);
+		int32_t val;
+
+		spa_assert_se(SPA_POD_SIZE(&pod) == 12);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Int);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 4);
+		spa_assert_se(SPA_POD_VALUE(struct spa_pod_int, &pod) == 23);
+		spa_assert_se(spa_pod_is_int(&pod.pod));
+		spa_assert_se(spa_pod_get_int(&pod.pod, &val) == 0);
+		spa_assert_se(val == 23);
+
+		pod = SPA_POD_INIT_Int(-123);
+		spa_assert_se(SPA_POD_SIZE(&pod) == 12);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Int);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 4);
+		spa_assert_se(SPA_POD_VALUE(struct spa_pod_int, &pod) == -123);
+		spa_assert_se(spa_pod_is_int(&pod.pod));
+		spa_assert_se(spa_pod_get_int(&pod.pod, &val) == 0);
+		spa_assert_se(val == -123);
+
+		pod.pod = SPA_POD_INIT(0, SPA_TYPE_Int);
+		spa_assert_se(!spa_pod_is_int(&pod.pod));
+		spa_assert_se(spa_pod_get_int(&pod.pod, &val) < 0);
+	}
+	{
+		struct spa_pod_long pod = SPA_POD_INIT_Long(-23);
+		int64_t val;
+
+		spa_assert_se(SPA_POD_SIZE(&pod) == 16);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Long);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 8);
+		spa_assert_se(SPA_POD_VALUE(struct spa_pod_long, &pod) == -23);
+		spa_assert_se(spa_pod_is_long(&pod.pod));
+		spa_assert_se(spa_pod_get_long(&pod.pod, &val) == 0);
+		spa_assert_se(val == -23);
+
+		pod = SPA_POD_INIT_Long(123);
+		spa_assert_se(SPA_POD_SIZE(&pod) == 16);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Long);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 8);
+		spa_assert_se(SPA_POD_VALUE(struct spa_pod_long, &pod) == 123);
+		spa_assert_se(spa_pod_is_long(&pod.pod));
+		spa_assert_se(spa_pod_get_long(&pod.pod, &val) == 0);
+		spa_assert_se(val == 123);
+
+		pod.pod = SPA_POD_INIT(0, SPA_TYPE_Long);
+		spa_assert_se(!spa_pod_is_long(&pod.pod));
+		spa_assert_se(spa_pod_get_long(&pod.pod, &val) < 0);
+	}
+	{
+		struct spa_pod_float pod = SPA_POD_INIT_Float(0.67f);
+		float val;
+
+		spa_assert_se(SPA_POD_SIZE(&pod) == 12);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Float);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 4);
+		spa_assert_se(SPA_POD_VALUE(struct spa_pod_float, &pod) == 0.67f);
+		spa_assert_se(spa_pod_is_float(&pod.pod));
+		spa_assert_se(spa_pod_get_float(&pod.pod, &val) == 0);
+		spa_assert_se(val == 0.67f);
+
+		pod = SPA_POD_INIT_Float(-134.8f);
+		spa_assert_se(SPA_POD_SIZE(&pod) == 12);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Float);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 4);
+		spa_assert_se(SPA_POD_VALUE(struct spa_pod_float, &pod) == -134.8f);
+		spa_assert_se(spa_pod_is_float(&pod.pod));
+		spa_assert_se(spa_pod_get_float(&pod.pod, &val) == 0);
+		spa_assert_se(val == -134.8f);
+
+		pod.pod = SPA_POD_INIT(0, SPA_TYPE_Float);
+		spa_assert_se(!spa_pod_is_float(&pod.pod));
+		spa_assert_se(spa_pod_get_float(&pod.pod, &val) < 0);
+	}
+	{
+		struct spa_pod_double pod = SPA_POD_INIT_Double(0.67);
+		double val;
+
+		spa_assert_se(SPA_POD_SIZE(&pod) == 16);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Double);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 8);
+		spa_assert_se(SPA_POD_VALUE(struct spa_pod_double, &pod) == 0.67);
+		spa_assert_se(spa_pod_is_double(&pod.pod));
+		spa_assert_se(spa_pod_get_double(&pod.pod, &val) == 0);
+		spa_assert_se(val == 0.67);
+
+		pod = SPA_POD_INIT_Double(-134.8);
+		spa_assert_se(SPA_POD_SIZE(&pod) == 16);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Double);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 8);
+		spa_assert_se(SPA_POD_VALUE(struct spa_pod_double, &pod) == -134.8);
+		spa_assert_se(spa_pod_is_double(&pod.pod));
+		spa_assert_se(spa_pod_get_double(&pod.pod, &val) == 0);
+		spa_assert_se(val == -134.8);
+
+		pod.pod = SPA_POD_INIT(0, SPA_TYPE_Double);
+		spa_assert_se(!spa_pod_is_double(&pod.pod));
+		spa_assert_se(spa_pod_get_double(&pod.pod, &val) < 0);
+	}
+	{
+		struct {
+			struct spa_pod_string pod;
+			char str[9];
+		} pod;
+		char val[12];
+
+		pod.pod	= SPA_POD_INIT_String(9);
+		strncpy(pod.str, "test", 9);
+
+		spa_assert_se(SPA_POD_SIZE(&pod) == 17);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_String);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 9);
+		spa_assert_se(spa_pod_is_string(&pod.pod.pod));
+		spa_assert_se(spa_pod_copy_string(&pod.pod.pod, sizeof(val), val) == 0);
+		spa_assert_se(spa_streq(pod.str, val));
+
+		pod.pod	= SPA_POD_INIT_String(6);
+		memcpy(pod.str, "test123456789", 9);
+
+		spa_assert_se(SPA_POD_SIZE(&pod) == 14);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_String);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 6);
+		spa_assert_se(!spa_pod_is_string(&pod.pod.pod));
+		spa_assert_se(spa_pod_copy_string(&pod.pod.pod, sizeof(val), val) < 0);
+	}
+	{
+		struct spa_pod_rectangle pod = SPA_POD_INIT_Rectangle(SPA_RECTANGLE(320,240));
+		struct spa_rectangle val;
+
+		spa_assert_se(SPA_POD_SIZE(&pod) == 16);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Rectangle);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 8);
+		spa_assert_se(memcmp(&SPA_POD_VALUE(struct spa_pod_rectangle, &pod),
+					&SPA_RECTANGLE(320,240), sizeof(struct spa_rectangle)) == 0);
+		spa_assert_se(spa_pod_is_rectangle(&pod.pod));
+		spa_assert_se(spa_pod_get_rectangle(&pod.pod, &val) == 0);
+		spa_assert_se(memcmp(&val, &SPA_RECTANGLE(320,240), sizeof(struct spa_rectangle)) == 0);
+
+		pod.pod = SPA_POD_INIT(0, SPA_TYPE_Rectangle);
+		spa_assert_se(!spa_pod_is_rectangle(&pod.pod));
+		spa_assert_se(spa_pod_get_rectangle(&pod.pod, &val) < 0);
+	}
+	{
+		struct spa_pod_fraction pod = SPA_POD_INIT_Fraction(SPA_FRACTION(25,1));
+		struct spa_fraction val;
+
+		spa_assert_se(SPA_POD_SIZE(&pod) == 16);
+		spa_assert_se(SPA_POD_TYPE(&pod) == SPA_TYPE_Fraction);
+		spa_assert_se(SPA_POD_BODY_SIZE(&pod) == 8);
+		spa_assert_se(memcmp(&SPA_POD_VALUE(struct spa_pod_fraction, &pod),
+					&SPA_FRACTION(25,1), sizeof(struct spa_fraction)) == 0);
+		spa_assert_se(spa_pod_is_fraction(&pod.pod));
+		spa_assert_se(spa_pod_get_fraction(&pod.pod, &val) == 0);
+		spa_assert_se(memcmp(&val, &SPA_FRACTION(25,1), sizeof(struct spa_fraction)) == 0);
+
+		pod.pod = SPA_POD_INIT(0, SPA_TYPE_Fraction);
+		spa_assert_se(!spa_pod_is_fraction(&pod.pod));
+		spa_assert_se(spa_pod_get_fraction(&pod.pod, &val) < 0);
+	}
+	return PWTEST_PASS;
+}
+
+PWTEST(pod_build)
+{
+	uint8_t buffer[4096];
+	struct spa_pod_builder b;
+	struct spa_pod *array, *choice, *head, *pod, *it;
+	const struct spa_pod_prop *prop;
+	struct spa_pod_control *control;
+	int64_t longs[] = { 5, 7, 11, 13, 17 }, *al;
+	uint32_t i, len, yl, *ai;
+	union {
+		bool b;
+		uint32_t I;
+		int32_t i;
+		int64_t l;
+		float f;
+		double d;
+		const char *s;
+		const void *y;
+		const void *p;
+		int64_t h;
+		struct spa_rectangle R;
+		struct spa_fraction F;
+	} val;
+	struct spa_pod_frame f;
+
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+	spa_assert_se(b.data == buffer);
+	spa_assert_se(b.size == sizeof(buffer));
+	spa_assert_se(b.state.offset == 0);
+	spa_assert_se(b.state.flags == 0);
+
+	spa_assert_se(spa_pod_builder_none(&b) == 0);
+	spa_assert_se(b.state.offset == 8);
+	spa_assert_se(spa_pod_builder_bool(&b, true) == 0);
+	spa_assert_se(b.state.offset == 24);
+	spa_assert_se(spa_pod_builder_id(&b, SPA_TYPE_Object) == 0);
+	spa_assert_se(b.state.offset == 40);
+	spa_assert_se(spa_pod_builder_int(&b, 21) == 0);
+	spa_assert_se(b.state.offset == 56);
+	spa_assert_se(spa_pod_builder_float(&b, 0.8f) == 0);
+	spa_assert_se(b.state.offset == 72);
+	spa_assert_se(spa_pod_builder_double(&b, -1.56) == 0);
+	spa_assert_se(b.state.offset == 88);
+	spa_assert_se(spa_pod_builder_string(&b, "test") == 0);
+	spa_assert_se(b.state.offset == 104);
+	spa_assert_se(spa_pod_builder_bytes(&b, "PipeWire", 8) == 0);
+	spa_assert_se(b.state.offset == 120);
+	spa_assert_se(spa_pod_builder_pointer(&b, SPA_TYPE_Object, &b) == 0);
+	spa_assert_se(b.state.offset == 144);
+	spa_assert_se(spa_pod_builder_fd(&b, 4) == 0);
+	spa_assert_se(b.state.offset == 160);
+	spa_assert_se(spa_pod_builder_rectangle(&b, 320, 240) == 0);
+	spa_assert_se(b.state.offset == 176);
+	spa_assert_se(spa_pod_builder_fraction(&b, 25, 1) == 0);
+
+	spa_assert_se(b.state.offset == 192);
+	spa_assert_se(spa_pod_builder_push_array(&b, &f) == 0);
+	spa_assert_se(f.offset == 192);
+	spa_assert_se(b.state.flags == (SPA_POD_BUILDER_FLAG_BODY | SPA_POD_BUILDER_FLAG_FIRST));
+	spa_assert_se(b.state.offset == 200);
+	spa_assert_se(spa_pod_builder_int(&b, 1) == 0);
+	spa_assert_se(b.state.flags == SPA_POD_BUILDER_FLAG_BODY);
+	spa_assert_se(b.state.offset == 212);
+	spa_assert_se(spa_pod_builder_int(&b, 2) == 0);
+	spa_assert_se(b.state.offset == 216);
+	spa_assert_se(spa_pod_builder_int(&b, 3) == 0);
+	array = spa_pod_builder_pop(&b, &f);
+	spa_assert_se(f.pod.size == 20);
+	spa_assert_se(array != NULL);
+	spa_assert_se(SPA_POD_BODY_SIZE(array) == 8 + 12);
+	spa_assert_se(b.state.flags == 0);
+
+	spa_assert_se(b.state.offset == 224);
+	spa_assert_se(spa_pod_builder_array(&b,
+				sizeof(int64_t), SPA_TYPE_Long,
+				SPA_N_ELEMENTS(longs), longs) == 0);
+	spa_assert_se(b.state.flags == 0);
+
+	spa_assert_se(b.state.offset == 280);
+	spa_assert_se(spa_pod_builder_push_choice(&b, &f, SPA_CHOICE_Enum, 0) == 0);
+	spa_assert_se(b.state.flags == (SPA_POD_BUILDER_FLAG_BODY | SPA_POD_BUILDER_FLAG_FIRST));
+	spa_assert_se(b.state.offset == 296);
+	spa_assert_se(spa_pod_builder_long(&b, 1) == 0);
+	spa_assert_se(b.state.flags == SPA_POD_BUILDER_FLAG_BODY);
+	spa_assert_se(b.state.offset == 312);
+	spa_assert_se(spa_pod_builder_long(&b, 2) == 0);
+	spa_assert_se(b.state.offset == 320);
+	spa_assert_se(spa_pod_builder_long(&b, 3) == 0);
+	choice = spa_pod_builder_pop(&b, &f);
+	spa_assert_se(choice != NULL);
+	spa_assert_se(b.state.flags == 0);
+
+	spa_assert_se(b.state.offset == 328);
+	spa_assert_se(spa_pod_builder_push_struct(&b, &f) == 0);
+	spa_assert_se(b.state.flags == 0);
+	spa_assert_se(b.state.offset == 336);
+	spa_assert_se(spa_pod_builder_int(&b, 21) == 0);
+	spa_assert_se(b.state.offset == 352);
+	spa_assert_se(spa_pod_builder_float(&b, 0.8f) == 0);
+	spa_assert_se(b.state.offset == 368);
+	spa_assert_se(spa_pod_builder_double(&b, -1.56) == 0);
+	spa_assert_se(spa_pod_builder_pop(&b, &f) != NULL);
+
+	spa_assert_se(b.state.offset == 384);
+	spa_assert_se(spa_pod_builder_push_object(&b, &f, SPA_TYPE_OBJECT_Props, 0) == 0);
+	spa_assert_se(b.state.flags == 0);
+	spa_assert_se(b.state.offset == 400);
+	spa_assert_se(spa_pod_builder_prop(&b, 1, 0) == 0);
+	spa_assert_se(b.state.flags == 0);
+	spa_assert_se(b.state.offset == 408);
+	spa_assert_se(spa_pod_builder_int(&b, 21) == 0);
+	spa_assert_se(b.state.flags == 0);
+	spa_assert_se(b.state.offset == 424);
+	spa_assert_se(spa_pod_builder_prop(&b, 2, 0) == 0);
+	spa_assert_se(b.state.flags == 0);
+	spa_assert_se(b.state.offset == 432);
+	spa_assert_se(spa_pod_builder_long(&b, 42) == 0);
+	spa_assert_se(b.state.flags == 0);
+	spa_assert_se(b.state.offset == 448);
+	spa_assert_se(spa_pod_builder_prop(&b, 3, 0) == 0);
+	spa_assert_se(b.state.offset == 456);
+	spa_assert_se(spa_pod_builder_string(&b, "test123") == 0);
+	spa_assert_se(spa_pod_builder_pop(&b, &f) != NULL);
+	spa_assert_se(b.state.flags == 0);
+
+	spa_assert_se(b.state.offset == 472);
+	spa_assert_se(spa_pod_builder_push_sequence(&b, &f, 0) == 0);
+	spa_assert_se(b.state.flags == 0);
+	spa_assert_se(b.state.offset == 488);
+	spa_assert_se(spa_pod_builder_control(&b, 0, 0) == 0);
+	spa_assert_se(b.state.flags == 0);
+	spa_assert_se(b.state.offset == 496);
+	spa_assert_se(spa_pod_builder_float(&b, 0.667f) == 0);
+	spa_assert_se(b.state.flags == 0);
+	spa_assert_se(b.state.offset == 512);
+	spa_assert_se(spa_pod_builder_control(&b, 12, 0) == 0);
+	spa_assert_se(b.state.flags == 0);
+	spa_assert_se(b.state.offset == 520);
+	spa_assert_se(spa_pod_builder_double(&b, 1.22) == 0);
+	spa_assert_se(b.state.flags == 0);
+	spa_assert_se(spa_pod_builder_pop(&b, &f) != NULL);
+	spa_assert_se(b.state.flags == 0);
+
+	spa_assert_se(b.state.offset == 536);
+
+	len = b.state.offset;
+	pod = head = (struct spa_pod *)buffer;
+
+	spa_assert_se(spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_none(pod));
+	spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_bool(pod));
+	spa_assert_se(spa_pod_get_bool(pod, &val.b) == 0);
+	spa_assert_se(val.b == true);
+	spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_id(pod));
+	spa_assert_se(spa_pod_get_id(pod, &val.I) == 0);
+	spa_assert_se(val.I == SPA_TYPE_Object);
+	spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_int(pod));
+	spa_assert_se(spa_pod_get_int(pod, &val.i) == 0);
+	spa_assert_se(val.i == 21);
+	spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_float(pod));
+	spa_assert_se(spa_pod_get_float(pod, &val.f) == 0);
+	spa_assert_se(val.f == 0.8f);
+	spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_double(pod));
+	spa_assert_se(spa_pod_get_double(pod, &val.d) == 0);
+	spa_assert_se(val.d == -1.56);
+	spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_string(pod));
+	spa_assert_se(spa_pod_get_string(pod, &val.s) == 0);
+	spa_assert_se(spa_streq(val.s, "test"));
+	spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_bytes(pod));
+	spa_assert_se(spa_pod_get_bytes(pod, &val.y, &yl) == 0);
+	spa_assert_se(yl == 8);
+	spa_assert_se(memcmp(val.y, "PipeWire", yl) == 0);
+	spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_pointer(pod));
+	spa_assert_se(spa_pod_get_pointer(pod, &yl, &val.p) == 0);
+	spa_assert_se(yl == SPA_TYPE_Object);
+	spa_assert_se(val.p == &b);
+	spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_fd(pod));
+	spa_assert_se(spa_pod_get_fd(pod, &val.l) == 0);
+	spa_assert_se(val.l == 4);
+	spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_rectangle(pod));
+	spa_assert_se(spa_pod_get_rectangle(pod, &val.R) == 0);
+	spa_assert_se(memcmp(&val.R, &SPA_RECTANGLE(320,240), sizeof(struct spa_rectangle)) == 0);
+	spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_fraction(pod));
+	spa_assert_se(spa_pod_get_fraction(pod, &val.F) == 0);
+	spa_assert_se(memcmp(&val.F, &SPA_FRACTION(25,1), sizeof(struct spa_fraction)) == 0);
+
+	spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_array(pod));
+	spa_assert_se(SPA_POD_ARRAY_VALUE_TYPE(pod) == SPA_TYPE_Int);
+	spa_assert_se(SPA_POD_ARRAY_VALUE_SIZE(pod) == sizeof(int32_t));
+	spa_assert_se(SPA_POD_ARRAY_N_VALUES(pod) == 3);
+	ai = SPA_POD_ARRAY_VALUES(pod);
+	spa_assert_se(ai != NULL);
+	spa_assert_se(SPA_POD_ARRAY_CHILD(pod)->type == SPA_TYPE_Int);
+	spa_assert_se(SPA_POD_ARRAY_CHILD(pod)->size == sizeof(int32_t));
+	spa_assert_se(ai[0] == 1);
+	spa_assert_se(ai[1] == 2);
+	spa_assert_se(ai[2] == 3);
+	i = 1;
+	SPA_POD_ARRAY_FOREACH((struct spa_pod_array*)pod, ai) {
+		spa_assert_se(*ai == i);
+		i++;
+	}
+
+	spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_array(pod));
+	spa_assert_se(SPA_POD_ARRAY_VALUE_TYPE(pod) == SPA_TYPE_Long);
+	spa_assert_se(SPA_POD_ARRAY_VALUE_SIZE(pod) == sizeof(int64_t));
+	spa_assert_se(SPA_POD_ARRAY_N_VALUES(pod) == SPA_N_ELEMENTS(longs));
+	al = SPA_POD_ARRAY_VALUES(pod);
+	spa_assert_se(al != NULL);
+	spa_assert_se(SPA_POD_ARRAY_CHILD(pod)->type == SPA_TYPE_Long);
+	spa_assert_se(SPA_POD_ARRAY_CHILD(pod)->size == sizeof(int64_t));
+	for (i = 0; i < SPA_N_ELEMENTS(longs); i++)
+		spa_assert_se(al[i] == longs[i]);
+	i = 0;
+	SPA_POD_ARRAY_FOREACH((struct spa_pod_array*)pod, al) {
+		spa_assert_se(*al == longs[i++]);
+	}
+
+	spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_choice(pod));
+	spa_assert_se(SPA_POD_CHOICE_TYPE(pod) == SPA_CHOICE_Enum);
+	spa_assert_se(SPA_POD_CHOICE_FLAGS(pod) == 0);
+	spa_assert_se(SPA_POD_CHOICE_VALUE_TYPE(pod) == SPA_TYPE_Long);
+	spa_assert_se(SPA_POD_CHOICE_VALUE_SIZE(pod) == sizeof(int64_t));
+	spa_assert_se(SPA_POD_CHOICE_N_VALUES(pod) == 3);
+	al = SPA_POD_CHOICE_VALUES(pod);
+	spa_assert_se(al != NULL);
+	spa_assert_se(SPA_POD_CHOICE_CHILD(pod)->type == SPA_TYPE_Long);
+	spa_assert_se(SPA_POD_CHOICE_CHILD(pod)->size == sizeof(int64_t));
+	spa_assert_se(al[0] == 1);
+	spa_assert_se(al[1] == 2);
+	spa_assert_se(al[2] == 3);
+	i = 1;
+	SPA_POD_CHOICE_FOREACH((struct spa_pod_choice*)pod, al) {
+		spa_assert_se(*al == i);
+		i++;
+	}
+
+	spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_struct(pod));
+	i = 0;
+	SPA_POD_STRUCT_FOREACH(pod, it) {
+		switch (i++) {
+		case 0:
+			spa_assert_se(spa_pod_is_int(it));
+			spa_assert_se(spa_pod_get_int(it, &val.i) == 0 && val.i == 21);
+			break;
+		case 1:
+			spa_assert_se(spa_pod_is_float(it));
+			spa_assert_se(spa_pod_get_float(it, &val.f) == 0 && val.f == 0.8f);
+			break;
+		case 2:
+			spa_assert_se(spa_pod_is_double(it));
+			spa_assert_se(spa_pod_get_double(it, &val.d) == 0 && val.d == -1.56);
+			break;
+		default:
+			spa_assert_not_reached();
+			break;
+		}
+	}
+
+	spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_object(pod));
+	spa_assert_se(spa_pod_is_object_type(pod, SPA_TYPE_OBJECT_Props));
+	spa_assert_se(spa_pod_is_object_id(pod, 0));
+	i = 0;
+	SPA_POD_OBJECT_FOREACH((const struct spa_pod_object*)pod, prop) {
+		switch (i++) {
+		case 0:
+			spa_assert_se(prop->key == 1);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 20);
+			spa_assert_se(spa_pod_get_int(&prop->value, &val.i) == 0 && val.i == 21);
+			break;
+		case 1:
+			spa_assert_se(prop->key == 2);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 24);
+			spa_assert_se(spa_pod_get_long(&prop->value, &val.l) == 0 && val.l == 42);
+			break;
+		case 2:
+			spa_assert_se(prop->key == 3);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 24);
+			spa_assert_se(spa_pod_get_string(&prop->value, &val.s) == 0 &&
+					spa_streq(val.s, "test123"));
+			break;
+		default:
+			spa_assert_not_reached();
+			break;
+		}
+	}
+	prop = spa_pod_find_prop(pod, NULL, 3);
+	spa_assert_se(prop != NULL);
+	spa_assert_se(prop->key == 3);
+	spa_assert_se(spa_pod_get_string(&prop->value, &val.s) == 0 &&
+				spa_streq(val.s, "test123"));
+	prop = spa_pod_find_prop(pod, prop, 1);
+	spa_assert_se(prop != NULL);
+	spa_assert_se(prop->key == 1);
+	spa_assert_se(spa_pod_get_int(&prop->value, &val.i) == 0 && val.i == 21);
+	prop = spa_pod_find_prop(pod, prop, 2);
+	spa_assert_se(prop != NULL);
+	spa_assert_se(prop->key == 2);
+	spa_assert_se(spa_pod_get_long(&prop->value, &val.l) == 0 && val.l == 42);
+	prop = spa_pod_find_prop(pod, prop, 5);
+	spa_assert_se(prop == NULL);
+
+	prop = spa_pod_find_prop(pod, NULL, 3);
+	spa_assert_se(prop != NULL);
+	spa_assert_se(prop->key == 3);
+	spa_assert_se(spa_pod_get_string(&prop->value, &val.s) == 0 &&
+				spa_streq(val.s, "test123"));
+
+	spa_assert_se((pod = spa_pod_next(pod)) != NULL && spa_pod_is_inside(head, len, pod));
+	spa_assert_se(spa_pod_is_sequence(pod));
+
+	i = 0;
+	SPA_POD_SEQUENCE_FOREACH((const struct spa_pod_sequence*)pod, control) {
+		switch (i++) {
+		case 0:
+			spa_assert_se(control->offset == 0);
+			spa_assert_se(SPA_POD_CONTROL_SIZE(control) == 20);
+			spa_assert_se(spa_pod_get_float(&control->value, &val.f) == 0 && val.f == 0.667f);
+			break;
+		case 1:
+			spa_assert_se(control->offset == 12);
+			spa_assert_se(SPA_POD_CONTROL_SIZE(control) == 24);
+			spa_assert_se(spa_pod_get_double(&control->value, &val.d) == 0 && val.d == 1.22);
+			break;
+		default:
+			spa_assert_not_reached();
+			break;
+		}
+	}
+	return PWTEST_PASS;
+}
+
+PWTEST(pod_empty)
+{
+	uint8_t buffer[4096];
+	struct spa_pod_builder b;
+	struct spa_pod *array, *a2, *choice, *ch2;
+	struct spa_pod_frame f;
+	uint32_t n_vals, ch;
+
+	memset(buffer, 0xab, sizeof(buffer));
+
+	/* create empty arrays */
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+	spa_assert_se(spa_pod_builder_push_array(&b, &f) == 0);
+	spa_assert_se(spa_pod_builder_child(&b, sizeof(uint32_t), SPA_TYPE_Id) == 0);
+	array = spa_pod_builder_pop(&b, &f);
+	spa_assert_se(array != NULL);
+	spa_debug_mem(0, array, 16);
+	spa_assert_se(spa_pod_is_array(array));
+	a2 = spa_pod_get_array(array, &n_vals);
+	spa_assert_se(a2 != NULL);
+	spa_assert_se(n_vals == 0);
+
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+	spa_assert_se(spa_pod_builder_push_array(&b, &f) == 0);
+	array = spa_pod_builder_pop(&b, &f);
+	spa_assert_se(array != NULL);
+	spa_assert_se(spa_pod_is_array(array));
+	a2 = spa_pod_get_array(array, &n_vals);
+	spa_assert_se(a2 != NULL);
+	spa_assert_se(n_vals == 0);
+
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+	spa_assert_se(spa_pod_builder_push_array(&b, &f) == 0);
+	spa_assert_se(spa_pod_builder_none(&b) == 0);
+	array = spa_pod_builder_pop(&b, &f);
+	spa_assert_se(array != NULL);
+	spa_assert_se(spa_pod_is_array(array));
+	a2 = spa_pod_get_array(array, &n_vals);
+	spa_assert_se(a2 != NULL);
+	spa_assert_se(n_vals == 0);
+
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+	spa_assert_se(spa_pod_builder_array(&b, 4, SPA_TYPE_Id, 0, NULL) == 0);
+	array = (struct spa_pod*)buffer;
+	spa_assert_se(spa_pod_is_array(array));
+	a2 = spa_pod_get_array(array, &n_vals);
+	spa_assert_se(a2 != NULL);
+	spa_assert_se(n_vals == 0);
+
+	/* create empty choice */
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+	spa_assert_se(spa_pod_builder_push_choice(&b, &f, 0, 0) == 0);
+	spa_assert_se(spa_pod_builder_child(&b, sizeof(uint32_t), SPA_TYPE_Id) == 0);
+	choice = spa_pod_builder_pop(&b, &f);
+	spa_assert_se(choice != NULL);
+	spa_debug_mem(0, choice, 32);
+	spa_assert_se(spa_pod_is_choice(choice));
+	ch2 = spa_pod_get_values(choice, &n_vals, &ch);
+	spa_assert_se(ch2 != NULL);
+	spa_assert_se(n_vals == 0);
+
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+	spa_assert_se(spa_pod_builder_push_choice(&b, &f, 0, 0) == 0);
+	choice = spa_pod_builder_pop(&b, &f);
+	spa_assert_se(choice != NULL);
+	spa_assert_se(spa_pod_is_choice(choice));
+	ch2 = spa_pod_get_values(choice, &n_vals, &ch);
+	spa_assert_se(ch2 != NULL);
+	spa_assert_se(n_vals == 0);
+
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+	spa_assert_se(spa_pod_builder_push_choice(&b, &f, 0, 0) == 0);
+	spa_assert_se(spa_pod_builder_none(&b) == 0);
+	choice = spa_pod_builder_pop(&b, &f);
+	spa_assert_se(choice != NULL);
+	spa_assert_se(spa_pod_is_choice(choice));
+	ch2 = spa_pod_get_values(choice, &n_vals, &ch);
+	spa_assert_se(ch2 != NULL);
+	spa_assert_se(n_vals == 0);
+	return PWTEST_PASS;
+}
+
+PWTEST(pod_varargs)
+{
+	uint8_t buffer[4096];
+	struct spa_pod_builder b;
+	struct spa_pod *pod;
+	struct spa_pod_prop *prop;
+	uint32_t i, *aI;
+	union {
+		bool b;
+		uint32_t I;
+		int32_t i;
+		int64_t l;
+		float f;
+		double d;
+		const char *s;
+		const void *y;
+		const void *p;
+		int64_t h;
+		struct spa_rectangle R;
+		struct spa_fraction F;
+	} val;
+	uint32_t media_type, media_subtype, format;
+	int32_t views;
+	struct spa_rectangle *aR, size;
+	struct spa_fraction *aF, framerate;
+	struct spa_pod *Vformat, *Vsize, *Vframerate;
+
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+	pod = spa_pod_builder_add_object(&b,
+		SPA_TYPE_OBJECT_Format, 0,
+		SPA_FORMAT_mediaType,		SPA_POD_Id(SPA_MEDIA_TYPE_video),
+		SPA_FORMAT_mediaSubtype,	SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
+		SPA_FORMAT_VIDEO_format,	SPA_POD_CHOICE_ENUM_Id(3,
+							SPA_VIDEO_FORMAT_I420,
+							SPA_VIDEO_FORMAT_I420,
+							SPA_VIDEO_FORMAT_YUY2),
+		SPA_FORMAT_VIDEO_size,		SPA_POD_CHOICE_RANGE_Rectangle(
+							&SPA_RECTANGLE(320,242),
+							&SPA_RECTANGLE(1,1),
+							&SPA_RECTANGLE(INT32_MAX,INT32_MAX)),
+		SPA_FORMAT_VIDEO_framerate,	SPA_POD_CHOICE_RANGE_Fraction(
+							&SPA_FRACTION(25,1),
+							&SPA_FRACTION(0,1),
+							&SPA_FRACTION(INT32_MAX,1)));
+
+	i = 0;
+	SPA_POD_OBJECT_FOREACH((const struct spa_pod_object*)pod, prop) {
+		switch (i++) {
+		case 0:
+			spa_assert_se(prop->key == SPA_FORMAT_mediaType);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 20);
+			spa_assert_se(spa_pod_get_id(&prop->value, &val.I) == 0 && val.I == SPA_MEDIA_TYPE_video);
+			break;
+		case 1:
+			spa_assert_se(prop->key == SPA_FORMAT_mediaSubtype);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 20);
+			spa_assert_se(spa_pod_get_id(&prop->value, &val.I) == 0 && val.I == SPA_MEDIA_SUBTYPE_raw);
+			break;
+		case 2:
+			spa_assert_se(prop->key == SPA_FORMAT_VIDEO_format);
+			spa_assert_se(spa_pod_is_choice(&prop->value));
+			spa_assert_se(SPA_POD_CHOICE_TYPE(&prop->value) == SPA_CHOICE_Enum);
+			spa_assert_se(SPA_POD_CHOICE_N_VALUES(&prop->value) == 3);
+			spa_assert_se(SPA_POD_CHOICE_VALUE_TYPE(&prop->value) == SPA_TYPE_Id);
+			spa_assert_se(SPA_POD_CHOICE_VALUE_SIZE(&prop->value) == sizeof(uint32_t));
+			aI = SPA_POD_CHOICE_VALUES(&prop->value);
+			spa_assert_se(aI != NULL);
+			spa_assert_se(aI[0] == SPA_VIDEO_FORMAT_I420);
+			spa_assert_se(aI[1] == SPA_VIDEO_FORMAT_I420);
+			spa_assert_se(aI[2] == SPA_VIDEO_FORMAT_YUY2);
+			break;
+		case 3:
+			spa_assert_se(prop->key == SPA_FORMAT_VIDEO_size);
+			spa_assert_se(spa_pod_is_choice(&prop->value));
+			spa_assert_se(SPA_POD_CHOICE_TYPE(&prop->value) == SPA_CHOICE_Range);
+			spa_assert_se(SPA_POD_CHOICE_N_VALUES(&prop->value) == 3);
+			spa_assert_se(SPA_POD_CHOICE_VALUE_TYPE(&prop->value) == SPA_TYPE_Rectangle);
+			spa_assert_se(SPA_POD_CHOICE_VALUE_SIZE(&prop->value) == sizeof(struct spa_rectangle));
+			aR = SPA_POD_CHOICE_VALUES(&prop->value);
+			spa_assert_se(aR != NULL);
+			spa_assert_se(memcmp(&aR[0], &SPA_RECTANGLE(320,242), sizeof(struct spa_rectangle)) == 0);
+			spa_assert_se(memcmp(&aR[1], &SPA_RECTANGLE(1,1), sizeof(struct spa_rectangle)) == 0);
+			spa_assert_se(memcmp(&aR[2], &SPA_RECTANGLE(INT32_MAX,INT32_MAX), sizeof(struct spa_rectangle)) == 0);
+			break;
+		case 4:
+			spa_assert_se(prop->key == SPA_FORMAT_VIDEO_framerate);
+			spa_assert_se(spa_pod_is_choice(&prop->value));
+			spa_assert_se(SPA_POD_CHOICE_TYPE(&prop->value) == SPA_CHOICE_Range);
+			spa_assert_se(SPA_POD_CHOICE_N_VALUES(&prop->value) == 3);
+			spa_assert_se(SPA_POD_CHOICE_VALUE_TYPE(&prop->value) == SPA_TYPE_Fraction);
+			spa_assert_se(SPA_POD_CHOICE_VALUE_SIZE(&prop->value) == sizeof(struct spa_fraction));
+			aF = SPA_POD_CHOICE_VALUES(&prop->value);
+			spa_assert_se(aF != NULL);
+			spa_assert_se(memcmp(&aF[0], &SPA_FRACTION(25,1), sizeof(struct spa_fraction)) == 0);
+			spa_assert_se(memcmp(&aF[1], &SPA_FRACTION(0,1), sizeof(struct spa_fraction)) == 0);
+			spa_assert_se(memcmp(&aF[2], &SPA_FRACTION(INT32_MAX,1), sizeof(struct spa_fraction)) == 0);
+			break;
+		default:
+			spa_assert_not_reached();
+			break;
+		}
+	}
+
+	spa_assert_se(spa_pod_parse_object(pod,
+		SPA_TYPE_OBJECT_Format, NULL,
+		SPA_FORMAT_mediaType,		SPA_POD_Id(&media_type),
+		SPA_FORMAT_mediaSubtype,	SPA_POD_Id(&media_subtype),
+		SPA_FORMAT_VIDEO_format,	SPA_POD_PodChoice(&Vformat),
+		SPA_FORMAT_VIDEO_size,		SPA_POD_PodChoice(&Vsize),
+		SPA_FORMAT_VIDEO_framerate,	SPA_POD_PodChoice(&Vframerate)) == 5);
+
+	spa_assert_se(media_type == SPA_MEDIA_TYPE_video);
+	spa_assert_se(media_subtype == SPA_MEDIA_SUBTYPE_raw);
+
+	spa_assert_se(spa_pod_is_choice(Vformat));
+	spa_assert_se(SPA_POD_CHOICE_TYPE(Vformat) == SPA_CHOICE_Enum);
+	spa_assert_se(SPA_POD_CHOICE_N_VALUES(Vformat) == 3);
+	spa_assert_se(SPA_POD_CHOICE_VALUE_TYPE(Vformat) == SPA_TYPE_Id);
+	spa_assert_se(SPA_POD_CHOICE_VALUE_SIZE(Vformat) == sizeof(uint32_t));
+	aI = SPA_POD_CHOICE_VALUES(Vformat);
+	spa_assert_se(aI != NULL);
+	spa_assert_se(aI[0] == SPA_VIDEO_FORMAT_I420);
+	spa_assert_se(aI[1] == SPA_VIDEO_FORMAT_I420);
+	spa_assert_se(aI[2] == SPA_VIDEO_FORMAT_YUY2);
+
+	spa_assert_se(spa_pod_is_choice(Vsize));
+	spa_assert_se(SPA_POD_CHOICE_TYPE(Vsize) == SPA_CHOICE_Range);
+	spa_assert_se(SPA_POD_CHOICE_N_VALUES(Vsize) == 3);
+	spa_assert_se(SPA_POD_CHOICE_VALUE_TYPE(Vsize) == SPA_TYPE_Rectangle);
+	spa_assert_se(SPA_POD_CHOICE_VALUE_SIZE(Vsize) == sizeof(struct spa_rectangle));
+	aR = SPA_POD_CHOICE_VALUES(Vsize);
+	spa_assert_se(aR != NULL);
+	spa_assert_se(memcmp(&aR[0], &SPA_RECTANGLE(320,242), sizeof(struct spa_rectangle)) == 0);
+	spa_assert_se(memcmp(&aR[1], &SPA_RECTANGLE(1,1), sizeof(struct spa_rectangle)) == 0);
+	spa_assert_se(memcmp(&aR[2], &SPA_RECTANGLE(INT32_MAX,INT32_MAX), sizeof(struct spa_rectangle)) == 0);
+
+	spa_assert_se(spa_pod_is_choice(Vframerate));
+
+	spa_assert_se(spa_pod_parse_object(pod,
+		SPA_TYPE_OBJECT_Format, NULL,
+		SPA_FORMAT_mediaType,		SPA_POD_Id(&media_type),
+		SPA_FORMAT_mediaSubtype,	SPA_POD_Id(&media_subtype),
+		SPA_FORMAT_VIDEO_views,		SPA_POD_Int(&views),
+		SPA_FORMAT_VIDEO_format,	SPA_POD_Id(&format),
+		SPA_FORMAT_VIDEO_size,		SPA_POD_Rectangle(&size),
+		SPA_FORMAT_VIDEO_framerate,	SPA_POD_Fraction(&framerate)) == -ESRCH);
+
+	spa_assert_se(spa_pod_parse_object(pod,
+		SPA_TYPE_OBJECT_Format, NULL,
+		SPA_FORMAT_mediaType,		SPA_POD_Id(&media_type),
+		SPA_FORMAT_mediaSubtype,	SPA_POD_Id(&media_subtype),
+		SPA_FORMAT_VIDEO_format,	SPA_POD_Id(&format),
+		SPA_FORMAT_VIDEO_size,		SPA_POD_Rectangle(&size),
+		SPA_FORMAT_VIDEO_framerate,	SPA_POD_Fraction(&framerate)) == -EPROTO);
+
+	spa_debug_pod(0, NULL, pod);
+	spa_pod_fixate(pod);
+
+	spa_assert_se(spa_pod_parse_object(pod,
+		SPA_TYPE_OBJECT_Format, NULL,
+		SPA_FORMAT_mediaType,		SPA_POD_Id(&media_type),
+		SPA_FORMAT_mediaSubtype,	SPA_POD_Id(&media_subtype),
+		SPA_FORMAT_VIDEO_format,	SPA_POD_Id(&format),
+		SPA_FORMAT_VIDEO_views,		SPA_POD_OPT_Int(&views),
+		SPA_FORMAT_VIDEO_size,		SPA_POD_Rectangle(&size),
+		SPA_FORMAT_VIDEO_framerate,	SPA_POD_Fraction(&framerate)) == 5);
+
+	spa_assert_se(media_type == SPA_MEDIA_TYPE_video);
+	spa_assert_se(media_subtype == SPA_MEDIA_SUBTYPE_raw);
+	spa_assert_se(format == SPA_VIDEO_FORMAT_I420);
+	spa_assert_se(memcmp(&size, &SPA_RECTANGLE(320,242), sizeof(struct spa_rectangle)) == 0);
+	spa_assert_se(memcmp(&framerate, &SPA_FRACTION(25,1), sizeof(struct spa_fraction)) == 0);
+
+	spa_debug_pod(0, NULL, pod);
+	return PWTEST_PASS;
+}
+
+PWTEST(pod_varargs2)
+{
+	uint8_t buffer[4096];
+	struct spa_pod_builder b;
+	struct spa_pod *pod;
+	struct spa_pod_prop *prop;
+	uint32_t i, j;
+	struct {
+		bool b;
+		uint32_t I;
+		int32_t i;
+		int64_t l;
+		float f;
+		double d;
+		const char *s;
+		uint32_t yl;
+		const void *y;
+		uint32_t ptype;
+		const void *p;
+		uint32_t asize, atype, anvals;
+		const void *a;
+		int64_t h;
+		struct spa_rectangle R;
+		struct spa_fraction F;
+		struct spa_pod *P;
+	} val;
+	uint8_t bytes[] = { 0x56, 0x00, 0x12, 0xf3, 0xba };
+	int64_t longs[] = { 1002, 5383, 28944, 1237748 }, *al;
+	struct spa_pod_int pi = SPA_POD_INIT_Int(77);
+
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+	pod = spa_pod_builder_add_object(&b,
+		SPA_TYPE_OBJECT_Props, 0,
+		1,	SPA_POD_Bool(true),
+		2,	SPA_POD_Id(SPA_TYPE_Id),
+		3,	SPA_POD_Int(3),
+		4,	SPA_POD_Long(4LL),
+		5,	SPA_POD_Float(0.453f),
+		6,	SPA_POD_Double(0.871),
+		7,	SPA_POD_String("test"),
+		8,	SPA_POD_Bytes(bytes, sizeof(bytes)),
+		9,	SPA_POD_Rectangle(&SPA_RECTANGLE(3,4)),
+		10,	SPA_POD_Fraction(&SPA_FRACTION(24,1)),
+		11,	SPA_POD_Array(sizeof(int64_t), SPA_TYPE_Long, SPA_N_ELEMENTS(longs), longs),
+		12,	SPA_POD_Pointer(SPA_TYPE_Object, &b),
+		13,	SPA_POD_Fd(3),
+		14,	SPA_POD_Pod(&pi));
+
+	spa_debug_pod(0, NULL, pod);
+
+	i = 0;
+	SPA_POD_OBJECT_FOREACH((const struct spa_pod_object*)pod, prop) {
+		switch (i++) {
+		case 0:
+			spa_assert_se(prop->key == 1);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 20);
+			spa_assert_se(spa_pod_get_bool(&prop->value, &val.b) == 0 && val.b == true);
+			break;
+		case 1:
+			spa_assert_se(prop->key == 2);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 20);
+			spa_assert_se(spa_pod_get_id(&prop->value, &val.I) == 0 && val.I == SPA_TYPE_Id);
+			break;
+		case 2:
+			spa_assert_se(prop->key == 3);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 20);
+			spa_assert_se(spa_pod_get_int(&prop->value, &val.i) == 0 && val.i == 3);
+			break;
+		case 3:
+			spa_assert_se(prop->key == 4);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 24);
+			spa_assert_se(spa_pod_get_long(&prop->value, &val.l) == 0 && val.l == 4);
+			break;
+		case 4:
+			spa_assert_se(prop->key == 5);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 20);
+			spa_assert_se(spa_pod_get_float(&prop->value, &val.f) == 0 && val.f == 0.453f);
+			break;
+		case 5:
+			spa_assert_se(prop->key == 6);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 24);
+			spa_assert_se(spa_pod_get_double(&prop->value, &val.d) == 0 && val.d == 0.871);
+			break;
+		case 6:
+			spa_assert_se(prop->key == 7);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 21);
+			spa_assert_se(spa_pod_get_string(&prop->value, &val.s) == 0);
+			spa_assert_se(spa_streq(val.s, "test"));
+			break;
+		case 7:
+			spa_assert_se(prop->key == 8);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 21);
+			spa_assert_se(spa_pod_get_bytes(&prop->value, &val.y, &val.yl) == 0);
+			spa_assert_se(val.yl == sizeof(bytes));
+			spa_assert_se(memcmp(val.y, bytes, val.yl) == 0);
+			break;
+		case 8:
+			spa_assert_se(prop->key == 9);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 24);
+			spa_assert_se(spa_pod_get_rectangle(&prop->value, &val.R) == 0);
+			spa_assert_se(memcmp(&val.R, &SPA_RECTANGLE(3,4), sizeof(struct spa_rectangle)) == 0);
+			break;
+		case 9:
+			spa_assert_se(prop->key == 10);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 24);
+			spa_assert_se(spa_pod_get_fraction(&prop->value, &val.F) == 0);
+			spa_assert_se(memcmp(&val.F, &SPA_FRACTION(24,1), sizeof(struct spa_fraction)) == 0);
+			break;
+		case 10:
+			spa_assert_se(prop->key == 11);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 56);
+			spa_assert_se(spa_pod_is_array(&prop->value));
+			spa_assert_se(SPA_POD_ARRAY_VALUE_TYPE(&prop->value) == SPA_TYPE_Long);
+			spa_assert_se(SPA_POD_ARRAY_VALUE_SIZE(&prop->value) == sizeof(int64_t));
+			spa_assert_se(SPA_POD_ARRAY_N_VALUES(&prop->value) == SPA_N_ELEMENTS(longs));
+			al = SPA_POD_ARRAY_VALUES(&prop->value);
+			spa_assert_se(al != NULL);
+			spa_assert_se(SPA_POD_ARRAY_CHILD(&prop->value)->type == SPA_TYPE_Long);
+			spa_assert_se(SPA_POD_ARRAY_CHILD(&prop->value)->size == sizeof(int64_t));
+			for (j = 0; j < SPA_N_ELEMENTS(longs); j++)
+				spa_assert_se(al[j] == longs[j]);
+			break;
+		case 11:
+			spa_assert_se(prop->key == 12);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == (sizeof(struct spa_pod_prop) +
+					sizeof(struct spa_pod_pointer_body)));
+			spa_assert_se(spa_pod_get_pointer(&prop->value, &val.ptype, &val.p) == 0);
+			spa_assert_se(val.ptype == SPA_TYPE_Object);
+			spa_assert_se(val.p == &b);
+			break;
+		case 12:
+			spa_assert_se(prop->key == 13);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 24);
+			spa_assert_se(spa_pod_get_fd(&prop->value, &val.h) == 0);
+			spa_assert_se(val.h == 3);
+			break;
+		case 13:
+			spa_assert_se(prop->key == 14);
+			spa_assert_se(SPA_POD_PROP_SIZE(prop) == 20);
+			spa_assert_se(spa_pod_get_int(&prop->value, &val.i) == 0);
+			spa_assert_se(val.i == 77);
+			break;
+		default:
+			spa_assert_not_reached();
+			break;
+		}
+	}
+	spa_assert_se(spa_pod_parse_object(pod, SPA_TYPE_OBJECT_Format, NULL) == -EPROTO);
+	spa_assert_se(spa_pod_parse_object(pod, SPA_TYPE_OBJECT_Props, NULL) == 0);
+
+	spa_zero(val);
+	spa_assert_se(spa_pod_parse_object(pod,
+		SPA_TYPE_OBJECT_Props, NULL,
+		1,	SPA_POD_Bool(&val.b),
+		2,	SPA_POD_Id(&val.I),
+		3,	SPA_POD_Int(&val.i),
+		4,	SPA_POD_Long(&val.l),
+		5,	SPA_POD_Float(&val.f),
+		6,	SPA_POD_Double(&val.d),
+		7,	SPA_POD_String(&val.s),
+		8,	SPA_POD_Bytes(&val.y, &val.yl),
+		9,	SPA_POD_Rectangle(&val.R),
+		10,	SPA_POD_Fraction(&val.F),
+		11,	SPA_POD_Array(&val.asize, &val.atype, &val.anvals, &val.a),
+		12,	SPA_POD_Pointer(&val.ptype, &val.p),
+		13,	SPA_POD_Fd(&val.h),
+		14,	SPA_POD_Pod(&val.P)) == 14);
+
+	spa_assert_se(val.b == true);
+	spa_assert_se(val.I == SPA_TYPE_Id);
+	spa_assert_se(val.i == 3);
+	spa_assert_se(val.l == 4);
+	spa_assert_se(val.f == 0.453f);
+	spa_assert_se(val.d == 0.871);
+	spa_assert_se(spa_streq(val.s, "test"));
+	spa_assert_se(val.yl == sizeof(bytes));
+	spa_assert_se(memcmp(val.y, bytes, sizeof(bytes)) == 0);
+	spa_assert_se(memcmp(&val.R, &SPA_RECTANGLE(3, 4), sizeof(struct spa_rectangle)) == 0);
+	spa_assert_se(memcmp(&val.F, &SPA_FRACTION(24, 1), sizeof(struct spa_fraction)) == 0);
+	spa_assert_se(val.asize == sizeof(int64_t));
+	spa_assert_se(val.atype == SPA_TYPE_Long);
+	spa_assert_se(val.anvals == SPA_N_ELEMENTS(longs));
+	spa_assert_se(memcmp(val.a, longs, val.anvals * val.asize) == 0);
+	spa_assert_se(val.ptype == SPA_TYPE_Object);
+	spa_assert_se(val.p == &b);
+	spa_assert_se(val.h == 3);
+	spa_assert_se(memcmp(val.P, &pi, sizeof(pi)) == 0);
+
+	spa_zero(val);
+	spa_assert_se(spa_pod_parse_object(pod,
+		SPA_TYPE_OBJECT_Props, NULL,
+		0,	SPA_POD_OPT_Bool(&val.b),
+		0,	SPA_POD_OPT_Id(&val.I),
+		0,	SPA_POD_OPT_Int(&val.i),
+		0,	SPA_POD_OPT_Long(&val.l),
+		0,	SPA_POD_OPT_Float(&val.f),
+		0,	SPA_POD_OPT_Double(&val.d),
+		0,	SPA_POD_OPT_String(&val.s),
+		0,	SPA_POD_OPT_Bytes(&val.y, &val.yl),
+		0,	SPA_POD_OPT_Rectangle(&val.R),
+		0,	SPA_POD_OPT_Fraction(&val.F),
+		0,	SPA_POD_OPT_Array(&val.asize, &val.atype, &val.anvals, &val.a),
+		0,	SPA_POD_OPT_Pointer(&val.ptype, &val.p),
+		0,	SPA_POD_OPT_Fd(&val.h),
+		0,	SPA_POD_OPT_Pod(&val.P)) == 0);
+
+	for (i = 1; i < 15; i++) {
+		spa_zero(val);
+		spa_assert_se(spa_pod_parse_object(pod,
+			SPA_TYPE_OBJECT_Props, NULL,
+			i,	SPA_POD_OPT_Bool(&val.b),
+			i,	SPA_POD_OPT_Id(&val.I),
+			i,	SPA_POD_OPT_Int(&val.i),
+			i,	SPA_POD_OPT_Long(&val.l),
+			i,	SPA_POD_OPT_Float(&val.f),
+			i,	SPA_POD_OPT_Double(&val.d),
+			i,	SPA_POD_OPT_String(&val.s),
+			i,	SPA_POD_OPT_Bytes(&val.y, &val.yl),
+			i,	SPA_POD_OPT_Rectangle(&val.R),
+			i,	SPA_POD_OPT_Fraction(&val.F),
+			i,	SPA_POD_OPT_Array(&val.asize, &val.atype, &val.anvals, &val.a),
+			i,	SPA_POD_OPT_Pointer(&val.ptype, &val.p),
+			i,	SPA_POD_OPT_Fd(&val.h),
+			i,	SPA_POD_OPT_Pod(&val.P)) == 2);
+	}
+	return PWTEST_PASS;
+}
+
+PWTEST(pod_parser)
+{
+	uint8_t buffer[4096];
+	struct spa_pod_builder b;
+	struct spa_pod_parser p;
+	struct spa_pod_frame f;
+	struct spa_pod *pod;
+	struct {
+		bool b;
+		uint32_t I;
+		int32_t i;
+		int64_t l;
+		float f;
+		double d;
+		const char *s;
+		uint32_t yl;
+		const void *y;
+		uint32_t ptype;
+		const void *p;
+		uint32_t asize, atype, anvals;
+		const void *a;
+		int64_t h;
+		struct spa_rectangle R;
+		struct spa_fraction F;
+		struct spa_pod *P;
+	} val;
+	uint8_t bytes[] = { 0x56, 0x00, 0x12, 0xf3, 0xba };
+	int64_t longs[] = { 1002, 5383, 28944, 1237748 };
+	struct spa_pod_int pi = SPA_POD_INIT_Int(77);
+
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+	pod = spa_pod_builder_add_object(&b,
+		SPA_TYPE_OBJECT_Props, 0,
+		1,	SPA_POD_Bool(true),
+		2,	SPA_POD_Id(SPA_TYPE_Id),
+		3,	SPA_POD_Int(3),
+		4,	SPA_POD_Long(4LL),
+		5,	SPA_POD_Float(0.453f),
+		6,	SPA_POD_Double(0.871),
+		7,	SPA_POD_String("test"),
+		8,	SPA_POD_Bytes(bytes, sizeof(bytes)),
+		9,	SPA_POD_Rectangle(&SPA_RECTANGLE(3,4)),
+		10,	SPA_POD_Fraction(&SPA_FRACTION(24,1)),
+		11,	SPA_POD_Array(sizeof(int64_t), SPA_TYPE_Long, SPA_N_ELEMENTS(longs), longs),
+		12,	SPA_POD_Pointer(SPA_TYPE_Object, &b),
+		13,	SPA_POD_Fd(3),
+		14,	SPA_POD_Pod(&pi));
+
+	spa_debug_pod(0, NULL, pod);
+
+	spa_pod_parser_pod(&p, pod);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_bool(&p, &val.b) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_id(&p, &val.I) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_int(&p, &val.i) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_long(&p, &val.l) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_float(&p, &val.f) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_double(&p, &val.d) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_string(&p, &val.s) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_bytes(&p, &val.y, &val.yl) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_rectangle(&p, &val.R) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_fraction(&p, &val.F) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_pointer(&p, &val.ptype, &val.p) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_fd(&p, &val.h) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_pod(&p, &val.P) == 0);
+	spa_assert_se(p.state.offset == 392);
+	spa_assert_se(spa_pod_is_object(val.P));
+
+	spa_pod_parser_pod(&p, val.P);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_push_struct(&p, &f) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_push_object(&p, &f, SPA_TYPE_OBJECT_Format, NULL) == -EPROTO);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_push_object(&p, &f, SPA_TYPE_OBJECT_Props, NULL) == 0);
+	spa_assert_se(p.state.offset == 392);
+	spa_assert_se(spa_pod_parser_frame(&p, &f) == val.P);
+
+	spa_zero(val);
+	spa_assert_se(spa_pod_parser_get(&p,
+		1,	SPA_POD_OPT_Bool(&val.b),
+		2,	SPA_POD_OPT_Id(&val.I),
+		3,	SPA_POD_OPT_Int(&val.i),
+		4,	SPA_POD_OPT_Long(&val.l),
+		5,	SPA_POD_OPT_Float(&val.f),
+		6,	SPA_POD_OPT_Double(&val.d),
+		7,	SPA_POD_OPT_String(&val.s),
+		8,	SPA_POD_OPT_Bytes(&val.y, &val.yl),
+		9,	SPA_POD_OPT_Rectangle(&val.R),
+		10,	SPA_POD_OPT_Fraction(&val.F),
+		11,	SPA_POD_OPT_Array(&val.asize, &val.atype, &val.anvals, &val.a),
+		12,	SPA_POD_OPT_Pointer(&val.ptype, &val.p),
+		13,	SPA_POD_OPT_Fd(&val.h),
+		14,	SPA_POD_OPT_Pod(&val.P), 0) == 14);
+	spa_pod_parser_pop(&p, &f);
+
+	spa_assert_se(val.b == true);
+	spa_assert_se(val.I == SPA_TYPE_Id);
+	spa_assert_se(val.i == 3);
+	spa_assert_se(val.l == 4);
+	spa_assert_se(val.f == 0.453f);
+	spa_assert_se(val.d == 0.871);
+	spa_assert_se(spa_streq(val.s, "test"));
+	spa_assert_se(val.yl == sizeof(bytes));
+	spa_assert_se(memcmp(val.y, bytes, sizeof(bytes)) == 0);
+	spa_assert_se(memcmp(&val.R, &SPA_RECTANGLE(3, 4), sizeof(struct spa_rectangle)) == 0);
+	spa_assert_se(memcmp(&val.F, &SPA_FRACTION(24, 1), sizeof(struct spa_fraction)) == 0);
+	spa_assert_se(val.asize == sizeof(int64_t));
+	spa_assert_se(val.atype == SPA_TYPE_Long);
+	spa_assert_se(val.anvals == SPA_N_ELEMENTS(longs));
+	spa_assert_se(memcmp(val.a, longs, val.anvals * val.asize) == 0);
+	spa_assert_se(val.ptype == SPA_TYPE_Object);
+	spa_assert_se(val.p == &b);
+	spa_assert_se(val.h == 3);
+	spa_assert_se(memcmp(val.P, &pi, sizeof(pi)) == 0);
+
+	spa_assert_se(p.state.offset == 392);
+	return PWTEST_PASS;
+}
+
+PWTEST(pod_parser2)
+{
+	uint8_t buffer[4096];
+	struct spa_pod_builder b;
+	struct spa_pod_parser p;
+	struct spa_pod_frame f;
+	struct spa_pod *pod;
+	struct {
+		bool b;
+		uint32_t I;
+		int32_t i;
+		int64_t l;
+		float f;
+		double d;
+		const char *s;
+		uint32_t yl;
+		const void *y;
+		uint32_t ptype;
+		const void *p;
+		uint32_t asize, atype, anvals;
+		const void *a;
+		int64_t h;
+		struct spa_rectangle R;
+		struct spa_fraction F;
+		struct spa_pod *P;
+	} val;
+	uint8_t bytes[] = { 0x56, 0x00, 0x12, 0xf3, 0xba };
+	int64_t longs[] = { 1002, 5383, 28944, 1237748 };
+	struct spa_pod_int pi = SPA_POD_INIT_Int(77);
+
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+	pod = spa_pod_builder_add_struct(&b,
+		SPA_POD_Bool(true),
+		SPA_POD_Id(SPA_TYPE_Id),
+		SPA_POD_Int(3),
+		SPA_POD_Long(4LL),
+		SPA_POD_Float(0.453f),
+		SPA_POD_Double(0.871),
+		SPA_POD_String("test"),
+		SPA_POD_Bytes(bytes, sizeof(bytes)),
+		SPA_POD_Rectangle(&SPA_RECTANGLE(3,4)),
+		SPA_POD_Fraction(&SPA_FRACTION(24,1)),
+		SPA_POD_Array(sizeof(int64_t), SPA_TYPE_Long, SPA_N_ELEMENTS(longs), longs),
+		SPA_POD_Pointer(SPA_TYPE_Object, &b),
+		SPA_POD_Fd(3),
+		SPA_POD_Pod(&pi));
+
+	spa_debug_pod(0, NULL, pod);
+
+	spa_pod_parser_pod(&p, pod);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_bool(&p, &val.b) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_id(&p, &val.I) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_int(&p, &val.i) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_long(&p, &val.l) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_float(&p, &val.f) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_double(&p, &val.d) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_string(&p, &val.s) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_bytes(&p, &val.y, &val.yl) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_rectangle(&p, &val.R) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_fraction(&p, &val.F) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_pointer(&p, &val.ptype, &val.p) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_fd(&p, &val.h) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_get_pod(&p, &val.P) == 0);
+	spa_assert_se(p.state.offset == 272);
+	spa_assert_se(spa_pod_is_struct(val.P));
+
+	spa_pod_parser_pod(&p, val.P);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_push_object(&p, &f, SPA_TYPE_OBJECT_Format, NULL) == -EINVAL);
+	spa_assert_se(p.state.offset == 0);
+	spa_assert_se(spa_pod_parser_push_struct(&p, &f) == 0);
+	spa_assert_se(f.pod.type == SPA_TYPE_Struct);
+	spa_assert_se(f.pod.size == 264);
+	spa_assert_se(f.offset == 0);
+	spa_assert_se(p.state.frame == &f);
+	spa_assert_se(spa_pod_parser_frame(&p, &f) == val.P);
+	spa_assert_se(p.state.offset == 8);
+	spa_assert_se(spa_pod_parser_get_bool(&p, &val.b) == 0 && val.b == true);
+	spa_assert_se(p.state.offset == 24);
+	spa_assert_se(spa_pod_parser_get_id(&p, &val.I) == 0 && val.I == SPA_TYPE_Id);
+	spa_assert_se(p.state.offset == 40);
+	spa_assert_se(spa_pod_parser_get_int(&p, &val.i) == 0 && val.i == 3);
+	spa_assert_se(p.state.offset == 56);
+	spa_assert_se(spa_pod_parser_get_long(&p, &val.l) == 0 && val.l == 4);
+	spa_assert_se(p.state.offset == 72);
+	spa_assert_se(spa_pod_parser_get_float(&p, &val.f) == 0 && val.f == 0.453f);
+	spa_assert_se(p.state.offset == 88);
+	spa_assert_se(spa_pod_parser_get_double(&p, &val.d) == 0 && val.d == 0.871);
+	spa_assert_se(p.state.offset == 104);
+	spa_assert_se(spa_pod_parser_get_string(&p, &val.s) == 0 && spa_streq(val.s, "test"));
+	spa_assert_se(p.state.offset == 120);
+	spa_assert_se(spa_pod_parser_get_bytes(&p, &val.y, &val.yl) == 0);
+	spa_assert_se(val.yl == sizeof(bytes));
+	spa_assert_se(memcmp(bytes, val.y, sizeof(bytes)) == 0);
+	spa_assert_se(p.state.offset == 136);
+	spa_assert_se(spa_pod_parser_get_rectangle(&p, &val.R) == 0);
+	spa_assert_se(memcmp(&val.R, &SPA_RECTANGLE(3,4), sizeof(struct spa_rectangle)) == 0);
+	spa_assert_se(p.state.offset == 152);
+	spa_assert_se(spa_pod_parser_get_fraction(&p, &val.F) == 0);
+	spa_assert_se(memcmp(&val.F, &SPA_FRACTION(24,1), sizeof(struct spa_fraction)) == 0);
+	spa_assert_se(p.state.offset == 168);
+	val.P = spa_pod_parser_next(&p);
+	spa_assert_se(val.P != NULL);
+	spa_assert_se(spa_pod_is_array(val.P));
+	spa_assert_se(p.state.offset == 216);
+	spa_assert_se(SPA_POD_ARRAY_VALUE_TYPE(val.P) == SPA_TYPE_Long);
+	spa_assert_se(SPA_POD_ARRAY_VALUE_SIZE(val.P) == sizeof(int64_t));
+	spa_assert_se(SPA_POD_ARRAY_N_VALUES(val.P) == SPA_N_ELEMENTS(longs));
+	spa_assert_se(spa_pod_parser_get_pointer(&p, &val.ptype, &val.p) == 0);
+	spa_assert_se(val.ptype == SPA_TYPE_Object);
+	spa_assert_se(val.p == &b);
+	spa_assert_se(p.state.offset == 240);
+	spa_assert_se(spa_pod_parser_get_fd(&p, &val.h) == 0);
+	spa_assert_se(val.h == 3);
+	spa_assert_se(p.state.offset == 256);
+	spa_assert_se(spa_pod_parser_get_pod(&p, &val.P) == 0);
+	spa_assert_se(p.state.offset == 272);
+	spa_assert_se(spa_pod_is_int(val.P));
+	spa_pod_parser_pop(&p, &f);
+	spa_assert_se(p.state.offset == 272);
+	spa_assert_se(p.state.frame == NULL);
+	return PWTEST_PASS;
+}
+
+PWTEST(pod_static)
+{
+	struct _test_format {
+		struct spa_pod_object fmt;
+
+		struct {
+			struct spa_pod_prop prop_media_type	SPA_ALIGNED(8);
+			uint32_t media_type;
+
+			struct spa_pod_prop prop_media_subtype	SPA_ALIGNED(8);
+			uint32_t media_subtype;
+
+			struct spa_pod_prop prop_format		SPA_ALIGNED(8);
+			struct {
+				struct spa_pod_choice_body choice;
+				uint32_t def_format;
+				uint32_t enum_format[2];
+			} format_vals;
+
+			struct spa_pod_prop prop_size		SPA_ALIGNED(8);
+			struct {
+				struct spa_pod_choice_body choice;
+				struct spa_rectangle def_size;
+				struct spa_rectangle min_size;
+				struct spa_rectangle max_size;
+			} size_vals;
+
+			struct spa_pod_prop prop_framerate	SPA_ALIGNED(8);
+			struct {
+				struct spa_pod_choice_body choice;
+				struct spa_fraction def_framerate;
+				struct spa_fraction min_framerate;
+				struct spa_fraction max_framerate;
+			} framerate_vals;
+		} props;
+	} test_format = {
+		SPA_POD_INIT_Object(sizeof(test_format.props) + sizeof(struct spa_pod_object_body),
+				SPA_TYPE_OBJECT_Format, 0),
+		{
+			SPA_POD_INIT_Prop(SPA_FORMAT_mediaType, 0,
+					  sizeof(test_format.props.media_type), SPA_TYPE_Id),
+			SPA_MEDIA_TYPE_video,
+
+			SPA_POD_INIT_Prop(SPA_FORMAT_mediaSubtype, 0,
+					  sizeof(test_format.props.media_subtype), SPA_TYPE_Id),
+			SPA_MEDIA_SUBTYPE_raw,
+
+			SPA_POD_INIT_Prop(SPA_FORMAT_VIDEO_format, 0,
+					  sizeof(test_format.props.format_vals), SPA_TYPE_Choice),
+			{
+				SPA_POD_INIT_CHOICE_BODY(SPA_CHOICE_Enum, 0,
+						sizeof(uint32_t), SPA_TYPE_Id),
+				SPA_VIDEO_FORMAT_I420,
+				{ SPA_VIDEO_FORMAT_I420, SPA_VIDEO_FORMAT_YUY2 }
+			},
+			SPA_POD_INIT_Prop(SPA_FORMAT_VIDEO_size, 0,
+					  sizeof(test_format.props.size_vals), SPA_TYPE_Choice),
+
+			{
+				SPA_POD_INIT_CHOICE_BODY(SPA_CHOICE_Range, 0,
+						sizeof(struct spa_rectangle), SPA_TYPE_Rectangle),
+				SPA_RECTANGLE(320,243),
+				SPA_RECTANGLE(1,1), SPA_RECTANGLE(INT32_MAX, INT32_MAX)
+			},
+			SPA_POD_INIT_Prop(SPA_FORMAT_VIDEO_framerate, 0,
+					  sizeof(test_format.props.framerate_vals), SPA_TYPE_Choice),
+			{
+				SPA_POD_INIT_CHOICE_BODY(SPA_CHOICE_Range, 0,
+						sizeof(struct spa_fraction), SPA_TYPE_Fraction),
+				SPA_FRACTION(25,1),
+				SPA_FRACTION(0,1), SPA_FRACTION(INT32_MAX,1)
+			}
+		}
+	};
+	struct {
+		uint32_t media_type;
+		uint32_t media_subtype;
+		uint32_t format;
+		struct spa_rectangle size;
+		struct spa_fraction framerate;
+	} vals;
+	int res;
+
+	spa_debug_pod(0, NULL, &test_format.fmt.pod);
+
+	spa_zero(vals);
+	res = spa_pod_parse_object(&test_format.fmt.pod,
+		SPA_TYPE_OBJECT_Format, NULL,
+		SPA_FORMAT_mediaType,       SPA_POD_Id(&vals.media_type),
+		SPA_FORMAT_mediaSubtype,    SPA_POD_Id(&vals.media_subtype),
+		SPA_FORMAT_VIDEO_format,    SPA_POD_Id(&vals.format),
+		SPA_FORMAT_VIDEO_size,      SPA_POD_Rectangle(&vals.size),
+		SPA_FORMAT_VIDEO_framerate, SPA_POD_Fraction(&vals.framerate));
+
+	spa_assert_se(res == -EPROTO);
+	spa_assert_se(vals.media_type == SPA_MEDIA_TYPE_video);
+	spa_assert_se(vals.media_subtype == SPA_MEDIA_SUBTYPE_raw);
+	spa_assert_se(vals.format == 0);
+	spa_assert_se(vals.size.width == 0 && vals.size.height == 0);
+	spa_assert_se(vals.framerate.num == 0 && vals.framerate.denom == 0);
+
+	spa_pod_fixate(&test_format.fmt.pod);
+
+	spa_zero(vals);
+	res = spa_pod_parse_object(&test_format.fmt.pod,
+		SPA_TYPE_OBJECT_Format, NULL,
+		SPA_FORMAT_mediaType,       SPA_POD_Id(&vals.media_type),
+		SPA_FORMAT_mediaSubtype,    SPA_POD_Id(&vals.media_subtype),
+		SPA_FORMAT_VIDEO_format,    SPA_POD_Id(&vals.format),
+		SPA_FORMAT_VIDEO_size,      SPA_POD_Rectangle(&vals.size),
+		SPA_FORMAT_VIDEO_framerate, SPA_POD_Fraction(&vals.framerate));
+
+	spa_assert_se(res == 5);
+	spa_assert_se(vals.media_type == SPA_MEDIA_TYPE_video);
+	spa_assert_se(vals.media_subtype == SPA_MEDIA_SUBTYPE_raw);
+	spa_assert_se(vals.format == SPA_VIDEO_FORMAT_I420);
+	spa_assert_se(vals.size.width == 320 && vals.size.height == 243);
+	spa_assert_se(vals.framerate.num == 25 && vals.framerate.denom == 1);
+	return PWTEST_PASS;
+}
+
+PWTEST(pod_overflow)
+{
+	static const char * const labels[] = {
+		"640x480p59", "720x480i29", "720x480p59", "720x576i25", "720x576p50",
+		"1280x720p24", "1280x720p25", "1280x720p30", "1280x720p50", "1280x720p60",
+		"1920x1080p24", "1920x1080p25", "1920x1080p30", "1920x1080i25", "1920x1080p50",
+		"1920x1080i30", "1920x1080p60", "640x350p85", "640x400p85", "720x400p85",
+		"640x480p72", "640x480p75", "640x480p85", "800x600p56", "800x600p60",
+		"800x600p72", "800x600p75", "800x600p85", "800x600p119", "848x480p60",
+		"1024x768i43", "1024x768p60", "1024x768p70", "1024x768p75", "1024x768p84",
+		"1024x768p119", "1152x864p75", "1280x768p59", "1280x768p59", "1280x768p74",
+		"1280x768p84", "1280x768p119", "1280x800p59", "1280x800p59", "1280x800p74",
+		"1280x800p84", "1280x800p119", "1280x960p60", "1280x960p85", "1280x960p119",
+		"1280x1024p60", "1280x1024p75", "1280x1024p85", "1280x1024p119", "1360x768p60",
+		"1360x768p119", "1366x768p59", "1366x768p60", "1400x1050p59", "1400x1050p59",
+		"1400x1050p74", "1400x1050p84", "1400x1050p119", "1440x900p59", "1440x900p59",
+		"1440x900p74", "1440x900p84", "1440x900p119", "1600x900p60", "1600x1200p60",
+		"1600x1200p65", "1600x1200p70", "1600x1200p75", "1600x1200p85", "1600x1200p119",
+		"1680x1050p59", "1680x1050p59", "1680x1050p74", "1680x1050p84", "1680x1050p119",
+		"1792x1344p59", "1792x1344p74", "1792x1344p119", "1856x1392p59", "1856x1392p75",
+		"1856x1392p119", "1920x1200p59", "1920x1200p59", "1920x1200p74", "1920x1200p84",
+		"1920x1200p119", "1920x1440p60", "1920x1440p75", "1920x1440p119", "2048x1152p60",
+		"2560x1600p59", "2560x1600p59", "2560x1600p74", "2560x1600p84", "2560x1600p119",
+		"3840x2160p24", "3840x2160p25", "3840x2160p30", "3840x2160p50", "3840x2160p60",
+		"4096x2160p24", "4096x2160p25", "4096x2160p30", "4096x2160p50", "4096x2160p59",
+		"4096x2160p60", NULL };
+
+	uint8_t buffer[1024];
+	struct spa_pod_builder b = { 0 };
+	struct spa_pod_builder_state state;
+	struct spa_pod_frame f[2];
+	uint32_t idx;
+	struct spa_pod *pod;
+
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+
+	spa_pod_builder_push_object(&b, &f[0], SPA_TYPE_OBJECT_PropInfo, SPA_PARAM_PropInfo);
+	spa_pod_builder_add(&b,
+			SPA_PROP_INFO_id,    SPA_POD_Id(32567359),
+			SPA_PROP_INFO_type,  SPA_POD_CHOICE_ENUM_Int(1, 0),
+			SPA_PROP_INFO_description,  SPA_POD_String("DV Timings"),
+			0);
+
+	spa_pod_builder_get_state(&b, &state),
+
+	spa_pod_builder_prop(&b, SPA_PROP_INFO_labels, 0);
+	spa_pod_builder_push_struct(&b, &f[1]);
+
+	for (idx = 0; labels[idx]; idx++) {
+		spa_pod_builder_int(&b, idx);
+		spa_pod_builder_string(&b, labels[idx]);
+	}
+	spa_assert_se(b.state.offset > sizeof(buffer));
+	pod = spa_pod_builder_pop(&b, &f[1]);
+	spa_assert_se(pod == NULL);
+	spa_pod_builder_reset(&b, &state);
+
+	spa_pod_builder_prop(&b, SPA_PROP_INFO_labels, 0);
+	spa_pod_builder_push_struct(&b, &f[1]);
+	pod = spa_pod_builder_pop(&b, &f[1]);
+
+	spa_assert_se(b.state.offset < sizeof(buffer));
+	pod = spa_pod_builder_pop(&b, &f[0]);
+	spa_assert_se(pod != NULL);
+
+	spa_debug_pod(0, NULL, pod);
+	return PWTEST_PASS;
+}
+
+static int handle_overflow(void *data, uint32_t size)
+{
+	uint32_t *d = data;
+	(*d)++;
+	return -ENOSPC;
+}
+
+static struct spa_pod_builder_callbacks overflow_cb = {
+	SPA_VERSION_POD_BUILDER_CALLBACKS,
+	.overflow = handle_overflow
+};
+
+PWTEST(pod_overflow2)
+{
+	uint8_t buffer[1024];
+	struct spa_pod_builder b = { 0 };
+	struct spa_pod_builder_state state;
+	struct spa_pod_frame f[2];
+	uint32_t idx, overflow_count = 0;
+	struct spa_pod *pod;
+
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+	spa_pod_builder_set_callbacks(&b, &overflow_cb, &overflow_count);
+
+	spa_pod_builder_push_object(&b, &f[0], SPA_TYPE_OBJECT_PropInfo, SPA_PARAM_PropInfo);
+	spa_pod_builder_add(&b,
+			SPA_PROP_INFO_id,    SPA_POD_Id(32567359),
+			SPA_PROP_INFO_type,  SPA_POD_CHOICE_ENUM_Int(1, 0),
+			SPA_PROP_INFO_description,  SPA_POD_String("DV Timings"),
+			0);
+
+	spa_pod_builder_get_state(&b, &state),
+
+	spa_pod_builder_prop(&b, SPA_PROP_INFO_labels, 0);
+	spa_pod_builder_push_struct(&b, &f[1]);
+
+	for (idx = 0; idx < 512; idx++) {
+		spa_pod_builder_int(&b, idx);
+		spa_pod_builder_string(&b, "foo");
+	}
+	spa_assert_se(b.state.offset > sizeof(buffer));
+	pod = spa_pod_builder_pop(&b, &f[1]);
+	spa_assert_se(pod == NULL);
+	spa_assert_se(overflow_count == 1);
+
+	return PWTEST_PASS;
+}
+
+PWTEST_SUITE(spa_pod)
+{
+	pwtest_add(pod_abi_sizes, PWTEST_NOARG);
+	pwtest_add(pod_abi, PWTEST_NOARG);
+	pwtest_add(pod_init, PWTEST_NOARG);
+	pwtest_add(pod_empty, PWTEST_NOARG);
+	pwtest_add(pod_build, PWTEST_NOARG);
+	pwtest_add(pod_varargs, PWTEST_NOARG);
+	pwtest_add(pod_varargs2, PWTEST_NOARG);
+	pwtest_add(pod_parser, PWTEST_NOARG);
+	pwtest_add(pod_parser2, PWTEST_NOARG);
+	pwtest_add(pod_static, PWTEST_NOARG);
+	pwtest_add(pod_overflow, PWTEST_NOARG);
+	pwtest_add(pod_overflow2, PWTEST_NOARG);
+
+	return PWTEST_PASS;
+}
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;
+}
diff --git a/test/test-support.c b/test/test-support.c
new file mode 100644
index 0000000..e8a18f0
--- /dev/null
+++ b/test/test-support.c
@@ -0,0 +1,88 @@
+/* PipeWire
+ *
+ * Copyright © 2021 Red Hat, Inc.
+ *
+ * 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 "pwtest.h"
+
+#include <spa/utils/names.h>
+#include <spa/support/plugin.h>
+#include <spa/support/log.h>
+
+PWTEST(pwtest_load_nonexisting)
+{
+	struct pwtest_spa_plugin *plugin;
+	void *iface;
+
+	plugin = pwtest_spa_plugin_new();
+
+	pwtest_neg_errno_check(
+		pwtest_spa_plugin_try_load_interface(plugin, &iface,
+					"support/does_not_exist",
+					SPA_NAME_SUPPORT_LOG, SPA_TYPE_INTERFACE_Log,
+					NULL),
+		-ENOENT);
+
+	pwtest_neg_errno_check(
+		pwtest_spa_plugin_try_load_interface(plugin, &iface,
+					"support/libspa-support",
+					"foo.bar", SPA_TYPE_INTERFACE_Log,
+					NULL),
+		-EINVAL);
+
+	pwtest_neg_errno_check(
+		pwtest_spa_plugin_try_load_interface(plugin, &iface,
+					"support/libspa-support",
+					SPA_NAME_SUPPORT_LOG,
+					"foo", NULL),
+		-ENOSYS);
+
+	pwtest_spa_plugin_destroy(plugin);
+
+	return PWTEST_PASS;
+}
+
+PWTEST(pwtest_load_plugin)
+{
+	struct pwtest_spa_plugin *plugin;
+	void *iface;
+
+	plugin = pwtest_spa_plugin_new();
+
+	pwtest_neg_errno_ok(
+		pwtest_spa_plugin_try_load_interface(plugin, &iface,
+					"support/libspa-support",
+					SPA_NAME_SUPPORT_LOG, SPA_TYPE_INTERFACE_Log,
+					NULL)
+		);
+
+	pwtest_spa_plugin_destroy(plugin);
+	return PWTEST_PASS;
+}
+
+PWTEST_SUITE(support)
+{
+	pwtest_add(pwtest_load_nonexisting, PWTEST_NOARG);
+	pwtest_add(pwtest_load_plugin, PWTEST_NOARG);
+
+	return PWTEST_PASS;
+}
diff --git a/test/test-utils.c b/test/test-utils.c
new file mode 100644
index 0000000..84a2fcb
--- /dev/null
+++ b/test/test-utils.c
@@ -0,0 +1,253 @@
+/* PipeWire
+ *
+ * Copyright © 2019 Wim Taymans
+ *
+ * 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 "pwtest.h"
+#include <limits.h>
+
+#include <pipewire/utils.h>
+
+#include <spa/utils/string.h>
+
+static void test_destroy(void *object)
+{
+	pwtest_fail_if_reached();
+}
+
+PWTEST(utils_abi)
+{
+	pw_destroy_t f = test_destroy;
+
+	pwtest_ptr_eq(f, &test_destroy);
+
+	return PWTEST_PASS;
+}
+
+static void test__pw_split_walk(void)
+{
+	const struct test_case {
+		const char * const input;
+		const char * const delim;
+		const char * const * const expected;
+	} test_cases[] = {
+		{
+			.input = "a \n test string  \n \r ",
+			.delim = " \r\n",
+			.expected = (const char *[]) {
+				"a",
+				"test",
+				"string",
+				NULL
+			},
+		},
+		{
+			.input = "::field1::field2:: field3:::::",
+			.delim = ":",
+			.expected = (const char *[]) {
+				"field1",
+				"field2",
+				" field3",
+				NULL
+			},
+		},
+		{
+			.input = ",,,,,,,,,,,,",
+			.delim = ",",
+			.expected = (const char *[]) {
+				NULL
+			},
+		},
+		{
+			.input = ",;,,,'''':::':::,,,,;",
+			.delim = ",:';",
+			.expected = (const char *[]) {
+				NULL
+			},
+		},
+		{
+			.input = "aaa:bbb,ccc##ddd/#,eee?fff...",
+			.delim = ":,#/?",
+			.expected = (const char *[]) {
+				"aaa",
+				"bbb",
+				"ccc",
+				"ddd",
+				"eee",
+				"fff...",
+				NULL
+			},
+		},
+		{
+			.input = "line 1\na different line\nthe third line\n",
+			.delim = "\n",
+			.expected = (const char *[]) {
+				"line 1",
+				"a different line",
+				"the third line",
+				NULL
+			},
+		},
+		{
+			.input = "no delimiters",
+			.delim = ",:/;",
+			.expected = (const char *[]) {
+				"no delimiters",
+				NULL
+			},
+		},
+		{
+			.input = "delimiter at the end,;",
+			.delim = ",;",
+			.expected = (const char *[]) {
+				"delimiter at the end",
+				NULL
+			},
+		},
+		{
+			.input = "/delimiter on both ends,",
+			.delim = "/,",
+			.expected = (const char *[]) {
+				"delimiter on both ends",
+				NULL
+			},
+		},
+		{
+			.input = ",delimiter at the beginning",
+			.delim = ",",
+			.expected = (const char *[]) {
+				"delimiter at the beginning",
+				NULL
+			},
+		},
+		{
+			.input = "/usr/lib/pipewire-0.3/libpipewire.so",
+			.delim = "/",
+			.expected = (const char *[]) {
+				"usr",
+				"lib",
+				"pipewire-0.3",
+				"libpipewire.so",
+				NULL
+			}
+		},
+		{
+			.input = "/home/x/.ladspa:/usr/lib/ladspa:/usr/local/lib/ladspa",
+			.delim = ":",
+			.expected = (const char *[]) {
+				"/home/x/.ladspa",
+				"/usr/lib/ladspa",
+				"/usr/local/lib/ladspa",
+				NULL
+			}
+		},
+		{
+			.input = "\n field1 \t\n   field2  \t   \t field3",
+			.delim = " \n\t",
+			.expected = (const char *[]) {
+				"field1",
+				"field2",
+				"field3",
+				NULL
+			}
+		},
+	};
+
+	SPA_FOR_EACH_ELEMENT_VAR(test_cases, tc) {
+		const char *str = tc->input, *s;
+		const char *state = NULL;
+		size_t j = 0, len;
+
+		while ((s = pw_split_walk(str, tc->delim, &len, &state)) != NULL && tc->expected[j] != NULL) {
+			pwtest_int_eq(strlen(tc->expected[j]), len);
+			pwtest_str_eq_n(s, tc->expected[j], len);
+
+			j += 1;
+		}
+
+		pwtest_ptr_null(s);
+		pwtest_ptr_null(tc->expected[j]);
+	}
+}
+
+static void test__pw_split_strv(void)
+{
+	const char *test1 = "a \n test string  \n \r ";
+	const char *del = "\n\r ";
+	const char *test2 = "a:";
+	const char *del2 = ":";
+	int n_tokens;
+	char **res;
+
+	res = pw_split_strv(test1, del, INT_MAX, &n_tokens);
+	pwtest_ptr_notnull(res);
+	pwtest_int_eq(n_tokens, 3);
+	pwtest_str_eq(res[0], "a");
+	pwtest_str_eq(res[1], "test");
+	pwtest_str_eq(res[2], "string");
+	pwtest_ptr_null(res[3]);
+	pw_free_strv(res);
+
+	res = pw_split_strv(test1, del, 2, &n_tokens);
+	pwtest_ptr_notnull(res);
+	pwtest_int_eq(n_tokens, 2);
+	pwtest_str_eq(res[0], "a");
+	pwtest_str_eq(res[1], "test string  \n \r ");
+	pwtest_ptr_null(res[2]);
+	pw_free_strv(res);
+
+	res = pw_split_strv(test2, del2, 2, &n_tokens);
+	pwtest_ptr_notnull(res);
+	pwtest_int_eq(n_tokens, 1);
+	pwtest_str_eq(res[0], "a");
+	pwtest_ptr_null(res[1]);
+	pw_free_strv(res);
+}
+
+PWTEST(utils_split)
+{
+	test__pw_split_walk();
+	test__pw_split_strv();
+
+	return PWTEST_PASS;
+}
+
+PWTEST(utils_strip)
+{
+	char test1[] = " \n\r \n a test string  \n \r ";
+	char test2[] = " \n\r \n   \n \r ";
+	char test3[] = "a test string";
+	spa_assert_se(spa_streq(pw_strip(test1, "\n\r "), "a test string"));
+	spa_assert_se(spa_streq(pw_strip(test2, "\n\r "), ""));
+	spa_assert_se(spa_streq(pw_strip(test3, "\n\r "), "a test string"));
+
+	return PWTEST_PASS;
+}
+
+PWTEST_SUITE(utils)
+{
+	pwtest_add(utils_abi, PWTEST_NOARG);
+	pwtest_add(utils_split, PWTEST_NOARG);
+	pwtest_add(utils_strip, PWTEST_NOARG);
+
+	return PWTEST_PASS;
+}