#include "test/jemalloc_test.h"
#include "jemalloc/internal/prof_stats.h"

typedef struct {
	char  *buf;
	size_t len;
	size_t capacity;
} stats_buf_t;

static void
stats_buf_init(stats_buf_t *sbuf) {
	/* 1MB is enough for the small number of arenas used by these tests. */
	sbuf->capacity = 1 << 20;
	sbuf->buf = mallocx(sbuf->capacity, MALLOCX_TCACHE_NONE);
	assert_ptr_not_null(sbuf->buf, "Failed to allocate stats buffer");
	sbuf->len = 0;
	sbuf->buf[0] = '\0';
}

static void
stats_buf_fini(stats_buf_t *sbuf) {
	dallocx(sbuf->buf, MALLOCX_TCACHE_NONE);
}

static void
stats_buf_write_cb(void *opaque, const char *str) {
	stats_buf_t *sbuf = (stats_buf_t *)opaque;
	size_t       slen = strlen(str);

	if (sbuf->len + slen + 1 > sbuf->capacity) {
		return;
	}
	memcpy(&sbuf->buf[sbuf->len], str, slen + 1);
	sbuf->len += slen;
}

static const char  *global_mutex_names[] = {"background_thread",
     "max_per_bg_thd", "ctl", "prof", "prof_thds_data", "prof_dump",
     "prof_recent_alloc", "prof_recent_dump", "prof_stats"};
static const size_t num_global_mutexes = sizeof(global_mutex_names)
    / sizeof(global_mutex_names[0]);

static const char  *arena_mutex_names[] = {"large", "extent_avail",
     "extents_dirty", "extents_muzzy", "extents_retained", "extents_pinned",
     "decay_dirty", "decay_muzzy", "base", "tcache_list", "hpa_shard",
     "hpa_shard_grow", "hpa_sec", "pac_sec"};
static const size_t num_arena_mutexes = sizeof(arena_mutex_names)
    / sizeof(arena_mutex_names[0]);

typedef struct {
	const char *begin;
	const char *end;
} json_fragment_t;

static const char *
json_skip_ws(const char *cur, const char *end) {
	while (cur < end
	    && (*cur == ' ' || *cur == '\t' || *cur == '\n' || *cur == '\r')) {
		cur++;
	}
	return cur;
}

static const char *
json_string_end(const char *begin, const char *end) {
	if (begin >= end || *begin != '"') {
		return NULL;
	}
	for (const char *cur = begin + 1; cur < end; cur++) {
		if (*cur == '\\') {
			cur++;
			if (cur >= end) {
				return NULL;
			}
		} else if (*cur == '"') {
			return cur + 1;
		}
	}
	return NULL;
}

static const char *
json_value_end(const char *begin, const char *end) {
	begin = json_skip_ws(begin, end);
	if (begin >= end) {
		return NULL;
	}
	if (*begin == '"') {
		return json_string_end(begin, end);
	}
	if (*begin != '{' && *begin != '[') {
		const char *cur = begin;
		while (cur < end && *cur != ',' && *cur != '}' && *cur != ']') {
			cur++;
		}
		while (cur > begin
		    && (cur[-1] == ' ' || cur[-1] == '\t' || cur[-1] == '\n'
		        || cur[-1] == '\r')) {
			cur--;
		}
		return cur;
	}

	char opening = *begin;
	char closing = opening == '{' ? '}' : ']';
	unsigned depth = 0;
	for (const char *cur = begin; cur < end; cur++) {
		if (*cur == '"') {
			cur = json_string_end(cur, end);
			if (cur == NULL) {
				return NULL;
			}
			cur--;
			continue;
		}
		if (*cur == opening) {
			depth++;
		} else if (*cur == closing && --depth == 0) {
			return cur + 1;
		}
	}
	return NULL;
}

static bool
json_fragment_init(const char *begin, const char *end, json_fragment_t *out) {
	begin = json_skip_ws(begin, end);
	const char *value_end = json_value_end(begin, end);
	if (value_end == NULL) {
		return true;
	}
	out->begin = begin;
	out->end = value_end;
	return false;
}

static bool
json_object_member(json_fragment_t object, const char *key,
    json_fragment_t *value) {
	if (object.begin >= object.end || *object.begin != '{') {
		return true;
	}
	const char *cur = object.begin + 1;
	while (true) {
		cur = json_skip_ws(cur, object.end);
		if (cur >= object.end || *cur == '}') {
			return true;
		}
		const char *key_end = json_string_end(cur, object.end);
		if (key_end == NULL) {
			return true;
		}
		size_t key_len = (size_t)(key_end - cur - 2);
		bool matches = strlen(key) == key_len
		    && strncmp(cur + 1, key, key_len) == 0;
		cur = json_skip_ws(key_end, object.end);
		if (cur >= object.end || *cur++ != ':') {
			return true;
		}
		cur = json_skip_ws(cur, object.end);
		const char *value_end = json_value_end(cur, object.end);
		if (value_end == NULL) {
			return true;
		}
		if (matches) {
			value->begin = cur;
			value->end = value_end;
			return false;
		}
		cur = json_skip_ws(value_end, object.end);
		if (cur < object.end && *cur == ',') {
			cur++;
		} else if (cur >= object.end || *cur != '}') {
			return true;
		}
	}
}

static size_t
json_object_size(json_fragment_t object) {
	if (object.begin >= object.end || *object.begin != '{') {
		return SIZE_T_MAX;
	}
	size_t count = 0;
	const char *cur = object.begin + 1;
	while (true) {
		cur = json_skip_ws(cur, object.end);
		if (cur < object.end && *cur == '}') {
			return count;
		}
		const char *key_end = json_string_end(cur, object.end);
		if (key_end == NULL) {
			return SIZE_T_MAX;
		}
		cur = json_skip_ws(key_end, object.end);
		if (cur >= object.end || *cur++ != ':') {
			return SIZE_T_MAX;
		}
		cur = json_skip_ws(cur, object.end);
		cur = json_value_end(cur, object.end);
		if (cur == NULL) {
			return SIZE_T_MAX;
		}
		count++;
		cur = json_skip_ws(cur, object.end);
		if (cur < object.end && *cur == ',') {
			cur++;
		} else if (cur >= object.end || *cur != '}') {
			return SIZE_T_MAX;
		}
	}
}

static bool
json_array_element(json_fragment_t array, size_t ind, json_fragment_t *value) {
	if (array.begin >= array.end || *array.begin != '[') {
		return true;
	}
	size_t current = 0;
	const char *cur = array.begin + 1;
	while (true) {
		cur = json_skip_ws(cur, array.end);
		if (cur >= array.end || *cur == ']') {
			return true;
		}
		const char *value_end = json_value_end(cur, array.end);
		if (value_end == NULL) {
			return true;
		}
		if (current++ == ind) {
			value->begin = cur;
			value->end = value_end;
			return false;
		}
		cur = json_skip_ws(value_end, array.end);
		if (cur < array.end && *cur == ',') {
			cur++;
		} else if (cur >= array.end || *cur != ']') {
			return true;
		}
	}
}

static size_t
json_array_size(json_fragment_t array) {
	if (array.begin >= array.end || *array.begin != '[') {
		return SIZE_T_MAX;
	}
	size_t count = 0;
	const char *cur = array.begin + 1;
	while (true) {
		cur = json_skip_ws(cur, array.end);
		if (cur < array.end && *cur == ']') {
			return count;
		}
		cur = json_value_end(cur, array.end);
		if (cur == NULL) {
			return SIZE_T_MAX;
		}
		count++;
		cur = json_skip_ws(cur, array.end);
		if (cur < array.end && *cur == ',') {
			cur++;
		} else if (cur >= array.end || *cur != ']') {
			return SIZE_T_MAX;
		}
	}
}

static bool
json_fragment_uint64(json_fragment_t value, uint64_t *result) {
	char *end;
	errno = 0;
	uint64_t parsed = strtoull(value.begin, &end, 10);
	if (errno != 0 || end != value.end) {
		return true;
	}
	*result = parsed;
	return false;
}

static bool
json_fragment_int64(json_fragment_t value, int64_t *result) {
	char *end;
	errno = 0;
	int64_t parsed = strtoll(value.begin, &end, 10);
	if (errno != 0 || end != value.end) {
		return true;
	}
	*result = parsed;
	return false;
}

static bool
json_fragment_string_eq(json_fragment_t value, const char *expected) {
	if (value.end - value.begin < 2 || *value.begin != '"'
	    || value.end[-1] != '"') {
		return false;
	}
	size_t len = (size_t)(value.end - value.begin - 2);
	return strlen(expected) == len
	    && strncmp(value.begin + 1, expected, len) == 0;
}

static void
expect_json_object_has_keys(json_fragment_t object, const char *const *keys,
    size_t nkeys, const char *name) {
	for (size_t i = 0; i < nkeys; i++) {
		json_fragment_t ignored;
		expect_false(json_object_member(object, keys[i], &ignored),
		    "%s is missing key %s", name, keys[i]);
	}
}

static void
expect_json_object_keys(json_fragment_t object, const char *const *keys,
    size_t nkeys, const char *name) {
	expect_zu_eq(json_object_size(object), nkeys,
	    "%s has an unexpected number of keys", name);
	expect_json_object_has_keys(object, keys, nkeys, name);
}

typedef enum {
	ctl_field_size,
	ctl_field_uint64,
	ctl_field_uint32,
	ctl_field_unsigned,
	ctl_field_ssize,
	ctl_field_string,
} ctl_field_type_t;

typedef struct {
	const char       *json_key;
	const char       *ctl_suffix;
	ctl_field_type_t  type;
} ctl_field_t;

static void
expect_json_ctl_fields(json_fragment_t object, const char *ctl_prefix,
    const ctl_field_t *fields, size_t nfields) {
	for (size_t i = 0; i < nfields; i++) {
		const ctl_field_t *field = &fields[i];
		json_fragment_t value;
		bool missing = json_object_member(object, field->json_key, &value);
		expect_false(missing, "JSON is missing %s", field->json_key);
		if (missing) {
			continue;
		}

		char ctl_name[256];
		size_t written = malloc_snprintf(ctl_name, sizeof(ctl_name),
		    "%s.%s", ctl_prefix, field->ctl_suffix);
		expect_zu_lt(written, sizeof(ctl_name), "mallctl name is too long");

		size_t sz;
		uint64_t json_u64 = 0;
		int64_t json_i64 = 0;
		switch (field->type) {
		case ctl_field_size: {
			size_t expected;
			sz = sizeof(expected);
			expect_d_eq(mallctl(ctl_name, &expected, &sz, NULL, 0), 0,
			    "mallctl failed for %s", ctl_name);
			expect_false(json_fragment_uint64(value, &json_u64),
			    "JSON value for %s is not unsigned", field->json_key);
			expect_zu_eq((size_t)json_u64, expected,
			    "JSON value does not match %s", ctl_name);
			break;
		}
		case ctl_field_uint64: {
			uint64_t expected;
			sz = sizeof(expected);
			expect_d_eq(mallctl(ctl_name, &expected, &sz, NULL, 0), 0,
			    "mallctl failed for %s", ctl_name);
			expect_false(json_fragment_uint64(value, &json_u64),
			    "JSON value for %s is not unsigned", field->json_key);
			expect_u64_eq(json_u64, expected,
			    "JSON value does not match %s", ctl_name);
			break;
		}
		case ctl_field_uint32: {
			uint32_t expected;
			sz = sizeof(expected);
			expect_d_eq(mallctl(ctl_name, &expected, &sz, NULL, 0), 0,
			    "mallctl failed for %s", ctl_name);
			expect_false(json_fragment_uint64(value, &json_u64),
			    "JSON value for %s is not unsigned", field->json_key);
			expect_u32_eq((uint32_t)json_u64, expected,
			    "JSON value does not match %s", ctl_name);
			break;
		}
		case ctl_field_unsigned: {
			unsigned expected;
			sz = sizeof(expected);
			expect_d_eq(mallctl(ctl_name, &expected, &sz, NULL, 0), 0,
			    "mallctl failed for %s", ctl_name);
			expect_false(json_fragment_uint64(value, &json_u64),
			    "JSON value for %s is not unsigned", field->json_key);
			expect_u_eq((unsigned)json_u64, expected,
			    "JSON value does not match %s", ctl_name);
			break;
		}
		case ctl_field_ssize: {
			ssize_t expected;
			sz = sizeof(expected);
			expect_d_eq(mallctl(ctl_name, &expected, &sz, NULL, 0), 0,
			    "mallctl failed for %s", ctl_name);
			expect_false(json_fragment_int64(value, &json_i64),
			    "JSON value for %s is not signed", field->json_key);
			expect_zd_eq((ssize_t)json_i64, expected,
			    "JSON value does not match %s", ctl_name);
			break;
		}
		case ctl_field_string: {
			const char *expected;
			sz = sizeof(expected);
			expect_d_eq(mallctl(ctl_name, &expected, &sz, NULL, 0), 0,
			    "mallctl failed for %s", ctl_name);
			expect_true(json_fragment_string_eq(value, expected),
			    "JSON value does not match %s", ctl_name);
			break;
		}
		}
	}
}

#define ARRAY_COUNT(array) (sizeof(array) / sizeof((array)[0]))

static void
expect_json_uint_eq(json_fragment_t object, const char *key,
    uint64_t expected, const char *name) {
	json_fragment_t value;
	bool missing = json_object_member(object, key, &value);
	expect_false(missing, "%s is missing %s", name, key);
	if (missing) {
		return;
	}
	uint64_t actual = 0;
	expect_false(json_fragment_uint64(value, &actual),
	    "%s.%s is not an unsigned integer", name, key);
	expect_u64_eq(actual, expected, "%s.%s has an unexpected value", name,
	    key);
}

static void
expect_json_string_eq(json_fragment_t object, const char *key,
    const char *expected, const char *name) {
	json_fragment_t value;
	bool missing = json_object_member(object, key, &value);
	expect_false(missing, "%s is missing %s", name, key);
	if (missing) {
		return;
	}
	expect_true(json_fragment_string_eq(value, expected),
	    "%s.%s has an unexpected value", name, key);
}

static uint64_t
expected_rate(uint64_t value, uint64_t uptime_ns) {
	const uint64_t billion = 1000000000;
	if (uptime_ns == 0 || value == 0) {
		return 0;
	}
	return uptime_ns < billion ? value : value / (uptime_ns / billion);
}

static void
expected_utilization(size_t curregs, size_t availregs, char result[6]) {
	if (availregs == 0) {
		malloc_snprintf(result, 6, "1");
		return;
	}
	assert_zu_le(curregs, availregs, "Cached bin stats should be consistent");
	unsigned n = (unsigned)(((uint64_t)curregs * 1000) / availregs);
	if (n < 10) {
		malloc_snprintf(result, 6, "0.00%u", n);
	} else if (n < 100) {
		malloc_snprintf(result, 6, "0.0%u", n);
	} else if (n < 1000) {
		malloc_snprintf(result, 6, "0.%u", n);
	} else {
		malloc_snprintf(result, 6, "1");
	}
}

static size_t
read_size_ctl(const char *name) {
	size_t value;
	size_t sz = sizeof(value);
	assert_d_eq(mallctl(name, &value, &sz, NULL, 0), 0,
	    "mallctl failed for %s", name);
	return value;
}

static uint64_t
read_uint64_ctl(const char *name) {
	uint64_t value;
	size_t sz = sizeof(value);
	assert_d_eq(mallctl(name, &value, &sz, NULL, 0), 0,
	    "mallctl failed for %s", name);
	return value;
}

static uint32_t
read_uint32_ctl(const char *name) {
	uint32_t value;
	size_t sz = sizeof(value);
	assert_d_eq(mallctl(name, &value, &sz, NULL, 0), 0,
	    "mallctl failed for %s", name);
	return value;
}

static size_t
read_size_field(const char *prefix, const char *suffix) {
	char name[192];
	malloc_snprintf(name, sizeof(name), "%s.%s", prefix, suffix);
	return read_size_ctl(name);
}

static uint64_t
read_uint64_field(const char *prefix, const char *suffix) {
	char name[192];
	malloc_snprintf(name, sizeof(name), "%s.%s", prefix, suffix);
	return read_uint64_ctl(name);
}

static uint32_t
read_uint32_field(const char *prefix, const char *suffix) {
	char name[192];
	malloc_snprintf(name, sizeof(name), "%s.%s", prefix, suffix);
	return read_uint32_ctl(name);
}

static bool
stats_json_print_opts(stats_buf_t *sbuf, const char *opts,
    json_fragment_t *jemalloc) {
	stats_buf_init(sbuf);
	malloc_stats_print(stats_buf_write_cb, sbuf, opts);

	json_fragment_t root;
	if (json_fragment_init(sbuf->buf, sbuf->buf + sbuf->len, &root)
	    || json_object_member(root, "jemalloc", jemalloc)) {
		return true;
	}
	return false;
}

static bool
stats_json_print(stats_buf_t *sbuf, json_fragment_t *stats,
    json_fragment_t *merged) {
	json_fragment_t jemalloc, stats_arenas;
	if (stats_json_print_opts(sbuf, "Ja", &jemalloc)
	    || json_object_member(jemalloc, "stats", stats)
	    || json_object_member(jemalloc, "stats.arenas", &stats_arenas)
	    || json_object_member(stats_arenas, "merged", merged)) {
		return true;
	}
	return false;
}

static const ctl_field_t mutex_fields[] = {
	{"num_ops", "num_ops", ctl_field_uint64},
	{"num_wait", "num_wait", ctl_field_uint64},
	{"num_spin_acq", "num_spin_acq", ctl_field_uint64},
	{"num_owner_switch", "num_owner_switch", ctl_field_uint64},
	{"total_wait_time", "total_wait_time", ctl_field_uint64},
	{"max_wait_time", "max_wait_time", ctl_field_uint64},
	{"max_num_thds", "max_num_thds", ctl_field_uint32},
};
static const char *const mutex_keys[] = {"num_ops", "num_wait",
	"num_spin_acq", "num_owner_switch", "total_wait_time",
	"max_wait_time", "max_num_thds"};

static void
expect_mutex_object(json_fragment_t mutex, const char *ctl_prefix) {
	expect_json_object_keys(
	    mutex, mutex_keys, ARRAY_COUNT(mutex_keys), ctl_prefix);
	expect_json_ctl_fields(
	    mutex, ctl_prefix, mutex_fields, ARRAY_COUNT(mutex_fields));
}

static const ctl_field_t global_fields[] = {
	{"allocated", "allocated", ctl_field_size},
	{"active", "active", ctl_field_size},
	{"metadata", "metadata", ctl_field_size},
	{"metadata_edata", "metadata_edata", ctl_field_size},
	{"metadata_rtree", "metadata_rtree", ctl_field_size},
	{"metadata_thp", "metadata_thp", ctl_field_size},
	{"resident", "resident", ctl_field_size},
	{"mapped", "mapped", ctl_field_size},
	{"retained", "retained", ctl_field_size},
	{"pinned", "pinned", ctl_field_size},
	{"zero_reallocs", "zero_reallocs", ctl_field_size},
};

static const ctl_field_t background_thread_fields[] = {
	{"num_threads", "num_threads", ctl_field_size},
	{"num_runs", "num_runs", ctl_field_uint64},
	{"run_interval", "run_interval", ctl_field_uint64},
};

static const ctl_field_t arena_fields[] = {
	{"nthreads", "nthreads", ctl_field_unsigned},
	{"uptime_ns", "uptime", ctl_field_uint64},
	{"dss", "dss", ctl_field_string},
	{"dirty_decay_ms", "dirty_decay_ms", ctl_field_ssize},
	{"muzzy_decay_ms", "muzzy_decay_ms", ctl_field_ssize},
	{"pactive", "pactive", ctl_field_size},
	{"pdirty", "pdirty", ctl_field_size},
	{"pmuzzy", "pmuzzy", ctl_field_size},
	{"dirty_npurge", "dirty_npurge", ctl_field_uint64},
	{"dirty_nmadvise", "dirty_nmadvise", ctl_field_uint64},
	{"dirty_purged", "dirty_purged", ctl_field_uint64},
	{"muzzy_npurge", "muzzy_npurge", ctl_field_uint64},
	{"muzzy_nmadvise", "muzzy_nmadvise", ctl_field_uint64},
	{"muzzy_purged", "muzzy_purged", ctl_field_uint64},
	{"mapped", "mapped", ctl_field_size},
	{"retained", "retained", ctl_field_size},
	{"pinned", "pinned", ctl_field_size},
	{"base", "base", ctl_field_size},
	{"internal", "internal", ctl_field_size},
	{"metadata_edata", "metadata_edata", ctl_field_size},
	{"metadata_rtree", "metadata_rtree", ctl_field_size},
	{"metadata_thp", "metadata_thp", ctl_field_size},
	{"tcache_bytes", "tcache_bytes", ctl_field_size},
	{"tcache_stashed_bytes", "tcache_stashed_bytes", ctl_field_size},
	{"resident", "resident", ctl_field_size},
	{"abandoned_vm", "abandoned_vm", ctl_field_size},
	{"extent_avail", "extent_avail", ctl_field_size},
};

static const ctl_field_t arena_alloc_fields[] = {
	{"allocated", "allocated", ctl_field_size},
	{"nmalloc", "nmalloc", ctl_field_uint64},
	{"ndalloc", "ndalloc", ctl_field_uint64},
	{"nrequests", "nrequests", ctl_field_uint64},
	{"nfills", "nfills", ctl_field_uint64},
	{"nflushes", "nflushes", ctl_field_uint64},
};
static const char *const arena_alloc_keys[] = {"allocated", "nmalloc",
	"ndalloc", "nrequests", "nfills", "nflushes"};

static const ctl_field_t pac_sec_fields[] = {
	{"pac_sec_bytes", "pac_sec_bytes", ctl_field_size},
	{"pac_sec_hits", "pac_sec_hits", ctl_field_size},
	{"pac_sec_misses", "pac_sec_misses", ctl_field_size},
	{"pac_sec_dalloc_noflush", "pac_sec_dalloc_noflush", ctl_field_size},
	{"pac_sec_dalloc_flush", "pac_sec_dalloc_flush", ctl_field_size},
};

static const char *const merged_keys[] = {"nthreads", "uptime_ns", "dss",
	"dirty_decay_ms", "muzzy_decay_ms", "pactive", "pdirty", "pmuzzy",
	"dirty_npurge", "dirty_nmadvise", "dirty_purged", "muzzy_npurge",
	"muzzy_nmadvise", "muzzy_purged", "small", "large", "mapped",
	"retained", "pinned", "base", "internal", "metadata_edata",
	"metadata_rtree", "metadata_thp", "tcache_bytes",
	"tcache_stashed_bytes", "resident", "abandoned_vm", "extent_avail",
	"mutexes", "bins", "lextents", "extents", "hpa_shard"};
static const char *const pac_sec_keys[] = {"pac_sec_bytes", "pac_sec_hits",
	"pac_sec_misses", "pac_sec_dalloc_noflush", "pac_sec_dalloc_flush"};

static const ctl_field_t arena_sample_fields[] = {
	{"nthreads", "nthreads", ctl_field_unsigned},
	{"dss", "dss", ctl_field_string},
	{"pactive", "pactive", ctl_field_size},
	{"mapped", "mapped", ctl_field_size},
};

static unsigned
create_manual_arena(void) {
	unsigned arena_ind = 0;
	size_t sz = sizeof(arena_ind);
	assert_d_eq(mallctl("arenas.create", &arena_ind, &sz, NULL, 0), 0,
	    "Could not create manual arena");
	return arena_ind;
}

static void
destroy_manual_arena(unsigned arena_ind) {
	size_t mib[3];
	size_t miblen = ARRAY_COUNT(mib);
	assert_d_eq(mallctlnametomib("arena.0.destroy", mib, &miblen), 0,
	    "Could not resolve arena destroy mallctl");
	mib[1] = arena_ind;
	assert_d_eq(mallctlbymib(mib, miblen, NULL, NULL, NULL, 0), 0,
	    "Could not destroy arena %u", arena_ind);
}

static void
expect_arena_sample(json_fragment_t stats_arenas, const char *json_key,
    unsigned ctl_ind, bool has_name) {
	json_fragment_t arena;
	bool missing = json_object_member(stats_arenas, json_key, &arena);
	expect_false(missing, "stats.arenas is missing %s", json_key);
	if (missing) {
		return;
	}

	char ctl_prefix[64];
	malloc_snprintf(ctl_prefix, sizeof(ctl_prefix), "stats.arenas.%u",
	    ctl_ind);
	expect_json_ctl_fields(arena, ctl_prefix, arena_sample_fields,
	    ARRAY_COUNT(arena_sample_fields));

	json_fragment_t name;
	bool name_missing = json_object_member(arena, "name", &name);
	if (has_name) {
		expect_false(name_missing, "stats.arenas.%s is missing name",
		    json_key);
	} else {
		expect_true(name_missing,
		    "stats.arenas.%s unexpectedly contains name", json_key);
	}
}

typedef enum {
	option_parent_jemalloc,
	option_parent_stats,
	option_parent_arenas,
	option_parent_merged,
} option_parent_t;

typedef struct {
	const char     *opts;
	option_parent_t parent;
	const char     *omitted_key;
} option_case_t;

static void
expect_option_omits(const option_case_t *test_case) {
	stats_buf_t sbuf;
	json_fragment_t jemalloc;
	bool malformed = stats_json_print_opts(
	    &sbuf, test_case->opts, &jemalloc);
	expect_false(malformed, "Malformed JSON for opts=%s", test_case->opts);
	if (malformed) {
		stats_buf_fini(&sbuf);
		return;
	}

	json_fragment_t stats, stats_arenas, merged;
	json_fragment_t parent = jemalloc;
	if (test_case->parent >= option_parent_stats) {
		assert_false(json_object_member(jemalloc, "stats", &stats),
		    "opts=%s omitted stats", test_case->opts);
		parent = stats;
	}
	if (test_case->parent >= option_parent_arenas) {
		assert_false(json_object_member(
		                 jemalloc, "stats.arenas", &stats_arenas),
		    "opts=%s omitted stats.arenas", test_case->opts);
		parent = stats_arenas;
	}
	if (test_case->parent >= option_parent_merged) {
		assert_false(json_object_member(stats_arenas, "merged", &merged),
		    "opts=%s omitted merged stats", test_case->opts);
		parent = merged;
	}

	json_fragment_t ignored;
	expect_true(json_object_member(
	                parent, test_case->omitted_key, &ignored),
	    "opts=%s did not omit %s", test_case->opts,
	    test_case->omitted_key);

	if (strcmp(test_case->opts, "Jx") == 0) {
		assert_false(json_object_member(
		                 jemalloc, "stats.arenas", &stats_arenas),
		    "opts=Jx omitted stats.arenas");
		assert_false(json_object_member(stats_arenas, "merged", &merged),
		    "opts=Jx omitted merged stats");
		expect_true(json_object_member(merged, "mutexes", &ignored),
		    "opts=Jx did not omit arena mutexes");
	}
	stats_buf_fini(&sbuf);
}

TEST_BEGIN(test_json_stats_arenas_and_options) {
	test_skip_if(!config_stats);

	unsigned manual_ind = create_manual_arena();
	unsigned destroyed_ind = create_manual_arena();
	void *manual_alloc = mallocx(1,
	    MALLOCX_ARENA(manual_ind) | MALLOCX_TCACHE_NONE);
	assert_ptr_not_null(manual_alloc, "Manual arena allocation failed");
	void *destroyed_alloc = mallocx(1,
	    MALLOCX_ARENA(destroyed_ind) | MALLOCX_TCACHE_NONE);
	assert_ptr_not_null(destroyed_alloc,
	    "Destroyed arena allocation failed");
	dallocx(destroyed_alloc, MALLOCX_TCACHE_NONE);
	destroy_manual_arena(destroyed_ind);

	stats_buf_t sbuf;
	json_fragment_t jemalloc;
	bool malformed = stats_json_print_opts(&sbuf, "J", &jemalloc);
	assert_false(malformed, "Malformed default JSON stats");
	json_fragment_t stats_arenas;
	assert_false(json_object_member(
	                 jemalloc, "stats.arenas", &stats_arenas),
	    "Default JSON stats omitted stats.arenas");

	char manual_key[32];
	malloc_snprintf(
	    manual_key, sizeof(manual_key), "%u", manual_ind);
	expect_arena_sample(stats_arenas, "0", 0, true);
	expect_arena_sample(
	    stats_arenas, manual_key, manual_ind, true);
	expect_arena_sample(stats_arenas, "destroyed",
	    MALLCTL_ARENAS_DESTROYED, false);
	stats_buf_fini(&sbuf);

	const option_case_t cases[] = {
	    {"Jg", option_parent_jemalloc, "version"},
	    {"Jm", option_parent_arenas, "merged"},
	    {"Jd", option_parent_arenas, "destroyed"},
	    {"Ja", option_parent_arenas, manual_key},
	    {"Jb", option_parent_merged, "bins"},
	    {"Jl", option_parent_merged, "lextents"},
	    {"Jx", option_parent_stats, "mutexes"},
	    {"Je", option_parent_merged, "extents"},
	    {"Jh", option_parent_merged, "hpa_shard"},
	    {"Jmda", option_parent_jemalloc, "stats.arenas"},
	};
	for (size_t i = 0; i < ARRAY_COUNT(cases); i++) {
		expect_option_omits(&cases[i]);
	}

	dallocx(manual_alloc, MALLOCX_TCACHE_NONE);
	destroy_manual_arena(manual_ind);
}
TEST_END

TEST_BEGIN(test_json_stats_global_and_arena) {
	test_skip_if(!config_stats);

	stats_buf_t sbuf;
	json_fragment_t stats, merged;
	bool malformed = stats_json_print(&sbuf, &stats, &merged);
	expect_false(malformed, "Could not find runtime stats in JSON output");
	if (malformed) {
		stats_buf_fini(&sbuf);
		return;
	}

	const char *const stats_keys[] = {"allocated", "active", "metadata",
	    "metadata_edata", "metadata_rtree", "metadata_thp", "resident",
	    "mapped", "retained", "pinned", "zero_reallocs",
	    "background_thread", "mutexes"};
	expect_json_object_keys(
	    stats, stats_keys, ARRAY_COUNT(stats_keys), "stats");
	expect_json_ctl_fields(
	    stats, "stats", global_fields, ARRAY_COUNT(global_fields));

	json_fragment_t background_thread;
	expect_false(json_object_member(
	                 stats, "background_thread", &background_thread),
	    "stats is missing background_thread");
	const char *const background_thread_keys[] = {
	    "num_threads", "num_runs", "run_interval"};
	expect_json_object_keys(background_thread, background_thread_keys,
	    ARRAY_COUNT(background_thread_keys), "stats.background_thread");
	if (have_background_thread) {
		expect_json_ctl_fields(background_thread, "stats.background_thread",
		    background_thread_fields,
		    ARRAY_COUNT(background_thread_fields));
	} else {
		for (size_t i = 0; i < ARRAY_COUNT(background_thread_keys); i++) {
			expect_json_uint_eq(background_thread,
			    background_thread_keys[i], 0, "stats.background_thread");
		}
	}

	char arena_prefix[64];
	malloc_snprintf(arena_prefix, sizeof(arena_prefix), "stats.arenas.%u",
	    MALLCTL_ARENAS_ALL);
	size_t expected_merged_keys = ARRAY_COUNT(merged_keys);
	if (opt_pac_sec_opts.nshards > 0) {
		expected_merged_keys += ARRAY_COUNT(pac_sec_keys);
	}
	expect_zu_eq(json_object_size(merged), expected_merged_keys,
	    "merged arena stats has an unexpected number of keys");
	expect_json_object_has_keys(merged, merged_keys, ARRAY_COUNT(merged_keys),
	    "merged arena stats");
	expect_json_ctl_fields(
	    merged, arena_prefix, arena_fields, ARRAY_COUNT(arena_fields));
	if (opt_pac_sec_opts.nshards > 0) {
		expect_json_object_has_keys(merged, pac_sec_keys,
		    ARRAY_COUNT(pac_sec_keys), "merged arena stats");
		expect_json_ctl_fields(merged, arena_prefix, pac_sec_fields,
		    ARRAY_COUNT(pac_sec_fields));
	}

	json_fragment_t small, large;
	expect_false(json_object_member(merged, "small", &small),
	    "merged arena stats are missing small");
	expect_false(json_object_member(merged, "large", &large),
	    "merged arena stats are missing large");
	expect_json_object_keys(small, arena_alloc_keys,
	    ARRAY_COUNT(arena_alloc_keys), "stats.arenas.merged.small");
	expect_json_object_keys(large, arena_alloc_keys,
	    ARRAY_COUNT(arena_alloc_keys), "stats.arenas.merged.large");
	char alloc_prefix[96];
	malloc_snprintf(
	    alloc_prefix, sizeof(alloc_prefix), "%s.small", arena_prefix);
	expect_json_ctl_fields(small, alloc_prefix, arena_alloc_fields,
	    ARRAY_COUNT(arena_alloc_fields));
	malloc_snprintf(
	    alloc_prefix, sizeof(alloc_prefix), "%s.large", arena_prefix);
	expect_json_ctl_fields(large, alloc_prefix, arena_alloc_fields,
	    ARRAY_COUNT(arena_alloc_fields));

	json_fragment_t mutexes;
	expect_false(json_object_member(stats, "mutexes", &mutexes),
	    "stats is missing mutexes");
	expect_zu_eq(json_object_size(mutexes), num_global_mutexes,
	    "stats.mutexes has an unexpected number of mutexes");
	for (size_t i = 0; i < num_global_mutexes; i++) {
		json_fragment_t mutex;
		expect_false(json_object_member(
		                 mutexes, global_mutex_names[i], &mutex),
		    "stats.mutexes is missing %s", global_mutex_names[i]);
		char prefix[128];
		malloc_snprintf(prefix, sizeof(prefix), "stats.mutexes.%s",
		    global_mutex_names[i]);
		expect_mutex_object(mutex, prefix);
	}

	expect_false(json_object_member(merged, "mutexes", &mutexes),
	    "merged arena stats are missing mutexes");
	expect_zu_eq(json_object_size(mutexes), num_arena_mutexes,
	    "merged arena mutexes has an unexpected number of mutexes");
	for (size_t i = 0; i < num_arena_mutexes; i++) {
		json_fragment_t mutex;
		expect_false(json_object_member(
		                 mutexes, arena_mutex_names[i], &mutex),
		    "merged arena mutexes is missing %s", arena_mutex_names[i]);
		char prefix[160];
		malloc_snprintf(prefix, sizeof(prefix), "%s.mutexes.%s",
		    arena_prefix, arena_mutex_names[i]);
		expect_mutex_object(mutex, prefix);
	}

	stats_buf_fini(&sbuf);
}
TEST_END

static const ctl_field_t hpa_fields[] = {
	{"npageslabs", "npageslabs", ctl_field_size},
	{"nactive", "nactive", ctl_field_size},
	{"ndirty", "ndirty", ctl_field_size},
	{"npurge_passes", "npurge_passes", ctl_field_uint64},
	{"npurges", "npurges", ctl_field_uint64},
	{"nhugifies", "nhugifies", ctl_field_uint64},
	{"nhugify_failures", "nhugify_failures", ctl_field_uint64},
	{"ndehugifies", "ndehugifies", ctl_field_uint64},
};

static const ctl_field_t hpa_sec_fields[] = {
	{"sec_bytes", "hpa_sec_bytes", ctl_field_size},
	{"sec_hits", "hpa_sec_hits", ctl_field_size},
	{"sec_misses", "hpa_sec_misses", ctl_field_size},
	{"sec_dalloc_noflush", "hpa_sec_dalloc_noflush", ctl_field_size},
	{"sec_dalloc_flush", "hpa_sec_dalloc_flush", ctl_field_size},
	{"sec_overfills", "hpa_sec_overfills", ctl_field_size},
};

static const ctl_field_t hpa_slab_fields[] = {
	{"npageslabs_huge", "npageslabs_huge", ctl_field_size},
	{"nactive_huge", "nactive_huge", ctl_field_size},
	{"ndirty_huge", "ndirty_huge", ctl_field_size},
	{"npageslabs_nonhuge", "npageslabs_nonhuge", ctl_field_size},
	{"nactive_nonhuge", "nactive_nonhuge", ctl_field_size},
	{"ndirty_nonhuge", "ndirty_nonhuge", ctl_field_size},
};
static const char *const hpa_slab_keys[] = {"npageslabs_huge",
	"nactive_huge", "ndirty_huge", "npageslabs_nonhuge",
	"nactive_nonhuge", "ndirty_nonhuge", "nretained_nonhuge"};
static const char *const hpa_slab_row_keys[] = {"size", "ind"};

static void
expect_hpa_slab(json_fragment_t slab, const char *ctl_prefix,
    const char *name, bool table_row) {
	expect_zu_eq(json_object_size(slab), ARRAY_COUNT(hpa_slab_keys)
	        + (table_row ? ARRAY_COUNT(hpa_slab_row_keys) : 0),
	    "%s has an unexpected number of keys", name);
	expect_json_object_has_keys(
	    slab, hpa_slab_keys, ARRAY_COUNT(hpa_slab_keys), name);
	if (table_row) {
		expect_json_object_has_keys(slab, hpa_slab_row_keys,
		    ARRAY_COUNT(hpa_slab_row_keys), name);
	}
	expect_json_ctl_fields(slab, ctl_prefix, hpa_slab_fields,
	    ARRAY_COUNT(hpa_slab_fields));

	size_t npageslabs, nactive, ndirty;
	size_t sz = sizeof(size_t);
	char ctl_name[192];
	malloc_snprintf(ctl_name, sizeof(ctl_name),
	    "%s.npageslabs_nonhuge", ctl_prefix);
	expect_d_eq(mallctl(ctl_name, &npageslabs, &sz, NULL, 0), 0,
	    "mallctl failed for %s", ctl_name);
	sz = sizeof(size_t);
	malloc_snprintf(
	    ctl_name, sizeof(ctl_name), "%s.nactive_nonhuge", ctl_prefix);
	expect_d_eq(mallctl(ctl_name, &nactive, &sz, NULL, 0), 0,
	    "mallctl failed for %s", ctl_name);
	sz = sizeof(size_t);
	malloc_snprintf(
	    ctl_name, sizeof(ctl_name), "%s.ndirty_nonhuge", ctl_prefix);
	expect_d_eq(mallctl(ctl_name, &ndirty, &sz, NULL, 0), 0,
	    "mallctl failed for %s", ctl_name);
	expect_json_uint_eq(slab, "nretained_nonhuge",
	    npageslabs * HUGEPAGE_PAGES - nactive - ndirty, name);
}

static const ctl_field_t hpa_alloc_fields[] = {
	{"min_extents", "min_extents", ctl_field_uint64},
	{"max_extents", "max_extents", ctl_field_uint64},
	{"extents", "extents", ctl_field_uint64},
	{"ps", "ps", ctl_field_uint64},
	{"pages_per_ps", "pages_per_ps", ctl_field_uint64},
	{"extents_per_ps", "extents_per_ps", ctl_field_uint64},
	{"total_elapsed_ns_per_ps", "total_elapsed_ns_per_ps",
	    ctl_field_uint64},
};
static const char *const hpa_alloc_keys[] = {"min_extents", "max_extents",
	"extents", "ps", "pages_per_ps", "extents_per_ps",
	"total_elapsed_ns_per_ps"};

TEST_BEGIN(test_json_stats_hpa) {
	test_skip_if(!config_stats);
	test_skip_if(!hpa_supported());

	stats_buf_t sbuf;
	json_fragment_t stats, merged;
	bool malformed = stats_json_print(&sbuf, &stats, &merged);
	expect_false(malformed, "Could not find runtime stats in JSON output");
	if (malformed) {
		stats_buf_fini(&sbuf);
		return;
	}

	json_fragment_t hpa;
	expect_false(json_object_member(merged, "hpa_shard", &hpa),
	    "merged arena stats are missing hpa_shard");
	const char *const hpa_keys[] = {"sec_bytes", "sec_hits", "sec_misses",
	    "sec_dalloc_noflush", "sec_dalloc_flush", "sec_overfills",
	    "npageslabs", "nactive", "ndirty", "npurge_passes", "npurges",
	    "nhugifies", "nhugify_failures", "ndehugifies", "slabs",
	    "extent_allocation_distribution", "full_slabs", "empty_slabs",
	    "nonfull_slabs"};
	expect_json_object_keys(
	    hpa, hpa_keys, ARRAY_COUNT(hpa_keys), "hpa_shard");

	char arena_prefix[64];
	malloc_snprintf(arena_prefix, sizeof(arena_prefix), "stats.arenas.%u",
	    MALLCTL_ARENAS_ALL);
	expect_json_ctl_fields(hpa, arena_prefix, hpa_sec_fields,
	    ARRAY_COUNT(hpa_sec_fields));
	char hpa_prefix[96];
	malloc_snprintf(
	    hpa_prefix, sizeof(hpa_prefix), "%s.hpa_shard", arena_prefix);
	expect_json_ctl_fields(
	    hpa, hpa_prefix, hpa_fields, ARRAY_COUNT(hpa_fields));

	json_fragment_t slabs;
	expect_false(json_object_member(hpa, "slabs", &slabs),
	    "hpa_shard is missing slabs");
	char slab_prefix[128];
	malloc_snprintf(
	    slab_prefix, sizeof(slab_prefix), "%s.slabs", hpa_prefix);
	expect_hpa_slab(slabs, slab_prefix, "hpa_shard.slabs", false);

	const char *const summary_names[] = {"full_slabs", "empty_slabs"};
	for (size_t i = 0; i < ARRAY_COUNT(summary_names); i++) {
		json_fragment_t summary;
		expect_false(json_object_member(hpa, summary_names[i], &summary),
		    "hpa_shard is missing %s", summary_names[i]);
		malloc_snprintf(slab_prefix, sizeof(slab_prefix), "%s.%s",
		    hpa_prefix, summary_names[i]);
		expect_hpa_slab(summary, slab_prefix, summary_names[i], true);
		expect_json_string_eq(
		    summary, "size", i == 0 ? "full" : "empty", summary_names[i]);
		expect_json_string_eq(summary, "ind", "-", summary_names[i]);
	}

	json_fragment_t nonfull;
	expect_false(json_object_member(hpa, "nonfull_slabs", &nonfull),
	    "hpa_shard is missing nonfull_slabs");
	size_t nonfull_count = PSSET_NPSIZES < SC_NPSIZES ? PSSET_NPSIZES
	                                                  : SC_NPSIZES;
	expect_zu_eq(json_array_size(nonfull), nonfull_count,
	    "nonfull_slabs has an unexpected number of rows");
	for (size_t i = 0; i < nonfull_count; i++) {
		json_fragment_t slab;
		expect_false(json_array_element(nonfull, i, &slab),
		    "nonfull_slabs is missing row %zu", i);
		malloc_snprintf(slab_prefix, sizeof(slab_prefix),
		    "%s.nonfull_slabs.%zu", hpa_prefix, i);
		char row_name[64];
		malloc_snprintf(
		    row_name, sizeof(row_name), "nonfull_slabs[%zu]", i);
		expect_hpa_slab(slab, slab_prefix, row_name, true);
		expect_json_uint_eq(
		    slab, "size", sz_pind2sz((pszind_t)i), row_name);
		expect_json_uint_eq(slab, "ind", i, row_name);
	}

	json_fragment_t distribution;
	expect_false(json_object_member(
	                 hpa, "extent_allocation_distribution", &distribution),
	    "hpa_shard is missing extent_allocation_distribution");
	expect_zu_eq(json_array_size(distribution), SEC_MAX_NALLOCS + 1,
	    "extent_allocation_distribution has an unexpected row count");
	for (size_t i = 0; i <= SEC_MAX_NALLOCS; i++) {
		json_fragment_t row;
		expect_false(json_array_element(distribution, i, &row),
		    "extent_allocation_distribution is missing row %zu", i);
		char row_name[80];
		malloc_snprintf(row_name, sizeof(row_name),
		    "extent_allocation_distribution[%zu]", i);
		expect_json_object_keys(row, hpa_alloc_keys,
		    ARRAY_COUNT(hpa_alloc_keys), row_name);
		char ctl_prefix[128];
		malloc_snprintf(ctl_prefix, sizeof(ctl_prefix),
		    "%s.alloc.%zu", hpa_prefix, i);
		expect_json_ctl_fields(row, ctl_prefix, hpa_alloc_fields,
		    ARRAY_COUNT(hpa_alloc_fields));
	}

	stats_buf_fini(&sbuf);
}
TEST_END

static const ctl_field_t bin_fields[] = {
	{"nmalloc", "nmalloc", ctl_field_uint64},
	{"ndalloc", "ndalloc", ctl_field_uint64},
	{"curregs", "curregs", ctl_field_size},
	{"nrequests", "nrequests", ctl_field_uint64},
	{"nfills", "nfills", ctl_field_uint64},
	{"nflushes", "nflushes", ctl_field_uint64},
	{"nslabs", "nslabs", ctl_field_uint64},
	{"nreslabs", "nreslabs", ctl_field_uint64},
	{"curslabs", "curslabs", ctl_field_size},
	{"nonfull_slabs", "nonfull_slabs", ctl_field_size},
};
static const char *const bin_keys[] = {"size", "ind", "allocated",
	"nmalloc", "nmalloc_ps", "ndalloc", "ndalloc_ps", "nrequests",
	"nrequests_ps", "nshards", "curregs", "curslabs", "nonfull_slabs",
	"regs", "pgs", "util", "nfills", "nfills_ps", "nflushes",
	"nflushes_ps", "nslabs", "nreslabs", "nreslabs_ps", "mutex"};

static const ctl_field_t lextent_fields[] = {
	{"nmalloc", "nmalloc", ctl_field_uint64},
	{"ndalloc", "ndalloc", ctl_field_uint64},
	{"nrequests", "nrequests", ctl_field_uint64},
	{"curlextents", "curlextents", ctl_field_size},
};
static const char *const lextent_keys[] = {"size", "ind", "allocated",
	"nmalloc", "nmalloc_ps", "ndalloc", "ndalloc_ps", "nrequests",
	"nrequests_ps", "curlextents"};

static const ctl_field_t extent_fields[] = {
	{"ndirty", "ndirty", ctl_field_size},
	{"nmuzzy", "nmuzzy", ctl_field_size},
	{"nretained", "nretained", ctl_field_size},
	{"npinned", "npinned", ctl_field_size},
	{"dirty_bytes", "dirty_bytes", ctl_field_size},
	{"muzzy_bytes", "muzzy_bytes", ctl_field_size},
	{"retained_bytes", "retained_bytes", ctl_field_size},
	{"pinned_bytes", "pinned_bytes", ctl_field_size},
};
static const char *const extent_keys[] = {"size", "ind", "ndirty",
	"dirty_bytes", "nmuzzy", "muzzy_bytes", "nretained",
	"retained_bytes", "npinned", "pinned_bytes", "ntotal",
	"total_bytes"};

static const char *const prof_keys[] = {"prof_live_requested",
	"prof_live_count", "prof_accum_requested", "prof_accum_count"};

static void
expect_prof_stats(json_fragment_t object, const char *ctl_prefix) {
	prof_stats_t live, accum;
	size_t sz = sizeof(prof_stats_t);
	char ctl_name[128];
	malloc_snprintf(
	    ctl_name, sizeof(ctl_name), "%s.live", ctl_prefix);
	expect_d_eq(mallctl(ctl_name, &live, &sz, NULL, 0), 0,
	    "mallctl failed for %s", ctl_name);
	sz = sizeof(prof_stats_t);
	malloc_snprintf(
	    ctl_name, sizeof(ctl_name), "%s.accum", ctl_prefix);
	expect_d_eq(mallctl(ctl_name, &accum, &sz, NULL, 0), 0,
	    "mallctl failed for %s", ctl_name);
	expect_json_uint_eq(object, "prof_live_requested", live.req_sum,
	    ctl_prefix);
	expect_json_uint_eq(
	    object, "prof_live_count", live.count, ctl_prefix);
	expect_json_uint_eq(object, "prof_accum_requested", accum.req_sum,
	    ctl_prefix);
	expect_json_uint_eq(
	    object, "prof_accum_count", accum.count, ctl_prefix);
}

TEST_BEGIN(test_json_stats_arena_tables) {
	test_skip_if(!config_stats);

	stats_buf_t sbuf;
	json_fragment_t stats, merged;
	bool malformed = stats_json_print(&sbuf, &stats, &merged);
	expect_false(malformed, "Could not find runtime stats in JSON output");
	if (malformed) {
		stats_buf_fini(&sbuf);
		return;
	}

	unsigned nbins, nlextents;
	size_t sz = sizeof(nbins);
	expect_d_eq(mallctl("arenas.nbins", &nbins, &sz, NULL, 0), 0,
	    "mallctl failed for arenas.nbins");
	sz = sizeof(nlextents);
	expect_d_eq(mallctl("arenas.nlextents", &nlextents, &sz, NULL, 0), 0,
	    "mallctl failed for arenas.nlextents");
	char arena_prefix[64];
	malloc_snprintf(arena_prefix, sizeof(arena_prefix), "stats.arenas.%u",
	    MALLCTL_ARENAS_ALL);
	uint64_t uptime = read_uint64_field(arena_prefix, "uptime");

	json_fragment_t bins;
	expect_false(json_object_member(merged, "bins", &bins),
	    "merged arena stats are missing bins");
	expect_zu_eq(json_array_size(bins), nbins,
	    "bins has an unexpected number of rows");
	json_fragment_t first_bin, ignored;
	expect_false(json_array_element(bins, 0, &first_bin),
	    "bins is missing its first row");
	bool prof_stats_present = !json_object_member(
	    first_bin, "prof_live_requested", &ignored);
	for (unsigned i = 0; i < nbins; i++) {
		json_fragment_t bin;
		expect_false(json_array_element(bins, i, &bin),
		    "bins is missing row %u", i);
		char row_name[64];
		malloc_snprintf(row_name, sizeof(row_name), "bins[%u]", i);
		expect_zu_eq(json_object_size(bin), ARRAY_COUNT(bin_keys)
		        + (prof_stats_present ? ARRAY_COUNT(prof_keys) : 0),
		    "%s has an unexpected number of keys", row_name);
		expect_json_object_has_keys(
		    bin, bin_keys, ARRAY_COUNT(bin_keys), row_name);
		char ctl_prefix[128];
		malloc_snprintf(ctl_prefix, sizeof(ctl_prefix),
		    "stats.arenas.%u.bins.%u", MALLCTL_ARENAS_ALL, i);
		expect_json_ctl_fields(
		    bin, ctl_prefix, bin_fields, ARRAY_COUNT(bin_fields));

		char meta_prefix[64];
		malloc_snprintf(
		    meta_prefix, sizeof(meta_prefix), "arenas.bin.%u", i);
		size_t bin_size = read_size_field(meta_prefix, "size");
		uint32_t nregs = read_uint32_field(meta_prefix, "nregs");
		size_t slab_size = read_size_field(meta_prefix, "slab_size");
		uint32_t nshards = read_uint32_field(meta_prefix, "nshards");
		size_t curregs = read_size_field(ctl_prefix, "curregs");
		size_t curslabs = read_size_field(ctl_prefix, "curslabs");
		uint64_t nmalloc = read_uint64_field(ctl_prefix, "nmalloc");
		uint64_t ndalloc = read_uint64_field(ctl_prefix, "ndalloc");
		uint64_t nrequests = read_uint64_field(ctl_prefix, "nrequests");
		uint64_t nfills = read_uint64_field(ctl_prefix, "nfills");
		uint64_t nflushes = read_uint64_field(ctl_prefix, "nflushes");
		uint64_t nreslabs = read_uint64_field(ctl_prefix, "nreslabs");
		expect_json_uint_eq(bin, "size", bin_size, row_name);
		expect_json_uint_eq(bin, "ind", i, row_name);
		expect_json_uint_eq(
		    bin, "allocated", curregs * bin_size, row_name);
		expect_json_uint_eq(bin, "nmalloc_ps",
		    expected_rate(nmalloc, uptime), row_name);
		expect_json_uint_eq(bin, "ndalloc_ps",
		    expected_rate(ndalloc, uptime), row_name);
		expect_json_uint_eq(bin, "nrequests_ps",
		    expected_rate(nrequests, uptime), row_name);
		expect_json_uint_eq(bin, "nshards", nshards, row_name);
		expect_json_uint_eq(bin, "regs", nregs, row_name);
		expect_json_uint_eq(bin, "pgs", slab_size / PAGE, row_name);
		expect_json_uint_eq(bin, "nfills_ps",
		    expected_rate(nfills, uptime), row_name);
		expect_json_uint_eq(bin, "nflushes_ps",
		    expected_rate(nflushes, uptime), row_name);
		expect_json_uint_eq(bin, "nreslabs_ps",
		    expected_rate(nreslabs, uptime), row_name);
		char util[6];
		expected_utilization(curregs, nregs * curslabs, util);
		expect_json_string_eq(bin, "util", util, row_name);
		if (prof_stats_present) {
			expect_json_object_has_keys(
			    bin, prof_keys, ARRAY_COUNT(prof_keys), row_name);
			char prof_prefix[128];
			malloc_snprintf(prof_prefix, sizeof(prof_prefix),
			    "prof.stats.bins.%u", i);
			expect_prof_stats(bin, prof_prefix);
		}

		json_fragment_t mutex;
		expect_false(json_object_member(bin, "mutex", &mutex),
		    "%s is missing mutex", row_name);
		char mutex_prefix[160];
		malloc_snprintf(mutex_prefix, sizeof(mutex_prefix), "%s.mutex",
		    ctl_prefix);
		expect_mutex_object(mutex, mutex_prefix);
	}

	json_fragment_t lextents;
	expect_false(json_object_member(merged, "lextents", &lextents),
	    "merged arena stats are missing lextents");
	expect_zu_eq(json_array_size(lextents), nlextents,
	    "lextents has an unexpected number of rows");
	for (unsigned i = 0; i < nlextents; i++) {
		json_fragment_t lextent;
		expect_false(json_array_element(lextents, i, &lextent),
		    "lextents is missing row %u", i);
		char row_name[64];
		malloc_snprintf(row_name, sizeof(row_name), "lextents[%u]", i);
		expect_zu_eq(json_object_size(lextent), ARRAY_COUNT(lextent_keys)
		        + (prof_stats_present ? ARRAY_COUNT(prof_keys) : 0),
		    "%s has an unexpected number of keys", row_name);
		expect_json_object_has_keys(lextent, lextent_keys,
		    ARRAY_COUNT(lextent_keys), row_name);
		char ctl_prefix[128];
		malloc_snprintf(ctl_prefix, sizeof(ctl_prefix),
		    "stats.arenas.%u.lextents.%u", MALLCTL_ARENAS_ALL, i);
		expect_json_ctl_fields(lextent, ctl_prefix, lextent_fields,
		    ARRAY_COUNT(lextent_fields));
		char meta_prefix[64];
		malloc_snprintf(meta_prefix, sizeof(meta_prefix),
		    "arenas.lextent.%u", i);
		size_t lextent_size = read_size_field(meta_prefix, "size");
		size_t curlextents = read_size_field(ctl_prefix, "curlextents");
		uint64_t nmalloc = read_uint64_field(ctl_prefix, "nmalloc");
		uint64_t ndalloc = read_uint64_field(ctl_prefix, "ndalloc");
		uint64_t nrequests = read_uint64_field(ctl_prefix, "nrequests");
		expect_json_uint_eq(lextent, "size", lextent_size, row_name);
		expect_json_uint_eq(lextent, "ind", nbins + i, row_name);
		expect_json_uint_eq(lextent, "allocated",
		    curlextents * lextent_size, row_name);
		expect_json_uint_eq(lextent, "nmalloc_ps",
		    expected_rate(nmalloc, uptime), row_name);
		expect_json_uint_eq(lextent, "ndalloc_ps",
		    expected_rate(ndalloc, uptime), row_name);
		expect_json_uint_eq(lextent, "nrequests_ps",
		    expected_rate(nrequests, uptime), row_name);
		if (prof_stats_present) {
			expect_json_object_has_keys(lextent, prof_keys,
			    ARRAY_COUNT(prof_keys), row_name);
			char prof_prefix[128];
			malloc_snprintf(prof_prefix, sizeof(prof_prefix),
			    "prof.stats.lextents.%u", i);
			expect_prof_stats(lextent, prof_prefix);
		}
	}

	json_fragment_t extents;
	expect_false(json_object_member(merged, "extents", &extents),
	    "merged arena stats are missing extents");
	expect_zu_eq(json_array_size(extents), SC_NPSIZES,
	    "extents has an unexpected number of rows");
	for (unsigned i = 0; i < SC_NPSIZES; i++) {
		json_fragment_t extent;
		expect_false(json_array_element(extents, i, &extent),
		    "extents is missing row %u", i);
		char row_name[64];
		malloc_snprintf(row_name, sizeof(row_name), "extents[%u]", i);
		expect_json_object_keys(
		    extent, extent_keys, ARRAY_COUNT(extent_keys), row_name);
		char ctl_prefix[128];
		malloc_snprintf(ctl_prefix, sizeof(ctl_prefix),
		    "stats.arenas.%u.extents.%u", MALLCTL_ARENAS_ALL, i);
		expect_json_ctl_fields(extent, ctl_prefix, extent_fields,
		    ARRAY_COUNT(extent_fields));
		size_t ndirty = read_size_field(ctl_prefix, "ndirty");
		size_t nmuzzy = read_size_field(ctl_prefix, "nmuzzy");
		size_t nretained = read_size_field(ctl_prefix, "nretained");
		size_t npinned = read_size_field(ctl_prefix, "npinned");
		size_t dirty_bytes = read_size_field(ctl_prefix, "dirty_bytes");
		size_t muzzy_bytes = read_size_field(ctl_prefix, "muzzy_bytes");
		size_t retained_bytes = read_size_field(
		    ctl_prefix, "retained_bytes");
		size_t pinned_bytes = read_size_field(ctl_prefix, "pinned_bytes");
		expect_json_uint_eq(extent, "size", sz_pind2sz(i), row_name);
		expect_json_uint_eq(extent, "ind", i, row_name);
		expect_json_uint_eq(extent, "ntotal",
		    ndirty + nmuzzy + nretained + npinned, row_name);
		expect_json_uint_eq(extent, "total_bytes",
		    dirty_bytes + muzzy_bytes + retained_bytes + pinned_bytes,
		    row_name);
	}

	stats_buf_fini(&sbuf);
}
TEST_END

int
main(void) {
	return test_no_reentrancy(test_json_stats_global_and_arena,
	    test_json_stats_arena_tables, test_json_stats_hpa,
	    test_json_stats_arenas_and_options);
}