Restructure project layout and clean up test suite

Move sources to src/, header to inc/, and tests to tests/src/.
Update Makefiles and .gitignore for the new layout.

Refactor test harness: add crash-wrapper macros (_S_CRASH,
_S_CRASH_I, _S_CRASH_V, _S_CRASH_BUF) replacing 58 hand-written
wrappers, add shared _s_test_int_range helper eliminating duplicate
_s_test_func, add _S_RAND_ITERS constant, move srand() to main()
in all test binaries, and add Doxygen comments to test_utils.h.

1 files changed, 249 insertions, 0 deletions

diff --git a/tests/src/test_mem.c b/tests/src/test_mem.c
new file mode 100644
index 0000000..3653004
--- /dev/null
+++ b/tests/src/test_mem.c
@@ -0,0 +1,249 @@
+#include "libft.h"
+#include "test_utils.h"
+#include <strings.h>
+
+_S_CRASH (ft_memset_null, ft_memset (NULL, 'A', 10))
+_S_CRASH (libc_memset_null, memset (NULL, 'A', 10))
+_S_CRASH_V (ft_bzero_null, ft_bzero (NULL, 10))
+_S_CRASH_V (libc_bzero_null, bzero (NULL, 10))
+_S_CRASH_BUF (ft_memcpy_null_dst, 10,
+              _s_sink = (size_t)ft_memcpy (NULL, buf, 10))
+_S_CRASH_BUF (libc_memcpy_null_dst, 10,
+              _s_sink = (size_t)memcpy (NULL, buf, 10))
+_S_CRASH_BUF (ft_memcpy_null_src, 10,
+              _s_sink = (size_t)ft_memcpy (buf, NULL, 10))
+_S_CRASH_BUF (libc_memcpy_null_src, 10,
+              _s_sink = (size_t)memcpy (buf, NULL, 10))
+_S_CRASH_BUF (ft_memmove_null_dst, 10,
+              _s_sink = (size_t)ft_memmove (NULL, buf, 10))
+_S_CRASH_BUF (libc_memmove_null_dst, 10,
+              _s_sink = (size_t)memmove (NULL, buf, 10))
+_S_CRASH_BUF (ft_memmove_null_src, 10,
+              _s_sink = (size_t)ft_memmove (buf, NULL, 10))
+_S_CRASH_BUF (libc_memmove_null_src, 10,
+              _s_sink = (size_t)memmove (buf, NULL, 10))
+
+/* ======================================
+ *  memset
+ * ====================================== */
+
+static void
+_s_test_memset (void)
+{
+  char ft_buf[256];
+  char libc_buf[256];
+  int i;
+  int c;
+  size_t len;
+  void *ret;
+  char label[64];
+
+  _s_section ("ft_memset");
+
+  /* NULL */
+  _s_check_both_crash ("memset NULL", _s_crash_ft_memset_null,
+                       _s_crash_libc_memset_null);
+
+  /* zero length */
+  memset (ft_buf, 'X', 256);
+  memset (libc_buf, 'X', 256);
+  ft_memset (ft_buf, 'A', 0);
+  memset (libc_buf, 'A', 0);
+  _s_check ("n=0", memcmp (ft_buf, libc_buf, 256) == 0);
+
+  /* return value */
+  ret = ft_memset (ft_buf, 'B', 10);
+  _s_check ("return value", ret == ft_buf);
+
+  /* randomized */
+  for (i = 0; i < _S_RAND_ITERS; i++)
+    {
+      c = rand () % 256;
+      len = rand () % 256;
+      ft_memset (ft_buf, c, len);
+      memset (libc_buf, c, len);
+      snprintf (label, sizeof (label), "random c=%d len=%zu", c, len);
+      _s_check (label, memcmp (ft_buf, libc_buf, len) == 0);
+    }
+}
+
+/* ======================================
+ *  bzero
+ * ====================================== */
+
+static void
+_s_test_bzero (void)
+{
+  char ft_buf[256];
+  char libc_buf[256];
+  int i;
+  size_t len;
+  char label[64];
+
+  _s_section ("ft_bzero");
+
+  /* NULL */
+  _s_check_both_crash ("bzero NULL", _s_crash_ft_bzero_null,
+                       _s_crash_libc_bzero_null);
+
+  /* zero length */
+  memset (ft_buf, 'X', 256);
+  memset (libc_buf, 'X', 256);
+  ft_bzero (ft_buf, 0);
+  bzero (libc_buf, 0);
+  _s_check ("n=0", memcmp (ft_buf, libc_buf, 256) == 0);
+
+  /* full clear */
+  memset (ft_buf, 'X', 256);
+  memset (libc_buf, 'X', 256);
+  ft_bzero (ft_buf, 256);
+  bzero (libc_buf, 256);
+  _s_check ("n=256", memcmp (ft_buf, libc_buf, 256) == 0);
+
+  /* randomized */
+  for (i = 0; i < _S_RAND_ITERS; i++)
+    {
+      len = rand () % 256;
+      memset (ft_buf, 'Z', 256);
+      memset (libc_buf, 'Z', 256);
+      ft_bzero (ft_buf, len);
+      bzero (libc_buf, len);
+      snprintf (label, sizeof (label), "random len=%zu", len);
+      _s_check (label, memcmp (ft_buf, libc_buf, 256) == 0);
+    }
+}
+
+/* ======================================
+ *  memcpy
+ * ====================================== */
+
+static void
+_s_test_memcpy (void)
+{
+  char src[256];
+  char ft_dst[256];
+  char libc_dst[256];
+  int i;
+  size_t len;
+  void *ret;
+  char label[64];
+
+  _s_section ("ft_memcpy");
+
+  /* NULL */
+  _s_check_both_crash ("memcpy NULL dst", _s_crash_ft_memcpy_null_dst,
+                       _s_crash_libc_memcpy_null_dst);
+  _s_check_both_crash ("memcpy NULL src", _s_crash_ft_memcpy_null_src,
+                       _s_crash_libc_memcpy_null_src);
+
+  /* fill source with pattern */
+  for (i = 0; i < 256; i++)
+    src[i] = i;
+
+  /* zero length */
+  memset (ft_dst, 'X', 256);
+  memset (libc_dst, 'X', 256);
+  ft_memcpy (ft_dst, src, 0);
+  memcpy (libc_dst, src, 0);
+  _s_check ("n=0", memcmp (ft_dst, libc_dst, 256) == 0);
+
+  /* return value */
+  ret = ft_memcpy (ft_dst, src, 10);
+  _s_check ("return value", ret == ft_dst);
+
+  /* NULL src and dst with n=0 */
+  ret = ft_memcpy (NULL, NULL, 0);
+  _s_check ("NULL,NULL,0", ret == NULL);
+
+  /* randomized */
+  for (i = 0; i < _S_RAND_ITERS; i++)
+    {
+      len = rand () % 256;
+      memset (ft_dst, 0, 256);
+      memset (libc_dst, 0, 256);
+      ft_memcpy (ft_dst, src, len);
+      memcpy (libc_dst, src, len);
+      snprintf (label, sizeof (label), "random len=%zu", len);
+      _s_check (label, memcmp (ft_dst, libc_dst, 256) == 0);
+    }
+}
+
+/* ======================================
+ *  memmove
+ * ====================================== */
+
+static void
+_s_test_memmove (void)
+{
+  char ft_buf[256];
+  char libc_buf[256];
+  int i;
+  size_t len;
+  size_t offset;
+  void *ret;
+  char label[64];
+
+  _s_section ("ft_memmove");
+
+  /* NULL */
+  _s_check_both_crash ("memmove NULL dst", _s_crash_ft_memmove_null_dst,
+                       _s_crash_libc_memmove_null_dst);
+  _s_check_both_crash ("memmove NULL src", _s_crash_ft_memmove_null_src,
+                       _s_crash_libc_memmove_null_src);
+
+  /* return value */
+  memset (ft_buf, 'A', 256);
+  ret = ft_memmove (ft_buf, ft_buf + 10, 10);
+  _s_check ("return value", ret == ft_buf);
+
+  /* NULL src and dst with n=0 */
+  ret = ft_memmove (NULL, NULL, 0);
+  _s_check ("NULL,NULL,0", ret == NULL);
+
+  /* forward overlap: src before dest */
+  for (i = 0; i < 256; i++)
+    ft_buf[i] = libc_buf[i] = i;
+  ft_memmove (ft_buf + 10, ft_buf, 100);
+  memmove (libc_buf + 10, libc_buf, 100);
+  _s_check ("forward overlap", memcmp (ft_buf, libc_buf, 256) == 0);
+
+  /* backward overlap: dest before src */
+  for (i = 0; i < 256; i++)
+    ft_buf[i] = libc_buf[i] = i;
+  ft_memmove (ft_buf, ft_buf + 10, 100);
+  memmove (libc_buf, libc_buf + 10, 100);
+  _s_check ("backward overlap", memcmp (ft_buf, libc_buf, 256) == 0);
+
+  /* non-overlapping */
+  for (i = 0; i < 256; i++)
+    ft_buf[i] = libc_buf[i] = i;
+  ft_memmove (ft_buf + 128, ft_buf, 50);
+  memmove (libc_buf + 128, libc_buf, 50);
+  _s_check ("non-overlapping", memcmp (ft_buf, libc_buf, 256) == 0);
+
+  /* randomized overlapping copies */
+  for (i = 0; i < _S_RAND_ITERS; i++)
+    {
+      for (int j = 0; j < 256; j++)
+        ft_buf[j] = libc_buf[j] = rand () % 256;
+      len = rand () % 128 + 1;
+      offset = rand () % 128;
+      ft_memmove (ft_buf + offset, ft_buf, len);
+      memmove (libc_buf + offset, libc_buf, len);
+      snprintf (label, sizeof (label), "random overlap len=%zu off=%zu", len,
+                offset);
+      _s_check (label, memcmp (ft_buf, libc_buf, 256) == 0);
+    }
+}
+
+int
+main (void)
+{
+  srand (time (NULL));
+  _s_test_memset ();
+  _s_test_bzero ();
+  _s_test_memcpy ();
+  _s_test_memmove ();
+  _s_print_results ();
+  return (_s_fail != 0);
+}