19 files changed, 543 insertions, 65 deletions

diff --git a/tests/bfs/execdir_path_relative_slash.out b/tests/bfs/execdir_path_relative_slash.out
new file mode 100644
index 0000000..62b31f6
--- /dev/null
+++ b/tests/bfs/execdir_path_relative_slash.out
@@ -0,0 +1,19 @@
+./a
+./b
+./bar
+./bar
+./basic
+./baz
+./c
+./d
+./e
+./f
+./foo
+./foo
+./foo
+./g
+./h
+./i
+./j
+./k
+./l
diff --git a/tests/bfs/execdir_path_relative_slash.sh b/tests/bfs/execdir_path_relative_slash.sh
new file mode 100644
index 0000000..fb5a924
--- /dev/null
+++ b/tests/bfs/execdir_path_relative_slash.sh
@@ -0,0 +1 @@
+PATH="foo:$PATH" bfs_diff basic -execdir /bin/sh -c 'printf "%s\\n" "$@"' sh {} +
diff --git a/tests/bfstd.c b/tests/bfstd.c
index a43783a..6e15e2b 100644
--- a/tests/bfstd.c
+++ b/tests/bfstd.c
@@ -6,35 +6,15 @@
 #include "bfstd.h"
 #include "diag.h"
 
+#include <errno.h>
 #include <langinfo.h>
+#include <limits.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
-/** Check the result of xdirname()/xbasename(). */
-static void check_base_dir(const char *path, const char *dir, const char *base) {
-	char *xdir = xdirname(path);
-	bfs_everify(xdir, "xdirname()");
-	bfs_check(strcmp(xdir, dir) == 0, "xdirname('%s') == '%s' (!= '%s')", path, xdir, dir);
-	free(xdir);
-
-	char *xbase = xbasename(path);
-	bfs_everify(xbase, "xbasename()");
-	bfs_check(strcmp(xbase, base) == 0, "xbasename('%s') == '%s' (!= '%s')", path, xbase, base);
-	free(xbase);
-}
-
-/** Check the result of wordesc(). */
-static void check_wordesc(const char *str, const char *exp, enum wesc_flags flags) {
-	char buf[256];
-	char *end = buf + sizeof(buf);
-	char *esc = wordesc(buf, end, str, flags);
-
-	if (bfs_check(esc != end)) {
-		bfs_check(strcmp(buf, exp) == 0, "wordesc('%s') == '%s' (!= '%s')", str, buf, exp);
-	}
-}
-
-void check_bfstd(void) {
+/** asciilen() test cases. */
+static void check_asciilen(void) {
 	bfs_check(asciilen("") == 0);
 	bfs_check(asciilen("@") == 1);
 	bfs_check(asciilen("@@") == 2);
@@ -49,7 +29,23 @@ void check_bfstd(void) {
 	bfs_check(asciilen("@@@@@@@\xFF@@@@@@a\xFF@@@@@@@") == 7);
 	bfs_check(asciilen("@@@@@@@@\xFF@@@@@a\xFF@@@@@@@") == 8);
 	bfs_check(asciilen("@@@@@@@@@\xFF@@@@a\xFF@@@@@@@") == 9);
+}
+
+/** Check the result of xdirname()/xbasename(). */
+static void check_base_dir(const char *path, const char *dir, const char *base) {
+	char *xdir = xdirname(path);
+	bfs_everify(xdir, "xdirname()");
+	bfs_check(strcmp(xdir, dir) == 0, "xdirname('%s') == '%s' (!= '%s')", path, xdir, dir);
+	free(xdir);
 
+	char *xbase = xbasename(path);
+	bfs_everify(xbase, "xbasename()");
+	bfs_check(strcmp(xbase, base) == 0, "xbasename('%s') == '%s' (!= '%s')", path, xbase, base);
+	free(xbase);
+}
+
+/** xdirname()/xbasename() test cases. */
+static void check_basedirs(void) {
 	// From man 3p basename
 	check_base_dir("usr", ".", "usr");
 	check_base_dir("usr/", ".", "usr");
@@ -61,7 +57,21 @@ void check_bfstd(void) {
 	check_base_dir("/usr/lib", "/usr", "lib");
 	check_base_dir("//usr//lib//", "//usr", "lib");
 	check_base_dir("/home//dwc//test", "/home//dwc", "test");
+}
+
+/** Check the result of wordesc(). */
+static void check_wordesc(const char *str, const char *exp, enum wesc_flags flags) {
+	char buf[256];
+	char *end = buf + sizeof(buf);
+	char *esc = wordesc(buf, end, str, flags);
 
+	if (bfs_check(esc != end)) {
+		bfs_check(strcmp(buf, exp) == 0, "wordesc('%s') == '%s' (!= '%s')", str, buf, exp);
+	}
+}
+
+/** wordesc() test cases. */
+static void check_wordescs(void) {
 	check_wordesc("", "\"\"", WESC_SHELL);
 	check_wordesc("word", "word", WESC_SHELL);
 	check_wordesc("two words", "\"two words\"", WESC_SHELL);
@@ -80,7 +90,123 @@ void check_bfstd(void) {
 		check_wordesc("\xF0\x9F\x98\x80", "\xF0\x9F\x98\x80", WESC_SHELL | WESC_TTY);
 		check_wordesc("\xCB\x9Cuser", "\xCB\x9Cuser", WESC_SHELL);
 	}
+}
+
+/** xstrto*() test cases. */
+static void check_strtox(void) {
+	short s;
+	unsigned short us;
+	int i;
+	unsigned int ui;
+	long l;
+	unsigned long ul;
+	long long ll;
+	unsigned long long ull;
+	char *end;
+
+#define check_strtouerr(err, str, end, base) \
+	do { \
+		bfs_echeck(xstrtous(str, end, base, &us) != 0 && errno == err); \
+		bfs_echeck(xstrtoui(str, end, base, &ui) != 0 && errno == err); \
+		bfs_echeck(xstrtoul(str, end, base, &ul) != 0 && errno == err); \
+		bfs_echeck(xstrtoull(str, end, base, &ull) != 0 && errno == err); \
+	} while (0)
+
+	check_strtouerr(ERANGE, "-1", NULL, 0);
+	check_strtouerr(ERANGE, "-0x1", NULL, 0);
 
+	check_strtouerr(EINVAL, "-", NULL, 0);
+	check_strtouerr(EINVAL, "-q", NULL, 0);
+	check_strtouerr(EINVAL, "-1q", NULL, 0);
+	check_strtouerr(EINVAL, "-0x", NULL, 0);
+
+#define check_strtoerr(err, str, end, base) \
+	do { \
+		bfs_echeck(xstrtos(str, end, base, &s) != 0 && errno == err); \
+		bfs_echeck(xstrtoi(str, end, base, &i) != 0 && errno == err); \
+		bfs_echeck(xstrtol(str, end, base, &l) != 0 && errno == err); \
+		bfs_echeck(xstrtoll(str, end, base, &ll) != 0 && errno == err); \
+		check_strtouerr(err, str, end, base); \
+	} while (0)
+
+	check_strtoerr(EINVAL, "", NULL, 0);
+	check_strtoerr(EINVAL, "", &end, 0);
+	check_strtoerr(EINVAL, " 1 ", &end, 0);
+	check_strtoerr(EINVAL, " -1", NULL, 0);
+	check_strtoerr(EINVAL, " 123", NULL, 0);
+	check_strtoerr(EINVAL, "123 ", NULL, 0);
+	check_strtoerr(EINVAL, "0789", NULL, 0);
+	check_strtoerr(EINVAL, "789A", NULL, 0);
+	check_strtoerr(EINVAL, "0x", NULL, 0);
+	check_strtoerr(EINVAL, "0x789A", NULL, 10);
+	check_strtoerr(EINVAL, "0x-1", NULL, 0);
+
+#define check_strtotype(type, min, max, fmt, fn, str, base, v, n) \
+	do { \
+		if ((n) >= min && (n) <= max) { \
+			bfs_echeck(fn(str, NULL, base, &v) == 0); \
+			bfs_check(v == (type)(n), "%s('%s') == " fmt " (!= " fmt ")", #fn, str, v, (type)(n)); \
+		} else { \
+			bfs_echeck(fn(str, NULL, base, &v) != 0 && errno == ERANGE); \
+		} \
+	} while (0)
+
+#define check_strtoint(str, base, n) \
+	do { \
+		check_strtotype(  signed short,      SHRT_MIN,   SHRT_MAX, "%d",   xstrtos,   str, base,  s,  n); \
+		check_strtotype(  signed int,         INT_MIN,    INT_MAX, "%d",   xstrtoi,   str, base,  i,  n); \
+		check_strtotype(  signed long,       LONG_MIN,   LONG_MAX, "%ld",  xstrtol,   str, base,  l,  n); \
+		check_strtotype(  signed long long, LLONG_MIN,  LLONG_MAX, "%lld", xstrtoll,  str, base, ll,  n); \
+		check_strtotype(unsigned short,             0,  USHRT_MAX, "%u",   xstrtous,  str, base, us,  n); \
+		check_strtotype(unsigned int,               0,   UINT_MAX, "%u",   xstrtoui,  str, base, ui,  n); \
+		check_strtotype(unsigned long,              0,  ULONG_MAX, "%lu",  xstrtoul,  str, base, ul,  n); \
+		check_strtotype(unsigned long long,         0, ULLONG_MAX, "%llu", xstrtoull, str, base, ull, n); \
+	} while (0)
+
+	check_strtoint("123", 0, 123);
+	check_strtoint("+123", 0, 123);
+	check_strtoint("-123", 0, -123);
+
+	check_strtoint("0123", 0, 0123);
+	check_strtoint("0x789A", 0, 0x789A);
+
+	check_strtoint("0123", 10, 123);
+	check_strtoint("0789", 10, 789);
+
+	check_strtoint("123", 16, 0x123);
+
+	check_strtoint("0x7FFF", 0, 0x7FFF);
+	check_strtoint("-0x8000", 0, -0x8000);
+
+	check_strtoint("0x7FFFFFFF", 0, 0x7FFFFFFFL);
+	check_strtoint("-0x80000000", 0, -0x7FFFFFFFL - 1);
+
+	check_strtoint("0x7FFFFFFFFFFFFFFF", 0, 0x7FFFFFFFFFFFFFFFLL);
+	check_strtoint("-0x8000000000000000", 0, -0x7FFFFFFFFFFFFFFFLL - 1);
+
+#define check_strtoend(str, estr, base, n) \
+	do { \
+		bfs_echeck(xstrtoll(str, &end, base, &ll) == 0); \
+		bfs_check(ll == (n), "xstrtoll('%s') == %lld (!= %lld)", str, ll, (long long)(n)); \
+		bfs_check(strcmp(end, estr) == 0, "xstrtoll('%s'): end == '%s' (!= '%s')", str, end, estr); \
+	} while (0)
+
+	check_strtoend("123 ", " ", 0, 123);
+	check_strtoend("0789", "89", 0, 07);
+	check_strtoend("789A", "A", 0, 789);
+	check_strtoend("0xDEFG", "G", 0, 0xDEF);
+}
+
+/** xstrwidth() test cases. */
+static void check_strwidth(void) {
 	bfs_check(xstrwidth("Hello world") == 11);
 	bfs_check(xstrwidth("Hello\1world") == 10);
 }
+
+void check_bfstd(void) {
+	check_asciilen();
+	check_basedirs();
+	check_wordescs();
+	check_strtox();
+	check_strwidth();
+}
diff --git a/tests/getopts.sh b/tests/getopts.sh
index 255f2fa..a16511f 100644
--- a/tests/getopts.sh
+++ b/tests/getopts.sh
@@ -5,11 +5,7 @@
 
 ## Argument parsing
 
-if command -v nproc &>/dev/null; then
-    JOBS=$(nproc)
-else
-    JOBS=1
-fi
+JOBS=$(_nproc)
 MAKE=
 PATTERNS=()
 SUDO=()
diff --git a/tests/gnu/execdir_self.out b/tests/gnu/execdir_self.out
new file mode 100644
index 0000000..3ad0640
--- /dev/null
+++ b/tests/gnu/execdir_self.out
@@ -0,0 +1 @@
+./bar.sh
diff --git a/tests/gnu/execdir_self.sh b/tests/gnu/execdir_self.sh
new file mode 100644
index 0000000..1fc5d04
--- /dev/null
+++ b/tests/gnu/execdir_self.sh
@@ -0,0 +1,9 @@
+cd "$TEST"
+mkdir foo
+cat >foo/bar.sh <<EOF
+#!/bin/sh
+printf '%s\n' "\$@"
+EOF
+chmod +x foo/bar.sh
+
+bfs_diff . -name bar.sh -execdir {} {} \;
diff --git a/tests/main.c b/tests/main.c
index 4c770bd..9240e1c 100644
--- a/tests/main.c
+++ b/tests/main.c
@@ -222,15 +222,15 @@ int main(int argc, char *argv[]) {
 	}
 	tzset();
 
-	long jobs = 0;
+	unsigned int jobs = 0;
 
 	const char *cmd = argc > 0 ? argv[0] : "units";
 	int c;
 	while (c = getopt(argc, argv, ":j:"), c != -1) {
 		switch (c) {
 		case 'j':
-			if (xstrtol(optarg, NULL, 10, &jobs) != 0 || jobs <= 0) {
-				fprintf(stderr, "%s: Bad job count '%s'\n", cmd, optarg);
+			if (xstrtoui(optarg, NULL, 10, &jobs) != 0) {
+				fprintf(stderr, "%s: Bad job count '%s': %s\n", cmd, optarg, errstr());
 				return EXIT_FAILURE;
 			}
 			break;
@@ -243,7 +243,7 @@ int main(int argc, char *argv[]) {
 		}
 	}
 
-	if (jobs == 0) {
+	if (!jobs) {
 		jobs = nproc();
 	}
 
diff --git a/tests/posix/exec_sigmask.sh b/tests/posix/exec_sigmask.sh
index d1192a4..2907458 100644
--- a/tests/posix/exec_sigmask.sh
+++ b/tests/posix/exec_sigmask.sh
@@ -11,6 +11,6 @@ mkfifo p1 p2
 } &
 
 # Write the `sh` PID to p1, then hang reading p2 until we're killed
-! invoke_bfs p1 -exec sh -c 'echo $$ >p1 && read -r _ <p2' {} + || fail
+! invoke_bfs p1 -exec bash -c 'echo $$ >p1 && read -r _ <p2' bash {} + || fail
 
-wait
+_wait
diff --git a/tests/posix/group_o_group.out b/tests/posix/group_o_group.out
new file mode 100644
index 0000000..a7ccfe4
--- /dev/null
+++ b/tests/posix/group_o_group.out
@@ -0,0 +1,19 @@
+basic
+basic/a
+basic/b
+basic/c
+basic/c/d
+basic/e
+basic/e/f
+basic/g
+basic/g/h
+basic/i
+basic/j
+basic/j/foo
+basic/k
+basic/k/foo
+basic/k/foo/bar
+basic/l
+basic/l/foo
+basic/l/foo/bar
+basic/l/foo/bar/baz
diff --git a/tests/posix/group_o_group.sh b/tests/posix/group_o_group.sh
new file mode 100644
index 0000000..60aefc0
--- /dev/null
+++ b/tests/posix/group_o_group.sh
@@ -0,0 +1,3 @@
+# Regression test for
+# https://github.com/tavianator/bfs/issues/155
+bfs_diff basic -group 0 -o -group "$(id -g)"
diff --git a/tests/posix/root_order.out b/tests/posix/root_order.out
new file mode 100644
index 0000000..ea94276
--- /dev/null
+++ b/tests/posix/root_order.out
@@ -0,0 +1,4 @@
+basic/a
+basic/b
+basic/c/d
+basic/e/f
diff --git a/tests/posix/root_order.sh b/tests/posix/root_order.sh
new file mode 100644
index 0000000..86adf20
--- /dev/null
+++ b/tests/posix/root_order.sh
@@ -0,0 +1,6 @@
+# Root paths must be processed in order
+# https://www.austingroupbugs.net/view.php?id=1859
+
+# -size forces a stat(), which we don't want to be async
+invoke_bfs basic/{a,b,c/d,e/f} -size -1000 >"$OUT"
+diff_output
diff --git a/tests/posix/user_o_user.out b/tests/posix/user_o_user.out
new file mode 100644
index 0000000..a7ccfe4
--- /dev/null
+++ b/tests/posix/user_o_user.out
@@ -0,0 +1,19 @@
+basic
+basic/a
+basic/b
+basic/c
+basic/c/d
+basic/e
+basic/e/f
+basic/g
+basic/g/h
+basic/i
+basic/j
+basic/j/foo
+basic/k
+basic/k/foo
+basic/k/foo/bar
+basic/l
+basic/l/foo
+basic/l/foo/bar
+basic/l/foo/bar/baz
diff --git a/tests/posix/user_o_user.sh b/tests/posix/user_o_user.sh
new file mode 100644
index 0000000..7c143ae
--- /dev/null
+++ b/tests/posix/user_o_user.sh
@@ -0,0 +1,3 @@
+# Regression test for
+# https://github.com/tavianator/bfs/issues/155
+bfs_diff basic -user 0 -o -user "$(id -u)"
diff --git a/tests/ptyx.c b/tests/ptyx.c
new file mode 100644
index 0000000..59292df
--- /dev/null
+++ b/tests/ptyx.c
@@ -0,0 +1,252 @@
+// Copyright © Tavian Barnes <tavianator@tavianator.com>
+// SPDX-License-Identifier: 0BSD
+
+/**
+ * Execute a command in a pseudo-terminal.
+ *
+ *     $ ptyx [-w WIDTH] [-h HEIGHT] [--] COMMAND [ARGS...]
+ */
+
+#include "bfs.h"
+#include "bfstd.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/wait.h>
+#include <termios.h>
+#include <unistd.h>
+
+#if __has_include(<stropts.h>)
+#  include <stropts.h>
+#endif
+
+#if __sun
+/**
+ * Push a STREAMS module, if it's not already there.
+ *
+ * See https://www.illumos.org/issues/9042.
+ */
+static int i_push(int fd, const char *name) {
+	int ret = ioctl(fd, I_FIND, name);
+	if (ret < 0) {
+		return ret;
+	} else if (ret == 0) {
+		return ioctl(fd, I_PUSH, name);
+	} else {
+		return 0;
+	}
+}
+#endif
+
+int main(int argc, char *argv[]) {
+	const char *cmd = argc > 0 ? argv[0] : "ptyx";
+
+/** Report an error message and exit. */
+#define die(...) die_(__VA_ARGS__, )
+
+#define die_(format, ...) \
+	do { \
+		fprintf(stderr, "%s: " format "%s", cmd, __VA_ARGS__ "\n"); \
+		exit(EXIT_FAILURE); \
+	} while (0)
+
+/** Report an error code and exit. */
+#define edie(...) edie_(__VA_ARGS__, )
+
+#define edie_(format, ...) \
+	do { \
+		fprintf(stderr, "%s: " format ": %s\n", cmd, __VA_ARGS__ errstr()); \
+		exit(EXIT_FAILURE); \
+	} while (0)
+
+	unsigned short width = 0;
+	unsigned short height = 0;
+
+	// Parse the command line
+	int c;
+	while (c = getopt(argc, argv, "+:w:h:"), c != -1) {
+		switch (c) {
+		case 'w':
+			if (xstrtous(optarg, NULL, 10, &width) != 0) {
+				edie("Bad width '%s'", optarg);
+			}
+			break;
+		case 'h':
+			if (xstrtous(optarg, NULL, 10, &height) != 0) {
+				edie("Bad height '%s'", optarg);
+			}
+			break;
+		case ':':
+			die("Missing argument to -%c", optopt);
+		case '?':
+			die("Unrecognized option -%c", optopt);
+		}
+	}
+
+	if (optind >= argc) {
+		die("Missing command");
+	}
+	char **args = argv + optind;
+
+	// Create a new pty, and set it up
+	int ptm = posix_openpt(O_RDWR | O_NOCTTY);
+	if (ptm < 0) {
+		edie("posix_openpt()");
+	}
+	if (grantpt(ptm) != 0) {
+		edie("grantpt()");
+	}
+	if (unlockpt(ptm) != 0) {
+		edie("unlockpt()");
+	}
+
+	// Get the subsidiary device path
+	char *name = ptsname(ptm);
+	if (!name) {
+		edie("ptsname()");
+	}
+
+	// Open the subsidiary device
+	int pts = open(name, O_RDWR | O_NOCTTY);
+	if (pts < 0) {
+		edie("%s", name);
+	}
+
+#if __sun
+	// On Solaris/illumos, a pty doesn't behave like a terminal until we
+	// push some STREAMS modules (see ptm(4D), ptem(4M), ldterm(4M)).
+	if (i_push(pts, "ptem") != 0) {
+		die("ioctl(I_PUSH, ptem)");
+	}
+	if (i_push(pts, "ldterm") != 0) {
+		die("ioctl(I_PUSH, ldterm)");
+	}
+#endif
+
+	// A new pty starts at 0x0, which is not very useful.  Instead, grab the
+	// default size from the current controlling terminal, if possible.
+	if (!width || !height) {
+		int tty = open_cterm(O_RDONLY | O_CLOEXEC);
+		if (tty >= 0) {
+			struct winsize ws;
+			if (xtcgetwinsize(tty, &ws) != 0) {
+				edie("tcgetwinsize()");
+			}
+			if (!width) {
+				width = ws.ws_col;
+			}
+			if (!height) {
+				height = ws.ws_row;
+			}
+			xclose(tty);
+		}
+	}
+	if (!width) {
+		width = 80;
+	}
+	if (!height) {
+		height = 24;
+	}
+
+	// Update the pty size
+	struct winsize ws;
+	if (xtcgetwinsize(pts, &ws) != 0) {
+		edie("tcgetwinsize()");
+	}
+	ws.ws_col = width;
+	ws.ws_row = height;
+	if (xtcsetwinsize(pts, &ws) != 0) {
+		edie("tcsetwinsize()");
+	}
+
+	// Set custom terminal attributes
+	struct termios attrs;
+	if (tcgetattr(pts, &attrs) != 0) {
+		edie("tcgetattr()");
+	}
+	attrs.c_oflag &= ~OPOST; // Don't convert \n to \r\n
+	if (tcsetattr(pts, TCSANOW, &attrs) != 0) {
+		edie("tcsetattr()");
+	}
+
+	pid_t pid = fork();
+	if (pid < 0) {
+		edie("fork()");
+	} else if (pid == 0) {
+		// Child
+		close(ptm);
+
+		// Make ourselves a session leader so we can have our own
+		// controlling terminal
+		if (setsid() < 0) {
+			edie("setsid()");
+		}
+
+#ifdef TIOCSCTTY
+		// Set the pty as the controlling terminal
+		if (ioctl(pts, TIOCSCTTY, 0) != 0) {
+			edie("ioctl(TIOCSCTTY)");
+		}
+#endif
+
+		// Redirect std{in,out,err} to the pty
+		if (dup2(pts, STDIN_FILENO) < 0
+		    || dup2(pts, STDOUT_FILENO) < 0
+		    || dup2(pts, STDERR_FILENO) < 0) {
+			edie("dup2()");
+		}
+		if (pts > STDERR_FILENO) {
+			xclose(pts);
+		}
+
+		// Run the requested command
+		execvp(args[0], args);
+		edie("execvp(): %s", args[0]);
+	}
+
+	// Parent
+	xclose(pts);
+
+	// Read output from the pty and copy it to stdout
+	char buf[1024];
+	while (true) {
+		ssize_t len = read(ptm, buf, sizeof(buf));
+		if (len > 0) {
+			if (xwrite(STDOUT_FILENO, buf, len) < 0) {
+				edie("write()");
+			}
+		} else if (len == 0) {
+			break;
+		} else if (errno == EINTR) {
+			continue;
+		} else if (errno == EIO) {
+			// Linux reports EIO rather than EOF when pts is closed
+			break;
+		} else {
+			die("read()");
+		}
+	}
+
+	xclose(ptm);
+
+	int wstatus;
+	if (xwaitpid(pid, &wstatus, 0) < 0) {
+		edie("waitpid()");
+	}
+
+	if (WIFEXITED(wstatus)) {
+		return WEXITSTATUS(wstatus);
+	} else if (WIFSIGNALED(wstatus)) {
+		int sig = WTERMSIG(wstatus);
+		fprintf(stderr, "%s: %s: %s\n", cmd, args[0], strsignal(sig));
+		return 128 + sig;
+	} else {
+		return 128;
+	}
+}
diff --git a/tests/run.sh b/tests/run.sh
index e3a4e3f..3ed2a9c 100644
--- a/tests/run.sh
+++ b/tests/run.sh
@@ -96,16 +96,13 @@ reap_test() {
 wait_test() {
     local pid line ret
 
-    while true; do
+    while :; do
         line=$((LINENO + 1))
-        wait -n -ppid
+        _wait -n -ppid
         ret=$?
 
         if [ "${pid:-}" ]; then
             break
-        elif ((ret > 128)); then
-            # Interrupted by signal
-            continue
         else
             debug "${BASH_SOURCE[0]}" $line "${RED}error $ret${RST}" >&$DUPERR
             exit 1
@@ -362,20 +359,12 @@ invoke_bfs() {
     fi
 }
 
-if command -v unbuffer &>/dev/null; then
-    UNBUFFER=unbuffer
-elif command -v expect_unbuffer &>/dev/null; then
-    UNBUFFER=expect_unbuffer
-fi
-
 # Run bfs with a pseudo-terminal attached
 bfs_pty() {
-    test -n "${UNBUFFER:-}" || skip
-
     bfs_verbose "$@"
 
     local ret=0
-    "$UNBUFFER" bash -c 'stty cols 80 rows 24 && "$@" </dev/null' bash "${BFS[@]}" "$@" || ret=$?
+    "$PTYX" -w80 -h24 -- "${BFS[@]}" "$@" || ret=$?
 
     if ((ret > 125)); then
         exit $ret
diff --git a/tests/util.sh b/tests/util.sh
index d8b7036..1718a1a 100644
--- a/tests/util.sh
+++ b/tests/util.sh
@@ -16,6 +16,7 @@ ROOT=$(_realpath "$(dirname -- "$TESTS")")
 TESTS="$ROOT/tests"
 BIN="$ROOT/bin"
 MKSOCK="$BIN/tests/mksock"
+PTYX="$BIN/tests/ptyx"
 XTOUCH="$BIN/tests/xtouch"
 UNAME=$(uname)
 
@@ -189,3 +190,28 @@ pop_defers() {
 
     return $ret
 }
+
+## Parallelism
+
+# Get the number of processors
+_nproc() {
+    {
+        nproc \
+            || sysctl -n hw.ncpu \
+            || getconf _NPROCESSORS_ONLN \
+            || echo 1
+    } 2>/dev/null
+}
+
+# Run wait, looping if interrupted
+_wait() {
+    local ret=130
+
+    # "If wait is interrupted by a signal, the return status will be greater than 128"
+    while ((ret > 128)); do
+	ret=0
+	wait "$@" || ret=$?
+    done
+
+    return $ret
+}
diff --git a/tests/xspawn.c b/tests/xspawn.c
index 0244006..6864192 100644
--- a/tests/xspawn.c
+++ b/tests/xspawn.c
@@ -99,6 +99,22 @@ static int reset_path(char *old_path) {
 	return ret;
 }
 
+/** Spawn the test binary and check for success. */
+static void check_spawnee(const char *exe, const struct bfs_spawn *ctx, char **argv, char **envp) {
+	pid_t pid = bfs_spawn(exe, ctx, argv, envp);
+	if (!bfs_echeck(pid >= 0, "bfs_spawn('%s')", exe)) {
+		return;
+	}
+
+	int wstatus;
+	bool exited = bfs_echeck(xwaitpid(pid, &wstatus, 0) == pid)
+		&& bfs_check(WIFEXITED(wstatus));
+	if (exited) {
+		int wexit = WEXITSTATUS(wstatus);
+		bfs_check(wexit == EXIT_SUCCESS, "xspawnee: exit(%d)", wexit);
+	}
+}
+
 /** Check that we resolve executables in $PATH correctly. */
 static void check_use_path(bool use_posix) {
 	struct bfs_spawn spawn;
@@ -133,20 +149,9 @@ static void check_use_path(bool use_posix) {
 	}
 
 	char *argv[] = {"xspawnee", old_path, NULL};
-	pid_t pid = bfs_spawn("xspawnee", &spawn, argv, envp);
-	if (!bfs_echeck(pid >= 0, "bfs_spawn()")) {
-		goto path;
-	}
-
-	int wstatus;
-	bool exited = bfs_echeck(xwaitpid(pid, &wstatus, 0) == pid)
-		&& bfs_check(WIFEXITED(wstatus));
-	if (exited) {
-		int wexit = WEXITSTATUS(wstatus);
-		bfs_check(wexit == EXIT_SUCCESS, "xspawnee: exit(%d)", wexit);
-	}
+	check_spawnee("xspawnee", &spawn, argv, envp);
+	check_spawnee("tests/xspawnee", &spawn, argv, envp);
 
-path:
 	bfs_echeck(reset_path(old_path) == 0);
 env:
 	for (char **var = envp; *var; ++var) {
diff --git a/tests/xtouch.c b/tests/xtouch.c
index 5d65a4c..f33c573 100644
--- a/tests/xtouch.c
+++ b/tests/xtouch.c
@@ -217,8 +217,8 @@ int main(int argc, char *argv[]) {
 	}
 
 	if (marg) {
-		long mode;
-		if (xstrtol(marg, NULL, 8, &mode) == 0 && mode >= 0 && mode < 01000) {
+		unsigned int mode;
+		if (xstrtoui(marg, NULL, 8, &mode) == 0 && mode < 01000) {
 			args.fmode = args.dmode = mode;
 		} else {
 			fprintf(stderr, "%s: Invalid mode '%s'\n", cmd, marg);