--- libmalloc/libmalloc-474.0.13/tests/nano_tests.c
+++ libmalloc/libmalloc-409.40.6/tests/nano_tests.c
@@ -88,33 +88,25 @@
 T_GLOBAL_META(T_META_RUN_CONCURRENTLY(true));
 
 T_DECL(nano_active_test, "Test that Nano is activated",
-	   T_META_ENVVAR("MallocNanoZone=1"), T_META_TAG_XZONE)
-{
-#if CONFIG_NANOZONE
-	if (getenv("MallocSecureAllocator")) {
-		T_ASSERT_EQ(malloc_engaged_nano(), 0, "Secure allocator engaged");
-	} else {
-		void *ptr = malloc(16);
-		T_LOG("Nano ptr is %p\n", ptr);
-		T_ASSERT_EQ(NANOZONE_SIGNATURE, (uint64_t)((uintptr_t)ptr) >> SHIFT_NANO_SIGNATURE,
-				"Nanozone is active");
-		T_ASSERT_NE(malloc_engaged_nano(), 0, "Nanozone engaged");
-		free(ptr);
-	}
+	   T_META_ENVVAR("MallocNanoZone=1"))
+{
+#if CONFIG_NANOZONE
+	void *ptr = malloc(16);
+	T_LOG("Nano ptr is %p\n", ptr);
+	T_ASSERT_EQ(NANOZONE_SIGNATURE, (uint64_t)((uintptr_t)ptr) >> SHIFT_NANO_SIGNATURE,
+			"Nanozone is active");
+	T_ASSERT_NE(malloc_engaged_nano(), 0, "Nanozone engaged");
+	free(ptr);
 #else // CONFIG_NANOZONE
 	T_SKIP("Nano allocator not configured");
 #endif // CONFIG_NANOZONE
 }
 
 T_DECL(nano_enumerator_test, "Test the Nanov2 enumerator",
-	   T_META_ENVVAR("MallocNanoZone=V2"), T_META_TAG_XZONE)
-{
-#if CONFIG_NANOZONE
-	if (getenv("MallocSecureAllocator")) {
-		T_ASSERT_EQ(malloc_engaged_nano(), 0, "Secure allocator engaged");
-	} else {
-		T_ASSERT_EQ(malloc_engaged_nano(), 2, "Nanozone V2 engaged");
-	}
+	   T_META_ENVVAR("MallocNanoZone=V2"))
+{
+#if CONFIG_NANOZONE
+	T_ASSERT_EQ(malloc_engaged_nano(), 2, "Nanozone V2 engaged");
 
 	// This test is problematic because the allocator is used before the test
 	// starts, so we can't start everything from zero.
@@ -146,7 +138,7 @@
 			"Incorrect blocks_in_use");
 	T_ASSERT_EQ(stats.size_in_use, initial_size_in_use + total_requested_size,
 			"Incorrect size_in_use");
-	T_ASSERT_GE(stats.size_allocated, total_requested_size,
+	T_ASSERT_TRUE(stats.size_allocated - initial_size_allocated >= total_requested_size,
 			"Size allocated must be >= size requested");
 
 	T_ASSERT_EQ(ptr_count, initial_ptrs + ALLOCATION_COUNT,
@@ -169,7 +161,7 @@
 	T_ASSERT_EQ(stats.size_in_use,
 			initial_size_in_use + total_requested_size - size_freed,
 			"Incorrect size_in_use after half free");
-	T_ASSERT_GE(stats.size_allocated, initial_size_allocated,
+	T_ASSERT_TRUE(stats.size_allocated >= initial_size_allocated ,
 			"Size allocated must be >= size requested");
 
 	T_ASSERT_EQ(ptr_count, initial_ptrs + ALLOCATION_COUNT / 2,
@@ -191,7 +183,7 @@
 			"Incorrect blocks_in_use after full free");
 	T_ASSERT_EQ(stats.size_in_use, initial_size_in_use,
 			"Incorrect size_in_use after full free");
-	T_ASSERT_GE(stats.size_allocated, initial_size_allocated,
+	T_ASSERT_TRUE(stats.size_allocated >= initial_size_allocated ,
 			"Size allocated must be >= size requested");
 	
 	T_ASSERT_EQ(ptr_count, initial_ptrs, "Incorrect number of pointers after free");
@@ -386,14 +378,16 @@
 #endif // CONFIG_NANOZONE
 }
 
-#if CONFIG_NANOZONE
+#if TARGET_OS_OSX
+
 // Guaranteed number of 256-byte allocations to be sure we fill a region.
 #define ALLOCS_PER_REGION ((NANOV2_REGION_SIZE)/256)
 
-#if NANOV2_MULTIPLE_REGIONS
+// These tests are required only on macOS because iOS only uses one region.
 T_DECL(overspill_region, "force overspill of a region",
 	   T_META_ENVVAR("MallocNanoZone=V2"))
 {
+#if CONFIG_NANOZONE
 	void **ptrs = calloc(ALLOCS_PER_REGION, sizeof(void *));
 	T_QUIET; T_ASSERT_NOTNULL(ptrs, "Unable to allocate pointers");
 	int index;
@@ -421,53 +415,11 @@
 		free(ptrs[i]);
 	}
 	free(ptrs);
-}
-#endif // NANOV2_MULTIPLE_REGIONS
-
-extern malloc_zone_t **malloc_zones;
-
-T_DECL(overspill_nanozone, "force overspill of nano zone",
-		T_META_ENVVAR("MallocNanoZone=V2"),
-		T_META_ENVVAR("MallocNanoMaxRegion=1"))
-{
-	int index;
-	bool spilled_to_tiny = false;
-	void **ptrs;
-	malloc_zone_t *nano_zone = malloc_zones[0];
-	malloc_zone_t *helper_zone = malloc_zones[1];
-
-	// Max number of 256B allocations that will fit in the nano zone (+1 to overspill)
-	const unsigned int nano_max_allocations = 2 * ALLOCS_PER_REGION + 1;
-
-	T_LOG("Allocating %d pointers for allocations", nano_max_allocations);
-	ptrs = calloc(nano_max_allocations, sizeof(void *));
-	T_QUIET; T_ASSERT_NOTNULL(ptrs, "Unable to allocate pointers");
-
-	ptrs[0] = malloc(256);
-	T_QUIET; T_ASSERT_NOTNULL(ptrs[0], "Failed to make initial allocation");
-	T_QUIET; T_ASSERT_TRUE(malloc_zone_claimed_address(nano_zone, ptrs[0]), 
-			"Initial allocation did not come from nano zone");
-	T_QUIET; T_ASSERT_FALSE(malloc_zone_claimed_address(helper_zone, ptrs[0]), 
-			"Initial allocation came from scalable zone");
-
-	for (index = 1; index < (nano_max_allocations); index++) {
-		ptrs[index] = malloc(256);
-		if (malloc_zone_claimed_address(helper_zone, ptrs[index])) {
-			T_LOG("Spilled to scalable zone");
-			spilled_to_tiny = true;
-			break;
-		}
-	}
-	T_EXPECT_TRUE(spilled_to_tiny, "Allocation falls through to scalable zone");
-
-	T_LOG("Freeing %d pointers", index);
-	for (int i = 0; i < MIN(index + 1, nano_max_allocations); i++) {
-		free(ptrs[i]);
-	}
-	free(ptrs);
-}
-
-#if NANOV2_MULTIPLE_REGIONS
+#else // CONFIG_NANOZONE
+	T_SKIP("Nano allocator not configured");
+#endif // CONFIG_NANOZONE
+}
+
 void *
 punch_holes_thread(void *arg)
 {
@@ -535,10 +487,9 @@
 }
 
 T_DECL(region_holes, "ensure correct handling of holes between regions",
-		T_META_ENVVAR("MallocNanoZone=V2"),
-		// Region reservation does not allow for holes between regions
-		T_META_ENABLED(!CONFIG_NANO_RESERVE_REGIONS))
-{
+		T_META_ENVVAR("MallocNanoZone=V2"))
+{
+#if CONFIG_NANOZONE
 	srandom(time(NULL));
 
 	bool done = false;
@@ -569,7 +520,10 @@
 
 	T_PASS("Didn't crash");
 	T_END;
-}
-#endif // NANOV2_MULTIPLE_REGIONS
-#endif // CONFIG_NANOZONE
-
+#else // CONFIG_NANOZONE
+	T_SKIP("Nano allocator not configured");
+#endif // CONFIG_NANOZONE
+}
+
+#endif // TARGET_OS_OSX
+