---

test.h

/*
*  Name:      test.h
*  Author:    Rafael Jesus Alcantara Perez
*  Summary:   Definitons for testing C and C++ programs
*  Date:      $Date: 2003/04/14 00:18:31 $
*  Revision:  $Revision: 1.1 $
*
*  Copyright (C) 1994-2001  Rafael Jesus Alcantara Perez <rafa@dedalo-ing.com>
*
*  This program is free software; you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation; either version 2 of the License, or
*  (at your option) any later version.
*
*  This program is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*  GNU General Public License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with this program; if not, write to the Free Software
*  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
*  MA 02111-1307, USA.
*/

#ifndef _TEST__
#define _TEST__

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


/*
*  E X P O R T E D   V A R I A B L E S
*/

extern FILE*   hptTestTargetFile;


#define TEST_AVAILABLE_MEMORY  (0)
#ifdef __WATCOMC__
#include <malloc.h>
#define TEST_AVAILABLE_MEMORY  _memavl()
#endif
#ifdef __BORLAND__
#include <malloc.h>
#define TEST_AVAILABLE_MEMORY  coreleft()
#endif

#define TEST_NORMAL_FORMAT "%s \"%s\" [file <%s> line <%i>]\n"
#define TEST_WATCH_FORMAT  "%s [cpu-time <%gs> total-time <%gs> file <%s> line <%i>] \"%s\"\n"
#define TEST_MEMORY_FORMAT "%s [memory-difference <%ld> file <%s> line <%i>]\n"


#define TEST_INIT(pccTEXT)                                             \
        long unsigned int   hluiInitialFreeMemory;                     \
        clock_t             htCpuTime;                                 \
        time_t              htInitialTime;                             \
        time_t              htEndTime;                                 \
        int                 hiExitCode = 0;                            \
                                                                       \
        {                                                              \
          hptTestTargetFile = stderr;                                  \
          if ( getenv ("TESTMODE") )                                   \
          {                                                            \
            if ( !std::strcmp (getenv ("TESTMODE"), "silent_mode") )   \
            {                                                          \
              hptTestTargetFile = NULL;                                \
            }                                                          \
          }                                                            \
          if ( hptTestTargetFile )                                     \
          {                                                            \
            fprintf (hptTestTargetFile, "#TEST INIT (%s)\n", pccTEXT); \
          }                                                            \
          hluiInitialFreeMemory = TEST_AVAILABLE_MEMORY;               \
          htCpuTime             = clock();                             \
          htInitialTime         = time (NULL);                         \
          htEndTime             = time (NULL);                         \
        }

#define TEST_PASS
#define TEST_FAIL                       { hiExitCode = 1; }
#define TEST_FAIL_WITH_CODE(EXIT_CODE)  { hiExitCode = EXIT_CODE; }
#define TEST_FUNCTION(FUNCTION)         { hiExitCode |= FUNCTION; }
#define TEST_IN_SILENT_MODE             ( hptTestTargetFile == NULL )
#define TEST_START_WATCH               \
        {                              \
          htCpuTime     = clock();     \
          htInitialTime = time (NULL); \
        }
#define TEST_STOP_WATCH                    \
        {                                  \
          htCpuTime = clock() - htCpuTime; \
          htEndTime = time (NULL);         \
        }
#define TEST_DISPLAY_WATCH(pccINFO)                        \
        if ( hptTestTargetFile )                           \
        {                                                  \
          fprintf ( hptTestTargetFile                   ,  \
                    TEST_WATCH_FORMAT                   ,  \
                    ">TIME STATS"                       ,  \
                    (double) htCpuTime / CLOCKS_PER_SEC ,  \
                    difftime (htEndTime, htInitialTime) ,  \
                    __FILE__                            ,  \
                    __LINE__                            ,  \
                    pccINFO                             ); \
        }

#define TEST_NUMBERS(gREAL,g)                        \
        if ( (g) != (gREAL) )                        \
        {                                            \
          TEST_WRITE_MESSAGE ( ">ERROR IN"        ,  \
                               #g                 ,  \
                               __FILE__           ,  \
                               __LINE__           ,  \
                               TEST_NORMAL_FORMAT ); \
          TEST_FAIL;                                 \
        }

#define TEST_STRINGS(cREAL,c)                        \
        if ( std::strcmp (c, cREAL) != 0 )           \
        {                                            \
          TEST_WRITE_MESSAGE ( ">ERROR IN"        ,  \
                               c                  ,  \
                               __FILE__           ,  \
                               __LINE__           ,  \
                               TEST_NORMAL_FORMAT ); \
          TEST_FAIL;                                 \
        }

#define TEST_MEMORY_STATUS                                                      \
        if ( TEST_AVAILABLE_MEMORY != hluiInitialFreeMemory )                   \
        {                                                                       \
          TEST_WRITE_MESSAGE ( ">MEMORY ERROR"                               ,  \
                               hluiInitialFreeMemory - TEST_AVAILABLE_MEMORY ,  \
                               __FILE__                                      ,  \
                               __LINE__                                      ,  \
                               TEST_MEMORY_FORMAT                            ); \
          TEST_FAIL;                                                            \
        }

#define TEST_WRITE_MESSAGE(pccDESC, xOP, pccFILE, iLINE, pccFORMAT)               \
        {                                                                         \
          if ( hptTestTargetFile )                                                \
          {                                                                       \
            fprintf (hptTestTargetFile, pccFORMAT, pccDESC, xOP, pccFILE, iLINE); \
          }                                                                       \
        }

#define TEST_WRITE_INFO(pccFORMAT, pccTEXT)                            \
        {                                                              \
          if ( !hptTestTargetFile  )                                   \
          {                                                            \
            hptTestTargetFile = stderr;                                \
            if ( getenv ("TESTMODE") )                                 \
            {                                                          \
              if ( !std::strcmp (getenv ("TESTMODE"), "silent_mode") ) \
              {                                                        \
                hptTestTargetFile = NULL;                              \
              }                                                        \
            }                                                          \
          }                                                            \
          if ( hptTestTargetFile )                                     \
          {                                                            \
            fprintf (hptTestTargetFile, "#INFO: ");                    \
            fprintf (hptTestTargetFile, pccFORMAT, pccTEXT);           \
            fprintf (hptTestTargetFile, "\n");                         \
          }                                                            \
        }

#define TEST_END                                                                       \
        {                                                                              \
          if ( hptTestTargetFile )                                                     \
          {                                                                            \
            fprintf (hptTestTargetFile, "#TEST END\n");                                \
            if ( hptTestTargetFile != stderr )                                         \
            {                                                                          \
              fclose (hptTestTargetFile);                                              \
              hptTestTargetFile = NULL;                                                \
            }                                                                          \
            if ( hiExitCode )                                                          \
            {                                                                          \
              fprintf (hptTestTargetFile, "#TEST BAD RETURN CODE (%d)\n", hiExitCode); \
            }                                                                          \
          }                                                                            \
        }

#define TEST_RETURN_CODE  { TEST_END; return hiExitCode; }


#endif  /* not _TEST__ */

---