diff --git a/components/heap/test_multi_heap_host/test_multi_heap.cpp b/components/heap/test_multi_heap_host/test_multi_heap.cpp
index 975fd4c447..944d15a643 100644
--- a/components/heap/test_multi_heap_host/test_multi_heap.cpp
+++ b/components/heap/test_multi_heap_host/test_multi_heap.cpp
@@ -6,6 +6,14 @@
 #include <string.h>
 #include <assert.h>
 
+
+/* The functions __malloc__ and __free__ are used to call the libc
+ * malloc and free and allocate memory from the host heap. Since the test
+ * `TEST_CASE("multi_heap many random allocations", "[multi_heap]")`
+ * calls multi_heap_allocation_impl() with sizes that can go up to 8MB,
+ * an allocatation on the heap will be prefered rather than the stack which
+ * might not have the necessary memory.
+ */
 static void *__malloc__(size_t bytes)
 {
     return malloc(bytes);
@@ -69,10 +77,11 @@ TEST_CASE("multi_heap simple allocations", "[multi_heap]")
 
 TEST_CASE("multi_heap fragmentation", "[multi_heap]")
 {
-    uint8_t small_heap[4 * 1024];
+    const size_t HEAP_SIZE = 4 * 1024;
+    uint8_t small_heap[HEAP_SIZE];
     multi_heap_handle_t heap = multi_heap_register(small_heap, sizeof(small_heap));
 
-    const size_t alloc_size = 128;
+    const size_t alloc_size = 500;
 
     void *p[4];
     for (int i = 0; i < 4; i++) {
@@ -214,7 +223,7 @@ TEST_CASE("multi_heap defrag realloc", "[multi_heap]")
 
 void multi_heap_allocation_impl(int heap_size)
 {
-    uint8_t *big_heap = (uint8_t *) __malloc__(2*heap_size);
+    uint8_t *big_heap = (uint8_t *) __malloc__(heap_size);
     const int NUM_POINTERS = 64;
 
     printf("Running multi-allocation test with heap_size %d...\n", heap_size);
@@ -227,7 +236,7 @@ void multi_heap_allocation_impl(int heap_size)
 
     const size_t initial_free = multi_heap_free_size(heap);
 
-    const int ITERATIONS = 10000;
+    const int ITERATIONS = 5000;
 
     for (int i = 0; i < ITERATIONS; i++) {
         /* check all pointers allocated so far are valid inside big_heap */
@@ -238,11 +247,11 @@ void multi_heap_allocation_impl(int heap_size)
 
         uint8_t n = rand() % NUM_POINTERS;
 
-        if (rand() % 4 == 0) {
+        if (i % 4 == 0) {
             /* 1 in 4 iterations, try to realloc the buffer instead
                of using malloc/free
             */
-            size_t new_size = rand() % 1024;
+            size_t new_size = (rand() % 1023) + 1;
             void *new_p = multi_heap_realloc(heap, p[n], new_size);
             printf("realloc %p -> %p (%zu -> %zu)\n", p[n], new_p, s[n], new_size);
             multi_heap_check(heap, true);
@@ -410,8 +419,9 @@ TEST_CASE("multi_heap minimum-size allocations", "[multi_heap]")
 
 TEST_CASE("multi_heap_realloc()", "[multi_heap]")
 {
+    const size_t HEAP_SIZE = 4 * 1024;
     const uint32_t PATTERN = 0xABABDADA;
-    uint8_t small_heap[4 * 1024];
+    uint8_t small_heap[HEAP_SIZE];
     multi_heap_handle_t heap = multi_heap_register(small_heap, sizeof(small_heap));
 
     uint32_t *a = (uint32_t *)multi_heap_malloc(heap, 64);
@@ -421,7 +431,6 @@ TEST_CASE("multi_heap_realloc()", "[multi_heap]")
     REQUIRE( b > a); /* 'b' takes the block after 'a' */
 
     *a = PATTERN;
-
     uint32_t *c = (uint32_t *)multi_heap_realloc(heap, a, 72);
     REQUIRE( multi_heap_check(heap, true));
     REQUIRE(  c  != NULL );
@@ -431,13 +440,12 @@ TEST_CASE("multi_heap_realloc()", "[multi_heap]")
 #ifndef MULTI_HEAP_POISONING_SLOW
     // "Slow" poisoning implementation doesn't reallocate in place, so these
     // test will fail...
-
     uint32_t *d = (uint32_t *)multi_heap_realloc(heap, c, 36);
     REQUIRE( multi_heap_check(heap, true) );
     REQUIRE( c == d ); /* 'c' block should be shrunk in-place */
     REQUIRE( *d == PATTERN);
-
-    uint32_t *e = (uint32_t *)multi_heap_malloc(heap, 64);
+    // biggest allocation possible to completely fill the block left free after it was reallocated
+    uint32_t *e = (uint32_t *)multi_heap_malloc(heap, 60);
     REQUIRE( multi_heap_check(heap, true));
     REQUIRE( a == e ); /* 'e' takes the block formerly occupied by 'a' */
 
@@ -446,11 +454,7 @@ TEST_CASE("multi_heap_realloc()", "[multi_heap]")
     REQUIRE( multi_heap_check(heap, true) );
     REQUIRE( f == b ); /* 'b' should be extended in-place, over space formerly occupied by 'd' */
 
-#ifdef MULTI_HEAP_POISONING
-#define TOO_MUCH 7420 + 1
-#else
-#define TOO_MUCH 7420 + 1
-#endif
+#define TOO_MUCH HEAP_SIZE + 1
     /* not enough contiguous space left in the heap */
     uint32_t *g = (uint32_t *)multi_heap_realloc(heap, e, TOO_MUCH);
     REQUIRE( g == NULL );
@@ -460,7 +464,8 @@ TEST_CASE("multi_heap_realloc()", "[multi_heap]")
     g = (uint32_t *)multi_heap_realloc(heap, e, 128);
     REQUIRE( multi_heap_check(heap, true) );
     REQUIRE( e == g ); /* 'g' extends 'e' in place, into the space formerly held by 'f' */
-#endif
+
+#endif // MULTI_HEAP_POISONING_SLOW
 }
 
 // TLSF only accepts heaps aligned to 4-byte boundary so