5 files changed, 1486 insertions, 0 deletions

diff --git a/lib/libc/gen/exect/t_exect.c b/lib/libc/gen/exect/t_exect.c
new file mode 100644
index 000000000000..4c85e4b2db4b
--- /dev/null
+++ b/lib/libc/gen/exect/t_exect.c
@@ -0,0 +1,90 @@
+/*	$NetBSD: t_exect.c,v 1.6 2016/12/12 10:34:55 joerg Exp $	*/
+
+/*-
+ * Copyright (c) 2014 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <atf-c.h>
+
+#include <errno.h>
+#include <signal.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <unistd.h>
+
+ATF_TC(t_exect_null);
+
+ATF_TC_HEAD(t_exect_null, tc)
+{
+	atf_tc_set_md_var(tc, "descr",
+	    "Tests an empty exect(2) executing");
+}
+
+static volatile sig_atomic_t caught = 0;
+
+static void
+sigtrap_handler(int sig, siginfo_t *info, void *ctx)
+{
+	ATF_REQUIRE_EQ(sig, SIGTRAP);
+	ATF_REQUIRE_EQ(info->si_code, TRAP_TRACE);
+
+	++caught;
+}
+
+ATF_TC_BODY(t_exect_null, tc)
+{
+	struct sigaction act;
+
+	/*
+	 * Currently exect(3) is misdesigned -- see PR port-amd64/51700 and it
+	 * needs to be redone from scratch.
+	 *
+	 * This test affects amd64 releng machines causing tests to hang or
+	 * fail. As there is little point to test interface that is still not,
+	 * designed and implemented and is breaking tests - skip it
+	 * unconditionally for all ports.
+	 */
+	/* Prevent static analysis from requiring t_exec_null to be __dead. */
+	if (!caught) 
+		atf_tc_skip("exect(3) misdesigned and hangs - PR port-amd64/51700");
+
+	ATF_REQUIRE(sigemptyset(&act.sa_mask) == 0);
+	act.sa_sigaction = sigtrap_handler;
+	act.sa_flags = SA_SIGINFO;
+
+	ATF_REQUIRE(sigaction(SIGTRAP, &act, 0) == 0);
+
+	ATF_REQUIRE_ERRNO(EFAULT, exect(NULL, NULL, NULL) == -1);
+
+	ATF_REQUIRE_EQ_MSG(caught, 1, "expected caught (1) != received (%d)",
+	    (int)caught);
+}
+
+ATF_TP_ADD_TCS(tp)
+{
+	ATF_TP_ADD_TC(tp, t_exect_null);
+
+	return atf_no_error();
+}
diff --git a/lib/libpthread_dbg/h_common.h b/lib/libpthread_dbg/h_common.h
new file mode 100644
index 000000000000..0a02b963d436
--- /dev/null
+++ b/lib/libpthread_dbg/h_common.h
@@ -0,0 +1,128 @@
+/*	$NetBSD: h_common.h,v 1.2 2016/11/19 02:30:54 kamil Exp $	*/
+
+/*-
+ * Copyright (c) 2016 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+#ifndef H_COMMON_H
+#define H_COMMON_H
+
+#include <sys/cdefs.h>
+#include <dlfcn.h>
+#include <pthread_dbg.h>
+#include <string.h>
+
+#include <atf-c.h>
+
+#define PTHREAD_REQUIRE(x) \
+    do { \
+        int ret = (x); \
+        ATF_REQUIRE_MSG(ret == 0, "%s: %s", #x, strerror(ret)); \
+    } while (0)
+
+#define PTHREAD_REQUIRE_STATUS(x, v) \
+    do { \
+        int ret = (x); \
+        ATF_REQUIRE_MSG(ret == (v), "%s: %s", #x, strerror(ret)); \
+    } while (0)
+
+static int __used
+dummy_proc_read(void *arg, caddr_t addr, void *buf, size_t size)
+{
+	return TD_ERR_ERR;
+}
+
+static int __used
+dummy_proc_write(void *arg, caddr_t addr, void *buf, size_t size)
+{
+	return TD_ERR_ERR;
+}
+
+static int __used
+dummy_proc_lookup(void *arg, const char *sym, caddr_t *addr)
+{
+	return TD_ERR_ERR;
+}
+
+static int __used
+dummy_proc_regsize(void *arg, int regset, size_t *size)
+{
+	return TD_ERR_ERR;
+}
+ 
+static int __used
+dummy_proc_getregs(void *arg, int regset, int lwp, void *buf)   
+{
+	return TD_ERR_ERR;
+}
+
+static int __used
+dummy_proc_setregs(void *arg, int regset, int lwp, void *buf)
+{
+	return TD_ERR_ERR;
+}
+
+/* Minimalistic basic implementation */
+
+static int __used
+basic_proc_read(void *arg, caddr_t addr, void *buf, size_t size)
+{
+	memcpy(buf, addr, size);
+
+	return TD_ERR_OK;
+}
+
+static int __used
+basic_proc_write(void *arg, caddr_t addr, void *buf, size_t size)
+{
+	memcpy(addr, buf, size);
+
+	return TD_ERR_OK;
+}
+
+static int __used
+basic_proc_lookup(void *arg, const char *sym, caddr_t *addr)
+{
+	void *handle;
+	void *symbol;
+
+	ATF_REQUIRE_MSG((handle = dlopen(NULL, RTLD_LOCAL | RTLD_LAZY))
+	    != NULL, "dlopen(3) failed: %s", dlerror());
+
+	symbol = dlsym(handle, sym);
+
+	ATF_REQUIRE_MSG(dlclose(handle) == 0, "dlclose(3) failed: %s",
+	    dlerror());
+
+	if (!symbol)
+		return TD_ERR_NOSYM;
+
+	*addr = (caddr_t)(uintptr_t)symbol;
+
+	return TD_ERR_OK;
+}
+
+#endif // H_COMMON_H
diff --git a/lib/libpthread_dbg/t_dummy.c b/lib/libpthread_dbg/t_dummy.c
new file mode 100644
index 000000000000..367443cd0351
--- /dev/null
+++ b/lib/libpthread_dbg/t_dummy.c
@@ -0,0 +1,131 @@
+/*	$NetBSD: t_dummy.c,v 1.6 2016/11/19 15:13:46 kamil Exp $	*/
+
+/*-
+ * Copyright (c) 2016 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+#include <sys/cdefs.h>
+__RCSID("$NetBSD: t_dummy.c,v 1.6 2016/11/19 15:13:46 kamil Exp $");
+
+#include "h_common.h"
+#include <pthread_dbg.h>
+#include <stdio.h>
+
+#include <atf-c.h>
+
+
+ATF_TC(dummy1);
+ATF_TC_HEAD(dummy1, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr",
+	    "Asserts that dummy lookup functions stop td_open() with failure");
+}
+
+ATF_TC_BODY(dummy1, tc)
+{
+
+	struct td_proc_callbacks_t dummy_callbacks;
+	td_proc_t *main_ta;
+
+	dummy_callbacks.proc_read	= dummy_proc_read;
+	dummy_callbacks.proc_write	= dummy_proc_write;
+	dummy_callbacks.proc_lookup	= dummy_proc_lookup;
+	dummy_callbacks.proc_regsize	= dummy_proc_regsize;
+	dummy_callbacks.proc_getregs	= dummy_proc_getregs;
+	dummy_callbacks.proc_setregs	= dummy_proc_setregs;
+
+	ATF_REQUIRE(td_open(&dummy_callbacks, NULL, &main_ta) == TD_ERR_ERR);
+}
+
+ATF_TC(dummy2);
+ATF_TC_HEAD(dummy2, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr",
+	    "Asserts that td_open() for basic proc_{read,write,lookup} works");
+}
+
+ATF_TC_BODY(dummy2, tc)
+{
+	struct td_proc_callbacks_t dummy_callbacks;
+	td_proc_t *main_ta;
+
+	dummy_callbacks.proc_read	= basic_proc_read;
+	dummy_callbacks.proc_write	= basic_proc_write;
+	dummy_callbacks.proc_lookup	= basic_proc_lookup;
+	dummy_callbacks.proc_regsize	= dummy_proc_regsize;
+	dummy_callbacks.proc_getregs	= dummy_proc_getregs;
+	dummy_callbacks.proc_setregs	= dummy_proc_setregs;
+
+	printf("Calling td_open(3)\n");
+	ATF_REQUIRE(td_open(&dummy_callbacks, NULL, &main_ta) == TD_ERR_OK);
+
+	printf("Calling td_close(3)\n");
+	ATF_REQUIRE(td_close(main_ta) == TD_ERR_OK);
+}
+
+ATF_TC(dummy3);
+ATF_TC_HEAD(dummy3, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr",
+	    "Asserts that calling twice td_open() for the same process fails");
+}
+
+ATF_TC_BODY(dummy3, tc)
+{
+	struct td_proc_callbacks_t dummy_callbacks;
+	td_proc_t *main_ta1;
+	td_proc_t *main_ta2;
+
+	dummy_callbacks.proc_read	= basic_proc_read;
+	dummy_callbacks.proc_write	= basic_proc_write;
+	dummy_callbacks.proc_lookup	= basic_proc_lookup;
+	dummy_callbacks.proc_regsize	= dummy_proc_regsize;
+	dummy_callbacks.proc_getregs	= dummy_proc_getregs;
+	dummy_callbacks.proc_setregs	= dummy_proc_setregs;
+
+	printf("Calling td_open(3) for the first time - expecting success\n");
+	ATF_REQUIRE(td_open(&dummy_callbacks, NULL, &main_ta1) == TD_ERR_OK);
+
+	printf("Calling td_open(3) for the first time - expecting in-use\n");
+	ATF_REQUIRE(td_open(&dummy_callbacks, NULL, &main_ta2) ==
+	    TD_ERR_INUSE);
+
+	printf("Calling td_close(3) for the first successful call\n");
+	ATF_REQUIRE(td_close(main_ta1) == TD_ERR_OK);
+}
+
+ATF_TP_ADD_TCS(tp)
+{
+
+	ATF_TP_ADD_TC(tp, dummy1);
+	ATF_TP_ADD_TC(tp, dummy2);
+	ATF_TP_ADD_TC(tp, dummy3);
+
+	return atf_no_error();
+}
diff --git a/lib/libpthread_dbg/t_threads.c b/lib/libpthread_dbg/t_threads.c
new file mode 100644
index 000000000000..f22bbc9c0563
--- /dev/null
+++ b/lib/libpthread_dbg/t_threads.c
@@ -0,0 +1,719 @@
+/*	$NetBSD: t_threads.c,v 1.9 2017/01/13 05:18:22 christos Exp $	*/
+
+/*-
+ * Copyright (c) 2016 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+#include <sys/cdefs.h>
+__RCSID("$NetBSD: t_threads.c,v 1.9 2017/01/13 05:18:22 christos Exp $");
+
+#include <dlfcn.h>
+#include <pthread.h>
+#include <pthread_dbg.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <atf-c.h>
+
+#include "h_common.h"
+
+#define MAX_THREADS (size_t)10
+
+ATF_TC(threads1);
+ATF_TC_HEAD(threads1, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr",
+	    "Asserts that td_thr_iter() call without extra logic works");
+}
+
+static volatile int exiting1;
+
+static void *
+busyFunction1(void *arg)
+{
+
+	while (exiting1 == 0)
+		usleep(50000);
+
+	return NULL;
+}
+
+static int
+iterateThreads1(td_thread_t *thread, void *arg)
+{
+
+	return TD_ERR_OK;
+}
+
+ATF_TC_BODY(threads1, tc)
+{
+	struct td_proc_callbacks_t dummy_callbacks;
+	td_proc_t *main_ta;
+	size_t i;
+	pthread_t threads[MAX_THREADS];
+
+	dummy_callbacks.proc_read	= basic_proc_read;
+	dummy_callbacks.proc_write	= basic_proc_write;
+	dummy_callbacks.proc_lookup	= basic_proc_lookup;
+	dummy_callbacks.proc_regsize	= dummy_proc_regsize;
+	dummy_callbacks.proc_getregs	= dummy_proc_getregs;
+	dummy_callbacks.proc_setregs	= dummy_proc_setregs;
+
+	for (i = 0; i < MAX_THREADS; i++) {
+		printf("Creating thread %zu\n", i);
+		PTHREAD_REQUIRE
+		    (pthread_create(&threads[i], NULL, busyFunction1, NULL));
+	}
+
+	printf("Calling td_open(3)\n");
+	ATF_REQUIRE(td_open(&dummy_callbacks, NULL, &main_ta) == TD_ERR_OK);
+
+	ATF_REQUIRE(td_thr_iter(main_ta, iterateThreads1, NULL) == TD_ERR_OK);
+
+	exiting1 = 1;
+
+	printf("Calling td_close(3)\n");
+	ATF_REQUIRE(td_close(main_ta) == TD_ERR_OK);
+}
+
+ATF_TC(threads2);
+ATF_TC_HEAD(threads2, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr",
+	    "Asserts that td_thr_iter() call is executed for each thread once");
+}
+
+static volatile int exiting2;
+
+static void *
+busyFunction2(void *arg)
+{
+
+	while (exiting2 == 0)
+		usleep(50000);
+
+	return NULL;
+}
+
+static int
+iterateThreads2(td_thread_t *thread, void *arg)
+{
+	int *counter = (int *)arg;
+
+	++(*counter);
+
+	return TD_ERR_OK;
+}
+
+ATF_TC_BODY(threads2, tc)
+{
+	struct td_proc_callbacks_t dummy_callbacks;
+	td_proc_t *main_ta;
+	size_t i;
+	pthread_t threads[MAX_THREADS];
+	int count = 0;
+
+	dummy_callbacks.proc_read	= basic_proc_read;
+	dummy_callbacks.proc_write	= basic_proc_write;
+	dummy_callbacks.proc_lookup	= basic_proc_lookup;
+	dummy_callbacks.proc_regsize	= dummy_proc_regsize;
+	dummy_callbacks.proc_getregs	= dummy_proc_getregs;
+	dummy_callbacks.proc_setregs	= dummy_proc_setregs;
+
+
+	for (i = 0; i < MAX_THREADS; i++) {
+		printf("Creating thread %zu\n", i);
+		PTHREAD_REQUIRE
+		    (pthread_create(&threads[i], NULL, busyFunction2, NULL));
+	}
+
+	printf("Calling td_open(3)\n");
+	ATF_REQUIRE(td_open(&dummy_callbacks, NULL, &main_ta) == TD_ERR_OK);
+
+	ATF_REQUIRE(td_thr_iter(main_ta, iterateThreads2, &count) == TD_ERR_OK);
+
+	exiting2 = 1;
+
+	printf("Calling td_close(3)\n");
+	ATF_REQUIRE(td_close(main_ta) == TD_ERR_OK);
+
+	ATF_REQUIRE_EQ_MSG(count, MAX_THREADS + 1,
+	    "counted threads (%d) != expected threads (%zu)",
+	    count, MAX_THREADS + 1);
+}
+
+ATF_TC(threads3);
+ATF_TC_HEAD(threads3, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr",
+	    "Asserts that for each td_thr_iter() call td_thr_info() is valid");
+}
+
+static volatile int exiting3;
+
+static void *
+busyFunction3(void *arg)
+{
+
+	while (exiting3 == 0)
+		usleep(50000);
+
+	return NULL;
+}
+
+static int
+iterateThreads3(td_thread_t *thread, void *arg)
+{
+	int *counter = (int *)arg;
+	td_thread_info_t info;
+
+	ATF_REQUIRE(td_thr_info(thread, &info) == TD_ERR_OK);
+
+	++(*counter);
+
+	return TD_ERR_OK;
+}
+
+ATF_TC_BODY(threads3, tc)
+{
+	struct td_proc_callbacks_t dummy_callbacks;
+	td_proc_t *main_ta;
+	size_t i;
+	pthread_t threads[MAX_THREADS];
+	int count = 0;
+
+	dummy_callbacks.proc_read	= basic_proc_read;
+	dummy_callbacks.proc_write	= basic_proc_write;
+	dummy_callbacks.proc_lookup	= basic_proc_lookup;
+	dummy_callbacks.proc_regsize	= dummy_proc_regsize;
+	dummy_callbacks.proc_getregs	= dummy_proc_getregs;
+	dummy_callbacks.proc_setregs	= dummy_proc_setregs;
+
+
+	for (i = 0; i < MAX_THREADS; i++) {
+		printf("Creating thread %zu\n", i);
+		PTHREAD_REQUIRE
+		    (pthread_create(&threads[i], NULL, busyFunction3, NULL));
+	}
+
+	printf("Calling td_open(3)\n");
+	ATF_REQUIRE(td_open(&dummy_callbacks, NULL, &main_ta) == TD_ERR_OK);
+
+	ATF_REQUIRE(td_thr_iter(main_ta, iterateThreads3, &count) == TD_ERR_OK);
+
+	exiting3 = 1;
+
+	printf("Calling td_close(3)\n");
+	ATF_REQUIRE(td_close(main_ta) == TD_ERR_OK);
+
+	ATF_REQUIRE_EQ_MSG(count, MAX_THREADS + 1,
+	    "counted threads (%d) != expected threads (%zu)",
+	    count, MAX_THREADS + 1);
+}
+
+ATF_TC(threads4);
+ATF_TC_HEAD(threads4, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr",
+	    "Asserts that for each td_thr_iter() call td_thr_getname() is "
+	    "valid");
+}
+
+static volatile int exiting4;
+
+static void *
+busyFunction4(void *arg)
+{
+
+	while (exiting4 == 0)
+		usleep(50000);
+
+	return NULL;
+}
+
+static int
+iterateThreads4(td_thread_t *thread, void *arg)
+{
+	int *counter = (int *)arg;
+	char name[PTHREAD_MAX_NAMELEN_NP];
+
+	ATF_REQUIRE(td_thr_getname(thread, name, sizeof(name)) == TD_ERR_OK);
+
+	printf("Thread name: %s\n", name);
+
+	++(*counter);
+
+	return TD_ERR_OK;
+}
+
+ATF_TC_BODY(threads4, tc)
+{
+	struct td_proc_callbacks_t dummy_callbacks;
+	td_proc_t *main_ta;
+	size_t i;
+	pthread_t threads[MAX_THREADS];
+	int count = 0;
+
+	dummy_callbacks.proc_read	= basic_proc_read;
+	dummy_callbacks.proc_write	= basic_proc_write;
+	dummy_callbacks.proc_lookup	= basic_proc_lookup;
+	dummy_callbacks.proc_regsize	= dummy_proc_regsize;
+	dummy_callbacks.proc_getregs	= dummy_proc_getregs;
+	dummy_callbacks.proc_setregs	= dummy_proc_setregs;
+
+	for (i = 0; i < MAX_THREADS; i++) {
+		printf("Creating thread %zu\n", i);
+		PTHREAD_REQUIRE
+		    (pthread_create(&threads[i], NULL, busyFunction4, NULL));
+	}
+
+	for (i = 0; i < MAX_THREADS; i++) {
+		PTHREAD_REQUIRE
+		    (pthread_setname_np(threads[i], "test_%d", (void*)i));
+	}
+
+	printf("Calling td_open(3)\n");
+	ATF_REQUIRE(td_open(&dummy_callbacks, NULL, &main_ta) == TD_ERR_OK);
+
+	ATF_REQUIRE(td_thr_iter(main_ta, iterateThreads4, &count) == TD_ERR_OK);
+
+	exiting4 = 1;
+
+	printf("Calling td_close(3)\n");
+	ATF_REQUIRE(td_close(main_ta) == TD_ERR_OK);
+
+	ATF_REQUIRE_EQ_MSG(count, MAX_THREADS + 1,
+	    "counted threads (%d) != expected threads (%zu)",
+	    count, MAX_THREADS + 1);
+}
+
+ATF_TC(threads5);
+ATF_TC_HEAD(threads5, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr",
+	    "Asserts that td_thr_getname() handles shorter buffer parameter "
+	    "and the result is properly truncated");
+}
+
+static volatile int exiting5;
+
+static void *
+busyFunction5(void *arg)
+{
+
+	while (exiting5 == 0)
+		usleep(50000);
+
+	return NULL;
+}
+
+static int
+iterateThreads5(td_thread_t *thread, void *arg)
+{
+	int *counter = (int *)arg;
+	/* Arbitrarily short string buffer */
+	char name[3];
+
+	ATF_REQUIRE(td_thr_getname(thread, name, sizeof(name)) == TD_ERR_OK);
+
+	printf("Thread name: %s\n", name);
+
+	/* strlen(3) does not count including a '\0' character */
+	ATF_REQUIRE(strlen(name) < sizeof(name));
+
+	++(*counter);
+
+	return TD_ERR_OK;
+}
+
+ATF_TC_BODY(threads5, tc)
+{
+	struct td_proc_callbacks_t dummy_callbacks;
+	td_proc_t *main_ta;
+	size_t i;
+	pthread_t threads[MAX_THREADS];
+	int count = 0;
+
+	dummy_callbacks.proc_read	= basic_proc_read;
+	dummy_callbacks.proc_write	= basic_proc_write;
+	dummy_callbacks.proc_lookup	= basic_proc_lookup;
+	dummy_callbacks.proc_regsize	= dummy_proc_regsize;
+	dummy_callbacks.proc_getregs	= dummy_proc_getregs;
+	dummy_callbacks.proc_setregs	= dummy_proc_setregs;
+
+	for (i = 0; i < MAX_THREADS; i++) {
+		printf("Creating thread %zu\n", i);
+		PTHREAD_REQUIRE
+		    (pthread_create(&threads[i], NULL, busyFunction5, NULL));
+	}
+
+	for (i = 0; i < MAX_THREADS; i++) {
+		PTHREAD_REQUIRE
+		    (pthread_setname_np(threads[i], "test_%d", (void*)i));
+	}
+
+	printf("Calling td_open(3)\n");
+	ATF_REQUIRE(td_open(&dummy_callbacks, NULL, &main_ta) == TD_ERR_OK);
+
+	ATF_REQUIRE(td_thr_iter(main_ta, iterateThreads5, &count) == TD_ERR_OK);
+
+	exiting5 = 1;
+
+	printf("Calling td_close(3)\n");
+	ATF_REQUIRE(td_close(main_ta) == TD_ERR_OK);
+
+	ATF_REQUIRE_EQ_MSG(count, MAX_THREADS + 1,
+	    "counted threads (%d) != expected threads (%zu)",
+	    count, MAX_THREADS + 1);
+}
+
+ATF_TC(threads6);
+ATF_TC_HEAD(threads6, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr",
+	    "Asserts that pthread_t can be translated with td_map_pth2thr() "
+	    "to td_thread_t -- and assert earlier that td_thr_iter() call is "
+	    "valid");
+}
+
+static volatile int exiting6;
+
+static void *
+busyFunction6(void *arg)
+{
+
+	while (exiting6 == 0)
+		usleep(50000);
+
+	return NULL;
+}
+
+static int
+iterateThreads6(td_thread_t *thread, void *arg)
+{
+	int *counter = (int *)arg;
+
+	++(*counter);
+
+	return TD_ERR_OK;
+}
+
+ATF_TC_BODY(threads6, tc)
+{
+	struct td_proc_callbacks_t dummy_callbacks;
+	td_proc_t *main_ta;
+	size_t i;
+	pthread_t threads[MAX_THREADS];
+	int count = 0;
+
+	dummy_callbacks.proc_read	= basic_proc_read;
+	dummy_callbacks.proc_write	= basic_proc_write;
+	dummy_callbacks.proc_lookup	= basic_proc_lookup;
+	dummy_callbacks.proc_regsize	= dummy_proc_regsize;
+	dummy_callbacks.proc_getregs	= dummy_proc_getregs;
+	dummy_callbacks.proc_setregs	= dummy_proc_setregs;
+
+	for (i = 0; i < MAX_THREADS; i++) {
+		printf("Creating thread %zu\n", i);
+		PTHREAD_REQUIRE
+		    (pthread_create(&threads[i], NULL, busyFunction6, NULL));
+	}
+
+	printf("Calling td_open(3)\n");
+	ATF_REQUIRE(td_open(&dummy_callbacks, NULL, &main_ta) == TD_ERR_OK);
+
+	ATF_REQUIRE(td_thr_iter(main_ta, iterateThreads6, &count) == TD_ERR_OK);
+
+	for (i = 0; i < MAX_THREADS; i++) {
+		td_thread_t *td_thread;
+		ATF_REQUIRE(td_map_pth2thr(main_ta, threads[i], &td_thread)
+		    == TD_ERR_OK);
+	}
+
+	exiting6 = 1;
+
+	printf("Calling td_close(3)\n");
+	ATF_REQUIRE(td_close(main_ta) == TD_ERR_OK);
+
+	ATF_REQUIRE_EQ_MSG(count, MAX_THREADS + 1,
+	    "counted threads (%d) != expected threads (%zu)",
+	    count, MAX_THREADS + 1);
+}
+
+ATF_TC(threads7);
+ATF_TC_HEAD(threads7, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr",
+	    "Asserts that pthread_t can be translated with td_map_pth2thr() "
+	    "to td_thread_t -- and assert later that td_thr_iter() call is "
+	    "valid");
+}
+
+static volatile int exiting7;
+
+static void *
+busyFunction7(void *arg)
+{
+
+	while (exiting7 == 0)
+		usleep(50000);
+
+	return NULL;
+}
+
+static int
+iterateThreads7(td_thread_t *thread, void *arg)
+{
+	int *counter = (int *)arg;
+
+	++(*counter);
+
+	return TD_ERR_OK;
+}
+
+ATF_TC_BODY(threads7, tc)
+{
+	struct td_proc_callbacks_t dummy_callbacks;
+	td_proc_t *main_ta;
+	size_t i;
+	pthread_t threads[MAX_THREADS];
+	int count = 0;
+
+	dummy_callbacks.proc_read	= basic_proc_read;
+	dummy_callbacks.proc_write	= basic_proc_write;
+	dummy_callbacks.proc_lookup	= basic_proc_lookup;
+	dummy_callbacks.proc_regsize	= dummy_proc_regsize;
+	dummy_callbacks.proc_getregs	= dummy_proc_getregs;
+	dummy_callbacks.proc_setregs	= dummy_proc_setregs;
+
+	for (i = 0; i < MAX_THREADS; i++) {
+		printf("Creating thread %zu\n", i);
+		PTHREAD_REQUIRE
+		    (pthread_create(&threads[i], NULL, busyFunction7, NULL));
+	}
+
+	printf("Calling td_open(3)\n");
+	ATF_REQUIRE(td_open(&dummy_callbacks, NULL, &main_ta) == TD_ERR_OK);
+
+	for (i = 0; i < MAX_THREADS; i++) {
+		td_thread_t *td_thread;
+		ATF_REQUIRE(td_map_pth2thr(main_ta, threads[i], &td_thread)
+		    == TD_ERR_OK);
+	}
+
+	ATF_REQUIRE(td_thr_iter(main_ta, iterateThreads7, &count) == TD_ERR_OK);
+
+	exiting7 = 1;
+
+	printf("Calling td_close(3)\n");
+	ATF_REQUIRE(td_close(main_ta) == TD_ERR_OK);
+
+	ATF_REQUIRE_EQ_MSG(count, MAX_THREADS + 1,
+	    "counted threads (%d) != expected threads (%zu)",
+	    count, MAX_THREADS + 1);
+}
+
+ATF_TC(threads8);
+ATF_TC_HEAD(threads8, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr",
+	    "Asserts that pthread_t can be translated with td_map_pth2thr() "
+	    "to td_thread_t -- compare thread's name of pthread_t and "
+	    "td_thread_t");
+}
+
+static volatile int exiting8;
+
+static void *
+busyFunction8(void *arg)
+{
+
+	while (exiting8 == 0)
+		usleep(50000);
+
+	return NULL;
+}
+
+static int
+iterateThreads8(td_thread_t *thread, void *arg)
+{
+	int *counter = (int *)arg;
+
+	++(*counter);
+
+	return TD_ERR_OK;
+}
+
+ATF_TC_BODY(threads8, tc)
+{
+	struct td_proc_callbacks_t dummy_callbacks;
+	td_proc_t *main_ta;
+	size_t i;
+	pthread_t threads[MAX_THREADS];
+	int count = 0;
+
+	dummy_callbacks.proc_read	= basic_proc_read;
+	dummy_callbacks.proc_write	= basic_proc_write;
+	dummy_callbacks.proc_lookup	= basic_proc_lookup;
+	dummy_callbacks.proc_regsize	= dummy_proc_regsize;
+	dummy_callbacks.proc_getregs	= dummy_proc_getregs;
+	dummy_callbacks.proc_setregs	= dummy_proc_setregs;
+
+	for (i = 0; i < MAX_THREADS; i++) {
+		printf("Creating thread %zu\n", i);
+		PTHREAD_REQUIRE
+		    (pthread_create(&threads[i], NULL, busyFunction8, NULL));
+	}
+
+	printf("Calling td_open(3)\n");
+	ATF_REQUIRE(td_open(&dummy_callbacks, NULL, &main_ta) == TD_ERR_OK);
+
+	ATF_REQUIRE(td_thr_iter(main_ta, iterateThreads8, &count) == TD_ERR_OK);
+
+	for (i = 0; i < MAX_THREADS; i++) {
+		td_thread_t *td_thread;
+		char td_threadname[PTHREAD_MAX_NAMELEN_NP];
+		char pth_threadname[PTHREAD_MAX_NAMELEN_NP];
+		ATF_REQUIRE(td_map_pth2thr(main_ta, threads[i], &td_thread)
+		    == TD_ERR_OK);
+		ATF_REQUIRE(td_thr_getname(td_thread, td_threadname,
+		    sizeof(td_threadname)) == TD_ERR_OK);
+		PTHREAD_REQUIRE(pthread_getname_np(threads[i], pth_threadname,
+		    sizeof(pth_threadname)));
+		ATF_REQUIRE(strcmp(td_threadname, pth_threadname) == 0);
+	}
+
+	exiting8 = 1;
+
+	printf("Calling td_close(3)\n");
+	ATF_REQUIRE(td_close(main_ta) == TD_ERR_OK);
+
+	ATF_REQUIRE_EQ_MSG(count, MAX_THREADS + 1,
+	    "counted threads (%d) != expected threads (%zu)",
+	    count, MAX_THREADS + 1);
+}
+
+ATF_TC(threads9);
+ATF_TC_HEAD(threads9, tc)
+{
+
+	atf_tc_set_md_var(tc, "descr",
+	    "Asserts that pthread_t can be translated with td_map_pth2thr() "
+	    "to td_thread_t -- assert that thread is in the TD_STATE_RUNNING "
+            "state");
+}
+
+static volatile int exiting9;
+
+static void *
+busyFunction9(void *arg)
+{
+
+	while (exiting9 == 0)
+		usleep(50000);
+
+	return NULL;
+}
+
+static int
+iterateThreads9(td_thread_t *thread, void *arg)
+{
+	int *counter = (int *)arg;
+
+	++(*counter);
+
+	return TD_ERR_OK;
+}
+
+ATF_TC_BODY(threads9, tc)
+{
+	struct td_proc_callbacks_t dummy_callbacks;
+	td_proc_t *main_ta;
+	size_t i;
+	pthread_t threads[MAX_THREADS];
+	int count = 0;
+
+	dummy_callbacks.proc_read	= basic_proc_read;
+	dummy_callbacks.proc_write	= basic_proc_write;
+	dummy_callbacks.proc_lookup	= basic_proc_lookup;
+	dummy_callbacks.proc_regsize	= dummy_proc_regsize;
+	dummy_callbacks.proc_getregs	= dummy_proc_getregs;
+	dummy_callbacks.proc_setregs	= dummy_proc_setregs;
+
+	for (i = 0; i < MAX_THREADS; i++) {
+		printf("Creating thread %zu\n", i);
+		PTHREAD_REQUIRE
+		    (pthread_create(&threads[i], NULL, busyFunction9, NULL));
+	}
+
+	printf("Calling td_open(3)\n");
+	ATF_REQUIRE(td_open(&dummy_callbacks, NULL, &main_ta) == TD_ERR_OK);
+
+	for (i = 0; i < MAX_THREADS; i++) {
+		td_thread_t *td_thread;
+		td_thread_info_t info;
+		ATF_REQUIRE(td_map_pth2thr(main_ta, threads[i], &td_thread)
+		    == TD_ERR_OK);
+		ATF_REQUIRE(td_thr_info(td_thread, &info) == TD_ERR_OK);
+		ATF_REQUIRE_EQ(info.thread_state, TD_STATE_RUNNING);
+	}
+
+	ATF_REQUIRE(td_thr_iter(main_ta, iterateThreads9, &count) == TD_ERR_OK);
+
+	exiting9 = 1;
+
+	printf("Calling td_close(3)\n");
+	ATF_REQUIRE(td_close(main_ta) == TD_ERR_OK);
+
+	ATF_REQUIRE_EQ_MSG(count, MAX_THREADS + 1,
+	    "counted threads (%d) != expected threads (%zu)",
+	    count, MAX_THREADS + 1);
+}
+
+ATF_TP_ADD_TCS(tp)
+{
+
+	ATF_TP_ADD_TC(tp, threads1);
+	ATF_TP_ADD_TC(tp, threads2);
+	ATF_TP_ADD_TC(tp, threads3);
+	ATF_TP_ADD_TC(tp, threads4);
+	ATF_TP_ADD_TC(tp, threads5);
+	ATF_TP_ADD_TC(tp, threads6);
+	ATF_TP_ADD_TC(tp, threads7);
+	ATF_TP_ADD_TC(tp, threads8);
+	ATF_TP_ADD_TC(tp, threads9);
+
+	return atf_no_error();
+}
diff --git a/lib/librefuse/t_refuse_opt.c b/lib/librefuse/t_refuse_opt.c
new file mode 100644
index 000000000000..23c2803f8552
--- /dev/null
+++ b/lib/librefuse/t_refuse_opt.c
@@ -0,0 +1,418 @@
+/*	$NetBSD: t_refuse_opt.c,v 1.8 2017/01/13 21:30:41 christos Exp $ */
+
+/*-
+ * Copyright (c) 2016 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.	IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <sys/cdefs.h>
+__RCSID("$NetBSD: t_refuse_opt.c,v 1.8 2017/01/13 21:30:41 christos Exp $");
+
+#define _KERNTYPES
+#include <sys/types.h>
+
+#include <atf-c.h>
+
+#include <fuse.h>
+
+#include "h_macros.h"
+
+ATF_TC(t_fuse_opt_add_arg);
+ATF_TC_HEAD(t_fuse_opt_add_arg, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "Check that fuse_opt_add_arg(3) works");
+}
+
+ATF_TC_BODY(t_fuse_opt_add_arg, tc)
+{
+	struct fuse_args args = FUSE_ARGS_INIT(0, NULL);
+
+	RZ(fuse_opt_add_arg(&args, "foo"));
+	RZ(fuse_opt_add_arg(&args, "bar"));
+
+	ATF_REQUIRE_EQ(args.argc, 2);
+	ATF_CHECK_STREQ(args.argv[0], "foo");
+	ATF_CHECK_STREQ(args.argv[1], "bar");
+	ATF_CHECK(args.allocated != 0);
+}
+
+ATF_TC(t_fuse_opt_insert_arg);
+ATF_TC_HEAD(t_fuse_opt_insert_arg, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "Check that fuse_opt_insert_arg(3) works");
+}
+
+ATF_TC_BODY(t_fuse_opt_insert_arg, tc)
+{
+	struct fuse_args args = FUSE_ARGS_INIT(0, NULL);
+
+	RZ(fuse_opt_insert_arg(&args, 0, "foo"));
+	RZ(fuse_opt_insert_arg(&args, 0, "bar"));
+
+	ATF_REQUIRE_EQ(args.argc, 2);
+	ATF_CHECK_STREQ(args.argv[0], "bar");
+	ATF_CHECK_STREQ(args.argv[1], "foo");
+	ATF_CHECK(args.allocated != 0);
+}
+
+ATF_TC(t_fuse_opt_add_opt);
+ATF_TC_HEAD(t_fuse_opt_add_opt, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "Check that fuse_opt_add_opt(3) works");
+}
+
+ATF_TC_BODY(t_fuse_opt_add_opt, tc)
+{
+	char* opt = NULL;
+
+	RZ(fuse_opt_add_opt(&opt, "fo\\o"));
+	ATF_CHECK_STREQ(opt, "fo\\o");
+
+	RZ(fuse_opt_add_opt(&opt, "ba,r"));
+	ATF_CHECK_STREQ(opt, "fo\\o,ba,r");
+}
+
+ATF_TC(t_fuse_opt_add_opt_escaped);
+ATF_TC_HEAD(t_fuse_opt_add_opt_escaped, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "Check that fuse_opt_add_opt_escaped(3) works");
+}
+
+ATF_TC_BODY(t_fuse_opt_add_opt_escaped, tc)
+{
+	char* opt = NULL;
+
+	RZ(fuse_opt_add_opt_escaped(&opt, "fo\\o"));
+	ATF_CHECK_STREQ(opt, "fo\\\\o");
+
+	RZ(fuse_opt_add_opt_escaped(&opt, "ba,r"));
+	ATF_CHECK_STREQ(opt, "fo\\\\o,ba\\,r");
+}
+
+ATF_TC(t_fuse_opt_match);
+ATF_TC_HEAD(t_fuse_opt_match, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "Check that fuse_opt_match(3) works"
+					  " for every form of templates");
+}
+
+ATF_TC_BODY(t_fuse_opt_match, tc)
+{
+	struct fuse_opt o1[] = { FUSE_OPT_KEY("-x"    , 0), FUSE_OPT_END };
+	struct fuse_opt o2[] = { FUSE_OPT_KEY("foo"   , 0), FUSE_OPT_END };
+	struct fuse_opt o3[] = { FUSE_OPT_KEY("foo="  , 0), FUSE_OPT_END };
+	struct fuse_opt o4[] = { FUSE_OPT_KEY("foo=%s", 0), FUSE_OPT_END };
+	struct fuse_opt o5[] = { FUSE_OPT_KEY("-x "   , 0), FUSE_OPT_END };
+	struct fuse_opt o6[] = { FUSE_OPT_KEY("-x %s" , 0), FUSE_OPT_END };
+
+	ATF_CHECK(fuse_opt_match(o1, "-x") == 1);
+	ATF_CHECK(fuse_opt_match(o1,  "x") == 0);
+
+	ATF_CHECK(fuse_opt_match(o2,  "foo") == 1);
+	ATF_CHECK(fuse_opt_match(o2, "-foo") == 0);
+
+	ATF_CHECK(fuse_opt_match(o3, "foo=bar") == 1);
+	ATF_CHECK(fuse_opt_match(o3, "foo"    ) == 0);
+
+	ATF_CHECK(fuse_opt_match(o4, "foo=bar") == 1);
+	ATF_CHECK(fuse_opt_match(o4, "foo"    ) == 0);
+
+	ATF_CHECK(fuse_opt_match(o5, "-xbar" ) == 1);
+	ATF_CHECK(fuse_opt_match(o5, "-x"    ) == 1);
+	ATF_CHECK(fuse_opt_match(o5, "-x=bar") == 1);
+	ATF_CHECK(fuse_opt_match(o5, "bar"   ) == 0);
+
+	ATF_CHECK(fuse_opt_match(o6, "-xbar" ) == 1);
+	ATF_CHECK(fuse_opt_match(o6, "-x"    ) == 1);
+	ATF_CHECK(fuse_opt_match(o6, "-x=bar") == 1);
+	ATF_CHECK(fuse_opt_match(o6, "bar"   ) == 0);
+}
+
+struct foofs_config {
+	int number;
+	char *string;
+	char* nonopt;
+};
+
+#define FOOFS_OPT(t, p, v) { t, offsetof(struct foofs_config, p), v }
+
+static struct fuse_opt foofs_opts[] = {
+	FOOFS_OPT("number=%i"     , number, 0),
+	FOOFS_OPT("-n %i"         , number, 0),
+	FOOFS_OPT("string=%s"     , string, 0),
+	FOOFS_OPT("number1"       , number, 1),
+	FOOFS_OPT("number2"       , number, 2),
+	FOOFS_OPT("--number=three", number, 3),
+	FOOFS_OPT("--number=four" , number, 4),
+	FUSE_OPT_END
+};
+
+static int foo_opt_proc(void *data, const char *arg, int key, struct fuse_args *outargs) {
+	struct foofs_config *config = data;
+
+	if (key == FUSE_OPT_KEY_NONOPT && config->nonopt == NULL) {
+		config->nonopt = strdup(arg);
+		return 0;
+	}
+	else {
+		return 1;
+	}
+}
+
+ATF_TC(t_fuse_opt_parse_null_args);
+ATF_TC_HEAD(t_fuse_opt_parse_null_args, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "NULL args means an empty arguments vector");
+}
+
+ATF_TC_BODY(t_fuse_opt_parse_null_args, tc)
+{
+	struct foofs_config config;
+
+	memset(&config, 0, sizeof(config));
+	ATF_CHECK(fuse_opt_parse(NULL, &config, NULL, NULL) == 0);
+	ATF_CHECK_EQ(config.number, 0);
+	ATF_CHECK_EQ(config.string, NULL);
+	ATF_CHECK_EQ(config.nonopt, NULL);
+}
+
+ATF_TC(t_fuse_opt_parse_null_opts);
+ATF_TC_HEAD(t_fuse_opt_parse_null_opts, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "NULL opts means an opts array which only has FUSE_OPT_END");
+}
+
+ATF_TC_BODY(t_fuse_opt_parse_null_opts, tc)
+{
+	struct fuse_args args = FUSE_ARGS_INIT(0, NULL);
+	struct foofs_config config;
+
+	RZ(fuse_opt_add_arg(&args, "foofs"));
+	RZ(fuse_opt_add_arg(&args, "-o"));
+	RZ(fuse_opt_add_arg(&args, "number=1,string=foo"));
+	RZ(fuse_opt_add_arg(&args, "bar"));
+
+	memset(&config, 0, sizeof(config));
+	ATF_CHECK(fuse_opt_parse(&args, &config, NULL, NULL) == 0);
+	ATF_CHECK_EQ(config.number, 0);
+	ATF_CHECK_EQ(config.string, NULL);
+	ATF_CHECK_EQ(config.nonopt, NULL);
+	ATF_CHECK_EQ(args.argc, 4);
+	ATF_CHECK_STREQ(args.argv[0], "foofs");
+	ATF_CHECK_STREQ(args.argv[1], "-o");
+	ATF_CHECK_STREQ(args.argv[2], "number=1,string=foo");
+	ATF_CHECK_STREQ(args.argv[3], "bar");
+}
+
+ATF_TC(t_fuse_opt_parse_null_proc);
+ATF_TC_HEAD(t_fuse_opt_parse_null_proc, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "NULL proc means a processor function always returning 1,"
+					  " i.e. keep the argument");
+}
+
+ATF_TC_BODY(t_fuse_opt_parse_null_proc, tc)
+{
+	struct fuse_args args = FUSE_ARGS_INIT(0, NULL);
+	struct foofs_config config;
+
+	RZ(fuse_opt_add_arg(&args, "foofs"));
+	RZ(fuse_opt_add_arg(&args, "-o"));
+	RZ(fuse_opt_add_arg(&args, "number=1,string=foo"));
+	RZ(fuse_opt_add_arg(&args, "bar"));
+
+	memset(&config, 0, sizeof(config));
+	ATF_CHECK(fuse_opt_parse(&args, &config, foofs_opts, NULL) == 0);
+	ATF_CHECK_EQ(config.number, 1);
+	ATF_CHECK_STREQ(config.string, "foo");
+	ATF_CHECK_EQ(config.nonopt, NULL);
+	ATF_CHECK_EQ(args.argc, 2);
+	ATF_CHECK_STREQ(args.argv[0], "foofs");
+	ATF_CHECK_STREQ(args.argv[1], "bar");
+}
+
+ATF_TC(t_fuse_opt_parse);
+ATF_TC_HEAD(t_fuse_opt_parse, tc)
+{
+	atf_tc_set_md_var(tc, "descr", "Check that fuse_opt_parse(3) fully works");
+}
+
+ATF_TC_BODY(t_fuse_opt_parse, tc)
+{
+	struct fuse_args args = FUSE_ARGS_INIT(0, NULL);
+	struct foofs_config config;
+
+    /* Standard form */
+	fuse_opt_free_args(&args);
+	RZ(fuse_opt_add_arg(&args, "foofs"));
+	RZ(fuse_opt_add_arg(&args, "-o"));
+	RZ(fuse_opt_add_arg(&args, "number=1,string=foo"));
+	RZ(fuse_opt_add_arg(&args, "bar"));
+
+	memset(&config, 0, sizeof(config));
+	ATF_CHECK(fuse_opt_parse(&args, &config, foofs_opts, foo_opt_proc) == 0);
+	ATF_CHECK_EQ(config.number, 1);
+	ATF_CHECK_STREQ(config.string, "foo");
+	ATF_CHECK_STREQ(config.nonopt, "bar");
+	ATF_CHECK_EQ(args.argc, 1);
+	ATF_CHECK_STREQ(args.argv[0], "foofs");
+
+    /* Concatenated -o */
+	fuse_opt_free_args(&args);
+	RZ(fuse_opt_add_arg(&args, "foofs"));
+	RZ(fuse_opt_add_arg(&args, "-onumber=1,unknown,string=foo"));
+	RZ(fuse_opt_add_arg(&args, "bar"));
+
+	memset(&config, 0, sizeof(config));
+	ATF_CHECK(fuse_opt_parse(&args, &config, foofs_opts, foo_opt_proc) == 0);
+	ATF_CHECK_EQ(config.number, 1);
+	ATF_CHECK_STREQ(config.string, "foo");
+	ATF_CHECK_STREQ(config.nonopt, "bar");
+	ATF_CHECK_EQ(args.argc, 3);
+	ATF_CHECK_STREQ(args.argv[0], "foofs");
+	ATF_CHECK_STREQ(args.argv[1], "-o");
+	ATF_CHECK_STREQ(args.argv[2], "unknown");
+
+	/* Sparse -o */
+	fuse_opt_free_args(&args);
+	RZ(fuse_opt_add_arg(&args, "foofs"));
+	RZ(fuse_opt_add_arg(&args, "bar"));
+	RZ(fuse_opt_add_arg(&args, "baz"));
+	RZ(fuse_opt_add_arg(&args, "-o"));
+	RZ(fuse_opt_add_arg(&args, "number=1"));
+	RZ(fuse_opt_add_arg(&args, "-o"));
+	RZ(fuse_opt_add_arg(&args, "unknown"));
+	RZ(fuse_opt_add_arg(&args, "-o"));
+	RZ(fuse_opt_add_arg(&args, "string=foo"));
+
+	memset(&config, 0, sizeof(config));
+	ATF_CHECK(fuse_opt_parse(&args, &config, foofs_opts, foo_opt_proc) == 0);
+	ATF_CHECK_EQ(config.number, 1);
+	ATF_CHECK_STREQ(config.string, "foo");
+	ATF_CHECK_STREQ(config.nonopt, "bar");
+	ATF_CHECK_EQ(args.argc, 4);
+	ATF_CHECK_STREQ(args.argv[0], "foofs");
+	ATF_CHECK_STREQ(args.argv[1], "-o");
+	ATF_CHECK_STREQ(args.argv[2], "unknown");
+	ATF_CHECK_STREQ(args.argv[3], "baz");
+
+	/* Separate -n %i */
+	fuse_opt_free_args(&args);
+	RZ(fuse_opt_add_arg(&args, "foofs"));
+	RZ(fuse_opt_add_arg(&args, "-n"));
+	RZ(fuse_opt_add_arg(&args, "3"));
+
+	memset(&config, 0, sizeof(config));
+	ATF_CHECK(fuse_opt_parse(&args, &config, foofs_opts, foo_opt_proc) == 0);
+	ATF_CHECK_EQ(config.number, 3);
+	ATF_CHECK_EQ(config.string, NULL);
+	ATF_CHECK_EQ(config.nonopt, NULL);
+	ATF_CHECK_EQ(args.argc, 1);
+	ATF_CHECK_STREQ(args.argv[0], "foofs");
+
+	/* Concatenated -n %i */
+	fuse_opt_free_args(&args);
+	RZ(fuse_opt_add_arg(&args, "foofs"));
+	RZ(fuse_opt_add_arg(&args, "-n3"));
+
+	memset(&config, 0, sizeof(config));
+	ATF_CHECK(fuse_opt_parse(&args, &config, foofs_opts, foo_opt_proc) == 0);
+	ATF_CHECK_EQ(config.number, 3);
+	ATF_CHECK_EQ(config.string, NULL);
+	ATF_CHECK_EQ(config.nonopt, NULL);
+	ATF_CHECK_EQ(args.argc, 1);
+	ATF_CHECK_STREQ(args.argv[0], "foofs");
+
+	/* -o constant */
+	fuse_opt_free_args(&args);
+	RZ(fuse_opt_add_arg(&args, "foofs"));
+	RZ(fuse_opt_add_arg(&args, "-o"));
+	RZ(fuse_opt_add_arg(&args, "number2"));
+
+	memset(&config, 0, sizeof(config));
+	ATF_CHECK(fuse_opt_parse(&args, &config, foofs_opts, foo_opt_proc) == 0);
+	ATF_CHECK_EQ(config.number, 2);
+	ATF_CHECK_EQ(config.string, NULL);
+	ATF_CHECK_EQ(config.nonopt, NULL);
+	ATF_CHECK_EQ(args.argc, 1);
+	ATF_CHECK_STREQ(args.argv[0], "foofs");
+
+	/* -x constant */
+	fuse_opt_free_args(&args);
+	RZ(fuse_opt_add_arg(&args, "foofs"));
+	RZ(fuse_opt_add_arg(&args, "--number=four"));
+
+	memset(&config, 0, sizeof(config));
+	ATF_CHECK(fuse_opt_parse(&args, &config, foofs_opts, foo_opt_proc) == 0);
+	ATF_CHECK_EQ(config.number, 4);
+	ATF_CHECK_EQ(config.string, NULL);
+	ATF_CHECK_EQ(config.nonopt, NULL);
+	ATF_CHECK_EQ(args.argc, 1);
+	ATF_CHECK_STREQ(args.argv[0], "foofs");
+
+	/* end-of-options "--" marker */
+	fuse_opt_free_args(&args);
+	RZ(fuse_opt_add_arg(&args, "foofs"));
+    RZ(fuse_opt_add_arg(&args, "--"));
+	RZ(fuse_opt_add_arg(&args, "-onumber=1"));
+	RZ(fuse_opt_add_arg(&args, "-ostring=foo"));
+
+	memset(&config, 0, sizeof(config));
+	ATF_CHECK(fuse_opt_parse(&args, &config, foofs_opts, foo_opt_proc) == 0);
+	ATF_CHECK_EQ(config.number, 0);
+	ATF_CHECK_EQ(config.string, NULL);
+	ATF_CHECK_STREQ(config.nonopt, "-onumber=1");
+	ATF_CHECK_EQ(args.argc, 3);
+	ATF_CHECK_STREQ(args.argv[0], "foofs");
+	ATF_CHECK_STREQ(args.argv[1], "--");
+	ATF_CHECK_STREQ(args.argv[2], "-ostring=foo");
+
+	/* The "--" marker at the last of outargs should be removed */
+	fuse_opt_free_args(&args);
+	RZ(fuse_opt_add_arg(&args, "foofs"));
+    RZ(fuse_opt_add_arg(&args, "--"));
+	RZ(fuse_opt_add_arg(&args, "-onumber=1"));
+
+	memset(&config, 0, sizeof(config));
+	ATF_CHECK(fuse_opt_parse(&args, &config, foofs_opts, foo_opt_proc) == 0);
+	ATF_CHECK_EQ(config.number, 0);
+	ATF_CHECK_EQ(config.string, NULL);
+	ATF_CHECK_STREQ(config.nonopt, "-onumber=1");
+	ATF_CHECK_EQ(args.argc, 1);
+	ATF_CHECK_STREQ(args.argv[0], "foofs");
+}
+
+ATF_TP_ADD_TCS(tp)
+{
+	ATF_TP_ADD_TC(tp, t_fuse_opt_add_arg);
+	ATF_TP_ADD_TC(tp, t_fuse_opt_insert_arg);
+	ATF_TP_ADD_TC(tp, t_fuse_opt_add_opt);
+	ATF_TP_ADD_TC(tp, t_fuse_opt_add_opt_escaped);
+	ATF_TP_ADD_TC(tp, t_fuse_opt_match);
+	ATF_TP_ADD_TC(tp, t_fuse_opt_parse_null_args);
+	ATF_TP_ADD_TC(tp, t_fuse_opt_parse_null_opts);
+	ATF_TP_ADD_TC(tp, t_fuse_opt_parse_null_proc);
+	ATF_TP_ADD_TC(tp, t_fuse_opt_parse);
+
+	return atf_no_error();
+}