Fennel: TupleTest Class Reference (original) (raw)

• Main Page

• Namespaces

• Classes

• Files

• Directories

• Related Pages

• Alphabetical List

• Class List

• Class Hierarchy

• Class Members

Inheritance diagram for TupleTest:

List of all members.

Detailed Description

Definition at line 41 of file TupleTest.cpp.

Constructor & Destructor Documentation

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

| virtual TupleTest::~TupleTest | ( | | ) | [inline, virtual] | | ------------------------------ | - | | - | ------------------- |

Member Function Documentation

Definition at line 273 of file TupleTest.cpp.

References TupleDatum::cbData, min(), TupleDatum::pData, STANDARD_TYPE_BINARY, STANDARD_TYPE_BOOL, STANDARD_TYPE_CHAR, STANDARD_TYPE_DOUBLE, STANDARD_TYPE_INT_16, STANDARD_TYPE_INT_32, STANDARD_TYPE_INT_64, STANDARD_TYPE_INT_8, STANDARD_TYPE_REAL, STANDARD_TYPE_UINT_16, STANDARD_TYPE_UINT_32, STANDARD_TYPE_UINT_64, STANDARD_TYPE_UINT_8, STANDARD_TYPE_UNICODE_CHAR, STANDARD_TYPE_UNICODE_VARCHAR, STANDARD_TYPE_VARBINARY, and STANDARD_TYPE_VARCHAR.

Referenced by testStandardTypes().

Definition at line 346 of file TupleTest.cpp.

References TupleDatum::cbData, max(), MAX_WIDTH, TupleDatum::pData, STANDARD_TYPE_BINARY, STANDARD_TYPE_BOOL, STANDARD_TYPE_CHAR, STANDARD_TYPE_DOUBLE, STANDARD_TYPE_INT_16, STANDARD_TYPE_INT_32, STANDARD_TYPE_INT_64, STANDARD_TYPE_INT_8, STANDARD_TYPE_REAL, STANDARD_TYPE_UINT_16, STANDARD_TYPE_UINT_32, STANDARD_TYPE_UINT_64, STANDARD_TYPE_UINT_8, STANDARD_TYPE_UNICODE_CHAR, STANDARD_TYPE_UNICODE_VARCHAR, STANDARD_TYPE_VARBINARY, and STANDARD_TYPE_VARCHAR.

Referenced by testStandardTypes().

Definition at line 414 of file TupleTest.cpp.

References TupleDatum::cbData, MAX_WIDTH, TupleDatum::pData, STANDARD_TYPE_BINARY, STANDARD_TYPE_BOOL, STANDARD_TYPE_CHAR, STANDARD_TYPE_DOUBLE, STANDARD_TYPE_INT_16, STANDARD_TYPE_INT_32, STANDARD_TYPE_INT_64, STANDARD_TYPE_INT_8, STANDARD_TYPE_REAL, STANDARD_TYPE_UINT_16, STANDARD_TYPE_UINT_32, STANDARD_TYPE_UINT_64, STANDARD_TYPE_UINT_8, STANDARD_TYPE_UNICODE_CHAR, STANDARD_TYPE_UNICODE_VARCHAR, STANDARD_TYPE_VARBINARY, and STANDARD_TYPE_VARCHAR.

Referenced by testStandardTypes().

Definition at line 199 of file TupleTest.cpp.

References checkData(), FixedBuffer, TupleAccessor::getAttributeAccessor(), TupleAccessor::getByteCount(), TupleAccessor::getCurrentByteCount(), TupleAccessor::getMaxByteCount(), TupleAccessor::marshal(), TRACE_FINE, traceTuple(), tupleAccessor, tupleDesc, TupleAccessor::unmarshal(), and AttributeAccessor::unmarshalValue().

Referenced by testStandardTypes().

00200 { 00201 FENNEL_TRACE(TRACE_FINE,"reference tuple:"); 00202 traceTuple(tupleDataFixed); 00203 boost::scoped_array pTupleBufVar( 00204 new FixedBuffer[tupleAccessor.getMaxByteCount()]); 00205 00206 uint cbTuple = tupleAccessor.getByteCount(tupleDataFixed); 00207 tupleAccessor.marshal(tupleDataFixed,pTupleBufVar.get()); 00208 BOOST_CHECK_EQUAL(cbTuple,tupleAccessor.getCurrentByteCount()); 00209 00210 TupleData tupleDataTogether(tupleDesc); 00211 tupleAccessor.unmarshal(tupleDataTogether); 00212 FENNEL_TRACE(TRACE_FINE,"unmarshalled tuple (together):"); 00213 traceTuple(tupleDataTogether); 00214 BOOST_CHECK_EQUAL(cbTuple,tupleAccessor.getByteCount(tupleDataTogether)); 00215 checkData(tupleDataFixed,tupleDataTogether); 00216 00217 TupleData tupleDataIndividual(tupleDesc); 00218 for (uint i = 0; i < tupleDataIndividual.size(); ++i) { 00219 tupleAccessor.getAttributeAccessor(i).unmarshalValue( 00220 tupleAccessor,tupleDataIndividual[i]); 00221 } 00222 FENNEL_TRACE(TRACE_FINE,"unmarshalled tuple (individual):"); 00223 traceTuple(tupleDataIndividual); 00224 BOOST_CHECK_EQUAL(cbTuple,tupleAccessor.getByteCount(tupleDataIndividual)); 00225 checkData(tupleDataFixed,tupleDataIndividual); 00226 00227 return tupleAccessor.getCurrentByteCount(); 00228 }

Definition at line 230 of file TupleTest.cpp.

References TupleDatum::cbData, checkAlignment(), TupleDatum::pData, and tupleDesc.

Referenced by testMarshal().

00232 { 00233 for (uint i = 0; i < tupleData1.size(); ++i) { 00234 TupleDatum const &datum1 = tupleData1[i]; 00235 TupleDatum const &datum2 = tupleData2[i]; 00236 if (!datum1.pData || !datum2.pData) { 00237 BOOST_CHECK_EQUAL( 00238 static_cast<void const *>(datum1.pData), 00239 static_cast<void const *>(datum2.pData)); 00240 continue; 00241 } 00242 checkAlignment(tupleDesc[i], datum1.pData); 00243 checkAlignment(tupleDesc[i], datum2.pData); 00244 BOOST_CHECK_EQUAL(datum1.cbData,datum2.cbData); 00245 BOOST_CHECK_EQUAL_COLLECTIONS( 00246 datum1.pData, 00247 datum1.pData + datum1.cbData, 00248 datum2.pData, 00249 datum2.pData + datum2.cbData); 00250 } 00251 }

| void TupleTest::testStandardTypesNullable | ( | | ) | [private] | | ----------------------------------------- | - | | - | ----------- |

| void TupleTest::testStandardTypesNotNull | ( | | ) | [private] | | ---------------------------------------- | - | | - | ----------- |

| void TupleTest::testStandardTypesNetworkNullable | ( | | ) | [private] | | ------------------------------------------------ | - | | - | ----------- |

| void TupleTest::testStandardTypesNetworkNotNull | ( | | ) | [private] | | ----------------------------------------------- | - | | - | ----------- |

Definition at line 119 of file TupleTest.cpp.

References TupleAccessor::compute(), FixedBuffer, TupleAccessor::getMaxByteCount(), TupleAccessor::getMinByteCount(), MAX_WIDTH, StandardTypeDescriptorFactory::newDataType(), STANDARD_TYPE_END, STANDARD_TYPE_MIN, testMarshal(), TRACE_FINE, TUPLE_FORMAT_ALL_FIXED, tupleAccessor, tupleDesc, writeMaxData(), writeMinData(), and writeSampleData().

Referenced by testStandardTypesNetworkNotNull(), testStandardTypesNetworkNullable(), testStandardTypesNotNull(), and testStandardTypesNullable().

00121 { 00122 StandardTypeDescriptorFactory typeFactory; 00123 uint cbMin = 0; 00124 tupleDesc.clear(); 00125 for (uint i = STANDARD_TYPE_MIN; i < STANDARD_TYPE_END; ++i) { 00126 StoredTypeDescriptor const &typeDesc = typeFactory.newDataType(i); 00127 uint cbFixed = typeDesc.getFixedByteCount(); 00128 if (cbFixed) { 00129 cbMin += cbFixed; 00130 } else { 00131 cbMin += typeDesc.getMinByteCount(MAX_WIDTH); 00132 } 00133 tupleDesc.push_back( 00134 TupleAttributeDescriptor( 00135 typeDesc, 00136 nullable, 00137 cbFixed ? 0 : MAX_WIDTH)); 00138 } 00139 00140 tupleAccessor.compute(tupleDesc,format); 00141 BOOST_CHECK(tupleAccessor.getMinByteCount() >= cbMin); 00142 BOOST_CHECK(tupleAccessor.getMaxByteCount() > cbMin); 00143 00144 TupleAccessor tupleAccessorFixed; 00145 tupleAccessorFixed.compute( 00146 tupleDesc, 00147 TUPLE_FORMAT_ALL_FIXED); 00148 00149 boost::scoped_array pTupleBufFixed( 00150 new FixedBuffer[tupleAccessor.getMaxByteCount()]); 00151 tupleAccessorFixed.setCurrentTupleBuf(pTupleBufFixed.get(), false); 00152 00153 TupleData tupleDataFixed(tupleDesc); 00154 tupleAccessorFixed.unmarshal(tupleDataFixed); 00155 00156 TupleData::iterator pDatum = tupleDataFixed.begin(); 00157 for (uint i = STANDARD_TYPE_MIN; i < STANDARD_TYPE_END; ++i) { 00158 writeMinData(*pDatum,i); 00159 ++pDatum; 00160 } 00161 FENNEL_TRACE(TRACE_FINE,"testMarshal(MinData)"); 00162 uint cbMinData = testMarshal(tupleDataFixed); 00163 BOOST_CHECK(cbMinData >= tupleAccessor.getMinByteCount()); 00164 BOOST_CHECK(cbMinData < tupleAccessor.getMaxByteCount()); 00165 00166 pDatum = tupleDataFixed.begin(); 00167 for (uint i = STANDARD_TYPE_MIN; i < STANDARD_TYPE_END; ++i) { 00168 writeMaxData(*pDatum,i); 00169 ++pDatum; 00170 } 00171 FENNEL_TRACE(TRACE_FINE,"testMarshal(MaxData)"); 00172 uint cbMaxData = testMarshal(tupleDataFixed); 00173 BOOST_CHECK(cbMaxData > cbMinData); 00174 BOOST_CHECK(cbMaxData <= tupleAccessor.getMaxByteCount()); 00175 00176 pDatum = tupleDataFixed.begin(); 00177 for (uint i = STANDARD_TYPE_MIN; i < STANDARD_TYPE_END; ++i) { 00178 writeSampleData(*pDatum,i); 00179 ++pDatum; 00180 } 00181 FENNEL_TRACE(TRACE_FINE,"testMarshal(SampleData)"); 00182 uint cbSampleData = testMarshal(tupleDataFixed); 00183 BOOST_CHECK(cbSampleData >= tupleAccessor.getMinByteCount()); 00184 BOOST_CHECK(cbSampleData <= tupleAccessor.getMaxByteCount()); 00185 00186 if (nullable) { 00187 pDatum = tupleDataFixed.begin(); 00188 for (uint i = STANDARD_TYPE_MIN; i < STANDARD_TYPE_END; ++i) { 00189 pDatum->pData = NULL; 00190 ++pDatum; 00191 } 00192 FENNEL_TRACE(TRACE_FINE,"testMarshal(NullData)"); 00193 uint cbNullData = testMarshal(tupleDataFixed); 00194 BOOST_CHECK(cbNullData >= tupleAccessor.getMinByteCount()); 00195 BOOST_CHECK(cbNullData < tupleAccessor.getMaxByteCount()); 00196 } 00197 }

| void TupleTest::testZeroByteTuple | ( | | ) | [private] | | --------------------------------- | - | | - | ----------- |

| void TupleTest::testDebugAccess | ( | | ) | [private] | | ------------------------------- | - | | - | ----------- |

| void TupleTest::testLoadStoreUnaligned | ( | | ) | [private] | | -------------------------------------- | - | | - | ----------- |

Definition at line 525 of file TupleTest.cpp.

References TupleDatum::cbData, FixedBuffer, loadAndStore8ByteInt(), loadStore2ByteLenData(), loadStore8ByteInts(), loadStoreNullData(), StandardTypeDescriptorFactory::newDataType(), TupleDatum::pData, STANDARD_TYPE_INT_16, STANDARD_TYPE_INT_32, STANDARD_TYPE_INT_64, and STANDARD_TYPE_VARBINARY.

Referenced by TupleTest().

00526 { 00527
00528 loadStore8ByteInts(0, 0xff); 00529 loadStore8ByteInts(0x80, 0); 00530 00531
00532 loadAndStore8ByteInt(0); 00533 00534
00535 loadStore2ByteLenData(128); 00536 loadStore2ByteLenData(129); 00537 loadStore2ByteLenData(255); 00538 loadStore2ByteLenData(256); 00539 loadStore2ByteLenData(257); 00540 loadStore2ByteLenData(510); 00541 loadStore2ByteLenData(511); 00542 loadStore2ByteLenData(512); 00543 00544
00545 loadStore2ByteLenData(0); 00546 00547
00548 loadStoreNullData(STANDARD_TYPE_INT_64, 8); 00549 loadStoreNullData(STANDARD_TYPE_INT_32, 4); 00550 00551
00552 TupleDatum tupleDatum; 00553 tupleDatum.cbData = 2; 00554 int16_t intVal = 43981; 00555 tupleDatum.pData = (PConstBuffer) &intVal; 00556 FixedBuffer storageBuf[4]; 00557 StandardTypeDescriptorFactory stdTypeFactory; 00558 TupleAttributeDescriptor attrDesc_int16( 00559 stdTypeFactory.newDataType(STANDARD_TYPE_INT_16)); 00560 UnalignedAttributeAccessor accessor_int16(attrDesc_int16); 00561 accessor_int16.storeValue(tupleDatum, storageBuf); 00562 uint len = accessor_int16.getStoredByteCount(storageBuf); 00563 BOOST_REQUIRE(len == 2); 00564 00565 FixedBuffer loadBuf[4]; 00566 tupleDatum.cbData = 0xff; 00567 tupleDatum.pData = loadBuf; 00568 accessor_int16.loadValue(tupleDatum, storageBuf); 00569 00570 BOOST_REQUIRE(tupleDatum.cbData == 2); 00571 bool rc = (intVal == *reinterpret_cast<int16_t const *> (tupleDatum.pData)); 00572 BOOST_REQUIRE(rc); 00573 00574
00575 tupleDatum.cbData = 3; 00576 FixedBuffer data[3]; 00577 data[0] = 0xba; 00578 data[0] = 0xdc; 00579 data[0] = 0xfe; 00580 tupleDatum.pData = data; 00581 TupleAttributeDescriptor attrDesc_varBinary( 00582 stdTypeFactory.newDataType(STANDARD_TYPE_VARBINARY), 00583 true, 00584 4); 00585 UnalignedAttributeAccessor accessor_varBinary(attrDesc_varBinary); 00586 accessor_varBinary.storeValue(tupleDatum, storageBuf); 00587 len = accessor_varBinary.getStoredByteCount(storageBuf); 00588 BOOST_REQUIRE(len == 4); 00589 00590 tupleDatum.cbData = 0xff; 00591 tupleDatum.pData = loadBuf; 00592 accessor_varBinary.loadValue(tupleDatum, storageBuf); 00593 00594 BOOST_REQUIRE(tupleDatum.cbData == 3); 00595 BOOST_REQUIRE(memcmp(tupleDatum.pData, data, 3) == 0); 00596 }

Definition at line 654 of file TupleTest.cpp.

References TupleDatum::cbData, FixedBuffer, StandardTypeDescriptorFactory::newDataType(), TupleDatum::pData, and STANDARD_TYPE_BINARY.

Referenced by testLoadStoreUnaligned().

00655 { 00656
00657 TupleDatum tupleDatum; 00658 tupleDatum.cbData = dataLen; 00659 boost::scoped_array dataBuf(new FixedBuffer[dataLen + 2]); 00660 for (int i = 0; i < dataLen; i++) { 00661 dataBuf[i] = i; 00662 } 00663 tupleDatum.pData = dataBuf.get(); 00664 00665
00666 boost::scoped_array storageBuf(new FixedBuffer[dataLen + 2]); 00667 StandardTypeDescriptorFactory stdTypeFactory; 00668 TupleAttributeDescriptor attrDesc( 00669 stdTypeFactory.newDataType(STANDARD_TYPE_BINARY), true, dataLen); 00670 UnalignedAttributeAccessor accessor(attrDesc); 00671 accessor.storeValue(tupleDatum, storageBuf.get()); 00672 uint len = accessor.getStoredByteCount(storageBuf.get()); 00673 BOOST_REQUIRE(len == dataLen + 2); 00674 00675
00676 boost::scoped_array loadBuf(new FixedBuffer[dataLen + 2]); 00677 tupleDatum.cbData = 0; 00678 tupleDatum.pData = loadBuf.get(); 00679 accessor.loadValue(tupleDatum, storageBuf.get()); 00680 BOOST_REQUIRE(tupleDatum.cbData == dataLen); 00681 BOOST_REQUIRE(memcmp(tupleDatum.pData, dataBuf.get(), dataLen) == 0); 00682 }

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

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

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

Default is no-op.

Reimplemented in LbmEntryTest, LbmExecStreamTestBase, LbmLoadBitmapTest, LbmSearchTest, LbmSplicerExecStreamTest, LcsClusterAppendExecStreamTest, LcsClusterReplaceExecStreamTest, LcsMultiClusterAppendTest, LcsRowScanExecStreamTest, BTreeReadersTest, BTreeTest, BTreeTxnTest, ExecStreamGovernorTest, ExecStreamTestBase, ExecStreamUnitTestBase, ExternalSortExecStreamTest, LhxHashTableTest, LogicalTxnTest, and SnapshotSegmentTestBase.

Definition at line 235 of file TestBase.cpp.

Referenced by ExecStreamTestBase::testCaseSetUp().

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

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

Default is no-op.

Reimplemented in LbmEntryTest, LbmLoadBitmapTest, LbmSearchTest, LcsClusterAppendExecStreamTest, LcsClusterReplaceExecStreamTest, LcsMultiClusterAppendTest, LcsRowScanExecStreamTest, BTreeReadersTest, BTreeTest, BTreeTxnTest, CacheTestBase, DatabaseTest, ExecStreamTestBase, LhxHashTableTest, RandomAccessFileDeviceTest, and SparseBitmapTest.

Definition at line 239 of file TestBase.cpp.

Referenced by SparseBitmapTest::testCaseTearDown().

| bool TraceSource::isTracing | ( | | ) | const [inline, inherited] | | --------------------------- | - | | - | --------------------------- |

| TraceTarget& TraceSource::getTraceTarget | ( | | ) | const [inline, inherited] | | ----------------------------------------------------------------- | - | | - | --------------------------- |

| std::string TraceSource::getTraceSourceName | ( | | ) | const [inline, inherited] | | ------------------------------------------- | - | | - | --------------------------- |

Sets the name of this source.

Useful to construct dynamic names for fine-grained filtering.

Definition at line 136 of file TraceSource.h.

00137 { 00138 name = n; 00139 }

| TraceLevel TraceSource::getMinimumTraceLevel | ( | | ) | const [inline, inherited] | | ------------------------------------------------------------------------------------------------------ | - | | - | --------------------------- |

| void TraceSource::disableTracing | ( | | ) | [inherited] | | -------------------------------- | - | | - | ------------- |

Member Data Documentation

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/TupleTest.cpp

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