testNoisyArithmetic.cpp File Reference

Go to the source code of this file.

Classes
struct	TOp
struct	TType
union	TSuper
class	Noisy_no_error
Enumerations
enum	{ SHORT_MSG_LENGTH = 7, LONG_MSG_LENGTH = 512, FIXED_ARGS = 3 }
Functions
int	min (int a, int b)
template<typename TMPL>
bool	DoOp_0 (int iOpCode, int iExType, const char *pExpected, char *pOp0, char *pOp1, char *pResult)
static bool	DoOp_1 (int iTypeCode, int iOpCode, int iExType, const char *pExpected, char *pOp0, char *pOp1, char *pResult)
static bool	DoOp_2 (int iType, int iOpCode, int iExType, const char *pExpected, char *pOp0, char *pOp1, char *pResult)
template<typename TMPL>
bool	SetConstant (const char *pConstant, TMPL *pData, int iLine)
static bool	SetConstant (const char *pConstant, int iTypeCode, char *pData, int iLine)
static bool	ReadArgument (int iLine, const char *pFile, int iArg, TType &tType, const char *ppArgs[], TSuper &t2Read)
static bool	RunTest (int iLine, const char *pFile, const char *ppArgs[], int iArgCount)
static char *	CanonifyArg (char *pArg)
static bool	ProcessALine (int iLine, const char *pFile, char *pLine, size_t tLength)
int	InputFromStream (const char *pFilename)
int	ProcessCppLine (int iLine, const char *pInputFileName, const char *pLine, int iLength)
int	main (int iArgc, const char *ppArgv[])
boost::unit_test_framework::test_suite *	init_unit_test_suite (int, char **)
Variables
static struct TOp	g_Ops []
static struct TType	g_Types []
static int	g_iProgramReturnCode = 0

---

Enumeration Type Documentation

anonymous enum

Enumerator:

SHORT_MSG_LENGTH
LONG_MSG_LENGTH
FIXED_ARGS

Definition at line 104 of file testNoisyArithmetic.cpp.

     {
    SHORT_MSG_LENGTH = 7,
    LONG_MSG_LENGTH/*hack*/ = 512,
    FIXED_ARGS = 3
};

---

Function Documentation

static char* CanonifyArg

(

char *

pArg

)

[static]

Definition at line 444 of file testNoisyArithmetic.cpp.

Referenced by ProcessALine().

{
    assert(pArg);
    while (*pArg && *pArg!=':' && isspace(*pArg)) {
        pArg++;    /* trim leading whitespace */
    }
    if (*pArg == '#') {
        return 0;
    }
    return pArg;
}

template<typename TMPL>

bool DoOp_0	(	int	iOpCode,
		int	iExType,
		const char *	pExpected,
		char *	pOp0,
		char *	pOp1,
		char *	pResult
	)

Definition at line 146 of file testNoisyArithmetic.cpp.

References Noisy< TMPL >::add(), Noisy< TMPL >::div(), Noisy< TMPL >::mul(), Noisy< TMPL >::neg(), and Noisy< TMPL >::sub().

{
    TMPL *tOp0 = reinterpret_cast<TMPL *>(pOp0);
    TMPL *tOp1 = reinterpret_cast<TMPL *>(pOp1);
    TMPL *tResult = reinterpret_cast<TMPL *>(pResult);
    TProgramCounter pc(0);
    switch (iOpCode) {
    case OP_ADD:
        *tResult = Noisy<TMPL>::add(pc, *tOp0, *tOp1, 0);
        break;

    case OP_SUB:
        *tResult = Noisy<TMPL>::sub(pc, *tOp0, *tOp1, 0);
        break;

    case OP_MUL:
        *tResult = Noisy<TMPL>::mul(pc, *tOp0, *tOp1, 0);
        break;

    case OP_DIV:
        *tResult = Noisy<TMPL>::div(pc, *tOp0, *tOp1, 0);
        break;

    case OP_NEG:
        *tResult = Noisy<TMPL>::neg(pc, *tOp0, 0);
        break;

    default:
        assert(0 /* op not implemented */);
    }
    switch (iExType) {
    case EX_NONE:
        return true;
    case EX_ERROR:
        throw Noisy_no_error();
        assert(0);
    case EX_DATA:
        break;
    default:
        assert(0);
    };
    const TMPL *tExpected = reinterpret_cast<const TMPL *>(pExpected);
    return (*tResult) == (*tExpected);
}

static bool DoOp_1	(	int	iTypeCode,
		int	iOpCode,
		int	iExType,
		const char *	pExpected,
		char *	pOp0,
		char *	pOp1,
		char *	pResult
	)			[static]

Definition at line 194 of file testNoisyArithmetic.cpp.

Referenced by DoOp_2().

{
    switch (iTypeCode) {
#define DOOP(type) \
    return DoOp_0<type>(iOpCode, iExType, pExpected, pOp0, pOp1, pResult); \
    break;

    case T_C:
        DOOP(char);
    case T_SC:
        DOOP(signed char);
    case T_UC:
        DOOP(unsigned char);
    case T_S:
        DOOP(short);
    case T_US:
       DOOP(unsigned short);
    case T_I32:
        DOOP(int);
    case T_UI32:
        DOOP(unsigned int);
    case T_I64:
        DOOP(long long int);
    case T_UI64:
        DOOP(unsigned long long int);
    case T_F:
        DOOP(float);
    case T_D:
        DOOP(double);
    case T_LD:
        DOOP(long double);
#undef DOOP
    default:
        assert(0 /* type not implemented */);
    }
    return false;    /* !++(__compiler_unhappy)++ */
}

static bool DoOp_2	(	int	iType,
		int	iOpCode,
		int	iExType,
		const char *	pExpected,
		char *	pOp0,
		char *	pOp1,
		char *	pResult
	)			[static]

Definition at line 235 of file testNoisyArithmetic.cpp.

References DoOp_1(), g_Types, SHORT_MSG_LENGTH, and CalcMessage::str.

Referenced by RunTest().

{
    try {
        bool bRet = DoOp_1(
            g_Types[iType].iCode,
            iOpCode,
            iExType,
            pExpected,
            pOp0,
            pOp1,
            pResult);
        sprintf(pResult, g_Types[iType].pPrintfFormat, *pResult);
        return bRet;
    } catch (Noisy_no_error &e) {
        sprintf(pResult, g_Types[iType].pPrintfFormat, *pResult);
        return false;
    } catch (CalcMessage &msg) {
        *pResult = '!';
        strncpy(&(pResult[1]), msg.str, SHORT_MSG_LENGTH - 2);
        pResult[SHORT_MSG_LENGTH - 1] = '\0';
        if (iExType == EX_NONE) {
            return true;
        }
        return strcmp(pResult, pExpected) == 0;
    }
}

boost::unit_test_framework::test_suite* init_unit_test_suite	(	int	,
		char **
	)

Definition at line 611 of file testNoisyArithmetic.cpp.

{
    return NULL;
}

int InputFromStream

(

const char *

pFilename

)

Definition at line 495 of file testNoisyArithmetic.cpp.

References g_iProgramReturnCode, and ProcessALine().

Referenced by main().

{
    enum { BUF_SIZE = 1023 };
    char szBuf[BUF_SIZE + 1];
    int iLine;
    FILE *pIn = stdin;
    FILE *pIn2Close = 0;

    /* --- */
    if (strcmp(pFilename, "-")) {
        pIn = ::fopen(pFilename, "r");
        if (!pIn) {
            perror(pFilename);
            return EX_IOERR;
        }
        pIn2Close = pIn;
    } else {
        pFilename = "(stdin)";
    }

    /* --- */
    szBuf[BUF_SIZE] = '\0';
    iLine = 0;
    for (;;) {
        const char *pRead = fgets(szBuf, BUF_SIZE, pIn);
        if (!pRead) {
            if (pIn2Close) {
                ::fclose(pIn2Close);
            }
            return feof(pIn) ? g_iProgramReturnCode : EX_IOERR;
        }
        assert(pRead == szBuf);
        size_t tRead = strlen(pRead) - 1;
        iLine++;    /* line could be too long .... TODO */
        if (!tRead) {
            continue;    /* EOF exactly after BUF_SIZE chars */
        }
        if (szBuf[tRead] == '\r' || szBuf[tRead] == '\n') {
            while (szBuf[tRead] == '\r' || szBuf[tRead] == '\n') {
                szBuf[tRead--] = '\0';
            }
        }
        assert(szBuf[tRead] != '\r' && szBuf[tRead] != '\n');
        if (!*szBuf) {
            continue;
        }
        if (!ProcessALine(iLine, pFilename, szBuf, tRead)) {
            /* real error, like invalid format */
            if (pIn2Close) {
                ::fclose(pIn2Close);
            }
            return EX_DATAERR;
        }
    }

    /* --- shouldn't get here --- */
    assert(0);
    if (pIn2Close) {
        ::fclose(pIn2Close);
    }
    return 1;
}

int main	(	int	iArgc,
		const char *	ppArgv[]
	)

Definition at line 577 of file testNoisyArithmetic.cpp.

References InputFromStream().

{
    // this test is causing a seg. fault, and its not valuable as part
    // of build tests
    return 0;

    /* --- */
    if (iArgc < 1/*how?*/ || iArgc > 2) {
        fprintf(
            stderr, "Usage: %s [<filename>|-]\n", iArgc > 0 ? ppArgv[0] : "");
        ::exit(EX_USAGE);
    }

    /* --- */
    if (iArgc == 2) {
        /* read from file */
        return InputFromStream(ppArgv[1]);
    }

    /* else */
    /* read generated C++ from this file */
    int iLine = 1;
#define GENERATED_FILE "testNoisyArithmeticGen.hpp"
#define EXPR(line)                                                  \
    if (!ProcessCppLine(iLine++, GENERATED_FILE,                    \
           #line, sizeof(line) - 1))                                \
        return EX_DATAERR;
#include GENERATED_FILE
#undef EXPR
    return 0;
}

int min	(	int	a,
		int	b
	)			[inline]

Definition at line 139 of file testNoisyArithmetic.cpp.

Referenced by ByteWindow< IndexT >::advanceEnd(), CacheImpl< PageT, VictimPolicyT >::allocatePages(), LhxHashTable::calculateNumSlots(), ReshapeExecStream::castOutput(), TupleDescriptor::compareTuples(), TupleDescriptor::compareTuplesKey(), VarBinaryType::compareValues(), UnicodeVarCharType::compareValues(), VarCharType::compareValues(), convertPropertyToBoost(), Database::deallocateOldPages(), LcsClusterDump::dump(), CastCast< RESULT_T, SOURCE_T >::exec(), ExternalSortRunLoader::fetch(), RandomAllocationSegmentBase::format(), SkipNumberStream::getMaxRowCount(), LbmUnionWorkspace::getSegment(), LbmEntry::getSizeBounds(), FlatFileExecStreamImpl::handleTuple(), hexDump(), IsoStringToTime(), IsoStringToTimestamp(), FlatFileExecStreamImpl::logError(), ByteWindow< IndexT >::mergeMem(), CalcExtCastTest::minInt64String(), LbmMinusExecStream::minusSegments(), LcsClusterNodeWriter::pickCompressionMode(), ProcessCppLine(), LcsColumnReader::readCompressedBatch(), SimpleExecStreamGovernor::requestResources(), SetConstant(), SqlExactMax(), SqlStrCastToExact(), CalcExtCastTest::testCalcExtCastCharToExact(), CalcExtCastTest::testCalcExtCastStringToDecimalMinMax(), CalcExtCastTest::testCalcExtCastVarCharToExact(), CalcAssemblerTest::testIntegralNativeInstructions(), CalcAssemblerTest::testNativeInstructions(), ExecStreamTestSuite::testNestedLoopJoinExecStream(), SqlStringTest::testSqlStringCastToChar(), SqlStringTest::testSqlStringCastToVarChar(), CalcAssemblerTest::testStandardTypes(), TimestampToIsoString(), CalcCastTest::UnderflowSet(), TupleAccessor::unmarshal(), LhxHashKeyAccessor::unpack(), LhxHashDataAccessor::unpack(), WinAggMin(), TupleTest::writeMinData(), and CalcAssemblerTestCase::writeMinData().

{
    return (a < b) ? a : b;
}

static bool ProcessALine	(	int	iLine,
		const char *	pFile,
		char *	pLine,
		size_t	tLength
	)			[static]

Definition at line 457 of file testNoisyArithmetic.cpp.

References CanonifyArg(), and RunTest().

Referenced by InputFromStream(), and ProcessCppLine().

{
    enum { MAX_ARGS = 11 };
    const char *ppArgs[MAX_ARGS];
    int iArgCount = 0;
    char *pStart = pLine;
    for (int i = 0; iArgCount < MAX_ARGS; i++) {
        if (!pLine[i] || pLine[i] == ':') {
            ppArgs[iArgCount] = CanonifyArg(pStart);
            if (!ppArgs[iArgCount]) {
                break;    /* rest of line is a comment */
            }
            iArgCount++;
            if (!pLine[i]) {
                break;
            }
            pLine[i] = '\0';
            pStart = &(pLine[i + 1]);
        }
    }
    assert(iArgCount <= MAX_ARGS);
    assert(iArgCount);
    iArgCount--;
    if (iArgCount < 2) {
        return true; /* comment or empty line */
    }
    if (iArgCount == MAX_ARGS) {
        fprintf(
            stderr, "Too many arguments (max=%d) at %s line %d\n",
            MAX_ARGS - 1, pFile, iLine);
        return false;
    }

    return RunTest(iLine, pFile, &(ppArgs[1]), iArgCount);
}

int ProcessCppLine	(	int	iLine,
		const char *	pInputFileName,
		const char *	pLine,
		int	iLength
	)

Definition at line 559 of file testNoisyArithmetic.cpp.

References min(), and ProcessALine().

{
    enum { BUF_SIZE = 1023 };
    char szBuf[BUF_SIZE + 1];

    /* --- */
    strncpy(szBuf, pLine, BUF_SIZE);
    szBuf[BUF_SIZE+1] ='\0';

    /* --- */
    return ProcessALine(
        iLine, pInputFileName, szBuf,
        min(iLength, BUF_SIZE));
}

static bool ReadArgument	(	int	iLine,
		const char *	pFile,
		int	iArg,
		TType &	tType,
		const char *	ppArgs[],
		TSuper &	t2Read
	)			[static]

Definition at line 323 of file testNoisyArithmetic.cpp.

References TSuper::_cptr, TType::iCode, TType::pScanfFormat, and SetConstant().

Referenced by RunTest().

{
    const char *pValue = ppArgs[iArg];
    assert(pValue);
    if (*pValue=='&') {
        return SetConstant(&(pValue[1]), tType.iCode, t2Read._cptr, iLine);
    } else if (1 != sscanf(pValue, tType.pScanfFormat, t2Read._cptr)) {
        fprintf(
            stderr, "Error in argument %d at %s line %d\n", iArg,
            pFile, iLine);
        return false;
    }
    return true;
}

static bool RunTest	(	int	iLine,
		const char *	pFile,
		const char *	ppArgs[],
		int	iArgCount
	)			[static]

Definition at line 341 of file testNoisyArithmetic.cpp.

References TSuper::_cptr, DoOp_2(), FIXED_ARGS, g_iProgramReturnCode, g_Ops, g_Types, TOp::iArity, TType::pName, TOp::pName, ReadArgument(), and SHORT_MSG_LENGTH.

Referenced by ProcessALine().

{
    // op type expected-result op0 [op1]
    if (iArgCount < FIXED_ARGS) {
        fprintf(
            stderr, "Bad number of arguments (%d) at %s line %d\n",
            iArgCount, pFile, iLine);
        return false;
    }
    assert(ppArgs[0]);
    int iOp = -1;
    int iArity = -1;
    for (int i = 0; g_Ops[i].pName; i++) {
        if (!strcasecmp(ppArgs[0], g_Ops[i].pName)) {
            iOp = i;
            break;
        }
    }
    if (iOp == -1) {
        fprintf(
            stderr, "No such operation '%s' at %s line %d\n",
            ppArgs[0], pFile, iLine);
        return false;
    }
    iArity = g_Ops[iOp].iArity;
    if (iArgCount < (FIXED_ARGS + iArity)) {
        fprintf(
            stderr,
            "Bad number of arguments (%d) for operation '%s' at %s line %d\n",
            iArgCount - FIXED_ARGS, g_Ops[iOp].pName, pFile, iLine);
        return false;
    }
    int iType = -1;
    assert(ppArgs[1]);
    for (int i = 0; g_Types[i].pName; i++) {
        if (!strcasecmp(ppArgs[1], g_Types[i].pName)) {
            iType = i;
            break;
        }
    }
    if (iType == -1) {
        fprintf(
            stderr, "No such type '%s' at %s line %d\n",
            ppArgs[1], pFile, iLine);
        return false;
    }

    /* --- Its important that this union is used and not a char * buffer
    to ensure correct [d/q]word alighnment of certain variables
    --- */
    TSuper tExpected;
    TSuper tOp0;
    TSuper tOp1;
    TSuper tResult;

    /* --- */
    int iExType;
    switch (*ppArgs[2]) {
    case '*':
        iExType = EX_NONE;
        break;
    case '!':
        iExType = EX_ERROR;
        strncpy(tExpected._cptr, ppArgs[2], SHORT_MSG_LENGTH);
        break;
    default:
        if (!ReadArgument(iLine, pFile, 2, g_Types[iType], ppArgs, tExpected)) {
            return false;
        }
        iExType = EX_DATA;
    }
    if (iArity > 0
        && !ReadArgument(iLine, pFile, 3, g_Types[iType], ppArgs, tOp0))
    {
        return false;
    }
    if (iArity > 1
        && !ReadArgument(iLine, pFile, 4, g_Types[iType], ppArgs, tOp1))
    {
        return false;
    }

    /* --- */
    if (!DoOp_2(
        iType, g_Ops[iOp].iOpCode, iExType,
        tExpected._cptr, tOp0._cptr, tOp1._cptr, tResult._cptr))
    {
        fprintf(stdout, "Line %d: Calculated result [", iLine);
        fprintf(stdout, "%s", tResult._cptr);
        fprintf(stdout, "] does not match expected [");
        fprintf(stdout, "%s", ppArgs[2]);
        fprintf(stdout, "].\n");

        fflush(stdout);

        g_iProgramReturnCode = 1;
        }

    return true;
}

static bool SetConstant	(	const char *	pConstant,
		int	iTypeCode,
		char *	pData,
		int	iLine
	)			[static]

Definition at line 282 of file testNoisyArithmetic.cpp.

{
    switch (iTypeCode) {
#define DOOP(type) \
    return SetConstant<type>(pConstant, reinterpret_cast<type *>(pData), iLine)
    case T_C:
        DOOP(char);
    case T_SC:
        DOOP(signed char);
    case T_UC:
        DOOP(unsigned char);
    case T_S:
        DOOP(short);
    case T_US:
        DOOP(unsigned short);
    case T_I32:
        DOOP(int);
    case T_UI32:
        DOOP(unsigned int);
    case T_I64:
        DOOP(long long int);
    case T_UI64:
        DOOP(unsigned long long int);
    case T_F:
        DOOP(float);
    case T_D:
        DOOP(double);
    case T_LD:
        DOOP(long double);
#undef DOOP
    default:
        assert(0);
        return false;
    }
}

template<typename TMPL>

bool SetConstant	(	const char *	pConstant,
		TMPL *	pData,
		int	iLine
	)

Definition at line 266 of file testNoisyArithmetic.cpp.

References max(), and min().

Referenced by ReadArgument().

{
    assert(pConstant);
    if (false) {
    } else if (!strcmp(pConstant, "MAX")) {
        *pData = std::numeric_limits<TMPL>::max();
    } else if (!strcmp(pConstant, "MIN")) {
        *pData = std::numeric_limits<TMPL>::min();
    } else {
        fprintf(stderr, "Invalid constant '%s' at line %d\n", pConstant, iLine);
        return false;
    }
    return true;
}

---

Variable Documentation

int g_iProgramReturnCode = 0 [static]

Definition at line 136 of file testNoisyArithmetic.cpp.

Referenced by InputFromStream(), and RunTest().

struct TOp g_Ops[] [static]

Referenced by RunTest().

struct TType g_Types[] [static]

Referenced by DoOp_2(), and RunTest().

---