Fennel: ExecStreamTestSuite Class Reference (original) (raw)

• Main Page

• Namespaces

• Classes

• Files

• Directories

• Related Pages

• Alphabetical List

• Class List

• Class Hierarchy

• Class Members

ExecStreamTestSuite tests various implementations of ExecStream. More...

#include <[ExecStreamTestSuite.h](ExecStreamTestSuite%5F8h-source.html)>

Inheritance diagram for ExecStreamTestSuite:

List of all members.

Detailed Description

ExecStreamTestSuite tests various implementations of ExecStream.

Derived classes can add tests and/or use a different scheduler implementation.

Definition at line 39 of file ExecStreamTestSuite.h.

Member Enumeration Documentation

The available victim policy implementations.

Enumerator:

| victimTwoQ | | | -------------- | | | victimLRU | | | victimRandom | |

Definition at line 44 of file CacheTestBase.h.

Constructor & Destructor Documentation

Create a ExecStreamTestSuite.

Parameters:

Definition at line 63 of file ExecStreamTestSuite.h.

00064 { 00065 if (initTestCases) { 00066 FENNEL_UNIT_TEST_CASE( 00067 ExecStreamTestSuite,testScratchBufferExecStream); 00068 FENNEL_UNIT_TEST_CASE( 00069 ExecStreamTestSuite,testDoubleBufferExecStream); 00070 FENNEL_UNIT_TEST_CASE(ExecStreamTestSuite,testCopyExecStream); 00071 FENNEL_UNIT_TEST_CASE(ExecStreamTestSuite,testMergeExecStream); 00072 FENNEL_UNIT_TEST_CASE(ExecStreamTestSuite,testSegBufferExecStream); 00073 FENNEL_UNIT_TEST_CASE( 00074 ExecStreamTestSuite,testCartesianJoinExecStreamOuter); 00075 FENNEL_UNIT_TEST_CASE( 00076 ExecStreamTestSuite,testCartesianJoinExecStreamInner); 00077 FENNEL_UNIT_TEST_CASE(ExecStreamTestSuite,testCountAggExecStream); 00078 FENNEL_UNIT_TEST_CASE(ExecStreamTestSuite,testSumAggExecStream); 00079 FENNEL_UNIT_TEST_CASE(ExecStreamTestSuite,testGroupAggExecStream1); 00080 FENNEL_UNIT_TEST_CASE(ExecStreamTestSuite,testGroupAggExecStream2); 00081 FENNEL_UNIT_TEST_CASE(ExecStreamTestSuite,testGroupAggExecStream3); 00082 FENNEL_UNIT_TEST_CASE(ExecStreamTestSuite,testGroupAggExecStream4); 00083 FENNEL_UNIT_TEST_CASE( 00084 ExecStreamTestSuite,testReshapeExecStreamCastFilter); 00085 FENNEL_UNIT_TEST_CASE( 00086 ExecStreamTestSuite,testReshapeExecStreamNoCastFilter); 00087 FENNEL_UNIT_TEST_CASE( 00088 ExecStreamTestSuite,testReshapeExecStreamDynamicParams); 00089 FENNEL_UNIT_TEST_CASE( 00090 ExecStreamTestSuite, 00091 testSingleValueAggExecStream); 00092 FENNEL_UNIT_TEST_CASE( 00093 ExecStreamTestSuite, 00094 testMergeImplicitPullInputs); 00095 FENNEL_UNIT_TEST_CASE( 00096 ExecStreamTestSuite, 00097 testBTreeInsertExecStreamStaticBTree); 00098 FENNEL_UNIT_TEST_CASE( 00099 ExecStreamTestSuite, 00100 testBTreeInsertExecStreamDynamicBTree); 00101 FENNEL_UNIT_TEST_CASE( 00102 ExecStreamTestSuite, 00103 testNestedLoopJoinExecStream1); 00104 FENNEL_UNIT_TEST_CASE( 00105 ExecStreamTestSuite, 00106 testNestedLoopJoinExecStream2); 00107 FENNEL_UNIT_TEST_CASE( 00108 ExecStreamTestSuite, 00109 testSplitterPlusBarrier); 00110 FENNEL_UNIT_TEST_CASE( 00111 ExecStreamTestSuite, 00112 testSegBufferReaderWriterExecStream1); 00113 FENNEL_UNIT_TEST_CASE( 00114 ExecStreamTestSuite, 00115 testSegBufferReaderWriterExecStream2); 00116 FENNEL_UNIT_TEST_CASE( 00117 ExecStreamTestSuite, 00118 testSegBufferReaderWriterExecStream3); 00119 FENNEL_UNIT_TEST_CASE( 00120 ExecStreamTestSuite, 00121 testSegBufferReaderWriterExecStream4); 00122 } 00123 }

Member Function Documentation

Definition at line 373 of file ExecStreamTestSuite.cpp.

References AGG_FUNC_COUNT, AggInvocation::aggFunction, SortedAggExecStreamParams::aggInvocations, ExecStreamEmbryo::getStream(), SortedAggExecStreamParams::groupByKeyCount, AggInvocation::iInputAttr, ExecStreamEmbryo::init(), StandardTypeDescriptorFactory::newDataType(), ExecStreamUnitTestBase::prepareTransformGraph(), STANDARD_TYPE_INT_64, and ExecStreamUnitTestBase::verifyOutput().

Definition at line 424 of file ExecStreamTestSuite.cpp.

References TupleDatum::cbData, COMP_EQ, COMP_NOOP, ReshapeExecStreamParams::compOp, TupleAccessor::compute(), TupleData::compute(), ReshapeExecStreamParams::dynamicParameters, FixedBuffer, TupleAccessor::getMaxByteCount(), ExecStreamEmbryo::getStream(), ExecStreamEmbryo::init(), ReshapeExecStreamParams::inputCompareProj, TupleAccessor::marshal(), MAXU, StandardTypeDescriptorFactory::newDataType(), opaqueToInt(), ReshapeExecStreamParams::outputProj, ReshapeExecStreamParams::pCompTupleBuffer, TupleDatum::pData, ExecStreamUnitTestBase::pGraph, ExecStreamUnitTestBase::prepareTransformGraph(), STANDARD_TYPE_INT_64, and ExecStreamUnitTestBase::verifyOutput().

00428 { 00429 assert(!compareParam || filter == compareParam); 00430 StandardTypeDescriptorFactory stdTypeFactory; 00431 TupleAttributeDescriptor nullAttrDesc( 00432 stdTypeFactory.newDataType(STANDARD_TYPE_INT_64), 00433 true, sizeof(int64_t)); 00434 TupleAttributeDescriptor notNullAttrDesc( 00435 stdTypeFactory.newDataType(STANDARD_TYPE_INT_64)); 00436 00437
00438
00439
00440
00441
00442
00443
00444 MockProducerExecStreamParams mockParams; 00445 for (int i = 0; i < 6; i++) { 00446 mockParams.outputTupleDesc.push_back(notNullAttrDesc); 00447 } 00448 vector<boost::shared_ptr<ColumnGenerator > > columnGenerators; 00449 SharedInt64ColumnGenerator colGen; 00450 for (int i = 0; i < 4; i++) { 00451 colGen = SharedInt64ColumnGenerator(new SeqColumnGenerator(i)); 00452 columnGenerators.push_back(colGen); 00453 } 00454 colGen = SharedInt64ColumnGenerator(new DupColumnGenerator(25, 0)); 00455 columnGenerators.push_back(colGen); 00456 colGen = SharedInt64ColumnGenerator(new DupColumnGenerator(10, 0)); 00457 columnGenerators.push_back(colGen); 00458 mockParams.nRows = 1000; 00459 mockParams.pGenerator.reset( 00460 new CompositeExecStreamGenerator(columnGenerators)); 00461 00462 ExecStreamEmbryo mockStreamEmbryo; 00463 mockStreamEmbryo.init(new MockProducerExecStream(),mockParams); 00464 mockStreamEmbryo.getStream()->setName("MockProducerExecStream"); 00465 00466
00467
00468
00469
00470
00471
00472
00473
00474 ReshapeExecStreamParams rsParams; 00475 boost::shared_array pBuffer; 00476 std::vector paramVals; 00477 paramVals.push_back(10); 00478 paramVals.push_back(20); 00479 paramVals.push_back(50); 00480 if (!filter) { 00481 rsParams.compOp = COMP_NOOP; 00482 } else { 00483 rsParams.compOp = COMP_EQ; 00484 TupleDescriptor compareDesc; 00485
00486 compareDesc.push_back(nullAttrDesc); 00487 if (!compareParam) { 00488 compareDesc.push_back(nullAttrDesc); 00489 } 00490 TupleData compareData; 00491 compareData.compute(compareDesc); 00492 if (compareParam) { 00493 compareData[0].pData = (PConstBuffer) &paramVals[1]; 00494 } else { 00495 compareData[0].pData = (PConstBuffer) &paramVals[1]; 00496 compareData[1].pData = (PConstBuffer) &paramVals[2]; 00497 } 00498 TupleAccessor tupleAccessor; 00499 tupleAccessor.compute(compareDesc); 00500 pBuffer.reset(new FixedBuffer[tupleAccessor.getMaxByteCount()]); 00501 tupleAccessor.marshal(compareData, pBuffer.get()); 00502 } 00503 rsParams.pCompTupleBuffer = pBuffer; 00504 00505 TupleProjection tupleProj; 00506 tupleProj.push_back(4); 00507 tupleProj.push_back(5); 00508 rsParams.inputCompareProj = tupleProj; 00509 00510 tupleProj.clear(); 00511 tupleProj.push_back(3); 00512 tupleProj.push_back(0); 00513 tupleProj.push_back(2); 00514 rsParams.outputProj = tupleProj; 00515 00516 for (int i = 0; i < 3; i++) { 00517 if (cast) { 00518 rsParams.outputTupleDesc.push_back(nullAttrDesc); 00519 } else { 00520 rsParams.outputTupleDesc.push_back(notNullAttrDesc); 00521 } 00522 } 00523 00524
00525
00526
00527 std::vector dynamicParams; 00528 if (compareParam || outputParams.size() > 0) { 00529 for (uint i = 1; i < paramVals.size() + 1; i++) { 00530 SharedDynamicParamManager pDynamicParamManager = 00531 pGraph->getDynamicParamManager(); 00532 pDynamicParamManager->createParam( 00533 DynamicParamId(i), 00534 notNullAttrDesc); 00535 TupleDatum paramValDatum; 00536 paramValDatum.pData = (PConstBuffer) &(paramVals[i - 1]); 00537 paramValDatum.cbData = sizeof(int64_t); 00538 pDynamicParamManager->writeParam( 00539 DynamicParamId(i), 00540 paramValDatum); 00541 dynamicParams.push_back( 00542 ReshapeParameter( 00543 DynamicParamId(i), 00544 ((i == 3) && compareParam) ? uint(5) : MAXU, 00545 (outputParams.find(i - 1) != outputParams.end()))); 00546 } 00547 } 00548 rsParams.dynamicParameters = dynamicParams; 00549 00550
00551 columnGenerators.clear(); 00552 colGen = SharedInt64ColumnGenerator( 00553 new SeqColumnGenerator(expectedStart + 3)); 00554 columnGenerators.push_back(colGen); 00555 colGen = SharedInt64ColumnGenerator( 00556 new SeqColumnGenerator(expectedStart)); 00557 columnGenerators.push_back(colGen); 00558 colGen = SharedInt64ColumnGenerator( 00559 new SeqColumnGenerator(expectedStart + 2)); 00560 columnGenerators.push_back(colGen); 00561 for (uint i = 0; i < dynamicParams.size(); i++) { 00562 if (dynamicParams[i].outputParam) { 00563 colGen = 00564 SharedInt64ColumnGenerator( 00565 new ConstColumnGenerator( 00566 paramVals[opaqueToInt( 00567 dynamicParams[i].dynamicParamId) - 1])); 00568 columnGenerators.push_back(colGen); 00569 rsParams.outputTupleDesc.push_back(notNullAttrDesc); 00570 } 00571 } 00572 00573 ExecStreamEmbryo rsStreamEmbryo; 00574 rsStreamEmbryo.init(new ReshapeExecStream(),rsParams); 00575 rsStreamEmbryo.getStream()->setName("ReshapeExecStream"); 00576 SharedExecStream pOutputStream = prepareTransformGraph( 00577 mockStreamEmbryo, rsStreamEmbryo); 00578 00579 CompositeExecStreamGenerator resultGenerator(columnGenerators); 00580 verifyOutput(*pOutputStream, expectedNRows, resultGenerator); 00581 }

Definition at line 764 of file ExecStreamTestSuite.cpp.

References TupleData::compute(), BTreeBuilder::createEmptyRoot(), BTreeInsertExecStreamParams::distinctness, DUP_FAIL, BTreeAccessBase::getRootPageId(), ExecStreamEmbryo::getStream(), ExecStreamEmbryo::init(), BTreeParams::keyProj, BTreeDescriptor::keyProjection, BTreeInsertExecStreamParams::monotonic, StandardTypeDescriptorFactory::newDataType(), NULL_PAGE_ID, SingleOutputExecStreamParams::outputTupleDesc, BTreeDescriptor::pageOwnerId, BTreeParams::pageOwnerId, CacheTestBase::pCache, ExecStreamParams::pCacheAccessor, ExecStreamTestBase::pCacheAccessor, SegmentAccessor::pCacheAccessor, ExecStreamUnitTestBase::pGraph, SegStorageTestBase::pRandomSegment, ExecStreamUnitTestBase::prepareTransformGraph(), BTreeParams::pRootMap, BTreeParams::pSegment, SegmentAccessor::pSegment, SegStorageTestBase::pSegmentFactory, BTreeParams::rootPageId, BTreeDescriptor::rootPageId, BTreeParams::rootPageIdParamId, ExecStreamParams::scratchAccessor, BTreeDescriptor::segmentAccessor, BTreeDescriptor::segmentId, BTreeParams::segmentId, STANDARD_TYPE_INT_64, BTreeParams::tupleDesc, BTreeDescriptor::tupleDescriptor, and ExecStreamUnitTestBase::verifyOutput().

Definition at line 868 of file ExecStreamTestSuite.cpp.

References ValuesExecStreamParams::bufSize, COMP_EQ, ReshapeExecStreamParams::compOp, ReshapeExecStreamParams::dynamicParameters, ExecStreamEmbryo::getStream(), ExecStreamEmbryo::init(), ReshapeExecStreamParams::inputCompareProj, NestedLoopJoinExecStreamParams::leftJoinKeys, CartesianJoinExecStreamParams::leftOuter, min(), StandardTypeDescriptorFactory::newDataType(), MockProducerExecStreamParams::nRows, ReshapeExecStreamParams::outputProj, SingleOutputExecStreamParams::outputTupleDesc, MockProducerExecStreamParams::pGenerator, ExecStreamUnitTestBase::prepareConfluenceGraph(), STANDARD_TYPE_INT_64, and ExecStreamUnitTestBase::verifyOutput().

00871 { 00872
00873 00874 StandardTypeDescriptorFactory stdTypeFactory; 00875 TupleAttributeDescriptor attrDesc( 00876 stdTypeFactory.newDataType(STANDARD_TYPE_INT_64)); 00877 00878
00879 MockProducerExecStreamParams paramsMockOuter; 00880 paramsMockOuter.outputTupleDesc.push_back(attrDesc); 00881 paramsMockOuter.nRows = nRowsLeft; 00882 paramsMockOuter.pGenerator.reset(new RampExecStreamGenerator(0, 1)); 00883 00884 ExecStreamEmbryo outerStreamEmbryo; 00885 outerStreamEmbryo.init(new MockProducerExecStream(), paramsMockOuter); 00886 outerStreamEmbryo.getStream()->setName("OuterProducerExecStream"); 00887 00888
00889
00890
00891
00892
00893 MockProducerExecStreamParams paramsMockInner; 00894 paramsMockInner.outputTupleDesc.push_back(attrDesc); 00895 paramsMockInner.nRows = nRowsRight; 00896 paramsMockInner.pGenerator.reset(new RampExecStreamGenerator(0, 1)); 00897 00898 ExecStreamEmbryo innerStreamEmbryo; 00899 innerStreamEmbryo.init(new MockProducerExecStream(), paramsMockInner); 00900 innerStreamEmbryo.getStream()->setName("InnerProducerExecStream"); 00901 00902 ReshapeExecStreamParams paramsReshape; 00903 paramsReshape.compOp = COMP_EQ; 00904 paramsReshape.outputProj.push_back(0); 00905 paramsReshape.inputCompareProj.push_back(0); 00906 paramsReshape.dynamicParameters.push_back( 00907 ReshapeParameter(DynamicParamId(1), 0, false)); 00908 paramsReshape.outputTupleDesc.push_back(attrDesc); 00909 00910 ExecStreamEmbryo reshapeStreamEmbryo; 00911 reshapeStreamEmbryo.init(new ReshapeExecStream(), paramsReshape); 00912 reshapeStreamEmbryo.getStream()->setName("ReshapeExecStream"); 00913 00914
00915
00916
00917 ValuesExecStreamParams paramsValues; 00918 paramsValues.bufSize = 0; 00919 paramsValues.outputTupleDesc.push_back(attrDesc); 00920 ExecStreamEmbryo valuesStreamEmbryo; 00921 valuesStreamEmbryo.init(new ValuesExecStream(), paramsValues); 00922 valuesStreamEmbryo.getStream()->setName("ValuesExecStream"); 00923 00924
00925 std::vector<std::vector > sourceStreamEmbryosList; 00926 std::vector sourceStreamEmbryos; 00927 sourceStreamEmbryos.push_back(outerStreamEmbryo); 00928 sourceStreamEmbryosList.push_back(sourceStreamEmbryos); 00929 00930 sourceStreamEmbryos.clear(); 00931 sourceStreamEmbryos.push_back(innerStreamEmbryo); 00932 sourceStreamEmbryos.push_back(reshapeStreamEmbryo); 00933 sourceStreamEmbryosList.push_back(sourceStreamEmbryos); 00934 00935 sourceStreamEmbryos.clear(); 00936 sourceStreamEmbryos.push_back(valuesStreamEmbryo); 00937 sourceStreamEmbryosList.push_back(sourceStreamEmbryos); 00938 00939 NestedLoopJoinExecStreamParams paramsJoin; 00940 paramsJoin.leftOuter = false; 00941 paramsJoin.leftJoinKeys.push_back( 00942 NestedLoopJoinKey(DynamicParamId(1), 0)); 00943 00944 ExecStreamEmbryo joinStreamEmbryo; 00945 joinStreamEmbryo.init(new NestedLoopJoinExecStream(), paramsJoin); 00946 joinStreamEmbryo.getStream()->setName("NestedLoopJoinExecStream"); 00947 00948 SharedExecStream pOutputStream = 00949 prepareConfluenceGraph(sourceStreamEmbryosList, joinStreamEmbryo); 00950 00951 vector<boost::shared_ptr<ColumnGenerator > > columnGenerators; 00952 SharedInt64ColumnGenerator colGen = 00953 SharedInt64ColumnGenerator(new SeqColumnGenerator(0)); 00954 columnGenerators.push_back(colGen); 00955 colGen = SharedInt64ColumnGenerator(new SeqColumnGenerator(0)); 00956 columnGenerators.push_back(colGen); 00957 00958 CompositeExecStreamGenerator resultGenerator(columnGenerators); 00959 verifyOutput( 00960 *pOutputStream, std::min(nRowsLeft, nRowsRight), resultGenerator); 00961 }

| uint ExecStreamTestSuite::getDegreeOfParallelism | ( | | ) | [protected, virtual] | | ------------------------------------------------------------------------------------------------------------- | - | | - | ---------------------- |

Definition at line 1019 of file ExecStreamTestSuite.cpp.

References TupleData::compute(), getDegreeOfParallelism(), ExecStreamEmbryo::getStream(), ExecStreamEmbryo::init(), MergeExecStreamParams::isParallel, CartesianJoinExecStreamParams::leftOuter, SegBufferExecStreamParams::multipass, StandardTypeDescriptorFactory::newDataType(), DiffluenceExecStreamParams::outputTupleDesc, ExecStreamTestBase::pCacheAccessor, SegStorageTestBase::pRandomSegment, ExecStreamUnitTestBase::prepareDAG(), SegBufferReaderExecStreamParams::readerRefCountParamId, SegBufferWriterExecStreamParams::readerRefCountParamId, STANDARD_TYPE_INT_64, and ExecStreamUnitTestBase::verifyConstantOutput().

01022 { 01023
01024
01025
01026
01027
01028
01029
01030
01031
01032
01033
01034
01035
01036 01037 StandardTypeDescriptorFactory stdTypeFactory; 01038 TupleAttributeDescriptor attrDesc( 01039 stdTypeFactory.newDataType(STANDARD_TYPE_INT_64)); 01040 01041 MockProducerExecStreamParams mockParams; 01042 mockParams.outputTupleDesc.push_back(attrDesc); 01043 uint nRows; 01044 if (!restartable) { 01045 nRows = 10000; 01046 } else { 01047 nRows = 200; 01048 } 01049 mockParams.nRows = nRows; 01050 01051 ExecStreamEmbryo mockStreamEmbryo; 01052 mockStreamEmbryo.init(new MockProducerExecStream(), mockParams); 01053 mockStreamEmbryo.getStream()->setName("MockProducerExecStream"); 01054 01055 SegBufferWriterExecStreamParams writerParams; 01056 writerParams.scratchAccessor.pSegment = pRandomSegment; 01057 writerParams.scratchAccessor.pCacheAccessor = pCacheAccessor; 01058 writerParams.readerRefCountParamId = DynamicParamId(1); 01059 writerParams.outputTupleDesc.push_back(attrDesc); 01060 01061 ExecStreamEmbryo writerStreamEmbryo; 01062 writerStreamEmbryo.init( 01063 new SegBufferWriterExecStream(), 01064 writerParams); 01065 writerStreamEmbryo.getStream()->setName("SegBufferWriterExecStream"); 01066 01067 SegBufferReaderExecStreamParams readerParams; 01068 readerParams.scratchAccessor.pSegment = pRandomSegment; 01069 readerParams.scratchAccessor.pCacheAccessor = pCacheAccessor; 01070 readerParams.readerRefCountParamId = DynamicParamId(1); 01071 readerParams.outputTupleDesc.push_back(attrDesc); 01072 01073 ExecStreamEmbryo readerStreamEmbryo1; 01074 readerStreamEmbryo1.init( 01075 new SegBufferReaderExecStream(), 01076 readerParams); 01077 readerStreamEmbryo1.getStream()->setName("SegBufferReaderExecStream1"); 01078 01079 ExecStreamEmbryo readerStreamEmbryo2; 01080 readerStreamEmbryo2.init( 01081 new SegBufferReaderExecStream(), 01082 readerParams); 01083 readerStreamEmbryo2.getStream()->setName("SegBufferReaderExecStream2"); 01084 01085 std::vector<std::vector > interStreamEmbryosList; 01086 std::vector readerInput; 01087 readerInput.push_back(readerStreamEmbryo1); 01088 if (earlyClose) { 01089 SegBufferExecStreamParams bufParams; 01090 bufParams.scratchAccessor.pSegment = pRandomSegment; 01091 bufParams.scratchAccessor.pCacheAccessor = pCacheAccessor; 01092 bufParams.multipass = false; 01093 01094 ExecStreamEmbryo bufStreamEmbryo; 01095 bufStreamEmbryo.init(new SegBufferExecStream(),bufParams); 01096 bufStreamEmbryo.getStream()->setName("SegBufferExecStream1"); 01097 readerInput.push_back(bufStreamEmbryo); 01098 } 01099 interStreamEmbryosList.push_back(readerInput); 01100 01101 readerInput.clear(); 01102 readerInput.push_back(readerStreamEmbryo2); 01103 if (earlyClose) { 01104 SegBufferExecStreamParams bufParams; 01105 bufParams.scratchAccessor.pSegment = pRandomSegment; 01106 bufParams.scratchAccessor.pCacheAccessor = pCacheAccessor; 01107 if (restartable) { 01108 bufParams.multipass = true; 01109 } 01110 01111 ExecStreamEmbryo bufStreamEmbryo; 01112 bufStreamEmbryo.init(new SegBufferExecStream(),bufParams); 01113 bufStreamEmbryo.getStream()->setName("SegBufferExecStream2"); 01114 readerInput.push_back(bufStreamEmbryo); 01115 } 01116 interStreamEmbryosList.push_back(readerInput); 01117 01118 MergeExecStreamParams mergeParams; 01119 CartesianJoinExecStreamParams joinParams; 01120 if (restartable) { 01121 joinParams.leftOuter = false; 01122 } else { 01123 mergeParams.outputTupleDesc.push_back(attrDesc); 01124 if (getDegreeOfParallelism() != 1) { 01125 mergeParams.isParallel = true; 01126 } 01127 } 01128 01129 ExecStreamEmbryo execStreamEmbryo; 01130 if (restartable) { 01131 execStreamEmbryo.init(new CartesianJoinExecStream(), joinParams); 01132 execStreamEmbryo.getStream()->setName("CartesianJoinExecStream"); 01133 } else { 01134 execStreamEmbryo.init(new MergeExecStream(), mergeParams); 01135 execStreamEmbryo.getStream()->setName("MergeExecStream"); 01136 } 01137 01138 SharedExecStream pOutputStream = 01139 prepareDAG( 01140 mockStreamEmbryo, 01141 writerStreamEmbryo, 01142 interStreamEmbryosList, 01143 execStreamEmbryo); 01144 01145 int64_t zero = 0; 01146 TupleDescriptor expectedDesc; 01147 expectedDesc.push_back(attrDesc); 01148 if (restartable) { 01149 expectedDesc.push_back(attrDesc); 01150 } 01151 TupleData expectedTuple; 01152 expectedTuple.compute(expectedDesc); 01153 expectedTuple[0].pData = reinterpret_cast(&zero); 01154 if (restartable) { 01155 expectedTuple[1].pData = reinterpret_cast(&zero); 01156 } 01157 01158 verifyConstantOutput( 01159 *pOutputStream, 01160 expectedTuple, 01161 restartable ? nRows * nRows : 2 * nRows); 01162 }

| void ExecStreamTestSuite::testScratchBufferExecStream | ( | | ) | | ----------------------------------------------------- | - | | - |

| void ExecStreamTestSuite::testDoubleBufferExecStream | ( | | ) | | ---------------------------------------------------- | - | | - |

| void ExecStreamTestSuite::testCopyExecStream | ( | | ) | | -------------------------------------------- | - | | - |

| void ExecStreamTestSuite::testMergeExecStream | ( | | ) | | --------------------------------------------- | - | | - |

| void ExecStreamTestSuite::testSegBufferExecStream | ( | | ) | | ------------------------------------------------- | - | | - |

| void ExecStreamTestSuite::testCountAggExecStream | ( | | ) | | ------------------------------------------------ | - | | - |

Definition at line 296 of file ExecStreamTestSuite.cpp.

References AGG_FUNC_COUNT, AggInvocation::aggFunction, SortedAggExecStreamParams::aggInvocations, ExecStreamEmbryo::getStream(), SortedAggExecStreamParams::groupByKeyCount, AggInvocation::iInputAttr, ExecStreamEmbryo::init(), StandardTypeDescriptorFactory::newDataType(), ExecStreamUnitTestBase::prepareTransformGraph(), STANDARD_TYPE_INT_64, and ExecStreamUnitTestBase::verifyOutput().

Referenced by ParallelExecStreamSchedulerTest::ParallelExecStreamSchedulerTest().

| void ExecStreamTestSuite::testSumAggExecStream | ( | | ) | | ---------------------------------------------- | - | | - |

Definition at line 333 of file ExecStreamTestSuite.cpp.

References AGG_FUNC_SUM, AggInvocation::aggFunction, SortedAggExecStreamParams::aggInvocations, ExecStreamEmbryo::getStream(), SortedAggExecStreamParams::groupByKeyCount, AggInvocation::iInputAttr, ExecStreamEmbryo::init(), StandardTypeDescriptorFactory::newDataType(), ExecStreamUnitTestBase::prepareTransformGraph(), STANDARD_TYPE_INT_64, and ExecStreamUnitTestBase::verifyOutput().

Referenced by ParallelExecStreamSchedulerTest::ParallelExecStreamSchedulerTest().

| void ExecStreamTestSuite::testReshapeExecStream | ( | | ) | | ----------------------------------------------- | - | | - |

| void ExecStreamTestSuite::testSingleValueAggExecStream | ( | | ) | | ------------------------------------------------------ | - | | - |

Definition at line 583 of file ExecStreamTestSuite.cpp.

References AGG_FUNC_SINGLE_VALUE, AggInvocation::aggFunction, SortedAggExecStreamParams::aggInvocations, ExecStreamEmbryo::getStream(), SortedAggExecStreamParams::groupByKeyCount, AggInvocation::iInputAttr, ExecStreamEmbryo::init(), StandardTypeDescriptorFactory::newDataType(), MockProducerExecStreamParams::nRows, SingleOutputExecStreamParams::outputTupleDesc, MockProducerExecStreamParams::pGenerator, ExecStreamUnitTestBase::prepareTransformGraph(), STANDARD_TYPE_INT_64, and ExecStreamUnitTestBase::verifyOutput().

Referenced by ParallelExecStreamSchedulerTest::ParallelExecStreamSchedulerTest().

| void ExecStreamTestSuite::testMergeImplicitPullInputs | ( | | ) | | ----------------------------------------------------- | - | | - |

Definition at line 645 of file ExecStreamTestSuite.cpp.

References COMP_EQ, TupleAccessor::compute(), TupleData::compute(), FixedBuffer, TupleAccessor::getMaxByteCount(), ExecStreamEmbryo::getStream(), ExecStreamEmbryo::init(), TupleAccessor::marshal(), SegBufferExecStreamParams::multipass, StandardTypeDescriptorFactory::newDataType(), MockProducerExecStreamParams::nRows, SingleOutputExecStreamParams::outputTupleDesc, ExecStreamTestBase::pCacheAccessor, MockProducerExecStreamParams::pGenerator, SegStorageTestBase::pRandomSegment, ExecStreamUnitTestBase::prepareDAG(), STANDARD_TYPE_INT_64, and ExecStreamUnitTestBase::verifyOutput().

Referenced by ParallelExecStreamSchedulerTest::ParallelExecStreamSchedulerTest().

00646 { 00647
00648
00649
00650
00651
00652 00653 StandardTypeDescriptorFactory stdTypeFactory; 00654 TupleAttributeDescriptor attrDesc( 00655 stdTypeFactory.newDataType(STANDARD_TYPE_INT_64)); 00656 TupleAttributeDescriptor nullAttrDesc( 00657 stdTypeFactory.newDataType(STANDARD_TYPE_INT_64), 00658 true, sizeof(int64_t)); 00659 00660
00661
00662
00663
00664 00665 MockProducerExecStreamParams mockParams; 00666 mockParams.outputTupleDesc.push_back(attrDesc); 00667
00668 uint nInputs = 5; 00669 uint nRows = nInputs * 4000; 00670 mockParams.nRows = nRows; 00671 vector<boost::shared_ptr<ColumnGenerator > > columnGenerator; 00672 columnGenerator.push_back( 00673 SharedInt64ColumnGenerator( 00674 new DupRepeatingSeqColumnGenerator(nInputs, 1))); 00675 mockParams.pGenerator.reset( 00676 new CompositeExecStreamGenerator(columnGenerator)); 00677 00678 ExecStreamEmbryo mockStreamEmbryo; 00679 mockStreamEmbryo.init(new MockProducerExecStream(), mockParams); 00680 mockStreamEmbryo.getStream()->setName("MockProducerExecStream"); 00681 00682
00683
00684
00685 00686 SplitterExecStreamParams splitterParams; 00687 ExecStreamEmbryo splitterStreamEmbryo; 00688 splitterStreamEmbryo.init(new SplitterExecStream(), splitterParams); 00689 splitterStreamEmbryo.getStream()->setName("SplitterExecStream"); 00690 00691 vector<vector > reshapeEmbryoStreamList; 00692 for (int i = 0; i < nInputs; i++) { 00693 ReshapeExecStreamParams rsParams; 00694 boost::shared_array pBuffer; 00695 rsParams.compOp = COMP_EQ; 00696 int64_t key = i; 00697 TupleDescriptor compareDesc; 00698
00699 compareDesc.push_back(nullAttrDesc); 00700 TupleData compareData; 00701 compareData.compute(compareDesc); 00702 compareData[0].pData = (PConstBuffer) &key; 00703 TupleAccessor tupleAccessor; 00704 tupleAccessor.compute(compareDesc); 00705 pBuffer.reset(new FixedBuffer[tupleAccessor.getMaxByteCount()]); 00706 tupleAccessor.marshal(compareData, pBuffer.get()); 00707 rsParams.pCompTupleBuffer = pBuffer; 00708 TupleProjection tupleProj; 00709 tupleProj.push_back(0); 00710 rsParams.inputCompareProj = tupleProj; 00711 rsParams.outputProj = tupleProj; 00712 00713 ExecStreamEmbryo rsStreamEmbryo; 00714 rsStreamEmbryo.init(new ReshapeExecStream(), rsParams); 00715 std::ostringstream oss; 00716 oss << "ReshapeExecStream" << "#" << i; 00717 rsStreamEmbryo.getStream()->setName(oss.str()); 00718 00719 vector reshapeStreamEmbryo; 00720 reshapeStreamEmbryo.push_back(rsStreamEmbryo); 00721 00722
00723
00724
00725 if (i != 0) { 00726 SegBufferExecStreamParams bufParams; 00727 bufParams.scratchAccessor.pSegment = pRandomSegment; 00728 bufParams.scratchAccessor.pCacheAccessor = pCacheAccessor; 00729 bufParams.multipass = false; 00730 00731 ExecStreamEmbryo bufStreamEmbryo; 00732 bufStreamEmbryo.init(new SegBufferExecStream(), bufParams); 00733 std::ostringstream oss; 00734 oss << "SegBufferExecStream" << "#" << i; 00735 bufStreamEmbryo.getStream()->setName(oss.str()); 00736 00737 reshapeStreamEmbryo.push_back(bufStreamEmbryo); 00738 } 00739 reshapeEmbryoStreamList.push_back(reshapeStreamEmbryo); 00740 } 00741 00742
00743 MergeExecStreamParams mergeParams; 00744 mergeParams.outputTupleDesc.push_back(attrDesc); 00745 00746 ExecStreamEmbryo mergeStreamEmbryo; 00747 mergeStreamEmbryo.init(new MergeExecStream(), mergeParams); 00748 mergeStreamEmbryo.getStream()->setName("MergeExecStream"); 00749 00750 SharedExecStream pOutputStream = 00751 prepareDAG( 00752 mockStreamEmbryo, 00753 splitterStreamEmbryo, 00754 reshapeEmbryoStreamList, 00755 mergeStreamEmbryo); 00756 00757
00758
00759 StairCaseExecStreamGenerator expectedResultGenerator(1, nRows / nInputs); 00760 00761 verifyOutput(*pOutputStream, nRows, expectedResultGenerator); 00762 }

| void ExecStreamTestSuite::testSplitterPlusBarrier | ( | | ) | | ------------------------------------------------- | - | | - |

Definition at line 963 of file ExecStreamTestSuite.cpp.

References AGG_FUNC_COUNT, AggInvocation::aggFunction, BARRIER_RET_ANY_INPUT, ExecStreamEmbryo::getStream(), AggInvocation::iInputAttr, ExecStreamEmbryo::init(), StandardTypeDescriptorFactory::newDataType(), ExecStreamUnitTestBase::prepareDAG(), BarrierExecStreamParams::returnMode, STANDARD_TYPE_INT_64, and ExecStreamUnitTestBase::verifyOutput().

Referenced by ParallelExecStreamSchedulerTest::ParallelExecStreamSchedulerTest().

| void ExecStreamTestSuite::testCartesianJoinExecStreamOuter | ( | | ) | [inline] | | ---------------------------------------------------------- | - | | - | ---------- |

| void ExecStreamTestSuite::testCartesianJoinExecStreamInner | ( | | ) | [inline] | | ---------------------------------------------------------- | - | | - | ---------- |

| void ExecStreamTestSuite::testGroupAggExecStream1 | ( | | ) | [inline] | | ------------------------------------------------- | - | | - | ---------- |

| void ExecStreamTestSuite::testGroupAggExecStream2 | ( | | ) | [inline] | | ------------------------------------------------- | - | | - | ---------- |

| void ExecStreamTestSuite::testGroupAggExecStream3 | ( | | ) | [inline] | | ------------------------------------------------- | - | | - | ---------- |

| void ExecStreamTestSuite::testGroupAggExecStream4 | ( | | ) | [inline] | | ------------------------------------------------- | - | | - | ---------- |

| void ExecStreamTestSuite::testReshapeExecStreamCastFilter | ( | | ) | [inline] | | --------------------------------------------------------- | - | | - | ---------- |

| void ExecStreamTestSuite::testReshapeExecStreamNoCastFilter | ( | | ) | [inline] | | ----------------------------------------------------------- | - | | - | ---------- |

| void ExecStreamTestSuite::testReshapeExecStreamDynamicParams | ( | | ) | [inline] | | ------------------------------------------------------------ | - | | - | ---------- |

| void ExecStreamTestSuite::testBTreeInsertExecStreamStaticBTree | ( | | ) | [inline] | | -------------------------------------------------------------- | - | | - | ---------- |

| void ExecStreamTestSuite::testBTreeInsertExecStreamDynamicBTree | ( | | ) | [inline] | | --------------------------------------------------------------- | - | | - | ---------- |

| void ExecStreamTestSuite::testNestedLoopJoinExecStream1 | ( | | ) | [inline] | | ------------------------------------------------------- | - | | - | ---------- |

| void ExecStreamTestSuite::testNestedLoopJoinExecStream2 | ( | | ) | [inline] | | ------------------------------------------------------- | - | | - | ---------- |

| void ExecStreamTestSuite::testSegBufferReaderWriterExecStream1 | ( | | ) | [inline] | | -------------------------------------------------------------- | - | | - | ---------- |

| void ExecStreamTestSuite::testSegBufferReaderWriterExecStream2 | ( | | ) | [inline] | | -------------------------------------------------------------- | - | | - | ---------- |

| void ExecStreamTestSuite::testSegBufferReaderWriterExecStream3 | ( | | ) | [inline] | | -------------------------------------------------------------- | - | | - | ---------- |

| void ExecStreamTestSuite::testSegBufferReaderWriterExecStream4 | ( | | ) | [inline] | | -------------------------------------------------------------- | - | | - | ---------- |

Defines and prepares a graph consisting of one source stream and one transform stream.

Parameters:

Returns:

output buffer stream

Definition at line 48 of file ExecStreamUnitTestBase.cpp.

Referenced by LcsClusterReplaceExecStreamTest::loadCluster(), LcsRowScanExecStreamTest::loadOneCluster(), ExecStreamUnitTestBase::prepareSourceGraph(), LcsClusterReplaceExecStreamTest::replaceCluster(), LcsMultiClusterAppendTest::scanCols(), LbmSplicerExecStreamTest::spliceInput(), testBTreeInsertExecStream(), CollectExecStreamTestSuite::testCollectCollectUncollectUncollect(), CollectExecStreamTestSuite::testCollectInts(), CollectExecStreamTestSuite::testCollectUncollect(), CalcExecStreamTestSuite::testConstant(), testCopyExecStream(), testCountAggExecStream(), LhxAggExecStreamTest::testCountImpl(), testDoubleBufferExecStream(), testGroupAggExecStreamNrows(), LhxAggExecStreamTest::testGroupCountImpl(), ExternalSortExecStreamTest::testImpl(), LcsClusterAppendExecStreamTest::testLoadMultiCol(), LcsClusterAppendExecStreamTest::testLoadSingleCol(), LbmNormalizerExecStreamTest::testNormalizer(), testReshapeExecStream(), LcsRowScanExecStreamTest::testSampleScanCols(), LcsRowScanExecStreamTest::testScanCols(), LbmSearchTest::testScanIdx(), LcsClusterAppendExecStreamTest::testScanMultiCol(), LcsClusterAppendExecStreamTest::testScanSingleCol(), testScratchBufferExecStream(), testSegBufferExecStream(), testSingleValueAggExecStream(), LhxAggExecStreamTest::testSingleValueImpl(), LbmSortedAggExecStreamTest::testSortedAgg(), testSumAggExecStream(), LhxAggExecStreamTest::testSumImpl(), LbmUnionExecStreamTest::testUnion(), and LcsClusterReplaceExecStreamTest::verifyCluster().

00051 { 00052 std::vector transforms; 00053 transforms.push_back(transformStreamEmbryo); 00054 return prepareTransformGraph(sourceStreamEmbryo, transforms); 00055 }

Defines and prepares a graph consisting of one source stream and one or multiple transform streams.

Parameters:

Returns:

output buffer stream

Definition at line 57 of file ExecStreamUnitTestBase.cpp.

References BUFPROV_PRODUCER, ExecStreamEmbryo::getStream(), ExecStreamUnitTestBase::pGraph, and ExecStreamUnitTestBase::pGraphEmbryo.

00060 { 00061 pGraphEmbryo->saveStreamEmbryo(sourceStreamEmbryo); 00062 std::vector::iterator it; 00063 00064
00065 for (it = transforms.begin(); it != transforms.end(); ++it) { 00066 pGraphEmbryo->saveStreamEmbryo(*it); 00067 } 00068 00069
00070 ExecStreamEmbryo& previousStream = sourceStreamEmbryo; 00071 for (it = transforms.begin(); it != transforms.end(); ++it) { 00072 pGraphEmbryo->addDataflow( 00073 previousStream.getStream()->getName(), 00074 (*it).getStream()->getName()); 00075 previousStream = *it; 00076 } 00077 00078 SharedExecStream pAdaptedStream = 00079 pGraphEmbryo->addAdapterFor( 00080 previousStream.getStream()->getName(), 00081 0, 00082 BUFPROV_PRODUCER); 00083 pGraph->addOutputDataflow(pAdaptedStream->getStreamId()); 00084 00085 pGraphEmbryo->prepareGraph(shared_from_this(), ""); 00086 return pAdaptedStream; 00087 }

Defines and prepares a graph consisting of two source streams and one confluence stream.

Parameters:

Returns:

output buffer stream

Definition at line 89 of file ExecStreamUnitTestBase.cpp.

Referenced by ExecStreamUnitTestBase::prepareConfluenceGraph(), testCartesianJoinExecStream(), CorrelationJoinExecStreamTestSuite::testCorrelationJoin(), LcsRowScanExecStreamTest::testFilterCols(), ExecStreamGovernorTest::testGovernor(), LhxJoinExecStreamTest::testImpl(), LbmIntersectExecStreamTest::testIntersect(), testMergeExecStream(), LbmMinusExecStreamTest::testMinus(), and testNestedLoopJoinExecStream().

00093 { 00094 std::vector sourceStreamEmbryos; 00095 sourceStreamEmbryos.push_back(sourceStreamEmbryo1); 00096 sourceStreamEmbryos.push_back(sourceStreamEmbryo2); 00097 return prepareConfluenceGraph(sourceStreamEmbryos, confluenceStreamEmbryo); 00098 }

Defines and prepares a graph consisting of a list of source streams and one confluence stream.

Parameters:

Returns:

output buffer stream

Definition at line 155 of file ExecStreamUnitTestBase.cpp.

References ExecStreamUnitTestBase::prepareConfluenceGraph().

00158 { 00159 std::vector<std::vector > sourceStreamEmbryosList; 00160 std::vector::iterator it; 00161 std::vector sourceStreamList; 00162 for (it = sourceStreamEmbryos.begin(); it != sourceStreamEmbryos.end(); 00163 it++) 00164 { 00165 sourceStreamList.clear(); 00166 sourceStreamList.push_back(*it); 00167 sourceStreamEmbryosList.push_back(sourceStreamList); 00168 } 00169 00170 return 00171 prepareConfluenceGraph(sourceStreamEmbryosList, confluenceStreamEmbryo); 00172 }

Defines and prepares a graph consisting of one or more source streams and one confluence stream.

Each source stream can be a list of streams.

Parameters:

Returns:

output buffer stream

Definition at line 174 of file ExecStreamUnitTestBase.cpp.

References BUFPROV_PRODUCER, ExecStreamEmbryo::getStream(), ExecStreamUnitTestBase::pGraph, and ExecStreamUnitTestBase::pGraphEmbryo.

00177 { 00178 pGraphEmbryo->saveStreamEmbryo(confluenceStreamEmbryo); 00179 00180 for (int i = 0; i < sourceStreamEmbryosList.size(); i++) { 00181 for (int j = 0; j < sourceStreamEmbryosList[i].size(); j++) { 00182 pGraphEmbryo->saveStreamEmbryo(sourceStreamEmbryosList[i][j]); 00183 } 00184 00185
00186 for (int j = 1; j < sourceStreamEmbryosList[i].size(); j++) { 00187 pGraphEmbryo->addDataflow( 00188 sourceStreamEmbryosList[i][j - 1].getStream()->getName(), 00189 sourceStreamEmbryosList[i][j].getStream()->getName()); 00190 } 00191 pGraphEmbryo->addDataflow( 00192 sourceStreamEmbryosList[i].back().getStream()->getName(), 00193 confluenceStreamEmbryo.getStream()->getName()); 00194 } 00195 00196 SharedExecStream pAdaptedStream = 00197 pGraphEmbryo->addAdapterFor( 00198 confluenceStreamEmbryo.getStream()->getName(), 0, 00199 BUFPROV_PRODUCER); 00200 pGraph->addOutputDataflow( 00201 pAdaptedStream->getStreamId()); 00202 00203 pGraphEmbryo->prepareGraph(shared_from_this(), ""); 00204 00205 return pAdaptedStream; 00206 }

Defines and prepares a graph consisting of two source streams, one confluence stream, and one transform stream.

Parameters:

Returns:

output buffer stream

Definition at line 100 of file ExecStreamUnitTestBase.cpp.

References BUFPROV_PRODUCER, ExecStreamEmbryo::getStream(), ExecStreamUnitTestBase::pGraph, and ExecStreamUnitTestBase::pGraphEmbryo.

Referenced by LhxJoinExecStreamTest::testImpl(), and LbmMinusExecStreamTest::testRestartingMinus().

00105 { 00106 std::vector sourceStreamEmbryos; 00107 sourceStreamEmbryos.push_back(sourceStreamEmbryo1); 00108 sourceStreamEmbryos.push_back(sourceStreamEmbryo2); 00109 00110 std::vector::iterator it; 00111 00112 for (it = sourceStreamEmbryos.begin(); it != sourceStreamEmbryos.end(); 00113 ++it) 00114 { 00115 pGraphEmbryo->saveStreamEmbryo(*it); 00116 } 00117 pGraphEmbryo->saveStreamEmbryo(confluenceStreamEmbryo); 00118 00119 for (it = sourceStreamEmbryos.begin(); it != sourceStreamEmbryos.end(); 00120 ++it) 00121 { 00122 pGraphEmbryo->addDataflow( 00123 (*it).getStream()->getName(), 00124 confluenceStreamEmbryo.getStream()->getName()); 00125 } 00126 00127 std::vector transforms; 00128 transforms.push_back(transformStreamEmbryo); 00129 ExecStreamEmbryo& previousStream = confluenceStreamEmbryo; 00130 00131
00132 for (it = transforms.begin(); it != transforms.end(); ++it) { 00133 pGraphEmbryo->saveStreamEmbryo(*it); 00134 } 00135 00136 for (it = transforms.begin(); it != transforms.end(); ++it) { 00137 pGraphEmbryo->addDataflow( 00138 previousStream.getStream()->getName(), 00139 (*it).getStream()->getName()); 00140 previousStream = *it; 00141 } 00142 00143 00144 SharedExecStream pAdaptedStream = 00145 pGraphEmbryo->addAdapterFor( 00146 previousStream.getStream()->getName(), 00147 0, 00148 BUFPROV_PRODUCER); 00149 pGraph->addOutputDataflow(pAdaptedStream->getStreamId()); 00150 00151 pGraphEmbryo->prepareGraph(shared_from_this(), ""); 00152 return pAdaptedStream; 00153 }

Defines and prepares a graph consisting of a source, a splitter, and one or more parallel transform streams which flow together into a confluence stream.

Parameters:

Returns:

output buffer stream or null stream if createSink is false

Definition at line 208 of file ExecStreamUnitTestBase.cpp.

Referenced by LcsMultiClusterAppendTest::loadClusters(), LbmSearchTest::loadTableAndIndex(), LbmLoadBitmapTest::testLoad(), testMergeImplicitPullInputs(), testSegBufferReaderWriterExecStream(), and testSplitterPlusBarrier().

00215 { 00216 std::vector<std::vector > listOfList; 00217 00218
00219
00220
00221 for (uint i = 0; i < interStreamEmbryos.size(); i++) { 00222 std::vector interStreamEmbryoList; 00223 00224 interStreamEmbryoList.push_back(interStreamEmbryos[i]); 00225 listOfList.push_back(interStreamEmbryoList); 00226 } 00227 return prepareDAG( 00228 srcStreamEmbryo, splitterStreamEmbryo, listOfList, destStreamEmbryo, 00229 createSink, saveSrc); 00230 }

Defines and prepares a graph consisting of a source, a splitter, and one or more parallel transform streams which flow together into a confluence stream.

Parameters:

Returns:

output buffer stream or null stream if createSink is false

Definition at line 232 of file ExecStreamUnitTestBase.cpp.

References BUFPROV_PRODUCER, ExecStreamEmbryo::getStream(), ExecStreamUnitTestBase::pGraph, and ExecStreamUnitTestBase::pGraphEmbryo.

00239 { 00240 if (saveSrc) { 00241 pGraphEmbryo->saveStreamEmbryo(srcStreamEmbryo); 00242 } 00243 pGraphEmbryo->saveStreamEmbryo(splitterStreamEmbryo); 00244 00245
00246 for (int i = 0; i < interStreamEmbryos.size(); i++) { 00247 for (int j = 0; j < interStreamEmbryos[i].size(); j++) { 00248 pGraphEmbryo->saveStreamEmbryo(interStreamEmbryos[i][j]); 00249 } 00250 00251
00252 for (int j = 1; j < interStreamEmbryos[i].size(); j++) { 00253 pGraphEmbryo->addDataflow( 00254 interStreamEmbryos[i][j - 1].getStream()->getName(), 00255 interStreamEmbryos[i][j].getStream()->getName()); 00256 } 00257 } 00258 00259 pGraphEmbryo->saveStreamEmbryo(destStreamEmbryo); 00260 00261 pGraphEmbryo->addDataflow( 00262 srcStreamEmbryo.getStream()->getName(), 00263 splitterStreamEmbryo.getStream()->getName()); 00264 00265
00266 for (int i = 0; i < interStreamEmbryos.size(); i++) { 00267 pGraphEmbryo->addDataflow( 00268 splitterStreamEmbryo.getStream()->getName(), 00269 interStreamEmbryos[i][0].getStream()->getName()); 00270 pGraphEmbryo->addDataflow( 00271 interStreamEmbryos[i].back().getStream()->getName(), 00272 destStreamEmbryo.getStream()->getName()); 00273 } 00274 00275 SharedExecStream pAdaptedStream; 00276 00277 if (createSink) { 00278 pAdaptedStream = pGraphEmbryo->addAdapterFor( 00279 destStreamEmbryo.getStream()->getName(), 0, 00280 BUFPROV_PRODUCER); 00281 pGraph->addOutputDataflow(pAdaptedStream->getStreamId()); 00282 00283 pGraphEmbryo->prepareGraph(shared_from_this(), ""); 00284 } 00285 00286 return pAdaptedStream; 00287 }

Executes the prepared stream graph and verifies that its output matches that produced by a value generator.

Parameters:

Definition at line 325 of file ExecStreamUnitTestBase.cpp.

References TupleData::compute(), EXECBUF_EOS, MockProducerExecStreamGenerator::generateValue(), ExecStreamUnitTestBase::pGraph, ExecStreamTestBase::pResourceGovernor, and ExecStreamTestBase::pScheduler.

Referenced by LcsClusterReplaceExecStreamTest::loadCluster(), LcsMultiClusterAppendTest::loadClusters(), LcsRowScanExecStreamTest::loadOneCluster(), LbmSearchTest::loadTableAndIndex(), LcsClusterReplaceExecStreamTest::replaceCluster(), LcsMultiClusterAppendTest::scanCols(), LbmSplicerExecStreamTest::spliceInput(), testBTreeInsertExecStream(), CollectExecStreamTestSuite::testCollectCollectUncollectUncollect(), CollectExecStreamTestSuite::testCollectUncollect(), CorrelationJoinExecStreamTestSuite::testCorrelationJoin(), testCountAggExecStream(), LhxAggExecStreamTest::testCountImpl(), testDoubleBufferExecStream(), LcsRowScanExecStreamTest::testFilterCols(), testGroupAggExecStreamNrows(), LhxAggExecStreamTest::testGroupCountImpl(), LhxJoinExecStreamTest::testImpl(), ExternalSortExecStreamTest::testImpl(), LbmLoadBitmapTest::testLoad(), LcsClusterAppendExecStreamTest::testLoadMultiCol(), LcsClusterAppendExecStreamTest::testLoadSingleCol(), testMergeImplicitPullInputs(), testNestedLoopJoinExecStream(), LbmNormalizerExecStreamTest::testNormalizer(), testReshapeExecStream(), LbmMinusExecStreamTest::testRestartingMinus(), LcsRowScanExecStreamTest::testSampleScanCols(), LcsRowScanExecStreamTest::testScanCols(), LcsClusterAppendExecStreamTest::testScanMultiCol(), LcsClusterAppendExecStreamTest::testScanSingleCol(), testScratchBufferExecStream(), testSingleValueAggExecStream(), LhxAggExecStreamTest::testSingleValueImpl(), LbmSortedAggExecStreamTest::testSortedAgg(), testSplitterPlusBarrier(), testSumAggExecStream(), LhxAggExecStreamTest::testSumImpl(), and LcsClusterReplaceExecStreamTest::verifyCluster().

00330 { 00331
00332 00333 pResourceGovernor->requestResources(*pGraph); 00334 pGraph->open(); 00335 pScheduler->start(); 00336 uint nRows = 0; 00337 for (;;) { 00338 ExecStreamBufAccessor &bufAccessor = 00339 pScheduler->readStream(stream); 00340 if (bufAccessor.getState() == EXECBUF_EOS) { 00341 break; 00342 } 00343 BOOST_REQUIRE(bufAccessor.isConsumptionPossible()); 00344 const uint nCol = 00345 bufAccessor.getConsumptionTupleAccessor().size(); 00346 BOOST_REQUIRE(nCol == bufAccessor.getTupleDesc().size()); 00347 BOOST_REQUIRE(nCol >= 1); 00348 TupleData inputTuple; 00349 inputTuple.compute(bufAccessor.getTupleDesc()); 00350 for (;;) { 00351 if (!bufAccessor.demandData()) { 00352 break; 00353 } 00354 BOOST_REQUIRE(nRows < nRowsExpected); 00355 bufAccessor.unmarshalTuple(inputTuple); 00356 for (int col = 0; col < nCol; ++col) { 00357 int64_t actualValue = 00358 *reinterpret_cast<int64_t const *>(inputTuple[col].pData); 00359 int64_t expectedValue = generator.generateValue(nRows, col); 00360 if (actualValue != expectedValue) { 00361 std::cout << "(Row, Col) = (" << nRows << ", " << col <<")" 00362 << std::endl; 00363 BOOST_CHECK_EQUAL(expectedValue,actualValue); 00364 return; 00365 } 00366 } 00367 bufAccessor.consumeTuple(); 00368 ++nRows; 00369 if (stopEarly && nRows == nRowsExpected) { 00370 return; 00371 } 00372 } 00373 } 00374 BOOST_CHECK_EQUAL(nRowsExpected,nRows); 00375 }

Executes the prepared stream graph and verifies that all output tuples matche an expected and given one.

Parameters:

Definition at line 377 of file ExecStreamUnitTestBase.cpp.

References TupleData::compute(), EXECBUF_EOS, ExecStreamUnitTestBase::pGraph, ExecStreamTestBase::pResourceGovernor, TuplePrinter::print(), and ExecStreamTestBase::pScheduler.

Referenced by testCartesianJoinExecStream(), CollectExecStreamTestSuite::testCollectInts(), CalcExecStreamTestSuite::testConstant(), testCopyExecStream(), ExecStreamGovernorTest::testGovernor(), testMergeExecStream(), testSegBufferExecStream(), and testSegBufferReaderWriterExecStream().

00381 { 00382
00383 00384 pResourceGovernor->requestResources(*pGraph); 00385 pGraph->open(); 00386 pScheduler->start(); 00387 uint nRows = 0; 00388 for (;;) { 00389 ExecStreamBufAccessor &bufAccessor = 00390 pScheduler->readStream(stream); 00391 if (bufAccessor.getState() == EXECBUF_EOS) { 00392 break; 00393 } 00394 BOOST_REQUIRE(bufAccessor.isConsumptionPossible()); 00395 00396 if (!bufAccessor.demandData()) { 00397 break; 00398 } 00399 BOOST_REQUIRE(nRows < nRowsExpected); 00400 00401 TupleData actualTuple; 00402 actualTuple.compute(bufAccessor.getTupleDesc()); 00403 bufAccessor.unmarshalTuple(actualTuple); 00404 00405 int c = bufAccessor.getTupleDesc().compareTuples( 00406 expectedTuple, actualTuple); 00407 bufAccessor.consumeTuple(); 00408 ++nRows; 00409 if (c) { 00410 #if 1 00411 TupleDescriptor statusDesc = bufAccessor.getTupleDesc(); 00412 TuplePrinter tuplePrinter; 00413 tuplePrinter.print(std::cout, statusDesc, actualTuple); 00414 tuplePrinter.print(std::cout, statusDesc, expectedTuple); 00415 std::cout << std::endl; 00416 #endif 00417 BOOST_CHECK_EQUAL(0,c); 00418 break; 00419 } 00420 } 00421 BOOST_CHECK_EQUAL(nRowsExpected, nRows); 00422 }

Executes the prepared stream graph and verifies the resultant tuples against a set of tuples supplied in an input buffer.

Parameters:

Definition at line 424 of file ExecStreamUnitTestBase.cpp.

References TupleDescriptor::compareTuples(), TupleData::compute(), TupleAccessor::compute(), EXECBUF_EOS, TupleAccessor::getCurrentByteCount(), ExecStreamUnitTestBase::pGraph, ExecStreamTestBase::pResourceGovernor, ExecStreamTestBase::pScheduler, TupleAccessor::setCurrentTupleBuf(), and TupleAccessor::unmarshal().

Referenced by LbmIntersectExecStreamTest::testIntersect(), LbmMinusExecStreamTest::testMinus(), LbmSearchTest::testScanIdx(), and LbmUnionExecStreamTest::testUnion().

00429 { 00430
00431 00432 TupleAccessor expectedOutputAccessor; 00433 expectedOutputAccessor.compute(outputTupleDesc); 00434 TupleData expectedTuple(outputTupleDesc); 00435 uint bufOffset = 0; 00436 pResourceGovernor->requestResources(*pGraph); 00437 pGraph->open(); 00438 pScheduler->start(); 00439 uint nRows = 0; 00440 for (;;) { 00441 ExecStreamBufAccessor &bufAccessor = 00442 pScheduler->readStream(stream); 00443 if (bufAccessor.getState() == EXECBUF_EOS) { 00444 break; 00445 } 00446 BOOST_REQUIRE(bufAccessor.getTupleDesc() == outputTupleDesc); 00447 BOOST_REQUIRE(bufAccessor.isConsumptionPossible()); 00448 const uint nCol = 00449 bufAccessor.getConsumptionTupleAccessor().size(); 00450 BOOST_REQUIRE(nCol == bufAccessor.getTupleDesc().size()); 00451 BOOST_REQUIRE(nCol >= 1); 00452 TupleData inputTuple; 00453 inputTuple.compute(bufAccessor.getTupleDesc()); 00454 for (;;) { 00455 if (!bufAccessor.demandData()) { 00456 break; 00457 } 00458 BOOST_REQUIRE(nRows < nRowsExpected); 00459 bufAccessor.unmarshalTuple(inputTuple); 00460 expectedOutputAccessor.setCurrentTupleBuf( 00461 expectedBuffer + bufOffset); 00462 expectedOutputAccessor.unmarshal(expectedTuple); 00463 int c = outputTupleDesc.compareTuples(inputTuple, expectedTuple); 00464 if (c) { 00465 std::cout << "(Row) = (" << nRows << ")" 00466 << " -- Tuples don't match"<< std::endl; 00467 BOOST_CHECK_EQUAL(0,c); 00468 return; 00469 } 00470 bufAccessor.consumeTuple(); 00471 bufOffset += expectedOutputAccessor.getCurrentByteCount(); 00472 ++nRows; 00473 } 00474 } 00475 BOOST_CHECK_EQUAL(nRowsExpected,nRows); 00476 }

| void ExecStreamUnitTestBase::resetExecStreamTest | ( | | ) | [protected, inherited] | | ------------------------------------------------ | - | | - | ------------------------ |

Reset stream graph so multiple iterations of a method can be called within a single testcase.

Definition at line 305 of file ExecStreamUnitTestBase.cpp.

References ExecStreamTestBase::newScheduler(), ExecStreamTestBase::newStreamGraph(), ExecStreamTestBase::newStreamGraphEmbryo(), ExecStreamUnitTestBase::pGraph, ExecStreamUnitTestBase::pGraphEmbryo, ExecStreamTestBase::pResourceGovernor, ExecStreamTestBase::pScheduler, and ExecStreamUnitTestBase::tearDownExecStreamTest().

Referenced by LcsRowScanExecStreamTest::loadClusters(), LbmLoadBitmapTest::testAppend(), LcsRowScanExecStreamTest::testBernoulliSampling(), LcsClusterReplaceExecStreamTest::testClusterReplace(), LcsRowScanExecStreamTest::testCompressedFiltering(), LbmSplicerExecStreamTest::testLER5968(), LbmSplicerExecStreamTest::testLER6473(), LcsMultiClusterAppendTest::testLoad(), LcsClusterAppendExecStreamTest::testMultiColConstNewRoot(), LcsClusterAppendExecStreamTest::testMultiColConstOldRoot(), LcsClusterAppendExecStreamTest::testMultiColNoDupNewRoot(), LcsClusterAppendExecStreamTest::testMultiColNoDupOldRoot(), LcsClusterAppendExecStreamTest::testMultiColStairNewRoot(), LcsClusterAppendExecStreamTest::testMultiColStairOldRoot(), LbmSearchTest::testMultipleRanges(), ExecStreamGovernorTest::testReturnResources(), LbmSearchTest::testScanIdx(), LcsRowScanExecStreamTest::testScanPastEndOfCluster(), LcsRowScanExecStreamTest::testScans(), LcsClusterAppendExecStreamTest::testSingleColConstNewRoot(), LcsClusterAppendExecStreamTest::testSingleColConstOldRoot(), LcsClusterAppendExecStreamTest::testSingleColNoDupNewRoot(), LcsClusterAppendExecStreamTest::testSingleColNoDupOldRoot(), LcsClusterAppendExecStreamTest::testSingleColStairNewRoot(), LcsClusterAppendExecStreamTest::testSingleColStairOldRoot(), LbmSplicerExecStreamTest::testSpliceRids(), LbmSplicerExecStreamTest::testSpliceWithKeys(), and LcsRowScanExecStreamTest::testSystemSampling().

| void ExecStreamUnitTestBase::tearDownExecStreamTest | ( | | ) | [protected, virtual, inherited] | | --------------------------------------------------- | - | | - | --------------------------------- |

| void ExecStreamUnitTestBase::testCaseSetUp | ( | | ) | [virtual, inherited] | | ------------------------------------------ | - | | - | ---------------------- |

Equivalent to JUnit TestCase.setUp; this is called before each test case method is invoked.

Default is no-op.

Reimplemented from ExecStreamTestBase.

Reimplemented in LbmExecStreamTestBase, LbmLoadBitmapTest, LbmSearchTest, LbmSplicerExecStreamTest, LcsClusterAppendExecStreamTest, LcsClusterReplaceExecStreamTest, LcsMultiClusterAppendTest, LcsRowScanExecStreamTest, ExecStreamGovernorTest, and ExternalSortExecStreamTest.

Definition at line 289 of file ExecStreamUnitTestBase.cpp.

References ExecStreamTestBase::newStreamGraph(), ExecStreamTestBase::newStreamGraphEmbryo(), SegStorageTestBase::openRandomSegment(), CacheTestBase::pCache, ExecStreamTestBase::pCacheAccessor, ExecStreamUnitTestBase::pGraph, ExecStreamUnitTestBase::pGraphEmbryo, ExecStreamTestBase::pResourceGovernor, and ExecStreamTestBase::testCaseSetUp().

Referenced by ExternalSortExecStreamTest::testCaseSetUp(), ExecStreamGovernorTest::testCaseSetUp(), LcsRowScanExecStreamTest::testCaseSetUp(), LcsMultiClusterAppendTest::testCaseSetUp(), LcsClusterReplaceExecStreamTest::testCaseSetUp(), LcsClusterAppendExecStreamTest::testCaseSetUp(), LbmSplicerExecStreamTest::testCaseSetUp(), LbmLoadBitmapTest::testCaseSetUp(), and LbmExecStreamTestBase::testCaseSetUp().

| void ExecStreamTestBase::testCaseTearDown | ( | | ) | [virtual, inherited] | | ----------------------------------------- | - | | - | ---------------------- |

Equivalent to JUnit TestCase.tearDown; this is called after each test case method is invoked.

Default is no-op.

Reimplemented from CacheTestBase.

Reimplemented in LbmLoadBitmapTest, LbmSearchTest, LcsClusterAppendExecStreamTest, LcsClusterReplaceExecStreamTest, LcsMultiClusterAppendTest, and LcsRowScanExecStreamTest.

Definition at line 82 of file ExecStreamTestBase.cpp.

References ExecStreamTestBase::pCacheAccessor, ExecStreamTestBase::pResourceGovernor, ExecStreamTestBase::pScheduler, ExecStreamTestBase::tearDownExecStreamTest(), and CacheTestBase::testCaseTearDown().

Referenced by LcsRowScanExecStreamTest::testCaseTearDown(), LcsMultiClusterAppendTest::testCaseTearDown(), LcsClusterReplaceExecStreamTest::testCaseTearDown(), LcsClusterAppendExecStreamTest::testCaseTearDown(), LbmSearchTest::testCaseTearDown(), and LbmLoadBitmapTest::testCaseTearDown().

Reimplemented from CacheTestBase.

Reimplemented in SegmentTestBase.

Definition at line 31 of file SegStorageTestBase.cpp.

References SegStorageTestBase::openSegmentStorage(), and CacheTestBase::openStorage().

Referenced by SegStorageTestBase::openRandomSegment(), SegmentTestBase::openStorage(), LhxHashTableTest::testCaseSetUp(), ExecStreamTestBase::testCaseSetUp(), BTreeTest::testCaseSetUp(), BTreeReadersTest::testCaseSetUp(), LbmEntryTest::testCaseSetUp(), SegPageIterTest::testIter(), SegPageEntryIterTest::testIter(), SegStreamTest::testMarkReset(), SegStreamTest::testReadSeg(), LogicalTxnTest::testTxn(), SegStreamTest::testWriteSeg(), and SegStreamTest::testWriteSpillAndRead().

| void SegStorageTestBase::openRandomSegment | ( | | ) | [virtual, inherited] | | ------------------------------------------ | - | | - | ---------------------- |

| void SegStorageTestBase::closeLinearSegment | ( | | ) | [inherited] | | ------------------------------------------- | - | | - | ------------- |

| void SegStorageTestBase::closeRandomSegment | ( | | ) | [inherited] | | ------------------------------------------- | - | | - | ------------- |

| void SegStorageTestBase::closeVersionedRandomSegment | ( | | ) | [inherited] | | ---------------------------------------------------- | - | | - | ------------- |

| void SegStorageTestBase::closeSnapshotRandomSegment | ( | | ) | [inherited] | | --------------------------------------------------- | - | | - | ------------- |

| void SegStorageTestBase::closeStorage | ( | | ) | [virtual, inherited] | | ------------------------------------- | - | | - | ---------------------- |

Reimplemented from CacheTestBase.

Reimplemented in SnapshotSegmentTestBase, and VersionedSegmentTest.

Definition at line 102 of file SegStorageTestBase.cpp.

References SegStorageTestBase::closeLinearSegment(), SegStorageTestBase::closeRandomSegment(), CacheTestBase::closeStorage(), and SegStorageTestBase::closeVersionedRandomSegment().

Referenced by VersionedSegmentTest::closeStorage(), SnapshotSegmentTestBase::closeStorage(), SegStorageTestBase::openRandomSegment(), SegPageIterTest::testIter(), SegPageEntryIterTest::testIter(), SegStreamTest::testMarkReset(), SegStreamTest::testReadSeg(), SegmentTestBase::testSingleThread(), SegStreamTest::testWriteSeg(), and SegStreamTest::testWriteSpillAndRead().

| Cache & CacheTestBase::getCache | ( | | ) | [inherited] | | -------------------------------------------------- | - | | - | ------------- |

| SharedCache CacheTestBase::newCache | ( | | ) | [virtual, inherited] | | --------------------------------------------------------------------------------------------- | - | | - | ---------------------- |

Parses the command line.

format: [-v] [-t TEST | -all] {param=val}* [CONFIGFILE | -] Normally, the test program runs the default test cases. With the option "-all", runs the extra test cases as well. With the option "-t TEST", runs only the single test case named TEST. CONFIGFILE is read to load configuration parameters. Configuration parameters can also be set ad hoc, from the command line, as pairs name=val. These take precedence.

Definition at line 108 of file TestBase.cpp.

References TestBase::configMap, ConfigMap::dumpParams(), ConfigMap::isParamSet(), ConfigMap::mergeFrom(), TestBase::paramDictionaryFileName, ConfigMap::readParams(), TestBase::runAll, TestBase::runSingle, ConfigMap::setStringParam(), and verbose.

00109 { 00110 bool verbose = false; 00111 ConfigMap adhocMap; 00112 00113 for (int i = 1; i < argc; ++i) { 00114 std::string arg = argv[i]; 00115 if (argv[i][0] == '-') { 00116 if (arg == "-v") { 00117 verbose = true; 00118 } else if (arg == "-") { 00119 configMap.readParams(std::cin); 00120 } else if (arg == "-all") { 00121 runAll = true; 00122 } else if (arg == "-t") {
00123 permAssert(i + 1 < argc); 00124 runSingle = argv[++i]; 00125 } else if (arg[1] == 't') { 00126 runSingle = arg.substr(2); 00127 } 00128 } else { 00129 int i = arg.find("="); 00130 if ((0 < i) && (i < arg.size())) { 00131
00132 std::string key = arg.substr(0,i); 00133 std::string val = arg.substr(i + 1); 00134 adhocMap.setStringParam(key,val); 00135 } else { 00136
00137 std::ifstream configFile(arg.c_str()); 00138 assert(configFile.good()); 00139 configMap.readParams(configFile); 00140 } 00141 } 00142 } 00143 configMap.mergeFrom(adhocMap); 00144 00145
00146
00147 if (.isParamSet(paramDictionaryFileName)) { 00148 std::string dictFileName = "dictWords"; 00149 configMap.setStringParam(paramDictionaryFileName,dictFileName); 00150 } 00151 00152 if (verbose) { 00153 configMap.dumpParams(std::cout); 00154 } 00155 }

| TestSuite * TestBase::releaseTestSuite | ( | | ) | [inherited] | | ---------------------------------------------------------------------------------------------- | - | | - | ------------- |

Member Data Documentation

Definition at line 46 of file ExecStreamUnitTestBase.h.

Referenced by ExecStreamUnitTestBase::prepareConfluenceGraph(), ExecStreamUnitTestBase::prepareConfluenceTransformGraph(), ExecStreamUnitTestBase::prepareDAG(), ExecStreamUnitTestBase::prepareTransformGraph(), ExecStreamUnitTestBase::resetExecStreamTest(), LbmSplicerExecStreamTest::spliceInput(), ExecStreamUnitTestBase::tearDownExecStreamTest(), testBTreeInsertExecStream(), ExecStreamUnitTestBase::testCaseSetUp(), CorrelationJoinExecStreamTestSuite::testCorrelationJoin(), LhxJoinExecStreamTest::testImpl(), ExternalSortExecStreamTest::testImpl(), LbmLoadBitmapTest::testLoad(), testReshapeExecStream(), LbmSearchTest::testScanIdx(), ExecStreamUnitTestBase::verifyBufferedOutput(), ExecStreamUnitTestBase::verifyConstantOutput(), FlatFileExecStreamTest::verifyOutput(), and ExecStreamUnitTestBase::verifyOutput().

Definition at line 51 of file ExecStreamTestBase.h.

Referenced by ExecStreamUnitTestBase::resetExecStreamTest(), ExternalSortExecStreamTest::testCaseSetUp(), ExecStreamUnitTestBase::testCaseSetUp(), ExecStreamTestBase::testCaseSetUp(), ExecStreamGovernorTest::testCaseSetUp(), ExecStreamTestBase::testCaseTearDown(), ExecStreamGovernorTest::testMinGreaterAllocation(), ExecStreamUnitTestBase::verifyBufferedOutput(), ExecStreamUnitTestBase::verifyConstantOutput(), FlatFileExecStreamTest::verifyOutput(), and ExecStreamUnitTestBase::verifyOutput().

Definition at line 40 of file SegStorageTestBase.h.

Referenced by BackupRestoreTest::backup(), SegStorageTestBase::createLinearDeviceSegment(), LogicalTxnTest::createRecoveryLog(), LbmSearchTest::initBTreeExecStreamParam(), LbmLoadBitmapTest::initBTreeExecStreamParam(), LcsClusterReplaceExecStreamTest::initClusterAppendParams(), LbmExecStreamTestBase::initSorterExecStream(), LcsMultiClusterAppendTest::loadClusters(), LcsRowScanExecStreamTest::loadOneCluster(), LbmSearchTest::loadTableAndIndex(), LbmMinusExecStreamTest::newMinusStream(), ExecStreamTestBase::newStreamGraphEmbryo(), SegStorageTestBase::openRandomSegment(), VersionedSegmentTest::openSegmentStorage(), SnapshotSegmentTestBase::openSegmentStorage(), LinearViewSegmentTest::openSegmentStorage(), BackupRestoreTest::restore(), SegStorageTestBase::SegStorageTestBase(), LbmSplicerExecStreamTest::spliceInput(), testBTreeInsertExecStream(), LhxHashTableTest::testCaseSetUp(), LcsClusterReplaceExecStreamTest::testClusterReplace(), LhxAggExecStreamTest::testCountImpl(), testDoubleBufferExecStream(), ExecStreamGovernorTest::testGovernor(), LhxAggExecStreamTest::testGroupCountImpl(), LhxJoinExecStreamTest::testImpl(), ExternalSortExecStreamTest::testImpl(), BTreeTest::testInserts(), LbmIntersectExecStreamTest::testIntersect(), LbmEntryTest::testldb35(), LbmEntryTest::testler5920(), LbmLoadBitmapTest::testLoad(), LcsClusterAppendExecStreamTest::testLoadMultiCol(), LcsClusterAppendExecStreamTest::testLoadSingleCol(), LbmEntryTest::testMergeEntry(), BTreeTest::testMultiKeySearches(), BTreeTest::testScan(), testScratchBufferExecStream(), LhxAggExecStreamTest::testSingleValueImpl(), FlatFileExecStreamTest::testStream(), LhxAggExecStreamTest::testSumImpl(), LogicalTxnTest::testTxn(), SnapshotSegmentTest::testUncommittedReads(), LbmUnionExecStreamTest::testUnion(), SegStreamTest::testWriteSpillAndRead(), and LbmEntryTest::testZeroBytes().

Segment supporting linear page allocation.

Definition at line 45 of file SegStorageTestBase.h.

Referenced by SegStorageTestBase::closeLinearSegment(), LogicalTxnTest::createRecoveryLog(), SegmentTestBase::lockPage(), SegStorageTestBase::openRandomSegment(), VersionedSegmentTest::openSegmentStorage(), SnapshotSegmentTestBase::openSegmentStorage(), SegStorageTestBase::openSegmentStorage(), LinearViewSegmentTest::openSegmentStorage(), SegmentTestBase::openStorage(), SegmentTestBase::prefetchPage(), SnapshotSegmentTestBase::testAllocateAll(), LinearViewSegmentTest::testAllocateAll(), VersionedSegmentTest::testCheckpoint(), SegmentTestBase::testCheckpoint(), SegPageIterTest::testIter(), SegPageEntryIterTest::testIter(), SegStreamTest::testMarkReset(), SegStreamTest::testReadSeg(), VersionedSegmentTest::testRecovery(), LogicalTxnTest::testTxn(), SnapshotSegmentTest::testUncommittedReads(), SegStreamTest::testWriteSeg(), and VersionedSegmentTest::verifyPage().

(Optional) segment supporting random page allocation.

Definition at line 50 of file SegStorageTestBase.h.

Referenced by SegStorageTestBase::closeRandomSegment(), SnapshotSegmentTestBase::closeStorage(), LbmSplicerExecStreamTest::createBTree(), LbmSplicerExecStreamTest::initBTreeParam(), LbmSearchTest::initBTreeParam(), LbmLoadBitmapTest::initBTreeParam(), LbmLoadBitmapTest::initBTreeTupleDesc(), LcsClusterReplaceExecStreamTest::initClusterAppendParams(), LbmExecStreamTestBase::initSorterExecStream(), LcsClusterReplaceExecStreamTest::loadCluster(), LcsMultiClusterAppendTest::loadClusters(), LcsRowScanExecStreamTest::loadOneCluster(), LbmSearchTest::loadTableAndIndex(), SegStorageTestBase::openRandomSegment(), SnapshotSegmentTestBase::openSegmentStorage(), LinearViewSegmentTest::openSegmentStorage(), SegmentTestBase::openStorage(), SegmentTestBase::testAllocate(), RandomAllocationSegmentTest::testAllocateAndDeallocate(), testBTreeInsertExecStream(), BTreeTest::testBulkLoad(), LhxHashTableTest::testCaseSetUp(), BTreeTest::testCaseSetUp(), BTreeReadersTest::testCaseSetUp(), LcsRowScanExecStreamTest::testCaseSetUp(), LcsMultiClusterAppendTest::testCaseSetUp(), LcsClusterReplaceExecStreamTest::testCaseSetUp(), LcsClusterAppendExecStreamTest::testCaseSetUp(), LbmExecStreamTestBase::testCaseSetUp(), LcsClusterReplaceExecStreamTest::testClusterReplace(), LhxAggExecStreamTest::testCountImpl(), SegmentTestBase::testDeallocate(), LhxAggExecStreamTest::testGroupCountImpl(), LhxJoinExecStreamTest::testImpl(), ExternalSortExecStreamTest::testImpl(), BTreeTest::testInserts(), LbmLoadBitmapTest::testLoad(), LcsClusterAppendExecStreamTest::testLoadMultiCol(), LcsClusterAppendExecStreamTest::testLoadSingleCol(), testMergeImplicitPullInputs(), BTreeTest::testMultiKeySearches(), BTreeReadersTest::testReaders(), LcsRowScanExecStreamTest::testScanOnEmptyCluster(), testSegBufferExecStream(), testSegBufferReaderWriterExecStream(), LhxAggExecStreamTest::testSingleValueImpl(), LhxAggExecStreamTest::testSumImpl(), and LbmUnionExecStreamTest::testUnion().

Cache instance being tested.

Definition at line 63 of file CacheTestBase.h.

Referenced by BackupRestoreTest::backup(), CacheTestBase::closeDevice(), CacheTestBase::closeStorage(), LbmSplicerExecStreamTest::createBTree(), SegStorageTestBase::createLinearDeviceSegment(), LogicalTxnTest::createRecoveryLog(), BackupRestoreTest::createSnapshotData(), BackupRestoreTest::executeSnapshotTxn(), CacheTestBase::getCache(), LbmSearchTest::initBTreeExecStreamParam(), LbmLoadBitmapTest::initBTreeExecStreamParam(), LbmSearchTest::initBTreeParam(), LbmLoadBitmapTest::initBTreeParam(), LcsClusterReplaceExecStreamTest::initClusterAppendParams(), LbmExecStreamTestBase::initSorterExecStream(), LcsClusterReplaceExecStreamTest::loadCluster(), LcsMultiClusterAppendTest::loadClusters(), LcsRowScanExecStreamTest::loadOneCluster(), LbmSearchTest::loadTableAndIndex(), SegmentTestBase::lockPage(), LbmMinusExecStreamTest::newMinusStream(), ExecStreamTestBase::newStreamGraphEmbryo(), CacheTestBase::openDevice(), CacheTestBase::openStorage(), LcsClusterReplaceExecStreamTest::replaceCluster(), BackupRestoreTest::restore(), LbmSplicerExecStreamTest::spliceInput(), SegmentTestBase::testAllocate(), RandomAllocationSegmentTest::testAllocateAndDeallocate(), BackupRestoreTest::testBackupCleanup(), testBTreeInsertExecStream(), BTreeTest::testBulkLoad(), LhxHashTableTest::testCaseSetUp(), ExecStreamUnitTestBase::testCaseSetUp(), BTreeTest::testCaseSetUp(), BTreeReadersTest::testCaseSetUp(), LhxAggExecStreamTest::testCountImpl(), SegmentTestBase::testDeallocate(), SnapshotSegmentTest::testDeallocateOld(), testDoubleBufferExecStream(), ExecStreamGovernorTest::testGovernor(), LhxAggExecStreamTest::testGroupCountImpl(), BackupRestoreTest::testHeaderBackupRestore(), LhxJoinExecStreamTest::testImpl(), ExternalSortExecStreamTest::testImpl(), BTreeTest::testInserts(), LbmIntersectExecStreamTest::testIntersect(), SegPageIterTest::testIter(), SegPageEntryIterTest::testIter(), CacheTest::testLargeCacheInit(), CacheTest::testLargeCacheRequest(), LbmEntryTest::testldb35(), LbmEntryTest::testler5920(), LbmLoadBitmapTest::testLoad(), LcsClusterAppendExecStreamTest::testLoadMultiCol(), LcsClusterAppendExecStreamTest::testLoadSingleCol(), SegStreamTest::testMarkReset(), LbmEntryTest::testMergeEntry(), BTreeTest::testMultiKeySearches(), CacheTest::testQuotaCacheAccessor(), BTreeReadersTest::testReaders(), SegStreamTest::testReadSeg(), BTreeTest::testScan(), LcsRowScanExecStreamTest::testScanOnEmptyCluster(), testScratchBufferExecStream(), LhxAggExecStreamTest::testSingleValueImpl(), FlatFileExecStreamTest::testStream(), LhxAggExecStreamTest::testSumImpl(), LogicalTxnTest::testTxn(), LogicalTxnTest::testTxnIdSequence(), LbmUnionExecStreamTest::testUnion(), SegStreamTest::testWriteSeg(), SegStreamTest::testWriteSpillAndRead(), LbmEntryTest::testZeroBytes(), and BackupRestoreTest::verifySnapshotData().

Size of device in disk pages.

Definition at line 78 of file CacheTestBase.h.

Referenced by CacheTestBase::CacheTestBase(), LinearViewSegmentTest::LinearViewSegmentTest(), CacheTest::makeBlockId(), VersionedSegmentTest::openSegmentStorage(), SnapshotSegmentTestBase::openSegmentStorage(), LinearViewSegmentTest::openSegmentStorage(), CacheTestBase::openStorage(), SegStreamTest::SegStreamTest(), SnapshotSegmentTestBase::SnapshotSegmentTestBase(), SnapshotSegmentTest::testDeallocateOld(), PagingTestBase::testPrefetch(), PagingTestBase::testPrefetchBatch(), PagingTestBase::testRandomOp(), SnapshotSegmentTest::testRollback(), PagingTestBase::testSequentialOp(), and PagingTestBase::testSkipOp().

Configuration parameters.

The reason this is static is so that no constructor parameters (which burden virtual bases) are needed.

Definition at line 155 of file TestBase.h.

Referenced by TestBase::afterTestCase(), TestBase::beforeTestCase(), BTreeTxnTest::BTreeTxnTest(), CacheTestBase::CacheTestBase(), BackupRestoreTest::createSnapshotData(), DatabaseTest::DatabaseTest(), TestOptionsTest::extra(), DatabaseTest::loadDatabase(), SparseBitmapTest::openStorage(), PagingTestBase::PagingTestBase(), ParallelExecStreamSchedulerTest::ParallelExecStreamSchedulerTest(), RandomAccessFileDeviceTest::RandomAccessFileDeviceTest(), TestBase::readParams(), SegStorageTestBase::SegStorageTestBase(), TestOptionsTest::test1(), TestOptionsTest::test2(), BackupRestoreTest::testBackupCleanup(), TestBase::TestBase(), BTreeTxnTest::testCaseSetUp(), BTreeTxnTest::testCheckpoint(), DatabaseTest::testCreateEmpty(), DatabaseTest::testForceTxns(), BackupRestoreTest::testHeaderBackupRestore(), SegPageEntryIterTest::testIter(), SegStreamTest::testRead(), BTreeTxnTest::testTxns(), SegStreamTest::testWrite(), ThreadedTestBase::ThreadedTestBase(), and TestBase::~TestBase().

The documentation for this class was generated from the following files:

• /home/pub/open/dev/fennel/test/ExecStreamTestSuite.h
• /home/pub/open/dev/fennel/test/ExecStreamTestSuite.cpp

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