calctest

CalcExtWinAggFuncTest.cpp File Reference

Go to the source code of this file.

Classes

class  CalcExtWinAggFuncTest

Functions

template<typename DTYPE>
void WinAggAddTest (TupleDataWithBuffer *winAggTuple, DTYPE testData[][SAMPLE_SIZE], StandardTypeDescriptorOrdinal dType, void(*check)(TupleDataWithBuffer *, DTYPE[][SAMPLE_SIZE], int))
template<typename DTYPE>
void WinAggDropTest (TupleDataWithBuffer *winAggTuple, DTYPE testData[][SAMPLE_SIZE], StandardTypeDescriptorOrdinal dType, void(*check)(TupleDataWithBuffer *, DTYPE[][SAMPLE_SIZE], int))
template<typename DTYPE>
void WinAggAddTestStr (TupleDataWithBuffer *winAggTuple, DTYPE testData[][STR_SAMPLE_SIZE], StandardTypeDescriptorOrdinal dType, void(*check)(TupleDataWithBuffer *, DTYPE[][STR_SAMPLE_SIZE], int))
template<typename DTYPE>
void WinAggDropTestStr (TupleDataWithBuffer *winAggTuple, DTYPE testData[][STR_SAMPLE_SIZE], StandardTypeDescriptorOrdinal dType, void(*check)(TupleDataWithBuffer *, DTYPE[][STR_SAMPLE_SIZE], int))
void checkAddInt (TupleDataWithBuffer *outTuple, int64_t testData[][SAMPLE_SIZE], int index)
void checkDropInt (TupleDataWithBuffer *outTuple, int64_t testData[][SAMPLE_SIZE], int index)
void checkAddDbl (TupleDataWithBuffer *outTuple, double testData[][SAMPLE_SIZE], int index)
void checkDropDbl (TupleDataWithBuffer *outTuple, double testData[][SAMPLE_SIZE], int index)
void checkDropStr (TupleDataWithBuffer *outTuple, char *testData[][STR_SAMPLE_SIZE], int index)
void checkEqualStr (TupleDatum const &tuple, const char *expected)
 Helper function to compare a tuple with an expected string value.
void checkStr (TupleDataWithBuffer *outTuple, const char *testData[][STR_SAMPLE_SIZE], int index)
 FENNEL_UNIT_TEST_SUITE (CalcExtWinAggFuncTest)

Variables

static const int64_t INT_TEST_MIN = 2
static const int64_t INT_TEST_MAX = 105
static int64_t intTestData [][SAMPLE_SIZE]
static const double DBL_TEST_MIN = 1.5
static const double DBL_TEST_MAX = 874.5
static double dblTestData [][SAMPLE_SIZE]
static const char * str1 = "abcd"
static const char * str2 = "qrst"
static const char * str3 = "abc "
static const char * str4 = "noot"
static const char * strAddTestData [][STR_SAMPLE_SIZE]
static const char * strDropTestData [][STR_SAMPLE_SIZE]
static vector< TupleData * > testTuples

Function Documentation

void checkAddDbl ( TupleDataWithBuffer *  outTuple,
double  testData[][SAMPLE_SIZE],
int  index 
)

Definition at line 536 of file CalcExtWinAggFuncTest.cpp.

Referenced by CalcExtWinAggFuncTest::testCalcExtMinMaxDbl().

00540 {
00541     int64_t rowCount =
00542         *(reinterpret_cast<const int64_t*>((*outTuple)[0].pData));
00543     BOOST_CHECK_EQUAL(index + 1, rowCount);
00544 
00545     double tdSum = testData[SUM_INDEX][index];
00546     double calcSum = *(reinterpret_cast<const double*>((*outTuple)[1].pData));
00547     BOOST_CHECK_CLOSE(tdSum, calcSum, 0.1);
00548 
00549     double tdMin = testData[MIN_INDEX][index];
00550     double calcMin = *(reinterpret_cast<const double*>((*outTuple)[3].pData));
00551     BOOST_CHECK_EQUAL(tdMin, calcMin);
00552 
00553     double tdMax = testData[MAX_INDEX][index];
00554     double calcMax = *(reinterpret_cast<const double*>((*outTuple)[4].pData));
00555     BOOST_CHECK_EQUAL(tdMax, calcMax);
00556 }

void checkAddInt ( TupleDataWithBuffer *  outTuple,
int64_t  testData[][SAMPLE_SIZE],
int  index 
)

Definition at line 484 of file CalcExtWinAggFuncTest.cpp.

Referenced by CalcExtWinAggFuncTest::testCalcExtMinMaxInt().

00488 {
00489     BOOST_CHECK_EQUAL(
00490         index + 1,
00491         *(reinterpret_cast<const int64_t*>((*outTuple)[0].pData)));
00492     BOOST_CHECK_EQUAL(
00493         testData[SUM_INDEX][index],
00494         *(reinterpret_cast<const int64_t*>((*outTuple)[1].pData)));
00495     BOOST_CHECK_EQUAL(
00496         testData[MIN_INDEX][index],
00497         *(reinterpret_cast<const int64_t*>((*outTuple)[3].pData)));
00498     BOOST_CHECK_EQUAL(
00499         testData[MAX_INDEX][index],
00500         *(reinterpret_cast<const int64_t*>((*outTuple)[4].pData)));
00501     BOOST_CHECK_EQUAL(
00502         testData[FV_INDEX][index],
00503         *(reinterpret_cast<const int64_t*>((*outTuple)[5].pData)));
00504     BOOST_CHECK_EQUAL(
00505         testData[TEST_DATA_INDEX][index],
00506         *(reinterpret_cast<const int64_t*>((*outTuple)[6].pData)));
00507 }

void checkDropDbl ( TupleDataWithBuffer *  outTuple,
double  testData[][SAMPLE_SIZE],
int  index 
)

Definition at line 558 of file CalcExtWinAggFuncTest.cpp.

Referenced by CalcExtWinAggFuncTest::testCalcExtMinMaxDbl().

00562 {
00563     if (index > 0) {
00564         int64_t calcRowCount =
00565             *(reinterpret_cast<const int64_t*>((*outTuple)[0].pData));
00566         BOOST_CHECK_EQUAL(index, calcRowCount);
00567 
00568         double tdSum = testData[SUM_INDEX][index - 1];
00569         double calcSum =
00570             *(reinterpret_cast<const double*>((*outTuple)[1].pData));
00571         BOOST_CHECK_CLOSE(tdSum, calcSum, 0.1);
00572 
00573         double tdMin = testData[MIN_INDEX][index - 1];
00574         double calcMin =
00575             *(reinterpret_cast<const double*>((*outTuple)[3].pData));
00576         BOOST_CHECK_CLOSE(tdMin, calcMin, 0.1);
00577 
00578         double tdMax = testData[MAX_INDEX][index - 1];
00579         double calcMax =
00580             *(reinterpret_cast<const double*>((*outTuple)[4].pData));
00581         BOOST_CHECK_CLOSE(tdMax, calcMax, 0.1);
00582     }
00583 }

void checkDropInt ( TupleDataWithBuffer *  outTuple,
int64_t  testData[][SAMPLE_SIZE],
int  index 
)

Definition at line 509 of file CalcExtWinAggFuncTest.cpp.

Referenced by CalcExtWinAggFuncTest::testCalcExtMinMaxInt().

00513 {
00514     if (index > 0) {
00515         BOOST_CHECK_EQUAL(
00516             index,
00517             *(reinterpret_cast<const int64_t*>((*outTuple)[0].pData)));
00518         BOOST_CHECK_EQUAL(
00519             testData[SUM_INDEX][index - 1],
00520             *(reinterpret_cast<const int64_t*>((*outTuple)[1].pData)));
00521         BOOST_CHECK_EQUAL(
00522             testData[MIN_INDEX][index - 1],
00523             *(reinterpret_cast<const int64_t*>((*outTuple)[3].pData)));
00524         BOOST_CHECK_EQUAL(
00525             testData[MAX_INDEX][index - 1],
00526             *(reinterpret_cast<const int64_t*>((*outTuple)[4].pData)));
00527         BOOST_CHECK_EQUAL(
00528             testData[TEST_DATA_INDEX][SAMPLE_SIZE - index],
00529             *(reinterpret_cast<const int64_t*>((*outTuple)[5].pData)));
00530         BOOST_CHECK_EQUAL(
00531             testData[LV_INDEX][index - 1],
00532             *(reinterpret_cast<const int64_t*>((*outTuple)[6].pData)));
00533     }
00534 }

void checkDropStr ( TupleDataWithBuffer *  outTuple,
char *  testData[][STR_SAMPLE_SIZE],
int  index 
)

Definition at line 585 of file CalcExtWinAggFuncTest.cpp.

00589 {
00590 }

void checkEqualStr ( TupleDatum const &  tuple,
const char *  expected 
)

Helper function to compare a tuple with an expected string value.

Definition at line 593 of file CalcExtWinAggFuncTest.cpp.

References TupleDatum::cbData, and TupleDatum::pData.

Referenced by checkStr().

00596 {
00597     const char *rtnStr =
00598         reinterpret_cast<const char*>(const_cast<PBuffer>(tuple.pData));
00599     if (NULL != expected && NULL != rtnStr) {
00600         const char *rtnStrEnd = rtnStr + tuple.cbData;
00601         const char *expectedEnd = expected + strlen(expected);
00602 
00603         BOOST_CHECK_EQUAL_COLLECTIONS(rtnStr, rtnStrEnd, expected, expectedEnd);
00604     } else {
00605         BOOST_CHECK(expected == rtnStr);
00606     }
00607 }

void checkStr ( TupleDataWithBuffer *  outTuple,
const char *  testData[][STR_SAMPLE_SIZE],
int  index 
)

Definition at line 609 of file CalcExtWinAggFuncTest.cpp.

References checkEqualStr().

Referenced by CalcExtWinAggFuncTest::testCalcExtMinMaxStr().

00613 {
00614     // check the MIN return value
00615     checkEqualStr((*outTuple)[1], testData[MIN_INDEX][index]);
00616 
00617     // check the MAX return value
00618     checkEqualStr((*outTuple)[2], testData[MAX_INDEX][index]);
00619 
00620     // check the FIRST_VALUE return value
00621     checkEqualStr((*outTuple)[3], testData[FV_INDEX][index]);
00622 
00623     // check the LAST_VALUE return value
00624     checkEqualStr((*outTuple)[4], testData[LV_INDEX][index]);
00625 }

FENNEL_UNIT_TEST_SUITE ( CalcExtWinAggFuncTest   ) 

template<typename DTYPE>
void WinAggAddTest ( TupleDataWithBuffer *  winAggTuple,
DTYPE  testData[][SAMPLE_SIZE],
StandardTypeDescriptorOrdinal  dType,
void(*)(TupleDataWithBuffer *, DTYPE[][SAMPLE_SIZE], int)  check 
)

Definition at line 240 of file CalcExtWinAggFuncTest.cpp.

References Calculator::assemble(), Calculator::bind(), Calculator::exec(), Calculator::getInputRegisterDescriptor(), FennelExcn::getMessage(), Calculator::getOutputRegisterDescriptor(), StandardTypeDescriptor::isApprox(), StandardTypeDescriptor::isExact(), Calculator::outputRegisterByReference(), TupleDatum::pData, and testTuples.

Referenced by CalcExtWinAggFuncTest::testCalcExtMinMaxDbl(), and CalcExtWinAggFuncTest::testCalcExtMinMaxInt().

00245 {
00246     ostringstream pg("");
00247 
00248     if (StandardTypeDescriptor::isExact(dType)) {
00249         pg << "O s8,s8,s8,s8,s8,s8,s8;" << endl;
00250         pg << "I s8,vb,4;" <<endl;
00251     } else if (StandardTypeDescriptor::isApprox(dType)) {
00252         pg << "O s8,d,d,d,d,d,d;" << endl;
00253         pg << "I d,vb,4;" <<endl;
00254     }
00255     pg << "T;" << endl;
00256     pg << "CALL 'WinAggAdd(I0,I1);" << endl;
00257     pg << "CALL 'WinAggCount(O0,I1);" << endl;
00258     pg << "CALL 'WinAggSum(O1,I1);" << endl;
00259     pg << "CALL 'WinAggAvg(O2,I1);" << endl;
00260     pg << "CALL 'WinAggMin(O3,I1);" << endl;
00261     pg << "CALL 'WinAggMax(O4,I1);" << endl;
00262     pg << "CALL 'WinAggFirstValue(O5,I1);" << endl;
00263     pg << "CALL 'WinAggLastValue(O6,I1);" << endl;
00264 
00265     // Allocate
00266     Calculator calc(0);
00267     calc.outputRegisterByReference(false);
00268 
00269     // Assemble the script
00270     try {
00271         calc.assemble(pg.str().c_str());
00272     } catch (FennelExcn& ex) {
00273         BOOST_FAIL("Assemble exception " << ex.getMessage()<< pg.str());
00274     }
00275 
00276     TupleDataWithBuffer outTuple(calc.getOutputRegisterDescriptor());
00277 
00278     for (int i = 0; i < 10; i++) {
00279         TupleDataWithBuffer *inTuple =
00280             new TupleDataWithBuffer(calc.getInputRegisterDescriptor());
00281         testTuples.push_back(inTuple);
00282 
00283         calc.bind(inTuple, &outTuple);
00284 
00285         // copy the Agg data block pointer into the input tuple
00286         (*inTuple)[1] = (*winAggTuple)[0];
00287 
00288         TupleDatum* pTD = &((*inTuple)[0]);
00289         pTD->pData = reinterpret_cast<PConstBuffer>(
00290             &testData[TEST_DATA_INDEX][i]);
00291 
00292         calc.exec();
00293 
00294         (*check)(&outTuple,testData,i);
00295     }
00296     assert(
00297         10 == *(reinterpret_cast<int64_t*>(
00298             const_cast<uint8_t*>(outTuple[0].pData))));
00299 }

template<typename DTYPE>
void WinAggAddTestStr ( TupleDataWithBuffer *  winAggTuple,
DTYPE  testData[][STR_SAMPLE_SIZE],
StandardTypeDescriptorOrdinal  dType,
void(*)(TupleDataWithBuffer *, DTYPE[][STR_SAMPLE_SIZE], int)  check 
)

Definition at line 366 of file CalcExtWinAggFuncTest.cpp.

References Calculator::assemble(), Calculator::bind(), Calculator::exec(), Calculator::getInputRegisterDescriptor(), FennelExcn::getMessage(), Calculator::getOutputRegisterDescriptor(), StandardTypeDescriptor::isArray(), StandardTypeDescriptor::isVariableLenArray(), Calculator::outputRegisterByReference(), TupleDatum::pData, and testTuples.

Referenced by CalcExtWinAggFuncTest::testCalcExtMinMaxStr().

00371 {
00372     ostringstream pg("");
00373 
00374     if (StandardTypeDescriptor::isVariableLenArray(dType)) {
00375         pg << "O s8, vc,4, vc,4, vc,4, vc,4;" << endl;
00376         pg << "I vc,4,vb,4;" <<endl;
00377     } else if (StandardTypeDescriptor::isArray(dType)) {
00378         pg << "O s8, c,4, c,4, c,4, c,4;" << endl;
00379         pg << "I c,4,vb,4;" <<endl;
00380     }
00381     pg << "T;" << endl;
00382     pg << "CALL 'WinAggAdd(I0,I1);" << endl;
00383     pg << "CALL 'WinAggCount(O0,I1);" << endl;
00384     pg << "CALL 'WinAggMin(O1,I1);" << endl;
00385     pg << "CALL 'WinAggMax(O2,I1);" << endl;
00386     pg << "CALL 'WinAggFirstValue(O3,I1);" << endl;
00387     pg << "CALL 'WinAggLastValue(O4,I1);" << endl;
00388 
00389     // Allocate
00390     Calculator calc(0);
00391     calc.outputRegisterByReference(false);
00392 
00393     // Assemble the script
00394     try {
00395         calc.assemble(pg.str().c_str());
00396     } catch (FennelExcn& ex) {
00397         BOOST_FAIL("Assemble exception " << ex.getMessage()<< pg.str());
00398     }
00399 
00400     TupleDataWithBuffer outTuple(calc.getOutputRegisterDescriptor());
00401 
00402     for (int i = 0; i < STR_SAMPLE_SIZE; i++) {
00403         TupleDataWithBuffer *inTuple =
00404             new TupleDataWithBuffer(calc.getInputRegisterDescriptor());
00405         testTuples.push_back(inTuple);
00406 
00407         calc.bind(inTuple, &outTuple);
00408 
00409         // copy the Agg data block pointer into the input tuple
00410         (*inTuple)[1] = (*winAggTuple)[0];
00411 
00412         TupleDatum* pTD = &((*inTuple)[0]);
00413         pTD->pData =
00414             reinterpret_cast<PConstBuffer>(testData[TEST_DATA_INDEX][i]);
00415 
00416         calc.exec();
00417 
00418         (*check)(&outTuple,testData,i);
00419     }
00420     assert(4 == *(reinterpret_cast<int64_t*>(
00421         const_cast<uint8_t*>(outTuple[0].pData))));
00422 }

template<typename DTYPE>
void WinAggDropTest ( TupleDataWithBuffer *  winAggTuple,
DTYPE  testData[][SAMPLE_SIZE],
StandardTypeDescriptorOrdinal  dType,
void(*)(TupleDataWithBuffer *, DTYPE[][SAMPLE_SIZE], int)  check 
)

Definition at line 304 of file CalcExtWinAggFuncTest.cpp.

References Calculator::assemble(), Calculator::bind(), Calculator::exec(), FennelExcn::getMessage(), Calculator::getOutputRegisterDescriptor(), StandardTypeDescriptor::isApprox(), StandardTypeDescriptor::isExact(), Calculator::outputRegisterByReference(), TupleDatum::pData, and testTuples.

Referenced by CalcExtWinAggFuncTest::testCalcExtMinMaxDbl(), and CalcExtWinAggFuncTest::testCalcExtMinMaxInt().

00309 {
00310     ostringstream pg("");
00311 
00312     if (StandardTypeDescriptor::isExact(dType)) {
00313         pg << "O s8,s8,s8,s8,s8,s8,s8;" << endl;
00314         pg << "I s8,vb,4;" <<endl;
00315     } else if (StandardTypeDescriptor::isApprox(dType)) {
00316         pg << "O s8,d,d,d,d,d,d;" << endl;
00317         pg << "I d,vb,4;" <<endl;
00318     }
00319     pg << "T;" << endl;
00320     pg << "CALL 'WinAggDrop(I0,I1);" << endl;
00321     pg << "CALL 'WinAggCount(O0,I1);" << endl;
00322     pg << "CALL 'WinAggSum(O1,I1);" << endl;
00323     pg << "CALL 'WinAggAvg(O2,I1);" << endl;
00324     pg << "CALL 'WinAggMin(O3,I1);" << endl;
00325     pg << "CALL 'WinAggMax(O4,I1);" << endl;
00326     pg << "CALL 'WinAggFirstValue(O5,I1);" << endl;
00327     pg << "CALL 'WinAggLastValue(O6,I1);" << endl;
00328 
00329     // Allocate
00330     Calculator calc(0);
00331     calc.outputRegisterByReference(false);
00332 
00333     // Assemble the script
00334     try {
00335         calc.assemble(pg.str().c_str());
00336     } catch (FennelExcn& ex) {
00337         BOOST_FAIL("Assemble exception " << ex.getMessage()<< pg.str());
00338     }
00339 
00340     // Alloc tuples and buffer space
00341     TupleDataWithBuffer outTuple(calc.getOutputRegisterDescriptor());
00342 
00343     // Step backwards through the data table and remove each entry
00344     // from the window checking the function returns along the way.
00345     for (int i=SAMPLE_SIZE-1; i >=0 ; i--) {
00346         TupleData* inTuple = testTuples[i];
00347         TupleDatum* pTD = &(*inTuple)[0];
00348 
00349         calc.bind(inTuple, &outTuple);
00350 
00351         // copy the Agg data block pointer into the input tuple
00352         (*inTuple)[1] = (*winAggTuple)[0];
00353 
00354         pTD->pData = reinterpret_cast<PConstBuffer>(
00355             &testData[TEST_DATA_INDEX][i]);
00356 
00357         calc.exec();
00358 
00359         (*check)(&outTuple, testData, i);
00360     }
00361     assert(0 == *(reinterpret_cast<const int64_t*>(outTuple[0].pData)));
00362 }

template<typename DTYPE>
void WinAggDropTestStr ( TupleDataWithBuffer *  winAggTuple,
DTYPE  testData[][STR_SAMPLE_SIZE],
StandardTypeDescriptorOrdinal  dType,
void(*)(TupleDataWithBuffer *, DTYPE[][STR_SAMPLE_SIZE], int)  check 
)

Definition at line 426 of file CalcExtWinAggFuncTest.cpp.

References Calculator::assemble(), Calculator::bind(), Calculator::exec(), FennelExcn::getMessage(), Calculator::getOutputRegisterDescriptor(), StandardTypeDescriptor::isArray(), StandardTypeDescriptor::isVariableLenArray(), Calculator::outputRegisterByReference(), TupleDatum::pData, and testTuples.

Referenced by CalcExtWinAggFuncTest::testCalcExtMinMaxStr().

00431 {
00432     ostringstream pg("");
00433 
00434     if (StandardTypeDescriptor::isVariableLenArray(dType)) {
00435         pg << "O s8, vc,4, vc,4, vc,4, vc,4;" << endl;
00436         pg << "I vc,4,vb,4;" <<endl;
00437     } else if (StandardTypeDescriptor::isArray(dType)) {
00438         pg << "O s8, c,4, c,4, c,4, c,4;" << endl;
00439         pg << "I c,4,vb,4;" <<endl;
00440     }
00441     pg << "T;" << endl;
00442     pg << "CALL 'WinAggDrop(I0,I1);" << endl;
00443     pg << "CALL 'WinAggCount(O0,I1);" << endl;
00444     pg << "CALL 'WinAggMin(O1,I1);" << endl;
00445     pg << "CALL 'WinAggMax(O2,I1);" << endl;
00446     pg << "CALL 'WinAggFirstValue(O3,I1);" << endl;
00447     pg << "CALL 'WinAggLastValue(O4,I1);" << endl;
00448 
00449     // Allocate
00450     Calculator calc(0);
00451     calc.outputRegisterByReference(false);
00452 
00453     // Assemble the script
00454     try {
00455         calc.assemble(pg.str().c_str());
00456     } catch (FennelExcn& ex) {
00457         BOOST_FAIL("Assemble exception " << ex.getMessage()<< pg.str());
00458     }
00459 
00460     // Alloc tuples and buffer space
00461     TupleDataWithBuffer outTuple(calc.getOutputRegisterDescriptor());
00462 
00463     // Step forwards through the data table and remove each entry
00464     // from the window checking the function returns along the way.
00465     for (int i = 0; i < STR_SAMPLE_SIZE; i++) {
00466         TupleData* inTuple = testTuples[i];
00467         TupleDatum* pTD = &(*inTuple)[0];
00468 
00469         calc.bind(inTuple, &outTuple);
00470 
00471         // copy the Agg data block pointer into the input tuple
00472         (*inTuple)[1] = (*winAggTuple)[0];
00473 
00474         pTD->pData = reinterpret_cast<PConstBuffer>(
00475             testData[TEST_DATA_INDEX][i]);
00476 
00477         calc.exec();
00478 
00479         (*check)(&outTuple, testData, i);
00480     }
00481     assert(0 == *(reinterpret_cast<const int64_t*>(outTuple[0].pData)));
00482 }

Variable Documentation

const double DBL_TEST_MAX = 874.5 [static]

Definition at line 70 of file CalcExtWinAggFuncTest.cpp.

const double DBL_TEST_MIN = 1.5 [static]

Definition at line 69 of file CalcExtWinAggFuncTest.cpp.

double dblTestData[][SAMPLE_SIZE] [static]

Initial value:

{
    
    { 63.5, 63.1, 92.9,  1.5,  6.3, 38.5, 23.1, 874.5,  44.7, 498.0 },
    
    { 63.5, 63.1, 63.1,  1.5,  1.5,  1.5,  1.5,   1.5,   1.5,   1.5 },
    
    { 63.5, 63.5, 92.9, 92.9, 92.9, 92.9, 92.9, 874.5, 874.5, 874.5 },
    
    { 63.5,126.6,219.5,221.0,227.3,265.8,288.9,1163.4,1208.1,1706.1 },
    
    { 63.5, 63.5, 63.5, 63.5, 63.5, 63.5, 63.5,  63.5,  63.5,  63.5 },
    
    {498.0,498.0,490.0,498.0,498.0,498.0,498.0, 498.0, 498.0, 498.0 },
}

Definition at line 72 of file CalcExtWinAggFuncTest.cpp.

Referenced by CalcExtWinAggFuncTest::testCalcExtMinMaxDbl().

const int64_t INT_TEST_MAX = 105 [static]

Definition at line 56 of file CalcExtWinAggFuncTest.cpp.

const int64_t INT_TEST_MIN = 2 [static]

Definition at line 55 of file CalcExtWinAggFuncTest.cpp.

int64_t intTestData[][SAMPLE_SIZE] [static]

Initial value:

{
    { 12,  33, 52, 14, 10, 63,  5,  2, 49,105 },  
    { 12,  12, 12, 12, 10, 10,  5,  2,  2,  2 },  
    { 12,  33, 52, 52, 52, 63, 63, 63, 63,105 },  
    { 12,  45, 97,111,121,184,189,191,240,345 },  
    { 12,  12, 12, 12, 12, 12, 12, 12, 12, 12 },  
    { 105,105,105,105,105,105,105,105,105,105 },  
}

Definition at line 58 of file CalcExtWinAggFuncTest.cpp.

Referenced by CalcExtWinAggFuncTest::testCalcExtMinMaxInt().

const char* str1 = "abcd" [static]

Definition at line 90 of file CalcExtWinAggFuncTest.cpp.

Referenced by WinAggHistogramStrA::_StringDescCompare::operator()(), strCatA2(), strCatA3(), strCmpA(), and strCmpOct().

const char* str2 = "qrst" [static]

Definition at line 91 of file CalcExtWinAggFuncTest.cpp.

Referenced by WinAggHistogramStrA::_StringDescCompare::operator()(), strCatA3(), strCmpA(), and strCmpOct().

const char* str3 = "abc " [static]

Definition at line 92 of file CalcExtWinAggFuncTest.cpp.

const char* str4 = "noot" [static]

Definition at line 93 of file CalcExtWinAggFuncTest.cpp.

const char* strAddTestData[][STR_SAMPLE_SIZE] [static]

Initial value:

{
    { str1, str2, str3, str4 },   
    { str1, str1, str3, str3 },   
    { str1, str2, str2, str2 },   
    { NULL, NULL, NULL, NULL },   
    { str1, str1, str1, str1 },   
    { str1, str2, str3, str4 },   
}

Definition at line 95 of file CalcExtWinAggFuncTest.cpp.

Referenced by CalcExtWinAggFuncTest::testCalcExtMinMaxStr().

const char* strDropTestData[][STR_SAMPLE_SIZE] [static]

Initial value:

{
    { str1, str2, str3, str4 },   
    { str3, str3, str4, NULL },   
    { str2, str4, str4, NULL },   
    { NULL, NULL, NULL, NULL },   
    { str2, str3, str4, NULL },   
    { str4, str4, str4, NULL },   
}

Definition at line 105 of file CalcExtWinAggFuncTest.cpp.

Referenced by CalcExtWinAggFuncTest::testCalcExtMinMaxStr().

vector<TupleData*> testTuples [static]

Definition at line 115 of file CalcExtWinAggFuncTest.cpp.

Referenced by CalcExtWinAggFuncTest::testCalcExtMinMaxDbl(), CalcExtWinAggFuncTest::testCalcExtMinMaxInt(), CalcExtWinAggFuncTest::testCalcExtMinMaxStr(), WinAggAddTest(), WinAggAddTestStr(), WinAggDropTest(), and WinAggDropTestStr().

Generated on Mon Jun 22 04:00:21 2009 for Fennel by  doxygen 1.5.1