LhxHashTableTest Class Reference

Testcase for inserting into hash table. More...

Inheritance diagram for LhxHashTableTest:

List of all members.

Public Member Functions
	LhxHashTableTest ()
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.
void	testInsert1Ka ()
void	testInsert1Kb ()
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
void	snooze (uint nSeconds)
Protected Attributes
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 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
uint	writeHashTable (LhxHashInfo const &hashInfo, LhxHashTable &hashTable, SharedLhxPartition destPartition)
uint	readPartition (LhxHashInfo &hashInfo, SharedLhxPartition srcPartition, ostringstream &dataTrace)
void	testInsert (uint numRows, uint maxBlockCount, uint partitionLevel, VectorOfUint &repeatSeqValues, uint numKeyCols, uint numAggs, uint numDataCols, bool dumpHashTable, bool writeToPartition, uint recursivePartitioning, string testName)
Private Attributes
StandardTypeDescriptorFactory	stdTypeFactory
LhxHashInfo	hashInfo
uint	buildInputIndex

---

Detailed Description

Testcase for inserting into hash table.

Definition at line 41 of file LhxHashTableTest.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.

                      {
        victimTwoQ,
        victimLRU,
        victimRandom
    };

---

Constructor & Destructor Documentation

LhxHashTableTest::LhxHashTableTest

(

)

[inline, explicit]

Definition at line 71 of file LhxHashTableTest.cpp.

References testInsert1Ka(), and testInsert1Kb().

    {
        FENNEL_UNIT_TEST_CASE(LhxHashTableTest, testInsert1Ka);
        FENNEL_UNIT_TEST_CASE(LhxHashTableTest, testInsert1Kb);
    }

---

Member Function Documentation

uint LhxHashTableTest::writeHashTable	(	LhxHashInfo const &	hashInfo,
		LhxHashTable &	hashTable,
		SharedLhxPartition	destPartition
	)			[private]

Definition at line 111 of file LhxHashTableTest.cpp.

References LhxHashTableReader::bindKey(), buildInputIndex, LhxPartitionWriter::close(), TupleData::compute(), LhxHashTableReader::getNext(), hashInfo, LhxHashTableReader::init(), LhxHashInfo::inputDesc, LhxPartitionWriter::marshalTuple(), and LhxPartitionWriter::open().

Referenced by testInsert().

{
    uint tuplesWritten = 0;
    LhxPartitionWriter writer;

    LhxHashTableReader hashTableReader;
    hashTableReader.init(&hashTable, hashInfo, buildInputIndex);
    hashTableReader.bindKey(NULL);
    TupleData outputTuple;

    outputTuple.compute(hashInfo.inputDesc[destPartition->inputIndex]);

    //write to a paritition
    writer.open(destPartition, (LhxHashInfo const &)hashInfo);
    while (hashTableReader.getNext(outputTuple)) {
        writer.marshalTuple(outputTuple);
        tuplesWritten ++;
    }
    writer.close();

    return tuplesWritten;
}

uint LhxHashTableTest::readPartition	(	LhxHashInfo &	hashInfo,
		SharedLhxPartition	srcPartition,
		ostringstream &	dataTrace
	)			[private]

Definition at line 137 of file LhxHashTableTest.cpp.

References LhxPartitionReader::close(), TupleData::compute(), LhxPartitionReader::consumeTuple(), LhxPartitionReader::demandData(), EXECBUF_EOS, LhxPartitionReader::getState(), hashInfo, LhxHashInfo::inputDesc, LhxPartitionReader::isTupleConsumptionPending(), LhxPartitionReader::open(), TuplePrinter::print(), and LhxPartitionReader::unmarshalTuple().

Referenced by testInsert().

{
    LhxPartitionReader reader;
    uint tuplesRead = 0;
    TupleData outputTuple;
    TuplePrinter tuplePrinter;
    TupleDescriptor &inputTupleDesc = hashInfo.inputDesc[1];

    outputTuple.compute(hashInfo.inputDesc[srcPartition->inputIndex]);

    reader.open(srcPartition, (LhxHashInfo const &)hashInfo);

    for (;;) {
        if (!reader.isTupleConsumptionPending()) {
            if (reader.getState() == EXECBUF_EOS) {
                break;
            }
            if (!reader.demandData()) {
                break;
            }
            reader.unmarshalTuple(outputTuple);

            tuplePrinter.print(dataTrace, inputTupleDesc, outputTuple);
            dataTrace << "\n";

            tuplesRead ++;
        }

        reader.consumeTuple();
    }
    reader.close();
    return tuplesRead;
}

void LhxHashTableTest::testInsert	(	uint	numRows,
		uint	maxBlockCount,
		uint	partitionLevel,
		VectorOfUint &	repeatSeqValues,
		uint	numKeyCols,
		uint	numAggs,
		uint	numDataCols,
		bool	dumpHashTable,
		bool	writeToPartition,
		uint	recursivePartitioning,
		string	testName
	)			[private]

Definition at line 174 of file LhxHashTableTest.cpp.

References LhxHashTable::addTuple(), LhxHashInfo::aggsProj, LhxHashTable::allocateResources(), LhxHashTableReader::bindKey(), buildInputIndex, LhxHashTable::calculateNumSlots(), LhxHashInfo::cndKeys, TupleData::compute(), LhxPlan::createChildren(), LhxHashInfo::dataProj, LhxHashTableDump::dump(), LhxHashInfo::filterNull, LhxHashInfo::filterNullKeyProj, LhxHashTable::findKey(), LhxPlan::getFirstLeaf(), LhxHashTableReader::getNext(), LhxPlan::getNextLeaf(), LhxPlan::getPartition(), HASH_TRIM_NONE, hashInfo, LhxHashTableReader::init(), LhxHashTable::init(), LhxHashInfo::inputDesc, LhxHashInfo::isKeyColVarChar, LhxHashInfo::keyProj, LhxPlan::LhxChildPartCount, LhxHashInfo::memSegmentAccessor, StandardTypeDescriptorFactory::newDataType(), LhxHashInfo::numCachePages, LhxHashInfo::numRows, TuplePrinter::print(), SegmentAccessor::pSegment, readPartition(), LhxHashTable::releaseResources(), LhxHashInfo::removeDuplicate, STANDARD_TYPE_INT_32, stdTypeFactory, TRACE_INFO, LhxHashInfo::useJoinFilter, and writeHashTable().

Referenced by testInsert1Ka(), and testInsert1Kb().

{
    LhxHashTable hashTable;

    hashInfo.numCachePages = maxBlockCount;

    TupleAttributeDescriptor attrDesc_int32 =
        TupleAttributeDescriptor(
            stdTypeFactory.newDataType(STANDARD_TYPE_INT_32));
    TupleData inputTuple;

    uint i, j;

    /*
     * Setup hash table.
     */
    uint numCols = numKeyCols + numAggs + numDataCols;

    boost::scoped_array<uint> colValues(new uint[numCols]);

    TupleDescriptor inputDesc;
    TupleProjection keyProj;
    TupleProjection dataProj;
    std::vector<LhxHashTrim> isKeyVarChar;

    for (i = 0; i < numCols; i ++) {
        inputDesc.push_back(attrDesc_int32);

        if (i < numKeyCols) {
            keyProj.push_back(i);
            isKeyVarChar.push_back(HASH_TRIM_NONE);
        } else if (i < numKeyCols + numAggs) {
            hashInfo.aggsProj.push_back(i);
        } else {
            dataProj.push_back(i);
        }
    }

    /*
     * Calculate key cardinality, assuming there's no correlation between key
     * cols.
     */
    uint cndKeys = 1;
    for (i = 0; i < numKeyCols; i ++) {
        cndKeys *= repeatSeqValues[i];
    }

    uint numInputs = 2;
    buildInputIndex = numInputs - 1;
    for (i = 0; i < numInputs; i ++) {
        hashInfo.inputDesc.push_back(inputDesc);
        hashInfo.keyProj.push_back(keyProj);
        hashInfo.isKeyColVarChar.push_back(isKeyVarChar);
        hashInfo.dataProj.push_back(dataProj);
        hashInfo.useJoinFilter.push_back(false);
        hashInfo.filterNull.push_back(false);
        // empty projection : do not filter nulls
        TupleProjection filterNullKeyProj;
        hashInfo.filterNullKeyProj.push_back(filterNullKeyProj);
        hashInfo.removeDuplicate.push_back(false);
        hashInfo.numRows.push_back(numRows);
        hashInfo.cndKeys.push_back(cndKeys);
    }

    TupleDescriptor &inputTupleDesc = hashInfo.inputDesc.back();
    TupleProjection &keyColsProj = hashInfo.keyProj.back();

    hashTable.init(partitionLevel, hashInfo, buildInputIndex);

    uint usablePageSize =
        (hashInfo.memSegmentAccessor.pSegment)->getUsablePageSize();

    hashTable.calculateNumSlots(
        cndKeys, usablePageSize, hashInfo.numCachePages);

    bool status = hashTable.allocateResources();

    assert(status);

    inputTuple.compute(inputTupleDesc);

    /*
     * Insert some tuples.
     */
    for (i = 0; i < numRows; i ++) {
        for (j = 0; j < numCols; j++) {
            colValues[j] = i % repeatSeqValues[j];
            inputTuple[j].pData = (PBuffer)&(colValues[j]);
        }

        status =
            hashTable.addTuple(inputTuple);

        assert(status);
    }

    LhxHashTableReader hashTableReader;
    hashTableReader.init(&hashTable, hashInfo, buildInputIndex);
    TupleData outputTuple;

    outputTuple.compute(inputTupleDesc);

    TuplePrinter tuplePrinter;
    ostringstream dataTrace;
    dataTrace << "All Inserted Tuples:\n";
    uint numTuples = 0;

    /*
     * verify that the hash table reader can see all the tuples.
     */
    while (hashTableReader.getNext(outputTuple)) {
        tuplePrinter.print(dataTrace, inputTupleDesc, outputTuple);
        dataTrace << "\n";
        numTuples ++;
    }
    assert (numTuples == numRows);

    /*
     * Verify that the keys are inserted.
     */
    dataTrace << "All Matched Tuples:\n";
    numTuples = 0;
    /*
     * verify that the hash table reader can see all the unmatched tuples.
     * The above search is done in probing mode, so matched keys are
     * marked as such. The whole table should be returned when reading
     * matched rows.
     */
    for (i = 0; i < numRows; i ++) {
        for (j = 0; j < numCols; j++) {
            colValues[j] = i % repeatSeqValues[j];
            inputTuple[j].pData = (PBuffer)&(colValues[j]);
        }

        PBuffer matchingKey =
            hashTable.findKey(inputTuple, keyColsProj, true);

        if (matchingKey) {
            hashTableReader.bindKey(matchingKey);
            while (hashTableReader.getNext(outputTuple)) {
                tuplePrinter.print(dataTrace, inputTupleDesc, outputTuple);
                dataTrace << "\n";
                numTuples ++;
            }
        }
    }

    assert (numTuples == numRows);

    if (dumpHashTable) {
        LhxHashTableDump hashTableDump(
            TRACE_INFO,
            shared_from_this(),
            "LhxHashTableTest");
        hashTableDump.dump(hashTable);
        hashTableDump.dump(dataTrace.str());
    }

    if (writeToPartition) {
        SharedLhxPartition partition =
            SharedLhxPartition(new LhxPartition(NULL));
        partition->inputIndex = 1;

        //write to a paritition
        uint tuplesWritten =
            writeHashTable(
                (LhxHashInfo const &)hashInfo,
                hashTable,
                partition);

        //read from the same paritition
        ostringstream dataTrace;

        dataTrace << "[Tuples read from partitions-1]\n";

        uint tuplesRead =
            readPartition(hashInfo, partition, dataTrace);

        if (dumpHashTable) {
            LhxHashTableDump hashTableDump(
                TRACE_INFO,
                shared_from_this(),
                "LhxHashTableTest");
            hashTableDump.dump(dataTrace.str());
        }
        // verify read/write row count match.
        assert (tuplesWritten == numRows && tuplesRead == tuplesWritten);
    }

    if (recursivePartitioning > 0) {
        // Using the same data set(the one from the hash table( for both inputs
        // partition all leaf nodes till the tree reaches
        // "recursivePartitioning", partition level starts from level 0 which is
        // a single partition.  For each level, read all the data from the leaf
        // partitions and make sure the rwo count remain the same as the rows
        // initially written into the single partition.

        // First set up the plan at level 0 which conprises of a single
        // partition, one from each side.
        std::vector<SharedLhxPartition> partitions;
        uint tuplesWritten[2];

        // for both input sides.
        for (int j = 0; j < 2; j ++) {
            partitions.push_back(
                SharedLhxPartition(new LhxPartition(NULL)));
            partitions[j]->inputIndex = 1;
            tuplesWritten[j] =
                writeHashTable(
                    (LhxHashInfo const &)hashInfo,
                    hashTable,
                    partitions[j]);
        }

        assert (tuplesWritten[0] == numRows &&
                tuplesWritten[0] == tuplesWritten[1]);

        uint tuplesRead[2];
        SharedLhxPlan plan = SharedLhxPlan(new LhxPlan());

        plan->init(WeakLhxPlan(), 0, partitions, false);

        LhxPlan *leafPlan;
        uint numLeafPlanCreated = 1;
        uint numLeafPlanRead = 0;

        for (int i = 0; i < recursivePartitioning; i ++) {
            numLeafPlanCreated *= LhxPlan::LhxChildPartCount;
            numLeafPlanRead = 0;
            leafPlan = plan->getFirstLeaf();

            //create leaf plans for the next level
            while (leafPlan) {
                leafPlan->createChildren(hashInfo, false);
                //skip the next numChildPart leaves as they are newly
                //created children
                leafPlan = leafPlan->getFirstLeaf();
                for (int k = 0; k < LhxPlan::LhxChildPartCount; k ++) {
                    leafPlan = leafPlan->getNextLeaf();
                }
            }
        }

        // each partition can be read exactly once(since SegStreamAllocation
        // deletes the disk content)
        // so only verify the leaf level partitions.

        tuplesRead[0] = 0;
        tuplesRead[1] = 0;

        // get the first leaf
        leafPlan = plan->getFirstLeaf();

        while (leafPlan) {
            numLeafPlanRead ++;
            for (int j = 0; j < 2; j ++) {
                ostringstream dataTrace;
                dataTrace << "[Tuples read from partitions-2]"
                          << "recursion depth" << recursivePartitioning
                          << "inputindex " << j << "\n";
                tuplesRead[j] +=
                    readPartition(
                        hashInfo,
                        leafPlan->getPartition(j),
                        dataTrace);
                if (dumpHashTable) {
                    LhxHashTableDump hashTableDump(
                        TRACE_INFO,
                        shared_from_this(),
                        "LhxHashTableTest");
                    hashTableDump.dump(dataTrace.str());
                }
            }
            leafPlan = leafPlan->getNextLeaf();
        }

        assert (numLeafPlanRead == numLeafPlanCreated);
        assert ((tuplesRead[0] == tuplesRead[1]) &&
            (tuplesRead[0] == numRows));
    }

    hashTable.releaseResources();
    colValues.reset();
}

void LhxHashTableTest::testCaseSetUp

(

)

[virtual]

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

Default is no-op.

Reimplemented from TestBase.

Definition at line 84 of file LhxHashTableTest.cpp.

References DeviceMode::createNew, LhxHashInfo::externalSegmentAccessor, hashInfo, LhxHashInfo::memSegmentAccessor, SegStorageTestBase::openRandomSegment(), SegStorageTestBase::openStorage(), CacheTestBase::pCache, SegmentAccessor::pCacheAccessor, SegStorageTestBase::pRandomSegment, SegmentAccessor::pSegment, and SegStorageTestBase::pSegmentFactory.

{
    openStorage(DeviceMode::createNew);
    openRandomSegment();
    hashInfo.externalSegmentAccessor.pSegment = pRandomSegment;
    hashInfo.externalSegmentAccessor.pCacheAccessor = pCache;
    hashInfo.memSegmentAccessor =
        pSegmentFactory->newScratchSegment(pCache, 100);
}

void LhxHashTableTest::testCaseTearDown

(

)

[virtual]

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

Default is no-op.

Reimplemented from CacheTestBase.

Definition at line 94 of file LhxHashTableTest.cpp.

References LhxHashInfo::aggsProj, LhxHashInfo::dataProj, LhxHashInfo::externalSegmentAccessor, hashInfo, LhxHashInfo::inputDesc, LhxHashInfo::isKeyColVarChar, LhxHashInfo::keyProj, LhxHashInfo::memSegmentAccessor, NULL_PAGE_ID, SegmentAccessor::pSegment, SegmentAccessor::reset(), and CacheTestBase::testCaseTearDown().

{
    hashInfo.inputDesc.clear();
    hashInfo.keyProj.clear();
    hashInfo.isKeyColVarChar.clear();

    hashInfo.aggsProj.clear();
    hashInfo.dataProj.clear();

    hashInfo.memSegmentAccessor.pSegment->deallocatePageRange(
        NULL_PAGE_ID,
        NULL_PAGE_ID);
    hashInfo.externalSegmentAccessor.reset();
    hashInfo.memSegmentAccessor.reset();
    SegStorageTestBase::testCaseTearDown();
}

void LhxHashTableTest::testInsert1Ka

(

)

Definition at line 470 of file LhxHashTableTest.cpp.

References testInsert(), and TestBase::testName.

Referenced by LhxHashTableTest().

{
    uint numRows = 100;
    uint maxBlockCount = 10;
    uint partitionLevel = 0;
    VectorOfUint values;
    uint numKeyCols = 1;
    uint numAggs = 0;
    uint numDataCols = 0;
    bool dumpHashTable = true;
    bool writeToPartition = true;
    uint recursivePartitioning = 3;
    string testName = "testInsert1K";
    uint i;

    for (i = 0; i < numKeyCols; i ++) {
        /*
         * At least one value, hence + 1.
         */
        values.push_back(i + 10);
    }

    for (i = 0; i < numAggs; i ++) {
        values.push_back(10);
    }

    for (i = 0; i < numDataCols; i ++) {
        values.push_back(i + 1);
    }

    testInsert(
        numRows, maxBlockCount, partitionLevel,
        values, numKeyCols, numAggs, numDataCols,
        dumpHashTable, writeToPartition, recursivePartitioning,
        testName);
}

void LhxHashTableTest::testInsert1Kb

(

)

Definition at line 507 of file LhxHashTableTest.cpp.

References testInsert(), and TestBase::testName.

Referenced by LhxHashTableTest().

{
    uint numRows = 1000;
    uint maxBlockCount = 10;
    uint partitionLevel = 0;
    VectorOfUint values;
    uint numKeyCols = 2;
    uint numAggs = 0;
    uint numDataCols = 4;
    bool dumpHashTable = true;
    bool writeToPartition = true;
    uint recursivePartitioning = 3;
    string testName = "testInsert1K";
    uint i;

    for (i = 0; i < numKeyCols; i ++) {
        /*
         * At least one value, hence + 1.
         */
        values.push_back(i + 10);
    }

    for (i = 0; i < numAggs; i ++) {
        values.push_back(10);
    }

    for (i = 0; i < numDataCols; i ++) {
        values.push_back(i + 1);
    }

    testInsert(
        numRows, maxBlockCount, partitionLevel,
        values, numKeyCols, numAggs, numDataCols,
        dumpHashTable, writeToPartition, recursivePartitioning,
        testName);
}

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(), testCaseSetUp(), ExecStreamTestBase::testCaseSetUp(), BTreeTest::testCaseSetUp(), BTreeReadersTest::testCaseSetUp(), LbmEntryTest::testCaseSetUp(), SegPageIterTest::testIter(), SegPageEntryIterTest::testIter(), SegStreamTest::testMarkReset(), SegStreamTest::testReadSeg(), LogicalTxnTest::testTxn(), SegStreamTest::testWriteSeg(), and SegStreamTest::testWriteSpillAndRead().

{
    CacheTestBase::openStorage(openMode);
    openSegmentStorage(openMode);
}

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

{
    pLinearSegment = createLinearDeviceSegment(
        dataDeviceId,
        openMode.create ? 0
        : pRandomAccessDevice->getSizeInBytes() / cbPageFull);
}

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(), testCaseSetUp(), ExecStreamUnitTestBase::testCaseSetUp(), BTreeTest::testCaseSetUp(), and BTreeReadersTest::testCaseSetUp().

{
    // reopen will interpret pages as already allocated, which
    // is what RandomAllocationSegment expects
    closeStorage();
    openStorage(DeviceMode::load);
    pRandomSegment = pSegmentFactory->newRandomAllocationSegment(
        pLinearSegment, true);
    pLinearSegment.reset();
}

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

{
    BlockId blockId(0);
    CompoundId::setDeviceId(blockId,deviceId);
    CompoundId::setBlockNum(blockId,0);
    LinearDeviceSegmentParams deviceParams;
    deviceParams.firstBlockId = blockId;
    deviceParams.nPagesMin = nPages;
    deviceParams.nPagesAllocated = nPages;
    return pSegmentFactory->newLinearDeviceSegment(
        pCache,deviceParams);
}

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

{
    if (pLinearSegment) {
        assert(pLinearSegment.unique());
        pLinearSegment.reset();
    }
}

void SegStorageTestBase::closeRandomSegment

(

)

[inherited]

Definition at line 78 of file SegStorageTestBase.cpp.

References SegStorageTestBase::pRandomSegment.

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

{
    if (pRandomSegment) {
        assert(pRandomSegment.unique());
        pRandomSegment.reset();
    }
}

void SegStorageTestBase::closeVersionedRandomSegment

(

)

[inherited]

Definition at line 86 of file SegStorageTestBase.cpp.

References SegStorageTestBase::pVersionedRandomSegment.

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

{
    if (pVersionedRandomSegment) {
        assert(pVersionedRandomSegment.unique());
        pVersionedRandomSegment.reset();
    }
}

void SegStorageTestBase::closeSnapshotRandomSegment

(

)

[inherited]

Definition at line 94 of file SegStorageTestBase.cpp.

References SegStorageTestBase::pSnapshotRandomSegment.

Referenced by SnapshotSegmentTestBase::closeStorage().

{
    if (pSnapshotRandomSegment) {
        assert(pSnapshotRandomSegment.unique());
        pSnapshotRandomSegment.reset();
    }
}

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

{
    closeLinearSegment();
    closeRandomSegment();
    closeVersionedRandomSegment();
    // TODO:  assert pSegmentFactory.unique(), but not here
    CacheTestBase::closeStorage();
}

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

{
    return *pCache;
}

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

{
    switch (victimPolicy) {
    case victimRandom:
        return SharedCache(
            new RandomCache(cacheParams),
            ClosableObjectDestructor());
    case victimLRU:
        return SharedCache(
            new LRUCache(cacheParams),
            ClosableObjectDestructor());
    case victimTwoQ:
        return Cache::newCache(cacheParams);
    default:
        permAssert(false);
    }
}

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

{
    if (openMode.create) {
        FileSystem::remove(devName.c_str());
    }
    SharedRandomAccessDevice pDevice(
        new RandomAccessFileDevice(devName,openMode));
    if (openMode.create) {
        pDevice->setSizeInBytes(nDevicePages*cbPageFull);
    }
    pCache->registerDevice(deviceId,pDevice);
    return pDevice;
}

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

{
    if (!pDevice) {
        return;
    }
    DeviceIdPagePredicate pagePredicate(deviceId);
    pCache->checkpointPages(pagePredicate,CHECKPOINT_FLUSH_AND_UNMAP);
    pCache->unregisterDevice(deviceId);
    assert(pDevice.unique());
    pDevice.reset();
}

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

{
#ifdef __MSVC__
    ::_sleep(nSeconds*1000);
#else
    ::sleep(nSeconds);
#endif
}

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.

{
    bool verbose = false;
    ConfigMap adhocMap;

    for (int i = 1; i < argc; ++i) {
        std::string arg = argv[i];
        if (argv[i][0] == '-') {
            if (arg == "-v") {
                verbose = true;
            } else if (arg == "-") {
                configMap.readParams(std::cin);
            } else if (arg == "-all") {
                runAll = true;
            } else if (arg == "-t") {   // -t TEST
                permAssert(i + 1 < argc);
                runSingle = argv[++i];
            } else if (arg[1] == 't') { // allow -tTEST
                runSingle = arg.substr(2);
            }
        } else {
            int i = arg.find("=");
            if ((0 < i) && (i < arg.size())) {
                // an ad hoc parameter
                std::string key = arg.substr(0,i);
                std::string val = arg.substr(i + 1);
                adhocMap.setStringParam(key,val);
            } else {
                // a config file name
                std::ifstream configFile(arg.c_str());
                assert(configFile.good());
                configMap.readParams(configFile);
            }
        }
    }
    configMap.mergeFrom(adhocMap);

    // set a default dictionary file location for use by tests that need a
    // small non-random sorted data set
    if (!configMap.isParamSet(paramDictionaryFileName)) {
        std::string dictFileName = "dictWords";
        configMap.setStringParam(paramDictionaryFileName,dictFileName);
    }

    if (verbose) {
        configMap.dumpParams(std::cout);
    }
}

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.

{
    assert(pTestObj);
    assert(pTestObj.use_count() > 1);

    // release self-reference now that all test cases have been registered
    pTestObj.reset();

    TestSuite* pTestSuite = BOOST_TEST_SUITE(testName.c_str());

    if (runSingle.size()) {
        test_unit *p =  defaultTests.findTest(runSingle);
        if (!p) {
            p = extraTests.findTest(runSingle);
        }
        if (!p) {
            std::cerr << "test " << runSingle << " not found\n";
            exit(2);
        }
        pTestSuite->add(p);
    } else {
        defaultTests.addAllToTestSuite(pTestSuite);
        if (runAll) {
            extraTests.addAllToTestSuite(pTestSuite);
        }
    }
    return pTestSuite;
}

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.

{
    notifyTrace(testName,TRACE_INFO,"ENTER:  " + testCaseName);

    // Install the AutoBacktrace signal handler now, after
    // boost::execution_monitor::catch_signals() has installed its own, so that
    // on SIGABRT AutoBacktrace goes first, prints the backtrace, then chains
    // to boost, which handles the error.
    AutoBacktrace::setOutputStream();
    AutoBacktrace::setTraceTarget(shared_from_this());
    AutoBacktrace::install();
    configMap.initTraceSource(shared_from_this(), "testConfig");
}

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.

{
    AutoBacktrace::setTraceTarget();
    configMap.disableTracing();
    notifyTrace(testName,TRACE_INFO,"LEAVE:  " + testCaseName);
}

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

{
    if (traceFile || traceStdout) {
        StrictMutexGuard traceMutexGuard(traceMutex);
        if (traceFile) {
            traceStream << "[" << source << "] " << message << std::endl;
            traceStream.flush();
        }
        if (traceStdout) {
            std::cout << "[" << source << "] " << message << std::endl;
            std::cout.flush();
        }
    }
}

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

{
    return traceLevel;
}

---

Member Data Documentation

StandardTypeDescriptorFactory LhxHashTableTest::stdTypeFactory [private]

Definition at line 43 of file LhxHashTableTest.cpp.

Referenced by testInsert().

LhxHashInfo LhxHashTableTest::hashInfo [private]

Definition at line 44 of file LhxHashTableTest.cpp.

Referenced by readPartition(), testCaseSetUp(), testCaseTearDown(), testInsert(), and writeHashTable().

uint LhxHashTableTest::buildInputIndex [private]

Definition at line 45 of file LhxHashTableTest.cpp.

Referenced by testInsert(), and writeHashTable().

SharedSegmentFactory SegStorageTestBase::pSegmentFactory [protected, inherited]

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(), ExecStreamTestSuite::testBTreeInsertExecStream(), testCaseSetUp(), LcsClusterReplaceExecStreamTest::testClusterReplace(), LhxAggExecStreamTest::testCountImpl(), ExecStreamTestSuite::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(), ExecStreamTestSuite::testScratchBufferExecStream(), LhxAggExecStreamTest::testSingleValueImpl(), FlatFileExecStreamTest::testStream(), LhxAggExecStreamTest::testSumImpl(), LogicalTxnTest::testTxn(), SnapshotSegmentTest::testUncommittedReads(), LbmUnionExecStreamTest::testUnion(), SegStreamTest::testWriteSpillAndRead(), and LbmEntryTest::testZeroBytes().

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

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(), ExecStreamTestSuite::testBTreeInsertExecStream(), BTreeTest::testBulkLoad(), testCaseSetUp(), ExecStreamUnitTestBase::testCaseSetUp(), BTreeTest::testCaseSetUp(), BTreeReadersTest::testCaseSetUp(), LhxAggExecStreamTest::testCountImpl(), SegmentTestBase::testDeallocate(), SnapshotSegmentTest::testDeallocateOld(), ExecStreamTestSuite::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(), ExecStreamTestSuite::testScratchBufferExecStream(), LhxAggExecStreamTest::testSingleValueImpl(), FlatFileExecStreamTest::testStream(), LhxAggExecStreamTest::testSumImpl(), LogicalTxnTest::testTxn(), LogicalTxnTest::testTxnIdSequence(), LbmUnionExecStreamTest::testUnion(), SegStreamTest::testWriteSeg(), SegStreamTest::testWriteSpillAndRead(), LbmEntryTest::testZeroBytes(), and BackupRestoreTest::verifySnapshotData().

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(), testInsert1Ka(), and 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/LhxHashTableTest.cpp

---