Merge branch 'dev'5.0.0

15 files changed, 477 insertions, 727 deletions

diff --git a/test/integration/MALLOCX_ARENA.c b/test/integration/MALLOCX_ARENA.c
index 910a096..222164d 100644
--- a/test/integration/MALLOCX_ARENA.c
+++ b/test/integration/MALLOCX_ARENA.c
@@ -1,6 +1,6 @@
 #include "test/jemalloc_test.h"
 
-#define	NTHREADS 10
+#define NTHREADS 10
 
 static bool have_dss =
 #ifdef JEMALLOC_DSS
@@ -11,16 +11,15 @@ static bool have_dss =
     ;
 
 void *
-thd_start(void *arg)
-{
+thd_start(void *arg) {
 	unsigned thread_ind = (unsigned)(uintptr_t)arg;
 	unsigned arena_ind;
 	void *p;
 	size_t sz;
 
 	sz = sizeof(arena_ind);
-	assert_d_eq(mallctl("arenas.extend", (void *)&arena_ind, &sz, NULL, 0),
-	    0, "Error in arenas.extend");
+	assert_d_eq(mallctl("arenas.create", (void *)&arena_ind, &sz, NULL, 0),
+	    0, "Error in arenas.create");
 
 	if (thread_ind % 4 != 3) {
 		size_t mib[3];
@@ -42,11 +41,10 @@ thd_start(void *arg)
 	assert_ptr_not_null(p, "Unexpected mallocx() error");
 	dallocx(p, 0);
 
-	return (NULL);
+	return NULL;
 }
 
-TEST_BEGIN(test_MALLOCX_ARENA)
-{
+TEST_BEGIN(test_MALLOCX_ARENA) {
 	thd_t thds[NTHREADS];
 	unsigned i;
 
@@ -55,15 +53,14 @@ TEST_BEGIN(test_MALLOCX_ARENA)
 		    (void *)(uintptr_t)i);
 	}
 
-	for (i = 0; i < NTHREADS; i++)
+	for (i = 0; i < NTHREADS; i++) {
 		thd_join(thds[i], NULL);
+	}
 }
 TEST_END
 
 int
-main(void)
-{
-
-	return (test(
-	    test_MALLOCX_ARENA));
+main(void) {
+	return test(
+	    test_MALLOCX_ARENA);
 }
diff --git a/test/integration/aligned_alloc.c b/test/integration/aligned_alloc.c
index 5843842..536b67e 100644
--- a/test/integration/aligned_alloc.c
+++ b/test/integration/aligned_alloc.c
@@ -1,7 +1,6 @@
 #include "test/jemalloc_test.h"
 
-#define	CHUNK 0x400000
-#define	MAXALIGN (((size_t)1) << 23)
+#define MAXALIGN (((size_t)1) << 23)
 
 /*
  * On systems which can't merge extents, tests that call this function generate
@@ -9,15 +8,12 @@
  * potential OOM on e.g. 32-bit Windows.
  */
 static void
-purge(void)
-{
-
+purge(void) {
 	assert_d_eq(mallctl("arena.0.purge", NULL, NULL, NULL, 0), 0,
 	    "Unexpected mallctl error");
 }
 
-TEST_BEGIN(test_alignment_errors)
-{
+TEST_BEGIN(test_alignment_errors) {
 	size_t alignment;
 	void *p;
 
@@ -38,8 +34,7 @@ TEST_BEGIN(test_alignment_errors)
 }
 TEST_END
 
-TEST_BEGIN(test_oom_errors)
-{
+TEST_BEGIN(test_oom_errors) {
 	size_t alignment, size;
 	void *p;
 
@@ -83,15 +78,15 @@ TEST_BEGIN(test_oom_errors)
 }
 TEST_END
 
-TEST_BEGIN(test_alignment_and_size)
-{
-#define	NITER 4
+TEST_BEGIN(test_alignment_and_size) {
+#define NITER 4
 	size_t alignment, size, total;
 	unsigned i;
 	void *ps[NITER];
 
-	for (i = 0; i < NITER; i++)
+	for (i = 0; i < NITER; i++) {
 		ps[i] = NULL;
+	}
 
 	for (alignment = 8;
 	    alignment <= MAXALIGN;
@@ -112,8 +107,9 @@ TEST_BEGIN(test_alignment_and_size)
 					    alignment, size, size, buf);
 				}
 				total += malloc_usable_size(ps[i]);
-				if (total >= (MAXALIGN << 1))
+				if (total >= (MAXALIGN << 1)) {
 					break;
+				}
 			}
 			for (i = 0; i < NITER; i++) {
 				if (ps[i] != NULL) {
@@ -129,11 +125,9 @@ TEST_BEGIN(test_alignment_and_size)
 TEST_END
 
 int
-main(void)
-{
-
-	return (test(
+main(void) {
+	return test(
 	    test_alignment_errors,
 	    test_oom_errors,
-	    test_alignment_and_size));
+	    test_alignment_and_size);
 }
diff --git a/test/integration/allocated.c b/test/integration/allocated.c
index 6ce145b..1425fd0 100644
--- a/test/integration/allocated.c
+++ b/test/integration/allocated.c
@@ -9,8 +9,7 @@ static const bool config_stats =
     ;
 
 void *
-thd_start(void *arg)
-{
+thd_start(void *arg) {
 	int err;
 	void *p;
 	uint64_t a0, a1, d0, d1;
@@ -19,15 +18,17 @@ thd_start(void *arg)
 
 	sz = sizeof(a0);
 	if ((err = mallctl("thread.allocated", (void *)&a0, &sz, NULL, 0))) {
-		if (err == ENOENT)
+		if (err == ENOENT) {
 			goto label_ENOENT;
+		}
 		test_fail("%s(): Error in mallctl(): %s", __func__,
 		    strerror(err));
 	}
 	sz = sizeof(ap0);
 	if ((err = mallctl("thread.allocatedp", (void *)&ap0, &sz, NULL, 0))) {
-		if (err == ENOENT)
+		if (err == ENOENT) {
 			goto label_ENOENT;
+		}
 		test_fail("%s(): Error in mallctl(): %s", __func__,
 		    strerror(err));
 	}
@@ -37,16 +38,18 @@ thd_start(void *arg)
 
 	sz = sizeof(d0);
 	if ((err = mallctl("thread.deallocated", (void *)&d0, &sz, NULL, 0))) {
-		if (err == ENOENT)
+		if (err == ENOENT) {
 			goto label_ENOENT;
+		}
 		test_fail("%s(): Error in mallctl(): %s", __func__,
 		    strerror(err));
 	}
 	sz = sizeof(dp0);
 	if ((err = mallctl("thread.deallocatedp", (void *)&dp0, &sz, NULL,
 	    0))) {
-		if (err == ENOENT)
+		if (err == ENOENT) {
 			goto label_ENOENT;
+		}
 		test_fail("%s(): Error in mallctl(): %s", __func__,
 		    strerror(err));
 	}
@@ -88,23 +91,20 @@ thd_start(void *arg)
 	    "Deallocated memory counter should increase by at least the amount "
 	    "explicitly deallocated");
 
-	return (NULL);
+	return NULL;
 label_ENOENT:
 	assert_false(config_stats,
 	    "ENOENT should only be returned if stats are disabled");
 	test_skip("\"thread.allocated\" mallctl not available");
-	return (NULL);
+	return NULL;
 }
 
-TEST_BEGIN(test_main_thread)
-{
-
+TEST_BEGIN(test_main_thread) {
 	thd_start(NULL);
 }
 TEST_END
 
-TEST_BEGIN(test_subthread)
-{
+TEST_BEGIN(test_subthread) {
 	thd_t thd;
 
 	thd_create(&thd, thd_start, NULL);
@@ -113,14 +113,12 @@ TEST_BEGIN(test_subthread)
 TEST_END
 
 int
-main(void)
-{
-
+main(void) {
 	/* Run tests multiple times to check for bad interactions. */
-	return (test(
+	return test(
 	    test_main_thread,
 	    test_subthread,
 	    test_main_thread,
 	    test_subthread,
-	    test_main_thread));
+	    test_main_thread);
 }
diff --git a/test/integration/chunk.c b/test/integration/chunk.c
deleted file mode 100644
index 997567a..0000000
--- a/test/integration/chunk.c
+++ /dev/null
@@ -1,290 +0,0 @@
-#include "test/jemalloc_test.h"
-
-static chunk_hooks_t orig_hooks;
-static chunk_hooks_t old_hooks;
-
-static bool do_dalloc = true;
-static bool do_decommit;
-
-static bool did_alloc;
-static bool did_dalloc;
-static bool did_commit;
-static bool did_decommit;
-static bool did_purge;
-static bool did_split;
-static bool did_merge;
-
-#if 0
-#  define TRACE_HOOK(fmt, ...) malloc_printf(fmt, __VA_ARGS__)
-#else
-#  define TRACE_HOOK(fmt, ...)
-#endif
-
-void *
-chunk_alloc(void *new_addr, size_t size, size_t alignment, bool *zero,
-    bool *commit, unsigned arena_ind)
-{
-
-	TRACE_HOOK("%s(new_addr=%p, size=%zu, alignment=%zu, *zero=%s, "
-	    "*commit=%s, arena_ind=%u)\n", __func__, new_addr, size, alignment,
-	    *zero ?  "true" : "false", *commit ? "true" : "false", arena_ind);
-	did_alloc = true;
-	return (old_hooks.alloc(new_addr, size, alignment, zero, commit,
-	    arena_ind));
-}
-
-bool
-chunk_dalloc(void *chunk, size_t size, bool committed, unsigned arena_ind)
-{
-
-	TRACE_HOOK("%s(chunk=%p, size=%zu, committed=%s, arena_ind=%u)\n",
-	    __func__, chunk, size, committed ? "true" : "false", arena_ind);
-	did_dalloc = true;
-	if (!do_dalloc)
-		return (true);
-	return (old_hooks.dalloc(chunk, size, committed, arena_ind));
-}
-
-bool
-chunk_commit(void *chunk, size_t size, size_t offset, size_t length,
-    unsigned arena_ind)
-{
-	bool err;
-
-	TRACE_HOOK("%s(chunk=%p, size=%zu, offset=%zu, length=%zu, "
-	    "arena_ind=%u)\n", __func__, chunk, size, offset, length,
-	    arena_ind);
-	err = old_hooks.commit(chunk, size, offset, length, arena_ind);
-	did_commit = !err;
-	return (err);
-}
-
-bool
-chunk_decommit(void *chunk, size_t size, size_t offset, size_t length,
-    unsigned arena_ind)
-{
-	bool err;
-
-	TRACE_HOOK("%s(chunk=%p, size=%zu, offset=%zu, length=%zu, "
-	    "arena_ind=%u)\n", __func__, chunk, size, offset, length,
-	    arena_ind);
-	if (!do_decommit)
-		return (true);
-	err = old_hooks.decommit(chunk, size, offset, length, arena_ind);
-	did_decommit = !err;
-	return (err);
-}
-
-bool
-chunk_purge(void *chunk, size_t size, size_t offset, size_t length,
-    unsigned arena_ind)
-{
-
-	TRACE_HOOK("%s(chunk=%p, size=%zu, offset=%zu, length=%zu "
-	    "arena_ind=%u)\n", __func__, chunk, size, offset, length,
-	    arena_ind);
-	did_purge = true;
-	return (old_hooks.purge(chunk, size, offset, length, arena_ind));
-}
-
-bool
-chunk_split(void *chunk, size_t size, size_t size_a, size_t size_b,
-    bool committed, unsigned arena_ind)
-{
-
-	TRACE_HOOK("%s(chunk=%p, size=%zu, size_a=%zu, size_b=%zu, "
-	    "committed=%s, arena_ind=%u)\n", __func__, chunk, size, size_a,
-	    size_b, committed ? "true" : "false", arena_ind);
-	did_split = true;
-	return (old_hooks.split(chunk, size, size_a, size_b, committed,
-	    arena_ind));
-}
-
-bool
-chunk_merge(void *chunk_a, size_t size_a, void *chunk_b, size_t size_b,
-    bool committed, unsigned arena_ind)
-{
-
-	TRACE_HOOK("%s(chunk_a=%p, size_a=%zu, chunk_b=%p size_b=%zu, "
-	    "committed=%s, arena_ind=%u)\n", __func__, chunk_a, size_a, chunk_b,
-	    size_b, committed ? "true" : "false", arena_ind);
-	did_merge = true;
-	return (old_hooks.merge(chunk_a, size_a, chunk_b, size_b,
-	    committed, arena_ind));
-}
-
-TEST_BEGIN(test_chunk)
-{
-	void *p;
-	size_t old_size, new_size, large0, large1, huge0, huge1, huge2, sz;
-	unsigned arena_ind;
-	int flags;
-	size_t hooks_mib[3], purge_mib[3];
-	size_t hooks_miblen, purge_miblen;
-	chunk_hooks_t new_hooks = {
-		chunk_alloc,
-		chunk_dalloc,
-		chunk_commit,
-		chunk_decommit,
-		chunk_purge,
-		chunk_split,
-		chunk_merge
-	};
-	bool xallocx_success_a, xallocx_success_b, xallocx_success_c;
-
-	sz = sizeof(unsigned);
-	assert_d_eq(mallctl("arenas.extend", (void *)&arena_ind, &sz, NULL, 0),
-	    0, "Unexpected mallctl() failure");
-	flags = MALLOCX_ARENA(arena_ind) | MALLOCX_TCACHE_NONE;
-
-	/* Install custom chunk hooks. */
-	hooks_miblen = sizeof(hooks_mib)/sizeof(size_t);
-	assert_d_eq(mallctlnametomib("arena.0.chunk_hooks", hooks_mib,
-	    &hooks_miblen), 0, "Unexpected mallctlnametomib() failure");
-	hooks_mib[1] = (size_t)arena_ind;
-	old_size = sizeof(chunk_hooks_t);
-	new_size = sizeof(chunk_hooks_t);
-	assert_d_eq(mallctlbymib(hooks_mib, hooks_miblen, (void *)&old_hooks,
-	    &old_size, (void *)&new_hooks, new_size), 0,
-	    "Unexpected chunk_hooks error");
-	orig_hooks = old_hooks;
-	assert_ptr_ne(old_hooks.alloc, chunk_alloc, "Unexpected alloc error");
-	assert_ptr_ne(old_hooks.dalloc, chunk_dalloc,
-	    "Unexpected dalloc error");
-	assert_ptr_ne(old_hooks.commit, chunk_commit,
-	    "Unexpected commit error");
-	assert_ptr_ne(old_hooks.decommit, chunk_decommit,
-	    "Unexpected decommit error");
-	assert_ptr_ne(old_hooks.purge, chunk_purge, "Unexpected purge error");
-	assert_ptr_ne(old_hooks.split, chunk_split, "Unexpected split error");
-	assert_ptr_ne(old_hooks.merge, chunk_merge, "Unexpected merge error");
-
-	/* Get large size classes. */
-	sz = sizeof(size_t);
-	assert_d_eq(mallctl("arenas.lrun.0.size", (void *)&large0, &sz, NULL,
-	    0), 0, "Unexpected arenas.lrun.0.size failure");
-	assert_d_eq(mallctl("arenas.lrun.1.size", (void *)&large1, &sz, NULL,
-	    0), 0, "Unexpected arenas.lrun.1.size failure");
-
-	/* Get huge size classes. */
-	assert_d_eq(mallctl("arenas.hchunk.0.size", (void *)&huge0, &sz, NULL,
-	    0), 0, "Unexpected arenas.hchunk.0.size failure");
-	assert_d_eq(mallctl("arenas.hchunk.1.size", (void *)&huge1, &sz, NULL,
-	    0), 0, "Unexpected arenas.hchunk.1.size failure");
-	assert_d_eq(mallctl("arenas.hchunk.2.size", (void *)&huge2, &sz, NULL,
-	    0), 0, "Unexpected arenas.hchunk.2.size failure");
-
-	/* Test dalloc/decommit/purge cascade. */
-	purge_miblen = sizeof(purge_mib)/sizeof(size_t);
-	assert_d_eq(mallctlnametomib("arena.0.purge", purge_mib, &purge_miblen),
-	    0, "Unexpected mallctlnametomib() failure");
-	purge_mib[1] = (size_t)arena_ind;
-	do_dalloc = false;
-	do_decommit = false;
-	p = mallocx(huge0 * 2, flags);
-	assert_ptr_not_null(p, "Unexpected mallocx() error");
-	did_dalloc = false;
-	did_decommit = false;
-	did_purge = false;
-	did_split = false;
-	xallocx_success_a = (xallocx(p, huge0, 0, flags) == huge0);
-	assert_d_eq(mallctlbymib(purge_mib, purge_miblen, NULL, NULL, NULL, 0),
-	    0, "Unexpected arena.%u.purge error", arena_ind);
-	if (xallocx_success_a) {
-		assert_true(did_dalloc, "Expected dalloc");
-		assert_false(did_decommit, "Unexpected decommit");
-		assert_true(did_purge, "Expected purge");
-	}
-	assert_true(did_split, "Expected split");
-	dallocx(p, flags);
-	do_dalloc = true;
-
-	/* Test decommit/commit and observe split/merge. */
-	do_dalloc = false;
-	do_decommit = true;
-	p = mallocx(huge0 * 2, flags);
-	assert_ptr_not_null(p, "Unexpected mallocx() error");
-	did_decommit = false;
-	did_commit = false;
-	did_split = false;
-	did_merge = false;
-	xallocx_success_b = (xallocx(p, huge0, 0, flags) == huge0);
-	assert_d_eq(mallctlbymib(purge_mib, purge_miblen, NULL, NULL, NULL, 0),
-	    0, "Unexpected arena.%u.purge error", arena_ind);
-	if (xallocx_success_b)
-		assert_true(did_split, "Expected split");
-	xallocx_success_c = (xallocx(p, huge0 * 2, 0, flags) == huge0 * 2);
-	assert_b_eq(did_decommit, did_commit, "Expected decommit/commit match");
-	if (xallocx_success_b && xallocx_success_c)
-		assert_true(did_merge, "Expected merge");
-	dallocx(p, flags);
-	do_dalloc = true;
-	do_decommit = false;
-
-	/* Test purge for partial-chunk huge allocations. */
-	if (huge0 * 2 > huge2) {
-		/*
-		 * There are at least four size classes per doubling, so a
-		 * successful xallocx() from size=huge2 to size=huge1 is
-		 * guaranteed to leave trailing purgeable memory.
-		 */
-		p = mallocx(huge2, flags);
-		assert_ptr_not_null(p, "Unexpected mallocx() error");
-		did_purge = false;
-		assert_zu_eq(xallocx(p, huge1, 0, flags), huge1,
-		    "Unexpected xallocx() failure");
-		assert_true(did_purge, "Expected purge");
-		dallocx(p, flags);
-	}
-
-	/* Test decommit for large allocations. */
-	do_decommit = true;
-	p = mallocx(large1, flags);
-	assert_ptr_not_null(p, "Unexpected mallocx() error");
-	assert_d_eq(mallctlbymib(purge_mib, purge_miblen, NULL, NULL, NULL, 0),
-	    0, "Unexpected arena.%u.purge error", arena_ind);
-	did_decommit = false;
-	assert_zu_eq(xallocx(p, large0, 0, flags), large0,
-	    "Unexpected xallocx() failure");
-	assert_d_eq(mallctlbymib(purge_mib, purge_miblen, NULL, NULL, NULL, 0),
-	    0, "Unexpected arena.%u.purge error", arena_ind);
-	did_commit = false;
-	assert_zu_eq(xallocx(p, large1, 0, flags), large1,
-	    "Unexpected xallocx() failure");
-	assert_b_eq(did_decommit, did_commit, "Expected decommit/commit match");
-	dallocx(p, flags);
-	do_decommit = false;
-
-	/* Make sure non-huge allocation succeeds. */
-	p = mallocx(42, flags);
-	assert_ptr_not_null(p, "Unexpected mallocx() error");
-	dallocx(p, flags);
-
-	/* Restore chunk hooks. */
-	assert_d_eq(mallctlbymib(hooks_mib, hooks_miblen, NULL, NULL,
-	    (void *)&old_hooks, new_size), 0, "Unexpected chunk_hooks error");
-	assert_d_eq(mallctlbymib(hooks_mib, hooks_miblen, (void *)&old_hooks,
-	    &old_size, NULL, 0), 0, "Unexpected chunk_hooks error");
-	assert_ptr_eq(old_hooks.alloc, orig_hooks.alloc,
-	    "Unexpected alloc error");
-	assert_ptr_eq(old_hooks.dalloc, orig_hooks.dalloc,
-	    "Unexpected dalloc error");
-	assert_ptr_eq(old_hooks.commit, orig_hooks.commit,
-	    "Unexpected commit error");
-	assert_ptr_eq(old_hooks.decommit, orig_hooks.decommit,
-	    "Unexpected decommit error");
-	assert_ptr_eq(old_hooks.purge, orig_hooks.purge,
-	    "Unexpected purge error");
-	assert_ptr_eq(old_hooks.split, orig_hooks.split,
-	    "Unexpected split error");
-	assert_ptr_eq(old_hooks.merge, orig_hooks.merge,
-	    "Unexpected merge error");
-}
-TEST_END
-
-int
-main(void)
-{
-
-	return (test(test_chunk));
-}
diff --git a/test/integration/cpp/basic.cpp b/test/integration/cpp/basic.cpp
new file mode 100644
index 0000000..65890ec
--- /dev/null
+++ b/test/integration/cpp/basic.cpp
@@ -0,0 +1,25 @@
+#include <memory>
+#include "test/jemalloc_test.h"
+
+TEST_BEGIN(test_basic) {
+	auto foo = new long(4);
+	assert_ptr_not_null(foo, "Unexpected new[] failure");
+	delete foo;
+	// Test nullptr handling.
+	foo = nullptr;
+	delete foo;
+
+	auto bar = new long;
+	assert_ptr_not_null(bar, "Unexpected new failure");
+	delete bar;
+	// Test nullptr handling.
+	bar = nullptr;
+	delete bar;
+}
+TEST_END
+
+int
+main() {
+	return test(
+	    test_basic);
+}
diff --git a/test/integration/extent.c b/test/integration/extent.c
new file mode 100644
index 0000000..7262b80
--- /dev/null
+++ b/test/integration/extent.c
@@ -0,0 +1,190 @@
+#include "test/jemalloc_test.h"
+
+#include "test/extent_hooks.h"
+
+static bool
+check_background_thread_enabled(void) {
+	bool enabled;
+	size_t sz = sizeof(bool);
+	int ret = mallctl("background_thread", (void *)&enabled, &sz, NULL,0);
+	if (ret == ENOENT) {
+		return false;
+	}
+	assert_d_eq(ret, 0, "Unexpected mallctl error");
+	return enabled;
+}
+
+static void
+test_extent_body(unsigned arena_ind) {
+	void *p;
+	size_t large0, large1, large2, sz;
+	size_t purge_mib[3];
+	size_t purge_miblen;
+	int flags;
+	bool xallocx_success_a, xallocx_success_b, xallocx_success_c;
+
+	flags = MALLOCX_ARENA(arena_ind) | MALLOCX_TCACHE_NONE;
+
+	/* Get large size classes. */
+	sz = sizeof(size_t);
+	assert_d_eq(mallctl("arenas.lextent.0.size", (void *)&large0, &sz, NULL,
+	    0), 0, "Unexpected arenas.lextent.0.size failure");
+	assert_d_eq(mallctl("arenas.lextent.1.size", (void *)&large1, &sz, NULL,
+	    0), 0, "Unexpected arenas.lextent.1.size failure");
+	assert_d_eq(mallctl("arenas.lextent.2.size", (void *)&large2, &sz, NULL,
+	    0), 0, "Unexpected arenas.lextent.2.size failure");
+
+	/* Test dalloc/decommit/purge cascade. */
+	purge_miblen = sizeof(purge_mib)/sizeof(size_t);
+	assert_d_eq(mallctlnametomib("arena.0.purge", purge_mib, &purge_miblen),
+	    0, "Unexpected mallctlnametomib() failure");
+	purge_mib[1] = (size_t)arena_ind;
+	try_dalloc = false;
+	try_decommit = false;
+	p = mallocx(large0 * 2, flags);
+	assert_ptr_not_null(p, "Unexpected mallocx() error");
+	called_dalloc = false;
+	called_decommit = false;
+	did_purge_lazy = false;
+	did_purge_forced = false;
+	called_split = false;
+	xallocx_success_a = (xallocx(p, large0, 0, flags) == large0);
+	assert_d_eq(mallctlbymib(purge_mib, purge_miblen, NULL, NULL, NULL, 0),
+	    0, "Unexpected arena.%u.purge error", arena_ind);
+	if (xallocx_success_a) {
+		assert_true(called_dalloc, "Expected dalloc call");
+		assert_true(called_decommit, "Expected decommit call");
+		assert_true(did_purge_lazy || did_purge_forced,
+		    "Expected purge");
+	}
+	assert_true(called_split, "Expected split call");
+	dallocx(p, flags);
+	try_dalloc = true;
+
+	/* Test decommit/commit and observe split/merge. */
+	try_dalloc = false;
+	try_decommit = true;
+	p = mallocx(large0 * 2, flags);
+	assert_ptr_not_null(p, "Unexpected mallocx() error");
+	did_decommit = false;
+	did_commit = false;
+	called_split = false;
+	did_split = false;
+	did_merge = false;
+	xallocx_success_b = (xallocx(p, large0, 0, flags) == large0);
+	assert_d_eq(mallctlbymib(purge_mib, purge_miblen, NULL, NULL, NULL, 0),
+	    0, "Unexpected arena.%u.purge error", arena_ind);
+	if (xallocx_success_b) {
+		assert_true(did_split, "Expected split");
+	}
+	xallocx_success_c = (xallocx(p, large0 * 2, 0, flags) == large0 * 2);
+	if (did_split) {
+		assert_b_eq(did_decommit, did_commit,
+		    "Expected decommit/commit match");
+	}
+	if (xallocx_success_b && xallocx_success_c) {
+		assert_true(did_merge, "Expected merge");
+	}
+	dallocx(p, flags);
+	try_dalloc = true;
+	try_decommit = false;
+
+	/* Make sure non-large allocation succeeds. */
+	p = mallocx(42, flags);
+	assert_ptr_not_null(p, "Unexpected mallocx() error");
+	dallocx(p, flags);
+}
+
+TEST_BEGIN(test_extent_manual_hook) {
+	unsigned arena_ind;
+	size_t old_size, new_size, sz;
+	size_t hooks_mib[3];
+	size_t hooks_miblen;
+	extent_hooks_t *new_hooks, *old_hooks;
+
+	extent_hooks_prep();
+
+	sz = sizeof(unsigned);
+	assert_d_eq(mallctl("arenas.create", (void *)&arena_ind, &sz, NULL, 0),
+	    0, "Unexpected mallctl() failure");
+
+	/* Install custom extent hooks. */
+	hooks_miblen = sizeof(hooks_mib)/sizeof(size_t);
+	assert_d_eq(mallctlnametomib("arena.0.extent_hooks", hooks_mib,
+	    &hooks_miblen), 0, "Unexpected mallctlnametomib() failure");
+	hooks_mib[1] = (size_t)arena_ind;
+	old_size = sizeof(extent_hooks_t *);
+	new_hooks = &hooks;
+	new_size = sizeof(extent_hooks_t *);
+	assert_d_eq(mallctlbymib(hooks_mib, hooks_miblen, (void *)&old_hooks,
+	    &old_size, (void *)&new_hooks, new_size), 0,
+	    "Unexpected extent_hooks error");
+	assert_ptr_ne(old_hooks->alloc, extent_alloc_hook,
+	    "Unexpected extent_hooks error");
+	assert_ptr_ne(old_hooks->dalloc, extent_dalloc_hook,
+	    "Unexpected extent_hooks error");
+	assert_ptr_ne(old_hooks->commit, extent_commit_hook,
+	    "Unexpected extent_hooks error");
+	assert_ptr_ne(old_hooks->decommit, extent_decommit_hook,
+	    "Unexpected extent_hooks error");
+	assert_ptr_ne(old_hooks->purge_lazy, extent_purge_lazy_hook,
+	    "Unexpected extent_hooks error");
+	assert_ptr_ne(old_hooks->purge_forced, extent_purge_forced_hook,
+	    "Unexpected extent_hooks error");
+	assert_ptr_ne(old_hooks->split, extent_split_hook,
+	    "Unexpected extent_hooks error");
+	assert_ptr_ne(old_hooks->merge, extent_merge_hook,
+	    "Unexpected extent_hooks error");
+
+	test_skip_if(check_background_thread_enabled());
+	test_extent_body(arena_ind);
+
+	/* Restore extent hooks. */
+	assert_d_eq(mallctlbymib(hooks_mib, hooks_miblen, NULL, NULL,
+	    (void *)&old_hooks, new_size), 0, "Unexpected extent_hooks error");
+	assert_d_eq(mallctlbymib(hooks_mib, hooks_miblen, (void *)&old_hooks,
+	    &old_size, NULL, 0), 0, "Unexpected extent_hooks error");
+	assert_ptr_eq(old_hooks, default_hooks, "Unexpected extent_hooks error");
+	assert_ptr_eq(old_hooks->alloc, default_hooks->alloc,
+	    "Unexpected extent_hooks error");
+	assert_ptr_eq(old_hooks->dalloc, default_hooks->dalloc,
+	    "Unexpected extent_hooks error");
+	assert_ptr_eq(old_hooks->commit, default_hooks->commit,
+	    "Unexpected extent_hooks error");
+	assert_ptr_eq(old_hooks->decommit, default_hooks->decommit,
+	    "Unexpected extent_hooks error");
+	assert_ptr_eq(old_hooks->purge_lazy, default_hooks->purge_lazy,
+	    "Unexpected extent_hooks error");
+	assert_ptr_eq(old_hooks->purge_forced, default_hooks->purge_forced,
+	    "Unexpected extent_hooks error");
+	assert_ptr_eq(old_hooks->split, default_hooks->split,
+	    "Unexpected extent_hooks error");
+	assert_ptr_eq(old_hooks->merge, default_hooks->merge,
+	    "Unexpected extent_hooks error");
+}
+TEST_END
+
+TEST_BEGIN(test_extent_auto_hook) {
+	unsigned arena_ind;
+	size_t new_size, sz;
+	extent_hooks_t *new_hooks;
+
+	extent_hooks_prep();
+
+	sz = sizeof(unsigned);
+	new_hooks = &hooks;
+	new_size = sizeof(extent_hooks_t *);
+	assert_d_eq(mallctl("arenas.create", (void *)&arena_ind, &sz,
+	    (void *)&new_hooks, new_size), 0, "Unexpected mallctl() failure");
+
+	test_skip_if(check_background_thread_enabled());
+	test_extent_body(arena_ind);
+}
+TEST_END
+
+int
+main(void) {
+	return test(
+	    test_extent_manual_hook,
+	    test_extent_auto_hook);
+}
diff --git a/test/integration/chunk.sh b/test/integration/extent.sh
index 0cc2187..0cc2187 100644
--- a/test/integration/chunk.sh
+++ b/test/integration/extent.sh
diff --git a/test/integration/mallocx.c b/test/integration/mallocx.c
index 5a9058d..b0b5cda 100644
--- a/test/integration/mallocx.c
+++ b/test/integration/mallocx.c
@@ -1,8 +1,7 @@
 #include "test/jemalloc_test.h"
 
 static unsigned
-get_nsizes_impl(const char *cmd)
-{
+get_nsizes_impl(const char *cmd) {
 	unsigned ret;
 	size_t z;
 
@@ -10,19 +9,16 @@ get_nsizes_impl(const char *cmd)
 	assert_d_eq(mallctl(cmd, (void *)&ret, &z, NULL, 0), 0,
 	    "Unexpected mallctl(\"%s\", ...) failure", cmd);
 
-	return (ret);
+	return ret;
 }
 
 static unsigned
-get_nhuge(void)
-{
-
-	return (get_nsizes_impl("arenas.nhchunks"));
+get_nlarge(void) {
+	return get_nsizes_impl("arenas.nlextents");
 }
 
 static size_t
-get_size_impl(const char *cmd, size_t ind)
-{
+get_size_impl(const char *cmd, size_t ind) {
 	size_t ret;
 	size_t z;
 	size_t mib[4];
@@ -36,14 +32,12 @@ get_size_impl(const char *cmd, size_t ind)
 	assert_d_eq(mallctlbymib(mib, miblen, (void *)&ret, &z, NULL, 0),
 	    0, "Unexpected mallctlbymib([\"%s\", %zu], ...) failure", cmd, ind);
 
-	return (ret);
+	return ret;
 }
 
 static size_t
-get_huge_size(size_t ind)
-{
-
-	return (get_size_impl("arenas.hchunk.0.size", ind));
+get_large_size(size_t ind) {
+	return get_size_impl("arenas.lextent.0.size", ind);
 }
 
 /*
@@ -52,21 +46,18 @@ get_huge_size(size_t ind)
  * potential OOM on e.g. 32-bit Windows.
  */
 static void
-purge(void)
-{
-
+purge(void) {
 	assert_d_eq(mallctl("arena.0.purge", NULL, NULL, NULL, 0), 0,
 	    "Unexpected mallctl error");
 }
 
-TEST_BEGIN(test_overflow)
-{
-	size_t hugemax;
+TEST_BEGIN(test_overflow) {
+	size_t largemax;
 
-	hugemax = get_huge_size(get_nhuge()-1);
+	largemax = get_large_size(get_nlarge()-1);
 
-	assert_ptr_null(mallocx(hugemax+1, 0),
-	    "Expected OOM for mallocx(size=%#zx, 0)", hugemax+1);
+	assert_ptr_null(mallocx(largemax+1, 0),
+	    "Expected OOM for mallocx(size=%#zx, 0)", largemax+1);
 
 	assert_ptr_null(mallocx(ZU(PTRDIFF_MAX)+1, 0),
 	    "Expected OOM for mallocx(size=%#zx, 0)", ZU(PTRDIFF_MAX)+1);
@@ -80,9 +71,8 @@ TEST_BEGIN(test_overflow)
 }
 TEST_END
 
-TEST_BEGIN(test_oom)
-{
-	size_t hugemax;
+TEST_BEGIN(test_oom) {
+	size_t largemax;
 	bool oom;
 	void *ptrs[3];
 	unsigned i;
@@ -91,19 +81,21 @@ TEST_BEGIN(test_oom)
 	 * It should be impossible to allocate three objects that each consume
 	 * nearly half the virtual address space.
 	 */
-	hugemax = get_huge_size(get_nhuge()-1);
+	largemax = get_large_size(get_nlarge()-1);
 	oom = false;
 	for (i = 0; i < sizeof(ptrs) / sizeof(void *); i++) {
-		ptrs[i] = mallocx(hugemax, 0);
-		if (ptrs[i] == NULL)
+		ptrs[i] = mallocx(largemax, 0);
+		if (ptrs[i] == NULL) {
 			oom = true;
+		}
 	}
 	assert_true(oom,
 	    "Expected OOM during series of calls to mallocx(size=%zu, 0)",
-	    hugemax);
+	    largemax);
 	for (i = 0; i < sizeof(ptrs) / sizeof(void *); i++) {
-		if (ptrs[i] != NULL)
+		if (ptrs[i] != NULL) {
 			dallocx(ptrs[i], 0);
+		}
 	}
 	purge();
 
@@ -121,9 +113,8 @@ TEST_BEGIN(test_oom)
 }
 TEST_END
 
-TEST_BEGIN(test_basic)
-{
-#define	MAXSZ (((size_t)1) << 23)
+TEST_BEGIN(test_basic) {
+#define MAXSZ (((size_t)1) << 23)
 	size_t sz;
 
 	for (sz = 1; sz < MAXSZ; sz = nallocx(sz, 0) + 1) {
@@ -159,16 +150,16 @@ TEST_BEGIN(test_basic)
 }
 TEST_END
 
-TEST_BEGIN(test_alignment_and_size)
-{
-#define	MAXALIGN (((size_t)1) << 23)
-#define	NITER 4
+TEST_BEGIN(test_alignment_and_size) {
+#define MAXALIGN (((size_t)1) << 23)
+#define NITER 4
 	size_t nsz, rsz, sz, alignment, total;
 	unsigned i;
 	void *ps[NITER];
 
-	for (i = 0; i < NITER; i++)
+	for (i = 0; i < NITER; i++) {
 		ps[i] = NULL;
+	}
 
 	for (alignment = 8;
 	    alignment <= MAXALIGN;
@@ -201,8 +192,9 @@ TEST_BEGIN(test_alignment_and_size)
 				    " alignment=%zu, size=%zu", ps[i],
 				    alignment, sz);
 				total += rsz;
-				if (total >= (MAXALIGN << 1))
+				if (total >= (MAXALIGN << 1)) {
 					break;
+				}
 			}
 			for (i = 0; i < NITER; i++) {
 				if (ps[i] != NULL) {
@@ -219,12 +211,10 @@ TEST_BEGIN(test_alignment_and_size)
 TEST_END
 
 int
-main(void)
-{
-
-	return (test(
+main(void) {
+	return test(
 	    test_overflow,
 	    test_oom,
 	    test_basic,
-	    test_alignment_and_size));
+	    test_alignment_and_size);
 }
diff --git a/test/integration/overflow.c b/test/integration/overflow.c
index 84a3565..6a9785b 100644
--- a/test/integration/overflow.c
+++ b/test/integration/overflow.c
@@ -1,20 +1,19 @@
 #include "test/jemalloc_test.h"
 
-TEST_BEGIN(test_overflow)
-{
-	unsigned nhchunks;
+TEST_BEGIN(test_overflow) {
+	unsigned nlextents;
 	size_t mib[4];
 	size_t sz, miblen, max_size_class;
 	void *p;
 
 	sz = sizeof(unsigned);
-	assert_d_eq(mallctl("arenas.nhchunks", (void *)&nhchunks, &sz, NULL, 0),
-	    0, "Unexpected mallctl() error");
+	assert_d_eq(mallctl("arenas.nlextents", (void *)&nlextents, &sz, NULL,
+	    0), 0, "Unexpected mallctl() error");
 
 	miblen = sizeof(mib) / sizeof(size_t);
-	assert_d_eq(mallctlnametomib("arenas.hchunk.0.size", mib, &miblen), 0,
+	assert_d_eq(mallctlnametomib("arenas.lextent.0.size", mib, &miblen), 0,
 	    "Unexpected mallctlnametomib() error");
-	mib[2] = nhchunks - 1;
+	mib[2] = nlextents - 1;
 
 	sz = sizeof(size_t);
 	assert_d_eq(mallctlbymib(mib, miblen, (void *)&max_size_class, &sz,
@@ -41,9 +40,7 @@ TEST_BEGIN(test_overflow)
 TEST_END
 
 int
-main(void)
-{
-
-	return (test(
-	    test_overflow));
+main(void) {
+	return test(
+	    test_overflow);
 }
diff --git a/test/integration/posix_memalign.c b/test/integration/posix_memalign.c
index e22e102..2c2726d 100644
--- a/test/integration/posix_memalign.c
+++ b/test/integration/posix_memalign.c
@@ -1,7 +1,6 @@
 #include "test/jemalloc_test.h"
 
-#define	CHUNK 0x400000
-#define	MAXALIGN (((size_t)1) << 23)
+#define MAXALIGN (((size_t)1) << 23)
 
 /*
  * On systems which can't merge extents, tests that call this function generate
@@ -9,15 +8,12 @@
  * potential OOM on e.g. 32-bit Windows.
  */
 static void
-purge(void)
-{
-
+purge(void) {
 	assert_d_eq(mallctl("arena.0.purge", NULL, NULL, NULL, 0), 0,
 	    "Unexpected mallctl error");
 }
 
-TEST_BEGIN(test_alignment_errors)
-{
+TEST_BEGIN(test_alignment_errors) {
 	size_t alignment;
 	void *p;
 
@@ -36,8 +32,7 @@ TEST_BEGIN(test_alignment_errors)
 }
 TEST_END
 
-TEST_BEGIN(test_oom_errors)
-{
+TEST_BEGIN(test_oom_errors) {
 	size_t alignment, size;
 	void *p;
 
@@ -75,16 +70,16 @@ TEST_BEGIN(test_oom_errors)
 }
 TEST_END
 
-TEST_BEGIN(test_alignment_and_size)
-{
-#define	NITER 4
+TEST_BEGIN(test_alignment_and_size) {
+#define NITER 4
 	size_t alignment, size, total;
 	unsigned i;
 	int err;
 	void *ps[NITER];
 
-	for (i = 0; i < NITER; i++)
+	for (i = 0; i < NITER; i++) {
 		ps[i] = NULL;
+	}
 
 	for (alignment = 8;
 	    alignment <= MAXALIGN;
@@ -106,8 +101,9 @@ TEST_BEGIN(test_alignment_and_size)
 					    alignment, size, size, buf);
 				}
 				total += malloc_usable_size(ps[i]);
-				if (total >= (MAXALIGN << 1))
+				if (total >= (MAXALIGN << 1)) {
 					break;
+				}
 			}
 			for (i = 0; i < NITER; i++) {
 				if (ps[i] != NULL) {
@@ -123,11 +119,9 @@ TEST_BEGIN(test_alignment_and_size)
 TEST_END
 
 int
-main(void)
-{
-
-	return (test(
+main(void) {
+	return test(
 	    test_alignment_errors,
 	    test_oom_errors,
-	    test_alignment_and_size));
+	    test_alignment_and_size);
 }
diff --git a/test/integration/rallocx.c b/test/integration/rallocx.c
index 506bf1c..7821ca5 100644
--- a/test/integration/rallocx.c
+++ b/test/integration/rallocx.c
@@ -1,8 +1,7 @@
 #include "test/jemalloc_test.h"
 
 static unsigned
-get_nsizes_impl(const char *cmd)
-{
+get_nsizes_impl(const char *cmd) {
 	unsigned ret;
 	size_t z;
 
@@ -10,19 +9,16 @@ get_nsizes_impl(const char *cmd)
 	assert_d_eq(mallctl(cmd, (void *)&ret, &z, NULL, 0), 0,
 	    "Unexpected mallctl(\"%s\", ...) failure", cmd);
 
-	return (ret);
+	return ret;
 }
 
 static unsigned
-get_nhuge(void)
-{
-
-	return (get_nsizes_impl("arenas.nhchunks"));
+get_nlarge(void) {
+	return get_nsizes_impl("arenas.nlextents");
 }
 
 static size_t
-get_size_impl(const char *cmd, size_t ind)
-{
+get_size_impl(const char *cmd, size_t ind) {
 	size_t ret;
 	size_t z;
 	size_t mib[4];
@@ -36,25 +32,22 @@ get_size_impl(const char *cmd, size_t ind)
 	assert_d_eq(mallctlbymib(mib, miblen, (void *)&ret, &z, NULL, 0),
 	    0, "Unexpected mallctlbymib([\"%s\", %zu], ...) failure", cmd, ind);
 
-	return (ret);
+	return ret;
 }
 
 static size_t
-get_huge_size(size_t ind)
-{
-
-	return (get_size_impl("arenas.hchunk.0.size", ind));
+get_large_size(size_t ind) {
+	return get_size_impl("arenas.lextent.0.size", ind);
 }
 
-TEST_BEGIN(test_grow_and_shrink)
-{
+TEST_BEGIN(test_grow_and_shrink) {
 	void *p, *q;
 	size_t tsz;
-#define	NCYCLES 3
+#define NCYCLES 3
 	unsigned i, j;
-#define	NSZS 2500
+#define NSZS 1024
 	size_t szs[NSZS];
-#define	MAXSZ ZU(12 * 1024 * 1024)
+#define MAXSZ ZU(12 * 1024 * 1024)
 
 	p = mallocx(1, 0);
 	assert_ptr_not_null(p, "Unexpected mallocx() error");
@@ -92,8 +85,7 @@ TEST_BEGIN(test_grow_and_shrink)
 TEST_END
 
 static bool
-validate_fill(const void *p, uint8_t c, size_t offset, size_t len)
-{
+validate_fill(const void *p, uint8_t c, size_t offset, size_t len) {
 	bool ret = false;
 	const uint8_t *buf = (const uint8_t *)p;
 	size_t i;
@@ -108,16 +100,15 @@ validate_fill(const void *p, uint8_t c, size_t offset, size_t len)
 		}
 	}
 
-	return (ret);
+	return ret;
 }
 
-TEST_BEGIN(test_zero)
-{
+TEST_BEGIN(test_zero) {
 	void *p, *q;
 	size_t psz, qsz, i, j;
 	size_t start_sizes[] = {1, 3*1024, 63*1024, 4095*1024};
-#define	FILL_BYTE 0xaaU
-#define	RANGE 2048
+#define FILL_BYTE 0xaaU
+#define RANGE 2048
 
 	for (i = 0; i < sizeof(start_sizes)/sizeof(size_t); i++) {
 		size_t start_size = start_sizes[i];
@@ -156,11 +147,10 @@ TEST_BEGIN(test_zero)
 }
 TEST_END
 
-TEST_BEGIN(test_align)
-{
+TEST_BEGIN(test_align) {
 	void *p, *q;
 	size_t align;
-#define	MAX_ALIGN (ZU(1) << 25)
+#define MAX_ALIGN (ZU(1) << 25)
 
 	align = ZU(1);
 	p = mallocx(1, MALLOCX_ALIGN(align));
@@ -181,13 +171,12 @@ TEST_BEGIN(test_align)
 }
 TEST_END
 
-TEST_BEGIN(test_lg_align_and_zero)
-{
+TEST_BEGIN(test_lg_align_and_zero) {
 	void *p, *q;
 	unsigned lg_align;
 	size_t sz;
-#define	MAX_LG_ALIGN 25
-#define	MAX_VALIDATE (ZU(1) << 22)
+#define MAX_LG_ALIGN 25
+#define MAX_VALIDATE (ZU(1) << 22)
 
 	lg_align = 0;
 	p = mallocx(1, MALLOCX_LG_ALIGN(lg_align)|MALLOCX_ZERO);
@@ -219,18 +208,17 @@ TEST_BEGIN(test_lg_align_and_zero)
 }
 TEST_END
 
-TEST_BEGIN(test_overflow)
-{
-	size_t hugemax;
+TEST_BEGIN(test_overflow) {
+	size_t largemax;
 	void *p;
 
-	hugemax = get_huge_size(get_nhuge()-1);
+	largemax = get_large_size(get_nlarge()-1);
 
 	p = mallocx(1, 0);
 	assert_ptr_not_null(p, "Unexpected mallocx() failure");
 
-	assert_ptr_null(rallocx(p, hugemax+1, 0),
-	    "Expected OOM for rallocx(p, size=%#zx, 0)", hugemax+1);
+	assert_ptr_null(rallocx(p, largemax+1, 0),
+	    "Expected OOM for rallocx(p, size=%#zx, 0)", largemax+1);
 
 	assert_ptr_null(rallocx(p, ZU(PTRDIFF_MAX)+1, 0),
 	    "Expected OOM for rallocx(p, size=%#zx, 0)", ZU(PTRDIFF_MAX)+1);
@@ -247,13 +235,11 @@ TEST_BEGIN(test_overflow)
 TEST_END
 
 int
-main(void)
-{
-
-	return (test(
+main(void) {
+	return test(
 	    test_grow_and_shrink,
 	    test_zero,
 	    test_align,
 	    test_lg_align_and_zero,
-	    test_overflow));
+	    test_overflow);
 }
diff --git a/test/integration/sdallocx.c b/test/integration/sdallocx.c
index f92e058..e7ea1d8 100644
--- a/test/integration/sdallocx.c
+++ b/test/integration/sdallocx.c
@@ -1,23 +1,22 @@
 #include "test/jemalloc_test.h"
 
-#define	MAXALIGN (((size_t)1) << 22)
-#define	NITER 3
+#define MAXALIGN (((size_t)1) << 22)
+#define NITER 3
 
-TEST_BEGIN(test_basic)
-{
+TEST_BEGIN(test_basic) {
 	void *ptr = mallocx(64, 0);
 	sdallocx(ptr, 64, 0);
 }
 TEST_END
 
-TEST_BEGIN(test_alignment_and_size)
-{
+TEST_BEGIN(test_alignment_and_size) {
 	size_t nsz, sz, alignment, total;
 	unsigned i;
 	void *ps[NITER];
 
-	for (i = 0; i < NITER; i++)
+	for (i = 0; i < NITER; i++) {
 		ps[i] = NULL;
+	}
 
 	for (alignment = 8;
 	    alignment <= MAXALIGN;
@@ -32,8 +31,9 @@ TEST_BEGIN(test_alignment_and_size)
 				ps[i] = mallocx(sz, MALLOCX_ALIGN(alignment) |
 				    MALLOCX_ZERO);
 				total += nsz;
-				if (total >= (MAXALIGN << 1))
+				if (total >= (MAXALIGN << 1)) {
 					break;
+				}
 			}
 			for (i = 0; i < NITER; i++) {
 				if (ps[i] != NULL) {
@@ -48,10 +48,8 @@ TEST_BEGIN(test_alignment_and_size)
 TEST_END
 
 int
-main(void)
-{
-
-	return (test(
+main(void) {
+	return test(
 	    test_basic,
-	    test_alignment_and_size));
+	    test_alignment_and_size);
 }
diff --git a/test/integration/thread_arena.c b/test/integration/thread_arena.c
index 7a35a63..1e5ec05 100644
--- a/test/integration/thread_arena.c
+++ b/test/integration/thread_arena.c
@@ -1,10 +1,9 @@
 #include "test/jemalloc_test.h"
 
-#define	NTHREADS 10
+#define NTHREADS 10
 
 void *
-thd_start(void *arg)
-{
+thd_start(void *arg) {
 	unsigned main_arena_ind = *(unsigned *)arg;
 	void *p;
 	unsigned arena_ind;
@@ -35,14 +34,19 @@ thd_start(void *arg)
 	assert_u_eq(arena_ind, main_arena_ind,
 	    "Arena index should be same as for main thread");
 
-	return (NULL);
+	return NULL;
 }
 
-TEST_BEGIN(test_thread_arena)
-{
+static void
+mallctl_failure(int err) {
+	char buf[BUFERROR_BUF];
+
+	buferror(err, buf, sizeof(buf));
+	test_fail("Error in mallctl(): %s", buf);
+}
+
+TEST_BEGIN(test_thread_arena) {
 	void *p;
-	unsigned arena_ind;
-	size_t size;
 	int err;
 	thd_t thds[NTHREADS];
 	unsigned i;
@@ -50,13 +54,15 @@ TEST_BEGIN(test_thread_arena)
 	p = malloc(1);
 	assert_ptr_not_null(p, "Error in malloc()");
 
-	size = sizeof(arena_ind);
-	if ((err = mallctl("thread.arena", (void *)&arena_ind, &size, NULL,
-	    0))) {
-		char buf[BUFERROR_BUF];
+	unsigned arena_ind, old_arena_ind;
+	size_t sz = sizeof(unsigned);
+	assert_d_eq(mallctl("arenas.create", (void *)&arena_ind, &sz, NULL, 0),
+	    0, "Arena creation failure");
 
-		buferror(err, buf, sizeof(buf));
-		test_fail("Error in mallctl(): %s", buf);
+	size_t size = sizeof(arena_ind);
+	if ((err = mallctl("thread.arena", (void *)&old_arena_ind, &size,
+	    (void *)&arena_ind, sizeof(arena_ind))) != 0) {
+		mallctl_failure(err);
 	}
 
 	for (i = 0; i < NTHREADS; i++) {
@@ -69,13 +75,12 @@ TEST_BEGIN(test_thread_arena)
 		thd_join(thds[i], (void *)&join_ret);
 		assert_zd_eq(join_ret, 0, "Unexpected thread join error");
 	}
+	free(p);
 }
 TEST_END
 
 int
-main(void)
-{
-
-	return (test(
-	    test_thread_arena));
+main(void) {
+	return test(
+	    test_thread_arena);
 }
diff --git a/test/integration/thread_tcache_enabled.c b/test/integration/thread_tcache_enabled.c
index 2c2825e..0c343a6 100644
--- a/test/integration/thread_tcache_enabled.c
+++ b/test/integration/thread_tcache_enabled.c
@@ -1,30 +1,11 @@
 #include "test/jemalloc_test.h"
 
-static const bool config_tcache =
-#ifdef JEMALLOC_TCACHE
-    true
-#else
-    false
-#endif
-    ;
-
 void *
-thd_start(void *arg)
-{
-	int err;
-	size_t sz;
+thd_start(void *arg) {
 	bool e0, e1;
-
-	sz = sizeof(bool);
-	if ((err = mallctl("thread.tcache.enabled", (void *)&e0, &sz, NULL,
-	    0))) {
-		if (err == ENOENT) {
-			assert_false(config_tcache,
-			    "ENOENT should only be returned if tcache is "
-			    "disabled");
-		}
-		goto label_ENOENT;
-	}
+	size_t sz = sizeof(bool);
+	assert_d_eq(mallctl("thread.tcache.enabled", (void *)&e0, &sz, NULL,
+	    0), 0, "Unexpected mallctl failure");
 
 	if (e0) {
 		e1 = false;
@@ -78,21 +59,17 @@ thd_start(void *arg)
 	assert_false(e0, "tcache should be disabled");
 
 	free(malloc(1));
-	return (NULL);
-label_ENOENT:
+	return NULL;
 	test_skip("\"thread.tcache.enabled\" mallctl not available");
-	return (NULL);
+	return NULL;
 }
 
-TEST_BEGIN(test_main_thread)
-{
-
+TEST_BEGIN(test_main_thread) {
 	thd_start(NULL);
 }
 TEST_END
 
-TEST_BEGIN(test_subthread)
-{
+TEST_BEGIN(test_subthread) {
 	thd_t thd;
 
 	thd_create(&thd, thd_start, NULL);
@@ -101,14 +78,12 @@ TEST_BEGIN(test_subthread)
 TEST_END
 
 int
-main(void)
-{
-
+main(void) {
 	/* Run tests multiple times to check for bad interactions. */
-	return (test(
+	return test(
 	    test_main_thread,
 	    test_subthread,
 	    test_main_thread,
 	    test_subthread,
-	    test_main_thread));
+	    test_main_thread);
 }
diff --git a/test/integration/xallocx.c b/test/integration/xallocx.c
index 2517a81..cd0ca04 100644
--- a/test/integration/xallocx.c
+++ b/test/integration/xallocx.c
@@ -6,21 +6,19 @@
  * xallocx() would ordinarily be able to extend.
  */
 static unsigned
-arena_ind(void)
-{
+arena_ind(void) {
 	static unsigned ind = 0;
 
 	if (ind == 0) {
 		size_t sz = sizeof(ind);
-		assert_d_eq(mallctl("arenas.extend", (void *)&ind, &sz, NULL,
+		assert_d_eq(mallctl("arenas.create", (void *)&ind, &sz, NULL,
 		    0), 0, "Unexpected mallctl failure creating arena");
 	}
 
-	return (ind);
+	return ind;
 }
 
-TEST_BEGIN(test_same_size)
-{
+TEST_BEGIN(test_same_size) {
 	void *p;
 	size_t sz, tsz;
 
@@ -35,8 +33,7 @@ TEST_BEGIN(test_same_size)
 }
 TEST_END
 
-TEST_BEGIN(test_extra_no_move)
-{
+TEST_BEGIN(test_extra_no_move) {
 	void *p;
 	size_t sz, tsz;
 
@@ -51,8 +48,7 @@ TEST_BEGIN(test_extra_no_move)
 }
 TEST_END
 
-TEST_BEGIN(test_no_move_fail)
-{
+TEST_BEGIN(test_no_move_fail) {
 	void *p;
 	size_t sz, tsz;
 
@@ -68,8 +64,7 @@ TEST_BEGIN(test_no_move_fail)
 TEST_END
 
 static unsigned
-get_nsizes_impl(const char *cmd)
-{
+get_nsizes_impl(const char *cmd) {
 	unsigned ret;
 	size_t z;
 
@@ -77,33 +72,21 @@ get_nsizes_impl(const char *cmd)
 	assert_d_eq(mallctl(cmd, (void *)&ret, &z, NULL, 0), 0,
 	    "Unexpected mallctl(\"%s\", ...) failure", cmd);
 
-	return (ret);
+	return ret;
 }
 
 static unsigned
-get_nsmall(void)
-{
-
-	return (get_nsizes_impl("arenas.nbins"));
-}
-
-static unsigned
-get_nlarge(void)
-{
-
-	return (get_nsizes_impl("arenas.nlruns"));
+get_nsmall(void) {
+	return get_nsizes_impl("arenas.nbins");
 }
 
 static unsigned
-get_nhuge(void)
-{
-
-	return (get_nsizes_impl("arenas.nhchunks"));
+get_nlarge(void) {
+	return get_nsizes_impl("arenas.nlextents");
 }
 
 static size_t
-get_size_impl(const char *cmd, size_t ind)
-{
+get_size_impl(const char *cmd, size_t ind) {
 	size_t ret;
 	size_t z;
 	size_t mib[4];
@@ -117,38 +100,26 @@ get_size_impl(const char *cmd, size_t ind)
 	assert_d_eq(mallctlbymib(mib, miblen, (void *)&ret, &z, NULL, 0),
 	    0, "Unexpected mallctlbymib([\"%s\", %zu], ...) failure", cmd, ind);
 
-	return (ret);
+	return ret;
 }
 
 static size_t
-get_small_size(size_t ind)
-{
-
-	return (get_size_impl("arenas.bin.0.size", ind));
+get_small_size(size_t ind) {
+	return get_size_impl("arenas.bin.0.size", ind);
 }
 
 static size_t
-get_large_size(size_t ind)
-{
-
-	return (get_size_impl("arenas.lrun.0.size", ind));
+get_large_size(size_t ind) {
+	return get_size_impl("arenas.lextent.0.size", ind);
 }
 
-static size_t
-get_huge_size(size_t ind)
-{
-
-	return (get_size_impl("arenas.hchunk.0.size", ind));
-}
-
-TEST_BEGIN(test_size)
-{
-	size_t small0, hugemax;
+TEST_BEGIN(test_size) {
+	size_t small0, largemax;
 	void *p;
 
 	/* Get size classes. */
 	small0 = get_small_size(0);
-	hugemax = get_huge_size(get_nhuge()-1);
+	largemax = get_large_size(get_nlarge()-1);
 
 	p = mallocx(small0, 0);
 	assert_ptr_not_null(p, "Unexpected mallocx() error");
@@ -158,60 +129,58 @@ TEST_BEGIN(test_size)
 	    "Unexpected xallocx() behavior");
 
 	/* Test largest supported size. */
-	assert_zu_le(xallocx(p, hugemax, 0, 0), hugemax,
+	assert_zu_le(xallocx(p, largemax, 0, 0), largemax,
 	    "Unexpected xallocx() behavior");
 
 	/* Test size overflow. */
-	assert_zu_le(xallocx(p, hugemax+1, 0, 0), hugemax,
+	assert_zu_le(xallocx(p, largemax+1, 0, 0), largemax,
 	    "Unexpected xallocx() behavior");
-	assert_zu_le(xallocx(p, SIZE_T_MAX, 0, 0), hugemax,
+	assert_zu_le(xallocx(p, SIZE_T_MAX, 0, 0), largemax,
 	    "Unexpected xallocx() behavior");
 
 	dallocx(p, 0);
 }
 TEST_END
 
-TEST_BEGIN(test_size_extra_overflow)
-{
-	size_t small0, hugemax;
+TEST_BEGIN(test_size_extra_overflow) {
+	size_t small0, largemax;
 	void *p;
 
 	/* Get size classes. */
 	small0 = get_small_size(0);
-	hugemax = get_huge_size(get_nhuge()-1);
+	largemax = get_large_size(get_nlarge()-1);
 
 	p = mallocx(small0, 0);
 	assert_ptr_not_null(p, "Unexpected mallocx() error");
 
 	/* Test overflows that can be resolved by clamping extra. */
-	assert_zu_le(xallocx(p, hugemax-1, 2, 0), hugemax,
+	assert_zu_le(xallocx(p, largemax-1, 2, 0), largemax,
 	    "Unexpected xallocx() behavior");
-	assert_zu_le(xallocx(p, hugemax, 1, 0), hugemax,
+	assert_zu_le(xallocx(p, largemax, 1, 0), largemax,
 	    "Unexpected xallocx() behavior");
 
-	/* Test overflow such that hugemax-size underflows. */
-	assert_zu_le(xallocx(p, hugemax+1, 2, 0), hugemax,
+	/* Test overflow such that largemax-size underflows. */
+	assert_zu_le(xallocx(p, largemax+1, 2, 0), largemax,
 	    "Unexpected xallocx() behavior");
-	assert_zu_le(xallocx(p, hugemax+2, 3, 0), hugemax,
+	assert_zu_le(xallocx(p, largemax+2, 3, 0), largemax,
 	    "Unexpected xallocx() behavior");
-	assert_zu_le(xallocx(p, SIZE_T_MAX-2, 2, 0), hugemax,
+	assert_zu_le(xallocx(p, SIZE_T_MAX-2, 2, 0), largemax,
 	    "Unexpected xallocx() behavior");
-	assert_zu_le(xallocx(p, SIZE_T_MAX-1, 1, 0), hugemax,
+	assert_zu_le(xallocx(p, SIZE_T_MAX-1, 1, 0), largemax,
 	    "Unexpected xallocx() behavior");
 
 	dallocx(p, 0);
 }
 TEST_END
 
-TEST_BEGIN(test_extra_small)
-{
-	size_t small0, small1, hugemax;
+TEST_BEGIN(test_extra_small) {
+	size_t small0, small1, largemax;
 	void *p;
 
 	/* Get size classes. */
 	small0 = get_small_size(0);
 	small1 = get_small_size(1);
-	hugemax = get_huge_size(get_nhuge()-1);
+	largemax = get_large_size(get_nlarge()-1);
 
 	p = mallocx(small0, 0);
 	assert_ptr_not_null(p, "Unexpected mallocx() error");
@@ -226,7 +195,7 @@ TEST_BEGIN(test_extra_small)
 	    "Unexpected xallocx() behavior");
 
 	/* Test size+extra overflow. */
-	assert_zu_eq(xallocx(p, small0, hugemax - small0 + 1, 0), small0,
+	assert_zu_eq(xallocx(p, small0, largemax - small0 + 1, 0), small0,
 	    "Unexpected xallocx() behavior");
 	assert_zu_eq(xallocx(p, small0, SIZE_T_MAX - small0, 0), small0,
 	    "Unexpected xallocx() behavior");
@@ -235,133 +204,69 @@ TEST_BEGIN(test_extra_small)
 }
 TEST_END
 
-TEST_BEGIN(test_extra_large)
-{
+TEST_BEGIN(test_extra_large) {
 	int flags = MALLOCX_ARENA(arena_ind());
-	size_t smallmax, large0, large1, large2, huge0, hugemax;
+	size_t smallmax, large1, large2, large3, largemax;
 	void *p;
 
 	/* Get size classes. */
 	smallmax = get_small_size(get_nsmall()-1);
-	large0 = get_large_size(0);
 	large1 = get_large_size(1);
 	large2 = get_large_size(2);
-	huge0 = get_huge_size(0);
-	hugemax = get_huge_size(get_nhuge()-1);
-
-	p = mallocx(large2, flags);
-	assert_ptr_not_null(p, "Unexpected mallocx() error");
-
-	assert_zu_eq(xallocx(p, large2, 0, flags), large2,
-	    "Unexpected xallocx() behavior");
-	/* Test size decrease with zero extra. */
-	assert_zu_eq(xallocx(p, large0, 0, flags), large0,
-	    "Unexpected xallocx() behavior");
-	assert_zu_eq(xallocx(p, smallmax, 0, flags), large0,
-	    "Unexpected xallocx() behavior");
-
-	assert_zu_eq(xallocx(p, large2, 0, flags), large2,
-	    "Unexpected xallocx() behavior");
-	/* Test size decrease with non-zero extra. */
-	assert_zu_eq(xallocx(p, large0, large2 - large0, flags), large2,
-	    "Unexpected xallocx() behavior");
-	assert_zu_eq(xallocx(p, large1, large2 - large1, flags), large2,
-	    "Unexpected xallocx() behavior");
-	assert_zu_eq(xallocx(p, large0, large1 - large0, flags), large1,
-	    "Unexpected xallocx() behavior");
-	assert_zu_eq(xallocx(p, smallmax, large0 - smallmax, flags), large0,
-	    "Unexpected xallocx() behavior");
-
-	assert_zu_eq(xallocx(p, large0, 0, flags), large0,
-	    "Unexpected xallocx() behavior");
-	/* Test size increase with zero extra. */
-	assert_zu_eq(xallocx(p, large2, 0, flags), large2,
-	    "Unexpected xallocx() behavior");
-	assert_zu_eq(xallocx(p, huge0, 0, flags), large2,
-	    "Unexpected xallocx() behavior");
-
-	assert_zu_eq(xallocx(p, large0, 0, flags), large0,
-	    "Unexpected xallocx() behavior");
-	/* Test size increase with non-zero extra. */
-	assert_zu_lt(xallocx(p, large0, huge0 - large0, flags), huge0,
-	    "Unexpected xallocx() behavior");
-
-	assert_zu_eq(xallocx(p, large0, 0, flags), large0,
-	    "Unexpected xallocx() behavior");
-	/* Test size increase with non-zero extra. */
-	assert_zu_eq(xallocx(p, large0, large2 - large0, flags), large2,
-	    "Unexpected xallocx() behavior");
-
-	assert_zu_eq(xallocx(p, large2, 0, flags), large2,
-	    "Unexpected xallocx() behavior");
-	/* Test size+extra overflow. */
-	assert_zu_lt(xallocx(p, large2, hugemax - large2 + 1, flags), huge0,
-	    "Unexpected xallocx() behavior");
-
-	dallocx(p, flags);
-}
-TEST_END
-
-TEST_BEGIN(test_extra_huge)
-{
-	int flags = MALLOCX_ARENA(arena_ind());
-	size_t largemax, huge1, huge2, huge3, hugemax;
-	void *p;
-
-	/* Get size classes. */
+	large3 = get_large_size(3);
 	largemax = get_large_size(get_nlarge()-1);
-	huge1 = get_huge_size(1);
-	huge2 = get_huge_size(2);
-	huge3 = get_huge_size(3);
-	hugemax = get_huge_size(get_nhuge()-1);
 
-	p = mallocx(huge3, flags);
+	p = mallocx(large3, flags);
 	assert_ptr_not_null(p, "Unexpected mallocx() error");
 
-	assert_zu_eq(xallocx(p, huge3, 0, flags), huge3,
+	assert_zu_eq(xallocx(p, large3, 0, flags), large3,
 	    "Unexpected xallocx() behavior");
 	/* Test size decrease with zero extra. */
-	assert_zu_ge(xallocx(p, huge1, 0, flags), huge1,
+	assert_zu_ge(xallocx(p, large1, 0, flags), large1,
 	    "Unexpected xallocx() behavior");
-	assert_zu_ge(xallocx(p, largemax, 0, flags), huge1,
+	assert_zu_ge(xallocx(p, smallmax, 0, flags), large1,
 	    "Unexpected xallocx() behavior");
 
-	assert_zu_eq(xallocx(p, huge3, 0, flags), huge3,
-	    "Unexpected xallocx() behavior");
+	if (xallocx(p, large3, 0, flags) != large3) {
+		p = rallocx(p, large3, flags);
+		assert_ptr_not_null(p, "Unexpected rallocx() failure");
+	}
 	/* Test size decrease with non-zero extra. */
-	assert_zu_eq(xallocx(p, huge1, huge3 - huge1, flags), huge3,
+	assert_zu_eq(xallocx(p, large1, large3 - large1, flags), large3,
 	    "Unexpected xallocx() behavior");
-	assert_zu_eq(xallocx(p, huge2, huge3 - huge2, flags), huge3,
+	assert_zu_eq(xallocx(p, large2, large3 - large2, flags), large3,
 	    "Unexpected xallocx() behavior");
-	assert_zu_eq(xallocx(p, huge1, huge2 - huge1, flags), huge2,
+	assert_zu_ge(xallocx(p, large1, large2 - large1, flags), large2,
 	    "Unexpected xallocx() behavior");
-	assert_zu_ge(xallocx(p, largemax, huge1 - largemax, flags), huge1,
+	assert_zu_ge(xallocx(p, smallmax, large1 - smallmax, flags), large1,
 	    "Unexpected xallocx() behavior");
 
-	assert_zu_ge(xallocx(p, huge1, 0, flags), huge1,
+	assert_zu_ge(xallocx(p, large1, 0, flags), large1,
 	    "Unexpected xallocx() behavior");
 	/* Test size increase with zero extra. */
-	assert_zu_le(xallocx(p, huge3, 0, flags), huge3,
+	assert_zu_le(xallocx(p, large3, 0, flags), large3,
 	    "Unexpected xallocx() behavior");
-	assert_zu_le(xallocx(p, hugemax+1, 0, flags), huge3,
+	assert_zu_le(xallocx(p, largemax+1, 0, flags), large3,
 	    "Unexpected xallocx() behavior");
 
-	assert_zu_ge(xallocx(p, huge1, 0, flags), huge1,
+	assert_zu_ge(xallocx(p, large1, 0, flags), large1,
 	    "Unexpected xallocx() behavior");
 	/* Test size increase with non-zero extra. */
-	assert_zu_le(xallocx(p, huge1, SIZE_T_MAX - huge1, flags), hugemax,
+	assert_zu_le(xallocx(p, large1, SIZE_T_MAX - large1, flags), largemax,
 	    "Unexpected xallocx() behavior");
 
-	assert_zu_ge(xallocx(p, huge1, 0, flags), huge1,
+	assert_zu_ge(xallocx(p, large1, 0, flags), large1,
 	    "Unexpected xallocx() behavior");
 	/* Test size increase with non-zero extra. */
-	assert_zu_le(xallocx(p, huge1, huge3 - huge1, flags), huge3,
+	assert_zu_le(xallocx(p, large1, large3 - large1, flags), large3,
 	    "Unexpected xallocx() behavior");
 
-	assert_zu_eq(xallocx(p, huge3, 0, flags), huge3,
-	    "Unexpected xallocx() behavior");
+	if (xallocx(p, large3, 0, flags) != large3) {
+		p = rallocx(p, large3, flags);
+		assert_ptr_not_null(p, "Unexpected rallocx() failure");
+	}
 	/* Test size+extra overflow. */
-	assert_zu_le(xallocx(p, huge3, hugemax - huge3 + 1, flags), hugemax,
+	assert_zu_le(xallocx(p, large3, largemax - large3 + 1, flags), largemax,
 	    "Unexpected xallocx() behavior");
 
 	dallocx(p, flags);
@@ -369,8 +274,7 @@ TEST_BEGIN(test_extra_huge)
 TEST_END
 
 static void
-print_filled_extents(const void *p, uint8_t c, size_t len)
-{
+print_filled_extents(const void *p, uint8_t c, size_t len) {
 	const uint8_t *pc = (const uint8_t *)p;
 	size_t i, range0;
 	uint8_t c0;
@@ -389,30 +293,30 @@ print_filled_extents(const void *p, uint8_t c, size_t len)
 }
 
 static bool
-validate_fill(const void *p, uint8_t c, size_t offset, size_t len)
-{
+validate_fill(const void *p, uint8_t c, size_t offset, size_t len) {
 	const uint8_t *pc = (const uint8_t *)p;
 	bool err;
 	size_t i;
 
 	for (i = offset, err = false; i < offset+len; i++) {
-		if (pc[i] != c)
+		if (pc[i] != c) {
 			err = true;
+		}
 	}
 
-	if (err)
+	if (err) {
 		print_filled_extents(p, c, offset + len);
+	}
 
-	return (err);
+	return err;
 }
 
 static void
-test_zero(size_t szmin, size_t szmax)
-{
+test_zero(size_t szmin, size_t szmax) {
 	int flags = MALLOCX_ARENA(arena_ind()) | MALLOCX_ZERO;
 	size_t sz, nsz;
 	void *p;
-#define	FILL_BYTE 0x7aU
+#define FILL_BYTE 0x7aU
 
 	sz = szmax;
 	p = mallocx(sz, flags);
@@ -430,15 +334,19 @@ test_zero(size_t szmin, size_t szmax)
 
 	/* Shrink in place so that we can expect growing in place to succeed. */
 	sz = szmin;
-	assert_zu_eq(xallocx(p, sz, 0, flags), sz,
-	    "Unexpected xallocx() error");
+	if (xallocx(p, sz, 0, flags) != sz) {
+		p = rallocx(p, sz, flags);
+		assert_ptr_not_null(p, "Unexpected rallocx() failure");
+	}
 	assert_false(validate_fill(p, FILL_BYTE, 0, sz),
 	    "Memory not filled: sz=%zu", sz);
 
 	for (sz = szmin; sz < szmax; sz = nsz) {
 		nsz = nallocx(sz+1, flags);
-		assert_zu_eq(xallocx(p, sz+1, 0, flags), nsz,
-		    "Unexpected xallocx() failure");
+		if (xallocx(p, sz+1, 0, flags) != nsz) {
+			p = rallocx(p, sz+1, flags);
+			assert_ptr_not_null(p, "Unexpected rallocx() failure");
+		}
 		assert_false(validate_fill(p, FILL_BYTE, 0, sz),
 		    "Memory not filled: sz=%zu", sz);
 		assert_false(validate_fill(p, 0x00, sz, nsz-sz),
@@ -451,35 +359,20 @@ test_zero(size_t szmin, size_t szmax)
 	dallocx(p, flags);
 }
 
-TEST_BEGIN(test_zero_large)
-{
-	size_t large0, largemax;
+TEST_BEGIN(test_zero_large) {
+	size_t large0, large1;
 
 	/* Get size classes. */
 	large0 = get_large_size(0);
-	largemax = get_large_size(get_nlarge()-1);
-
-	test_zero(large0, largemax);
-}
-TEST_END
-
-TEST_BEGIN(test_zero_huge)
-{
-	size_t huge0, huge1;
-
-	/* Get size classes. */
-	huge0 = get_huge_size(0);
-	huge1 = get_huge_size(1);
+	large1 = get_large_size(1);
 
-	test_zero(huge1, huge0 * 2);
+	test_zero(large1, large0 * 2);
 }
 TEST_END
 
 int
-main(void)
-{
-
-	return (test(
+main(void) {
+	return test(
 	    test_same_size,
 	    test_extra_no_move,
 	    test_no_move_fail,
@@ -487,7 +380,5 @@ main(void)
 	    test_size_extra_overflow,
 	    test_extra_small,
 	    test_extra_large,
-	    test_extra_huge,
-	    test_zero_large,
-	    test_zero_huge));
+	    test_zero_large);
 }