Implement realloc and add realloc rounds to random test

realloc returns the same pointer if the chunk is large enough,
otherwise malloc + memcpy + free. The random test now verifies
data integrity after resizing across all three categories.

1 files changed, 103 insertions, 1 deletions

diff --git a/tests/src/test_random.c b/tests/src/test_random.c
index f7247e2..396abf9 100644
--- a/tests/src/test_random.c
+++ b/tests/src/test_random.c
@@ -1,6 +1,6 @@
 /**
  * @file   test_random.c
- * @brief  Randomized correctness test for malloc/free.
+ * @brief  Randomized correctness test for malloc/free/realloc.
  *
  * Allocates random-sized blocks in TINY, SMALL, and LARGE ranges,
  * fills them with a deterministic pattern, then verifies the data.
@@ -138,6 +138,102 @@ _s_test_category (const char *label, size_t min, size_t max, int seed,
 }
 
 static int
+_s_test_realloc (const char *label, size_t min, size_t max, int seed,
+                 int base_index, int count)
+{
+  void *blocks[count];
+  size_t sizes[count];
+  size_t new_size;
+  size_t check_size;
+  unsigned char *data;
+  int fail;
+  int i;
+  int j;
+
+  fail = 0;
+  i = 0;
+  while (i < count)
+    {
+      sizes[i] = _s_rand_range (min, max);
+      blocks[i] = malloc (sizes[i]);
+      if (!blocks[i])
+        {
+          i++;
+          continue;
+        }
+      data = (unsigned char *)blocks[i];
+      j = 0;
+      while (j < (int)sizes[i])
+        {
+          data[j] = _s_pattern (seed, base_index + i, j);
+          j++;
+        }
+      i++;
+    }
+  i = 0;
+  while (i < count)
+    {
+      if (!blocks[i])
+        {
+          i++;
+          continue;
+        }
+      new_size = _s_rand_range (min, max);
+      blocks[i] = realloc (blocks[i], new_size);
+      if (!blocks[i])
+        {
+          _s_put_str (label);
+          _s_put_str ("[");
+          _s_put_nbr (i);
+          _s_put_str ("]: realloc FAILED\n");
+          fail = 1;
+          i++;
+          continue;
+        }
+      check_size = sizes[i];
+      if (new_size < check_size)
+        check_size = new_size;
+      data = (unsigned char *)blocks[i];
+      j = 0;
+      while (j < (int)check_size)
+        {
+          if (data[j] != _s_pattern (seed, base_index + i, j))
+            {
+              _s_put_str (label);
+              _s_put_str ("[");
+              _s_put_nbr (i);
+              _s_put_str ("]: FAIL at byte ");
+              _s_put_nbr (j);
+              _s_put_str ("\n");
+              fail = 1;
+              break;
+            }
+          j++;
+        }
+      if (j == (int)check_size)
+        {
+          _s_put_str (label);
+          _s_put_str ("[");
+          _s_put_nbr (i);
+          _s_put_str ("]: OK (");
+          _s_put_nbr ((int)sizes[i]);
+          _s_put_str (" -> ");
+          _s_put_nbr ((int)new_size);
+          _s_put_str (" bytes)\n");
+        }
+      sizes[i] = new_size;
+      i++;
+    }
+  i = 0;
+  while (i < count)
+    {
+      free (blocks[i]);
+      i++;
+    }
+  return (fail);
+}
+
+static int
 _s_atoi (const char *str)
 {
   int n;
@@ -172,5 +268,11 @@ main (int argc, char **argv)
                             count);
   fail |= _s_test_category ("LARGE", SMALL_MAX + 1, LARGE_MAX, seed, count * 2,
                             count);
+  fail
+      |= _s_test_realloc ("REALLOC_TINY", 1, TINY_MAX, seed, count * 3, count);
+  fail |= _s_test_realloc ("REALLOC_SMALL", TINY_MAX + 1, SMALL_MAX, seed,
+                           count * 4, count);
+  fail |= _s_test_realloc ("REALLOC_LARGE", SMALL_MAX + 1, LARGE_MAX, seed,
+                           count * 5, count);
   return (fail);
 }