From 671a58519ef6207b54947ff70eea497ff7eb58ae Mon Sep 17 00:00:00 2001 From: Thomas Vanbesien Date: Sat, 21 Feb 2026 15:49:06 +0100 Subject: 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. --- tests/src/test_mem.c | 249 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 249 insertions(+) create mode 100644 tests/src/test_mem.c (limited to 'tests/src/test_mem.c') 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 + +_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); +} -- cgit v1.2.3