/**
 *  CPE 101 Fall 2007
 *  -------------------
 *  Program to test students' Lab 9.
 *
 *  @author Kevin O'Gorman
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

/* pull in the standard library string things. */
#include <string.h>

#define CATCH_SIGNED_CHAR

int mystrlen(char *);
char * mystrcpy(char*, char*);
char * mystrncpy(char*, char*, size_t);
char * mystrstr(char *, char *);
char * mystrcat(char *, char *);
char * mystrncat(char *, char *, size_t);

void check(int logic);
void newset(int setnum);
void endset(void);
void clearbufs(char *buf1, char *buf2);
void checkcpy(char *dest1, char *dest2, char *src);
void checkncpy(char *dest1, char *dest2, char *src);
void checkcat(char *dest1, char *dest2, char *src1, char *src2);
void checkncat(char *dest1, char *dest2, char *src1, char *src2);
void checkstrstr(char *s1, char *s2);
int signum(int x);

/* Gobal data.  Not usually allowed. */
int errors = 0;
int tests = 0;
int set;
int setErrors;
int test;

/* There's no safety in it, but we can try. */
#define SAFETY 4096
#define LIMLIM 256
#define CLEAR_TO '\xff'

int
main(int argc, char *argv[])
{
   char s1[] = "";
   char s2[] = "a";
   char s3[] = "ab";
   char s4[] = "xxxxabxxx";
   char s5[] = "A beverage that was almost but not quite entirely unlike tea.";
   char s6[] = "On breaking the ice:\nCandy is dandy\nBut liquor is quicker.\n"
         "         -- Ogden Nash\n";
#ifdef CATCH_SIGNED_CHAR
   char s7[] = "\xff\x7f\x80\x01";
#else
   char s7[] = "\x01\x7f\x80\xff";
#endif

   char ss1[] = "a";
   char ss2[] = "tea";
   char ss3[] = "xxxx";
   char ss4[] = "liquor";
   char ss5[] = "\x80";

   char buf1[SAFETY];
   char buf2[SAFETY];

   /* First we test "my" functs that are likely to be used by other "my"functs. */
   /* mystrlen */
   newset(1);
   check(strlen(s1) == mystrlen(s1));
   check(strlen(s2) == mystrlen(s2));
   check(strlen(s3) == mystrlen(s3));
   check(strlen(s4) == mystrlen(s4));
   check(strlen(s5) == mystrlen(s5));
   check(strlen(s6) == mystrlen(s6));
   check(strlen(s7) == mystrlen(s7));
   endset();

   /* mystrcpy */
   newset(2);
   checkcpy(buf1, buf2, s1);
   checkcpy(buf1, buf2, s2);
   checkcpy(buf1, buf2, s3);
   checkcpy(buf1, buf2, s4);
   checkcpy(buf1, buf2, s5);
   checkcpy(buf1, buf2, s6);
   checkcpy(buf1, buf2, s7);
   endset();

   /* mystrncpy */
   newset(3);
   checkncpy(buf1, buf2, s1);
   checkncpy(buf1, buf2, s2);
   checkncpy(buf1, buf2, s3);
   checkncpy(buf1, buf2, s4);
   checkncpy(buf1, buf2, s5);
   checkncpy(buf1, buf2, s6);
   checkncpy(buf1, buf2, s7);
   endset();

   /* mystrcat */
   newset(4);
   checkcat(buf1, buf2, s1, s1);
   checkcat(buf1, buf2, s1, s2);
   checkcat(buf1, buf2, s1, s3);
   checkcat(buf1, buf2, s1, s4);
   checkcat(buf1, buf2, s1, s5);
   checkcat(buf1, buf2, s1, s6);
   checkcat(buf1, buf2, s1, s7);

   checkcat(buf1, buf2, s1, s1);
   checkcat(buf1, buf2, s2, s1);
   checkcat(buf1, buf2, s3, s1);
   checkcat(buf1, buf2, s4, s1);
   checkcat(buf1, buf2, s5, s1);
   checkcat(buf1, buf2, s6, s1);
   checkcat(buf1, buf2, s7, s1);

   checkcat(buf1, buf2, s1, s7);
   checkcat(buf1, buf2, s2, s6);
   checkcat(buf1, buf2, s3, s5);
   checkcat(buf1, buf2, s4, s4);
   checkcat(buf1, buf2, s5, s3);
   checkcat(buf1, buf2, s6, s2);
   checkcat(buf1, buf2, s7, s1);
   endset();

   /* mystrncat */
   newset(5);
   checkncat(buf1, buf2, s1, s1);
   checkncat(buf1, buf2, s1, s2);
   checkncat(buf1, buf2, s1, s3);
   checkncat(buf1, buf2, s1, s4);
   checkncat(buf1, buf2, s1, s5);
   checkncat(buf1, buf2, s1, s6);
   checkncat(buf1, buf2, s1, s7);

   checkncat(buf1, buf2, s1, s1);
   checkncat(buf1, buf2, s2, s1);
   checkncat(buf1, buf2, s3, s1);
   checkncat(buf1, buf2, s4, s1);
   checkncat(buf1, buf2, s5, s1);
   checkncat(buf1, buf2, s6, s1);
   checkncat(buf1, buf2, s7, s1);

   checkncat(buf1, buf2, s1, s7);
   checkncat(buf1, buf2, s2, s6);
   checkncat(buf1, buf2, s3, s5);
   checkncat(buf1, buf2, s4, s4);
   checkncat(buf1, buf2, s5, s3);
   checkncat(buf1, buf2, s6, s2);
   checkncat(buf1, buf2, s7, s1);
   endset();

   /* mystrstr */
   newset(6);
   checkstrstr(s1, ss1);
   checkstrstr(s1, ss2);
   checkstrstr(s1, ss3);
   checkstrstr(s1, ss4);
   checkstrstr(s1, ss5);

   checkstrstr(s2, ss1);
   checkstrstr(s2, ss2);
   checkstrstr(s2, ss3);
   checkstrstr(s2, ss4);
   checkstrstr(s2, ss5);

   checkstrstr(s3, ss1);
   checkstrstr(s3, ss2);
   checkstrstr(s3, ss3);
   checkstrstr(s3, ss4);
   checkstrstr(s3, ss5);

   checkstrstr(s4, ss1);
   checkstrstr(s4, ss2);
   checkstrstr(s4, ss3);
   checkstrstr(s4, ss4);
   checkstrstr(s4, ss5);

   checkstrstr(s5, ss1);
   checkstrstr(s5, ss2);
   checkstrstr(s5, ss3);
   checkstrstr(s5, ss4);
   checkstrstr(s5, ss5);

   checkstrstr(s6, ss1);
   checkstrstr(s6, ss2);
   checkstrstr(s6, ss3);
   checkstrstr(s6, ss4);
   checkstrstr(s6, ss5);

   checkstrstr(s7, ss1);
   checkstrstr(s7, ss2);
   checkstrstr(s7, ss3);
   checkstrstr(s7, ss4);
   checkstrstr(s7, ss5);

   endset();

   if (errors)
   {
      printf("    >>> Failed %d tests out of %d.\n", errors, tests);
      return EXIT_FAILURE;
   }
   else
   {
      printf("    >>> Passed all %d tests.\n", tests);
      return EXIT_SUCCESS;
   }
}

void check(int logic)
{
   if (!logic) {
      printf("** Failed set %d test %d\n", set, test);
      errors++;
      setErrors++;
   }
   test++;
   tests++;
}

void newset(int theSet)
{
   set = theSet;
   setErrors = 0;
   test = 1;
   printf("\n");
   printf("Beginning set %d\n", set);
}

void endset(void)
{
   if (!setErrors)
   {
      printf("++ Passed set %d\n", set);
   }
   else
   {
      printf("-- Failed set %d with %d errors.\n", set, setErrors);
   }
}


void
checkcpy(char *dest1, char *dest2, char *src)
{
   char *result;
   memset(dest1, CLEAR_TO, SAFETY);
   memset(dest2, CLEAR_TO, SAFETY);
   result = mystrcpy(dest1, src);
   strcpy(dest2, src);
   check(memcmp(dest1, dest2, SAFETY) == 0 && result == dest1);
}

void
checkncpy(char *dest1, char *dest2, char *src)
{
   int i;
   int okay = 1;
   char *result;

   for (i = 0; i < LIMLIM; i++) {
      memset(dest1, CLEAR_TO, SAFETY);
      memset(dest2, CLEAR_TO, SAFETY);
      result = mystrncpy(dest1, src, test);
      strncpy(dest2, src, test);
      okay = (okay && memcmp(dest1, dest2, SAFETY) == 0
            && result == dest1);
   }
   check(okay);
}

void
checkcat(char *dest1, char *dest2, char *src1, char *src2)
{
   char *result;

   memset(dest1, CLEAR_TO, SAFETY);
   memset(dest2, CLEAR_TO, SAFETY);
   strcpy(dest1, src1);
   strcpy(dest2, src1);
   result = mystrcat(dest1, src2);
   strcat(dest2, src2);
   check(memcmp(dest1, dest2, SAFETY) == 0
         && result == dest1);
}

void
checkncat(char *dest1, char *dest2, char *src1, char *src2)
{
   int i;
   int okay = 1;
   char *result;

   for (i = 0; i < LIMLIM; i++) {
      memset(dest1, CLEAR_TO, SAFETY);
      memset(dest2, CLEAR_TO, SAFETY);
      strcpy(dest1, src1);
      strcpy(dest2, src1);
      result = mystrncat(dest1, src2, test);
      strncat(dest2, src2, test);
      okay = (okay && memcmp(dest1, dest2, SAFETY) == 0
            && result == dest1);
   }
   check(okay);
}

void
checkstrstr(char *s1, char *s2)
{
   check(strstr(s1, s2) == mystrstr(s1, s2));
}

int
signum(int x)
{
   return x < 0 ? -1 : x > 0 ? 1 : 0;
}