/* ---------------------------------------------------------------------
   (c) ED 2001-2008
   Project      : CLIB
   Function     : Unit test for the TOK module
   Module       : TOK
   File         : TTOK.C
   Created      : 11-03-2001
   Modified     : 29-05-2008
   --------------------------------------------------------------------- */

/* ---------------------------------------------------------------------
   Log

   1.1 - 29-05-2008 *TOK* becomes *tok*. Ascending compatibility is preserved
   1.0 - 11-03-2001 Initial version
   0.0 - 11-03-2001 Created

   --------------------------------------------------------------------- */

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

#include "ed/inc/sysalloc.h"
#include "ed/inc/sys.h"
#include "ed/inc/tok.h"

/* macros ============================================================== */

#define MODULE "TTOK"
#define VER "1.1"
#define ID "TTOK Module \"C\" (c) ED 2001-2008"

#define OUT "CON"
/* #define OUT "COM1" */
/* #define OUT "LOG.TXT" */

#define DQ "\""

/* constants =========================================================== */
/* types =============================================================== */
/* structures ========================================================== */
/* private data ======================================================== */
/* private functions =================================================== */

/* ---------------------------------------------------------------------
   test_err()
   ---------------------------------------------------------------------
   tests and prints out the current error number
   ---------------------------------------------------------------------
   E :
   S :
   --------------------------------------------------------------------- */
static void test_err (tok_s * const pTok, tok_err_e const err)
{
   if (pTok != NULL)
   {
      if (err)
      {
         tok_err_e tok_err = tok_errno (pTok);

         printf ("*** TOK ERROR *** #%d %s\n"
                 ,(int) tok_err
                 ,(char *) tok_serr (tok_err));
      }
   }
   else
   {
      printf ("*** TOK ERROR *** #%d %s\n"
              ,(int) err
              ,(char *) tok_serr (err));
   }
}

/* ---------------------------------------------------------------------
   cb_list()
   ---------------------------------------------------------------------

   ---------------------------------------------------------------------
   E :
   S :
   --------------------------------------------------------------------- */
static int cb_list (char const *s, size_t rank, void *puser)
{
   int err = 0;
   if (s)
   {
      printf ("[%lu] '%s' (User='%s')\n"
              ,(unsigned long) rank
              ,(char *) s
              ,(char *) puser);
   }
   else
   {
      printf ("[%lu] '' (User='%s')\n"
              ,(unsigned long) rank
              ,(char *) puser);
   }
   return err;
}


/* ---------------------------------------------------------------------
   test_list()
   ---------------------------------------------------------------------
   test the list
   ---------------------------------------------------------------------
   E :
   S :
   --------------------------------------------------------------------- */
static void test_list (tok_s * const pTok)
{
   if (pTok != NULL)
   {
      tok_info_s list;

      tok_err_e err = tok_get (pTok, &list);
      test_err (pTok, err);

      printf ("test_list\n");
      {
         int i;

         for (i = 0; i < list.argc; i++)
         {
            printf ("[%d] '%s'\n", i, list.argv[i]);
         }
      }
   }
}

/* ---------------------------------------------------------------------
   test()
   ---------------------------------------------------------------------
   Test functions
   ---------------------------------------------------------------------
   E :
   S :
   --------------------------------------------------------------------- */
static int test (char const *s, char const *const sep, char const *str_sep)
{
   int err;
   tok_s *pTok = tok_create (s, sep, str_sep);

   if (pTok)
   {
      err = tok_list (pTok, cb_list, (char *) "user");

      test_err (pTok, err);

      test_list (pTok);

      tok_delete (pTok), pTok=NULL;
   }
   else
   {
      if (s)
      {
         puts ("*** string length null ***");
      }
      else
      {
         puts ("*** no string ***");
      }
      err = 1;
   }
   return err;
}

/* entry points ======================================================== */

/* ---------------------------------------------------------------------
   main()
   ---------------------------------------------------------------------
   Main program
   ---------------------------------------------------------------------
   E :
   S :
   --------------------------------------------------------------------- */
int main (void)
{
   int err = EXIT_SUCCESS;

   freopen (OUT, "w", stdout);
   freopen (OUT, "w", stderr);

   {
      static char Trace[1 << 9];

      sys_mem_init (Trace, sizeof Trace, TRACE_OFF, NULL);

      printf ("Testing [%s Ver %s]\n", tok_sid (), tok_sver ());

      {
         static const char *const as[] =
         {
            NULL
            ,""
            ,";"
            ,";;"
            ,"1;"
            ,";2"
            ,"1;2"
            ,"1;2;"
            ,"1;2;3"
            ,"1;2;3;4;5;6"
            ,"1;2;3;"DQ"45"DQ";6"
            ,"1;2;3;"DQ"4;5"DQ";6"
#if 0
#endif
#if 0
            ,"<1>::1::Track-No05.mp3::2/20/2002::21:30:48::2/20/2002::21:30:47::0"
#endif
#if 1

            , DQ DQ                            /* "" */
            , DQ "a" DQ                        /* "a" */
            , DQ "a" DQ ";" DQ "b" DQ          /* "a" "b" */
            , DQ "a;b" DQ                      /* "a;b" */
            , DQ "a;b" DQ ";" DQ "c;d" DQ      /* "a;b" "c;d" */
            , DQ "a" DQ ";1"                   /* "a" 1 */
            , DQ "a;b" DQ ";1;2"               /* "a;b" 1 2 */

/* malformed string (not detected at the moment) */
            , DQ                               /* " */
            , DQ "a"                           /* "a */
            , "a" DQ                           /* a" */
#if 0
            /* OK */

            /* KO ... */
#endif
#endif

         };
         size_t i;

         for (i = 0; i < NELEM (as); i++)
         {
#if 1
            err = test (as[i], ";", "\"");
#else
            err = test (as[i], "::", NULL);
#endif
            printf ("\n");
         }
      }


      if (err != 0)
      {
         err = EXIT_FAILURE;
      }

      sys_mem_trace ();

   }

#ifdef DEVCPP
   system ("pause");
#endif

   return err;
}


/* File generated by 'NEW.EXE' Ver 1.28 (c) ED 1998-2001 */