Fennel: BTreeTest Class Reference (original) (raw)

• Main Page

• Namespaces

• Classes

• Files

• Directories

• Related Pages

• Alphabetical List

• Class List

• Class Hierarchy

• Class Members

Inheritance diagram for BTreeTest:

List of all members.

Detailed Description

Definition at line 41 of file BTreeTest.cpp.

Member Enumeration Documentation

Enumerator:

| MONOTONIC | | | ------------ | | | SEQUENTIAL | | | RANDOM | |

Definition at line 48 of file BTreeTest.cpp.

The available victim policy implementations.

Enumerator:

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

Definition at line 44 of file CacheTestBase.h.

Constructor & Destructor Documentation

| BTreeTest::BTreeTest | ( | | ) | [inline, explicit] | | -------------------- | - | | - | -------------------- |

Definition at line 146 of file BTreeTest.cpp.

References TupleData::compute(), TupleAccessor::compute(), descriptor, FixedBuffer, TupleAccessor::getMaxByteCount(), BTreeDescriptor::keyProjection, StandardTypeDescriptorFactory::newDataType(), recordBuf, STANDARD_TYPE_INT_32, testBigMultiKeySearches(), testBulkLoadOneLevelNewRoot(), testBulkLoadOneLevelReuseRoot(), testBulkLoadThreeLevels(), testBulkLoadTwoLevelsNewRoot(), testBulkLoadTwoLevelsReuseRoot(), testMonotonicInserts(), testRandomInserts(), testSequentialInserts(), testSmallMultiKeySearches(), tupleAccessor, tupleData, and BTreeDescriptor::tupleDescriptor.

00147 { 00148 FENNEL_UNIT_TEST_CASE(BTreeTest,testBulkLoadOneLevelNewRoot); 00149 FENNEL_UNIT_TEST_CASE(BTreeTest,testBulkLoadOneLevelReuseRoot); 00150 FENNEL_UNIT_TEST_CASE(BTreeTest,testBulkLoadTwoLevelsNewRoot); 00151 FENNEL_UNIT_TEST_CASE(BTreeTest,testBulkLoadTwoLevelsReuseRoot); 00152 FENNEL_UNIT_TEST_CASE(BTreeTest,testBulkLoadThreeLevels); 00153 FENNEL_UNIT_TEST_CASE(BTreeTest,testSequentialInserts); 00154 FENNEL_UNIT_TEST_CASE(BTreeTest,testRandomInserts); 00155 FENNEL_UNIT_TEST_CASE(BTreeTest,testMonotonicInserts); 00156 00157
00158
00159
00160 FENNEL_UNIT_TEST_CASE(BTreeTest,testSmallMultiKeySearches); 00161 FENNEL_UNIT_TEST_CASE(BTreeTest,testBigMultiKeySearches); 00162 00163 StandardTypeDescriptorFactory stdTypeFactory; 00164 TupleAttributeDescriptor attrDesc( 00165 stdTypeFactory.newDataType(STANDARD_TYPE_INT_32)); 00166 descriptor.tupleDescriptor.push_back(attrDesc); 00167 descriptor.tupleDescriptor.push_back(attrDesc); 00168 descriptor.keyProjection.push_back(0); 00169 tupleAccessor.compute(descriptor.tupleDescriptor); 00170 recordBuf.reset(new FixedBuffer[tupleAccessor.getMaxByteCount()]); 00171 tupleData.compute(descriptor.tupleDescriptor); 00172 }

Member Function Documentation

| int32_t BTreeTest::readKey | ( | | ) | [private] | | ------------------------------------------------------------------------------- | - | | - | ----------- |

| int32_t BTreeTest::readSecondKey | ( | | ) | [private] | | ------------------------------------------------------------------------------------- | - | | - | ----------- |

| int32_t BTreeTest::readValue | ( | | ) | [private] | | --------------------------------------------------------------------------------- | - | | - | ----------- |

| int32_t BTreeTest::readMultiKeyValue | ( | | ) | [private] | | ----------------------------------------------------------------------------------------- | - | | - | ----------- |

| void BTreeTest::testBulkLoadOneLevelNewRoot | ( | | ) | [inline, private] | | ------------------------------------------- | - | | - | ------------------- |

| void BTreeTest::testBulkLoadOneLevelReuseRoot | ( | | ) | [inline, private] | | --------------------------------------------- | - | | - | ------------------- |

| void BTreeTest::testBulkLoadTwoLevelsNewRoot | ( | | ) | [inline, private] | | -------------------------------------------- | - | | - | ------------------- |

| void BTreeTest::testBulkLoadTwoLevelsReuseRoot | ( | | ) | [inline, private] | | ---------------------------------------------- | - | | - | ------------------- |

| void BTreeTest::testBulkLoadThreeLevels | ( | | ) | [inline, private] | | --------------------------------------- | - | | - | ------------------- |

Definition at line 219 of file BTreeTest.cpp.

References BTreeBuilder::build(), TupleData::compute(), BTreeBuilder::createEmptyRoot(), descriptor, TupleAccessor::getCurrentByteCount(), BTreeAccessBase::getKeyDescriptor(), BTreeAccessBase::getRootPageId(), iValueMax, BTreeTest::Record::key, keyData, marshalRecord(), SegInputStream::newSegInputStream(), SegOutputStream::newSegOutputStream(), nRandomSeed, NULL_PAGE_ID, CacheTestBase::pCache, SegStorageTestBase::pRandomSegment, record, recordBuf, BTreeDescriptor::rootPageId, testScan(), testSearch(), BTreeBuilder::truncate(), tupleAccessor, BTreeTest::Record::value, and verifyTree().

Referenced by testBulkLoadOneLevelNewRoot(), testBulkLoadOneLevelReuseRoot(), testBulkLoadThreeLevels(), testBulkLoadTwoLevelsNewRoot(), and testBulkLoadTwoLevelsReuseRoot().

00220 { 00221 BlockNum nPagesAllocatedInitially = 00222 pRandomSegment->getAllocatedSizeInPages(); 00223 00224 descriptor.rootPageId = NULL_PAGE_ID; 00225 BTreeBuilder builder(descriptor,pRandomSegment); 00226 00227 keyData.compute(builder.getKeyDescriptor()); 00228 keyData[0].pData = reinterpret_cast(&record.key); 00229 00230
00231
00232
00233
00234
00235
00236
00237
00238
00239 if (!newRoot) { 00240 builder.createEmptyRoot(); 00241 descriptor.rootPageId = builder.getRootPageId(); 00242 } 00243 00244
00245 SegmentAccessor segmentAccessor(pRandomSegment,pCache); 00246 SharedSegOutputStream pOutputStream = 00247 SegOutputStream::newSegOutputStream(segmentAccessor); 00248 std::subtractive_rng randomNumberGenerator(nRandomSeed); 00249 record.key = 0; 00250 for (uint i = 0; i < nRecords; i++) { 00251
00252 record.key += (randomNumberGenerator(10)) + 2; 00253 record.value = randomNumberGenerator(iValueMax); 00254 00255 marshalRecord(); 00256 uint cbTuple = tupleAccessor.getCurrentByteCount(); 00257 PBuffer pBuffer = pOutputStream->getWritePointer(cbTuple); 00258 memcpy(pBuffer,recordBuf.get(),cbTuple); 00259 pOutputStream->consumeWritePointer(cbTuple); 00260 } 00261 PageId pageId = pOutputStream->getFirstPageId(); 00262 pOutputStream.reset(); 00263 SharedSegInputStream pInputStream = 00264 SegInputStream::newSegInputStream(segmentAccessor,pageId); 00265 SegStreamPosition startPos; 00266 pInputStream->getSegPos(startPos); 00267 00268
00269 builder.build(*pInputStream,nRecords,1.0); 00270 descriptor.rootPageId = builder.getRootPageId(); 00271 00272
00273 verifyTree(nRecords,nLevelsExpected); 00274 00275
00276 pInputStream->seekSegPos(startPos); 00277 testSearch(pInputStream,nRecords,true); 00278 00279
00280
00281 pInputStream->seekSegPos(startPos); 00282 testSearch(pInputStream,nRecords,false); 00283 00284
00285 pInputStream->seekSegPos(startPos); 00286 testScan(pInputStream,nRecords,false,false); 00287 00288
00289 pInputStream->seekSegPos(startPos); 00290 testScan(pInputStream,nRecords,true,true); 00291 00292
00293 verifyTree(nRecords / 2,nLevelsExpected); 00294 00295
00296 pInputStream->seekSegPos(startPos); 00297 testScan(pInputStream,nRecords,true,false); 00298 00299
00300 pInputStream->seekSegPos(startPos); 00301 pInputStream->setDeallocate(true); 00302 pInputStream.reset(); 00303 00304
00305 builder.truncate(true); 00306 00307
00308 BOOST_CHECK_EQUAL( 00309 pRandomSegment->getAllocatedSizeInPages(), 00310 nPagesAllocatedInitially); 00311 }

Definition at line 348 of file BTreeTest.cpp.

References BTreeWriter::deleteCurrent(), descriptor, BTreeReader::endSearch(), BTreeReader::getTupleAccessorForRead(), BTreeTest::Record::key, CacheTestBase::pCache, SegStorageTestBase::pSegmentFactory, readKey(), readValue(), record, BTreeReader::searchFirst(), BTreeReader::searchLast(), BTreeReader::searchNext(), tupleData, TupleAccessor::unmarshal(), unmarshalRecord(), and BTreeTest::Record::value.

Referenced by testBulkLoad().

Definition at line 323 of file BTreeTest.cpp.

References descriptor, DUP_SEEK_ANY, BTreeReader::getTupleAccessorForRead(), BTreeTest::Record::key, keyData, readKey(), readValue(), record, BTreeReader::searchForKey(), tupleData, TupleAccessor::unmarshal(), unmarshalRecord(), and BTreeTest::Record::value.

Referenced by testBulkLoad().

| void BTreeTest::testSearchLast | ( | | ) | [private] | | ------------------------------ | - | | - | ----------- |

| void BTreeTest::testSequentialInserts | ( | | ) | [inline, private] | | ------------------------------------- | - | | - | ------------------- |

| void BTreeTest::testRandomInserts | ( | | ) | [inline, private] | | --------------------------------- | - | | - | ------------------- |

| void BTreeTest::testMonotonicInserts | ( | | ) | [inline, private] | | ------------------------------------ | - | | - | ------------------- |

Definition at line 442 of file BTreeTest.cpp.

References TupleData::compute(), BTreeBuilder::createEmptyRoot(), descriptor, DUP_FAIL, DUP_SEEK_ANY, BTreeAccessBase::getKeyDescriptor(), BTreeAccessBase::getRootPageId(), BTreeReader::getTupleAccessorForRead(), BTreeWriter::insertTupleFromBuffer(), BTreeTest::Record::key, keyData, marshalRecord(), MONOTONIC, NULL_PAGE_ID, CacheTestBase::pCache, SegStorageTestBase::pRandomSegment, SegStorageTestBase::pSegmentFactory, RANDOM, readKey(), readValue(), record, recordBuf, BTreeDescriptor::rootPageId, BTreeReader::searchForKey(), tupleData, BTreeDescriptor::tupleDescriptor, TupleAccessor::unmarshal(), and BTreeTest::Record::value.

Referenced by testMonotonicInserts(), testRandomInserts(), and testSequentialInserts().

| void BTreeTest::marshalRecord | ( | | ) | [private] | | ----------------------------- | - | | - | ----------- |

| void BTreeTest::marshalMultiKeyRecord | ( | | ) | [private] | | ------------------------------------- | - | | - | ----------- |

Definition at line 208 of file BTreeTest.cpp.

References TupleAccessor::getCurrentByteCount(), BTreeTest::Record::key, readKey(), readValue(), record, TupleAccessor::setCurrentTupleBuf(), tupleAccessor, tupleData, TupleAccessor::unmarshal(), and BTreeTest::Record::value.

Referenced by testScan(), and testSearch().

Definition at line 494 of file BTreeTest.cpp.

References TupleData::compute(), TupleAccessor::compute(), BTreeBuilder::createEmptyRoot(), BTreeWriter::deleteCurrent(), descriptor, DUP_FAIL, DUP_SEEK_ANY, DUP_SEEK_BEGIN, DUP_SEEK_END, BTreeReader::endSearch(), FixedBuffer, BTreeAccessBase::getKeyDescriptor(), TupleAccessor::getMaxByteCount(), BTreeAccessBase::getRootPageId(), BTreeWriter::insertTupleFromBuffer(), BTreeTest::Record::key, keyData, BTreeDescriptor::keyProjection, marshalMultiKeyRecord(), StandardTypeDescriptorFactory::newDataType(), NULL_PAGE_ID, CacheTestBase::pCache, SegStorageTestBase::pRandomSegment, SegStorageTestBase::pSegmentFactory, readKey(), readMultiKeyValue(), readSecondKey(), record, recordBuf, BTreeDescriptor::rootPageId, BTreeReader::searchForKey(), BTreeTest::Record::secondKey, STANDARD_TYPE_INT_32, tupleAccessor, tupleData, BTreeDescriptor::tupleDescriptor, and BTreeTest::Record::value.

Referenced by testBigMultiKeySearches(), and testSmallMultiKeySearches().

00495 { 00496
00497 StandardTypeDescriptorFactory stdTypeFactory; 00498 TupleAttributeDescriptor attrDesc( 00499 stdTypeFactory.newDataType(STANDARD_TYPE_INT_32)); 00500 descriptor.tupleDescriptor.clear(); 00501 descriptor.tupleDescriptor.push_back(attrDesc); 00502 descriptor.tupleDescriptor.push_back(attrDesc); 00503 descriptor.keyProjection.clear(); 00504 descriptor.keyProjection.push_back(0); 00505 00506
00507 descriptor.tupleDescriptor.push_back(attrDesc); 00508 descriptor.keyProjection.push_back(1); 00509 00510 tupleAccessor.compute(descriptor.tupleDescriptor); 00511 recordBuf.reset(new FixedBuffer[tupleAccessor.getMaxByteCount()]); 00512 00513
00514
00515 descriptor.rootPageId = NULL_PAGE_ID; 00516 BTreeBuilder builder(descriptor,pRandomSegment); 00517 00518 tupleData.compute(descriptor.tupleDescriptor); 00519 00520 builder.createEmptyRoot(); 00521 descriptor.rootPageId = builder.getRootPageId(); 00522 00523 SegmentAccessor scratchAccessor = pSegmentFactory->newScratchSegment( 00524 pCache, 00525 1); 00526 00527 BTreeWriter writer(descriptor,scratchAccessor,false); 00528 00529 for (uint i = 0; i < nKey1; i++) { 00530 for (uint j = 0; j < nKey2; j++) { 00531 record.key = i; 00532 record.secondKey = j; 00533 record.value = i + j; 00534 marshalMultiKeyRecord(); 00535 writer.insertTupleFromBuffer(recordBuf.get(), DUP_FAIL); 00536 } 00537 } 00538 00539
00540 TupleDescriptor searchKeyDesc; 00541 searchKeyDesc.push_back(attrDesc); 00542 keyData.compute(searchKeyDesc); 00543 keyData[0].pData = reinterpret_cast(&record.key); 00544 00545
00546 BTreeReader reader(descriptor); 00547 for (uint i = 0; i < nKey1; ++i) { 00548 record.key = i; 00549 00550 if (!reader.searchForKey(keyData,DUP_SEEK_BEGIN)) { 00551 BOOST_FAIL("Could not find begin key #" << i); 00552 } 00553 reader.getTupleAccessorForRead().unmarshal(tupleData); 00554 BOOST_CHECK_EQUAL(i,readKey()); 00555 BOOST_CHECK_EQUAL(0,readSecondKey()); 00556 BOOST_CHECK_EQUAL(i,readMultiKeyValue()); 00557 00558
00559
00560 reader.searchForKey(keyData,DUP_SEEK_END); 00561 00562 if (i == nKey1 - 1) { 00563 if (!reader.isSingular()) { 00564 BOOST_FAIL( 00565 "Should have reached end of tree for end key #" << i); 00566 } 00567 } else { 00568 reader.getTupleAccessorForRead().unmarshal(tupleData); 00569 BOOST_CHECK_EQUAL(i + 1,readKey()); 00570 BOOST_CHECK_EQUAL(0,readSecondKey()); 00571 BOOST_CHECK_EQUAL(i + 1,readMultiKeyValue()); 00572 } 00573 } 00574 reader.endSearch(); 00575 00576
00577
00578
00579
00580
00581
00582
00583
00584
00585
00586 00587 TupleData multiKeyData; 00588 multiKeyData.compute(builder.getKeyDescriptor()); 00589 multiKeyData[0].pData = reinterpret_cast(&record.key); 00590 multiKeyData[1].pData = reinterpret_cast(&record.secondKey); 00591 for (uint i = 0; i < nKey1; i++) { 00592 for (uint j = 0; j < nKey2; j++) { 00593 record.key = i; 00594 record.secondKey = j; 00595 if (!writer.searchForKey(multiKeyData,DUP_SEEK_ANY)) { 00596 BOOST_FAIL("Could not find key #" << i); 00597 } 00598 writer.deleteCurrent(); 00599 00600 record.secondKey = j + nKey2; 00601 record.value = i + j + nKey2; 00602 marshalMultiKeyRecord(); 00603 writer.insertTupleFromBuffer(recordBuf.get(), DUP_FAIL); 00604 } 00605 } 00606 writer.endSearch(); 00607 for (uint i = 0; i < nKey1; i++) { 00608 record.key = i; 00609 if (!reader.searchForKey(keyData,DUP_SEEK_BEGIN)) { 00610 BOOST_FAIL("Could not find begin key #" << i); 00611 } 00612 reader.getTupleAccessorForRead().unmarshal(tupleData); 00613 BOOST_CHECK_EQUAL(i,readKey()); 00614 BOOST_CHECK_EQUAL(nKey2,readSecondKey()); 00615 BOOST_CHECK_EQUAL(i + nKey2,readMultiKeyValue()); 00616 00617 reader.searchForKey(keyData,DUP_SEEK_END); 00618 00619 if (i == nKey1 - 1) { 00620 if (!reader.isSingular()) { 00621 BOOST_FAIL( 00622 "Should have reached end of tree for end key #" << i); 00623 } 00624 } else { 00625 reader.getTupleAccessorForRead().unmarshal(tupleData); 00626 BOOST_CHECK_EQUAL(i + 1,readKey()); 00627 BOOST_CHECK_EQUAL(nKey2,readSecondKey()); 00628 BOOST_CHECK_EQUAL(i + 1 + nKey2,readMultiKeyValue()); 00629 } 00630 00631 record.secondKey = 0; 00632 reader.searchForKey(multiKeyData,DUP_SEEK_END); 00633 00634 reader.getTupleAccessorForRead().unmarshal(tupleData); 00635 BOOST_CHECK_EQUAL(i,readKey()); 00636 BOOST_CHECK_EQUAL(nKey2,readSecondKey()); 00637 BOOST_CHECK_EQUAL(i + nKey2,readMultiKeyValue()); 00638 } 00639 }

| void BTreeTest::testSmallMultiKeySearches | ( | | ) | [inline, private] | | ----------------------------------------- | - | | - | ------------------- |

| void BTreeTest::testBigMultiKeySearches | ( | | ) | [inline, private] | | --------------------------------------- | - | | - | ------------------- |

| void BTreeTest::testCaseSetUp | ( | | ) | [virtual] | | ----------------------------- | - | | - | ----------- |

| void BTreeTest::testCaseTearDown | ( | | ) | [virtual] | | -------------------------------- | - | | - | ----------- |

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

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

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

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

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

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

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

Reimplemented from CacheTestBase.

Reimplemented in SnapshotSegmentTestBase, and VersionedSegmentTest.

Definition at line 102 of file SegStorageTestBase.cpp.

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

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

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

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

Parses the command line.

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

Definition at line 108 of file TestBase.cpp.

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

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

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

Member Data Documentation

Definition at line 65 of file BTreeTest.cpp.

Referenced by BTreeTest(), marshalMultiKeyRecord(), marshalRecord(), readKey(), readMultiKeyValue(), readSecondKey(), readValue(), testInserts(), testMultiKeySearches(), testScan(), testSearch(), and unmarshalRecord().

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(), LhxHashTableTest::testCaseSetUp(), LcsClusterReplaceExecStreamTest::testClusterReplace(), LhxAggExecStreamTest::testCountImpl(), ExecStreamTestSuite::testDoubleBufferExecStream(), ExecStreamGovernorTest::testGovernor(), LhxAggExecStreamTest::testGroupCountImpl(), LhxJoinExecStreamTest::testImpl(), ExternalSortExecStreamTest::testImpl(), testInserts(), LbmIntersectExecStreamTest::testIntersect(), LbmEntryTest::testldb35(), LbmEntryTest::testler5920(), LbmLoadBitmapTest::testLoad(), LcsClusterAppendExecStreamTest::testLoadMultiCol(), LcsClusterAppendExecStreamTest::testLoadSingleCol(), LbmEntryTest::testMergeEntry(), testMultiKeySearches(), testScan(), ExecStreamTestSuite::testScratchBufferExecStream(), LhxAggExecStreamTest::testSingleValueImpl(), FlatFileExecStreamTest::testStream(), LhxAggExecStreamTest::testSumImpl(), LogicalTxnTest::testTxn(), SnapshotSegmentTest::testUncommittedReads(), LbmUnionExecStreamTest::testUnion(), SegStreamTest::testWriteSpillAndRead(), and LbmEntryTest::testZeroBytes().

Segment supporting linear page allocation.

Definition at line 45 of file SegStorageTestBase.h.

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

(Optional) segment supporting random page allocation.

Definition at line 50 of file SegStorageTestBase.h.

Referenced by SegStorageTestBase::closeRandomSegment(), SnapshotSegmentTestBase::closeStorage(), LbmSplicerExecStreamTest::createBTree(), LbmSplicerExecStreamTest::initBTreeParam(), LbmSearchTest::initBTreeParam(), LbmLoadBitmapTest::initBTreeParam(), LbmLoadBitmapTest::initBTreeTupleDesc(), LcsClusterReplaceExecStreamTest::initClusterAppendParams(), LbmExecStreamTestBase::initSorterExecStream(), LcsClusterReplaceExecStreamTest::loadCluster(), LcsMultiClusterAppendTest::loadClusters(), LcsRowScanExecStreamTest::loadOneCluster(), LbmSearchTest::loadTableAndIndex(), SegStorageTestBase::openRandomSegment(), SnapshotSegmentTestBase::openSegmentStorage(), LinearViewSegmentTest::openSegmentStorage(), SegmentTestBase::openStorage(), SegmentTestBase::testAllocate(), RandomAllocationSegmentTest::testAllocateAndDeallocate(), ExecStreamTestSuite::testBTreeInsertExecStream(), testBulkLoad(), LhxHashTableTest::testCaseSetUp(), 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(), testInserts(), LbmLoadBitmapTest::testLoad(), LcsClusterAppendExecStreamTest::testLoadMultiCol(), LcsClusterAppendExecStreamTest::testLoadSingleCol(), ExecStreamTestSuite::testMergeImplicitPullInputs(), testMultiKeySearches(), BTreeReadersTest::testReaders(), LcsRowScanExecStreamTest::testScanOnEmptyCluster(), ExecStreamTestSuite::testSegBufferExecStream(), ExecStreamTestSuite::testSegBufferReaderWriterExecStream(), LhxAggExecStreamTest::testSingleValueImpl(), LhxAggExecStreamTest::testSumImpl(), and LbmUnionExecStreamTest::testUnion().

Cache instance being tested.

Definition at line 63 of file CacheTestBase.h.

Referenced by BackupRestoreTest::backup(), CacheTestBase::closeDevice(), CacheTestBase::closeStorage(), LbmSplicerExecStreamTest::createBTree(), SegStorageTestBase::createLinearDeviceSegment(), LogicalTxnTest::createRecoveryLog(), BackupRestoreTest::createSnapshotData(), BackupRestoreTest::executeSnapshotTxn(), CacheTestBase::getCache(), LbmSearchTest::initBTreeExecStreamParam(), LbmLoadBitmapTest::initBTreeExecStreamParam(), LbmSearchTest::initBTreeParam(), LbmLoadBitmapTest::initBTreeParam(), LcsClusterReplaceExecStreamTest::initClusterAppendParams(), LbmExecStreamTestBase::initSorterExecStream(), LcsClusterReplaceExecStreamTest::loadCluster(), LcsMultiClusterAppendTest::loadClusters(), LcsRowScanExecStreamTest::loadOneCluster(), LbmSearchTest::loadTableAndIndex(), SegmentTestBase::lockPage(), LbmMinusExecStreamTest::newMinusStream(), ExecStreamTestBase::newStreamGraphEmbryo(), CacheTestBase::openDevice(), CacheTestBase::openStorage(), LcsClusterReplaceExecStreamTest::replaceCluster(), BackupRestoreTest::restore(), LbmSplicerExecStreamTest::spliceInput(), SegmentTestBase::testAllocate(), RandomAllocationSegmentTest::testAllocateAndDeallocate(), BackupRestoreTest::testBackupCleanup(), ExecStreamTestSuite::testBTreeInsertExecStream(), testBulkLoad(), LhxHashTableTest::testCaseSetUp(), ExecStreamUnitTestBase::testCaseSetUp(), testCaseSetUp(), BTreeReadersTest::testCaseSetUp(), LhxAggExecStreamTest::testCountImpl(), SegmentTestBase::testDeallocate(), SnapshotSegmentTest::testDeallocateOld(), ExecStreamTestSuite::testDoubleBufferExecStream(), ExecStreamGovernorTest::testGovernor(), LhxAggExecStreamTest::testGroupCountImpl(), BackupRestoreTest::testHeaderBackupRestore(), LhxJoinExecStreamTest::testImpl(), ExternalSortExecStreamTest::testImpl(), 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(), testMultiKeySearches(), CacheTest::testQuotaCacheAccessor(), BTreeReadersTest::testReaders(), SegStreamTest::testReadSeg(), 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().

Size of device in disk pages.

Definition at line 78 of file CacheTestBase.h.

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

Configuration parameters.

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

Definition at line 155 of file TestBase.h.

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

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

• /home/pub/open/dev/fennel/test/BTreeTest.cpp

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