Replace tabs following #define with spaces.

This resolves #564.

4 files changed, 123 insertions, 123 deletions

diff --git a/test/include/test/btalloc.h b/test/include/test/btalloc.h
index 8b733f5..5877ea7 100644
--- a/test/include/test/btalloc.h
+++ b/test/include/test/btalloc.h
@@ -1,12 +1,12 @@
 /* btalloc() provides a mechanism for allocating via permuted backtraces. */
 void	*btalloc(size_t size, unsigned bits);
 
-#define	btalloc_n_proto(n)						\
+#define btalloc_n_proto(n)						\
 void	*btalloc_##n(size_t size, unsigned bits);
 btalloc_n_proto(0)
 btalloc_n_proto(1)
 
-#define	btalloc_n_gen(n)						\
+#define btalloc_n_gen(n)						\
 void *									\
 btalloc_##n(size_t size, unsigned bits) {				\
 	void *p;							\
diff --git a/test/include/test/jemalloc_test.h.in b/test/include/test/jemalloc_test.h.in
index a0b9474..36d59cf 100644
--- a/test/include/test/jemalloc_test.h.in
+++ b/test/include/test/jemalloc_test.h.in
@@ -123,7 +123,7 @@ static const bool config_debug =
 #include "test/test.h"
 #include "test/timer.h"
 #include "test/thd.h"
-#define	MEXP 19937
+#define MEXP 19937
 #include "test/SFMT.h"
 
 /******************************************************************************/
@@ -136,7 +136,7 @@ static const bool config_debug =
 #undef not_implemented
 #undef assert_not_implemented
 
-#define	assert(e) do {							\
+#define assert(e) do {							\
 	if (!(e)) {							\
 		malloc_printf(						\
 		    "<jemalloc>: %s:%d: Failed assertion: \"%s\"\n",	\
@@ -145,20 +145,20 @@ static const bool config_debug =
 	}								\
 } while (0)
 
-#define	not_reached() do {						\
+#define not_reached() do {						\
 	malloc_printf(							\
 	    "<jemalloc>: %s:%d: Unreachable code reached\n",		\
 	    __FILE__, __LINE__);					\
 	abort();							\
 } while (0)
 
-#define	not_implemented() do {						\
+#define not_implemented() do {						\
 	malloc_printf("<jemalloc>: %s:%d: Not implemented\n",		\
 	    __FILE__, __LINE__);					\
 	abort();							\
 } while (0)
 
-#define	assert_not_implemented(e) do {					\
+#define assert_not_implemented(e) do {					\
 	if (!(e)) {							\
 		not_implemented();					\
 	}								\
diff --git a/test/include/test/mq.h b/test/include/test/mq.h
index 8d9907b..af2c078 100644
--- a/test/include/test/mq.h
+++ b/test/include/test/mq.h
@@ -26,9 +26,9 @@ void	mq_nanosleep(unsigned ns);
  * does not perform any cleanup of messages, since it knows nothing of their
  * payloads.
  */
-#define	mq_msg(a_mq_msg_type)	ql_elm(a_mq_msg_type)
+#define mq_msg(a_mq_msg_type)	ql_elm(a_mq_msg_type)
 
-#define	mq_gen(a_attr, a_prefix, a_mq_type, a_mq_msg_type, a_field)	\
+#define mq_gen(a_attr, a_prefix, a_mq_type, a_mq_msg_type, a_field)	\
 typedef struct {							\
 	mtx_t			lock;					\
 	ql_head(a_mq_msg_type)	msgs;					\
diff --git a/test/include/test/test.h b/test/include/test/test.h
index a1b6f72..d7f05fa 100644
--- a/test/include/test/test.h
+++ b/test/include/test/test.h
@@ -1,6 +1,6 @@
-#define	ASSERT_BUFSIZE	256
+#define ASSERT_BUFSIZE	256
 
-#define	assert_cmp(t, a, b, cmp, neg_cmp, pri, ...) do {		\
+#define assert_cmp(t, a, b, cmp, neg_cmp, pri, ...) do {		\
 	t a_ = (a);							\
 	t b_ = (b);							\
 	if (!(a_ cmp b_)) {						\
@@ -17,200 +17,200 @@
 	}								\
 } while (0)
 
-#define	assert_ptr_eq(a, b, ...)	assert_cmp(void *, a, b, ==,	\
+#define assert_ptr_eq(a, b, ...)	assert_cmp(void *, a, b, ==,	\
     !=, "p", __VA_ARGS__)
-#define	assert_ptr_ne(a, b, ...)	assert_cmp(void *, a, b, !=,	\
+#define assert_ptr_ne(a, b, ...)	assert_cmp(void *, a, b, !=,	\
     ==, "p", __VA_ARGS__)
-#define	assert_ptr_null(a, ...)		assert_cmp(void *, a, NULL, ==,	\
+#define assert_ptr_null(a, ...)		assert_cmp(void *, a, NULL, ==,	\
     !=, "p", __VA_ARGS__)
-#define	assert_ptr_not_null(a, ...)	assert_cmp(void *, a, NULL, !=,	\
+#define assert_ptr_not_null(a, ...)	assert_cmp(void *, a, NULL, !=,	\
     ==, "p", __VA_ARGS__)
 
-#define	assert_c_eq(a, b, ...)	assert_cmp(char, a, b, ==, !=, "c", __VA_ARGS__)
-#define	assert_c_ne(a, b, ...)	assert_cmp(char, a, b, !=, ==, "c", __VA_ARGS__)
-#define	assert_c_lt(a, b, ...)	assert_cmp(char, a, b, <, >=, "c", __VA_ARGS__)
-#define	assert_c_le(a, b, ...)	assert_cmp(char, a, b, <=, >, "c", __VA_ARGS__)
-#define	assert_c_ge(a, b, ...)	assert_cmp(char, a, b, >=, <, "c", __VA_ARGS__)
-#define	assert_c_gt(a, b, ...)	assert_cmp(char, a, b, >, <=, "c", __VA_ARGS__)
+#define assert_c_eq(a, b, ...)	assert_cmp(char, a, b, ==, !=, "c", __VA_ARGS__)
+#define assert_c_ne(a, b, ...)	assert_cmp(char, a, b, !=, ==, "c", __VA_ARGS__)
+#define assert_c_lt(a, b, ...)	assert_cmp(char, a, b, <, >=, "c", __VA_ARGS__)
+#define assert_c_le(a, b, ...)	assert_cmp(char, a, b, <=, >, "c", __VA_ARGS__)
+#define assert_c_ge(a, b, ...)	assert_cmp(char, a, b, >=, <, "c", __VA_ARGS__)
+#define assert_c_gt(a, b, ...)	assert_cmp(char, a, b, >, <=, "c", __VA_ARGS__)
 
-#define	assert_x_eq(a, b, ...)	assert_cmp(int, a, b, ==, !=, "#x", __VA_ARGS__)
-#define	assert_x_ne(a, b, ...)	assert_cmp(int, a, b, !=, ==, "#x", __VA_ARGS__)
-#define	assert_x_lt(a, b, ...)	assert_cmp(int, a, b, <, >=, "#x", __VA_ARGS__)
-#define	assert_x_le(a, b, ...)	assert_cmp(int, a, b, <=, >, "#x", __VA_ARGS__)
-#define	assert_x_ge(a, b, ...)	assert_cmp(int, a, b, >=, <, "#x", __VA_ARGS__)
-#define	assert_x_gt(a, b, ...)	assert_cmp(int, a, b, >, <=, "#x", __VA_ARGS__)
+#define assert_x_eq(a, b, ...)	assert_cmp(int, a, b, ==, !=, "#x", __VA_ARGS__)
+#define assert_x_ne(a, b, ...)	assert_cmp(int, a, b, !=, ==, "#x", __VA_ARGS__)
+#define assert_x_lt(a, b, ...)	assert_cmp(int, a, b, <, >=, "#x", __VA_ARGS__)
+#define assert_x_le(a, b, ...)	assert_cmp(int, a, b, <=, >, "#x", __VA_ARGS__)
+#define assert_x_ge(a, b, ...)	assert_cmp(int, a, b, >=, <, "#x", __VA_ARGS__)
+#define assert_x_gt(a, b, ...)	assert_cmp(int, a, b, >, <=, "#x", __VA_ARGS__)
 
-#define	assert_d_eq(a, b, ...)	assert_cmp(int, a, b, ==, !=, "d", __VA_ARGS__)
-#define	assert_d_ne(a, b, ...)	assert_cmp(int, a, b, !=, ==, "d", __VA_ARGS__)
-#define	assert_d_lt(a, b, ...)	assert_cmp(int, a, b, <, >=, "d", __VA_ARGS__)
-#define	assert_d_le(a, b, ...)	assert_cmp(int, a, b, <=, >, "d", __VA_ARGS__)
-#define	assert_d_ge(a, b, ...)	assert_cmp(int, a, b, >=, <, "d", __VA_ARGS__)
-#define	assert_d_gt(a, b, ...)	assert_cmp(int, a, b, >, <=, "d", __VA_ARGS__)
+#define assert_d_eq(a, b, ...)	assert_cmp(int, a, b, ==, !=, "d", __VA_ARGS__)
+#define assert_d_ne(a, b, ...)	assert_cmp(int, a, b, !=, ==, "d", __VA_ARGS__)
+#define assert_d_lt(a, b, ...)	assert_cmp(int, a, b, <, >=, "d", __VA_ARGS__)
+#define assert_d_le(a, b, ...)	assert_cmp(int, a, b, <=, >, "d", __VA_ARGS__)
+#define assert_d_ge(a, b, ...)	assert_cmp(int, a, b, >=, <, "d", __VA_ARGS__)
+#define assert_d_gt(a, b, ...)	assert_cmp(int, a, b, >, <=, "d", __VA_ARGS__)
 
-#define	assert_u_eq(a, b, ...)	assert_cmp(int, a, b, ==, !=, "u", __VA_ARGS__)
-#define	assert_u_ne(a, b, ...)	assert_cmp(int, a, b, !=, ==, "u", __VA_ARGS__)
-#define	assert_u_lt(a, b, ...)	assert_cmp(int, a, b, <, >=, "u", __VA_ARGS__)
-#define	assert_u_le(a, b, ...)	assert_cmp(int, a, b, <=, >, "u", __VA_ARGS__)
-#define	assert_u_ge(a, b, ...)	assert_cmp(int, a, b, >=, <, "u", __VA_ARGS__)
-#define	assert_u_gt(a, b, ...)	assert_cmp(int, a, b, >, <=, "u", __VA_ARGS__)
+#define assert_u_eq(a, b, ...)	assert_cmp(int, a, b, ==, !=, "u", __VA_ARGS__)
+#define assert_u_ne(a, b, ...)	assert_cmp(int, a, b, !=, ==, "u", __VA_ARGS__)
+#define assert_u_lt(a, b, ...)	assert_cmp(int, a, b, <, >=, "u", __VA_ARGS__)
+#define assert_u_le(a, b, ...)	assert_cmp(int, a, b, <=, >, "u", __VA_ARGS__)
+#define assert_u_ge(a, b, ...)	assert_cmp(int, a, b, >=, <, "u", __VA_ARGS__)
+#define assert_u_gt(a, b, ...)	assert_cmp(int, a, b, >, <=, "u", __VA_ARGS__)
 
-#define	assert_ld_eq(a, b, ...)	assert_cmp(long, a, b, ==,	\
+#define assert_ld_eq(a, b, ...)	assert_cmp(long, a, b, ==,	\
     !=, "ld", __VA_ARGS__)
-#define	assert_ld_ne(a, b, ...)	assert_cmp(long, a, b, !=,	\
+#define assert_ld_ne(a, b, ...)	assert_cmp(long, a, b, !=,	\
     ==, "ld", __VA_ARGS__)
-#define	assert_ld_lt(a, b, ...)	assert_cmp(long, a, b, <,	\
+#define assert_ld_lt(a, b, ...)	assert_cmp(long, a, b, <,	\
     >=, "ld", __VA_ARGS__)
-#define	assert_ld_le(a, b, ...)	assert_cmp(long, a, b, <=,	\
+#define assert_ld_le(a, b, ...)	assert_cmp(long, a, b, <=,	\
     >, "ld", __VA_ARGS__)
-#define	assert_ld_ge(a, b, ...)	assert_cmp(long, a, b, >=,	\
+#define assert_ld_ge(a, b, ...)	assert_cmp(long, a, b, >=,	\
     <, "ld", __VA_ARGS__)
-#define	assert_ld_gt(a, b, ...)	assert_cmp(long, a, b, >,	\
+#define assert_ld_gt(a, b, ...)	assert_cmp(long, a, b, >,	\
     <=, "ld", __VA_ARGS__)
 
-#define	assert_lu_eq(a, b, ...)	assert_cmp(unsigned long,	\
+#define assert_lu_eq(a, b, ...)	assert_cmp(unsigned long,	\
     a, b, ==, !=, "lu", __VA_ARGS__)
-#define	assert_lu_ne(a, b, ...)	assert_cmp(unsigned long,	\
+#define assert_lu_ne(a, b, ...)	assert_cmp(unsigned long,	\
     a, b, !=, ==, "lu", __VA_ARGS__)
-#define	assert_lu_lt(a, b, ...)	assert_cmp(unsigned long,	\
+#define assert_lu_lt(a, b, ...)	assert_cmp(unsigned long,	\
     a, b, <, >=, "lu", __VA_ARGS__)
-#define	assert_lu_le(a, b, ...)	assert_cmp(unsigned long,	\
+#define assert_lu_le(a, b, ...)	assert_cmp(unsigned long,	\
     a, b, <=, >, "lu", __VA_ARGS__)
-#define	assert_lu_ge(a, b, ...)	assert_cmp(unsigned long,	\
+#define assert_lu_ge(a, b, ...)	assert_cmp(unsigned long,	\
     a, b, >=, <, "lu", __VA_ARGS__)
-#define	assert_lu_gt(a, b, ...)	assert_cmp(unsigned long,	\
+#define assert_lu_gt(a, b, ...)	assert_cmp(unsigned long,	\
     a, b, >, <=, "lu", __VA_ARGS__)
 
-#define	assert_qd_eq(a, b, ...)	assert_cmp(long long, a, b, ==,	\
+#define assert_qd_eq(a, b, ...)	assert_cmp(long long, a, b, ==,	\
     !=, "qd", __VA_ARGS__)
-#define	assert_qd_ne(a, b, ...)	assert_cmp(long long, a, b, !=,	\
+#define assert_qd_ne(a, b, ...)	assert_cmp(long long, a, b, !=,	\
     ==, "qd", __VA_ARGS__)
-#define	assert_qd_lt(a, b, ...)	assert_cmp(long long, a, b, <,	\
+#define assert_qd_lt(a, b, ...)	assert_cmp(long long, a, b, <,	\
     >=, "qd", __VA_ARGS__)
-#define	assert_qd_le(a, b, ...)	assert_cmp(long long, a, b, <=,	\
+#define assert_qd_le(a, b, ...)	assert_cmp(long long, a, b, <=,	\
     >, "qd", __VA_ARGS__)
-#define	assert_qd_ge(a, b, ...)	assert_cmp(long long, a, b, >=,	\
+#define assert_qd_ge(a, b, ...)	assert_cmp(long long, a, b, >=,	\
     <, "qd", __VA_ARGS__)
-#define	assert_qd_gt(a, b, ...)	assert_cmp(long long, a, b, >,	\
+#define assert_qd_gt(a, b, ...)	assert_cmp(long long, a, b, >,	\
     <=, "qd", __VA_ARGS__)
 
-#define	assert_qu_eq(a, b, ...)	assert_cmp(unsigned long long,	\
+#define assert_qu_eq(a, b, ...)	assert_cmp(unsigned long long,	\
     a, b, ==, !=, "qu", __VA_ARGS__)
-#define	assert_qu_ne(a, b, ...)	assert_cmp(unsigned long long,	\
+#define assert_qu_ne(a, b, ...)	assert_cmp(unsigned long long,	\
     a, b, !=, ==, "qu", __VA_ARGS__)
-#define	assert_qu_lt(a, b, ...)	assert_cmp(unsigned long long,	\
+#define assert_qu_lt(a, b, ...)	assert_cmp(unsigned long long,	\
     a, b, <, >=, "qu", __VA_ARGS__)
-#define	assert_qu_le(a, b, ...)	assert_cmp(unsigned long long,	\
+#define assert_qu_le(a, b, ...)	assert_cmp(unsigned long long,	\
     a, b, <=, >, "qu", __VA_ARGS__)
-#define	assert_qu_ge(a, b, ...)	assert_cmp(unsigned long long,	\
+#define assert_qu_ge(a, b, ...)	assert_cmp(unsigned long long,	\
     a, b, >=, <, "qu", __VA_ARGS__)
-#define	assert_qu_gt(a, b, ...)	assert_cmp(unsigned long long,	\
+#define assert_qu_gt(a, b, ...)	assert_cmp(unsigned long long,	\
     a, b, >, <=, "qu", __VA_ARGS__)
 
-#define	assert_jd_eq(a, b, ...)	assert_cmp(intmax_t, a, b, ==,	\
+#define assert_jd_eq(a, b, ...)	assert_cmp(intmax_t, a, b, ==,	\
     !=, "jd", __VA_ARGS__)
-#define	assert_jd_ne(a, b, ...)	assert_cmp(intmax_t, a, b, !=,	\
+#define assert_jd_ne(a, b, ...)	assert_cmp(intmax_t, a, b, !=,	\
     ==, "jd", __VA_ARGS__)
-#define	assert_jd_lt(a, b, ...)	assert_cmp(intmax_t, a, b, <,	\
+#define assert_jd_lt(a, b, ...)	assert_cmp(intmax_t, a, b, <,	\
     >=, "jd", __VA_ARGS__)
-#define	assert_jd_le(a, b, ...)	assert_cmp(intmax_t, a, b, <=,	\
+#define assert_jd_le(a, b, ...)	assert_cmp(intmax_t, a, b, <=,	\
     >, "jd", __VA_ARGS__)
-#define	assert_jd_ge(a, b, ...)	assert_cmp(intmax_t, a, b, >=,	\
+#define assert_jd_ge(a, b, ...)	assert_cmp(intmax_t, a, b, >=,	\
     <, "jd", __VA_ARGS__)
-#define	assert_jd_gt(a, b, ...)	assert_cmp(intmax_t, a, b, >,	\
+#define assert_jd_gt(a, b, ...)	assert_cmp(intmax_t, a, b, >,	\
     <=, "jd", __VA_ARGS__)
 
-#define	assert_ju_eq(a, b, ...)	assert_cmp(uintmax_t, a, b, ==,	\
+#define assert_ju_eq(a, b, ...)	assert_cmp(uintmax_t, a, b, ==,	\
     !=, "ju", __VA_ARGS__)
-#define	assert_ju_ne(a, b, ...)	assert_cmp(uintmax_t, a, b, !=,	\
+#define assert_ju_ne(a, b, ...)	assert_cmp(uintmax_t, a, b, !=,	\
     ==, "ju", __VA_ARGS__)
-#define	assert_ju_lt(a, b, ...)	assert_cmp(uintmax_t, a, b, <,	\
+#define assert_ju_lt(a, b, ...)	assert_cmp(uintmax_t, a, b, <,	\
     >=, "ju", __VA_ARGS__)
-#define	assert_ju_le(a, b, ...)	assert_cmp(uintmax_t, a, b, <=,	\
+#define assert_ju_le(a, b, ...)	assert_cmp(uintmax_t, a, b, <=,	\
     >, "ju", __VA_ARGS__)
-#define	assert_ju_ge(a, b, ...)	assert_cmp(uintmax_t, a, b, >=,	\
+#define assert_ju_ge(a, b, ...)	assert_cmp(uintmax_t, a, b, >=,	\
     <, "ju", __VA_ARGS__)
-#define	assert_ju_gt(a, b, ...)	assert_cmp(uintmax_t, a, b, >,	\
+#define assert_ju_gt(a, b, ...)	assert_cmp(uintmax_t, a, b, >,	\
     <=, "ju", __VA_ARGS__)
 
-#define	assert_zd_eq(a, b, ...)	assert_cmp(ssize_t, a, b, ==,	\
+#define assert_zd_eq(a, b, ...)	assert_cmp(ssize_t, a, b, ==,	\
     !=, "zd", __VA_ARGS__)
-#define	assert_zd_ne(a, b, ...)	assert_cmp(ssize_t, a, b, !=,	\
+#define assert_zd_ne(a, b, ...)	assert_cmp(ssize_t, a, b, !=,	\
     ==, "zd", __VA_ARGS__)
-#define	assert_zd_lt(a, b, ...)	assert_cmp(ssize_t, a, b, <,	\
+#define assert_zd_lt(a, b, ...)	assert_cmp(ssize_t, a, b, <,	\
     >=, "zd", __VA_ARGS__)
-#define	assert_zd_le(a, b, ...)	assert_cmp(ssize_t, a, b, <=,	\
+#define assert_zd_le(a, b, ...)	assert_cmp(ssize_t, a, b, <=,	\
     >, "zd", __VA_ARGS__)
-#define	assert_zd_ge(a, b, ...)	assert_cmp(ssize_t, a, b, >=,	\
+#define assert_zd_ge(a, b, ...)	assert_cmp(ssize_t, a, b, >=,	\
     <, "zd", __VA_ARGS__)
-#define	assert_zd_gt(a, b, ...)	assert_cmp(ssize_t, a, b, >,	\
+#define assert_zd_gt(a, b, ...)	assert_cmp(ssize_t, a, b, >,	\
     <=, "zd", __VA_ARGS__)
 
-#define	assert_zu_eq(a, b, ...)	assert_cmp(size_t, a, b, ==,	\
+#define assert_zu_eq(a, b, ...)	assert_cmp(size_t, a, b, ==,	\
     !=, "zu", __VA_ARGS__)
-#define	assert_zu_ne(a, b, ...)	assert_cmp(size_t, a, b, !=,	\
+#define assert_zu_ne(a, b, ...)	assert_cmp(size_t, a, b, !=,	\
     ==, "zu", __VA_ARGS__)
-#define	assert_zu_lt(a, b, ...)	assert_cmp(size_t, a, b, <,	\
+#define assert_zu_lt(a, b, ...)	assert_cmp(size_t, a, b, <,	\
     >=, "zu", __VA_ARGS__)
-#define	assert_zu_le(a, b, ...)	assert_cmp(size_t, a, b, <=,	\
+#define assert_zu_le(a, b, ...)	assert_cmp(size_t, a, b, <=,	\
     >, "zu", __VA_ARGS__)
-#define	assert_zu_ge(a, b, ...)	assert_cmp(size_t, a, b, >=,	\
+#define assert_zu_ge(a, b, ...)	assert_cmp(size_t, a, b, >=,	\
     <, "zu", __VA_ARGS__)
-#define	assert_zu_gt(a, b, ...)	assert_cmp(size_t, a, b, >,	\
+#define assert_zu_gt(a, b, ...)	assert_cmp(size_t, a, b, >,	\
     <=, "zu", __VA_ARGS__)
 
-#define	assert_d32_eq(a, b, ...)	assert_cmp(int32_t, a, b, ==,	\
+#define assert_d32_eq(a, b, ...)	assert_cmp(int32_t, a, b, ==,	\
     !=, FMTd32, __VA_ARGS__)
-#define	assert_d32_ne(a, b, ...)	assert_cmp(int32_t, a, b, !=,	\
+#define assert_d32_ne(a, b, ...)	assert_cmp(int32_t, a, b, !=,	\
     ==, FMTd32, __VA_ARGS__)
-#define	assert_d32_lt(a, b, ...)	assert_cmp(int32_t, a, b, <,	\
+#define assert_d32_lt(a, b, ...)	assert_cmp(int32_t, a, b, <,	\
     >=, FMTd32, __VA_ARGS__)
-#define	assert_d32_le(a, b, ...)	assert_cmp(int32_t, a, b, <=,	\
+#define assert_d32_le(a, b, ...)	assert_cmp(int32_t, a, b, <=,	\
     >, FMTd32, __VA_ARGS__)
-#define	assert_d32_ge(a, b, ...)	assert_cmp(int32_t, a, b, >=,	\
+#define assert_d32_ge(a, b, ...)	assert_cmp(int32_t, a, b, >=,	\
     <, FMTd32, __VA_ARGS__)
-#define	assert_d32_gt(a, b, ...)	assert_cmp(int32_t, a, b, >,	\
+#define assert_d32_gt(a, b, ...)	assert_cmp(int32_t, a, b, >,	\
     <=, FMTd32, __VA_ARGS__)
 
-#define	assert_u32_eq(a, b, ...)	assert_cmp(uint32_t, a, b, ==,	\
+#define assert_u32_eq(a, b, ...)	assert_cmp(uint32_t, a, b, ==,	\
     !=, FMTu32, __VA_ARGS__)
-#define	assert_u32_ne(a, b, ...)	assert_cmp(uint32_t, a, b, !=,	\
+#define assert_u32_ne(a, b, ...)	assert_cmp(uint32_t, a, b, !=,	\
     ==, FMTu32, __VA_ARGS__)
-#define	assert_u32_lt(a, b, ...)	assert_cmp(uint32_t, a, b, <,	\
+#define assert_u32_lt(a, b, ...)	assert_cmp(uint32_t, a, b, <,	\
     >=, FMTu32, __VA_ARGS__)
-#define	assert_u32_le(a, b, ...)	assert_cmp(uint32_t, a, b, <=,	\
+#define assert_u32_le(a, b, ...)	assert_cmp(uint32_t, a, b, <=,	\
     >, FMTu32, __VA_ARGS__)
-#define	assert_u32_ge(a, b, ...)	assert_cmp(uint32_t, a, b, >=,	\
+#define assert_u32_ge(a, b, ...)	assert_cmp(uint32_t, a, b, >=,	\
     <, FMTu32, __VA_ARGS__)
-#define	assert_u32_gt(a, b, ...)	assert_cmp(uint32_t, a, b, >,	\
+#define assert_u32_gt(a, b, ...)	assert_cmp(uint32_t, a, b, >,	\
     <=, FMTu32, __VA_ARGS__)
 
-#define	assert_d64_eq(a, b, ...)	assert_cmp(int64_t, a, b, ==,	\
+#define assert_d64_eq(a, b, ...)	assert_cmp(int64_t, a, b, ==,	\
     !=, FMTd64, __VA_ARGS__)
-#define	assert_d64_ne(a, b, ...)	assert_cmp(int64_t, a, b, !=,	\
+#define assert_d64_ne(a, b, ...)	assert_cmp(int64_t, a, b, !=,	\
     ==, FMTd64, __VA_ARGS__)
-#define	assert_d64_lt(a, b, ...)	assert_cmp(int64_t, a, b, <,	\
+#define assert_d64_lt(a, b, ...)	assert_cmp(int64_t, a, b, <,	\
     >=, FMTd64, __VA_ARGS__)
-#define	assert_d64_le(a, b, ...)	assert_cmp(int64_t, a, b, <=,	\
+#define assert_d64_le(a, b, ...)	assert_cmp(int64_t, a, b, <=,	\
     >, FMTd64, __VA_ARGS__)
-#define	assert_d64_ge(a, b, ...)	assert_cmp(int64_t, a, b, >=,	\
+#define assert_d64_ge(a, b, ...)	assert_cmp(int64_t, a, b, >=,	\
     <, FMTd64, __VA_ARGS__)
-#define	assert_d64_gt(a, b, ...)	assert_cmp(int64_t, a, b, >,	\
+#define assert_d64_gt(a, b, ...)	assert_cmp(int64_t, a, b, >,	\
     <=, FMTd64, __VA_ARGS__)
 
-#define	assert_u64_eq(a, b, ...)	assert_cmp(uint64_t, a, b, ==,	\
+#define assert_u64_eq(a, b, ...)	assert_cmp(uint64_t, a, b, ==,	\
     !=, FMTu64, __VA_ARGS__)
-#define	assert_u64_ne(a, b, ...)	assert_cmp(uint64_t, a, b, !=,	\
+#define assert_u64_ne(a, b, ...)	assert_cmp(uint64_t, a, b, !=,	\
     ==, FMTu64, __VA_ARGS__)
-#define	assert_u64_lt(a, b, ...)	assert_cmp(uint64_t, a, b, <,	\
+#define assert_u64_lt(a, b, ...)	assert_cmp(uint64_t, a, b, <,	\
     >=, FMTu64, __VA_ARGS__)
-#define	assert_u64_le(a, b, ...)	assert_cmp(uint64_t, a, b, <=,	\
+#define assert_u64_le(a, b, ...)	assert_cmp(uint64_t, a, b, <=,	\
     >, FMTu64, __VA_ARGS__)
-#define	assert_u64_ge(a, b, ...)	assert_cmp(uint64_t, a, b, >=,	\
+#define assert_u64_ge(a, b, ...)	assert_cmp(uint64_t, a, b, >=,	\
     <, FMTu64, __VA_ARGS__)
-#define	assert_u64_gt(a, b, ...)	assert_cmp(uint64_t, a, b, >,	\
+#define assert_u64_gt(a, b, ...)	assert_cmp(uint64_t, a, b, >,	\
     <=, FMTu64, __VA_ARGS__)
 
-#define	assert_b_eq(a, b, ...) do {					\
+#define assert_b_eq(a, b, ...) do {					\
 	bool a_ = (a);							\
 	bool b_ = (b);							\
 	if (!(a_ == b_)) {						\
@@ -226,7 +226,7 @@
 		p_test_fail(prefix, message);				\
 	}								\
 } while (0)
-#define	assert_b_ne(a, b, ...) do {					\
+#define assert_b_ne(a, b, ...) do {					\
 	bool a_ = (a);							\
 	bool b_ = (b);							\
 	if (!(a_ != b_)) {						\
@@ -242,10 +242,10 @@
 		p_test_fail(prefix, message);				\
 	}								\
 } while (0)
-#define	assert_true(a, ...)	assert_b_eq(a, true, __VA_ARGS__)
-#define	assert_false(a, ...)	assert_b_eq(a, false, __VA_ARGS__)
+#define assert_true(a, ...)	assert_b_eq(a, true, __VA_ARGS__)
+#define assert_false(a, ...)	assert_b_eq(a, false, __VA_ARGS__)
 
-#define	assert_str_eq(a, b, ...) do {				\
+#define assert_str_eq(a, b, ...) do {				\
 	if (strcmp((a), (b))) {						\
 		char prefix[ASSERT_BUFSIZE];				\
 		char message[ASSERT_BUFSIZE];				\
@@ -258,7 +258,7 @@
 		p_test_fail(prefix, message);				\
 	}								\
 } while (0)
-#define	assert_str_ne(a, b, ...) do {				\
+#define assert_str_ne(a, b, ...) do {				\
 	if (!strcmp((a), (b))) {					\
 		char prefix[ASSERT_BUFSIZE];				\
 		char message[ASSERT_BUFSIZE];				\
@@ -272,7 +272,7 @@
 	}								\
 } while (0)
 
-#define	assert_not_reached(...) do {					\
+#define assert_not_reached(...) do {					\
 	char prefix[ASSERT_BUFSIZE];					\
 	char message[ASSERT_BUFSIZE];					\
 	malloc_snprintf(prefix, sizeof(prefix),				\
@@ -296,24 +296,24 @@ typedef enum {
 
 typedef void (test_t)(void);
 
-#define	TEST_BEGIN(f)							\
+#define TEST_BEGIN(f)							\
 static void								\
 f(void) {								\
 	p_test_init(#f);
 
-#define	TEST_END							\
+#define TEST_END							\
 	goto label_test_end;						\
 label_test_end:								\
 	p_test_fini();							\
 }
 
-#define	test(...)							\
+#define test(...)							\
 	p_test(__VA_ARGS__, NULL)
 
-#define	test_no_malloc_init(...)					\
+#define test_no_malloc_init(...)					\
 	p_test_no_malloc_init(__VA_ARGS__, NULL)
 
-#define	test_skip_if(e) do {						\
+#define test_skip_if(e) do {						\
 	if (e) {							\
 		test_skip("%s:%s:%d: Test skipped: (%s)",		\
 		    __func__, __FILE__, __LINE__, #e);			\