clTestApi.h

Go to the documentation of this file.

/*
 * Copyright (C) 2002-2012 OpenClovis Solutions Inc.  All Rights Reserved.
 *
 * This file is available  under  a  commercial  license  from  the
 * copyright  holder or the GNU General Public License Version 2.0.
 * 
 * The source code for  this program is not published  or otherwise 
 * divested of  its trade secrets, irrespective  of  what  has been 
 * deposited with the U.S. Copyright office.
 * 
 * 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.
 * 
 * For more  information, see  the file  COPYING provided with this
 * material.
 */
#ifndef _CL_TEST_H_
#define _CL_TEST_H_

#include <stdio.h>
#include "clDebugApi.h"

#ifdef __cplusplus
extern "C" {
#endif

/* See clTest.c for documentation on these global variables */
extern int clTestLogLevel;
extern int clTestOn;
extern int clTestPrintIndent;

enum 
{
  ClTestCaseMaxNameLen = 512,
  ClTestMaxNameLen     = 512
};

typedef enum /* A bit field that turns on/off types of printout */
{
    CL_TEST_PRINT_ALL = 0xffffff,
    CL_TEST_PRINT_TEST_OK = 1,
    CL_TEST_PRINT_TEST_FAILED = 2,
} ClTestVerbosity;

extern ClTestVerbosity clTestVerbosity;

/* Not part of the public API */

typedef struct 
{
  unsigned int passed;
  unsigned int failed;
  unsigned int malfunction;
  unsigned int malfPops;
  char         name[ClTestCaseMaxNameLen];
} ClTestCaseData;

/* Not part of the public API */
extern void clPushTestCase(const ClTestCaseData* tcd);
extern void clPopTestCase(ClTestCaseData* tcd);
extern int  clTestGroupFinalizeImpl();
extern void clTestPrintImpl(const char* file, int line, const char* fn, const char* c);
extern void clTestImpl(const char* file, int line, const char* function, const char * id, const char * error, int ok);

extern ClTestCaseData clCurTc;


/* All strings are printf formatted and in () */
#define this_error_indicates_missing_parens_around_string(...) __VA_ARGS__

#define clTestStripParens(...) __VA_ARGS__


#ifndef CL_NO_TEST

#define clTestGroupInitialize(name) clTestPrint(name)

#define clTestGroupFinalize() clTestGroupFinalizeImpl()

#define clTestGroupMalfunction(reason, predicate, execOnFailure) \
do { \
    if (!(predicate)) { \
        clTestPrint(reason); \
        clTestPrint(("Test Malfunction.")); \
        (void) clTestGroupFinalize(); \
        execOnFailure; \
    } \
} while(0)

#define clTestCase(name, test) \
do { \
    clTestCaseStart(name); \
    clCurTc.malfPops = 0; \
    test; \
    clTestCaseEnd((" ")); \
} while (0)


#define clTestCaseStart(testname) \
do { \
    clTestPrintIndent+=2; \
    clPushTestCase(&clCurTc); \
    clCurTc.passed=0; \
    clCurTc.failed=0; \
    clCurTc.malfunction=0; \
    clCurTc.malfPops = 1; \
    snprintf(clCurTc.name, ClTestCaseMaxNameLen, \
        this_error_indicates_missing_parens_around_string testname); \
    clTestPrint(("Test case started [%s]:\n", clCurTc.name)); \
} while(0)

#define clTestCaseNumErrors() clCurTc.failed

#define clTestCaseNumMalfunctions() clCurTc.malfunction

#define clTestCaseNumPasses() clCurTc.passed

#define clTestCaseEnd(synopsis) \
do { \
    clTestPrint(("Test case completed [%s]. " \
                 "Subcases: [%d] passed, [%d] failed, [%d] malfunction.\n" \
                 "Synopsis:\n", \
                 clCurTc.name, clCurTc.passed, \
                 clCurTc.failed, clCurTc.malfunction)); \
    clTestPrint(synopsis); \
    clTestPrintIndent-=2; \
    int malf=clCurTc.malfunction; \
    int fail = clCurTc.failed; \
    clPopTestCase(&clCurTc); \
    if (fail) \
        clCurTc.failed++; \
    else if (malf) \
        clCurTc.malfunction++; \
    else \
        clCurTc.passed++; \
} while(0)

// Will call TestCaseEnd, but you have to "return" or break, whatever
#define clTestCaseMalfunction(reason, predicate, execOnFailure) \
do { \
    if (!(predicate)) { \
        clTestPrint(("Test case malfunction [%s]. " \
                     "Subtests: [%d] Passed, [%d] Failed.\n" \
                     "Malfunction reason:\n", \
                     clCurTc.name, clCurTc.passed, clCurTc.failed)); \
        clTestPrint(reason); \
        if (clCurTc.malfPops) clPopTestCase(&clCurTc); \
        clCurTc.malfunction++; \
        execOnFailure; \
    }  \
} while(0)

#define clTest(string, predicate, errorPrintf)\
do{ \
    char __id[ClTestMaxNameLen]; \
    char __error[ClTestMaxNameLen]=""; \
    int __ok = predicate; \
    snprintf(__id, ClTestMaxNameLen, \
             this_error_indicates_missing_parens_around_string string); \
    if (!__ok) \
        snprintf(__error, ClTestMaxNameLen, \
            this_error_indicates_missing_parens_around_string errorPrintf); \
    clTestImpl(__FILE__, __LINE__, __FUNCTION__, __id, __error, __ok); \
} while(0)

// do { clTestPrint(string); { int result = (predicate); if (result) { clCurTc.passed++; clTestPrint((": Ok\n")); } else { clCurTc.failed++; clTestPrint((": %s:%d: Test (" #predicate ") failed.  ", __FILE__, __LINE__)); clTestPrint(errorPrintf); clTestPrint(("\n")); } } } while(0)

#define clTestExecOnFailure(string, predicate, errorPrintf, execOnFailure) \
do { \
    clTestPrint(string); \
    { \
        int result = (predicate); \
        if (result) { \
            clCurTc.passed++; \
            clTestPrint((": Ok\n")); \
        } else { \
            clCurTc.failed++; \
            clTestPrint((": %s:%d: Test (" #predicate ") failed.  ", \
                         __FILE__, __LINE__)); \
            clTestPrint(errorPrintf); \
            clTestPrint(("\n")); \
            execOnFailure; \
        } \
    } \
} while(0)

#define clTestFailed(__string) clTestFailedAt(__FILE__, __LINE__,__string)

#define clTestFailedAt(__file, __line, __string) \
do { \
    clCurTc.failed++; \
    clTestPrint((": %s:%d: Test failed.  ", __file, __line)); \
    clTestPrint(__string); \
    clTestPrint(("\n")); \
} while(0)

#define clTestSuccess(__string) clTestSuccessAt(__FILE__, __LINE__, __string) 

#define clTestSuccessAt(__file, __line, __string) \
{ \
    clCurTc.passed++; \
    clTestPrintAt(__file,__line, __FUNCTION__, __string); \
    clTestPrintAt(__file,__line, __FUNCTION__, (": Ok\n")); \
} while (0)



#define clTestPrint(x) clTestPrintAt(__FILE__, __LINE__, __FUNCTION__, x)

#define clTestPrintAt(__file, __line, __function, x) \
do { \
    char __tempstr[2048]; \
    snprintf(__tempstr,2048, \
             this_error_indicates_missing_parens_around_string x); \
    clTestPrintImpl(__file, __line, __function,__tempstr); \
    CL_DEBUG_PRINT(clTestLogLevel, x); \
} while(0)

#else

/* Make all macros a noop if CL_NO_TEST is defined */
#define clTestGroupInitialize(name) do{ } while(0)
#define clTestGroupFinalize() do{ } while(0)
#define clTestGroupMalfunction(reason, predicate, execOnFailure) do{ } while(0)
#define clTestCase(name, test) do{ } while(0)
#define clTestCaseStart(testname)  do{ } while(0)
#define clTestCaseNumErrors() 0
#define clTestCaseNumMalfunctions() 0
#define clTestCaseNumPasses() 0
#define clTestCaseEnd(synopsis) do{ } while(0)
#define clTestCaseMalfunction(reason, predicate, execOnFailure) do{ } while(0)
#define clTest(string, predicate, errorPrintf) do{ } while(0)
#define clTestExecOnFailure(string, predicate, errorPrintf, execOnFailure) do{ } while(0)
#define clTestFailed(string) do{ } while(0)
#define clTestSuccess(string) do{ } while(0)
#define clTestPrint(x) do{ } while(0)

#define clTestPrintAt(__file, __line, __function, x) do{ } while(0)
#define clTestSuccessAt(__file, __line, __string) do{ } while(0)
#define clTestFailedAt(__file, __line, __string) do{ } while(0)
#endif

#ifdef __cplusplus
}
#endif

#endif