Fennel: BackupRestoreTest Class Reference (original) (raw)

• Main Page

• Namespaces

• Classes

• Files

• Directories

• Related Pages

• Alphabetical List

• Class List

• Class Hierarchy

• Class Members

Unit test for backup and restore of database header pages and a VersionedRandomAllocationSegment. More...

Inheritance diagram for BackupRestoreTest:

List of all members.

Detailed Description

Unit test for backup and restore of database header pages and a VersionedRandomAllocationSegment.

Definition at line 43 of file BackupRestoreTest.cpp.

Member Typedef Documentation

Member Enumeration Documentation

The available victim policy implementations.

Enumerator:

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

Definition at line 44 of file CacheTestBase.h.

The various operations that can be run in the multi-threaded test.

Enumerator:

| OP_READ_SEQ | | | --------------------- | | | OP_WRITE_SEQ | | | OP_READ_RAND | | | OP_WRITE_RAND | | | OP_READ_NOWAIT | | | OP_WRITE_NOWAIT | | | OP_WRITE_SKIP | | | OP_SCRATCH | | | OP_PREFETCH | | | OP_PREFETCH_BATCH | | | OP_ALLOCATE | | | OP_DEALLOCATE | | | OP_CHECKPOINT | | | OP_RESIZE_CACHE | | | OP_MAX | |

Definition at line 83 of file PagingTestBase.h.

00083 { 00084 OP_READ_SEQ, 00085 OP_WRITE_SEQ, 00086 OP_READ_RAND, 00087 OP_WRITE_RAND, 00088 OP_READ_NOWAIT, 00089 OP_WRITE_NOWAIT, 00090 OP_WRITE_SKIP, 00091 OP_SCRATCH, 00092 OP_PREFETCH, 00093 OP_PREFETCH_BATCH, 00094 OP_ALLOCATE, 00095 OP_DEALLOCATE, 00096 OP_CHECKPOINT, 00097 OP_RESIZE_CACHE, 00098 OP_MAX 00099 };

Constructor & Destructor Documentation

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

Member Function Documentation

| void BackupRestoreTest::createSnapshotData | ( | | ) | [private] | | ------------------------------------------ | - | | - | ----------- |

Definition at line 115 of file BackupRestoreTest.cpp.

References SegNodeLock< Node >::allocatePage(), Segment::checkpoint(), CHECKPOINT_FLUSH_ALL, SnapshotRandomAllocationSegment::commitChanges(), TestBase::configMap, DeviceMode::createNew, executeSnapshotTxn(), SegNodeLock< Node >::getNodeForWrite(), Database::newDatabase(), CacheTestBase::pCache, pDatabase, persistentPageId, and SegPageLock::unlock().

Referenced by testBackupCleanup(), and testHeaderBackupRestore().

Definition at line 376 of file BackupRestoreTest.cpp.

References Segment::checkpoint(), CHECKPOINT_FLUSH_ALL, SnapshotRandomAllocationSegment::commitChanges(), SegNodeLock< Node >::getNodeForWrite(), SegPageLock::lockExclusive(), CacheTestBase::pCache, pDatabase, persistentPageId, and SegPageLock::unlock().

Referenced by createSnapshotData(), testBackupCleanup(), and testHeaderBackupRestore().

Definition at line 420 of file BackupRestoreTest.cpp.

References backup(), SnapshotSegmentTestBase::closeStorage(), DeviceMode::createNew, SnapshotSegmentTestBase::currCsn, DeviceMode::load, NULL_TXN_ID, SegmentTestBase::openStorage(), restore(), SnapshotSegmentTestBase::testAllocateAll(), PagingTestBase::testSkipWrite(), SnapshotSegmentTestBase::updatedCsns, and verifyData().

Referenced by testBackupRestoreCompressed(), and testBackupRestoreUncompressed().

00421 { 00422
00423
00424 currCsn = TxnId(0); 00425 openStorage(DeviceMode::createNew); 00426 testAllocateAll(); 00427 closeStorage(); 00428 00429
00430 currCsn = TxnId(5); 00431 updatedCsns.push_back(currCsn); 00432 openStorage(DeviceMode::load); 00433 testSkipWrite(5); 00434 closeStorage(); 00435 00436
00437 std::string backup5 = "backupTxnId5.dat"; 00438 backup(backup5, NULL_TXN_ID, TxnId(5), isCompressed); 00439 00440
00441 currCsn = TxnId(7); 00442 updatedCsns.push_back(currCsn); 00443 openStorage(DeviceMode::load); 00444 testSkipWrite(7); 00445 closeStorage(); 00446 00447
00448 std::string backup5to7 = "backupTxnId5to7.dat"; 00449 backup(backup5to7, TxnId(5), TxnId(7), isCompressed); 00450 00451
00452 currCsn = TxnId(11); 00453 updatedCsns.push_back(currCsn); 00454 openStorage(DeviceMode::load); 00455 testSkipWrite(11); 00456 closeStorage(); 00457 00458
00459 std::string backup7to11 = "backupTxnId7to11.dat"; 00460 backup(backup7to11, TxnId(7), TxnId(11), isCompressed); 00461 00462
00463 std::string backup5to11 = "backupTxnId5to11.dat"; 00464 backup(backup5to11, TxnId(5), TxnId(11), isCompressed); 00465 00466
00467 restore(backup5, NULL_TXN_ID, TxnId(5), isCompressed); 00468 00469
00470
00471
00472 updatedCsns.clear(); 00473 updatedCsns.push_back(TxnId(5)); 00474 verifyData(); 00475 00476
00477
00478 restore(backup5to7, TxnId(5), TxnId(7), isCompressed); 00479 updatedCsns.push_back(TxnId(7)); 00480 verifyData(); 00481 00482
00483
00484 restore(backup7to11, TxnId(7), TxnId(11), isCompressed); 00485 updatedCsns.push_back(TxnId(11)); 00486 verifyData(); 00487 00488
00489
00490 restore(backup5, NULL_TXN_ID, TxnId(5), isCompressed); 00491 updatedCsns.clear(); 00492 updatedCsns.push_back(TxnId(5)); 00493 verifyData(); 00494 restore(backup5to11, TxnId(5), TxnId(11), isCompressed); 00495 updatedCsns.push_back(TxnId(7)); 00496 updatedCsns.push_back(TxnId(11)); 00497 verifyData(); 00498 }

Definition at line 500 of file BackupRestoreTest.cpp.

References VersionedRandomAllocationSegment::backupAllocationNodes(), VersionedRandomAllocationSegment::backupDataPages(), SnapshotSegmentTestBase::closeStorage(), getCompressionProgram(), DeviceMode::load, SegPageBackupRestoreDevice::newSegPageBackupRestoreDevice(), SegmentTestBase::openStorage(), CacheTestBase::pCache, CacheTestBase::pRandomAccessDevice, SegStorageTestBase::pSegmentFactory, and SegStorageTestBase::pVersionedRandomSegment.

Referenced by testBackupRestore().

00505 { 00506 openStorage(DeviceMode::load); 00507 VersionedRandomAllocationSegment pVRSegment = 00508 SegmentFactory::dynamicCast<VersionedRandomAllocationSegment *>( 00509 pVersionedRandomSegment); 00510 SegmentAccessor scratchAccessor = 00511 pSegmentFactory->newScratchSegment(pCache, 12); 00512 00513 if (isCompressed) { 00514 backupFileName.append(".gz"); 00515 } 00516 SharedSegPageBackupRestoreDevice pBackupDevice = 00517 SegPageBackupRestoreDevice::newSegPageBackupRestoreDevice( 00518 backupFileName, 00519 "w", 00520 getCompressionProgram(isCompressed), 00521 10, 00522 2, 00523 scratchAccessor, 00524 pCache->getDeviceAccessScheduler(pRandomAccessDevice), 00525 pRandomAccessDevice); 00526 bool abortFlag = false; 00527 pVRSegment->backupAllocationNodes( 00528 pBackupDevice, 00529 false, 00530 lowerBoundCsn, 00531 upperBoundCsn, 00532 abortFlag); 00533 pVRSegment->backupDataPages( 00534 pBackupDevice, 00535 lowerBoundCsn, 00536 upperBoundCsn, 00537 abortFlag); 00538 00539 assert(pBackupDevice.unique()); 00540 pBackupDevice.reset(); 00541 00542 scratchAccessor.reset(); 00543 closeStorage(); 00544 }

Definition at line 546 of file BackupRestoreTest.cpp.

References CHECKPOINT_FLUSH_AND_UNMAP, SnapshotSegmentTestBase::closeStorage(), getCompressionProgram(), DeviceMode::load, SegPageBackupRestoreDevice::newSegPageBackupRestoreDevice(), SegmentTestBase::openStorage(), CacheTestBase::pCache, CacheTestBase::pRandomAccessDevice, SegStorageTestBase::pSegmentFactory, SegStorageTestBase::pVersionedRandomSegment, and VersionedRandomAllocationSegment::restoreFromBackup().

Referenced by testBackupRestore().

00551 { 00552 openStorage(DeviceMode::load); 00553 VersionedRandomAllocationSegment *pVRSegment = 00554 SegmentFactory::dynamicCast<VersionedRandomAllocationSegment *>( 00555 pVersionedRandomSegment); 00556 SegmentAccessor scratchAccessor = 00557 pSegmentFactory->newScratchSegment(pCache, 10); 00558 00559
00560
00561 MappedPageListenerPredicate pagePredicate(pVRSegment); 00562 pCache->checkpointPages(pagePredicate, CHECKPOINT_FLUSH_AND_UNMAP); 00563 00564 if (isCompressed) { 00565 backupFileName.append(".gz"); 00566 } 00567 SharedSegPageBackupRestoreDevice pBackupDevice = 00568 SegPageBackupRestoreDevice::newSegPageBackupRestoreDevice( 00569 backupFileName, 00570 "r", 00571 getCompressionProgram(isCompressed), 00572 10, 00573 0, 00574 scratchAccessor, 00575 pCache->getDeviceAccessScheduler(pRandomAccessDevice), 00576 pRandomAccessDevice); 00577 bool abortFlag = false; 00578 pVRSegment->restoreFromBackup( 00579 pBackupDevice, 00580 lowerBoundCsn, 00581 upperBoundCsn, 00582 abortFlag); 00583 00584 assert(pBackupDevice.unique()); 00585 pBackupDevice.reset(); 00586 00587 scratchAccessor.reset(); 00588 closeStorage(); 00589 }

| void BackupRestoreTest::verifyData | ( | | ) | [private] | | ---------------------------------- | - | | - | ----------- |

| void BackupRestoreTest::testHeaderBackupRestore | ( | | ) | | ----------------------------------------------- | - | | - |

Tests backup and restore of the database header pages.

Definition at line 150 of file BackupRestoreTest.cpp.

References CacheTestBase::cacheParams, TestBase::configMap, createSnapshotData(), executeSnapshotTxn(), Cache::newCache(), NULL_TXN_ID, Database::paramDatabaseDir, CacheTestBase::pCache, pDatabase, CacheParams::readConfig(), ConfigMap::setStringParam(), and verifySnapshotData().

Referenced by BackupRestoreTest().

00151 { 00152 configMap.setStringParam( 00153 Database::paramDatabaseDir,"."); 00154 configMap.setStringParam( 00155 "databaseInitSize","1000"); 00156 configMap.setStringParam( 00157 "tempInitSize","1000"); 00158 configMap.setStringParam( 00159 "databaseShadowLogInitSize","1000"); 00160 configMap.setStringParam( 00161 "databaseTxnLogInitSize","1000"); 00162 configMap.setStringParam( 00163 "forceTxns","true"); 00164 configMap.setStringParam( 00165 "disableSnapshots","false"); 00166 00167 CacheParams cacheParams; 00168 cacheParams.readConfig(configMap); 00169 pCache = Cache::newCache(cacheParams); 00170 00171
00172
00173
00174 createSnapshotData(); 00175 pDatabase->checkpointImpl(); 00176 verifySnapshotData(5); 00177 00178
00179 std::string fullBackup = "fullBackup.dat"; 00180 FileSize dataDeviceSize; 00181 bool aborted = false; 00182 TxnId fullTxnId = 00183 pDatabase->initiateBackup( 00184 fullBackup, 00185 false, 00186 0, 00187 NULL_TXN_ID, 00188 "", 00189 dataDeviceSize, 00190 aborted); 00191 pDatabase->completeBackup(NULL_TXN_ID, fullTxnId, aborted); 00192 00193
00194 executeSnapshotTxn(10); 00195 verifySnapshotData(15); 00196 00197
00198 std::string incrBackup1 = "incrBackup1.dat"; 00199 TxnId incrTxnId1 = 00200 pDatabase->initiateBackup( 00201 incrBackup1, 00202 true, 00203 0, 00204 fullTxnId, 00205 "", 00206 dataDeviceSize, 00207 aborted); 00208 00209
00210 uint nPagesBefore = 00211 pDatabase->getDataSegment()->getAllocatedSizeInPages(); 00212 pDatabase->deallocateOldPages(incrTxnId1); 00213 uint nPagesAfter = 00214 pDatabase->getDataSegment()->getAllocatedSizeInPages(); 00215 BOOST_REQUIRE(nPagesBefore == nPagesAfter); 00216 00217 pDatabase->completeBackup(fullTxnId, incrTxnId1, aborted); 00218 00219
00220 pDatabase->deallocateOldPages(incrTxnId1); 00221 nPagesAfter = pDatabase->getDataSegment()->getAllocatedSizeInPages(); 00222 BOOST_REQUIRE(nPagesBefore > nPagesAfter); 00223 00224
00225 executeSnapshotTxn(20); 00226 verifySnapshotData(35); 00227 00228
00229 std::string incrBackup2 = "incrBackup2.dat"; 00230 TxnId incrTxnId2 = 00231 pDatabase->initiateBackup( 00232 incrBackup2, 00233 true, 00234 4096, 00235 incrTxnId1, 00236 "", 00237 dataDeviceSize, 00238 aborted); 00239 pDatabase->completeBackup(incrTxnId1, incrTxnId2, aborted); 00240 00241
00242 pDatabase->restoreFromBackup( 00243 fullBackup, 00244 1002 * pCache->getPageSize(), 00245 "", 00246 NULL_TXN_ID, 00247 fullTxnId, 00248 aborted); 00249 verifySnapshotData(5); 00250 00251
00252 pDatabase->restoreFromBackup( 00253 incrBackup1, 00254 1002 * pCache->getPageSize(), 00255 "", 00256 fullTxnId, 00257 incrTxnId1, 00258 aborted); 00259 verifySnapshotData(15); 00260 00261
00262 pDatabase->restoreFromBackup( 00263 incrBackup2, 00264 1002 * pCache->getPageSize(), 00265 "", 00266 incrTxnId1, 00267 incrTxnId2, 00268 aborted); 00269 verifySnapshotData(35); 00270 00271 pDatabase.reset(); 00272 }

| void BackupRestoreTest::testBackupCleanup | ( | | ) | | ----------------------------------------- | - | | - |

Tests that backup properly cleans up after either an error or an abort.

Definition at line 274 of file BackupRestoreTest.cpp.

References CacheTestBase::cacheParams, TestBase::configMap, createSnapshotData(), executeSnapshotTxn(), getCompressionProgram(), FileSystem::getDiskFreeSpace(), FennelExcn::getMessage(), Cache::newCache(), NULL_TXN_ID, Database::paramDatabaseDir, CacheTestBase::pCache, pDatabase, CacheParams::readConfig(), FileSystem::remove(), ConfigMap::setStringParam(), and verifySnapshotData().

Referenced by BackupRestoreTest().

00275 { 00276 configMap.setStringParam( 00277 Database::paramDatabaseDir,"."); 00278 configMap.setStringParam( 00279 "databaseInitSize","1000"); 00280 configMap.setStringParam( 00281 "tempInitSize","1000"); 00282 configMap.setStringParam( 00283 "databaseShadowLogInitSize","1000"); 00284 configMap.setStringParam( 00285 "databaseTxnLogInitSize","1000"); 00286 configMap.setStringParam( 00287 "forceTxns","true"); 00288 configMap.setStringParam( 00289 "disableSnapshots","false"); 00290 00291 CacheParams cacheParams; 00292 cacheParams.readConfig(configMap); 00293 pCache = Cache::newCache(cacheParams); 00294 00295
00296
00297
00298 createSnapshotData(); 00299 pDatabase->checkpointImpl(); 00300 verifySnapshotData(5); 00301 00302
00303 executeSnapshotTxn(10); 00304 verifySnapshotData(15); 00305 00306 std::string fullBackup = "fullBackup.dat"; 00307 00308
00309
00310
00311
00312
00313
00314
00315 FileSystem::remove(fullBackup.c_str()); 00316 FileSize spaceAvailable; 00317 FileSystem::getDiskFreeSpace(".", spaceAvailable); 00318 FileSize dataDeviceSize; 00319 bool aborted = false; 00320 try { 00321 pDatabase->initiateBackup( 00322 fullBackup, 00323 true, 00324 spaceAvailable * 1000, 00325 NULL_TXN_ID, 00326 "", 00327 dataDeviceSize, 00328 aborted); 00329 BOOST_FAIL("Out of space exception not returned"); 00330 } catch (FennelExcn &ex) { 00331 std::string errMsg = ex.getMessage(); 00332 if (errMsg.find("Insufficient space") != 0) { 00333 BOOST_FAIL("Wrong exception returned"); 00334 } 00335 } 00336 00337
00338
00339 uint nPagesBefore = 00340 pDatabase->getDataSegment()->getAllocatedSizeInPages(); 00341 pDatabase->deallocateOldPages(pDatabase->getLastCommittedTxnId()); 00342 uint nPagesAfter = 00343 pDatabase->getDataSegment()->getAllocatedSizeInPages(); 00344 BOOST_REQUIRE(nPagesBefore > nPagesAfter); 00345 00346
00347 executeSnapshotTxn(20); 00348 verifySnapshotData(35); 00349 00350
00351 pDatabase->initiateBackup( 00352 fullBackup, 00353 false, 00354 0, 00355 NULL_TXN_ID, 00356 getCompressionProgram(true), 00357 dataDeviceSize, 00358 aborted); 00359 pDatabase->abortBackup(); 00360 00361
00362
00363 nPagesBefore = 00364 pDatabase->getDataSegment()->getAllocatedSizeInPages(); 00365 pDatabase->deallocateOldPages(pDatabase->getLastCommittedTxnId()); 00366 nPagesAfter = 00367 pDatabase->getDataSegment()->getAllocatedSizeInPages(); 00368 BOOST_REQUIRE(nPagesBefore > nPagesAfter); 00369 00370
00371 pDatabase->abortBackup(); 00372 00373 pDatabase.reset(); 00374 }

| void BackupRestoreTest::testBackupRestoreUncompressed | ( | | ) | | ----------------------------------------------------- | - | | - |

| void BackupRestoreTest::testBackupRestoreCompressed | ( | | ) | | --------------------------------------------------- | - | | - |

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

Reimplemented from SegStorageTestBase.

Definition at line 47 of file SnapshotSegmentTestBase.cpp.

References DeviceMode::create, SegStorageTestBase::createLinearDeviceSegment(), SnapshotSegmentTestBase::currCsn, CacheTestBase::dataDeviceId, SnapshotSegmentTestBase::firstPageId, CacheTestBase::nDiskPages, SnapshotSegmentTestBase::nDiskPagesTotal, NULL_PAGE_ID, CacheTestBase::openDevice(), SegStorageTestBase::pLinearSegment, SegStorageTestBase::pRandomSegment, SegStorageTestBase::pSegmentFactory, SegStorageTestBase::pSnapshotRandomSegment, SnapshotSegmentTestBase::pTempDevice, SnapshotSegmentTestBase::pTempSegment, SegStorageTestBase::pVersionedRandomSegment, SnapshotSegmentTestBase::setForceCacheUnmap(), and SnapshotSegmentTestBase::tempDeviceId.

00048 { 00049 nDiskPages = nDiskPagesTotal; 00050 if (openMode.create) { 00051 firstPageId = NULL_PAGE_ID; 00052 } 00053 00054 pTempDevice = 00055 openDevice("temp.dat", openMode, nDiskPages / 50, tempDeviceId); 00056 SharedSegment pTempDeviceSegment = 00057 createLinearDeviceSegment(tempDeviceId, nDiskPages / 50); 00058 pTempSegment = 00059 pSegmentFactory->newRandomAllocationSegment( 00060 pTempDeviceSegment, 00061 openMode.create); 00062 00063 SharedSegment pDeviceSegment = 00064 createLinearDeviceSegment(dataDeviceId, nDiskPages); 00065 pVersionedRandomSegment = 00066 pSegmentFactory->newVersionedRandomAllocationSegment( 00067 pDeviceSegment, 00068 pTempSegment, 00069 openMode.create); 00070 pSnapshotRandomSegment = 00071 pSegmentFactory->newSnapshotRandomAllocationSegment( 00072 pVersionedRandomSegment, 00073 pVersionedRandomSegment, 00074 currCsn); 00075 setForceCacheUnmap(pSnapshotRandomSegment); 00076 00077 pRandomSegment = pSnapshotRandomSegment; 00078 00079 nDiskPages /= 2; 00080 SharedSegment pLinearViewSegment = 00081 pSegmentFactory->newLinearViewSegment( 00082 pSnapshotRandomSegment, 00083 firstPageId); 00084 pLinearSegment = pLinearViewSegment; 00085 }

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

Reimplemented from SegStorageTestBase.

Definition at line 99 of file SnapshotSegmentTestBase.cpp.

References CacheTestBase::closeDevice(), SegStorageTestBase::closeLinearSegment(), SegStorageTestBase::closeSnapshotRandomSegment(), SegStorageTestBase::closeStorage(), SegStorageTestBase::closeVersionedRandomSegment(), SnapshotSegmentTestBase::commitChanges(), SnapshotSegmentTestBase::currCsn, VersionedRandomAllocationSegment::freeTempPages(), SegStorageTestBase::pRandomSegment, SnapshotSegmentTestBase::pSnapshotRandomSegment2, SnapshotSegmentTestBase::pTempDevice, SnapshotSegmentTestBase::pTempSegment, SegStorageTestBase::pVersionedRandomSegment, and SnapshotSegmentTestBase::tempDeviceId.

Referenced by backup(), SnapshotSegmentTest::deallocateOldPages(), restore(), testBackupRestore(), SnapshotSegmentTest::testDeallocateOld(), SnapshotSegmentTest::testRollback(), SnapshotSegmentTest::testSnapshotReads(), SnapshotSegmentTest::testUncommittedReads(), and verifyData().

| void SnapshotSegmentTestBase::testAllocateAll | ( | | ) | [virtual, inherited] | | --------------------------------------------- | - | | - | ---------------------- |

Reimplemented from SegStorageTestBase.

Definition at line 37 of file SegmentTestBase.cpp.

References PagingTestBase::cbPageUsable, PagingTestBase::OP_ALLOCATE, PagingTestBase::OP_DEALLOCATE, SegStorageTestBase::openStorage(), SegStorageTestBase::pLinearSegment, SegStorageTestBase::pRandomSegment, and ThreadedTestBase::threadCounts.

Referenced by backup(), SnapshotSegmentTest::deallocateOldPages(), restore(), RandomAllocationSegmentTest::testAllocateAndDeallocate(), testBackupRestore(), SnapshotSegmentTest::testDeallocateOld(), VersionedSegmentTest::testRecovery(), SnapshotSegmentTest::testRollback(), SegmentTestBase::testSingleThread(), SnapshotSegmentTest::testSnapshotReads(), SnapshotSegmentTest::testUncommittedReads(), and verifyData().

Implements PagingTestBase.

Definition at line 47 of file SegmentTestBase.cpp.

References SegPageLock::allocatePage(), SegPageLock::dontUnlock(), PagingTestBase::fillPage(), Segment::getLinearBlockNum(), Segment::getLinearPageId(), PagingTestBase::getLockMode(), SegPageLock::getPage(), SegPageLock::isLocked(), SegPageLock::lockPage(), SegmentTestBase::objId, PagingTestBase::OP_ALLOCATE, PagingTestBase::OP_WRITE_RAND, PagingTestBase::OP_WRITE_SEQ, PagingTestBase::OP_WRITE_SKIP, CacheTestBase::pCache, and SegStorageTestBase::pLinearSegment.

| void SegmentTestBase::testAllocate | ( | | ) | [virtual, inherited] | | ---------------------------------- | - | | - | ---------------------- |

| void SegmentTestBase::testDeallocate | ( | | ) | [virtual, inherited] | | ------------------------------------ | - | | - | ---------------------- |

| void SegmentTestBase::testCheckpoint | ( | | ) | [virtual, inherited] | | ------------------------------------ | - | | - | ---------------------- |

| void SegmentTestBase::testSingleThread | ( | | ) | [inherited] | | -------------------------------------- | - | | - | ------------- |

Definition at line 161 of file SegmentTestBase.cpp.

References SegStorageTestBase::closeStorage(), DeviceMode::createNew, SegmentTestBase::freeablePages, DeviceMode::load, SegmentTestBase::openStorage(), PagingTestBase::testAllocateAll(), PagingTestBase::testRandomRead(), PagingTestBase::testRandomWrite(), PagingTestBase::testSequentialRead(), and PagingTestBase::testSequentialWrite().

Referenced by LinearDeviceSegmentTest::LinearDeviceSegmentTest(), LinearViewSegmentTest::LinearViewSegmentTest(), SnapshotSegmentTest::SnapshotSegmentTest(), and VersionedSegmentTest::VersionedSegmentTest().

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

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

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

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

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

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

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

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

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

Default is no-op.

Reimplemented from TestBase.

Reimplemented in LbmEntryTest, LbmLoadBitmapTest, LbmSearchTest, LcsClusterAppendExecStreamTest, LcsClusterReplaceExecStreamTest, LcsMultiClusterAppendTest, LcsRowScanExecStreamTest, BTreeReadersTest, BTreeTest, ExecStreamTestBase, and LhxHashTableTest.

Definition at line 125 of file CacheTestBase.cpp.

References CacheTestBase::closeStorage().

Referenced by LhxHashTableTest::testCaseTearDown(), ExecStreamTestBase::testCaseTearDown(), BTreeTest::testCaseTearDown(), BTreeReadersTest::testCaseTearDown(), and LbmEntryTest::testCaseTearDown().

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] | | ---------------------------------------------------------------------------------------------- | - | | - | ------------- |

Carries out one operation on a page.

This involves locking the page, calling verifyPage or fillPage, and then unlocking the page.

Parameters:

Returns:

true if the operation was successfully carried out; false if NoWait locking was requested and the page lock could not be acquired

Definition at line 85 of file PagingTestBase.cpp.

References PagingTestBase::fillPage(), CacheTestBase::getCache(), PagingTestBase::getLockMode(), LOCKMODE_S, LOCKMODE_S_NOWAIT, LOCKMODE_X, LOCKMODE_X_NOWAIT, PagingTestBase::lockPage(), CacheAccessor::nicePage(), PagingTestBase::unlockPage(), and PagingTestBase::verifyPage().

Referenced by PagingTestBase::testRandomOp(), PagingTestBase::testSequentialOp(), and PagingTestBase::testSkipOp().

Gets the LockMode corresponding to an OpType.

Definition at line 143 of file PagingTestBase.cpp.

References LOCKMODE_S, LOCKMODE_S_NOWAIT, LOCKMODE_X, LOCKMODE_X_NOWAIT, PagingTestBase::OP_ALLOCATE, PagingTestBase::OP_READ_NOWAIT, PagingTestBase::OP_READ_RAND, PagingTestBase::OP_READ_SEQ, PagingTestBase::OP_WRITE_NOWAIT, PagingTestBase::OP_WRITE_RAND, PagingTestBase::OP_WRITE_SEQ, and PagingTestBase::OP_WRITE_SKIP.

Referenced by SegmentTestBase::lockPage(), CacheTest::lockPage(), and PagingTestBase::testOp().

| void PagingTestBase::testScratch | ( | | ) | [inherited] | | -------------------------------- | - | | - | ------------- |

| void PagingTestBase::testPrefetch | ( | | ) | [inherited] | | --------------------------------- | - | | - | ------------- |

| void PagingTestBase::testPrefetchBatch | ( | | ) | [inherited] | | -------------------------------------- | - | | - | ------------- |

| void PagingTestBase::testSequentialRead | ( | | ) | [inherited] | | --------------------------------------- | - | | - | ------------- |

| void PagingTestBase::testSequentialWrite | ( | | ) | [inherited] | | ---------------------------------------- | - | | - | ------------- |

| void PagingTestBase::testRandomRead | ( | | ) | [inherited] | | ----------------------------------- | - | | - | ------------- |

| void PagingTestBase::testRandomWrite | ( | | ) | [inherited] | | ------------------------------------ | - | | - | ------------- |

| void PagingTestBase::testCheckpointGuarded | ( | | ) | [inherited] | | ------------------------------------------ | - | | - | ------------- |

| void PagingTestBase::testCacheResize | ( | | ) | [inherited] | | ------------------------------------ | - | | - | ------------- |

| void PagingTestBase::testMultipleThreads | ( | | ) | [inherited] | | ---------------------------------------- | - | | - | ------------- |

| void PagingTestBase::threadInit | ( | | ) | [virtual, inherited] | | ------------------------------- | - | | - | ---------------------- |

| void PagingTestBase::threadTerminate | ( | | ) | [virtual, inherited] | | ------------------------------------ | - | | - | ---------------------- |

Test implementation must be supplied by derived test class.

Parameters:

Returns:

true if test should run again

Implements ThreadedTestBase.

Definition at line 378 of file PagingTestBase.cpp.

References PagingTestBase::checkpointMutex, SXMutexGuard< lockMode >::lock(), PagingTestBase::OP_ALLOCATE, PagingTestBase::OP_CHECKPOINT, PagingTestBase::OP_DEALLOCATE, PagingTestBase::OP_MAX, PagingTestBase::OP_PREFETCH, PagingTestBase::OP_PREFETCH_BATCH, PagingTestBase::OP_READ_NOWAIT, PagingTestBase::OP_READ_RAND, PagingTestBase::OP_READ_SEQ, PagingTestBase::OP_RESIZE_CACHE, PagingTestBase::OP_SCRATCH, PagingTestBase::OP_WRITE_NOWAIT, PagingTestBase::OP_WRITE_RAND, PagingTestBase::OP_WRITE_SEQ, PagingTestBase::OP_WRITE_SKIP, PagingTestBase::testAllocate(), PagingTestBase::testCacheResize(), PagingTestBase::testCheckpointGuarded(), PagingTestBase::testDeallocate(), PagingTestBase::testPrefetch(), PagingTestBase::testPrefetchBatch(), PagingTestBase::testRandomOp(), PagingTestBase::testScratch(), PagingTestBase::testSequentialOp(), and PagingTestBase::testSkipOp().

| void ThreadedTestBase::runThreadedTestCase | ( | | ) | [protected, inherited] | | ------------------------------------------ | - | | - | ------------------------ |

Member Data Documentation

Definition at line 44 of file SnapshotSegmentTestBase.h.

Referenced by SnapshotSegmentTestBase::closeStorage(), SnapshotSegmentTest::deallocateOldPages(), SnapshotSegmentTestBase::fillPage(), SnapshotSegmentTestBase::openSegmentStorage(), testBackupRestore(), SnapshotSegmentTestBase::testCaseSetUp(), LcsClusterReplaceExecStreamTest::testClusterReplace(), SnapshotSegmentTest::testDeallocateOld(), SnapshotSegmentTest::testRollback(), SnapshotSegmentTest::testSnapshotReads(), SnapshotSegmentTest::testUncommittedReads(), and SnapshotSegmentTestBase::verifyPage().

Definition at line 40 of file SegStorageTestBase.h.

Referenced by 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(), restore(), SegStorageTestBase::SegStorageTestBase(), LbmSplicerExecStreamTest::spliceInput(), ExecStreamTestSuite::testBTreeInsertExecStream(), LhxHashTableTest::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().

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

Cache instance being tested.

Definition at line 63 of file CacheTestBase.h.

Referenced by backup(), CacheTestBase::closeDevice(), CacheTestBase::closeStorage(), LbmSplicerExecStreamTest::createBTree(), SegStorageTestBase::createLinearDeviceSegment(), LogicalTxnTest::createRecoveryLog(), createSnapshotData(), 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(), restore(), LbmSplicerExecStreamTest::spliceInput(), SegmentTestBase::testAllocate(), RandomAllocationSegmentTest::testAllocateAndDeallocate(), testBackupCleanup(), ExecStreamTestSuite::testBTreeInsertExecStream(), BTreeTest::testBulkLoad(), LhxHashTableTest::testCaseSetUp(), ExecStreamUnitTestBase::testCaseSetUp(), BTreeTest::testCaseSetUp(), BTreeReadersTest::testCaseSetUp(), LhxAggExecStreamTest::testCountImpl(), SegmentTestBase::testDeallocate(), SnapshotSegmentTest::testDeallocateOld(), ExecStreamTestSuite::testDoubleBufferExecStream(), ExecStreamGovernorTest::testGovernor(), LhxAggExecStreamTest::testGroupCountImpl(), 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 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(), createSnapshotData(), DatabaseTest::DatabaseTest(), TestOptionsTest::extra(), DatabaseTest::loadDatabase(), SparseBitmapTest::openStorage(), PagingTestBase::PagingTestBase(), ParallelExecStreamSchedulerTest::ParallelExecStreamSchedulerTest(), RandomAccessFileDeviceTest::RandomAccessFileDeviceTest(), TestBase::readParams(), SegStorageTestBase::SegStorageTestBase(), TestOptionsTest::test1(), TestOptionsTest::test2(), testBackupCleanup(), TestBase::TestBase(), BTreeTxnTest::testCaseSetUp(), BTreeTxnTest::testCheckpoint(), DatabaseTest::testCreateEmpty(), DatabaseTest::testForceTxns(), 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/BackupRestoreTest.cpp

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