#include "../libft.h"
#include "test_utils.h"

static void
_s_ft_strdup_null (void)
{
  _s_sink = (size_t)ft_strdup (NULL);
}
static void
_s_libc_strdup_null (void)
{
  _s_sink = (size_t)strdup (NULL);
}

/* ======================================
 *  calloc
 * ====================================== */

static void
_s_test_calloc (void)
{
  int i;
  char label[64];

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

  /* zeroed memory */
  {
    char *ft_p = ft_calloc (100, 1);
    char *libc_p = calloc (100, 1);
    _s_check ("zeroed", ft_p && libc_p && memcmp (ft_p, libc_p, 100) == 0);
    free (ft_p);
    free (libc_p);
  }

  /* nmemb=0 */
  {
    void *p = ft_calloc (0, 10);
    _s_check ("nmemb=0 not NULL", p != NULL);
    free (p);
  }

  /* size=0 */
  {
    void *p = ft_calloc (10, 0);
    _s_check ("size=0 not NULL", p != NULL);
    free (p);
  }

  /* overflow protection */
  {
    void *p = ft_calloc ((size_t)-1, 2);
    _s_check ("overflow returns NULL", p == NULL);
  }

  /* single byte */
  {
    unsigned char *p = ft_calloc (1, 1);
    _s_check ("single byte zeroed", p && *p == 0);
    free (p);
  }

  /* randomized: check all bytes are zero */
  srand (time (NULL));
  for (i = 0; i < 50; i++)
    {
      size_t nmemb = rand () % 500 + 1;
      size_t size = rand () % 50 + 1;
      unsigned char *ft_p = ft_calloc (nmemb, size);
      unsigned char *libc_p = calloc (nmemb, size);
      int ok = 1;
      size_t j;
      if (!ft_p || !libc_p)
        {
          ok = 0;
        }
      else
        {
          for (j = 0; j < nmemb * size; j++)
            {
              if (ft_p[j] != 0)
                {
                  ok = 0;
                  break;
                }
            }
        }
      snprintf (label, sizeof (label), "random nmemb=%zu size=%zu", nmemb,
                size);
      _s_check (label, ok);
      free (ft_p);
      free (libc_p);
    }
}

/* ======================================
 *  strdup
 * ====================================== */

static void
_s_test_strdup (void)
{
  int i;
  char label[64];

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

  /* NULL */
  _s_check_both_crash ("strdup NULL", _s_ft_strdup_null, _s_libc_strdup_null);

  /* empty string */
  {
    char *p = ft_strdup ("");
    _s_check ("empty", p && strcmp (p, "") == 0);
    free (p);
  }

  /* returns independent copy */
  {
    char src[] = "hello";
    char *p = ft_strdup (src);
    _s_check ("independent copy", p && p != src && strcmp (p, src) == 0);
    src[0] = 'X';
    _s_check ("mutation safe", p[0] == 'h');
    free (p);
  }

  /* randomized */
  for (i = 0; i < 50; i++)
    {
      int len = rand () % 500 + 1;
      char *src = malloc (len + 1);
      int j;
      char *ft_p;
      char *libc_p;
      if (!src)
        continue;
      for (j = 0; j < len; j++)
        src[j] = 'A' + rand () % 26;
      src[len] = '\0';
      ft_p = ft_strdup (src);
      libc_p = strdup (src);
      snprintf (label, sizeof (label), "random len=%d", len);
      _s_check (label, ft_p && libc_p && strcmp (ft_p, libc_p) == 0);
      free (src);
      free (ft_p);
      free (libc_p);
    }
}

int
main (void)
{
  printf ("=== alloc functions ===\n");
  _s_test_calloc ();
  _s_test_strdup ();
  _s_print_results ();
  return (_s_fail != 0);
}