FlatFileExecStreamTest Class Reference

Inheritance diagram for FlatFileExecStreamTest:


Public Member Functions
	FlatFileExecStreamTest ()
void	testBuffer ()
void	testParser ()
void	testStream ()
virtual void	testCaseSetUp ()
	Equivalent to JUnit TestCase.setUp; this is called before each test case method is invoked.
virtual void	testCaseTearDown ()
	Equivalent to JUnit TestCase.tearDown; this is called after each test case method is invoked.
virtual void	openStorage (DeviceMode openMode)
virtual void	openSegmentStorage (DeviceMode openMode)
virtual void	openRandomSegment ()
SharedSegment	createLinearDeviceSegment (DeviceId deviceId, uint nPages)
void	closeLinearSegment ()
void	closeRandomSegment ()
void	closeVersionedRandomSegment ()
void	closeSnapshotRandomSegment ()
virtual void	closeStorage ()
Cache &	getCache ()
virtual SharedCache	newCache ()
SharedRandomAccessDevice	openDevice (std::string devName, DeviceMode openMode, uint nDevicePages, DeviceId deviceId)
void	closeDevice (DeviceId deviceId, SharedRandomAccessDevice &pDevice)
TestSuite *	releaseTestSuite ()
void	beforeTestCase (std::string testCaseName)
void	afterTestCase (std::string testCaseName)
virtual void	notifyTrace (std::string source, TraceLevel level, std::string message)
	Receives notification when a trace event occurs.
virtual TraceLevel	getSourceTraceLevel (std::string source)
	Gets the level at which a particular source should be traced.
Static Public Member Functions
static void	readParams (int argc, char **argv)
	Parses the command line.
Static Public Attributes
static ParamName	paramTestSuiteName
static ParamName	paramTraceFileName
static ParamName	paramDictionaryFileName
static ParamName	paramTraceLevel
static ParamName	paramStatsFileName
static ParamName	paramTraceStdout
static ParamName	paramDegreeOfParallelism
static ConfigMap	configMap
	Configuration parameters.
Protected Types
enum	VictimPolicy { victimTwoQ, victimLRU, victimRandom }
	The available victim policy implementations. More...
Protected Member Functions
SharedExecStream	prepareSourceGraph (ExecStreamEmbryo &sourceStreamEmbryo)
	Defines and prepares a graph consisting of one source stream.
SharedExecStream	prepareTransformGraph (ExecStreamEmbryo &sourceStreamEmbryo, ExecStreamEmbryo &transformStreamEmbryo)
	Defines and prepares a graph consisting of one source stream and one transform stream.
SharedExecStream	prepareTransformGraph (ExecStreamEmbryo &sourceStreamEmbryo, std::vector< ExecStreamEmbryo > &transforms)
	Defines and prepares a graph consisting of one source stream and one or multiple transform streams.
SharedExecStream	prepareConfluenceGraph (ExecStreamEmbryo &sourceStreamEmbryo1, ExecStreamEmbryo &sourceStreamEmbryo2, ExecStreamEmbryo &confluenceStreamEmbryo)
	Defines and prepares a graph consisting of two source streams and one confluence stream.
SharedExecStream	prepareConfluenceGraph (std::vector< ExecStreamEmbryo > &sourceStreamEmbryos, ExecStreamEmbryo &confluenceStreamEmbryo)
	Defines and prepares a graph consisting of a list of source streams and one confluence stream.
SharedExecStream	prepareConfluenceGraph (std::vector< std::vector< ExecStreamEmbryo > > &sourceStreamEmbryosList, ExecStreamEmbryo &confluenceStreamEmbryo)
	Defines and prepares a graph consisting of one or more source streams and one confluence stream.
SharedExecStream	prepareConfluenceTransformGraph (ExecStreamEmbryo &sourceStreamEmbryo1, ExecStreamEmbryo &sourceStreamEmbryo2, ExecStreamEmbryo &confluenceStreamEmbryo, ExecStreamEmbryo &transformStreamEmbryo)
	Defines and prepares a graph consisting of two source streams, one confluence stream, and one transform stream.
SharedExecStream	prepareDAG (ExecStreamEmbryo &srcStreamEmbryo, ExecStreamEmbryo &splitterStreamEmbryo, std::vector< ExecStreamEmbryo > &interStreamEmbryos, ExecStreamEmbryo &destStreamEmbryo, bool createSink=true, bool saveSrc=true)
	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.
SharedExecStream	prepareDAG (ExecStreamEmbryo &srcStreamEmbryo, ExecStreamEmbryo &splitterStreamEmbryo, std::vector< std::vector< ExecStreamEmbryo > > &interStreamEmbryosList, ExecStreamEmbryo &destStreamEmbryo, bool createSink=true, bool saveSrc=true)
	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.
void	verifyOutput (ExecStream &stream, uint nRowsExpected, MockProducerExecStreamGenerator &verifier, bool stopEarly=false)
	Executes the prepared stream graph and verifies that its output matches that produced by a value generator.
void	verifyConstantOutput (ExecStream &stream, const TupleData &expectedTuple, uint nRowsExpected)
	Executes the prepared stream graph and verifies that all output tuples matche an expected and given one.
void	verifyBufferedOutput (ExecStream &stream, TupleDescriptor outputTupleDesc, uint nRowsExpected, PBuffer expectedBuffer)
	Executes the prepared stream graph and verifies the resultant tuples against a set of tuples supplied in an input buffer.
void	resetExecStreamTest ()
	Reset stream graph so multiple iterations of a method can be called within a single testcase.
virtual void	tearDownExecStreamTest ()
	ExecStream-specific handler called from testCaseTearDown.
virtual SharedExecStreamGraph	newStreamGraph ()
	Creates a stream graph.
virtual SharedExecStreamGraphEmbryo	newStreamGraphEmbryo (SharedExecStreamGraph)
	Creates an embryo for a stream graph.
virtual ExecStreamScheduler *	newScheduler ()
	Creates a scheduler.
virtual ExecStreamGovernor *	newResourceGovernor (ExecStreamResourceKnobs const &knobSettings, ExecStreamResourceQuantity const &resourcesAvailable)
	Creates the resource governor.
void	snooze (uint nSeconds)
Protected Attributes
SharedExecStreamGraph	pGraph
SharedExecStreamGraphEmbryo	pGraphEmbryo
SharedExecStreamScheduler	pScheduler
SharedExecStreamGovernor	pResourceGovernor
SharedCacheAccessor	pCacheAccessor
SharedSegmentFactory	pSegmentFactory
SharedSegment	pLinearSegment
	Segment supporting linear page allocation.
SharedSegment	pRandomSegment
	(Optional) segment supporting random page allocation.
SharedSegment	pVersionedRandomSegment
	(Optional) segment supporting versioned random page allocation.
SharedSegment	pSnapshotRandomSegment
	(Optional) segment supporting snapshot random page allocation.
VictimPolicy	victimPolicy
	VictimPolicy to instantiate.
CacheParams	cacheParams
	Parameters for cache initialization.
SharedCache	pCache
	Cache instance being tested.
SharedRandomAccessDevice	pRandomAccessDevice
	The default cached device.
uint	nMemPages
	Size of cache in memory pages.
uint	nDiskPages
	Size of device in disk pages.
uint	cbPageFull
	Disk page size.
DeviceId	dataDeviceId
	Fixed ID to assign to data device.
TestSuite *	pTestSuite
	Boost test suite.
boost::shared_ptr< TestBase >	pTestObj
std::ofstream	traceStream
	Output file stream for tracing.
StrictMutex	traceMutex
	Protects traceStream.
std::string	testName
	Name of test.
TraceLevel	traceLevel
	Level at which to trace test execution.
FileStatsTarget	statsTarget
	Output for stats.
StatsTimer	statsTimer
	Timer for stats collection.
bool	traceStdout
	Copy trace output to stdout.
bool	traceFile
	Copy trace output to file.
TestCaseGroup	defaultTests
TestCaseGroup	extraTests
Static Protected Attributes
static const uint	DefaultCacheReservePercent = 5
static const uint	DefaultConcurrentStatements = 4
static bool	runAll
	Run all test cases, including the extra tests.
static std::string	runSingle
	Run only the test case of this name.
Private Member Functions
void	checkRead (FlatFileBuffer &buffer, const char *string)
void	checkTrim (FlatFileParser &parser, const char string, const char result)
void	checkStrip (FlatFileParser &parser, const char string, const char result)
void	checkColumnScan (FlatFileParser &parser, const char *string, FlatFileColumnParseResult::DelimiterType type, uint size, uint offset)
void	verifyOutput (ExecStream &stream, uint nRowsExpected, StringExecStreamGenerator &generator)

Detailed Description

Definition at line 82 of file FlatFileExecStreamTest.cpp.

Member Enumeration Documentation

enum CacheTestBase::VictimPolicy [protected, inherited]

The available victim policy implementations.

Enumerator:

victimTwoQ
victimLRU
victimRandom

Definition at line 44 of file CacheTestBase.h.

00044                       {
00045         victimTwoQ,
00046         victimLRU,
00047         victimRandom
00048     };

Constructor & Destructor Documentation

FlatFileExecStreamTest::FlatFileExecStreamTest ( ) [inline, explicit]

Definition at line 111 of file FlatFileExecStreamTest.cpp.

References testBuffer(), testParser(), and testStream().

00112     {
00113         FENNEL_UNIT_TEST_CASE(FlatFileExecStreamTest, testBuffer);
00114         FENNEL_UNIT_TEST_CASE(FlatFileExecStreamTest, testParser);
00115         FENNEL_UNIT_TEST_CASE(FlatFileExecStreamTest, testStream);
00116     }

Member Function Documentation

void FlatFileExecStreamTest::checkRead	(	FlatFileBuffer &	buffer,
		const char *	string
	)			`[private]`

Definition at line 194 of file FlatFileExecStreamTest.cpp.

References FlatFileBuffer::getEndPtr(), FlatFileBuffer::getReadPtr(), and FlatFileBuffer::read().

Referenced by testBuffer().

00197 {
00198     uint size = strlen(string);
00199     buffer.read();
00200     BOOST_CHECK_EQUAL(buffer.getEndPtr() - buffer.getReadPtr(), size);
00201     BOOST_CHECK_EQUAL(strncmp(buffer.getReadPtr(), string, size), 0);
00202 }

void FlatFileExecStreamTest::checkTrim	(	FlatFileParser &	parser,
		const char *	string,
		const char *	result
	)			`[private]`

Definition at line 204 of file FlatFileExecStreamTest.cpp.

References FlatFileParser::trim().

Referenced by testParser().

00208 {
00209     char buffer[128];
00210     assert (strlen(string) < sizeof(buffer));
00211     strcpy(buffer, string);
00212 
00213     uint size = strlen(result);
00214     BOOST_CHECK_EQUAL(parser.trim(buffer, strlen(buffer)), size);
00215     BOOST_CHECK_EQUAL(strncmp(buffer, result, size), 0);
00216 }

void FlatFileExecStreamTest::checkStrip	(	FlatFileParser &	parser,
		const char *	string,
		const char *	result
	)			`[private]`

Definition at line 218 of file FlatFileExecStreamTest.cpp.

References FlatFileParser::stripQuoting().

Referenced by testParser().

00222 {
00223     char buffer[128];
00224     assert (strlen(string) < sizeof(buffer));
00225     strcpy(buffer, string);
00226 
00227     uint size = strlen(result);
00228     BOOST_CHECK_EQUAL(parser.stripQuoting(buffer, strlen(buffer), true), size);
00229     BOOST_CHECK_EQUAL(strncmp(buffer, result, size), 0);
00230 }

void FlatFileExecStreamTest::checkColumnScan	(	FlatFileParser &	parser,
		const char *	string,
		FlatFileColumnParseResult::DelimiterType	type,
		uint	size,
		uint	offset
	)			`[private]`

Definition at line 232 of file FlatFileExecStreamTest.cpp.

References FlatFileColumnParseResult::next, FlatFileParser::scanColumn(), FlatFileColumnParseResult::size, and FlatFileColumnParseResult::type.

Referenced by testParser().

00238 {
00239     char buffer[128];
00240     assert(strlen(string) < sizeof(buffer));
00241     strcpy(buffer, string);
00242 
00243     FlatFileColumnParseResult result;
00244     parser.scanColumn(buffer, strlen(buffer), sizeof(buffer), result);
00245 
00246     BOOST_CHECK_EQUAL(result.type, type);
00247     BOOST_CHECK_EQUAL(result.size, size);
00248     BOOST_CHECK_EQUAL(result.next, buffer + offset);
00249 }

void FlatFileExecStreamTest::verifyOutput	(	ExecStream &	stream,
		uint	nRowsExpected,
		StringExecStreamGenerator &	generator
	)			`[private]`

Definition at line 288 of file FlatFileExecStreamTest.cpp.

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

Referenced by testStream().

00292 {
00293     // TODO:  assertions about output tuple, or better yet, use proper tuple
00294     // access
00295 
00296     pResourceGovernor->requestResources(*pGraph);
00297     pGraph->open();
00298     pScheduler->start();
00299     uint nRows = 0;
00300     for (;;) {
00301         ExecStreamBufAccessor &bufAccessor =
00302             pScheduler->readStream(stream);
00303         if (bufAccessor.getState() == EXECBUF_EOS) {
00304             break;
00305         }
00306         BOOST_REQUIRE(bufAccessor.isConsumptionPossible());
00307         const uint nCol =
00308             bufAccessor.getConsumptionTupleAccessor().size();
00309         BOOST_REQUIRE(nCol == bufAccessor.getTupleDesc().size());
00310         BOOST_REQUIRE(nCol >= 1);
00311         TupleData inputTuple;
00312         inputTuple.compute(bufAccessor.getTupleDesc());
00313         std::ostringstream oss;
00314         TuplePrinter tuplePrinter;
00315         for (;;) {
00316             if (!bufAccessor.demandData()) {
00317                 break;
00318             }
00319             BOOST_REQUIRE(nRows < nRowsExpected);
00320             bufAccessor.unmarshalTuple(inputTuple);
00321             tuplePrinter.print(oss,bufAccessor.getTupleDesc(),inputTuple);
00322             std::string actualValue = oss.str();
00323             oss.str("");
00324             const std::string &expectedValue = generator.generateValue(nRows);
00325             if (actualValue.compare(expectedValue)) {
00326                 std::cout << "(Row) = (" << nRows << ")" << std::endl;
00327                 BOOST_CHECK_EQUAL(expectedValue,actualValue);
00328                 return;
00329             }
00330             bufAccessor.consumeTuple();
00331             ++nRows;
00332         }
00333     }
00334     BOOST_CHECK_EQUAL(nRowsExpected,nRows);
00335 }

void FlatFileExecStreamTest::testBuffer ( )

Definition at line 123 of file FlatFileExecStreamTest.cpp.

References checkRead(), and FixedBuffer.

Referenced by FlatFileExecStreamTest().

00124 {
00125     FixedBuffer fixedBuffer[8];
00126     std::string path = "flatfile/buffer";
00127 
00128     SharedFlatFileBuffer pFileBuffer;
00129     pFileBuffer.reset(new FlatFileBuffer(path), ClosableObjectDestructor());
00130     pFileBuffer->open();
00131     pFileBuffer->setStorage((char *) fixedBuffer, (uint)8);
00132 
00133     checkRead(*pFileBuffer, "12345671");
00134     BOOST_CHECK_EQUAL(pFileBuffer->getReadPtr(), (char *)fixedBuffer);
00135 
00136     pFileBuffer->setReadPtr(pFileBuffer->getReadPtr() + 7);
00137     checkRead(*pFileBuffer, "12345676");
00138 
00139     pFileBuffer->setReadPtr(pFileBuffer->getReadPtr() + 6);
00140     checkRead(*pFileBuffer, "7654\n");
00141     BOOST_CHECK(pFileBuffer->isComplete());
00142 }

void FlatFileExecStreamTest::testParser ( )

Definition at line 144 of file FlatFileExecStreamTest.cpp.

References checkColumnScan(), checkStrip(), checkTrim(), FlatFileColumnParseResult::FIELD_DELIM, FlatFileColumnParseResult::NO_DELIM, and FlatFileColumnParseResult::ROW_DELIM.

Referenced by FlatFileExecStreamTest().

00145 {
00146     FlatFileParser parser(',', '\n', '"', '"');
00147 
00148     checkTrim(parser, "", "");
00149     checkTrim(parser, "aRobin", "aRobin");
00150     checkTrim(parser, "   red breast in cage  ", "red breast in cage");
00151 
00152     checkStrip(parser, "", "");
00153     checkStrip(parser, "puts all", "puts all");
00154     checkStrip(parser, "\"heaven\"", "heaven");
00155     checkStrip(parser, "   \"in a\"  ", "in a");
00156     checkStrip(parser, "   \"\"\"rage\"\"\"  ", "\"rage\"");
00157 
00158     // quote a delimiter
00159     checkColumnScan(
00160         parser, "\"all that\n is \"gold, ",
00161         FlatFileColumnParseResult::FIELD_DELIM, 19, 20);
00162 
00163     // quotes are valid for char columns
00164     checkColumnScan(
00165         parser, "\"does not, glitter\"\n ",
00166         FlatFileColumnParseResult::ROW_DELIM, 19, 20);
00167 
00168     // embedded quotes
00169     checkColumnScan(
00170         parser, "\"not all those who \"\"wander\"\"\", ",
00171         FlatFileColumnParseResult::FIELD_DELIM, 30, 31);
00172 
00173     // ends in escape
00174     checkColumnScan(
00175         parser, " are lost  \"",
00176         FlatFileColumnParseResult::NO_DELIM, 12, 12);
00177 
00178     // imbalanced quote
00179     checkColumnScan(
00180         parser, "\"JRR, ",
00181         FlatFileColumnParseResult::NO_DELIM, 6, 6);
00182 
00183     // data after quote
00184     checkColumnScan(
00185         parser, "\"Tolkien\"  , ",
00186         FlatFileColumnParseResult::FIELD_DELIM, 11, 12);
00187 
00188     // fixed length exactly equal to buffer size
00189     checkColumnScan(
00190         parser, "some poems",
00191         FlatFileColumnParseResult::NO_DELIM, 10, 10);
00192 }

void FlatFileExecStreamTest::testStream ( )

Definition at line 251 of file FlatFileExecStreamTest.cpp.

References ExecStreamEmbryo::getStream(), ExecStreamEmbryo::init(), StringExecStreamGeneratorImpl::insert(), StandardTypeDescriptorFactory::newDataType(), FlatFileExecStream::newFlatFileExecStream(), CacheTestBase::pCache, ExecStreamUnitTestBase::prepareSourceGraph(), SegStorageTestBase::pSegmentFactory, STANDARD_TYPE_VARCHAR, and verifyOutput().

Referenced by FlatFileExecStreamTest().

00252 {
00253     StandardTypeDescriptorFactory stdTypeFactory;
00254     TupleAttributeDescriptor attrDesc(
00255         stdTypeFactory.newDataType(STANDARD_TYPE_VARCHAR),
00256         false,
00257         32);
00258 
00259     FlatFileExecStreamParams flatfileParams;
00260     flatfileParams.scratchAccessor =
00261         pSegmentFactory->newScratchSegment(pCache,1);
00262      flatfileParams.outputTupleDesc.push_back(attrDesc);
00263     flatfileParams.outputTupleDesc.push_back(attrDesc);
00264     flatfileParams.dataFilePath = "flatfile/stream";
00265     flatfileParams.fieldDelim = ',';
00266     flatfileParams.rowDelim = '\n';
00267     flatfileParams.quoteChar = '"';
00268     flatfileParams.escapeChar = '\\';
00269     flatfileParams.header = false;
00270 
00271     ExecStreamEmbryo flatfileStreamEmbryo;
00272     flatfileStreamEmbryo.init(
00273         FlatFileExecStream::newFlatFileExecStream(), flatfileParams);
00274     flatfileStreamEmbryo.getStream()->setName("FlatFileExecStream");
00275 
00276     SharedExecStream pOutputStream = prepareSourceGraph(flatfileStreamEmbryo);
00277     StringExecStreamGeneratorImpl verifier;
00278     verifier.insert("[ 'No one', 'travels' ]");
00279     verifier.insert("[ 'Along this way', 'but I,' ]");
00280     verifier.insert("[ 'This', 'autumn evening.' ]");
00281 
00282     verifyOutput(
00283         *pOutputStream,
00284         3,
00285         verifier);
00286 }

SharedExecStream ExecStreamUnitTestBase::prepareSourceGraph ( ExecStreamEmbryo & sourceStreamEmbryo ) [protected, inherited]

Defines and prepares a graph consisting of one source stream.

Parameters:

sourceStreamEmbryo

embryonic source stream which produces tuples

Returns:: output buffer stream

Definition at line 41 of file ExecStreamUnitTestBase.cpp.

References ExecStreamUnitTestBase::prepareTransformGraph().

Referenced by testStream().

00043 {
00044     std::vector<ExecStreamEmbryo> transforms;
00045     return prepareTransformGraph(sourceStreamEmbryo, transforms);
00046 }

SharedExecStream ExecStreamUnitTestBase::prepareTransformGraph	(	ExecStreamEmbryo &	sourceStreamEmbryo,
		ExecStreamEmbryo &	transformStreamEmbryo
	)			`[protected, inherited]`

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

Parameters:

	sourceStreamEmbryo	embryonic source stream which produces tuples
	transformStreamEmbryo	embryonic transform stream which processes tuples produced by sourceStreamEmbryo

Returns:: output buffer stream

Definition at line 48 of file ExecStreamUnitTestBase.cpp.

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

SharedExecStream ExecStreamUnitTestBase::prepareTransformGraph	(	ExecStreamEmbryo &	sourceStreamEmbryo,
		std::vector< ExecStreamEmbryo > &	transforms
	)			`[protected, inherited]`

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

Parameters:

	sourceStreamEmbryo	embryonic source stream which produces tuples
	transforms	embryonic transform streams which process tuples produced by sourceStreamEmbryo or a child stream

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<ExecStreamEmbryo>::iterator it;
00063 
00064     // save all transforms
00065     for (it = transforms.begin(); it != transforms.end(); ++it) {
00066         pGraphEmbryo->saveStreamEmbryo(*it);
00067     }
00068 
00069     // connect streams in a cascade
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 }

SharedExecStream ExecStreamUnitTestBase::prepareConfluenceGraph	(	ExecStreamEmbryo &	sourceStreamEmbryo1,
		ExecStreamEmbryo &	sourceStreamEmbryo2,
		ExecStreamEmbryo &	confluenceStreamEmbryo
	)			`[protected, inherited]`

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

Parameters:

	sourceStreamEmbryo1	embryonic source stream which produces tuples
	sourceStreamEmbryo2	embryonic source stream which produces tuples
	confluenceStreamEmbryo	embryonic confluence stream which processes tuples produced by the sourceStreamEmbryos

Returns:: output buffer stream

Definition at line 89 of file ExecStreamUnitTestBase.cpp.

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

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

SharedExecStream ExecStreamUnitTestBase::prepareConfluenceGraph	(	std::vector< ExecStreamEmbryo > &	sourceStreamEmbryos,
		ExecStreamEmbryo &	confluenceStreamEmbryo
	)			`[protected, inherited]`

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

Parameters:

	sourceStreamEmbryos	list of embryonic source streams that produce tuples
	confluenceStreamEmbryo	embryonic confluence stream which processes tuples produced by the sourceStreamEmbryos

Returns:: output buffer stream

Definition at line 155 of file ExecStreamUnitTestBase.cpp.

References ExecStreamUnitTestBase::prepareConfluenceGraph().

00158 {
00159     std::vector<std::vector<ExecStreamEmbryo> > sourceStreamEmbryosList;
00160     std::vector<ExecStreamEmbryo>::iterator it;
00161     std::vector<ExecStreamEmbryo> 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 }

SharedExecStream ExecStreamUnitTestBase::prepareConfluenceGraph	(	std::vector< std::vector< ExecStreamEmbryo > > &	sourceStreamEmbryosList,
		ExecStreamEmbryo &	confluenceStreamEmbryo
	)			`[protected, inherited]`

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:

	sourceStreamEmbryosList	list of embryonic source streams which produce tuples
	confluenceStreamEmbryo	embryonic confluence stream which processes tuples produced by the source streams

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         // connect streams in each sourceStreamEmbryos list in a cascade
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 }

SharedExecStream ExecStreamUnitTestBase::prepareConfluenceTransformGraph	(	ExecStreamEmbryo &	sourceStreamEmbryo1,
		ExecStreamEmbryo &	sourceStreamEmbryo2,
		ExecStreamEmbryo &	confluenceStreamEmbryo,
		ExecStreamEmbryo &	transformStreamEmbryo
	)			`[protected, inherited]`

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

Parameters:

	sourceStreamEmbryo1	embryonic source stream which produces tuples
	sourceStreamEmbryo2	embryonic source stream which produces tuples
	confluenceStreamEmbryo	embryonic confluence stream which processes tuples produced by the sourceStreamEmbryos
	transformStreamEmbryo	embryonic transform streams which process tuples produced by a child stream

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<ExecStreamEmbryo> sourceStreamEmbryos;
00107     sourceStreamEmbryos.push_back(sourceStreamEmbryo1);
00108     sourceStreamEmbryos.push_back(sourceStreamEmbryo2);
00109 
00110     std::vector<ExecStreamEmbryo>::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<ExecStreamEmbryo> transforms;
00128     transforms.push_back(transformStreamEmbryo);
00129     ExecStreamEmbryo& previousStream = confluenceStreamEmbryo;
00130 
00131     // save all transforms
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 }

SharedExecStream ExecStreamUnitTestBase::prepareDAG	(	ExecStreamEmbryo &	srcStreamEmbryo,
		ExecStreamEmbryo &	splitterStreamEmbryo,
		std::vector< ExecStreamEmbryo > &	interStreamEmbryos,
		ExecStreamEmbryo &	destStreamEmbryo,
		bool	createSink = `true`,
		bool	saveSrc = `true`
	)			`[protected, inherited]`

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:

	srcStreamEmbryo	embryonic source stream which produces tuples
	splitterStreamEmbryo	embryonic SplitterExecStream which produces tuples for multiple consumers
	interStreamEmbryos	embryonic intermediate streams which transform tuples; each stream consists of a single embryo
	destStreamEmbryo	embryonic confluence stream which processes tuples produced by the interStreamEmbryos
	createSink	if true (the default), creates a final output sink in the stream graph
	saveSrc	if true (the default), save the source in the stream graph; if false, the save has already been done

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(), ExecStreamTestSuite::testMergeImplicitPullInputs(), ExecStreamTestSuite::testSegBufferReaderWriterExecStream(), and ExecStreamTestSuite::testSplitterPlusBarrier().

00215 {
00216     std::vector<std::vector<ExecStreamEmbryo> > listOfList;
00217 
00218     // Convert interStreamEmbryos to a vector of vectors.  E.g., if
00219     // interStreamEmbryos contains (1, 2, 3), it will get converted to:
00220     // ((1)) ((2)) ((3))
00221     for (uint i = 0; i < interStreamEmbryos.size(); i++) {
00222         std::vector<ExecStreamEmbryo> 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 }

SharedExecStream ExecStreamUnitTestBase::prepareDAG	(	ExecStreamEmbryo &	srcStreamEmbryo,
		ExecStreamEmbryo &	splitterStreamEmbryo,
		std::vector< std::vector< ExecStreamEmbryo > > &	interStreamEmbryosList,
		ExecStreamEmbryo &	destStreamEmbryo,
		bool	createSink = `true`,
		bool	saveSrc = `true`
	)			`[protected, inherited]`

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:

	srcStreamEmbryo	embryonic source stream which produces tuples
	splitterStreamEmbryo	embryonic SplitterExecStream which produces tuples for multiple consumers
	interStreamEmbryosList	one or more embryonic intermediate streams which transform tuples; each stream can have one more embryos
	destStreamEmbryo	embryonic confluence stream which processes tuples produced by the interStreamEmbryos
	createSink	if true (the default), creates a final output sink in the stream graph
	saveSrc	if true (the default), save the source in the stream graph; if false, the save has already been done

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     // save all intermediate stream embryos
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         // connect streams in each interStreamEmbryos list in a cascade
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     // connect all inter streams to src and dest
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 }

void ExecStreamUnitTestBase::verifyOutput	(	ExecStream &	stream,
		uint	nRowsExpected,
		MockProducerExecStreamGenerator &	verifier,
		bool	stopEarly = `false`
	)			`[protected, inherited]`

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

Parameters:

	stream	output stream from which to read
	nRowsExpected	number of rows expected
	verifier	generator for expected values
	stopEarly	if true, stop once nRowsExpected have been fetched, even if more rows are available; this can be used for simulating the cleanup effect of an error in the middle of execution

Definition at line 325 of file ExecStreamUnitTestBase.cpp.

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

00330 {
00331     // TODO:  assertions about output tuple
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 }

void ExecStreamUnitTestBase::verifyConstantOutput	(	ExecStream &	stream,
		const TupleData &	expectedTuple,
		uint	nRowsExpected
	)			`[protected, inherited]`

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

Parameters:

	stream	output stream from which to read
	expectedTuple
	nRowsExpected

Definition at line 377 of file ExecStreamUnitTestBase.cpp.

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

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

00381 {
00382     // TODO:  assertions about output tuple
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 }

void ExecStreamUnitTestBase::verifyBufferedOutput	(	ExecStream &	stream,
		TupleDescriptor	outputTupleDesc,
		uint	nRowsExpected,
		PBuffer	expectedBuffer
	)			`[protected, inherited]`

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

Parameters:

	stream	output stream from which to read
	outputTupleDesc	descriptor of expected output tuple
	nRowsExpected	number of rows expected
	expectedBuffer	buffer containing expected tuples

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     // TODO:  assertions about output tuple
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().

00306 {
00307     if (pScheduler) {
00308         pScheduler->stop();
00309     }
00310     tearDownExecStreamTest();
00311 
00312     pScheduler.reset(newScheduler());
00313     pGraph = newStreamGraph();
00314     pGraphEmbryo = newStreamGraphEmbryo(pGraph);
00315     pGraph->setResourceGovernor(pResourceGovernor);
00316 }

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

ExecStream-specific handler called from testCaseTearDown.

Reimplemented from ExecStreamTestBase.

Definition at line 319 of file ExecStreamUnitTestBase.cpp.

References ExecStreamUnitTestBase::pGraph, and ExecStreamUnitTestBase::pGraphEmbryo.

Referenced by ExecStreamUnitTestBase::resetExecStreamTest().

00320 {
00321     pGraph.reset();
00322     pGraphEmbryo.reset();
00323 }

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().

00290 {
00291     ExecStreamTestBase::testCaseSetUp();
00292     openRandomSegment();
00293     pGraph = newStreamGraph();
00294     pGraphEmbryo = newStreamGraphEmbryo(pGraph);
00295     pGraph->setResourceGovernor(pResourceGovernor);
00296 
00297     // we don't bother with quotas for unit tests, but we do need
00298     // to be able to associate TxnId's in order for parallel
00299     // execution to work (since a cache page may be pinned
00300     // by one thread and then released by another)
00301     pCacheAccessor.reset(
00302         new TransactionalCacheAccessor(pCache));
00303 }

SharedExecStreamGraph ExecStreamTestBase::newStreamGraph ( ) [protected, virtual, inherited]

Creates a stream graph.

Definition at line 37 of file ExecStreamTestBase.cpp.

References ExecStreamGraph::newExecStreamGraph().

Referenced by ExecStreamUnitTestBase::resetExecStreamTest(), and ExecStreamUnitTestBase::testCaseSetUp().

00038 {
00039     SharedExecStreamGraph pGraph = ExecStreamGraph::newExecStreamGraph();
00040     pGraph->enableDummyTxnId(true);
00041     return pGraph;
00042 }

SharedExecStreamGraphEmbryo ExecStreamTestBase::newStreamGraphEmbryo ( SharedExecStreamGraph ) [protected, virtual, inherited]

Creates an embryo for a stream graph.

Definition at line 45 of file ExecStreamTestBase.cpp.

References CacheTestBase::pCache, ExecStreamTestBase::pScheduler, and SegStorageTestBase::pSegmentFactory.

Referenced by ExecStreamUnitTestBase::resetExecStreamTest(), and ExecStreamUnitTestBase::testCaseSetUp().

00046 {
00047     return SharedExecStreamGraphEmbryo(
00048         new ExecStreamGraphEmbryo(
00049             g, pScheduler, pCache, pSegmentFactory));
00050 }

ExecStreamScheduler * ExecStreamTestBase::newScheduler ( ) [protected, virtual, inherited]

Creates a scheduler.

Reimplemented in ParallelExecStreamSchedulerTest.

Definition at line 52 of file ExecStreamTestBase.cpp.

Referenced by ExecStreamUnitTestBase::resetExecStreamTest(), and ExecStreamTestBase::testCaseSetUp().

00053 {
00054     return new DfsTreeExecStreamScheduler(
00055         shared_from_this(),
00056         "DfsTreeExecStreamScheduler");
00057 }

ExecStreamGovernor * ExecStreamTestBase::newResourceGovernor	(	ExecStreamResourceKnobs const &	knobSettings,
		ExecStreamResourceQuantity const &	resourcesAvailable
	)			`[protected, virtual, inherited]`

Creates the resource governor.

Definition at line 59 of file ExecStreamTestBase.cpp.

Referenced by ExecStreamTestBase::testCaseSetUp().

00062 {
00063     return new SimpleExecStreamGovernor(
00064         knobSettings, resourcesAvailable, shared_from_this(),
00065         "SimpleExecStreamGovernor");
00066 }

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().

00083 {
00084     // first stop the scheduler
00085     if (pScheduler) {
00086         pScheduler->stop();
00087     }
00088     pCacheAccessor.reset();
00089     // destroy the graph
00090     tearDownExecStreamTest();
00091     // free the scheduler last, since an ExecStreamGraph holds a raw Scheduler
00092     // ptr
00093     pScheduler.reset();
00094     assert(pResourceGovernor.unique());
00095     pResourceGovernor.reset();
00096     SegStorageTestBase::testCaseTearDown();
00097 }

void SegStorageTestBase::openStorage ( DeviceMode openMode ) [virtual, inherited]

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().

00032 {
00033     CacheTestBase::openStorage(openMode);
00034     openSegmentStorage(openMode);
00035 }

void SegStorageTestBase::openSegmentStorage ( DeviceMode openMode ) [virtual, inherited]

Reimplemented in LinearViewSegmentTest, SnapshotSegmentTestBase, and VersionedSegmentTest.

Definition at line 37 of file SegStorageTestBase.cpp.

References CacheTestBase::cbPageFull, DeviceMode::create, SegStorageTestBase::createLinearDeviceSegment(), CacheTestBase::dataDeviceId, SegStorageTestBase::pLinearSegment, and CacheTestBase::pRandomAccessDevice.

Referenced by VersionedSegmentTest::openSegmentStorage(), and SegStorageTestBase::openStorage().

00038 {
00039     pLinearSegment = createLinearDeviceSegment(
00040         dataDeviceId,
00041         openMode.create ? 0
00042         : pRandomAccessDevice->getSizeInBytes() / cbPageFull);
00043 }

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

Reimplemented in LcsClusterReplaceExecStreamTest.

Definition at line 45 of file SegStorageTestBase.cpp.

References SegStorageTestBase::closeStorage(), DeviceMode::load, SegStorageTestBase::openStorage(), SegStorageTestBase::pLinearSegment, SegStorageTestBase::pRandomSegment, and SegStorageTestBase::pSegmentFactory.

Referenced by RandomAllocationSegmentTest::testAllocateAndDeallocate(), LhxHashTableTest::testCaseSetUp(), ExecStreamUnitTestBase::testCaseSetUp(), BTreeTest::testCaseSetUp(), and BTreeReadersTest::testCaseSetUp().

00046 {
00047     // reopen will interpret pages as already allocated, which
00048     // is what RandomAllocationSegment expects
00049     closeStorage();
00050     openStorage(DeviceMode::load);
00051     pRandomSegment = pSegmentFactory->newRandomAllocationSegment(
00052         pLinearSegment, true);
00053     pLinearSegment.reset();
00054 }

SharedSegment SegStorageTestBase::createLinearDeviceSegment	(	DeviceId	deviceId,
		uint	nPages
	)			`[inherited]`

Definition at line 56 of file SegStorageTestBase.cpp.

References LinearDeviceSegmentParams::firstBlockId, LinearDeviceSegmentParams::nPagesAllocated, LinearDeviceSegmentParams::nPagesMin, CacheTestBase::pCache, SegStorageTestBase::pSegmentFactory, CompoundId::setBlockNum(), and CompoundId::setDeviceId().

Referenced by VersionedSegmentTest::openSegmentStorage(), SnapshotSegmentTestBase::openSegmentStorage(), SegStorageTestBase::openSegmentStorage(), and LinearViewSegmentTest::openSegmentStorage().

00058 {
00059     BlockId blockId(0);
00060     CompoundId::setDeviceId(blockId,deviceId);
00061     CompoundId::setBlockNum(blockId,0);
00062     LinearDeviceSegmentParams deviceParams;
00063     deviceParams.firstBlockId = blockId;
00064     deviceParams.nPagesMin = nPages;
00065     deviceParams.nPagesAllocated = nPages;
00066     return pSegmentFactory->newLinearDeviceSegment(
00067         pCache,deviceParams);
00068 }

void SegStorageTestBase::closeLinearSegment ( ) [inherited]

Definition at line 70 of file SegStorageTestBase.cpp.

References SegStorageTestBase::pLinearSegment.

Referenced by VersionedSegmentTest::closeStorage(), SnapshotSegmentTestBase::closeStorage(), SegStorageTestBase::closeStorage(), and SnapshotSegmentTest::testUncommittedReads().

00071 {
00072     if (pLinearSegment) {
00073         assert(pLinearSegment.unique());
00074         pLinearSegment.reset();
00075     }
00076 }

void SegStorageTestBase::closeRandomSegment ( ) [inherited]

Definition at line 78 of file SegStorageTestBase.cpp.

References SegStorageTestBase::pRandomSegment.

Referenced by VersionedSegmentTest::closeStorage(), and SegStorageTestBase::closeStorage().

00079 {
00080     if (pRandomSegment) {
00081         assert(pRandomSegment.unique());
00082         pRandomSegment.reset();
00083     }
00084 }

void SegStorageTestBase::closeVersionedRandomSegment ( ) [inherited]

Definition at line 86 of file SegStorageTestBase.cpp.

References SegStorageTestBase::pVersionedRandomSegment.

Referenced by SnapshotSegmentTestBase::closeStorage(), and SegStorageTestBase::closeStorage().

00087 {
00088     if (pVersionedRandomSegment) {
00089         assert(pVersionedRandomSegment.unique());
00090         pVersionedRandomSegment.reset();
00091     }
00092 }

void SegStorageTestBase::closeSnapshotRandomSegment ( ) [inherited]

Definition at line 94 of file SegStorageTestBase.cpp.

References SegStorageTestBase::pSnapshotRandomSegment.

Referenced by SnapshotSegmentTestBase::closeStorage().

00095 {
00096     if (pSnapshotRandomSegment) {
00097         assert(pSnapshotRandomSegment.unique());
00098         pSnapshotRandomSegment.reset();
00099     }
00100 }

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().

00103 {
00104     closeLinearSegment();
00105     closeRandomSegment();
00106     closeVersionedRandomSegment();
00107     // TODO:  assert pSegmentFactory.unique(), but not here
00108     CacheTestBase::closeStorage();
00109 }

Cache & CacheTestBase::getCache ( ) [inherited]

Definition at line 42 of file CacheTestBase.cpp.

References CacheTestBase::pCache.

Referenced by CacheTest::lockPage(), CacheTest::prefetchBatch(), SegmentTestBase::prefetchPage(), CacheTest::prefetchPage(), PagingTestBase::testCacheResize(), PagingTestBase::testCheckpoint(), PagingTestBase::testOp(), PagingTestBase::testScratch(), SegmentTestBase::unlockPage(), and CacheTest::unlockPage().

00043 {
00044     return *pCache;
00045 }

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

Definition at line 66 of file CacheTestBase.cpp.

References CacheTestBase::cacheParams, Cache::newCache(), CacheTestBase::victimLRU, CacheTestBase::victimPolicy, CacheTestBase::victimRandom, and CacheTestBase::victimTwoQ.

Referenced by CacheTestBase::openStorage().

00067 {
00068     switch (victimPolicy) {
00069     case victimRandom:
00070         return SharedCache(
00071             new RandomCache(cacheParams),
00072             ClosableObjectDestructor());
00073     case victimLRU:
00074         return SharedCache(
00075             new LRUCache(cacheParams),
00076             ClosableObjectDestructor());
00077     case victimTwoQ:
00078         return Cache::newCache(cacheParams);
00079     default:
00080         permAssert(false);
00081     }
00082 }

SharedRandomAccessDevice CacheTestBase::openDevice	(	std::string	devName,
		DeviceMode	openMode,
		uint	nDevicePages,
		DeviceId	deviceId
	)			`[inherited]`

Definition at line 84 of file CacheTestBase.cpp.

References CacheTestBase::cbPageFull, DeviceMode::create, CacheTestBase::pCache, and FileSystem::remove().

Referenced by VersionedSegmentTest::openSegmentStorage(), SnapshotSegmentTestBase::openSegmentStorage(), and CacheTestBase::openStorage().

00087 {
00088     if (openMode.create) {
00089         FileSystem::remove(devName.c_str());
00090     }
00091     SharedRandomAccessDevice pDevice(
00092         new RandomAccessFileDevice(devName,openMode));
00093     if (openMode.create) {
00094         pDevice->setSizeInBytes(nDevicePages*cbPageFull);
00095     }
00096     pCache->registerDevice(deviceId,pDevice);
00097     return pDevice;
00098 }

void CacheTestBase::closeDevice	(	DeviceId	deviceId,
		SharedRandomAccessDevice &	pDevice
	)			`[inherited]`

Definition at line 130 of file CacheTestBase.cpp.

References CHECKPOINT_FLUSH_AND_UNMAP, and CacheTestBase::pCache.

Referenced by VersionedSegmentTest::closeStorage(), SnapshotSegmentTestBase::closeStorage(), and CacheTestBase::closeStorage().

00132 {
00133     if (!pDevice) {
00134         return;
00135     }
00136     DeviceIdPagePredicate pagePredicate(deviceId);
00137     pCache->checkpointPages(pagePredicate,CHECKPOINT_FLUSH_AND_UNMAP);
00138     pCache->unregisterDevice(deviceId);
00139     assert(pDevice.unique());
00140     pDevice.reset();
00141 }

void TestBase::snooze ( uint nSeconds ) [protected, inherited]

Definition at line 263 of file TestBase.cpp.

Referenced by DatabaseTest::executeForceTxn(), ThreadedTestBase::runThreadedTestCase(), PagingTestBase::testCacheResize(), BTreeTxnTest::testCheckpoint(), PagingTestBase::testCheckpointGuarded(), PagingTestBase::testPrefetch(), and PagingTestBase::testPrefetchBatch().

00264 {
00265 #ifdef __MSVC__
00266     ::_sleep(nSeconds*1000);
00267 #else
00268     ::sleep(nSeconds);
00269 #endif
00270 }

void TestBase::readParams	(	int	argc,
		char **	argv
	)			`[static, 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") {   // -t TEST
00123                 permAssert(i + 1 < argc);
00124                 runSingle = argv[++i];
00125             } else if (arg[1] == 't') { // allow -tTEST
00126                 runSingle = arg.substr(2);
00127             }
00128         } else {
00129             int i = arg.find("=");
00130             if ((0 < i) && (i < arg.size())) {
00131                 // an ad hoc parameter
00132                 std::string key = arg.substr(0,i);
00133                 std::string val = arg.substr(i + 1);
00134                 adhocMap.setStringParam(key,val);
00135             } else {
00136                 // a config file name
00137                 std::ifstream configFile(arg.c_str());
00138                 assert(configFile.good());
00139                 configMap.readParams(configFile);
00140             }
00141         }
00142     }
00143     configMap.mergeFrom(adhocMap);
00144 
00145     // set a default dictionary file location for use by tests that need a
00146     // small non-random sorted data set
00147     if (!configMap.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]

Definition at line 157 of file TestBase.cpp.

References TestBase::TestCaseGroup::addAllToTestSuite(), TestBase::defaultTests, TestBase::extraTests, TestBase::TestCaseGroup::findTest(), TestBase::pTestObj, TestBase::pTestSuite, TestBase::runAll, TestBase::runSingle, and TestBase::testName.

00158 {
00159     assert(pTestObj);
00160     assert(pTestObj.use_count() > 1);
00161 
00162     // release self-reference now that all test cases have been registered
00163     pTestObj.reset();
00164 
00165     TestSuite* pTestSuite = BOOST_TEST_SUITE(testName.c_str());
00166 
00167     if (runSingle.size()) {
00168         test_unit *p =  defaultTests.findTest(runSingle);
00169         if (!p) {
00170             p = extraTests.findTest(runSingle);
00171         }
00172         if (!p) {
00173             std::cerr << "test " << runSingle << " not found\n";
00174             exit(2);
00175         }
00176         pTestSuite->add(p);
00177     } else {
00178         defaultTests.addAllToTestSuite(pTestSuite);
00179         if (runAll) {
00180             extraTests.addAllToTestSuite(pTestSuite);
00181         }
00182     }
00183     return pTestSuite;
00184 }

void TestBase::beforeTestCase ( std::string testCaseName ) [inherited]

Definition at line 214 of file TestBase.cpp.

References TestBase::configMap, TraceSource::initTraceSource(), AutoBacktrace::install(), TestBase::notifyTrace(), AutoBacktrace::setOutputStream(), AutoBacktrace::setTraceTarget(), TestBase::testName, and TRACE_INFO.

00215 {
00216     notifyTrace(testName,TRACE_INFO,"ENTER:  " + testCaseName);
00217 
00218     // Install the AutoBacktrace signal handler now, after
00219     // boost::execution_monitor::catch_signals() has installed its own, so that
00220     // on SIGABRT AutoBacktrace goes first, prints the backtrace, then chains
00221     // to boost, which handles the error.
00222     AutoBacktrace::setOutputStream();
00223     AutoBacktrace::setTraceTarget(shared_from_this());
00224     AutoBacktrace::install();
00225     configMap.initTraceSource(shared_from_this(), "testConfig");
00226 }

void TestBase::afterTestCase ( std::string testCaseName ) [inherited]

Definition at line 228 of file TestBase.cpp.

References TestBase::configMap, TraceSource::disableTracing(), TestBase::notifyTrace(), AutoBacktrace::setTraceTarget(), TestBase::testName, and TRACE_INFO.

00229 {
00230     AutoBacktrace::setTraceTarget();
00231     configMap.disableTracing();
00232     notifyTrace(testName,TRACE_INFO,"LEAVE:  " + testCaseName);
00233 }

void TestBase::notifyTrace	(	std::string	source,
		TraceLevel	level,
		std::string	message
	)			`[virtual, inherited]`

Receives notification when a trace event occurs.

Parameters:

	source	the facility from which the message originated
	level	the trace event severity level
	message	the text of the message

Implements TraceTarget.

Definition at line 243 of file TestBase.cpp.

References TestBase::traceFile, TestBase::traceMutex, TestBase::traceStdout, and TestBase::traceStream.

Referenced by TestBase::afterTestCase(), and TestBase::beforeTestCase().

00244 {
00245     if (traceFile || traceStdout) {
00246         StrictMutexGuard traceMutexGuard(traceMutex);
00247         if (traceFile) {
00248             traceStream << "[" << source << "] " << message << std::endl;
00249             traceStream.flush();
00250         }
00251         if (traceStdout) {
00252             std::cout << "[" << source << "] " << message << std::endl;
00253             std::cout.flush();
00254         }
00255     }
00256 }

TraceLevel TestBase::getSourceTraceLevel ( std::string source ) [virtual, inherited]

Gets the level at which a particular source should be traced.

Parameters:

source

name of source to be traced

Returns:: minimum severity level which should be traced

Implements TraceTarget.

Definition at line 258 of file TestBase.cpp.

References TestBase::traceLevel.

Referenced by LbmExecStreamTestBase::generateBitmaps().

00259 {
00260     return traceLevel;
00261 }

Member Data Documentation

SharedExecStreamGraph ExecStreamUnitTestBase::pGraph [protected, inherited]

Definition at line 46 of file ExecStreamUnitTestBase.h.

SharedExecStreamGraphEmbryo ExecStreamUnitTestBase::pGraphEmbryo [protected, inherited]

Definition at line 47 of file ExecStreamUnitTestBase.h.

const uint ExecStreamTestBase::DefaultCacheReservePercent = 5 [static, protected, inherited]

Definition at line 45 of file ExecStreamTestBase.h.

Referenced by ExecStreamTestBase::testCaseSetUp().

const uint ExecStreamTestBase::DefaultConcurrentStatements = 4 [static, protected, inherited]

Definition at line 47 of file ExecStreamTestBase.h.

Referenced by ExecStreamTestBase::testCaseSetUp().

SharedExecStreamScheduler ExecStreamTestBase::pScheduler [protected, inherited]

Definition at line 49 of file ExecStreamTestBase.h.

Referenced by ExecStreamTestBase::newStreamGraphEmbryo(), ExecStreamUnitTestBase::resetExecStreamTest(), ExecStreamTestBase::testCaseSetUp(), ExecStreamTestBase::testCaseTearDown(), LhxJoinExecStreamTest::testImpl(), ExternalSortExecStreamTest::testImpl(), ExecStreamUnitTestBase::verifyBufferedOutput(), ExecStreamUnitTestBase::verifyConstantOutput(), verifyOutput(), and ExecStreamUnitTestBase::verifyOutput().

SharedExecStreamGovernor ExecStreamTestBase::pResourceGovernor [protected, inherited]

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(), verifyOutput(), and ExecStreamUnitTestBase::verifyOutput().

SharedCacheAccessor ExecStreamTestBase::pCacheAccessor [protected, inherited]

Definition at line 53 of file ExecStreamTestBase.h.

Referenced by ExecStreamTestSuite::testBTreeInsertExecStream(), ExecStreamUnitTestBase::testCaseSetUp(), ExecStreamTestBase::testCaseTearDown(), ExecStreamTestSuite::testMergeImplicitPullInputs(), ExecStreamTestSuite::testSegBufferExecStream(), and ExecStreamTestSuite::testSegBufferReaderWriterExecStream().

SharedSegmentFactory SegStorageTestBase::pSegmentFactory [protected, inherited]

Definition at line 40 of file SegStorageTestBase.h.

SharedSegment SegStorageTestBase::pLinearSegment [protected, inherited]

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().

SharedSegment SegStorageTestBase::pRandomSegment [protected, inherited]

(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(), ExecStreamTestSuite::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(), ExecStreamTestSuite::testMergeImplicitPullInputs(), BTreeTest::testMultiKeySearches(), BTreeReadersTest::testReaders(), LcsRowScanExecStreamTest::testScanOnEmptyCluster(), ExecStreamTestSuite::testSegBufferExecStream(), ExecStreamTestSuite::testSegBufferReaderWriterExecStream(), LhxAggExecStreamTest::testSingleValueImpl(), LhxAggExecStreamTest::testSumImpl(), and LbmUnionExecStreamTest::testUnion().

SharedSegment SegStorageTestBase::pVersionedRandomSegment [protected, inherited]

(Optional) segment supporting versioned random page allocation.

Definition at line 55 of file SegStorageTestBase.h.

Referenced by BackupRestoreTest::backup(), SnapshotSegmentTestBase::closeStorage(), SegStorageTestBase::closeVersionedRandomSegment(), SnapshotSegmentTest::deallocateOldPages(), SnapshotSegmentTestBase::openSegmentStorage(), BackupRestoreTest::restore(), LcsClusterReplaceExecStreamTest::testClusterReplace(), SnapshotSegmentTest::testRollback(), and SnapshotSegmentTest::testUncommittedReads().

SharedSegment SegStorageTestBase::pSnapshotRandomSegment [protected, inherited]

(Optional) segment supporting snapshot random page allocation.

Definition at line 60 of file SegStorageTestBase.h.

Referenced by SegStorageTestBase::closeSnapshotRandomSegment(), SnapshotSegmentTestBase::commitChanges(), SnapshotSegmentTestBase::openSegmentStorage(), LcsClusterReplaceExecStreamTest::testClusterReplace(), and SnapshotSegmentTest::testDeallocateOld().

VictimPolicy CacheTestBase::victimPolicy [protected, inherited]

VictimPolicy to instantiate.

Definition at line 53 of file CacheTestBase.h.

Referenced by CacheTestBase::CacheTestBase(), and CacheTestBase::newCache().

CacheParams CacheTestBase::cacheParams [protected, inherited]

Parameters for cache initialization.

Definition at line 58 of file CacheTestBase.h.

Referenced by CacheTestBase::CacheTestBase(), CacheTestBase::newCache(), BackupRestoreTest::testBackupCleanup(), BackupRestoreTest::testHeaderBackupRestore(), and SegPageEntryIterTest::testIter().

SharedCache CacheTestBase::pCache [protected, inherited]

Cache instance being tested.

Definition at line 63 of file CacheTestBase.h.

SharedRandomAccessDevice CacheTestBase::pRandomAccessDevice [protected, inherited]

The default cached device.

Definition at line 68 of file CacheTestBase.h.

Referenced by BackupRestoreTest::backup(), CacheTestBase::closeStorage(), SegStorageTestBase::openSegmentStorage(), CacheTestBase::openStorage(), and BackupRestoreTest::restore().

uint CacheTestBase::nMemPages [protected, inherited]

Size of cache in memory pages.

Definition at line 73 of file CacheTestBase.h.

Referenced by CacheTestBase::CacheTestBase(), PagingTestBase::testCacheResize(), and ExecStreamTestBase::testCaseSetUp().

uint CacheTestBase::nDiskPages [protected, inherited]

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().

uint CacheTestBase::cbPageFull [protected, inherited]

Disk page size.

Definition at line 83 of file CacheTestBase.h.

Referenced by CacheTest::CacheTest(), CacheTestBase::CacheTestBase(), CacheTestBase::openDevice(), and SegStorageTestBase::openSegmentStorage().

DeviceId CacheTestBase::dataDeviceId [protected, inherited]

Fixed ID to assign to data device.

Definition at line 88 of file CacheTestBase.h.

Referenced by CacheTestBase::CacheTestBase(), CacheTestBase::closeStorage(), CacheTest::makeBlockId(), SnapshotSegmentTestBase::openSegmentStorage(), SegStorageTestBase::openSegmentStorage(), LinearViewSegmentTest::openSegmentStorage(), CacheTestBase::openStorage(), and PagingTestBase::testCheckpoint().

TestSuite* TestBase::pTestSuite [protected, inherited]

Boost test suite.

Definition at line 59 of file TestBase.h.

Referenced by TestBase::releaseTestSuite().

boost::shared_ptr<TestBase> TestBase::pTestObj [protected, inherited]

Definition at line 61 of file TestBase.h.

Referenced by TestBase::releaseTestSuite(), and TestBase::TestBase().

std::ofstream TestBase::traceStream [protected, inherited]

Output file stream for tracing.

Definition at line 66 of file TestBase.h.

Referenced by TestBase::notifyTrace(), TestBase::TestBase(), and TestBase::~TestBase().

StrictMutex TestBase::traceMutex [protected, inherited]

Protects traceStream.

Definition at line 71 of file TestBase.h.

Referenced by TestBase::notifyTrace().

std::string TestBase::testName [protected, inherited]

Name of test.

Definition at line 76 of file TestBase.h.

Referenced by TestBase::afterTestCase(), TestBase::beforeTestCase(), TestBase::releaseTestSuite(), TestBase::TestBase(), LhxHashTableTest::testInsert1Ka(), and LhxHashTableTest::testInsert1Kb().

TraceLevel TestBase::traceLevel [protected, inherited]

Level at which to trace test execution.

Definition at line 81 of file TestBase.h.

Referenced by TestBase::getSourceTraceLevel(), and TestBase::TestBase().

FileStatsTarget TestBase::statsTarget [protected, inherited]

Output for stats.

Definition at line 86 of file TestBase.h.

StatsTimer TestBase::statsTimer [protected, inherited]

Timer for stats collection.

Definition at line 91 of file TestBase.h.

Referenced by CacheTestBase::closeStorage(), CacheTestBase::openStorage(), BTreeTxnTest::testCaseSetUp(), BTreeTxnTest::testCaseTearDown(), and BTreeTxnTest::testTxns().

bool TestBase::traceStdout [protected, inherited]

Copy trace output to stdout.

Definition at line 99 of file TestBase.h.

Referenced by TestBase::notifyTrace(), and TestBase::TestBase().

bool TestBase::traceFile [protected, inherited]

Copy trace output to file.

Definition at line 104 of file TestBase.h.

Referenced by TestBase::notifyTrace(), and TestBase::TestBase().

bool TestBase::runAll [static, protected, inherited]

Run all test cases, including the extra tests.

(static, since set by readParams())

Definition at line 110 of file TestBase.h.

Referenced by TestBase::readParams(), and TestBase::releaseTestSuite().

std::string TestBase::runSingle [static, protected, inherited]

Run only the test case of this name.

(static, since set by readParams())

Definition at line 116 of file TestBase.h.

Referenced by TestBase::readParams(), and TestBase::releaseTestSuite().

TestCaseGroup TestBase::defaultTests [protected, inherited]

Definition at line 139 of file TestBase.h.

Referenced by TestBase::releaseTestSuite().

TestCaseGroup TestBase::extraTests [protected, inherited]

Definition at line 140 of file TestBase.h.

Referenced by TestBase::releaseTestSuite().

ParamName TestBase::paramTestSuiteName [static, inherited]

Definition at line 143 of file TestBase.h.

Referenced by TestBase::TestBase().

ParamName TestBase::paramTraceFileName [static, inherited]

Definition at line 144 of file TestBase.h.

Referenced by TestBase::TestBase().

ParamName TestBase::paramDictionaryFileName [static, inherited]

Definition at line 145 of file TestBase.h.

Referenced by TestBase::readParams(), SegStreamTest::testRead(), and SegStreamTest::testWrite().

ParamName TestBase::paramTraceLevel [static, inherited]

Definition at line 146 of file TestBase.h.

Referenced by TestBase::TestBase().

ParamName TestBase::paramStatsFileName [static, inherited]

Definition at line 147 of file TestBase.h.

ParamName TestBase::paramTraceStdout [static, inherited]

Definition at line 148 of file TestBase.h.

Referenced by TestBase::TestBase().

ParamName TestBase::paramDegreeOfParallelism [static, inherited]

Definition at line 149 of file TestBase.h.

Referenced by ParallelExecStreamSchedulerTest::ParallelExecStreamSchedulerTest().

ConfigMap TestBase::configMap [static, inherited]

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 file:

/home/pub/open/dev/fennel/test/FlatFileExecStreamTest.cpp

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

1.5.1

FlatFileExecStreamTest Class Reference

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation