#include "../libft.h"
#include "test_utils.h"
#include <strings.h>

static void
_s_ft_memset_null (void)
{
  _s_sink = (size_t)ft_memset (NULL, 'A', 10);
}
static void
_s_libc_memset_null (void)
{
  _s_sink = (size_t)memset (NULL, 'A', 10);
}
static void
_s_ft_bzero_null (void)
{
  ft_bzero (NULL, 10);
}
static void
_s_libc_bzero_null (void)
{
  bzero (NULL, 10);
}
static void
_s_ft_memcpy_null_dst (void)
{
  char buf[10];
  _s_sink = (size_t)ft_memcpy (NULL, buf, 10);
}
static void
_s_libc_memcpy_null_dst (void)
{
  char buf[10];
  _s_sink = (size_t)memcpy (NULL, buf, 10);
}
static void
_s_ft_memcpy_null_src (void)
{
  char buf[10];
  _s_sink = (size_t)ft_memcpy (buf, NULL, 10);
}
static void
_s_libc_memcpy_null_src (void)
{
  char buf[10];
  _s_sink = (size_t)memcpy (buf, NULL, 10);
}
static void
_s_ft_memmove_null_dst (void)
{
  char buf[10];
  _s_sink = (size_t)ft_memmove (NULL, buf, 10);
}
static void
_s_libc_memmove_null_dst (void)
{
  char buf[10];
  _s_sink = (size_t)memmove (NULL, buf, 10);
}
static void
_s_ft_memmove_null_src (void)
{
  char buf[10];
  _s_sink = (size_t)ft_memmove (buf, NULL, 10);
}
static void
_s_libc_memmove_null_src (void)
{
  char buf[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];

  printf ("-- memset --\n");

  /* NULL */
  _s_check_both_crash ("memset NULL", _s_ft_memset_null, _s_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 */
  srand (time (NULL));
  for (i = 0; i < 50; 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];

  printf ("-- bzero --\n");

  /* NULL */
  _s_check_both_crash ("bzero NULL", _s_ft_bzero_null, _s_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 < 50; 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];

  printf ("-- memcpy --\n");

  /* NULL */
  _s_check_both_crash ("memcpy NULL dst", _s_ft_memcpy_null_dst,
                       _s_libc_memcpy_null_dst);
  _s_check_both_crash ("memcpy NULL src", _s_ft_memcpy_null_src,
                       _s_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 < 50; 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];

  printf ("-- memmove --\n");

  /* NULL */
  _s_check_both_crash ("memmove NULL dst", _s_ft_memmove_null_dst,
                       _s_libc_memmove_null_dst);
  _s_check_both_crash ("memmove NULL src", _s_ft_memmove_null_src,
                       _s_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 < 50; 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)
{
  printf ("=== mem functions ===\n");
  _s_test_memset ();
  _s_test_bzero ();
  _s_test_memcpy ();
  _s_test_memmove ();
  _s_print_results ();
  return (_s_fail != 0);
}