testCalcExtended.cpp File Reference

Go to the source code of this file.

Classes
class	TestCalculator
	Subclass of Calculator specialized for testing extended instructions. More...
Functions
void	fail (const char *str, int line)
void	convertDoubleToFloat (RegisterRef< float > *regOut, RegisterRef< double > *regIn)
void	convertFloatToDouble (RegisterRef< double > *regOut, RegisterRef< float > *regIn)
void	convertFloatToInt (RegisterRef< int > *regOut, RegisterRef< float > *regIn)
void	convertIntToFloat (RegisterRef< float > *regOut, RegisterRef< int > *regIn)
void	convertDecimal (RegisterRef< int32_t > *resultReg, RegisterRef< int32_t > *inputReg, RegisterRef< int32_t > *exponentReg)
	Assigns "input" * 10 ^ "exponent" to "result".
void	convertStringToExactNumber (RegisterRef< int > *regOut, RegisterRef< char * > *regIn)
void	convertExactNumberToString (RegisterRef< char * > *regOut, RegisterRef< int > *regIn)
void	convertStringToFloat (RegisterRef< float > *regOut, RegisterRef< char * > *regIn)
void	convertFloatToString (RegisterRef< char * > *regOut, RegisterRef< float > *regIn)
void	convertStringToDouble (RegisterRef< double > *regOut, RegisterRef< char * > *regIn)
void	convertDoubleToString (RegisterRef< char * > *regOut, RegisterRef< double > *regIn)
void	printTestHeader (const char *msg)
void	testConvertDoubleToFloat (double val, float expected)
void	testConvertFloatToDouble (float val, double expected)
void	testConvertFloatToIntTypes (const char *const str, float val, int expected)
void	testConvertIntTypesToFloat (const char *const str, int val, float expected)
void	testConvertDecimal (const char *const str, int val, int exp, int expected)
void	testConvertStringToExactNumber (const char *str, int expected)
void	testConvertExactNumberToString (int num, char *expected)
void	testStringToApproximateNumber (char *str, float expected)
void	testApproximateNumberToString (float expected, char *str)
void	testStringToDate (char *str, long long expected)
void	testDateToString (long long d, char *expected)
int	main (int argc, char *argv[])
boost::unit_test_framework::test_suite *	init_unit_test_suite (int, char **)
Variables
char *	ProgramName

---

Function Documentation

void convertDecimal	(	RegisterRef< int32_t > *	resultReg,
		RegisterRef< int32_t > *	inputReg,
		RegisterRef< int32_t > *	exponentReg
	)

Assigns "input" * 10 ^ "exponent" to "result".

Definition at line 91 of file testCalcExtended.cpp.

References RegisterRef< TMPLT >::value().

Referenced by testConvertDecimal().

{
    int32_t in = inputReg->value();
    int32_t exp = exponentReg->value();
    int32_t result = in;
    if (exp < 0) {
        while (exp++ < 0) {
            result /= 10;
        }
    } else {
        while (exp-- > 0) {
            result *= 10;
        }
    }
    resultReg->value(result);
}

void convertDoubleToFloat	(	RegisterRef< float > *	regOut,
		RegisterRef< double > *	regIn
	)

Definition at line 64 of file testCalcExtended.cpp.

References RegisterRef< TMPLT >::value().

Referenced by testConvertDoubleToFloat().

{
    regOut->value((float)regIn->value());
}

void convertDoubleToString	(	RegisterRef< char * > *	regOut,
		RegisterRef< double > *	regIn
	)

Definition at line 210 of file testCalcExtended.cpp.

{}

void convertExactNumberToString	(	RegisterRef< char * > *	regOut,
		RegisterRef< int > *	regIn
	)

Definition at line 147 of file testCalcExtended.cpp.

References RegisterRef< TMPLT >::pointer(), RegisterRef< TMPLT >::storage(), RegisterRef< TMPLT >::value(), and RegisterRef< TMPLT >::valueToString().

Referenced by testConvertExactNumberToString().

{
#if 1
    // TODO: Change the following proof-of-concept code into
    // TODO: something real.
    char *nullTermStr = new char[256];
    sprintf(nullTermStr, "%d", regIn->value());

    uint dstL = regOut->storage();
    uint newL = strlen(nullTermStr);

    printf("dstL = %d  newL = %d\n", dstL, newL);

    if (newL > dstL) {
        // TODO: Must check right space padding to see what, if
        // anything valid is truncated before going all wild and
        // throwing exception
        assert(0);        // TODO: Must have a valid pc here!
        // SQL99 Part 2 Section 22.1 22-001 "string data, right truncation"
        memcpy(regOut->pointer(), nullTermStr, dstL);
        regOut->putS(dstL);
        throw CalcMessage("22001", 0); // TODO: PC is bogus
        printf("ConvertExactNumberToString\n");
        assert(newL <= dstL);
    }

    regOut->putS(newL);
    memcpy(regOut->pointer(), nullTermStr, newL);
    delete [] nullTermStr;
#endif
#if 0
// TODO: JR 6/07 ... valueToStringis not implemented yet ...
// re-enabled the above ...
    const char *pString = regIn->valueToString().c_str();
    assert(pString);
    regOut->value(const_cast<char*>(pString));
#endif
}

void convertFloatToDouble	(	RegisterRef< double > *	regOut,
		RegisterRef< float > *	regIn
	)

Definition at line 70 of file testCalcExtended.cpp.

References RegisterRef< TMPLT >::value().

Referenced by testConvertFloatToDouble().

{
    regOut->value((double)regIn->value());
}

void convertFloatToInt	(	RegisterRef< int > *	regOut,
		RegisterRef< float > *	regIn
	)

Definition at line 76 of file testCalcExtended.cpp.

References RegisterRef< TMPLT >::value().

{
    regOut->value((int)regIn->value());
}

void convertFloatToString	(	RegisterRef< char * > *	regOut,
		RegisterRef< float > *	regIn
	)

Definition at line 196 of file testCalcExtended.cpp.

{
    //*str = itoa ((int) *approx);
}

void convertIntToFloat	(	RegisterRef< float > *	regOut,
		RegisterRef< int > *	regIn
	)

Definition at line 82 of file testCalcExtended.cpp.

References RegisterRef< TMPLT >::value().

Referenced by testConvertIntTypesToFloat().

{
    regOut->value((float)regIn->value());
}

void convertStringToDouble	(	RegisterRef< double > *	regOut,
		RegisterRef< char * > *	regIn
	)

Definition at line 203 of file testCalcExtended.cpp.

{
    //*regOut = strtod(*regIn, (char **)NULL);
}

void convertStringToExactNumber	(	RegisterRef< int > *	regOut,
		RegisterRef< char * > *	regIn
	)

Definition at line 111 of file testCalcExtended.cpp.

References RegisterRef< TMPLT >::pointer(), RegisterRef< TMPLT >::stringLength(), RegisterRef< TMPLT >::value(), and RegisterRef< TMPLT >::valueToString().

Referenced by testConvertStringToExactNumber().

{
#if 0
    // TODO: Wrap this code in
    uint srcL = regIn->getS();
    // TODO: Change the following proof-of-concept code into
    // TODO: something real.
    char *nullTermStr = new char[srcL + 1];
    nullTermStr[srcL + 1] = 0;
    memcpy(nullTermStr, regIn->pointer(), srcL);
    regOut->value(strtol(nullTermStr, 0, 10));
    delete [] nullTermStr;
#endif
#if 0

    // TODO: Nope this is a disaster JR 6/07 (valueToString() returns "Unimpl");
    const char *pString = regIn->valueToString().c_str();
    assert(pString);
    int iValue = atoi(pString);
    regOut->value(iValue);
#endif

    // Try original pointer casting code updated to new class interface
    // This code is the same as above
    uint srcL = regIn->stringLength();
    char *nullTermStr = new char[srcL + 1];
    nullTermStr[srcL] = 0;
    memcpy(nullTermStr, regIn->pointer(), srcL);
    regOut->value(strtol(nullTermStr, 0, 10));
    delete [] nullTermStr;
}

void convertStringToFloat	(	RegisterRef< float > *	regOut,
		RegisterRef< char * > *	regIn
	)

Definition at line 189 of file testCalcExtended.cpp.

{
    //*regOut = strtof(*regIn, (char **)NULL);
}

void fail	(	const char *	str,
		int	line
	)

Definition at line 55 of file testCalcExtended.cpp.

References ProgramName.

                                {
    assert(ProgramName);
    assert(str);
    printf("%s: unit test failed: |%s| line %d\n", ProgramName, str, line);
    exit(-1);
}

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

Definition at line 900 of file testCalcExtended.cpp.

{
    return NULL;
}

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 871 of file testCalcExtended.cpp.

References ProgramName, testConvertDecimal(), testConvertDoubleToFloat(), testConvertFloatToDouble(), testConvertFloatToIntTypes(), testConvertIntTypesToFloat(), and testConvertStringToExactNumber().

{
    ProgramName = argv[0];
    testConvertDoubleToFloat((double) 100.33, (float) 100.33);
    testConvertFloatToDouble((float) 33.3378, (double) 33.3378);
    testConvertFloatToIntTypes("s1",(float) 45.65, 45);
    testConvertFloatToIntTypes("u1",(float) 45.65, 45);
    testConvertFloatToIntTypes("s2",(float) 45.65, 45);
    testConvertFloatToIntTypes("u2",(float) 45.65, 45);
    testConvertFloatToIntTypes("s4",(float) 45.65, 45);
    testConvertFloatToIntTypes("u4",(float) 45.65, 45);
    testConvertFloatToIntTypes("s8",(float) 45.65, 45);
    testConvertFloatToIntTypes("u8",(float) 45.65, 45);
    testConvertIntTypesToFloat("s1", 4565, (float) 4565);
    testConvertIntTypesToFloat("u1", 4565, (float) 4565);
    testConvertIntTypesToFloat("s2", 4565, (float) 4565);
    testConvertIntTypesToFloat("u2", 4565, (float) 4565);
    testConvertIntTypesToFloat("s4", 4565, (float) 4565);
    testConvertIntTypesToFloat("u4", 4565, (float) 4565);
    testConvertIntTypesToFloat("s8", 4565, (float) 4565);
    testConvertIntTypesToFloat("u8", 4565, (float) 4565);
    testConvertDecimal("s2", 123, 3, 123000);

    testConvertStringToExactNumber("123", 123);
//    testConvertExactNumberToString(123, "123"); -- JR 6/07 removing this
    printf("all tests passed\n");
    exit(0);
}

void printTestHeader

(

const char *

msg

)

Definition at line 459 of file testCalcExtended.cpp.

Referenced by testConvertDecimal(), testConvertDoubleToFloat(), testConvertExactNumberToString(), testConvertFloatToDouble(), testConvertFloatToIntTypes(), testConvertIntTypesToFloat(), and testConvertStringToExactNumber().

{
    printf("=========================================================\n");
    printf("=========================================================\n");
    printf("=====\n");
    printf("=====     ");
    printf("%s", msg);
    printf("\n");
    printf("=====\n");
    printf("=========================================================\n");
    printf("=========================================================\n");
}

void testApproximateNumberToString	(	float	expected,
		char *	str
	)

Definition at line 858 of file testCalcExtended.cpp.

{
}

void testConvertDecimal	(	const char *const	str,
		int	val,
		int	exp,
		int	expected
	)

Definition at line 679 of file testCalcExtended.cpp.

References ExtendedInstructionTable::add(), Calculator::appendInstruction(), Calculator::appendRegRef(), TestCalculator::bind(), convertDecimal(), ExtendedInstructionDef::createInstruction(), RegisterReference::EInput, RegisterReference::EOutput, Calculator::exec(), StandardTypeDescriptor::fromString(), ExtendedInstructionDef::getName(), TestCalculator::getOutput(), ExtendedInstructionDef::getParameterTypes(), TestCalculator::printOutput(), printTestHeader(), TestCalculator::setInput(), STANDARD_TYPE_INT_32, and STANDARD_TYPE_INT_8.

Referenced by main().

{
    printTestHeader("testConvertDecimal()");
    ExtendedInstructionTable table;
    vector<StandardTypeDescriptorOrdinal> parameterTypes;
    // define a function
    parameterTypes.resize(3);
    parameterTypes[0] = StandardTypeDescriptor::fromString(str);
    parameterTypes[1] = StandardTypeDescriptor::fromString(str);
    parameterTypes[2] = STANDARD_TYPE_INT_8;
    table.add(
        "convert",
        parameterTypes,
        (ExtendedInstruction3<int, int, int>*) NULL,
        &convertDecimal);
    // lookup a function
    string s("convert(");
    s += str;
    s += ",";
    s += str;
    s += ",";
    s += "s1";
    s += ")";
    cout << s << endl;
    ExtendedInstructionDef *pDef = table[s];
    assert(pDef != NULL);
    assert(pDef->getName() == string("convert"));
    assert(pDef->getParameterTypes().size() == 3);
    // Set up the Calculator
    DynamicParamManager dpm;
    TestCalculator c(&dpm, true, pDef);
    c.setInput(0, &val);
    c.setInput(1, &exp);
    // setup registers
    vector<RegisterReference *> regRefs(3);
    regRefs[0] = new RegisterRef<int>(
        RegisterReference::EOutput, 0,
        STANDARD_TYPE_INT_32);
    regRefs[1] = new RegisterRef<int>(
        RegisterReference::EInput, 0,
        STANDARD_TYPE_INT_32);
    regRefs[2] = new RegisterRef<int>(
        RegisterReference::EInput, 1,
        STANDARD_TYPE_INT_32);
    c.appendRegRef(regRefs[0]);
    c.appendRegRef(regRefs[1]);
    c.appendRegRef(regRefs[2]);
    c.bind();
    // create an instruction
    //ExtendedInstruction *pInstr = pDef->createInstruction(&c, regRefs);
    ExtendedInstruction *pInstr = pDef->createInstruction(regRefs);
    assert(pInstr != NULL);
    // execute it
    c.appendInstruction(pInstr);
    c.exec();
    c.printOutput();
    int i;
    c.getOutput(0, i);
    //cout << i << endl;
    assert(abs(expected - i)<0.00001);
};

void testConvertDoubleToFloat	(	double	val,
		float	expected
	)

Definition at line 472 of file testCalcExtended.cpp.

References ExtendedInstructionTable::add(), Calculator::appendInstruction(), Calculator::appendRegRef(), TestCalculator::bind(), convertDoubleToFloat(), ExtendedInstructionDef::createInstruction(), RegisterReference::EInput, RegisterReference::EOutput, Calculator::exec(), ExtendedInstructionDef::getName(), TestCalculator::getOutput(), ExtendedInstructionDef::getParameterTypes(), TestCalculator::printOutput(), printTestHeader(), TestCalculator::setInput(), STANDARD_TYPE_DOUBLE, and STANDARD_TYPE_REAL.

Referenced by main().

{
    printTestHeader("testConvertDoubleToFloat()");
    ExtendedInstructionTable table;
    vector<StandardTypeDescriptorOrdinal> parameterTypes;
    // define a function
    parameterTypes.resize(2);
    parameterTypes[0] = STANDARD_TYPE_REAL;
    parameterTypes[1] = STANDARD_TYPE_DOUBLE;
    table.add(
        "convert",
        parameterTypes,
        (ExtendedInstruction2<float,double>*) NULL,
        &convertDoubleToFloat);
    // lookup a function
    ExtendedInstructionDef *pDef = table["convert(r,d)"];
    assert(pDef != NULL);
    assert(pDef->getName() == string("convert"));
    assert(pDef->getParameterTypes().size() == 2);
    // lookup non-existent, should return NULL
    ExtendedInstructionDef *pNonExistentDef = table["convert(d,r)"];
    assert(pNonExistentDef == NULL);
    // Set up the Calculator
    DynamicParamManager dpm;
    TestCalculator c(&dpm, true, pDef);
    c.setInput(0, &val);
    // setup registers
    vector<RegisterReference *> regRefs(2);
    regRefs[0] = new RegisterRef<float>(
        RegisterReference::EOutput, 0,
        STANDARD_TYPE_REAL);
    regRefs[1] = new RegisterRef<double>(
        RegisterReference::EInput, 0,
        STANDARD_TYPE_DOUBLE);
    c.appendRegRef(regRefs[0]);
    c.appendRegRef(regRefs[1]);
    c.bind();
    // create an instruction
    //ExtendedInstruction *pInstr = pDef->createInstruction(&c, regRefs);
    ExtendedInstruction *pInstr = pDef->createInstruction(regRefs);
    assert(pInstr != NULL);
    // execute it
    c.appendInstruction(pInstr);
    c.exec();
    c.printOutput();
    float f;
    c.getOutput(0, f);
    cout << f << endl;
    assert(fabs(expected - f) < 0.0001);
};

void testConvertExactNumberToString	(	int	num,
		char *	expected
	)

Definition at line 796 of file testCalcExtended.cpp.

References ExtendedInstructionTable::add(), Calculator::appendInstruction(), Calculator::appendRegRef(), TestCalculator::bind(), convertExactNumberToString(), ExtendedInstructionDef::createInstruction(), RegisterReference::EInput, RegisterReference::EOutput, Calculator::exec(), ExtendedInstructionDef::getName(), TestCalculator::getOutputP(), ExtendedInstructionDef::getParameterTypes(), TestCalculator::printOutput(), printTestHeader(), TestCalculator::setInput(), TestCalculator::setOutput(), STANDARD_TYPE_INT_32, and STANDARD_TYPE_VARCHAR.

{
    printTestHeader("testConvertExactNumberToString()");
    ExtendedInstructionTable table;
    vector<StandardTypeDescriptorOrdinal> parameterTypes;
    // define a function
    parameterTypes.resize(2);
    parameterTypes[0] = STANDARD_TYPE_VARCHAR;
    parameterTypes[1] = STANDARD_TYPE_INT_32;

    table.add(
        "convert",
        parameterTypes,
        (ExtendedInstruction2<char *, int32_t>*) NULL,
        &convertExactNumberToString);

    // lookup a function
    ExtendedInstructionDef *pDef = table["convert(vc,s4)"];
    assert(pDef != NULL);
    assert(pDef->getName() == string("convert"));
    assert(pDef->getParameterTypes().size() == 2);

    // Set up the Calculator
    DynamicParamManager dpm;
    TestCalculator c(&dpm, true, pDef);
    c.setInput(0, &num);
    int destLen = strlen(expected);
    char *buf = new char[destLen*2];
    memset(buf, 'X', destLen*2); // no null terminator
    c.setOutput(0, buf, destLen*2, destLen*2);

    // setup registers
    vector<RegisterReference *> regRefs(2);
    regRefs[0] = new RegisterRef<int32_t>(
        RegisterReference::EOutput, 0,
        STANDARD_TYPE_VARCHAR);
    regRefs[1] = new RegisterRef<char *>(
        RegisterReference::EInput, 0,
        STANDARD_TYPE_INT_32);
    c.appendRegRef(regRefs[0]);
    c.appendRegRef(regRefs[1]);
    c.bind();

    // create an instruction
    //ExtendedInstruction *pInstr = pDef->createInstruction(&c, regRefs);
    ExtendedInstruction *pInstr = pDef->createInstruction(regRefs);
    assert(pInstr != NULL);
    // execute it
    c.appendInstruction(pInstr);
    c.exec();
    c.printOutput();
    char *outP;
    c.getOutputP(0, outP);
    assert(outP == buf);
    assert(!strncmp(outP, expected, destLen));
    outP[destLen] = 0;
    cout << outP << endl;
}

void testConvertFloatToDouble	(	float	val,
		double	expected
	)

Definition at line 523 of file testCalcExtended.cpp.

References ExtendedInstructionTable::add(), Calculator::appendInstruction(), Calculator::appendRegRef(), TestCalculator::bind(), convertFloatToDouble(), ExtendedInstructionDef::createInstruction(), RegisterReference::EInput, RegisterReference::EOutput, Calculator::exec(), ExtendedInstructionDef::getName(), TestCalculator::getOutput(), ExtendedInstructionDef::getParameterTypes(), TestCalculator::printOutput(), printTestHeader(), TestCalculator::setInput(), STANDARD_TYPE_DOUBLE, and STANDARD_TYPE_REAL.

Referenced by main().

{
    printTestHeader("testConvertFloatToDouble()");
    ExtendedInstructionTable table;
    vector<StandardTypeDescriptorOrdinal> parameterTypes;
    // define a function
    parameterTypes.resize(2);
    parameterTypes[0] = STANDARD_TYPE_DOUBLE;
    parameterTypes[1] = STANDARD_TYPE_REAL;
    table.add(
        "convert",
        parameterTypes,
        (ExtendedInstruction2<double, float>*) NULL,
        &convertFloatToDouble);
    // lookup a function
    ExtendedInstructionDef *pDef = table["convert(d,r)"];
    assert(pDef != NULL);
    assert(pDef->getName() == string("convert"));
    assert(pDef->getParameterTypes().size() == 2);
    // Set up the Calculator
    DynamicParamManager dpm;
    TestCalculator c(&dpm, true, pDef);
    c.setInput(0, &val);
    // setup registers
    vector<RegisterReference *> regRefs(2);
    regRefs[0] = new RegisterRef<double>(
        RegisterReference::EOutput, 0,
        STANDARD_TYPE_DOUBLE);
    regRefs[1] = new RegisterRef<float>(
        RegisterReference::EInput, 0,
        STANDARD_TYPE_REAL);
    c.appendRegRef(regRefs[0]);
    c.appendRegRef(regRefs[1]);
    c.bind();
    // create an instruction
    //ExtendedInstruction *pInstr = pDef->createInstruction(&c, regRefs);
    ExtendedInstruction *pInstr = pDef->createInstruction(regRefs);
    assert(pInstr != NULL);
    // execute it
    c.appendInstruction(pInstr);
    c.exec();
    c.printOutput();
    double d;
    c.getOutput(0, d);
    cout << d << endl;
    assert(fabs(expected - d) < 0.0001);
};

void testConvertFloatToIntTypes	(	const char *const	str,
		float	val,
		int	expected
	)

Definition at line 572 of file testCalcExtended.cpp.

References ExtendedInstructionTable::add(), Calculator::appendInstruction(), Calculator::appendRegRef(), TestCalculator::bind(), convertFloatToInt(), ExtendedInstructionDef::createInstruction(), RegisterReference::EInput, RegisterReference::EOutput, Calculator::exec(), StandardTypeDescriptor::fromString(), ExtendedInstructionDef::getName(), TestCalculator::getOutput(), ExtendedInstructionDef::getParameterTypes(), TestCalculator::printOutput(), printTestHeader(), TestCalculator::setInput(), STANDARD_TYPE_INT_32, and STANDARD_TYPE_REAL.

Referenced by main().

{
    printTestHeader("testConvertFloatToIntTypes()");
    ExtendedInstructionTable table;
    vector<StandardTypeDescriptorOrdinal> parameterTypes;
    // define a function
    parameterTypes.resize(2);
    parameterTypes[0] = StandardTypeDescriptor::fromString(str);
    parameterTypes[1] = STANDARD_TYPE_REAL;
    table.add(
        "convert",
        parameterTypes,
        (ExtendedInstruction2<int, float>*) NULL,
        &convertFloatToInt);
    // lookup a function
    string s("convert(");
    s += str;
    s += ",r)";
    cout << s << endl;
    ExtendedInstructionDef *pDef = table[s];
    assert(pDef != NULL);
    assert(pDef->getName() == string("convert"));
    assert(pDef->getParameterTypes().size() == 2);
    // lookup non-existent, should return NULL
    ExtendedInstructionDef *pNonExistentDef = table["convert(d,r)"];
    assert(pNonExistentDef == NULL);
    // Set up the Calculator
    DynamicParamManager dpm;
    TestCalculator c(&dpm, true, pDef);
    c.setInput(0, &val);
    // setup registers
    vector<RegisterReference *> regRefs(2);
    regRefs[0] = new RegisterRef<int>(
        RegisterReference::EOutput, 0,
        STANDARD_TYPE_INT_32);
    regRefs[1] = new RegisterRef<float>(
        RegisterReference::EInput, 0,
        STANDARD_TYPE_REAL);
    c.appendRegRef(regRefs[0]);
    c.appendRegRef(regRefs[1]);
    c.bind();
    // create an instruction
    //ExtendedInstruction *pInstr = pDef->createInstruction(&c, regRefs);
    ExtendedInstruction *pInstr = pDef->createInstruction(regRefs);
    assert(pInstr != NULL);
    // execute it
    c.appendInstruction(pInstr);
    c.exec();
    c.printOutput();
    int d;
    c.getOutput(0, d);
    cout << d << endl;
    assert(expected == d);
};

void testConvertIntTypesToFloat	(	const char *const	str,
		int	val,
		float	expected
	)

Definition at line 627 of file testCalcExtended.cpp.

References ExtendedInstructionTable::add(), Calculator::appendInstruction(), Calculator::appendRegRef(), TestCalculator::bind(), convertIntToFloat(), ExtendedInstructionDef::createInstruction(), RegisterReference::EInput, RegisterReference::EOutput, Calculator::exec(), StandardTypeDescriptor::fromString(), ExtendedInstructionDef::getName(), TestCalculator::getOutput(), ExtendedInstructionDef::getParameterTypes(), TestCalculator::printOutput(), printTestHeader(), TestCalculator::setInput(), STANDARD_TYPE_INT_32, and STANDARD_TYPE_REAL.

Referenced by main().

{
    printTestHeader("testConvertIntTypesToFloat()");
    ExtendedInstructionTable table;
    vector<StandardTypeDescriptorOrdinal> parameterTypes;
    // define a function
    parameterTypes.resize(2);
    parameterTypes[0] = STANDARD_TYPE_REAL;
    parameterTypes[1] = StandardTypeDescriptor::fromString(str);
    table.add(
        "convert",
        parameterTypes,
        (ExtendedInstruction2<float, int>*) NULL,
        &convertIntToFloat);
    // lookup a function
    string s("convert(r,");
    s += str;
    s += ")";
    cout << s << endl;
    ExtendedInstructionDef *pDef = table[s];
    assert(pDef != NULL);
    assert(pDef->getName() == string("convert"));
    assert(pDef->getParameterTypes().size() == 2);
    // Set up the Calculator
    DynamicParamManager dpm;
    TestCalculator c(&dpm, true, pDef);
    c.setInput(0, &val);
    // setup registers
    vector<RegisterReference *> regRefs(2);
    regRefs[0] = new RegisterRef<float>(
        RegisterReference::EOutput, 0,
        STANDARD_TYPE_REAL);
    regRefs[1] = new RegisterRef<int>(
        RegisterReference::EInput, 0,
        STANDARD_TYPE_INT_32);
    c.appendRegRef(regRefs[0]);
    c.appendRegRef(regRefs[1]);
    c.bind();
    // create an instruction
    //ExtendedInstruction *pInstr = pDef->createInstruction(&c, regRefs);
    ExtendedInstruction *pInstr = pDef->createInstruction(regRefs);
    assert(pInstr != NULL);
    // execute it
    c.appendInstruction(pInstr);
    c.exec();
    c.printOutput();
    float f;
    c.getOutput(0, f);
    cout << f << endl;
    assert(expected == f);
};

void testConvertStringToExactNumber	(	const char *	str,
		int	expected
	)

Definition at line 741 of file testCalcExtended.cpp.

References ExtendedInstructionTable::add(), Calculator::appendInstruction(), Calculator::appendRegRef(), TestCalculator::bind(), convertStringToExactNumber(), ExtendedInstructionDef::createInstruction(), RegisterReference::EInput, RegisterReference::EOutput, Calculator::exec(), ExtendedInstructionDef::getName(), TestCalculator::getOutput(), ExtendedInstructionDef::getParameterTypes(), TestCalculator::printOutput(), printTestHeader(), TestCalculator::setInput(), STANDARD_TYPE_INT_32, and STANDARD_TYPE_VARCHAR.

Referenced by main().

{
    printTestHeader("testConvertStringToExactNumber()");
    ExtendedInstructionTable table;
    vector<StandardTypeDescriptorOrdinal> parameterTypes;
    // define a function
    parameterTypes.resize(2);
    parameterTypes[0] = STANDARD_TYPE_INT_32;
    parameterTypes[1] = STANDARD_TYPE_VARCHAR;

    table.add(
        "convert",
        parameterTypes,
        (ExtendedInstruction2<int32_t, char *>*) NULL,
        &convertStringToExactNumber);

    // lookup a function
    ExtendedInstructionDef *pDef = table["convert(s4,vc)"];
    assert(pDef != NULL);
    assert(pDef->getName() == string("convert"));
    assert(pDef->getParameterTypes().size() == 2);

    // Set up the Calculator
    DynamicParamManager dpm;
    TestCalculator c(&dpm, true, pDef);
    c.setInput(0, str, strlen(str));

    // setup registers
    vector<RegisterReference *> regRefs(2);
    regRefs[0] = new RegisterRef<int32_t>(
        RegisterReference::EOutput, 0,
        STANDARD_TYPE_INT_32);
    regRefs[1] = new RegisterRef<char *>(
        RegisterReference::EInput, 0,
        STANDARD_TYPE_VARCHAR);
    c.appendRegRef(regRefs[0]);
    c.appendRegRef(regRefs[1]);
    c.bind();

    // create an instruction
    //ExtendedInstruction *pInstr = pDef->createInstruction(&c, regRefs);
    ExtendedInstruction *pInstr = pDef->createInstruction(regRefs);
    assert(pInstr != NULL);
    // execute it
    c.appendInstruction(pInstr);
    c.exec();
    c.printOutput();
    int i;
    c.getOutput(0, i);
    assert(i == expected);
    cout << i << endl;
}

void testDateToString	(	long long	d,
		char *	expected
	)

Definition at line 864 of file testCalcExtended.cpp.

{
}

void testStringToApproximateNumber	(	char *	str,
		float	expected
	)

Definition at line 855 of file testCalcExtended.cpp.

{
}

void testStringToDate	(	char *	str,
		long long	expected
	)

Definition at line 861 of file testCalcExtended.cpp.

{
}

---

Variable Documentation

char* ProgramName

Definition at line 53 of file testCalcExtended.cpp.

---