--- libmalloc/libmalloc-409.60.6/tests/memory_pressure.c
+++ libmalloc/libmalloc-792.80.2/tests/memory_pressure.c
@@ -5,6 +5,9 @@
 #include <stdlib.h>
 #include <sys/queue.h>
 
+#include "../src/platform.h"
+#include "xzone_testing.h"
+
 #if TARGET_OS_WATCH
 #define TEST_TIMEOUT 1200
 #endif // TARGET_OS_WATCH
@@ -23,6 +26,7 @@
 	for (int t=0; t<100; t++) {
 		for (int i=0; i<cnt; i++) {
 			struct entry *p = calloc(1, sz);
+			T_QUIET; T_ASSERT_NOTNULL(p, "Failed to make allocation with size %zu", sz);
 			TAILQ_INSERT_TAIL(&head, p, next);
 		}
 		int i=0;
@@ -43,6 +47,8 @@
 		T_META_ENVVAR("MallocScribble=1"),
 		T_META_ENVVAR("MallocSpaceEfficient=1"),
 		T_META_ENVVAR("MallocMaxMagazines=1"),
+		T_META_TAG_VM_NOT_PREFERRED,
+		T_META_TAG_MAGAZINE_ONLY,
 		T_META_CHECK_LEAKS(false))
 {
 	dispatch_queue_t q = dispatch_queue_create("pressure queue", 0); // serial
@@ -57,6 +63,9 @@
 }
 
 T_DECL(small_mem_pressure, "small memory pressure thread",
+		T_META_TAG_VM_NOT_PREFERRED,
+		T_META_TAG_MAGAZINE_ONLY,
+		T_META_RUN_CONCURRENTLY(true),
 #if TARGET_OS_WATCH
 		T_META_TIMEOUT(TEST_TIMEOUT),
 #endif // TARGET_OS_WATCH
@@ -116,10 +125,106 @@
 
 #endif
 
+#if CONFIG_MALLOC_PROCESS_IDENTITY && CONFIG_XZONE_MALLOC
+#if !HAVE_MALLOC_TYPE
+#error "must have _MALLOC_TYPE_ENABLED"
+#endif // !HAVE_MALLOC_TYPE
+
+T_DECL(xzone_mem_pressure, "xzone memory pressure",
+		T_META_ENVVAR("MallocNanoZone=1"),
+		T_META_ENVVAR("MallocProbGuard=0"),
+#if TARGET_OS_WATCH
+		T_META_ENVVAR(PTR_BUCKET_ENVVAR), // disables narrow bucketing
+#endif
+		T_META_TAG("no_debug"),
+		T_META_TAG_XZONE_ONLY, T_META_TAG_VM_NOT_PREFERRED)
+{
+#define XZM_DATA_RANGE_SIZE    GiB(10)
+	xzm_malloc_zone_t zone = get_default_xzone_zone();
+	xzm_slice_kind_t kind;
+	xzm_segment_group_id_t sgid;
+	xzm_xzone_bucket_t bucket;
+
+	struct data {
+		size_t dummy[XZM_DATA_RANGE_SIZE / sizeof(size_t)];
+	};
+	void *data_alloc = malloc(sizeof(struct data));
+#if TARGET_OS_OSX
+	bool data_large = DEFAULT_LARGE_CACHE_ENABLED;
+#if CONFIG_XZM_CLUSTER_AWARE
+	data_large = true;
+#elif CONFIG_LARGE_CACHE && !MALLOC_TARGET_EXCLAVES
+	const char *env = getenv("MallocLargeCache")
+	if (env) {
+		data_large = env && !strcmp(env, "1");
+	}
+#endif
+
+	T_ASSERT_NOTNULL(data_alloc, "data allocation succeeded");
+	T_ASSERT_TRUE(xzm_ptr_lookup_4test(zone, data_alloc, &kind, &sgid, &bucket),
+			"data allocation lookup");
+	T_ASSERT_EQ(kind, XZM_SLICE_KIND_HUGE_CHUNK, "huge chunk");
+	T_ASSERT_EQ(sgid, data_large ?
+			XZM_SEGMENT_GROUP_DATA_LARGE : XZM_SEGMENT_GROUP_DATA,
+			"data segment group");
+	T_ASSERT_EQ(bucket, XZM_XZONE_BUCKET_DATA, "data bucket");
+	free(data_alloc);
+#else
+	T_ASSERT_NULL(data_alloc, "data allocation failed");
+#endif
+
+#define XZM_POINTER_RANGE_SIZE GiB(8)
+#define NUM_ALLOCS ((XZM_POINTER_RANGE_SIZE / XZM_LARGE_BLOCK_SIZE_MAX) + 20)
+	struct pointer {
+		void *dummy[XZM_LARGE_BLOCK_SIZE_MAX / sizeof(void *)];
+	};
+	// Exhaust this type in the early allocator
+    for (unsigned i = 0; i < 1000; i++) {
+        void *ptr = malloc(sizeof(struct pointer));
+        T_QUIET; T_ASSERT_NOTNULL(ptr, "early malloc");
+        free(ptr);
+    }
+
+	void *ptr_allocs[NUM_ALLOCS];
+#if !TARGET_OS_OSX
+	bool did_succeed = false, did_fail = false;
+#endif
+	for (size_t i = 0; i < NUM_ALLOCS; ++i) {
+		ptr_allocs[i] = malloc(sizeof(struct pointer));
+#if TARGET_OS_OSX
+		T_ASSERT_NOTNULL(ptr_allocs[i], "pointer allocation succeeded");
+		bucket = (xzm_xzone_bucket_t)~0u;
+		T_ASSERT_TRUE(xzm_ptr_lookup_4test(zone, ptr_allocs[i], &kind, &sgid,
+				&bucket), "pointer allocation lookup");
+		T_ASSERT_EQ(kind, XZM_SLICE_KIND_LARGE_CHUNK, "large chunk");
+		T_ASSERT_EQ(sgid, XZM_SEGMENT_GROUP_POINTER_LARGE,
+				"pointer segment group");
+		T_ASSERT_EQ(bucket, (xzm_xzone_bucket_t)~0u, "no bucket");
+#else
+		if (ptr_allocs[i]) {
+			did_succeed = true;
+		} else {
+			did_fail = true;
+		}
+#endif
+	}
+#if !TARGET_OS_OSX
+	T_ASSERT_TRUE(did_succeed, "a pointer allocation succeeded");
+	T_ASSERT_TRUE(did_fail, "a pointer allocation failed, presumably after exhausting memory");
+#endif
+
+	for (size_t i = 0; i < NUM_ALLOCS; ++i) {
+		free(ptr_allocs[i]);
+	}
+}
+#endif
+
 T_DECL(tiny_mem_pressure_multi, "test memory pressure in tiny on threads",
 #if TARGET_OS_WATCH
 		T_META_TIMEOUT(TEST_TIMEOUT),
 #endif // TARGET_OS_WATCH
+		T_META_TAG_VM_NOT_PREFERRED,
+		T_META_TAG_MAGAZINE_ONLY,
 		T_META_CHECK_LEAKS(false)) {
 	dispatch_group_t g = dispatch_group_create();
 	for (int i=0; i<16; i++) {
@@ -141,6 +246,9 @@
 }
 
 T_DECL(small_mem_pressure_multi, "test memory pressure in small on threads",
+		T_META_TAG_VM_NOT_PREFERRED,
+		T_META_TAG_MAGAZINE_ONLY,
+		T_META_RUN_CONCURRENTLY(true),
 #if TARGET_OS_WATCH
 		T_META_TIMEOUT(TEST_TIMEOUT),
 #endif // TARGET_OS_WATCH
@@ -168,7 +276,10 @@
 #if TARGET_OS_WATCH
 		T_META_TIMEOUT(TEST_TIMEOUT),
 #endif // TARGET_OS_WATCH
-		T_META_CHECK_LEAKS(false)) {
+		T_META_CHECK_LEAKS(false),
+		T_META_TAG_VM_NOT_PREFERRED,
+		T_META_TAG_MAGAZINE_ONLY,
+		T_META_RUN_CONCURRENTLY(true)) {
 	dispatch_group_t g = dispatch_group_create();
 	for (int i=0; i<30; i++) {
 		dispatch_group_async(g, dispatch_get_global_queue(0, 0), ^{