database/mariadb-columnstore-engine
1
0
Fork 0
mirror of https://github.com/mariadb-corporation/mariadb-columnstore-engine.git synced 2025-10-30 07:25:34 +03:00
Code Activity
Files
ae8d8c68b73e562a838f31faa1c9ee9055c6bd6a
mariadb-columnstore-engine/writeengine/index/tindex.cpp
Leonid Fedorov 04752ec546 clang format apply
2022-01-21 16:43:49 +00:00

4219 lines
147 KiB
C++
Raw Blame History

/* Copyright (C) 2014 InfiniDB, Inc.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; version 2 of
the License.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
MA 02110-1301, USA. */
#include <stdio.h>
#include <string>
#include <stdexcept>
#include <stdlib.h>
#include <bitset>
#include <map>
using namespace std;
#include <boost/scoped_ptr.hpp>
#include <boost/progress.hpp>
using namespace boost;
#include <cppunit/extensions/HelperMacros.h>
#include "we_indextree.h"
#include "we_freemgr.h"
#include "we_indexlist.h"
using namespace WriteEngine;
class IndexTest : public CppUnit::TestFixture
{
CPPUNIT_TEST_SUITE(IndexTest);
// CPPUNIT_TEST( tmpTest );
// PUNIT_TEST( multimapdemo );
// PUNIT_TEST( sortvecdemo );
// PUNIT_TEST( sortarrdemo );
// CPPUNIT_TEST( spacehog );
// CPPUNIT_TEST( test1 );
// CPPUNIT_TEST( test2 );
// Index basic testing
CPPUNIT_TEST(testStructIO);
CPPUNIT_TEST(testAddTreeNode);
CPPUNIT_TEST(testSetupBittestArray);
// Index tree testing
CPPUNIT_TEST(testTreeGetTestbitValue);
CPPUNIT_TEST(testTreeGetTreeNodeInfo);
CPPUNIT_TEST(testTreeGetTreeMatchEntry);
CPPUNIT_TEST(testTreeMoveEntry);
CPPUNIT_TEST(testTreeBuildEmptyTree);
CPPUNIT_TEST(testTreeBuildExistTree1);
CPPUNIT_TEST(testTreeBuildExistTree2);
CPPUNIT_TEST(testTreeIntegration);
//
CPPUNIT_TEST(testIntegrationVolume);
CPPUNIT_TEST(testCreateAndUpdateIndex);
//
CPPUNIT_TEST(testDeleteIndex);
//
CPPUNIT_TEST(testResetIndex);
//
CPPUNIT_TEST(testUpdateMutiColIndex);
// Index free manager testing
CPPUNIT_TEST(testFreeMgrBRM);
CPPUNIT_TEST(testFreeMgrInit);
CPPUNIT_TEST(testFreeMgrInit2);
CPPUNIT_TEST(testFreeMgrAssign);
CPPUNIT_TEST(testFreeMgrAssignList);
CPPUNIT_TEST(testFreeMgrAssignListCk);
CPPUNIT_TEST(testFreeMgrAssignListCk2);
CPPUNIT_TEST(testFreeMgrAssignListLots);
CPPUNIT_TEST(testFreeMgrAssignListBlocks);
CPPUNIT_TEST(testFreeMgrAssignExtend);
CPPUNIT_TEST(testFreeMgrExtendLots);
CPPUNIT_TEST(testFreeMgrRelease);
CPPUNIT_TEST(testFreeMgrFragment);
CPPUNIT_TEST(testFreeMgrChain);
// Index list testing
CPPUNIT_TEST(testIndexListMultiKey);
CPPUNIT_TEST(testIndexListUpdate);
CPPUNIT_TEST(testIndexListDelete);
CPPUNIT_TEST(testIndexListReleaseMgrBack);
CPPUNIT_TEST(testIndexListMultipleAddHdr);
CPPUNIT_TEST(testIndexListMultipleUpdate);
CPPUNIT_TEST_SUITE_END();
private:
IndexTree m_index;
IndexList m_indexlist;
FreeMgr m_freeMgr;
public:
void setUp()
{
m_index.setUseFreeMgr(false);
m_index.setUseListMgr(false);
m_index.setTransId(124353); // a dummy transaction id
// init the 000.dir
// int rc = m_index.createIndex( 20, 21 );
// CPPUNIT_ASSERT( rc == NO_ERROR );
BRMWrapper::setUseBrm(true);
m_indexlist.setDebugLevel(DEBUG_0);
m_indexlist.setNarray(true);
}
void testInit()
{
}
void tearDown()
{
}
/*
void tmpTest() {
int rc, width = 32, i;
m_index.setUseFreeMgr( true );
m_index.setUseListMgr( true );
BRMWrapper::setUseBrm( true );
BRMWrapper::setUseVb( false );
Cache::setUseCache( true );
Cache::init();
m_index.setTransId( 12345678 );
m_index.dropIndex( 990, 991 );
rc = m_index.createIndex( 990, 991 );
CPPUNIT_ASSERT( rc == NO_ERROR );
rc = m_index.openIndex( 990, 991 );
CPPUNIT_ASSERT( rc == NO_ERROR );
// m_index.m_freeMgr.setDebugLevel( DEBUG_1 );
FILE* pFile;
uint64_t key, curkey, lastkey;
RID rid, ridArray[5000];
int counter = 0, ridCounter = 0;
pFile = fopen( "test.txt", "r" );
CPPUNIT_ASSERT( pFile != NULL );
while( !feof( pFile ) && rc == NO_ERROR )
{
fscanf( pFile, "%lld %lld\n", &key, &rid );
curkey = key;
if( curkey == lastkey || counter == 0 || ridCounter == MAX_IDX_RID - 1 )
ridArray[ridCounter++] = rid;
else {
m_index.m_multiRid.setMultiRid( ridArray, ridCounter );
rc = m_index.updateIndex( lastkey, width, ridArray[0] );
ridCounter = 0;
ridArray[ridCounter++] = rid;
} // end of if( curkey == lastkey ) {
lastkey = curkey;
// printf( "%d %d\n", (int)key, (int)rid );
counter++;
if( counter%1000 == 0 )
printf( "\ncounter=%d", counter );
} // end of while
// last piece
if( rc == NO_ERROR && ridCounter > 0 ) {
m_index.m_multiRid.setMultiRid( ridArray, ridCounter );
rc = m_index.updateIndex( lastkey, width, ridArray[0] );
}
m_index.flushCache();
m_index.closeIndex();
Cache::freeMemory();
}
*/
#define NUMELEM 30000000
void multimapdemo()
{
multimap<int, int> mul;
timer t1, t2;
unsigned int idx;
map<int, int> mm;
for (idx = 0; idx < NUMELEM; idx++)
{
mul.insert(pair<int, int>(idx, idx));
if (idx % 10000 == 0)
{
printf("\nMultimap: index is %06i and time is:%lf (elapsed is %lf)", idx, t1.elapsed(), t2.elapsed());
t1.restart();
}
}
mul.clear();
}
bool pairCompare(const pair<int, int>& lhs, const pair<int, int>& rhs)
{
return lhs.second > rhs.second;
}
void sortvecdemo()
{
vector<pair<int, int> > idxvec;
timer t1, t2;
unsigned int idx;
for (idx = 0; idx < NUMELEM; idx++)
{
idxvec.push_back(pair<int, int>(idx, idx));
if (idx % 10000 == 0)
{
printf("Sortvec: index is %06i and time is:%lf (elapsed is %lf)\n", idx, t1.elapsed(), t2.elapsed());
t1.restart();
}
}
sort(idxvec.begin(), idxvec.end());
printf("Sortvec: time is:%lf (elapsed is %lf)\n", t1.elapsed(), t2.elapsed());
idxvec.clear();
}
void sortarrdemo()
{
int* idxarr;
idxarr = (int*)malloc(sizeof(int) * NUMELEM);
if (idxarr == 0)
{
printf("\nOOPs..\n");
exit(-1);
}
timer t1, t2;
unsigned int idx;
for (idx = 0; idx < NUMELEM; idx++)
{
idxarr[idx] = idx;
if (idx % 10000 == 0)
{
printf("Sortarr: index is %06i and time is:%lf (elapsed is %lf)\n", idx, t1.elapsed(), t2.elapsed());
t1.restart();
}
}
sort(idxarr, idxarr + NUMELEM);
printf("Sortarr: time is:%lf (elapsed is %lf)\n", t1.elapsed(), t2.elapsed());
}
void spacehog()
{
// test case to estimate space requirements
// generate an index with 200K entries, each unique
int rc;
uint64_t i;
printf("\nUT: Beginning Space Hog\n");
m_index.setUseFreeMgr(true);
m_index.setUseListMgr(true);
rc = m_index.createIndex(123, 124);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_index.openIndex(123, 124);
CPPUNIT_ASSERT(rc == NO_ERROR);
for (i = 0; i < 800 * 1000; i++)
{
if (i % (1000 * 10) == 0)
{
printf("UT: I is now: %i\n", (int)i);
}
rc = m_index.updateIndex(i * 10 * rand(), 32, i);
if (rc != NO_ERROR)
{
printf("\nShock and horror! i=%llu rc=%i\n", i, rc);
}
CPPUNIT_ASSERT(rc == NO_ERROR);
}
m_index.setAssignFbo(1);
m_index.closeIndex();
rc = m_index.dropIndex(123, 124);
CPPUNIT_ASSERT(rc == NO_ERROR);
m_index.setUseFreeMgr(false);
m_index.setUseListMgr(false);
printf("\nUT: Finishing Space Hog\n");
}
void test1()
{
int rc, width = 64, i;
m_index.setUseFreeMgr(true);
m_index.setUseListMgr(true);
BRMWrapper::setUseBrm(true);
BRMWrapper::setUseVb(false);
// Cache::setUseCache( true );
// Cache::init();
m_index.setTransId(12345678);
m_index.dropIndex(990, 991);
rc = m_index.createIndex(990, 991);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_index.openIndex(990, 991);
CPPUNIT_ASSERT(rc == NO_ERROR);
// m_index.m_freeMgr.setDebugLevel( DEBUG_1 );
DataBlock curBlock;
char buf[20];
uint64_t key;
timer t1, t2;
for (i = 0; i < 100000; i++)
{
sprintf(buf, "%dSuccess", i);
memcpy(&key, buf, 8);
if (i % (1000) == 0)
{
printf("UT: I is now: %i, elapsed time %lf s, delta %lf s\n", (int)i, t1.elapsed(), t2.elapsed());
t2.restart();
}
rc = m_index.updateIndex(key, width, i);
if (rc != NO_ERROR)
printf("\n i =%d rc=%d", i, rc);
CPPUNIT_ASSERT(rc == NO_ERROR);
}
printf("UT: I is now: %i, elapsed time %lf s, delta %lf s\n", (int)i, t1.elapsed(), t2.elapsed());
curBlock = m_index.getRootBlock();
printf("\n block 0 subblock 0 ");
m_index.printMemSubBlock(&curBlock, 0);
printf("\n block 0 subblock 1 ");
m_index.printMemSubBlock(&curBlock, 1);
m_index.printSubBlock(11, 10);
m_index.closeIndex();
// rc = m_index.dropIndex( 990, 991 );
// CPPUNIT_ASSERT( rc == NO_ERROR );
m_index.setUseFreeMgr(false);
m_index.setUseListMgr(false);
// Cache::freeMemory();
}
void test2()
{
int rc, width = 16, i;
m_index.setUseFreeMgr(true);
m_index.setUseListMgr(true);
rc = m_index.createIndex(990, 991);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_index.openIndex(990, 991);
CPPUNIT_ASSERT(rc == NO_ERROR);
DataBlock curBlock;
for (i = 10; i < 381; i++)
{
curBlock = m_index.getRootBlock();
printf("\n i=%d", i);
if (i == 130)
{
printf("\n130");
;
}
if (i == 20 || i == 128 || i == 129 || i == 64 || i == 66)
{
printf("\n******* before call updateIndex (i=%i)", i);
m_index.printMemSubBlock(&curBlock, 0);
m_index.printSubBlock(63, 19);
m_index.printSubBlock(63, 31);
}
rc = m_index.updateIndex(2 * i, width, i * 100);
if (rc != NO_ERROR)
printf("\n i =%d rc=%d", i, rc);
if (i == 20 || i == 128 || i == 129 || i == 64 || i == 66)
{
printf("\n******* after call updateIndex (i=%i)", i);
m_index.printMemSubBlock(&curBlock, 0);
m_index.printSubBlock(63, 19);
m_index.printSubBlock(63, 31);
}
CPPUNIT_ASSERT(rc == NO_ERROR);
}
m_index.setAssignFbo(1);
m_index.closeIndex();
rc = m_index.dropIndex(990, 991);
CPPUNIT_ASSERT(rc == NO_ERROR);
m_index.setUseFreeMgr(false);
m_index.setUseListMgr(false);
}
void testStructIO()
{
DataBlock curBlock;
FILE* pFile;
int rc, fbo = 1, sbid = 2, entryNo = 5, width = 8, allocSize;
IdxBitmapPointerEntry bitmapPtr;
memset(&bitmapPtr, 0, 8);
memset(curBlock.data, 0, sizeof(curBlock.data));
m_index.deleteFile(999);
CPPUNIT_ASSERT(m_index.exists(999) == false);
CPPUNIT_ASSERT(m_index.createFile(999, 10, allocSize) == NO_ERROR);
pFile = m_index.openFile(999);
CPPUNIT_ASSERT(pFile != NULL);
rc = m_index.readSubBlockEntry(pFile, &curBlock, fbo, sbid, entryNo, width, &bitmapPtr);
CPPUNIT_ASSERT(rc == NO_ERROR);
bitmapPtr.type = 1;
bitmapPtr.fbo = 2;
bitmapPtr.sbid = 8;
bitmapPtr.entry = 7;
rc = m_index.writeSubBlockEntry(pFile, &curBlock, fbo, sbid, entryNo, width, &bitmapPtr);
CPPUNIT_ASSERT(rc == NO_ERROR);
m_index.closeFile(pFile);
// reload the value
memset(&bitmapPtr, 0, 8);
memset(curBlock.data, 0, sizeof(curBlock.data));
CPPUNIT_ASSERT(m_index.isAddrPtrEmpty(&bitmapPtr, EMPTY_PTR) == true);
pFile = m_index.openFile(999);
CPPUNIT_ASSERT(pFile != NULL);
rc = m_index.readDBFile(pFile, curBlock.data, fbo);
CPPUNIT_ASSERT(rc == NO_ERROR);
m_index.getSubBlockEntry(curBlock.data, sbid, entryNo, width, &bitmapPtr);
CPPUNIT_ASSERT(bitmapPtr.type == 1);
CPPUNIT_ASSERT(bitmapPtr.fbo == 2);
CPPUNIT_ASSERT(bitmapPtr.sbid == 8);
CPPUNIT_ASSERT(bitmapPtr.entry == 7);
CPPUNIT_ASSERT(m_index.isAddrPtrEmpty(&bitmapPtr, BITMAP_PTR /*EMPTY_PTR*/) == false);
uint64_t i;
for (i = 0; i < 15; i++)
{
bitmapPtr.type = i % 8;
bitmapPtr.fbo = 2 * i;
bitmapPtr.sbid = i;
bitmapPtr.entry = i + 6;
m_index.setSubBlockEntry(curBlock.data, i, 0, 8, &bitmapPtr);
}
rc = m_index.writeDBFile(pFile, curBlock.data, fbo);
CPPUNIT_ASSERT(rc == NO_ERROR);
m_index.closeFile(pFile);
for (i = 0; i < 15; i++)
{
m_index.getSubBlockEntry(curBlock.data, i, 0, 8, &bitmapPtr);
CPPUNIT_ASSERT(bitmapPtr.type == i % 8);
// CPPUNIT_ASSERT( bitmapPtr.oid == i );
CPPUNIT_ASSERT(bitmapPtr.fbo == 2 * i);
CPPUNIT_ASSERT(bitmapPtr.sbid == i);
CPPUNIT_ASSERT(bitmapPtr.entry == i + 6);
}
}
void testAddTreeNode()
{
uint64_t key = 123, rid = 1900, width = 8, testbitVal = 3;
IdxTree myTree;
IdxBitmapPointerEntry bitmapEntry;
m_index.clearTree(&myTree);
bitmapEntry.fbo = 6;
bitmapEntry.sbid = 1;
bitmapEntry.entry = 9;
m_index.setTreeHeader(&myTree, key, rid, width, testbitVal, bitmapEntry);
CPPUNIT_ASSERT(myTree.width == width);
CPPUNIT_ASSERT(myTree.key == key);
CPPUNIT_ASSERT(myTree.rid == rid);
CPPUNIT_ASSERT(myTree.maxLevel == ((width / 5) + 1));
CPPUNIT_ASSERT(myTree.node[0].level == 0);
CPPUNIT_ASSERT(myTree.node[0].allocCount == ENTRY_PER_SUBBLOCK);
// CPPUNIT_ASSERT( myTree.node[0].group == ENTRY_32 );
CPPUNIT_ASSERT(myTree.node[0].used == true);
CPPUNIT_ASSERT(myTree.node[0].next.fbo == bitmapEntry.fbo);
CPPUNIT_ASSERT(myTree.node[0].next.sbid == bitmapEntry.sbid);
CPPUNIT_ASSERT(myTree.node[0].next.entry == bitmapEntry.entry);
}
void testSetupBittestArray()
{
char charVal[] = "abcde";
short i8Val = 21;
uint16_t i16Val = 1098, curPos = 0;
uint32_t i32Val = 0x0A6E6D8E, compareVal;
uint64_t i64Val = 0xDE1B4213;
int width, testbitVal, rc, i, shiftPos;
// compare with old code to make sure we can still be consistent
// test 64 bit
width = 8;
rc = m_index.setBitsetColumn(&i64Val, 1, width * 8, WriteEngine::WR_LONGLONG);
CPPUNIT_ASSERT(rc == NO_ERROR);
// cout << "bitArray = " << m_index.m_multiColKey.bitSet.to_string() << endl;
m_index.calculateBittestArray();
// cout << "\nMax level = " << m_index.m_multiColKey.maxLevel << endl;
for (i = 0; i < m_index.m_multiColKey.maxLevel; i++)
{
rc = m_index.getTestbitValue(i64Val, width * 8, i, &testbitVal);
CPPUNIT_ASSERT(rc == true);
printf("\tOld Level[%d] bit test value : %d \n", i, testbitVal);
shiftPos = i == m_index.m_multiColKey.maxLevel - 1 ? 4 : 5;
compareVal = compareVal << shiftPos | testbitVal;
CPPUNIT_ASSERT(testbitVal == m_index.m_multiColKey.testbitArray[i]);
}
// cout << "\nNew bitset array value " << endl;
for (i = 0; i < m_index.m_multiColKey.maxLevel; i++)
printf("\tLevel[%d] bit test value : %d \n", i, m_index.m_multiColKey.testbitArray[i]);
// test 32 bit
width = 4;
m_index.m_multiColKey.clear();
rc = m_index.setBitsetColumn(&i32Val, 1, width * 8, WriteEngine::WR_INT);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_index.calculateBittestArray();
CPPUNIT_ASSERT(rc == NO_ERROR);
for (i = 0; i < m_index.m_multiColKey.maxLevel; i++)
{
rc = m_index.getTestbitValue(i32Val, width * 8, i, &testbitVal);
CPPUNIT_ASSERT(rc == true);
CPPUNIT_ASSERT(testbitVal == m_index.m_multiColKey.testbitArray[i]);
}
// test 16 bit
width = 2;
m_index.m_multiColKey.clear();
rc = m_index.setBitsetColumn(&i16Val, 1, width * 8, WriteEngine::WR_SHORT);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_index.calculateBittestArray();
CPPUNIT_ASSERT(rc == NO_ERROR);
for (i = 0; i < m_index.m_multiColKey.maxLevel; i++)
{
rc = m_index.getTestbitValue(i16Val, width * 8, i, &testbitVal);
CPPUNIT_ASSERT(rc == true);
CPPUNIT_ASSERT(testbitVal == m_index.m_multiColKey.testbitArray[i]);
}
// test 8 bit
width = 1;
m_index.m_multiColKey.clear();
rc = m_index.setBitsetColumn(&i8Val, 1, width * 8, WriteEngine::WR_BYTE);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_index.calculateBittestArray();
CPPUNIT_ASSERT(rc == NO_ERROR);
for (i = 0; i < m_index.m_multiColKey.maxLevel; i++)
{
rc = m_index.getTestbitValue(i8Val, width * 8, i, &testbitVal);
CPPUNIT_ASSERT(rc == true);
CPPUNIT_ASSERT(testbitVal == m_index.m_multiColKey.testbitArray[i]);
}
// here is the real one for multi-column
m_index.m_multiColKey.clear();
width = 1;
rc = m_index.setBitsetColumn(&i8Val, curPos++, width * 8, WriteEngine::WR_BYTE);
CPPUNIT_ASSERT(rc == NO_ERROR);
width = 5;
rc = m_index.setBitsetColumn(charVal, curPos++, width * 8, WriteEngine::WR_CHAR);
CPPUNIT_ASSERT(rc == NO_ERROR);
width = 4;
rc = m_index.setBitsetColumn(&i32Val, curPos++, width * 8, WriteEngine::WR_INT);
CPPUNIT_ASSERT(rc == NO_ERROR);
width = 9;
strcpy(charVal, "test12345");
rc = m_index.setBitsetColumn(charVal, curPos++, width * 8, WriteEngine::WR_CHAR);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_index.calculateBittestArray();
CPPUNIT_ASSERT(rc == NO_ERROR);
CPPUNIT_ASSERT(m_index.m_multiColKey.maxLevel == 31);
CPPUNIT_ASSERT(m_index.m_multiColKey.totalBit == 152);
// cout << "\nMulti-column bitset array value " << endl;
for (i = 0; i < m_index.m_multiColKey.maxLevel; i++)
printf("\tLevel[%d] bit test value : %d \n", i, m_index.m_multiColKey.testbitArray[i]);
}
void testCreateAndUpdateIndex()
{
int rc;
bool bEmptyFlag;
BRMWrapper::setUseBrm(false);
m_index.dropIndex(990, 991);
rc = m_index.createIndex(990, 991);
CPPUNIT_ASSERT(rc == NO_ERROR);
// check invalid file not exist
rc = m_index.openIndex(990, 992);
CPPUNIT_ASSERT(rc != NO_ERROR);
rc = m_index.openIndex(992, 991);
CPPUNIT_ASSERT(rc != NO_ERROR);
// here is the correct check
rc = m_index.openIndex(990, 991);
CPPUNIT_ASSERT(rc == NO_ERROR);
bEmptyFlag = m_index.isTreeEmpty();
CPPUNIT_ASSERT(bEmptyFlag == true);
rc = m_index.updateIndex(123, 8, 1);
CPPUNIT_ASSERT(rc == NO_ERROR);
bEmptyFlag = m_index.isTreeEmpty();
CPPUNIT_ASSERT(bEmptyFlag == false);
// test insert multiple rid
RID ridArray[6];
ridArray[0] = 23;
ridArray[1] = 26;
ridArray[2] = 27;
ridArray[3] = 31;
ridArray[4] = 39;
ridArray[5] = 40;
m_index.setUseMultiRid(true);
m_index.m_multiRid.setMultiRid(ridArray, 6);
rc = m_index.updateIndex(123, 8, ridArray[0]);
CPPUNIT_ASSERT(rc == NO_ERROR);
m_index.m_multiRid.clearMultiRid();
m_index.closeIndex();
}
void testDeleteIndex()
{
int rc;
rc = m_index.dropIndex(990, 991);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_index.createIndex(990, 991);
CPPUNIT_ASSERT(rc == NO_ERROR);
m_index.setUseFreeMgr(true);
m_index.setUseListMgr(true);
rc = m_index.openIndex(990, 991);
CPPUNIT_ASSERT(rc == NO_ERROR);
// 8 bit
rc = m_index.deleteIndex(123, 8, 1);
CPPUNIT_ASSERT(rc == ERR_IDX_LIST_INVALID_DELETE);
rc = m_index.updateIndex(123, 8, 1);
printf("383. rc %i \n", rc);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_index.deleteIndex(123, 8, 1);
CPPUNIT_ASSERT(rc == NO_ERROR);
// 16 bit
rc = m_index.deleteIndex(0xA1C9, 16, 3);
CPPUNIT_ASSERT(rc != NO_ERROR);
rc = m_index.updateIndex(0xA1C9, 16, 3);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_index.deleteIndex(0xA1C9, 16, 3);
CPPUNIT_ASSERT(rc == NO_ERROR);
// 32 bit
rc = m_index.updateIndex(0xCA6E6D8E, 32, 3);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_index.deleteIndex(0xCA6E6D8E, 32, 3);
CPPUNIT_ASSERT(rc == NO_ERROR);
// repeat one more time, should fail
rc = m_index.deleteIndex(0xCA6E6D8E, 32, 3);
CPPUNIT_ASSERT(rc != NO_ERROR);
m_index.closeIndex();
}
void testResetIndex()
{
int rc, width = 64, i;
m_index.setUseFreeMgr(true);
m_index.setUseListMgr(true);
BRMWrapper::setUseBrm(true);
BRMWrapper::setUseVb(false);
m_index.setTransId(12345678);
m_index.dropIndex(990, 991);
rc = m_index.createIndex(990, 991);
CPPUNIT_ASSERT(rc == NO_ERROR);
m_index.closeIndex();
rc = m_index.openIndex(990, 991);
CPPUNIT_ASSERT(rc == NO_ERROR);
char buf[20];
uint64_t key;
for (i = 0; i < 10000; i++)
{
sprintf(buf, "%dSuccess", i);
memcpy(&key, buf, 8);
rc = m_index.updateIndex(key, width, i);
if (rc != NO_ERROR)
printf("\n i =%d rc=%d", i, rc);
CPPUNIT_ASSERT(rc == NO_ERROR);
}
m_index.closeIndex();
// reset index
// rc = m_index.openIndex( 990, 991 );
// CPPUNIT_ASSERT( rc == NO_ERROR );
rc = m_index.resetIndexFile(990, 991);
CPPUNIT_ASSERT(rc == NO_ERROR);
// m_index.closeIndex();
printf("\nre-insert begin\n");
rc = m_index.openIndex(990, 991);
CPPUNIT_ASSERT(rc == NO_ERROR);
for (i = 0; i < 10000; i++)
{
sprintf(buf, "%dSuccess", i);
memcpy(&key, buf, 8);
rc = m_index.updateIndex(key, width, i);
if (rc != NO_ERROR)
printf("\n i =%d rc=%d", i, rc);
CPPUNIT_ASSERT(rc == NO_ERROR);
}
m_index.closeIndex();
rc = m_index.dropIndex(990, 991);
CPPUNIT_ASSERT(rc == NO_ERROR);
}
void testUpdateMutiColIndex()
{
uint16_t i16Val;
uint32_t i32Val;
uint64_t key;
int rc, width = 64, i, pos = 0, totalWidth = 0;
char charVal[50];
m_index.setUseFreeMgr(true);
m_index.setUseListMgr(true);
BRMWrapper::setUseBrm(true);
BRMWrapper::setUseVb(false);
m_index.setTransId(12345678);
m_index.dropIndex(990, 991);
rc = m_index.createIndex(990, 991);
CPPUNIT_ASSERT(rc == NO_ERROR);
m_index.closeIndex();
rc = m_index.openIndex(990, 991);
CPPUNIT_ASSERT(rc == NO_ERROR);
m_index.setUseMultiCol(true);
printf("\nBegin of multicol index insert\n");
for (i = 0; i < 10000; i++)
{
totalWidth = 0;
// init part
m_index.m_multiColKey.clear();
// multi colum inserts
// column 1
width = 4;
totalWidth += width;
i32Val = i;
rc = m_index.setBitsetColumn(&i32Val, pos++, width * 8, WriteEngine::WR_INT);
CPPUNIT_ASSERT(rc == NO_ERROR);
// column 2
width = 4;
totalWidth += width;
i32Val = i * 3;
rc = m_index.setBitsetColumn(&i32Val, pos++, width * 8, WriteEngine::WR_INT);
CPPUNIT_ASSERT(rc == NO_ERROR);
// column 3
width = 2;
totalWidth += width;
i16Val = i;
rc = m_index.setBitsetColumn(&i16Val, pos++, width * 8, WriteEngine::WR_SHORT);
CPPUNIT_ASSERT(rc == NO_ERROR);
// column 4
width = 15;
totalWidth += width;
sprintf(charVal, "%7d success", i);
rc = m_index.setBitsetColumn(charVal, pos++, width * 8, WriteEngine::WR_CHAR);
CPPUNIT_ASSERT(rc == NO_ERROR);
// column 5
width = 7;
totalWidth += width;
sprintf(charVal, "%7d", i);
rc = m_index.setBitsetColumn(charVal, pos++, width * 8, WriteEngine::WR_CHAR);
CPPUNIT_ASSERT(rc == NO_ERROR);
// final part
rc = m_index.calculateBittestArray();
CPPUNIT_ASSERT(rc == NO_ERROR);
memcpy(&key, m_index.m_multiColKey.keyBuf, 8);
// printf( "\ntotalWidth = %d", totalWidth );
rc = m_index.updateIndex(key, totalWidth * 8, i);
if (rc != NO_ERROR)
printf("\n i =%d rc=%d", i, rc);
CPPUNIT_ASSERT(rc == NO_ERROR);
if (i % 500 == 0)
printf("\n process i=%d", i);
}
m_index.closeIndex();
printf("\nEnd of multicol index insert\n");
rc = m_index.dropIndex(990, 991);
CPPUNIT_ASSERT(rc == NO_ERROR);
}
void testIntegrationVolume()
{
int rc, width = 8, count = 3, i, j;
uint64_t key = 123;
RID rid = 1;
IdxTree myTree;
BRMWrapper::setUseBrm(false);
m_index.setUseFreeMgr(false);
m_index.setUseListMgr(true);
m_index.setDebugLevel(DEBUG_3);
for (i = 0; i < 3; i++)
{
switch (i)
{
case 0:
key = 123;
width = 8;
rid = 1;
break;
case 1:
key = 0xA1C9;
width = 16;
rid = 100;
break;
case 2:
key = 0xCA6E6D8E;
width = 32;
rid = 1000;
break;
}
rc = m_index.dropIndex(990, 991);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_index.createIndex(990, 991);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_index.openIndex(990, 991);
CPPUNIT_ASSERT(rc == NO_ERROR);
for (j = 0; j < count; j++)
{
printf("\nj=%d", j);
rc = m_index.updateIndex(key + j, width, rid + j);
if (rc != NO_ERROR)
printf("\nrc=%d", rc);
CPPUNIT_ASSERT(rc == NO_ERROR);
myTree = m_index.getTree();
m_index.setAssignFbo(1 + j);
}
for (j = 0; j < count; j++)
{
rc = m_index.deleteIndex(key + j, width, rid + j);
CPPUNIT_ASSERT(rc == NO_ERROR);
}
m_index.closeIndex();
}
}
void testTreeGetTestbitValue()
{
uint64_t key;
int width, bittestVal;
bool bStatus;
BRMWrapper::setUseBrm(false);
// test 8 bit
width = 8;
key = 35;
bStatus = m_index.getTestbitValue(key, width, 0, &bittestVal);
CPPUNIT_ASSERT(bStatus == true);
CPPUNIT_ASSERT(bittestVal == 4);
bStatus = m_index.getTestbitValue(key, width, 1, &bittestVal);
CPPUNIT_ASSERT(bStatus == true);
CPPUNIT_ASSERT(bittestVal == 3);
bStatus = m_index.getTestbitValue(key, width, 2, &bittestVal);
CPPUNIT_ASSERT(bStatus == false);
// test 16 bit
width = 16;
key = 0xA1C9;
bStatus = m_index.getTestbitValue(key, width, 0, &bittestVal);
CPPUNIT_ASSERT(bStatus == true);
CPPUNIT_ASSERT(bittestVal == 20);
bStatus = m_index.getTestbitValue(key, width, 1, &bittestVal);
CPPUNIT_ASSERT(bStatus == true);
CPPUNIT_ASSERT(bittestVal == 7);
bStatus = m_index.getTestbitValue(key, width, 2, &bittestVal);
CPPUNIT_ASSERT(bStatus == true);
CPPUNIT_ASSERT(bittestVal == 4);
bStatus = m_index.getTestbitValue(key, width, 3, &bittestVal);
CPPUNIT_ASSERT(bittestVal == 1);
CPPUNIT_ASSERT(bStatus == true);
bStatus = m_index.getTestbitValue(key, width, 4, &bittestVal);
CPPUNIT_ASSERT(bStatus == false);
// test 32 bit
width = 32;
key = 0xCA6E6D8E;
bStatus = m_index.getTestbitValue(key, width, 0, &bittestVal);
CPPUNIT_ASSERT(bStatus == true);
CPPUNIT_ASSERT(bittestVal == 25);
bStatus = m_index.getTestbitValue(key, width, 1, &bittestVal);
CPPUNIT_ASSERT(bStatus == true);
CPPUNIT_ASSERT(bittestVal == 9);
bStatus = m_index.getTestbitValue(key, width, 2, &bittestVal);
CPPUNIT_ASSERT(bStatus == true);
CPPUNIT_ASSERT(bittestVal == 23);
bStatus = m_index.getTestbitValue(key, width, 3, &bittestVal);
CPPUNIT_ASSERT(bittestVal == 6);
CPPUNIT_ASSERT(bStatus == true);
bStatus = m_index.getTestbitValue(key, width, 4, &bittestVal);
CPPUNIT_ASSERT(bittestVal == 27);
CPPUNIT_ASSERT(bStatus == true);
bStatus = m_index.getTestbitValue(key, width, 5, &bittestVal);
CPPUNIT_ASSERT(bittestVal == 3);
CPPUNIT_ASSERT(bStatus == true);
bStatus = m_index.getTestbitValue(key, width, 6, &bittestVal);
CPPUNIT_ASSERT(bittestVal == 2);
CPPUNIT_ASSERT(bStatus == true);
bStatus = m_index.getTestbitValue(key, width, 7, &bittestVal);
CPPUNIT_ASSERT(bStatus == false);
}
void testTreeGetTreeNodeInfo()
{
int rc, fbo = 6, sbid = 1, entry = 2, testbitVal = 5;
int curSbid = 3, curEntry = 2, allocCount, realCount;
IdxTreeGroupType curGroup;
bool entryMap[ENTRY_PER_SUBBLOCK];
DataBlock block;
IdxBitTestEntry bittestEntry;
// test ENTRY_1
m_index.clearBlock(&block);
curGroup = ENTRY_1;
m_index.setBittestEntry(&bittestEntry, testbitVal, curGroup, fbo, sbid, entry);
m_index.setSubBlockEntry(block.data, curSbid, curEntry, 8, &bittestEntry);
m_index.setBittestEntry(&bittestEntry, testbitVal + 3, curGroup, fbo + 6, sbid + 3, entry + 1);
m_index.setSubBlockEntry(block.data, curSbid, curEntry + 1, 8, &bittestEntry);
rc = m_index.getTreeNodeInfo(&block, curSbid, curEntry, 8, curGroup, &allocCount, &realCount, entryMap);
CPPUNIT_ASSERT(rc == NO_ERROR);
CPPUNIT_ASSERT(allocCount == 1);
CPPUNIT_ASSERT(realCount == 1);
CPPUNIT_ASSERT(entryMap[0] == true);
// test ENTRY_2
m_index.clearBlock(&block);
curGroup = ENTRY_2;
m_index.setBittestEntry(&bittestEntry, testbitVal, curGroup, fbo, sbid, entry);
m_index.setSubBlockEntry(block.data, curSbid, curEntry, 8, &bittestEntry);
m_index.setBittestEntry(&bittestEntry, testbitVal + 3, curGroup, fbo + 6, sbid + 3, entry + 1);
m_index.setSubBlockEntry(block.data, curSbid, curEntry + 1, 8, &bittestEntry);
m_index.setBittestEntry(&bittestEntry, testbitVal, curGroup, fbo + 6, sbid + 3, entry + 1);
bittestEntry.type = EMPTY_LIST;
m_index.setSubBlockEntry(block.data, curSbid, curEntry + 2, 8, &bittestEntry);
rc = m_index.getTreeNodeInfo(&block, curSbid, curEntry, 8, curGroup, &allocCount, &realCount, entryMap);
CPPUNIT_ASSERT(rc == NO_ERROR);
CPPUNIT_ASSERT(allocCount == 2);
CPPUNIT_ASSERT(realCount == 2);
CPPUNIT_ASSERT(entryMap[0] == true);
CPPUNIT_ASSERT(entryMap[1] == true);
CPPUNIT_ASSERT(entryMap[2] == false);
// test ENTRY_8
m_index.clearBlock(&block);
curGroup = ENTRY_8;
m_index.setBittestEntry(&bittestEntry, testbitVal, curGroup, fbo, sbid, entry);
m_index.setSubBlockEntry(block.data, curSbid, curEntry, 8, &bittestEntry);
m_index.setBittestEntry(&bittestEntry, testbitVal, curGroup, fbo + 6, sbid + 3, entry + 1);
bittestEntry.type = EMPTY_LIST;
m_index.setSubBlockEntry(block.data, curSbid, curEntry + 3, 8, &bittestEntry);
rc = m_index.getTreeNodeInfo(&block, curSbid, curEntry, 8, curGroup, &allocCount, &realCount, entryMap);
CPPUNIT_ASSERT(rc == ERR_IDX_TREE_INVALID_TYPE);
m_index.setBittestEntry(&bittestEntry, testbitVal, curGroup, fbo + 6, sbid + 3, entry + 1);
m_index.setSubBlockEntry(block.data, curSbid, curEntry + 3, 8, &bittestEntry);
bittestEntry.type = EMPTY_ENTRY;
m_index.setSubBlockEntry(block.data, curSbid, curEntry + 2, 2, &bittestEntry);
rc = m_index.getTreeNodeInfo(&block, curSbid, curEntry, 8, curGroup, &allocCount, &realCount, entryMap);
CPPUNIT_ASSERT(rc == NO_ERROR);
CPPUNIT_ASSERT(allocCount == 8);
CPPUNIT_ASSERT(realCount == 2);
CPPUNIT_ASSERT(entryMap[0] == true);
CPPUNIT_ASSERT(entryMap[1] == false);
CPPUNIT_ASSERT(entryMap[2] == false);
CPPUNIT_ASSERT(entryMap[3] == true);
CPPUNIT_ASSERT(entryMap[4] == false);
}
void testTreeGetTreeMatchEntry()
{
int rc, fbo = 6, sbid = 1, entry = 2, testbitVal = 5;
int curSbid = 3, curEntry = 2, allocCount, realCount, matchEntry;
IdxTreeGroupType curGroup;
bool entryMap[ENTRY_PER_SUBBLOCK];
DataBlock block;
IdxBitTestEntry bittestEntry, checkEntry;
bool bFound;
// ENTRY_8
m_index.clearBlock(&block);
curGroup = ENTRY_8;
m_index.setBittestEntry(&bittestEntry, testbitVal, curGroup, fbo, sbid, entry);
m_index.setSubBlockEntry(block.data, curSbid, curEntry, 8, &bittestEntry);
m_index.setBittestEntry(&bittestEntry, testbitVal + 5, curGroup, fbo + 9, sbid + 6, entry + 2);
m_index.setSubBlockEntry(block.data, curSbid, curEntry + 4, 8, &bittestEntry);
m_index.setBittestEntry(&bittestEntry, testbitVal + 9, curGroup, fbo + 6, sbid + 3, entry + 1);
m_index.setSubBlockEntry(block.data, curSbid, curEntry + 3, 8, &bittestEntry);
bittestEntry.type = EMPTY_ENTRY;
m_index.setSubBlockEntry(block.data, curSbid, curEntry + 2, 2, &bittestEntry);
rc = m_index.getTreeNodeInfo(&block, curSbid, curEntry, 8, curGroup, &allocCount, &realCount, entryMap);
CPPUNIT_ASSERT(rc == NO_ERROR);
CPPUNIT_ASSERT(allocCount == 8);
CPPUNIT_ASSERT(realCount == 3);
CPPUNIT_ASSERT(entryMap[0] == true);
CPPUNIT_ASSERT(entryMap[1] == false);
CPPUNIT_ASSERT(entryMap[2] == false);
CPPUNIT_ASSERT(entryMap[3] == true);
CPPUNIT_ASSERT(entryMap[4] == true);
CPPUNIT_ASSERT(entryMap[5] == false);
memset(&checkEntry, 0, 8);
checkEntry.type = BIT_TEST;
checkEntry.bitTest = testbitVal + 4;
bFound = m_index.getTreeMatchEntry(&block, curSbid, curEntry, 8, allocCount, entryMap, &matchEntry,
&checkEntry);
CPPUNIT_ASSERT(bFound == false);
checkEntry.bitTest = testbitVal + 9;
bFound = m_index.getTreeMatchEntry(&block, curSbid, curEntry, 8, allocCount, entryMap, &matchEntry,
&checkEntry);
CPPUNIT_ASSERT(bFound == true);
CPPUNIT_ASSERT(matchEntry == 3);
m_index.setBittestEntry(&bittestEntry, testbitVal + 5, curGroup, fbo + 9, sbid + 6, entry + 2);
checkEntry.bitTest = testbitVal + 5;
bFound = m_index.getTreeMatchEntry(&block, curSbid, curEntry, 8, allocCount, entryMap, &matchEntry,
&checkEntry);
CPPUNIT_ASSERT(bFound == true);
CPPUNIT_ASSERT(matchEntry == 4);
CPPUNIT_ASSERT(!memcmp(&checkEntry, &bittestEntry, 8));
}
void testTreeMoveEntry()
{
int rc, fbo = 6, sbid = 1, entry = 2, testbitVal = 5;
int curSbid = 3, curEntry = 2, allocCount, realCount, moveCount;
IdxTreeGroupType curGroup;
bool entryMap[ENTRY_PER_SUBBLOCK];
DataBlock oldBlock, newBlock, testBlock, blankBlock;
IdxBitTestEntry bittestEntry;
FILE* treeFile;
if (m_index.exists(990))
{
rc = m_index.dropIndex(990, 991);
CPPUNIT_ASSERT(rc == NO_ERROR);
}
BRMWrapper::setUseBrm(false);
rc = m_index.createIndex(990, 991, false);
CPPUNIT_ASSERT(rc == NO_ERROR);
treeFile = m_index.openFile(990);
CPPUNIT_ASSERT(treeFile != NULL);
// ENTRY_8
m_index.clearBlock(&oldBlock);
m_index.clearBlock(&newBlock);
m_index.clearBlock(&testBlock);
m_index.clearBlock(&blankBlock);
curGroup = ENTRY_8;
m_index.setBittestEntry(&bittestEntry, testbitVal, curGroup, fbo, sbid, entry);
m_index.setSubBlockEntry(oldBlock.data, curSbid, curEntry, 8, &bittestEntry);
m_index.setBittestEntry(&bittestEntry, testbitVal + 5, curGroup, fbo + 9, sbid + 6, entry + 2);
m_index.setSubBlockEntry(oldBlock.data, curSbid, curEntry + 4, 8, &bittestEntry);
m_index.setBittestEntry(&bittestEntry, testbitVal + 9, curGroup, fbo + 6, sbid + 3, entry + 1);
m_index.setSubBlockEntry(oldBlock.data, curSbid, curEntry + 3, 8, &bittestEntry);
bittestEntry.type = EMPTY_ENTRY;
m_index.setSubBlockEntry(oldBlock.data, curSbid, curEntry + 2, 2, &bittestEntry);
rc =
m_index.getTreeNodeInfo(&oldBlock, curSbid, curEntry, 8, curGroup, &allocCount, &realCount, entryMap);
CPPUNIT_ASSERT(rc == NO_ERROR);
CPPUNIT_ASSERT(allocCount == 8);
CPPUNIT_ASSERT(realCount == 3);
CPPUNIT_ASSERT(entryMap[0] == true);
CPPUNIT_ASSERT(entryMap[1] == false);
CPPUNIT_ASSERT(entryMap[2] == false);
CPPUNIT_ASSERT(entryMap[3] == true);
CPPUNIT_ASSERT(entryMap[4] == true);
CPPUNIT_ASSERT(entryMap[5] == false);
rc = m_index.writeDBFile(treeFile, &oldBlock, 3);
CPPUNIT_ASSERT(rc == NO_ERROR);
m_index.closeFile(treeFile);
rc = m_index.openIndex(990, 991);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_index.moveEntry(3, curSbid, curEntry, 8, 5, curSbid + 10, curEntry + 1, curGroup, allocCount,
entryMap, &moveCount);
CPPUNIT_ASSERT(rc == NO_ERROR);
CPPUNIT_ASSERT(moveCount == 3);
m_index.closeIndex();
treeFile = m_index.openFile(990);
CPPUNIT_ASSERT(treeFile != NULL);
rc = m_index.readDBFile(treeFile, &testBlock, 3);
CPPUNIT_ASSERT(rc == NO_ERROR);
CPPUNIT_ASSERT(!memcmp(testBlock.data, blankBlock.data, sizeof(testBlock.data)));
rc = m_index.readDBFile(treeFile, &testBlock, 5);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_index.getTreeNodeInfo(&testBlock, curSbid + 10, curEntry + 1, 8, curGroup, &allocCount, &realCount,
entryMap);
CPPUNIT_ASSERT(rc == NO_ERROR);
CPPUNIT_ASSERT(allocCount == 8);
CPPUNIT_ASSERT(realCount == 3);
CPPUNIT_ASSERT(entryMap[0] == true);
CPPUNIT_ASSERT(entryMap[1] == true);
CPPUNIT_ASSERT(entryMap[2] == true);
CPPUNIT_ASSERT(entryMap[3] == false);
CPPUNIT_ASSERT(entryMap[4] == false);
CPPUNIT_ASSERT(entryMap[5] == false);
m_index.closeFile(treeFile);
}
void testTreeNodeAssert(IdxTree myTree, int curLevel, uint64_t curBitTest, uint16_t curGroup,
uint64_t curFbo, uint64_t curSbid, uint64_t curEntry, uint64_t nextFbo,
uint64_t nextSbid, uint64_t nextEntry)
{
CPPUNIT_ASSERT(myTree.node[curLevel].current.bitTest == curBitTest);
CPPUNIT_ASSERT(myTree.node[curLevel].current.group == curGroup);
CPPUNIT_ASSERT(myTree.node[curLevel].current.fbo == curFbo);
CPPUNIT_ASSERT(myTree.node[curLevel].current.sbid == curSbid);
CPPUNIT_ASSERT(myTree.node[curLevel].current.entry == curEntry);
if (curLevel == 0)
CPPUNIT_ASSERT(myTree.node[curLevel].current.type == BITMAP_PTR);
else if (curLevel == myTree.maxLevel - 1)
CPPUNIT_ASSERT(myTree.node[curLevel].current.type == LEAF_LIST);
else
CPPUNIT_ASSERT(myTree.node[curLevel].current.type == BIT_TEST);
CPPUNIT_ASSERT(myTree.node[curLevel].next.fbo == nextFbo);
CPPUNIT_ASSERT(myTree.node[curLevel].next.sbid == nextSbid);
CPPUNIT_ASSERT(myTree.node[curLevel].next.entry == nextEntry);
CPPUNIT_ASSERT(myTree.node[curLevel].allocCount == (0x1 << curGroup));
CPPUNIT_ASSERT(myTree.node[curLevel].used == true);
}
void testTreeBuildEmptyTree()
{
int rc, width = 8, rid = 3;
uint64_t key = 123;
IdxTree myTree;
BRMWrapper::setUseBrm(false);
rc = m_index.dropIndex(990, 991);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_index.createIndex(990, 991);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_index.openIndex(990, 991);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_index.buildEmptyTreePart(key, width, rid, 0);
CPPUNIT_ASSERT(rc == ERR_IDX_TREE_INVALID_LEVEL);
rc = m_index.buildEmptyTreePart(key, 4, rid, 0);
CPPUNIT_ASSERT(rc == ERR_IDX_TREE_INVALID_LEVEL);
rc = m_index.updateIndex(key, width, rid);
CPPUNIT_ASSERT(rc == NO_ERROR);
// width = 8
myTree = m_index.getTree();
CPPUNIT_ASSERT(myTree.maxLevel == 2);
CPPUNIT_ASSERT(myTree.key == key);
CPPUNIT_ASSERT(myTree.width == width);
CPPUNIT_ASSERT(myTree.rid == (RID)rid);
testTreeNodeAssert(myTree, 0, 15, ENTRY_32, 0, 1, 15, /* */ 1, 3, 4);
testTreeNodeAssert(myTree, 1, 3, ENTRY_1, 1, 3, 4, /* */ 3, 3, 4);
CPPUNIT_ASSERT(myTree.node[2].used == false);
// width = 16
key = 0xA1C9;
width = 16;
rc = m_index.updateIndex(key, width, rid);
CPPUNIT_ASSERT(rc == NO_ERROR);
myTree = m_index.getTree();
CPPUNIT_ASSERT(myTree.maxLevel == 4);
CPPUNIT_ASSERT(myTree.key == key);
CPPUNIT_ASSERT(myTree.width == width);
CPPUNIT_ASSERT(myTree.rid == (RID)rid);
testTreeNodeAssert(myTree, 0, 20, ENTRY_32, 0, 1, 20, /* */ 1, 3, 4);
testTreeNodeAssert(myTree, 1, 7, ENTRY_1, 1, 3, 4, /* */ 1, 4, 4);
testTreeNodeAssert(myTree, 2, 4, ENTRY_1, 1, 4, 4, /* */ 1, 5, 4);
testTreeNodeAssert(myTree, 3, 1, ENTRY_1, 1, 5, 4, /* */ 3, 3, 6);
CPPUNIT_ASSERT(myTree.node[4].used == false);
// width = 32
key = 0xCA6E6D8E;
width = 32;
rc = m_index.updateIndex(key, width, rid);
CPPUNIT_ASSERT(rc == NO_ERROR);
myTree = m_index.getTree();
CPPUNIT_ASSERT(myTree.maxLevel == 7);
CPPUNIT_ASSERT(myTree.key == key);
CPPUNIT_ASSERT(myTree.width == width);
CPPUNIT_ASSERT(myTree.rid == (RID)rid);
testTreeNodeAssert(myTree, 0, 25, ENTRY_32, 0, 1, 25, /* */ 1, 3, 4);
testTreeNodeAssert(myTree, 1, 9, ENTRY_1, 1, 3, 4, /* */ 1, 4, 4);
testTreeNodeAssert(myTree, 2, 23, ENTRY_1, 1, 4, 4, /* */ 1, 5, 4);
testTreeNodeAssert(myTree, 3, 6, ENTRY_1, 1, 5, 4, /* */ 1, 6, 4);
testTreeNodeAssert(myTree, 4, 27, ENTRY_1, 1, 6, 4, /* */ 1, 7, 4);
testTreeNodeAssert(myTree, 5, 3, ENTRY_1, 1, 7, 4, /* */ 1, 8, 4);
testTreeNodeAssert(myTree, 6, 2, ENTRY_1, 1, 8, 4, /* */ 3, 3, 9);
CPPUNIT_ASSERT(myTree.node[7].used == false);
m_index.closeIndex();
}
void testTreeBuildExistTree1()
{
int rc, width = 8, rid = 3;
uint64_t key = 123;
IdxTree myTree;
BRMWrapper::setUseBrm(false);
rc = m_index.dropIndex(990, 991);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_index.createIndex(990, 991);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_index.openIndex(990, 991);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_index.updateIndex(key, width, rid);
CPPUNIT_ASSERT(rc == NO_ERROR);
// width = 8
myTree = m_index.getTree();
CPPUNIT_ASSERT(myTree.maxLevel == 2);
CPPUNIT_ASSERT(myTree.key == key);
CPPUNIT_ASSERT(myTree.width == width);
CPPUNIT_ASSERT(myTree.rid == (RID)rid);
testTreeNodeAssert(myTree, 0, 15, ENTRY_32, 0, 1, 15, /* */ 1, 3, 4);
testTreeNodeAssert(myTree, 1, 3, ENTRY_1, 1, 3, 4, /* */ 3, 3, 4);
CPPUNIT_ASSERT(myTree.node[2].used == false);
// insert again
m_index.setAssignFbo(1);
rc = m_index.updateIndex(key, width, rid + 3);
CPPUNIT_ASSERT(rc == NO_ERROR);
myTree = m_index.getTree();
CPPUNIT_ASSERT(myTree.maxLevel == 2);
CPPUNIT_ASSERT(myTree.key == key);
CPPUNIT_ASSERT(myTree.width == width);
CPPUNIT_ASSERT(myTree.rid == (RID)(rid + 3));
testTreeNodeAssert(myTree, 0, 15, ENTRY_32, 0, 1, 15, /* */ 1, 3, 4);
testTreeNodeAssert(myTree, 1, 3, ENTRY_1, 1, 3, 4, /* */ 3, 3, 4);
CPPUNIT_ASSERT(myTree.node[2].used == false);
// insert with a little different key
m_index.setAssignFbo(2);
rc = m_index.updateIndex(key + 1, width, rid + 4);
CPPUNIT_ASSERT(rc == NO_ERROR);
myTree = m_index.getTree();
CPPUNIT_ASSERT(myTree.maxLevel == 2);
CPPUNIT_ASSERT(myTree.key == key + 1);
CPPUNIT_ASSERT(myTree.width == width);
CPPUNIT_ASSERT(myTree.rid == (RID)(rid + 4));
testTreeNodeAssert(myTree, 0, 15, ENTRY_32, 0, 1, 15, /* */ 3, 4, 4);
testTreeNodeAssert(myTree, 1, 4, ENTRY_2, 3, 4, 4, /* */ 3, 3, 4);
CPPUNIT_ASSERT(myTree.node[2].used == false);
// insert with a different key and different rid
m_index.setAssignFbo(3);
rc = m_index.updateIndex(key + 2, width, rid + 5);
CPPUNIT_ASSERT(rc == NO_ERROR);
myTree = m_index.getTree();
CPPUNIT_ASSERT(myTree.maxLevel == 2);
CPPUNIT_ASSERT(myTree.key == key + 2);
CPPUNIT_ASSERT(myTree.width == width);
CPPUNIT_ASSERT(myTree.rid == (RID)(rid + 5));
testTreeNodeAssert(myTree, 0, 15, ENTRY_32, 0, 1, 15, /* */ 4, 4, 4);
testTreeNodeAssert(myTree, 1, 5, ENTRY_4, 4, 4, 4, /* */ 3, 3, 4);
CPPUNIT_ASSERT(myTree.node[1].useCount == 3);
CPPUNIT_ASSERT(myTree.node[2].used == false);
// insert with a different key and different rid
m_index.setAssignFbo(4);
rc = m_index.updateIndex(key + 3, width, rid + 7);
CPPUNIT_ASSERT(rc == NO_ERROR);
myTree = m_index.getTree();
CPPUNIT_ASSERT(myTree.maxLevel == 2);
CPPUNIT_ASSERT(myTree.key == key + 3);
CPPUNIT_ASSERT(myTree.width == width);
CPPUNIT_ASSERT(myTree.rid == (RID)(rid + 7));
testTreeNodeAssert(myTree, 0, 15, ENTRY_32, 0, 1, 15, /* */ 4, 4, 4);
testTreeNodeAssert(myTree, 1, 6, ENTRY_4, 4, 4, 4, /* */ 3, 3, 4);
CPPUNIT_ASSERT(myTree.node[2].used == false);
m_index.closeIndex();
}
void testTreeBuildExistTree2()
{
int rc, width = 16, rid = 3;
uint64_t key = 0xA1C9;
IdxTree myTree;
BRMWrapper::setUseBrm(false);
rc = m_index.dropIndex(990, 991);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_index.createIndex(990, 991);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_index.openIndex(990, 991);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_index.updateIndex(key, width, rid);
CPPUNIT_ASSERT(rc == NO_ERROR);
// width = 16
myTree = m_index.getTree();
CPPUNIT_ASSERT(myTree.maxLevel == 4);
CPPUNIT_ASSERT(myTree.key == key);
CPPUNIT_ASSERT(myTree.width == width);
CPPUNIT_ASSERT(myTree.rid == (RID)rid);
testTreeNodeAssert(myTree, 0, 20, ENTRY_32, 0, 1, 20, /* */ 1, 3, 4);
testTreeNodeAssert(myTree, 1, 7, ENTRY_1, 1, 3, 4, /* */ 1, 4, 4);
testTreeNodeAssert(myTree, 2, 4, ENTRY_1, 1, 4, 4, /* */ 1, 5, 4);
testTreeNodeAssert(myTree, 3, 1, ENTRY_1, 1, 5, 4, /* */ 3, 3, 6);
CPPUNIT_ASSERT(myTree.node[4].used == false);
// insert again
m_index.setAssignFbo(1);
rc = m_index.updateIndex(key, width, rid + 3);
CPPUNIT_ASSERT(rc == NO_ERROR);
myTree = m_index.getTree();
CPPUNIT_ASSERT(myTree.maxLevel == 4);
CPPUNIT_ASSERT(myTree.key == key);
CPPUNIT_ASSERT(myTree.width == width);
CPPUNIT_ASSERT(myTree.rid == (RID)(rid + 3));
testTreeNodeAssert(myTree, 0, 20, ENTRY_32, 0, 1, 20, /* */ 1, 3, 4);
testTreeNodeAssert(myTree, 1, 7, ENTRY_1, 1, 3, 4, /* */ 1, 4, 4);
testTreeNodeAssert(myTree, 2, 4, ENTRY_1, 1, 4, 4, /* */ 1, 5, 4);
testTreeNodeAssert(myTree, 3, 1, ENTRY_1, 1, 5, 4, /* */ 3, 3, 6);
CPPUNIT_ASSERT(myTree.node[4].used == false);
// insert with a little different key
m_index.setAssignFbo(2);
rc = m_index.updateIndex(key + 1, width, rid + 4);
CPPUNIT_ASSERT(rc == NO_ERROR);
myTree = m_index.getTree();
CPPUNIT_ASSERT(myTree.maxLevel == 4);
CPPUNIT_ASSERT(myTree.key == key + 1);
CPPUNIT_ASSERT(myTree.width == width);
CPPUNIT_ASSERT(myTree.rid == (RID)(rid + 4));
testTreeNodeAssert(myTree, 0, 20, ENTRY_32, 0, 1, 20, /* */ 1, 3, 4);
// testTreeNodeAssert( myTree, 1, 7, ENTRY_1, 1,3,4, /* */ 3, 5, 5 );
testTreeNodeAssert(myTree, 2, 5, ENTRY_2, 3, 5, 5, /* */ 3, 3, 4);
testTreeNodeAssert(myTree, 3, 0, ENTRY_1, 3, 3, 4, /* */ 3, 3, 6);
CPPUNIT_ASSERT(myTree.node[4].used == false);
// insert with a different key and different rid
m_index.setAssignFbo(3);
rc = m_index.updateIndex(key + 2, width, rid + 5);
CPPUNIT_ASSERT(rc == NO_ERROR);
myTree = m_index.getTree();
CPPUNIT_ASSERT(myTree.maxLevel == 4);
CPPUNIT_ASSERT(myTree.key == key + 2);
CPPUNIT_ASSERT(myTree.width == width);
CPPUNIT_ASSERT(myTree.rid == (RID)(rid + 5));
testTreeNodeAssert(myTree, 0, 20, ENTRY_32, 0, 1, 20, /* */ 1, 3, 4);
// testTreeNodeAssert( myTree, 1, 7, ENTRY_1, 1,3,4, /* */ 3, 5, 5 );
testTreeNodeAssert(myTree, 2, 5, ENTRY_2, 3, 5, 5, /* */ 4, 6, 4);
testTreeNodeAssert(myTree, 3, 1, ENTRY_2, 4, 6, 4, /* */ 3, 3, 6);
CPPUNIT_ASSERT(myTree.node[4].used == false);
// insert with a different key and different rid
m_index.setAssignFbo(4);
rc = m_index.updateIndex(key + 3, width, rid + 7);
CPPUNIT_ASSERT(rc == NO_ERROR);
myTree = m_index.getTree();
CPPUNIT_ASSERT(myTree.maxLevel == 4);
CPPUNIT_ASSERT(myTree.key == key + 3);
CPPUNIT_ASSERT(myTree.width == width);
CPPUNIT_ASSERT(myTree.rid == (RID)(rid + 7));
testTreeNodeAssert(myTree, 0, 20, ENTRY_32, 0, 1, 20, /* */ 1, 3, 4);
// testTreeNodeAssert( myTree, 1, 7, ENTRY_1, 1,3,4, /* */ 3, 5, 5 );
testTreeNodeAssert(myTree, 2, 6, ENTRY_4, 5, 5, 6, /* */ 5, 3, 4);
testTreeNodeAssert(myTree, 3, 0, ENTRY_1, 5, 3, 4, /* */ 3, 3, 6);
CPPUNIT_ASSERT(myTree.node[4].used == false);
m_index.closeIndex();
// set a blank entry
IdxBitTestEntry curEntry;
FILE* treeFile;
DataBlock curBlock;
treeFile = m_index.openFile(990);
CPPUNIT_ASSERT(treeFile != NULL);
rc = m_index.readSubBlockEntry(treeFile, &curBlock, 1, 3, 4, MAX_COLUMN_BOUNDARY, &curEntry);
CPPUNIT_ASSERT(rc == NO_ERROR);
m_index.setBlankEntry(&curEntry);
rc = m_index.writeSubBlockEntry(treeFile, &curBlock, 1, 3, 4, MAX_COLUMN_BOUNDARY, &curEntry);
CPPUNIT_ASSERT(rc == NO_ERROR);
m_index.closeFile(treeFile);
rc = m_index.openIndex(990, 991);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_index.updateIndex(key, width, rid);
CPPUNIT_ASSERT(rc == ERR_STRUCT_EMPTY);
m_index.closeIndex();
}
void testTreeIntegration()
{
IdxEmptyListEntry myEntry;
int rc;
BRMWrapper::setUseBrm(false);
rc = m_index.openIndex(990, 991);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_index.assignSegment(ENTRY_1, &myEntry, 0);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_index.releaseSegment(ENTRY_1, &myEntry);
CPPUNIT_ASSERT(rc == NO_ERROR);
m_index.setUseFreeMgr(true);
rc = m_index.assignSegment(ENTRY_1, &myEntry, 0);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_index.releaseSegment(ENTRY_1, &myEntry);
CPPUNIT_ASSERT(rc == NO_ERROR);
m_index.closeIndex();
}
void testFreeMgrBRM()
{
int rc;
int allocSize;
CommBlock cb;
uint64_t lbid;
uint64_t fbo;
m_freeMgr.setDebugLevel(DEBUG_0);
printf("\nUT: Begin testFreeMgrBRM\n");
m_freeMgr.deleteFile(777);
m_freeMgr.createFile(777, 80, allocSize);
m_freeMgr.createFile(778, 80, allocSize);
cb.file.oid = 777;
fbo = 0;
lbid = m_freeMgr.mapLBID(cb, fbo, rc);
CPPUNIT_ASSERT(rc == NO_ERROR);
printf("OID: %u FBO: %llu LBID: %llu\n", cb.file.oid, fbo, lbid);
cb.file.oid = 777;
fbo = 10;
lbid = m_freeMgr.mapLBID(cb, fbo, rc);
CPPUNIT_ASSERT(rc == NO_ERROR);
printf("OID: %u FBO: %llu LBID: %llu\n", cb.file.oid, fbo, lbid);
cb.file.oid = 777;
fbo = 1023;
lbid = m_freeMgr.mapLBID(cb, fbo, rc);
CPPUNIT_ASSERT(rc == NO_ERROR);
printf("OID: %u FBO: %llu LBID: %llu\n", cb.file.oid, fbo, lbid);
cb.file.oid = 777;
fbo = 1020;
lbid = m_freeMgr.mapLBID(cb, fbo, rc);
CPPUNIT_ASSERT(rc == NO_ERROR);
printf("OID: %u FBO: %llu LBID: %llu\n", cb.file.oid, fbo, lbid);
cb.file.oid = 778;
fbo = 0;
lbid = m_freeMgr.mapLBID(cb, fbo, rc);
CPPUNIT_ASSERT(rc == NO_ERROR);
printf("OID: %u FBO: %llu LBID: %llu\n", cb.file.oid, fbo, lbid);
cb.file.oid = 778;
fbo = 1000;
lbid = m_freeMgr.mapLBID(cb, fbo, rc);
CPPUNIT_ASSERT(rc == NO_ERROR);
printf("OID: %u FBO: %llu LBID: %llu\n", cb.file.oid, fbo, lbid);
CPPUNIT_ASSERT(rc == NO_ERROR);
}
void testFreeMgrInit()
{
FILE* indexFile;
DataBlock blockZero;
IdxEmptyListEntry emptyMap, assignPtr;
CommBlock cb;
int allocSize, rc;
uint64_t lbid;
m_freeMgr.setDebugLevel(DEBUG_1);
printf("\nUT: Begin testFreeMgrInit\n");
assignPtr.fbo = 0;
assignPtr.sbid = 0;
assignPtr.entry = 0;
assignPtr.type = 0;
cb.file.pFile = NULL;
CPPUNIT_ASSERT(m_freeMgr.init(cb, TREE) == ERR_INVALID_PARAM);
m_freeMgr.deleteFile(777);
m_freeMgr.deleteFile(778);
m_freeMgr.createFile(
778, 8, allocSize); // create a second file to try and force lbid range to not collide with fbo
m_freeMgr.createFile(777, 8, allocSize);
cb.file.pFile = m_freeMgr.openFile(777);
cb.file.oid = 777;
// m_indexlist.createFile(777,800, allocSize);
indexFile = cb.file.pFile;
CPPUNIT_ASSERT(m_freeMgr.init(cb, 1234) == ERR_INVALID_PARAM);
// init a freemgr for a tree
CPPUNIT_ASSERT(m_freeMgr.init(cb, TREE) == NO_ERROR);
lbid = m_freeMgr.mapLBID(cb, 0, rc);
CPPUNIT_ASSERT_MESSAGE("Error using mapLBID", rc == NO_ERROR);
m_freeMgr.readDBFile(cb.file.pFile, blockZero.data, lbid);
m_freeMgr.getSubBlockEntry(blockZero.data, 0, 1 + ENTRY_32, 8, &emptyMap);
// check the entries are as expected
CPPUNIT_ASSERT(emptyMap.type == EMPTY_LIST);
CPPUNIT_ASSERT(emptyMap.group == ENTRY_32);
// CPPUNIT_ASSERT( emptyMap.fbo == 1 );
// CPPUNIT_ASSERT( emptyMap.entry == 31 ); // points to last entry in sub-block
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_16, 8, &emptyMap);
// check the entries are as expected
CPPUNIT_ASSERT(emptyMap.type == EMPTY_LIST);
CPPUNIT_ASSERT(emptyMap.group == ENTRY_16);
// printf("UT: fbo: %llu sbid: %i entry: %i\n", emptyMap.fbo, (unsigned int)emptyMap.sbid,
// (unsigned int)emptyMap.entry);
CPPUNIT_ASSERT(emptyMap.fbo == 0);
CPPUNIT_ASSERT(emptyMap.entry == 0);
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_8, 8, &emptyMap);
// check the entries are as expected
CPPUNIT_ASSERT(emptyMap.type == EMPTY_LIST);
CPPUNIT_ASSERT(emptyMap.group == ENTRY_8);
CPPUNIT_ASSERT(emptyMap.fbo == 0);
CPPUNIT_ASSERT(emptyMap.entry == 0);
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_4, 8, &emptyMap);
// check the entries are as expected
CPPUNIT_ASSERT(emptyMap.type == EMPTY_LIST);
CPPUNIT_ASSERT(emptyMap.group == ENTRY_4);
CPPUNIT_ASSERT(emptyMap.fbo == 0);
CPPUNIT_ASSERT(emptyMap.entry == 0);
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_2, 8, &emptyMap);
// check the entries are as expected
CPPUNIT_ASSERT(emptyMap.type == EMPTY_LIST);
CPPUNIT_ASSERT(emptyMap.group == ENTRY_2);
CPPUNIT_ASSERT(emptyMap.fbo == 0);
CPPUNIT_ASSERT(emptyMap.entry == 0);
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_1, 8, &emptyMap);
// check the entries are as expected
CPPUNIT_ASSERT(emptyMap.type == EMPTY_LIST);
CPPUNIT_ASSERT(emptyMap.group == ENTRY_1);
CPPUNIT_ASSERT(emptyMap.fbo == 0);
CPPUNIT_ASSERT(emptyMap.entry == 0);
// assign a segment and check that entries in sb0 change
printf("UT: Init: Assign ENTRY_32 fbo: %llu sbid: %i entry: %i\n", assignPtr.fbo,
(unsigned int)assignPtr.sbid, (unsigned int)assignPtr.entry);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_32, &assignPtr) == NO_ERROR);
CPPUNIT_ASSERT(assignPtr.entry == 0); // points to start of sub-block
// CPPUNIT_ASSERT( assignPtr.fbo == 1 ); //
CPPUNIT_ASSERT(assignPtr.group == ENTRY_32);
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_32, 8, &emptyMap);
CPPUNIT_ASSERT(emptyMap.type == EMPTY_LIST);
CPPUNIT_ASSERT(emptyMap.group == ENTRY_32);
// CPPUNIT_ASSERT( emptyMap.fbo == 1 );
// CPPUNIT_ASSERT( emptyMap.entry == 30 ); // points to second to last entry in sub-block
// release segment and see if head pointer moves
rc = m_freeMgr.releaseSegment(cb, &blockZero, TREE, ENTRY_32, &assignPtr);
CPPUNIT_ASSERT(rc == NO_ERROR);
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_32, 8, &emptyMap);
CPPUNIT_ASSERT(emptyMap.type == EMPTY_LIST);
CPPUNIT_ASSERT(emptyMap.group == ENTRY_32);
// CPPUNIT_ASSERT( emptyMap.fbo == 1 );
// CPPUNIT_ASSERT( emptyMap.sbid == 31 );
// CPPUNIT_ASSERT( emptyMap.entry == 31 ); // points to last entry in sub-block
// release to wrong list
printf("UT: Put sub-block segment on list of 16 (expect error)\n");
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, TREE, ENTRY_16, &assignPtr) ==
ERR_FM_RELEASE_ERR);
// tweak type then try to release
// printf("UT: Release EMPTY_LIST entry\n");
// assignPtr.type = EMPTY_LIST;
// CPPUNIT_ASSERT( freeMgr.releaseSegment( cb, &blockZero, TREE, ENTRY_16, &assignPtr ) ==
// ERR_FM_BAD_TYPE );
printf("UT: assign ENTRY_16 segment\n");
// assign ENTRY_16 segment
CPPUNIT_ASSERT_MESSAGE("Failed assigning ENTRY_16 segment",
m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_16, &assignPtr) == NO_ERROR);
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_16, 8, &emptyMap);
CPPUNIT_ASSERT_MESSAGE("Empty map type should be EMPTY_LIST", emptyMap.type == EMPTY_LIST);
CPPUNIT_ASSERT(emptyMap.group == ENTRY_16);
// CPPUNIT_ASSERT( emptyMap.fbo == 1 );
// CPPUNIT_ASSERT( emptyMap.sbid == 0 );
// CPPUNIT_ASSERT( emptyMap.entry == 1 ); // points to last entry in sub-block
// release ENTRY_16 segment
printf("UT: Release ENTRY_16 segment\n");
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, TREE, ENTRY_16, &assignPtr) == NO_ERROR);
// legal segment size but list is empty - causes list to be populated
printf("UT: Assign from ENTRY_4 list - which is empty\n");
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_4, &assignPtr) == NO_ERROR);
printf("UT: After Assign ENTRY_4 fbo: %llu sbid: %i entry: %i\n", assignPtr.fbo,
(unsigned int)assignPtr.sbid, (unsigned int)assignPtr.entry);
// Check ENTRY_4 in map
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_4, 8, &emptyMap);
printf("UT: fbo: %llu sbid: %i entry: %i\n", emptyMap.fbo, (unsigned int)emptyMap.sbid,
(unsigned int)emptyMap.entry);
// ENTRY_4 segment size
printf("UT: Assign from ENTRY_4 list - which is no longer empty\n");
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_4, &assignPtr) == NO_ERROR);
printf("UT: Assign from ENTRY_4 fbo: %llu sbid: %i entry: %i\n", assignPtr.fbo,
(unsigned int)assignPtr.sbid, (unsigned int)assignPtr.entry);
// cleanup
m_freeMgr.writeDBFile(indexFile, blockZero.data, lbid);
m_freeMgr.closeFile(indexFile);
}
// list tests
void testFreeMgrInit2()
{
FILE* indexFile;
CommBlock cb;
DataBlock blockZero;
IdxEmptyListEntry emptyMap, assignPtr;
int allocSize, rc;
uint64_t lbid;
m_freeMgr.setDebugLevel(DEBUG_0);
printf("\nUT: Begin testFreeMgrInit2\n");
assignPtr.fbo = 0;
assignPtr.sbid = 0;
assignPtr.entry = 0;
assignPtr.type = 0;
m_freeMgr.deleteFile(776);
rc = m_freeMgr.createFile(776, 80, allocSize);
CPPUNIT_ASSERT(rc == NO_ERROR);
cb.file.pFile = m_freeMgr.openFile(776);
cb.file.oid = 776;
indexFile = cb.file.pFile;
CPPUNIT_ASSERT(m_freeMgr.init(cb, LIST) == NO_ERROR);
lbid = m_freeMgr.mapLBID(cb, 0, rc);
CPPUNIT_ASSERT_MESSAGE("Error using mapLBID", rc == NO_ERROR);
m_freeMgr.readSubBlockEntry(cb, &blockZero, lbid, 0, 1 + ENTRY_BLK, 8, &emptyMap);
// check the entries are as expected
printf("UT: fbo: %llu sbid: %i entry: %i\n", emptyMap.fbo, (unsigned int)emptyMap.sbid,
(unsigned int)emptyMap.entry);
CPPUNIT_ASSERT(emptyMap.type == EMPTY_LIST);
CPPUNIT_ASSERT(emptyMap.group == ENTRY_BLK);
CPPUNIT_ASSERT(emptyMap.fbo != 0);
// CPPUNIT_ASSERT( emptyMap.entry == 31 ); // points to last entry in sub-block
// assign a segment and check that entries in sb0 change
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, LIST, ENTRY_BLK, &assignPtr) == NO_ERROR);
CPPUNIT_ASSERT(assignPtr.group == ENTRY_BLK); // right group
// CPPUNIT_ASSERT( assignPtr.entry == 0 ); // right position
// CPPUNIT_ASSERT( assignPtr.sbid == 31 ); // right position
// CPPUNIT_ASSERT( assignPtr.fbo == 1 ); // right block
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_BLK, 8, &emptyMap);
CPPUNIT_ASSERT(emptyMap.type == EMPTY_LIST);
CPPUNIT_ASSERT(emptyMap.group == ENTRY_BLK);
// CPPUNIT_ASSERT( emptyMap.fbo == 1 );
// CPPUNIT_ASSERT( emptyMap.sbid == 0 );
// CPPUNIT_ASSERT( emptyMap.entry == 30 ); // points to second to last entry in sub-block
// illegal segment size
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, LIST, ENTRY_16, &assignPtr) == ERR_INVALID_PARAM);
// illegal segment size
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, LIST, ENTRY_8, &assignPtr) == ERR_INVALID_PARAM);
// illegal segment size
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, LIST, ENTRY_2, &assignPtr) == ERR_INVALID_PARAM);
// illegal segment size
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, LIST, ENTRY_1, &assignPtr) == ERR_INVALID_PARAM);
// legal segment size but list is empty
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, LIST, ENTRY_4, &assignPtr) == NO_ERROR);
CPPUNIT_ASSERT(assignPtr.group == ENTRY_4); // points to start of sub-block
CPPUNIT_ASSERT(assignPtr.entry == 28);
// CPPUNIT_ASSERT( assignPtr.sbid == 29 );
// CPPUNIT_ASSERT( assignPtr.fbo == 1 );
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_4, 8, &emptyMap);
CPPUNIT_ASSERT(emptyMap.type == EMPTY_LIST);
CPPUNIT_ASSERT(emptyMap.group == ENTRY_4);
// CPPUNIT_ASSERT( emptyMap.fbo == 1 );
// CPPUNIT_ASSERT( emptyMap.sbid == 30 );
CPPUNIT_ASSERT(emptyMap.entry == 7); // eight segments in list
// CPPUNIT_ASSERT( emptyMap.entry == 31 ); // 32 segments if using blocks for buckets
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, LIST, ENTRY_4, &assignPtr) == NO_ERROR);
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_4, 8, &emptyMap);
CPPUNIT_ASSERT(emptyMap.type == EMPTY_LIST);
CPPUNIT_ASSERT(emptyMap.group == ENTRY_4);
// CPPUNIT_ASSERT( emptyMap.fbo == 1 );
// CPPUNIT_ASSERT( emptyMap.sbid == 30 );
CPPUNIT_ASSERT(emptyMap.entry == 8); // eight segments in list
// CPPUNIT_ASSERT( (int)emptyMap.entry == 32 ); // 32 segments if using blocks for buckets
m_freeMgr.writeDBFile(cb, blockZero.data, lbid);
m_freeMgr.closeFile(indexFile);
}
void testFreeMgrAssign()
{
/**
* Assign tests
*/
FILE* indexFile;
CommBlock cb;
DataBlock blockZero;
IdxEmptyListEntry assignPtr, assignPtr2;
IdxEmptyListEntry assignPtr3, assignPtr4;
IdxEmptyListEntry emptyMap;
int idx, result;
int allocSize, rc;
IdxEmptyListEntry entries[1500];
m_freeMgr.setDebugLevel(DEBUG_0);
printf("\nUT: Begin testFreeMgrAssign\n");
m_freeMgr.deleteFile(777);
rc = m_freeMgr.createFile(777, 8, allocSize);
CPPUNIT_ASSERT(rc == NO_ERROR);
cb.file.pFile = m_freeMgr.openFile(777);
cb.file.oid = 777;
indexFile = cb.file.pFile;
CPPUNIT_ASSERT(m_freeMgr.init(cb, TREE) == NO_ERROR);
/* m_freeMgr.readDBFile( indexFile, blockZero.data, 0 );
m_index.printMemSubBlock( &blockZero , 0 );*/
uint64_t lbid = m_freeMgr.mapLBID(cb, 0, rc);
CPPUNIT_ASSERT_MESSAGE("Error using mapLBID", rc == NO_ERROR);
m_freeMgr.readDBFile(indexFile, blockZero.data, lbid);
// m_index.printMemSubBlock( &blockZero , 0 );
printf("\nUT: Cont testFreeMgrAssign\n");
// CPPUNIT_ASSERT( m_freeMgr.assignSegment( cb, 0, TREE, ENTRY_32, &assignPtr ) ==
// ERR_INVALID_PARAM ); CPPUNIT_ASSERT( m_freeMgr.assignSegment( cb, &blockZero, TREE, ENTRY_32, 0
// ) == ERR_INVALID_PARAM ); CPPUNIT_ASSERT( m_freeMgr.assignSegment( cb, &blockZero, 1234,
// ENTRY_32, &assignPtr ) == ERR_INVALID_PARAM );
// Assign a segment
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_32, &assignPtr) == NO_ERROR);
// Assign a second segment and make sure that we get different pointers
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_32, &assignPtr2) == NO_ERROR);
printf("UT: sbid: %i sbid2: %i\n", (unsigned int)assignPtr.sbid, (unsigned int)assignPtr2.sbid);
CPPUNIT_ASSERT(assignPtr.sbid != assignPtr2.sbid); // assigned from sb list so cannot have same sbid
CPPUNIT_ASSERT(assignPtr.type = EMPTY_PTR);
CPPUNIT_ASSERT(assignPtr2.type = EMPTY_PTR);
// release in 'wrong' order ..
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, TREE, ENTRY_32, &assignPtr) == NO_ERROR);
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, TREE, ENTRY_32, &assignPtr2) == NO_ERROR);
// .. then check that the list issues them in the return order
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_32, &assignPtr3) == NO_ERROR);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_32, &assignPtr4) == NO_ERROR);
// CPPUNIT_ASSERT( assignPtr2.sbid == assignPtr3.sbid);
// CPPUNIT_ASSERT( assignPtr.sbid == assignPtr4.sbid);
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, TREE, ENTRY_32, &assignPtr3) == NO_ERROR);
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, TREE, ENTRY_32, &assignPtr4) == NO_ERROR);
// assign lots of sub-blocks
printf("UT: Assign lots of sub-blocks\n");
for (idx = 0; idx < 39; idx++)
{
// printf("UT: Visit: %i\n", idx);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_32, &entries[idx]) == NO_ERROR);
printf("UT: Visit: %03i fbo: %llu sbid: %02i entry: %02i in 'Assign lots of sub-blocks, assigning'\n",
idx, entries[idx].fbo, (unsigned int)(entries[idx].sbid), (unsigned int)(entries[idx].entry));
}
printf("UT: Releasing\n");
for (idx--; idx > -1; idx--)
{
// printf("UT: Visit: %i\n", idx);
printf("UT: Visit: %03i fbo: %llu sbid: %02i entry: %02i in 'Assign lots of sub-blocks, releasing'\n",
idx, entries[idx].fbo, (unsigned int)(entries[idx].sbid), (unsigned int)(entries[idx].entry));
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, TREE, ENTRY_32, &entries[idx]) == NO_ERROR);
}
for (idx = 0; idx < 39; idx++)
{
// printf("UT: Visit: %i\n", idx);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_32, &entries[idx]) == NO_ERROR);
printf("UT: Visit: %03i fbo: %llu sbid: %02i entry: %02i in 'Assign lots of sub-blocks, assigning'\n",
idx, entries[idx].fbo, (unsigned int)entries[idx].sbid, (unsigned int)entries[idx].entry);
}
// assign lots of smaller segments
printf("UT: Assign lots of smaller segments\n");
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_16, &assignPtr) == NO_ERROR);
printf("UT: fbo: %llu sbid: %i entry: %i \n", assignPtr.fbo, (unsigned int)assignPtr.sbid,
(unsigned int)assignPtr.entry);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_16, &assignPtr) == NO_ERROR);
printf("UT: fbo: %llu sbid: %i entry: %i \n", assignPtr.fbo, (unsigned int)assignPtr.sbid,
(unsigned int)assignPtr.entry);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_16, &assignPtr) == NO_ERROR);
printf("UT: fbo: %llu sbid: %i entry: %i \n", assignPtr.fbo, (unsigned int)assignPtr.sbid,
(unsigned int)assignPtr.entry);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_16, &assignPtr) == NO_ERROR);
printf("UT: fbo: %llu sbid: %i entry: %i \n", assignPtr.fbo, (unsigned int)assignPtr.sbid,
(unsigned int)assignPtr.entry);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_8, &assignPtr) == NO_ERROR);
printf("UT: fbo: %llu sbid: %i entry: %i \n", assignPtr.fbo, (unsigned int)assignPtr.sbid,
(unsigned int)assignPtr.entry);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_8, &assignPtr) == NO_ERROR);
printf("UT: fbo: %llu sbid: %i entry: %i \n", assignPtr.fbo, (unsigned int)assignPtr.sbid,
(unsigned int)assignPtr.entry);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_8, &assignPtr) == NO_ERROR);
printf("UT: fbo: %llu sbid: %i entry: %i \n", assignPtr.fbo, (unsigned int)assignPtr.sbid,
(unsigned int)assignPtr.entry);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_8, &assignPtr) == NO_ERROR);
printf("UT: fbo: %llu sbid: %i entry: %i \n", assignPtr.fbo, (unsigned int)assignPtr.sbid,
(unsigned int)assignPtr.entry);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_4, &assignPtr) == NO_ERROR);
printf("UT: fbo: %llu sbid: %i entry: %i \n", assignPtr.fbo, (unsigned int)assignPtr.sbid,
(unsigned int)assignPtr.entry);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_2, &assignPtr) == NO_ERROR);
printf("UT: fbo: %llu sbid: %i entry: %i \n", assignPtr.fbo, (unsigned int)assignPtr.sbid,
(unsigned int)assignPtr.entry);
printf("UT: Assign lots of segments after init\n");
CPPUNIT_ASSERT(m_freeMgr.init(cb, TREE) == NO_ERROR);
lbid = m_freeMgr.mapLBID(cb, 0, rc);
CPPUNIT_ASSERT_MESSAGE("Error using mapLBID", rc == NO_ERROR);
m_freeMgr.readDBFile(indexFile, blockZero.data, lbid);
// use up 32 entries
// assign more than 32 entries, keeping track of them all, then release them causing the chain to extend
// over two blocks
printf("UT: Assign more than 32 segments\n");
for (idx = 0; idx < 39; idx++)
{
// printf("UT: Visit: %i\n", idx);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_4, &entries[idx]) == NO_ERROR);
printf("UT: Visit: %i fbo: %llu sbid: %i entry: %i in 'Assign more than 32 segments'\n", idx,
entries[idx].fbo, (unsigned int)entries[idx].sbid, (unsigned int)entries[idx].entry);
}
printf("UT: Releasing\n");
for (idx--; idx > -1; idx--)
{
// printf("UT: Visit: %i\n", idx);
printf("UT: Visit: %i fbo: %llu sbid: %i entry: %i in 'Assign more than 32 segments, releasing'\n",
idx, entries[idx].fbo, (unsigned int)entries[idx].sbid, (unsigned int)entries[idx].entry);
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, TREE, ENTRY_4, &entries[idx]) == NO_ERROR);
}
for (idx = 0; idx < 39; idx++)
{
// printf("UT: Visit: %i\n", idx);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_4, &entries[idx]) == NO_ERROR);
printf("UT: Visit: %i fbo: %llu sbid: %i entry: %i in 'Assign more than 32 segments'\n", idx,
entries[idx].fbo, (unsigned int)entries[idx].sbid, (unsigned int)entries[idx].entry);
}
// commmenting this next bit breaks things
// CPPUNIT_ASSERT( freeMgr.init( indexFile, TREE ) == NO_ERROR );
// dbFileOp.readDBFile( indexFile, blockZero.data, 0 );
printf("UT: Use almost all free space\n");
for (idx = 0; idx < 215; idx++)
{
result = m_freeMgr.assignSegment(cb, &blockZero, LIST, ENTRY_32, &assignPtr);
printf("UT: Visit: %i fbo: %llu sbid: %i entry: %i, result = %i\n", idx, assignPtr.fbo,
(unsigned int)assignPtr.sbid, (unsigned int)assignPtr.entry, result);
CPPUNIT_ASSERT(result == NO_ERROR);
}
// assign one more than is available, expect error
CPPUNIT_ASSERT((result = m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_32, &assignPtr2)) !=
ERR_FM_NO_SPACE);
// release last assigned segment
CPPUNIT_ASSERT((result = m_freeMgr.releaseSegment(cb, &blockZero, TREE, ENTRY_32, &assignPtr)) ==
NO_ERROR);
// assign segment, expect no error
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_32, &assignPtr) == NO_ERROR);
// assign segment after using up the list
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_32, &assignPtr2) != ERR_FM_NO_SPACE);
// release the segment, expect to become first bucket
printf("UT: Putting sub-block back\n");
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, TREE, ENTRY_32, &assignPtr) == NO_ERROR);
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_32, 8, &emptyMap);
printf("UT: After putting one sb back fbo: %llu sbid: %i entry: %i\n", emptyMap.fbo,
(unsigned int)emptyMap.sbid, (unsigned int)emptyMap.entry);
CPPUNIT_ASSERT(emptyMap.type == EMPTY_LIST);
CPPUNIT_ASSERT(emptyMap.group == ENTRY_32);
// CPPUNIT_ASSERT( emptyMap.fbo == 7 );
// CPPUNIT_ASSERT( emptyMap.sbid == 0 );
// CPPUNIT_ASSERT( emptyMap.entry == 1 ); // points to second to last entry in sub-block
printf("UT: Request space after using all space\n");
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_16, &assignPtr) != ERR_FM_NO_SPACE);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_8, &assignPtr) != ERR_FM_NO_SPACE);
// CPPUNIT_ASSERT( m_freeMgr.assignSegment( cb, &blockZero, TREE, ENTRY_4, &assignPtr ) ==
// NO_ERROR + 1);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_2, &assignPtr) != ERR_FM_NO_SPACE);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_1, &assignPtr) != ERR_FM_NO_SPACE);
m_freeMgr.writeDBFile(indexFile, blockZero.data, lbid);
m_freeMgr.closeFile(indexFile);
printf("UT: End testFreeMgrAssign\n");
}
void testFreeMgrAssignList()
{
/**
* Assign tests
*/
FILE* indexFile;
DataBlock blockZero;
IdxEmptyListEntry assignPtr, assignPtr2;
IdxEmptyListEntry assignPtr3, assignPtr4;
IdxEmptyListEntry emptyMap;
int rc;
int allocSize;
CommBlock cb;
uint64_t lbid;
m_freeMgr.setDebugLevel(DEBUG_0);
printf("UT: Begin testFreeMgrAssignList\n");
m_freeMgr.deleteFile(777);
rc = m_freeMgr.createFile(777, 8, allocSize);
CPPUNIT_ASSERT(rc == NO_ERROR);
cb.file.pFile = m_freeMgr.openFile(777);
cb.file.oid = 777;
indexFile = cb.file.pFile;
CPPUNIT_ASSERT(m_freeMgr.init(cb, LIST) == NO_ERROR);
lbid = m_freeMgr.mapLBID(cb, 0, rc);
CPPUNIT_ASSERT_MESSAGE("Error using mapLBID", rc == NO_ERROR);
m_freeMgr.readDBFile(cb, blockZero.data, lbid);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, 0, LIST, ENTRY_32, &assignPtr) == ERR_INVALID_PARAM);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, LIST, ENTRY_32, 0) == ERR_INVALID_PARAM);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, 1234, ENTRY_32, &assignPtr) == ERR_INVALID_PARAM);
// Assign a segment
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, LIST, ENTRY_32, &assignPtr) == NO_ERROR);
// Assign a second segment and make sure that we get different pointers
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, LIST, ENTRY_32, &assignPtr2) == NO_ERROR);
printf("UT: sbid: %i sbid2: %i\n", (unsigned int)assignPtr.sbid, (unsigned int)assignPtr2.sbid);
CPPUNIT_ASSERT(assignPtr.sbid != assignPtr2.sbid); // assigned from sb list so cannot have same sbid
CPPUNIT_ASSERT(assignPtr.type = EMPTY_PTR);
CPPUNIT_ASSERT(assignPtr2.type = EMPTY_PTR);
// release in 'wrong' order ..
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, LIST, ENTRY_32, &assignPtr) == NO_ERROR);
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, LIST, ENTRY_32, &assignPtr2) == NO_ERROR);
// .. then check that the list issues them in the return order
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, LIST, ENTRY_32, &assignPtr3) == NO_ERROR);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, LIST, ENTRY_32, &assignPtr4) == NO_ERROR);
// CPPUNIT_ASSERT( assignPtr2.sbid == assignPtr3.sbid);
// CPPUNIT_ASSERT( assignPtr.sbid == assignPtr4.sbid);
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, LIST, ENTRY_32, &assignPtr3) == NO_ERROR);
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, LIST, ENTRY_32, &assignPtr4) == NO_ERROR);
// assign lots of sub-blocks
printf("UT: Assign lots of sub-blocks\n");
int idx;
IdxEmptyListEntry entries[40];
for (idx = 0; idx < 39; idx++)
{
// printf("UT: Visit: %i\n", idx);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, LIST, ENTRY_32, &entries[idx]) == NO_ERROR);
}
printf("UT: Releasing\n");
for (idx--; idx > -1; idx--)
{
// printf("UT: Visit: %i\n", idx);
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, LIST, ENTRY_32, &entries[idx]) == NO_ERROR);
}
for (idx = 0; idx < 39; idx++)
{
// printf("UT: Visit: %i\n", idx);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, LIST, ENTRY_32, &entries[idx]) == NO_ERROR);
}
// assign lots of smaller segments
printf("UT: Assign lots of smaller segments\n");
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, LIST, ENTRY_4, &assignPtr) == NO_ERROR);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, LIST, ENTRY_4, &assignPtr) == NO_ERROR);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, LIST, ENTRY_4, &assignPtr) == NO_ERROR);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, LIST, ENTRY_4, &assignPtr) == NO_ERROR);
printf("UT: Assign lots of segments after init\n");
CPPUNIT_ASSERT(m_freeMgr.init(cb, LIST) == NO_ERROR);
lbid = m_freeMgr.mapLBID(cb, 0, rc);
CPPUNIT_ASSERT_MESSAGE("Error using mapLBID", rc == NO_ERROR);
m_freeMgr.readDBFile(indexFile, blockZero.data, lbid);
// use up 32 entries
// assign more than 32 entries, keeping track of them all, then release them causing the chain to extend
// over two blocks
printf("UT: Assign more than 32 segments\n");
for (idx = 0; idx < 39; idx++)
{
// printf("UT: Visit: %i\n", idx);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, LIST, ENTRY_4, &entries[idx]) == NO_ERROR);
}
printf("UT: Releasing\n");
for (idx--; idx > -1; idx--)
{
// printf("UT: Visit: %i\n", idx);
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, LIST, ENTRY_4, &entries[idx]) == NO_ERROR);
}
for (idx = 0; idx < 39; idx++)
{
// printf("UT: Visit: %i\n", idx);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, LIST, ENTRY_4, &entries[idx]) == NO_ERROR);
}
// printf("UT: sbid: %i entry: %i \n", (unsigned int)entries[idx].sbid, (unsigned int)entries[idx].entry
// );
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, LIST, ENTRY_32, &assignPtr) == NO_ERROR);
printf("UT: sbid: %i entry: %i \n", (unsigned int)assignPtr.sbid, (unsigned int)assignPtr.entry);
// now use up almost all free space
for (idx = 0; idx < 215; idx++)
{
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, LIST, ENTRY_32, &assignPtr) == NO_ERROR);
printf("UT: Visit: %i fbo: %llu sbid: %i entry: %i\n", idx, assignPtr.fbo,
(unsigned int)assignPtr.sbid, (unsigned int)assignPtr.entry);
}
// assign one more than is available, expect error
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, LIST, ENTRY_32, &assignPtr) != ERR_FM_NO_SPACE);
// check empty map
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_32, 8, &emptyMap);
// check the entries are as expected
printf("UT: Empty - fbo: %llu sbid: %i entry: %i\n", emptyMap.fbo, (unsigned int)emptyMap.sbid,
(unsigned int)emptyMap.entry);
CPPUNIT_ASSERT(emptyMap.type == EMPTY_LIST);
CPPUNIT_ASSERT(emptyMap.group == ENTRY_32);
// CPPUNIT_ASSERT( emptyMap.fbo == 7 );
// CPPUNIT_ASSERT( emptyMap.entry == 0 ); // points to last entry in sub-block
// release last assigned segment
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, LIST, ENTRY_16, &assignPtr) ==
ERR_FM_RELEASE_ERR);
assignPtr.group = ENTRY_16;
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, LIST, ENTRY_16, &assignPtr) == ERR_INVALID_PARAM);
assignPtr.group = ENTRY_32;
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, LIST, ENTRY_32, &assignPtr) == NO_ERROR);
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_32, 8, &emptyMap);
// check the entries are as expected
printf("UT: Empty - fbo: %llu sbid: %i entry: %i\n", emptyMap.fbo, (unsigned int)emptyMap.sbid,
(unsigned int)emptyMap.entry);
CPPUNIT_ASSERT(emptyMap.type == EMPTY_LIST);
CPPUNIT_ASSERT(emptyMap.group == ENTRY_32);
// CPPUNIT_ASSERT( emptyMap.fbo == 7 );
// CPPUNIT_ASSERT( emptyMap.entry == 1 ); // points to last entry in sub-block
// assign segment, expect no error
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, LIST, ENTRY_32, &assignPtr) == NO_ERROR);
// assign segment after using up the list
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, LIST, ENTRY_32, &assignPtr2) != ERR_FM_NO_SPACE);
// release the segment, expect to become first bucket
printf("UT: Putting sub-block back\n");
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, LIST, ENTRY_32, &assignPtr) == NO_ERROR);
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_32, 8, &emptyMap);
printf("UT: After putting one sb back fbo: %llu sbid: %i entry: %i\n", emptyMap.fbo,
(unsigned int)emptyMap.sbid, (unsigned int)emptyMap.entry);
CPPUNIT_ASSERT(emptyMap.type == EMPTY_LIST);
CPPUNIT_ASSERT(emptyMap.group == ENTRY_32);
// CPPUNIT_ASSERT( emptyMap.fbo == 7 );
// CPPUNIT_ASSERT( emptyMap.sbid == 0 );
// CPPUNIT_ASSERT( emptyMap.entry == 1 ); // points to second to last entry in sub-block
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, LIST, ENTRY_16, &assignPtr) == ERR_INVALID_PARAM);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, LIST, ENTRY_8, &assignPtr) == ERR_INVALID_PARAM);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, LIST, ENTRY_2, &assignPtr) == ERR_INVALID_PARAM);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, LIST, ENTRY_1, &assignPtr) == ERR_INVALID_PARAM);
m_freeMgr.writeDBFile(cb, blockZero.data, lbid);
m_freeMgr.closeFile(indexFile);
printf("UT: End testFreeMgrAssignList\n");
}
void testFreeMgrAssignListCk()
{
/**
* Assign tests
*/
FILE* indexFile;
CommBlock cb;
int rc, allocSize;
DataBlock blockZero;
int idx;
IdxEmptyListEntry entries[100];
uint64_t lbid;
m_freeMgr.setDebugLevel(DEBUG_0);
printf("UT: Begin testFreeMgrAssignListCk\n");
m_freeMgr.deleteFile(777);
rc = m_freeMgr.createFile(777, 8, allocSize);
CPPUNIT_ASSERT(rc == NO_ERROR);
cb.file.pFile = m_freeMgr.openFile(777);
cb.file.oid = 777;
indexFile = cb.file.pFile;
CPPUNIT_ASSERT(m_freeMgr.init(cb, LIST) == NO_ERROR);
lbid = m_freeMgr.mapLBID(cb, 0, rc);
CPPUNIT_ASSERT_MESSAGE("Error using mapLBID", rc == NO_ERROR);
m_freeMgr.readDBFile(cb, blockZero.data, lbid);
printf("UT: Assign lots of segments\n");
CPPUNIT_ASSERT(m_freeMgr.init(cb, LIST) == NO_ERROR);
m_freeMgr.readDBFile(cb, blockZero.data, lbid);
// use up 32 entries
// assign more than 32 entries, keeping track of them all, then release them causing the chain to extend
// over two blocks
printf("UT: Assign more than 32 segments\n");
for (idx = 0; idx < 39; idx++)
{
// printf("UT: Visit: %i\n", idx);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, LIST, ENTRY_4, &entries[idx]) == NO_ERROR);
printf("UT: Visit: %i fbo: %llu sbid: %i entry: %i\n", idx, entries[idx].fbo,
(unsigned int)entries[idx].sbid, (unsigned int)entries[idx].entry);
}
printf("UT: Releasing segments\n");
for (idx--; idx > -1; idx--)
{
// printf("UT: Visit: %i\n", idx);
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, LIST, ENTRY_4, &entries[idx]) == NO_ERROR);
}
printf("UT: Assign again\n");
for (idx = 0; idx < 39; idx++)
{
// printf("UT: Visit: %i\n", idx);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, LIST, ENTRY_4, &entries[idx]) == NO_ERROR);
printf("UT: Visit: %i fbo: %llu sbid: %i entry: %i\n", idx, entries[idx].fbo,
(unsigned int)entries[idx].sbid, (unsigned int)entries[idx].entry);
}
printf("UT: End testFreeMgrAssignListCk\n");
}
void testFreeMgrAssignListLots()
{
/**
* Assign tests
*/
FILE* indexFile;
DbFileOp dbFileOp;
DataBlock blockZero;
DataBlock tempBlock;
int idx, rc, allocSize;
IdxEmptyListEntry entries[4000];
IdxEmptyListEntry map;
CommBlock cb;
uint64_t lbid;
m_freeMgr.setDebugLevel(DEBUG_0);
printf("UT: Begin testFreeMgrAssignListLots\n");
int freemgr_type = LIST;
m_freeMgr.deleteFile(777);
rc = m_freeMgr.createFile(777, 8, allocSize);
CPPUNIT_ASSERT(rc == NO_ERROR);
cb.file.pFile = m_freeMgr.openFile(777);
cb.file.oid = 777;
indexFile = cb.file.pFile;
CPPUNIT_ASSERT(m_freeMgr.init(cb, freemgr_type) == NO_ERROR);
lbid = m_freeMgr.mapLBID(cb, 0, rc);
CPPUNIT_ASSERT_MESSAGE("Error using mapLBID", rc == NO_ERROR);
m_freeMgr.readDBFile(cb, blockZero.data, lbid);
printf("UT: Assign lots of segments\n");
// use up 32 entries
// assign more than 32 entries, keeping track of them all, then release them causing the chain to extend
// over two blocks
printf("UT: Assign more than 32 segments\n");
int iters = 172;
IdxTreeGroupType entryType = ENTRY_32;
for (idx = 0; idx < iters; idx++)
{
// printf("UT: Visit: %i\n", idx);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, freemgr_type, entryType, &entries[idx]) ==
NO_ERROR);
printf("UT: Visit: %i fbo %llu sbid %02i entry %02i (assigning)\n", idx, entries[idx].fbo,
(unsigned int)entries[idx].sbid, (unsigned int)entries[idx].entry);
rc = m_freeMgr.readDBFile(cb, tempBlock.data, entries[idx].fbo);
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_32, 8, &map);
printf("UT: Map is now: %i fbo %llu sbid %02i entry %02i (assigning)\n", idx, map.fbo,
(unsigned int)map.sbid, (unsigned int)map.entry);
}
printf("UT: Releasing segments\n");
for (idx = 0; idx < iters; idx++)
{
// for (idx=iters-1; idx>-1; idx--){
printf("UT: Visit: %i fbo %llu sbid %02i entry %02i (releasing)\n", idx, entries[idx].fbo,
(unsigned int)entries[idx].sbid, (unsigned int)entries[idx].entry);
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, freemgr_type, entryType, &entries[idx]) ==
NO_ERROR);
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_32, 8, &map);
printf("UT: Map is now: %i fbo %llu sbid %02i entry %02i (releasing)\n", idx, map.fbo,
(unsigned int)map.sbid, (unsigned int)map.entry);
}
printf("UT: Assign again\n");
for (idx = 0; idx < iters; idx++)
{
// printf("UT: Visit: %i\n", idx);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, freemgr_type, entryType, &entries[idx]) ==
NO_ERROR);
printf("UT: Visit: %i fbo %llu sbid %02i entry %02i (assigning again)\n", idx, entries[idx].fbo,
(unsigned int)entries[idx].sbid, (unsigned int)entries[idx].entry);
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_32, 8, &map);
printf("UT: Map is now: %i fbo %llu sbid %02i entry %02i (assigning again)\n", idx, map.fbo,
(unsigned int)map.sbid, (unsigned int)map.entry);
}
// printf("UT: Releasing segments again\n");
//
// for (idx=0; idx<iters; idx++){
// // for (idx=iters-1; idx>-1; idx--){
// printf("UT: Visit: %i fbo %llu sbid %02i entry %02i (releasing again)\n", idx,
// entries[idx].fbo, (unsigned int)entries[idx].sbid, (unsigned int)entries[idx].entry);
// CPPUNIT_ASSERT( m_freeMgr.releaseSegment( cb, &blockZero, freemgr_type, entryType,
// &entries[idx] ) == NO_ERROR ); getSubBlockEntry( &blockZero, 0, 1+ENTRY_32, 8, &map);
// printf("UT: Map is now: %i fbo %llu sbid %02i entry %02i (releasing again )\n", idx,
// map.fbo, (unsigned int)map.sbid, (unsigned int)map.entry);
//
// }
printf("UT: End testFreeMgrAssignListLots\n");
}
void testFreeMgrAssignListBlocks()
{
/**
* Assign tests
*/
FILE* indexFile;
DataBlock blockZero;
int rc, allocSize;
CommBlock cb;
int idx;
IdxEmptyListEntry entries[8000];
uint64_t lbid;
m_freeMgr.setDebugLevel(DEBUG_0);
printf("UT: Begin testFreeMgrAssignListBlocks\n");
m_freeMgr.deleteFile(776);
rc = m_freeMgr.createFile(776, 80, allocSize);
CPPUNIT_ASSERT(rc == NO_ERROR);
cb.file.pFile = m_freeMgr.openFile(776);
cb.file.oid = 776;
indexFile = cb.file.pFile;
CPPUNIT_ASSERT(m_freeMgr.init(cb, LIST) == NO_ERROR);
lbid = m_freeMgr.mapLBID(cb, 0, rc);
CPPUNIT_ASSERT_MESSAGE("Error using mapLBID", rc == NO_ERROR);
m_freeMgr.readDBFile(cb, blockZero.data, lbid);
printf("UT: Assign blocks from list\n");
// use up 32 entries
// assign more than 32 entries, keeping track of them all, then release them causing the chain to extend
// over two blocks
int iters = 77;
IdxTreeGroupType entryType = ENTRY_BLK;
for (idx = 0; idx < iters; idx++)
{
// printf("UT: Visit: %i\n", idx);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, LIST, entryType, &entries[idx]) == NO_ERROR);
printf("UT: Visit: %i fbo %llu sbid %02i entry %02i (assigning)\n", idx, entries[idx].fbo,
(unsigned int)entries[idx].sbid, (unsigned int)entries[idx].entry);
}
printf("UT: Releasing segments\n");
for (idx = 0; idx < iters; idx++)
{
// for (idx=iters-1; idx>-1; idx--){
printf("UT: Visit: %i fbo %llu sbid %02i entry %02i (releasing)\n", idx, entries[idx].fbo,
(unsigned int)entries[idx].sbid, (unsigned int)entries[idx].entry);
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, LIST, entryType, &entries[idx]) == NO_ERROR);
entries[idx].fbo = 0;
}
printf("UT: Assign again\n");
for (idx = 0; idx < iters; idx++)
{
// printf("UT: Visit: %i\n", idx);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, LIST, entryType, &entries[idx]) == NO_ERROR);
printf("UT: Visit: %i fbo: %llu sbid: %02i entry: %02i (assigning again)\n", idx, entries[idx].fbo,
(unsigned int)entries[idx].sbid, (unsigned int)entries[idx].entry);
}
for (idx = 0; idx < iters; idx++)
{
// for (idx=iters-1; idx>-1; idx--){
printf("UT: Visit: %i fbo %llu sbid %02i entry %02i (releasing again)\n", idx, entries[idx].fbo,
(unsigned int)entries[idx].sbid, (unsigned int)entries[idx].entry);
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, LIST, entryType, &entries[idx]) == NO_ERROR);
entries[idx].fbo = 0;
}
printf("UT: End testFreeMgrAssignListBlocks\n");
}
void testFreeMgrAssignListCk2()
{
/**
* Assign tests
*/
FILE* indexFile;
DataBlock blockZero;
int rc, allocSize;
CommBlock cb;
uint64_t lbid;
m_freeMgr.setDebugLevel(DEBUG_0);
printf("UT: Begin testFreeMgrAssignListCk2\n");
m_freeMgr.deleteFile(777);
rc = m_freeMgr.createFile(777, 8, allocSize);
CPPUNIT_ASSERT(rc == NO_ERROR);
cb.file.pFile = m_freeMgr.openFile(777);
cb.file.oid = 777;
indexFile = cb.file.pFile;
CPPUNIT_ASSERT(m_freeMgr.init(cb, TREE) == NO_ERROR);
lbid = m_freeMgr.mapLBID(cb, 0, rc);
CPPUNIT_ASSERT_MESSAGE("Error using mapLBID", rc == NO_ERROR);
m_freeMgr.readDBFile(cb, blockZero.data, lbid);
int idx;
IdxEmptyListEntry e1[3400];
IdxEmptyListEntry e32[3400];
printf("UT: Assign lots of segments\n");
CPPUNIT_ASSERT(m_freeMgr.init(cb, TREE) == NO_ERROR);
lbid = m_freeMgr.mapLBID(cb, 0, rc);
CPPUNIT_ASSERT_MESSAGE("Error using mapLBID", rc == NO_ERROR);
m_freeMgr.readDBFile(cb, blockZero.data, lbid);
// use up 32 entries
// assign more than 32 entries, keeping track of them all, then release them causing the chain to extend
// over two blocks
printf("UT: Assign more than 32 segments\n");
for (idx = 0; idx < 340; idx++)
{
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_1, &e1[idx]) == NO_ERROR);
printf("UT: Visit: %i fbo %llu sbid %i entry %i\n", idx, e1[idx].fbo, (unsigned int)e1[idx].sbid,
(unsigned int)e1[idx].entry);
if (idx % 10 == 0)
{
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_32, &e32[idx]) == NO_ERROR);
}
e1[idx].type = 7;
}
printf("UT: Releasing segments\n");
for (idx = 0; idx < 340; idx++)
{
// printf("UT: Visit: %i\n", idx);
rc = m_freeMgr.releaseSegment(cb, &blockZero, TREE, ENTRY_1, &e1[idx]);
CPPUNIT_ASSERT(rc == NO_ERROR);
if (idx % 10 == 0)
{
rc = m_freeMgr.releaseSegment(cb, &blockZero, TREE, ENTRY_32, &e1[idx]);
}
}
printf("UT: Assign again\n");
for (idx = 0; idx < 340; idx++)
{
rc = m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_1, &e1[idx]);
CPPUNIT_ASSERT(rc == NO_ERROR);
printf("UT: Visit: %i fbo %llu sbid %i entry %i\n", idx, e1[idx].fbo, (unsigned int)e1[idx].sbid,
(unsigned int)e1[idx].entry);
}
printf("UT: Releasing segments\n");
for (idx = 0; idx < 340; idx++)
{
// printf("UT: Visit: %i\n", idx);
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, TREE, ENTRY_1, &e1[idx]) == NO_ERROR);
}
//
printf("UT: End testFreeMgrAssignListCk2\n");
}
void testFreeMgrAssignExtend()
{
/**
* Test the Extend method
**/
FILE* indexFile;
int allocSize;
int rc;
DataBlock blockZero;
CommBlock cb;
uint64_t lbid;
DbFileOp db;
printf("UT: Begin testFreeMgrAssignExtend\n");
m_indexlist.deleteFile(777);
m_freeMgr.setDebugLevel(DEBUG_1);
m_freeMgr.deleteFile(777);
rc = m_freeMgr.createFile(777, 800, allocSize);
CPPUNIT_ASSERT(rc == NO_ERROR);
cb.file.pFile = m_freeMgr.openFile(777);
cb.file.oid = 777;
indexFile = cb.file.pFile;
CPPUNIT_ASSERT(m_freeMgr.init(cb, LIST) == NO_ERROR);
lbid = m_freeMgr.mapLBID(cb, 0, rc);
CPPUNIT_ASSERT_MESSAGE("Error using mapLBID", rc == NO_ERROR);
m_freeMgr.readDBFile(cb, blockZero.data, lbid);
CPPUNIT_ASSERT(m_freeMgr.extendFreespace(cb, &blockZero, LIST) == NO_ERROR);
int currSize = db.getFileSize(indexFile) / BYTE_PER_BLOCK;
lbid = m_freeMgr.mapLBID(cb, currSize - 1, rc);
CPPUNIT_ASSERT_MESSAGE("Error using mapLBID", rc == NO_ERROR);
}
void testFreeMgrExtendLots()
{
/**
* Test the Extend method
**/
FILE* indexFile;
int allocSize;
int idx, rc;
DataBlock blockZero;
CommBlock cb;
uint64_t lbid;
DbFileOp db;
printf("UT: Begin testFreeMgrExtendLots\n");
m_indexlist.deleteFile(777);
m_freeMgr.setDebugLevel(DEBUG_1);
m_freeMgr.deleteFile(777);
rc = m_freeMgr.createFile(777, 800, allocSize);
CPPUNIT_ASSERT(rc == NO_ERROR);
cb.file.pFile = m_freeMgr.openFile(777);
cb.file.oid = 777;
indexFile = cb.file.pFile;
// CPPUNIT_ASSERT( m_freeMgr.init( cb, LIST ) == NO_ERROR );
// lbid = m_freeMgr.mapLBID( cb, 0, rc);
// CPPUNIT_ASSERT_MESSAGE( "Error using mapLBID", rc == NO_ERROR );
m_freeMgr.readDBFile(cb, blockZero.data, lbid);
for (idx = 0; idx < 5; idx++)
{
printf("Loop count: %i\n", idx);
CPPUNIT_ASSERT(m_freeMgr.extendFreespace(cb, &blockZero, LIST) == NO_ERROR);
}
// int currSize = db.getFileSize( indexFile )/BYTE_PER_BLOCK ;
// lbid = m_freeMgr.mapLBID( cb, currSize-1, rc);
// CPPUNIT_ASSERT_MESSAGE( "Error using mapLBID", rc == NO_ERROR );
printf("UT: End testFreeMgrExtendLots\n");
}
void testFreeMgrRelease()
{
FILE* indexFile;
DataBlock blockZero;
IdxEmptyListEntry assignPtr, emptyMap;
CommBlock cb;
int rc, allocSize;
uint64_t lbid;
m_freeMgr.setDebugLevel(DEBUG_0);
printf("UT: Begin testFreeMgrRelease\n");
m_freeMgr.deleteFile(777);
rc = m_freeMgr.createFile(777, 80, allocSize);
CPPUNIT_ASSERT(rc == NO_ERROR);
cb.file.pFile = m_freeMgr.openFile(777);
cb.file.oid = 777;
indexFile = cb.file.pFile;
CPPUNIT_ASSERT(m_freeMgr.init(cb, TREE) == NO_ERROR);
lbid = m_freeMgr.mapLBID(cb, 0, rc);
CPPUNIT_ASSERT_MESSAGE("Error using mapLBID", rc == NO_ERROR);
m_freeMgr.readDBFile(cb, blockZero.data, lbid);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_32, &assignPtr) == NO_ERROR);
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, 0, TREE, ENTRY_32, &assignPtr) == ERR_INVALID_PARAM);
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, TREE, ENTRY_32, 0) == ERR_INVALID_PARAM);
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, TREE, ENTRY_32, &assignPtr) == NO_ERROR);
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_32, 8, &emptyMap);
// check the entries are as expected
CPPUNIT_ASSERT(emptyMap.type == EMPTY_LIST);
CPPUNIT_ASSERT(emptyMap.group == ENTRY_32);
// CPPUNIT_ASSERT( emptyMap.fbo == 1 );
// CPPUNIT_ASSERT( emptyMap.entry == 31 ); // points to last entry in sub-block
// CPPUNIT_ASSERT( m_freeMgr.releaseSegment( cb, &blockZero, TREE, ENTRY_32, &assignPtr ) == NO_ERROR );
m_freeMgr.writeDBFile(cb, blockZero.data, 0);
m_freeMgr.closeFile(indexFile);
printf("UT: End testFreeMgrRelease\n");
}
void testFreeMgrFragment()
{
FILE* indexFile;
CommBlock cb;
int rc, idx, allocSize;
DataBlock blockZero;
IdxEmptyListEntry assignPtr, emptyMap;
// test if possible to split a list of segments and populate smaller lists
m_freeMgr.setDebugLevel(DEBUG_0);
printf("UT: Begin testFreeMgrFragment\n");
m_freeMgr.deleteFile(777);
rc = m_freeMgr.createFile(777, 80, allocSize);
CPPUNIT_ASSERT(rc == NO_ERROR);
cb.file.pFile = m_freeMgr.openFile(777);
cb.file.oid = 777;
indexFile = cb.file.pFile;
CPPUNIT_ASSERT(m_freeMgr.init(cb, TREE) == NO_ERROR);
m_freeMgr.readSubBlockEntry(cb, &blockZero, 0, 0, 1 + ENTRY_1, 8, &emptyMap);
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_32, &assignPtr) == NO_ERROR);
printf("UT: fbo %llu sbid %i entry %i\n", assignPtr.fbo, (unsigned int)assignPtr.sbid,
(unsigned int)assignPtr.entry);
assignPtr.type = EMPTY_PTR;
assignPtr.group = ENTRY_16;
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, TREE, ENTRY_16, &assignPtr) == NO_ERROR);
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_16, 8, &emptyMap);
printf("UT: fbo %llu sbid %i entry %i\n", emptyMap.fbo, (unsigned int)emptyMap.sbid,
(unsigned int)emptyMap.entry);
assignPtr.type = EMPTY_PTR;
assignPtr.group = ENTRY_8;
assignPtr.entry = 16;
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, TREE, ENTRY_8, &assignPtr) == NO_ERROR);
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_8, 8, &emptyMap);
printf("UT: fbo %llu sbid %i entry %i\n", emptyMap.fbo, (unsigned int)emptyMap.sbid,
(unsigned int)emptyMap.entry);
assignPtr.type = EMPTY_PTR;
assignPtr.group = ENTRY_4;
assignPtr.entry = 24;
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, TREE, ENTRY_4, &assignPtr) == NO_ERROR);
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_4, 8, &emptyMap);
printf("UT: fbo %llu sbid %i entry %i\n", emptyMap.fbo, (unsigned int)emptyMap.sbid,
(unsigned int)emptyMap.entry);
assignPtr.type = EMPTY_PTR;
assignPtr.group = ENTRY_2;
assignPtr.entry = 28;
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, TREE, ENTRY_2, &assignPtr) == NO_ERROR);
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_2, 8, &emptyMap);
printf("UT: fbo %llu sbid %i entry %i\n", emptyMap.fbo, (unsigned int)emptyMap.sbid,
(unsigned int)emptyMap.entry);
assignPtr.type = EMPTY_PTR;
assignPtr.group = ENTRY_1;
assignPtr.entry = 30;
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, TREE, ENTRY_1, &assignPtr) == NO_ERROR);
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_1, 8, &emptyMap);
printf("UT: fbo %llu sbid %i entry %i\n", emptyMap.fbo, (unsigned int)emptyMap.sbid,
(unsigned int)emptyMap.entry);
assignPtr.type = EMPTY_PTR;
assignPtr.group = ENTRY_1;
assignPtr.entry = 31;
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, TREE, ENTRY_1, &assignPtr) == NO_ERROR);
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_1, 8, &emptyMap);
// check the entries are as expected
printf("UT: fbo %llu sbid %i entry %i\n", emptyMap.fbo, (unsigned int)emptyMap.sbid,
(unsigned int)emptyMap.entry);
CPPUNIT_ASSERT(emptyMap.type == EMPTY_LIST);
CPPUNIT_ASSERT(emptyMap.group == ENTRY_1);
// CPPUNIT_ASSERT( emptyMap.fbo == 1 );
CPPUNIT_ASSERT(emptyMap.entry == 2); // points to second entry in sub-block
/**
* Now do it many times
**/
for (idx = 0; idx < 185; idx++)
{
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_32, &assignPtr) == NO_ERROR);
// printf("\nVisit: %i\n", idx);
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_32, 8, &emptyMap);
// printf("UT: Chain: %i fbo: %llu sbid: %i entry: %i\n", (unsigned int)assignPtr.group,
// emptyMap.fbo, (unsigned int)emptyMap.sbid, (unsigned int)emptyMap.entry);
assignPtr.type = EMPTY_PTR;
assignPtr.group = ENTRY_16;
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, TREE, ENTRY_16, &assignPtr) == NO_ERROR);
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_16, 8, &emptyMap);
// printf("UT: Chain: %i fbo %llu sbid %i entry %i\n", (unsigned int)assignPtr.group,
// emptyMap.fbo, (unsigned int)emptyMap.sbid, (unsigned int)emptyMap.entry);
assignPtr.type = EMPTY_PTR;
assignPtr.group = ENTRY_8;
assignPtr.entry = 16;
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, TREE, ENTRY_8, &assignPtr) == NO_ERROR);
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_8, 8, &emptyMap);
// printf("UT: Chain: %i ffbo %llu sbid %i entry %i\n", (unsigned int)assignPtr.group,
// emptyMap.fbo, (unsigned int)emptyMap.sbid, (unsigned int)emptyMap.entry);
assignPtr.type = EMPTY_PTR;
assignPtr.group = ENTRY_4;
assignPtr.entry = 24;
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, TREE, ENTRY_4, &assignPtr) == NO_ERROR);
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_4, 8, &emptyMap);
// printf("UT: Chain: %i fbo %llu sbid %i entry %i\n", (unsigned int)assignPtr.group,
// emptyMap.fbo, (unsigned int)emptyMap.sbid, (unsigned int)emptyMap.entry);
assignPtr.type = EMPTY_PTR;
assignPtr.group = ENTRY_2;
assignPtr.entry = 28;
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, TREE, ENTRY_2, &assignPtr) == NO_ERROR);
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_2, 8, &emptyMap);
// printf("UT: Chain: %i fbo %llu sbid %i entry %i\n", (unsigned int)assignPtr.group,
// emptyMap.fbo, (unsigned int)emptyMap.sbid, (unsigned int)emptyMap.entry);
assignPtr.type = EMPTY_PTR;
assignPtr.group = ENTRY_1;
assignPtr.entry = 30;
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, TREE, ENTRY_1, &assignPtr) == NO_ERROR);
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_1, 8, &emptyMap);
// printf("UT: Chain: %i fbo: %llu sbid: %i entry: %i\n", (unsigned int)assignPtr.group,
// emptyMap.fbo, (unsigned int)emptyMap.sbid, (unsigned int)emptyMap.entry);
assignPtr.type = EMPTY_PTR;
assignPtr.group = ENTRY_1;
assignPtr.entry = 31;
CPPUNIT_ASSERT(m_freeMgr.releaseSegment(cb, &blockZero, TREE, ENTRY_1, &assignPtr) == NO_ERROR);
}
// CPPUNIT_ASSERT( m_freeMgr.releaseSegment( cb, &blockZero, TREE, ENTRY_32, &assignPtr ) == NO_ERROR );
m_freeMgr.writeDBFile(indexFile, blockZero.data, 0);
m_freeMgr.closeFile(indexFile);
printf("UT: End testFreeMgrFragment\n");
}
void testFreeMgrChain()
{
FILE* indexFile;
DataBlock blockZero;
IdxEmptyListEntry assignPtr, emptyMap;
int rc, allocSize;
CommBlock cb;
uint64_t lbid;
// test if possible to split a list of segments and populate smaller lists
m_freeMgr.setDebugLevel(DEBUG_0);
printf("UT: Begin testFreeMgrChain\n");
m_freeMgr.deleteFile(777);
rc = m_freeMgr.createFile(777, 80, allocSize);
CPPUNIT_ASSERT(rc == NO_ERROR);
cb.file.pFile = m_freeMgr.openFile(777);
cb.file.oid = 777;
indexFile = cb.file.pFile;
CPPUNIT_ASSERT(m_freeMgr.init(cb, TREE) == NO_ERROR);
lbid = m_freeMgr.mapLBID(cb, 0, rc);
CPPUNIT_ASSERT_MESSAGE("Error using mapLBID", rc == NO_ERROR);
m_freeMgr.readDBFile(cb, blockZero.data, lbid);
/**
* Now do it many times
**/
int idx;
for (idx = 0; idx < 208; idx++)
{
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_32, &assignPtr) == NO_ERROR);
// printf("\nVisit: %i\n", idx);
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_32, 8, &emptyMap);
// printf("UT: ENTRY_32: %i fbo: %llu sbid: %i entry: %i\n", (unsigned int)assignPtr.group,
// emptyMap.fbo, (unsigned int)emptyMap.sbid, (unsigned int)emptyMap.entry);
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_16, 8, &emptyMap);
// printf("UT: ENTRY_16: %i fbo: %llu sbid: %i entry: %i\n", (unsigned int)assignPtr.group,
// emptyMap.fbo, (unsigned int)emptyMap.sbid, (unsigned int)emptyMap.entry);
}
m_freeMgr.deleteFile(777);
rc = m_freeMgr.createFile(777, 10, allocSize);
CPPUNIT_ASSERT(rc == NO_ERROR);
cb.file.pFile = m_freeMgr.openFile(777);
cb.file.oid = 777;
indexFile = cb.file.pFile;
CPPUNIT_ASSERT(m_freeMgr.init(cb, TREE) == NO_ERROR);
lbid = m_freeMgr.mapLBID(cb, 0, rc);
CPPUNIT_ASSERT_MESSAGE("Error using mapLBID", rc == NO_ERROR);
m_freeMgr.readDBFile(cb, blockZero.data, lbid);
printf("UT: Assigning from ENTRY_16 chain\n");
for (idx = 0; idx < 420; idx++)
{
CPPUNIT_ASSERT(m_freeMgr.assignSegment(cb, &blockZero, TREE, ENTRY_16, &assignPtr) == NO_ERROR);
// printf("Visit: %i\n", idx);
m_freeMgr.getSubBlockEntry(&blockZero, 0, 1 + ENTRY_16, 8, &emptyMap);
printf("UT: ENTRY_16: fbo: %llu sbid: %i entry: %i\n", assignPtr.fbo, (unsigned int)assignPtr.sbid,
(unsigned int)assignPtr.entry);
}
m_freeMgr.writeDBFile(cb, blockZero.data, 0);
m_freeMgr.closeFile(indexFile);
printf("UT: End testFreeMgrChain\n");
}
// void testFreeMgrEvil() {
//
// FILE* indexFile;
// int rc, allocSize;
// DataBlock blockZero, workBlock;
// IdxEmptyListEntry assignPtr, emptyPtr, emptyEntry;
// CommBlock cb;
// uint64_t lbid;
//
// /**
// * Forget Google.. be evil
// **/
//
// test if possible to split a list of segments and populate smaller lists
// m_freeMgr.setDebugLevel( DEBUG_0 );
// printf("UT: Begin testFreeMgrEvil\n");
//
//
// m_freeMgr.deleteFile( 777 );
// rc = m_freeMgr.createFile( 777, 80, allocSize );
// CPPUNIT_ASSERT( rc == NO_ERROR );
// cb.file.pFile = m_freeMgr.openFile( 777 );
// cb.file.oid = 777;
// indexFile = cb.file.pFile;
//
// CPPUNIT_ASSERT( m_freeMgr.init( cb, TREE ) == NO_ERROR );
// lbid = m_freeMgr.mapLBID( cb, 0, rc);
// CPPUNIT_ASSERT_MESSAGE( "Error using mapLBID", rc == NO_ERROR );
//
// m_freeMgr.readDBFile( cb, blockZero.data, lbid );
//
// m_freeMgr.getSubBlockEntry( &blockZero, 0, 1+ENTRY_32, 8, &emptyPtr);
//
// check the entries are as expected
// CPPUNIT_ASSERT( emptyPtr.type == EMPTY_LIST );
// CPPUNIT_ASSERT( emptyPtr.group == ENTRY_32 );
// CPPUNIT_ASSERT( emptyPtr.fbo == 1 );
// CPPUNIT_ASSERT( emptyPtr.entry == 31 ); // points to last entry in sub-block
//
// printf("UT: Mess up fbo in emptyMap for ENTRY_32\n");
// emptyPtr.fbo =999999999;
// m_freeMgr.writeSubBlockEntry( cb, &blockZero, 0, 0, 1+ENTRY_32, 8, &emptyPtr);
//
// CPPUNIT_ASSERT( m_freeMgr.assignSegment( cb, &blockZero, TREE, ENTRY_32, &assignPtr ) ==
// ERR_FM_BAD_FBO ); emptyPtr.fbo =7; m_freeMgr.writeSubBlockEntry( cb, &blockZero, 0, 0, 1+ENTRY_32,
// 8, &emptyPtr);
//
// CPPUNIT_ASSERT( m_freeMgr.assignSegment( cb, &blockZero, TREE, ENTRY_32, &assignPtr ) ==
// NO_ERROR );
//
// CPPUNIT_ASSERT( assignPtr.fbo == 7 );
// assignPtr.fbo =1234;
// first release with bad fbo then with good
// CPPUNIT_ASSERT( m_freeMgr.releaseSegment( cb, &blockZero, TREE, ENTRY_32, &assignPtr ) ==
// ERR_FM_BAD_FBO );
//
// assignPtr.fbo =7;
// CPPUNIT_ASSERT( m_freeMgr.releaseSegment( cb, &blockZero, TREE, ENTRY_32, &assignPtr ) ==
// NO_ERROR );
//
//
// printf("UT: Mess up fbo in emptyMap for ENTRY_16\n");
// m_freeMgr.getSubBlockEntry( &blockZero, 0, 1+ENTRY_16, 8, &emptyPtr);
// CPPUNIT_ASSERT( emptyPtr.fbo == 0 ); // zero because nothing in list yet
//
// emptyPtr.fbo =999999999;
// m_freeMgr.writeSubBlockEntry( cb, &blockZero, 0, 0, 1+ENTRY_16, 8, &emptyPtr);
//
// CPPUNIT_ASSERT( m_freeMgr.assignSegment( cb, &blockZero, TREE, ENTRY_16, &assignPtr ) ==
// ERR_FM_BAD_FBO ); emptyPtr.fbo =0; m_freeMgr.writeSubBlockEntry( cb, &blockZero, 0, 0, 1+ENTRY_16,
// 8, &emptyPtr);
//
// CPPUNIT_ASSERT( m_freeMgr.assignSegment( cb, &blockZero, TREE, ENTRY_16, &assignPtr ) == NO_ERROR
// );
//
// CPPUNIT_ASSERT( assignPtr.fbo == 7 );
// assignPtr.fbo =1234;
// first release with bad fbo then with good
// CPPUNIT_ASSERT( m_freeMgr.releaseSegment( cb, &blockZero, TREE, ENTRY_16, &assignPtr ) ==
// ERR_FM_BAD_FBO );
//
// assignPtr.fbo =7;
// CPPUNIT_ASSERT( m_freeMgr.releaseSegment( cb, &blockZero, TREE, ENTRY_16, &assignPtr ) ==
// NO_ERROR );
//
// Mess with type field
// CPPUNIT_ASSERT( m_freeMgr.assignSegment( cb, &blockZero, TREE, ENTRY_16, &assignPtr ) == NO_ERROR
// );
//
// m_freeMgr.getSubBlockEntry( blockZero.data, 0, 1+ENTRY_16, 8, &emptyPtr );
// m_freeMgr.readDBFile( cb, &workBlock, emptyPtr.fbo );
// m_freeMgr.getSubBlockEntry( &workBlock, emptyPtr.sbid, emptyPtr.entry, 8, &emptyEntry );
//
// CPPUNIT_ASSERT( emptyEntry.type == 2 ); //check is EMPTY_PTR
// CPPUNIT_ASSERT( emptyEntry.fbo == 7 ); //check is last sb
// emptyEntry.type = 7; // set to garbage
// m_freeMgr.writeSubBlockEntry( cb, &workBlock, emptyPtr.fbo, emptyPtr.sbid, emptyPtr.entry, 8,
// &emptyEntry); check assign fails CPPUNIT_ASSERT( m_freeMgr.assignSegment( cb, &blockZero, TREE,
// ENTRY_16, &assignPtr ) == ERR_FM_BAD_TYPE );
//
// emptyEntry.type = 2;
// emptyEntry.fbo = 0;
// m_freeMgr.writeSubBlockEntry( cb, &workBlock, emptyPtr.fbo, emptyPtr.sbid, emptyPtr.entry, 8,
// &emptyEntry); check assign fails CPPUNIT_ASSERT( m_freeMgr.assignSegment( cb, &blockZero, TREE,
// ENTRY_16, &assignPtr ) == ERR_FM_BAD_TYPE );
//
//
// fix type field and re-try assign
// emptyEntry.type = 2;
// emptyEntry.fbo = 7;
// m_freeMgr.writeSubBlockEntry( cb, &workBlock, emptyPtr.fbo, emptyPtr.sbid, emptyPtr.entry, 8,
// &emptyEntry); CPPUNIT_ASSERT( m_freeMgr.assignSegment( cb, &blockZero, TREE, ENTRY_16, &assignPtr
// ) == NO_ERROR ); CPPUNIT_ASSERT( m_freeMgr.releaseSegment( cb, &blockZero, TREE, ENTRY_16,
// &assignPtr ) == NO_ERROR );
//
//
// printf("UT: Zero fbo in emptyMap for ENTRY_8\n");
// //start 8 list
// CPPUNIT_ASSERT( m_freeMgr.assignSegment( cb, &blockZero, TREE, ENTRY_8, &assignPtr ) == NO_ERROR
// ); CPPUNIT_ASSERT( m_freeMgr.releaseSegment( cb, &blockZero, TREE, ENTRY_8, &assignPtr ) ==
// NO_ERROR );
//
// m_freeMgr.getSubBlockEntry( &blockZero, 0, 1+ENTRY_8, 8, &emptyPtr);
// CPPUNIT_ASSERT( emptyPtr.fbo == 7 );
// CPPUNIT_ASSERT( emptyPtr.type == 2 );
//
// emptyPtr.fbo = 0;
// m_freeMgr.writeSubBlockEntry( indexFile, &blockZero, 0, 0, 1+ENTRY_8, 8, &emptyPtr);
//
// CPPUNIT_ASSERT( m_freeMgr.assignSegment( cb, &blockZero, TREE, ENTRY_8, &assignPtr ) == NO_ERROR
// + 1 );
// //cleanup
// emptyPtr.fbo = 7;
// m_freeMgr.writeSubBlockEntry( indexFile, &blockZero, 0, 0, 1+ENTRY_8, 8, &emptyPtr);
//
// check that assign and release works ok
// CPPUNIT_ASSERT( m_freeMgr.assignSegment( cb, &blockZero, TREE, ENTRY_8, &assignPtr ) == NO_ERROR
// ); CPPUNIT_ASSERT( m_freeMgr.releaseSegment( cb, &blockZero, TREE, ENTRY_8, &assignPtr ) ==
// NO_ERROR );
//
// m_freeMgr.writeDBFile( indexFile, blockZero.data, 0 );
// CPPUNIT_ASSERT( m_freeMgr.init( cb, TREE ) == NO_ERROR );
// m_freeMgr.closeFile( indexFile );
//
// printf("UT: End testFreeMgrEvil\n");
//
// }
void testIndexListMultiKey()
{
DataBlock curBlock;
FILE* pFile = NULL;
int rc, allocSize;
uint64_t key = 0x123;
int rowId;
int file_number = 20000;
int fbo, sbid, entry;
IdxEmptyListEntry newIdxListHdrPtr;
IdxRidListHdr newIdxRidListHdr;
printf("\nRunning multiple keys for adding header \n");
BRMWrapper::setUseBrm(true);
// Then increment the rowId as it goes
rowId = 0x567;
/*******************************************************
* TEST with FreeMgr for coverage
* Start here for add header and delete header entries
*
*******************************************************/
m_indexlist.deleteFile(file_number);
m_indexlist.createFile(file_number, 10, allocSize);
pFile = m_indexlist.openFile(file_number);
CPPUNIT_ASSERT(pFile != NULL);
CommBlock cb;
File file;
file.oid = file_number;
file.pFile = pFile;
cb.file = file;
m_indexlist.init(cb, LIST);
int loop;
for (loop = 0; loop < 10; loop++)
{
rc = m_indexlist.addIndexListHdr(cb, rowId, key, &newIdxListHdrPtr);
if (rc != NO_ERROR)
printf("196. error code:%i \n", rc);
// printf("The fbo is:%i sbid is %i entry is %i \n",(int)newIdxListHdrPtr.fbo,
// (int)newIdxListHdrPtr.sbid, (int)newIdxListHdrPtr.entry);
CPPUNIT_ASSERT(rc == NO_ERROR);
fbo = newIdxListHdrPtr.fbo; // fbo=? from the free manager
sbid = newIdxListHdrPtr.sbid; // sbid =? from the free manager
entry = newIdxListHdrPtr.entry; // entry=? from the free manager
memset(curBlock.data, 0, sizeof(curBlock.data));
rc = m_indexlist.readDBFile(pFile, curBlock.data, fbo);
m_indexlist.getSubBlockEntry(curBlock.data, sbid, entry, LIST_HDR_SIZE, &newIdxRidListHdr);
// cout<< "rowId->" << rowId << " key->" << key << " size->" <<
// newIdxRidListHdr.idxRidListSize.size << endl;
rowId++;
key++;
}
// cout << " \n Successfully ran testIndexListMultiKey \n" << endl;
return;
} // testIndexListMultiKey
void testIndexListUpdate()
{
DataBlock curBlock;
FILE* pFile = NULL;
int rc, fbo, sbid, entry;
uint64_t key = 123;
int count = 40000;
int rowId;
int i;
int file_number = 8001;
IdxEmptyListEntry newIdxListHdrPtr;
IdxRidListHdr newIdxRidListHdr;
// bool found = false;
// int p_sbid, p_entry,
// uint64_t p_fbo;
int allocSize;
BRMWrapper::setUseBrm(true);
printf("\nRunning testIndexListUpdate\n");
memset(curBlock.data, 0, sizeof(curBlock.data));
m_indexlist.deleteFile(file_number);
m_indexlist.createFile(file_number, 10, allocSize);
pFile = m_indexlist.openFile(file_number);
CPPUNIT_ASSERT(pFile != NULL);
// Free Manager
CommBlock cb;
File file;
file.oid = file_number;
file.pFile = pFile;
cb.file = file;
m_indexlist.init(cb, LIST);
// Initialize first rowId to 0
rowId = 0;
rc = m_indexlist.addIndexListHdr(cb, rowId, key, &newIdxListHdrPtr);
if (rc != NO_ERROR)
// printf("245. error code:%i \n", rc);
CPPUNIT_ASSERT(rc == NO_ERROR);
fbo = newIdxListHdrPtr.fbo; // fbo=? from the free manager
sbid = newIdxListHdrPtr.sbid; // sbid =? from the free manager
entry = newIdxListHdrPtr.entry; // entry=? from the free manager
memset(curBlock.data, 0, sizeof(curBlock.data));
rc = m_indexlist.readDBFile(pFile, curBlock.data, fbo);
m_indexlist.getSubBlockEntry(curBlock.data, sbid, entry, LIST_HDR_SIZE, &newIdxRidListHdr);
CPPUNIT_ASSERT(newIdxRidListHdr.idxRidListSize.size == 1);
rowId++;
// cout << " Single Insert->start Timer :inserting " << count << " rowId " << endl;
m_indexlist.startfTimer();
for (i = 0; i < count; i++)
{
////cout << " count number-> " << i << endl;
rc = m_indexlist.updateIndexList(cb, rowId, key, &newIdxListHdrPtr);
if (rc != NO_ERROR)
{
// cout << "error code->" << rc << " i->" << i << endl;
return;
}
rowId++;
}
m_indexlist.stopfTimer();
// cout << " Single Insert ->End Timer :inserting " << count << " rowId " << endl;
// cout << " Total used time (msec) " << m_indexlist.getTotalfRunTime() << endl;
m_indexlist.closeFile(pFile);
//
memset(curBlock.data, 0, sizeof(curBlock.data));
pFile = m_indexlist.openFile(file_number);
CPPUNIT_ASSERT(pFile != NULL);
rc = m_indexlist.readDBFile(pFile, curBlock.data, fbo);
m_indexlist.getSubBlockEntry(curBlock.data, sbid, entry, LIST_HDR_SIZE, &newIdxRidListHdr);
// cout<< " key->" << key << " size->" <<
// newIdxRidListHdr.idxRidListSize.size << endl;
CPPUNIT_ASSERT(newIdxRidListHdr.idxRidListSize.size == (uint64_t)(count + 1));
RID ridArray[count + 1];
int size;
m_indexlist.getRIDArrayFromListHdr(pFile, key, &newIdxListHdrPtr, ridArray, size);
CPPUNIT_ASSERT(newIdxRidListHdr.idxRidListSize.size == (uint64_t)size);
// cout << "size=" << size << endl;
// cout << " newIdxRidListHdr.idxRidListSize.size=" << newIdxRidListHdr.idxRidListSize.size << endl;
// for (int i=0; i< size ; i++)
////cout<< " ridArray[i]->" << ridArray[i] << " i->" << i << endl;
uint64_t firstLbid;
rc = m_indexlist.findFirstBlk(pFile, key, &newIdxListHdrPtr, firstLbid);
// cout << " Single RID insert->FirstLbid is ->" << firstLbid << endl;
// cout << " This will print level and counts for Children " << endl;
// if (m_indexlist.getUseNarray())
// m_indexlist.printBlocks(firstLbid);
CPPUNIT_ASSERT(rc == NO_ERROR);
m_indexlist.closeFile(pFile);
printf("\nSuccessfully Running testIndexListUpdate\n");
} // testIndexListUpdate
void testIndexListDelete()
{
DataBlock curBlock;
FILE* pFile = NULL;
int rc, fbo, sbid, entry, width = 32, allocSize;
uint64_t key = 123;
int count = 2890;
int rowId;
int i;
int k = count + 1;
int delete_count;
int file_number = 8002;
IdxEmptyListEntry newIdxListHdrPtr;
IdxRidListHdr newIdxRidListHdr;
bool found = false;
int p_sbid, p_entry;
uint64_t p_fbo;
// Initialize first rowId to 0
// Then increment the rowId as it goes
printf("\nRunning testIndexListDelete\n");
rowId = 0;
delete_count = 0;
BRMWrapper::setUseBrm(true);
/*******************************************************
* TEST with FreeMgr for coverage
* Start here for add header and delete header entries
*
*******************************************************/
memset(curBlock.data, 0, sizeof(curBlock.data));
m_indexlist.deleteFile(file_number);
m_indexlist.createFile(file_number, 10, allocSize);
pFile = m_indexlist.openFile(file_number);
CPPUNIT_ASSERT(pFile != NULL);
CommBlock cb;
File file;
file.oid = file_number;
file.pFile = pFile;
cb.file = file;
m_indexlist.init(cb, LIST);
rc = m_indexlist.addIndexListHdr(cb, rowId, key, &newIdxListHdrPtr);
if (rc != NO_ERROR)
// printf("388. error code:%i \n", rc);
CPPUNIT_ASSERT(rc == NO_ERROR);
rowId++;
rc = m_indexlist.deleteIndexList(pFile, 0, key, &newIdxListHdrPtr);
CPPUNIT_ASSERT(rc == NO_ERROR);
delete_count++;
// delete the same item again, should not be there, return an error
rc = m_indexlist.deleteIndexList(pFile, 0, key, &newIdxListHdrPtr);
CPPUNIT_ASSERT(rc != NO_ERROR);
// delete an rowId which does not exist in the index list
// return a error
rc = m_indexlist.deleteIndexList(pFile, 1, key, &newIdxListHdrPtr);
CPPUNIT_ASSERT(rc != NO_ERROR);
//
rc = m_indexlist.updateIndexList(pFile, 5, key, &newIdxListHdrPtr);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_indexlist.updateIndexList(pFile, 6, key, &newIdxListHdrPtr);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_indexlist.deleteIndexList(pFile, 5, key, &newIdxListHdrPtr);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_indexlist.deleteIndexList(pFile, 6, key, &newIdxListHdrPtr);
CPPUNIT_ASSERT(rc == NO_ERROR);
fbo = newIdxListHdrPtr.fbo; // fbo=? from free manager
sbid = newIdxListHdrPtr.sbid; // sbid =?
entry = newIdxListHdrPtr.entry; // entry=?
// printf("Index List Header: fbo: %i sbid: %i entry: %i\n", (int)fbo, (int)sbid, (int)entry);
m_indexlist.closeFile(pFile);
// Reading the Header out
memset(curBlock.data, 0, sizeof(curBlock.data));
pFile = m_indexlist.openFile(file_number);
CPPUNIT_ASSERT(pFile != NULL);
rc = m_indexlist.readDBFile(pFile, curBlock.data, fbo);
m_indexlist.getSubBlockEntry(curBlock.data, sbid, entry, 32, &newIdxRidListHdr);
CPPUNIT_ASSERT(newIdxRidListHdr.idxRidListSize.size == 0);
CPPUNIT_ASSERT(newIdxRidListHdr.idxRidListSize.type == 0);
CPPUNIT_ASSERT(newIdxRidListHdr.key == key);
CPPUNIT_ASSERT(newIdxRidListHdr.firstIdxRidListEntry.type == 7);
CPPUNIT_ASSERT(newIdxRidListHdr.firstIdxRidListEntry.rid == (RID)0);
CPPUNIT_ASSERT(newIdxRidListHdr.nextIdxRidListPtr.type == 7);
CPPUNIT_ASSERT(newIdxRidListHdr.nextIdxRidListPtr.llp == 0x0);
m_indexlist.closeFile(pFile);
// Add Header again and also Update the index list
rowId = 0;
delete_count = 0;
//
memset(curBlock.data, 0, sizeof(curBlock.data));
m_indexlist.deleteFile(file_number);
m_indexlist.createFile(file_number, 10, allocSize);
pFile = m_indexlist.openFile(file_number);
CPPUNIT_ASSERT(pFile != NULL);
file.oid = file_number;
file.pFile = pFile;
cb.file = file;
m_indexlist.init(cb, LIST);
rc = m_indexlist.addIndexListHdr(pFile, rowId, key, &newIdxListHdrPtr);
found = m_indexlist.findRowId(pFile, rowId, key, &newIdxListHdrPtr, p_fbo, p_sbid, p_entry);
// printf("Find RowId: %i in : fbo: %i sbid: %i entry: %i\n", (int) rowId, (int)p_fbo, (int)p_sbid,
// (int)p_entry); cout << " RowId->" << rowId <<" Fbo->" << p_fbo << " Sbid->" << p_sbid << " Entry->" <<
// p_entry << endl;
rowId++;
CPPUNIT_ASSERT(rc == NO_ERROR);
fbo = newIdxListHdrPtr.fbo; // fbo=? from the free manager
sbid = newIdxListHdrPtr.sbid; // sbid =? from the free manager
entry = newIdxListHdrPtr.entry; // entry=? from the free manager
rc = m_indexlist.readDBFile(pFile, curBlock.data, fbo);
m_indexlist.getSubBlockEntry(curBlock.data, sbid, entry, width, &newIdxRidListHdr);
CPPUNIT_ASSERT(newIdxRidListHdr.idxRidListSize.size == 1);
CPPUNIT_ASSERT(newIdxRidListHdr.idxRidListSize.type == 0);
CPPUNIT_ASSERT(newIdxRidListHdr.key == key);
CPPUNIT_ASSERT(newIdxRidListHdr.firstIdxRidListEntry.rid == (RID)rowId - 1);
CPPUNIT_ASSERT(newIdxRidListHdr.firstIdxRidListEntry.type == 3);
CPPUNIT_ASSERT(newIdxRidListHdr.nextIdxRidListPtr.llp == 0x0);
CPPUNIT_ASSERT(newIdxRidListHdr.nextIdxRidListPtr.type == 7);
for (i = 0; i < count; i++)
{
// printf("Index List Count: i: %i Row Id: %i \n", i, rowId);
rc = m_indexlist.updateIndexList(pFile, rowId, key, &newIdxListHdrPtr);
rowId++;
// if (rc != NO_ERROR)
// printf("ERROR ->2940 i %i \n rowID %i \n", i, rowId);
// CPPUNIT_ASSERT( rc == NO_ERROR );
}
for (i = 0; i < count; i++)
{
found = m_indexlist.findRowId(pFile, i, key, &newIdxListHdrPtr, p_fbo, p_sbid, p_entry);
// printf("Find RowId: %i in : fbo: %i sbid: %i entry: %i\n", (int) rowId, (int)p_fbo, (int)p_sbid,
// (int)p_entry); if (found) cout << " Found RowId->" << i <<" Fbo->" << p_fbo << " Sbid->" << p_sbid <<
// " Entry->" << p_entry << endl; else cout << " Not Found RowId->" << i << endl; Check Header again, we
// need to read the block again since it is changed
}
rc = m_indexlist.readDBFile(pFile, curBlock.data, fbo);
m_indexlist.getSubBlockEntry(curBlock.data, sbid, entry, width, &newIdxRidListHdr);
CPPUNIT_ASSERT(newIdxRidListHdr.idxRidListSize.size == (uint64_t)k);
CPPUNIT_ASSERT(newIdxRidListHdr.idxRidListSize.type == 0);
CPPUNIT_ASSERT(newIdxRidListHdr.key == key);
CPPUNIT_ASSERT(newIdxRidListHdr.firstIdxRidListEntry.rid == (RID)0);
CPPUNIT_ASSERT(newIdxRidListHdr.firstIdxRidListEntry.type == 3);
CPPUNIT_ASSERT(newIdxRidListHdr.nextIdxRidListPtr.type == 4);
// printf("Index List Header: fbo: %i sbid: %i entry: %i\n", (int)fbo, (int)sbid, (int)entry);
m_indexlist.closeFile(pFile);
// Delete test
// Read now
// Check Header
delete_count = 0;
fbo = newIdxListHdrPtr.fbo; // fbo=?
sbid = newIdxListHdrPtr.sbid; // sbid =?
entry = newIdxListHdrPtr.entry; // entry=?
memset(&newIdxRidListHdr, 0, 32);
memset(curBlock.data, 0, sizeof(curBlock.data));
// Delete action
pFile = m_indexlist.openFile(file_number);
CPPUNIT_ASSERT(pFile != NULL);
rc = m_indexlist.deleteIndexList(pFile, 0, key, &newIdxListHdrPtr); // rowId 0 deleted
if (rc == NO_ERROR)
delete_count++;
else
{
// cout << "cannot find rowId->" << 0 << endl;
}
rc = m_indexlist.deleteIndexList(pFile, 100, key, &newIdxListHdrPtr); // rowId 100 deleted
if (rc == NO_ERROR)
delete_count++;
else
{
// cout << "cannot find rowId->" << 100 << endl;
}
rc = m_indexlist.deleteIndexList(pFile, 975, key, &newIdxListHdrPtr); // rowId 975 deleted
if (rc == NO_ERROR)
delete_count++;
else
{
// cout << "cannot find rowId->" << 975 << endl;
}
rc = m_indexlist.deleteIndexList(pFile, 2000, key, &newIdxListHdrPtr); // rowId 2000 deleted
if (rc == NO_ERROR)
delete_count++;
else
{
// cout << "cannot find rowId->" << 2000 << endl;
}
m_indexlist.closeFile(pFile);
// Check Answers Read File at block fbo=0;
memset(curBlock.data, 0, sizeof(curBlock.data));
pFile = m_indexlist.openFile(file_number);
CPPUNIT_ASSERT(pFile != NULL);
rc = m_indexlist.readDBFile(pFile, curBlock.data, fbo);
width = 32;
m_indexlist.getSubBlockEntry(curBlock.data, sbid, entry, width, &newIdxRidListHdr);
k = k - delete_count;
CPPUNIT_ASSERT(newIdxRidListHdr.idxRidListSize.size == (uint64_t)k);
CPPUNIT_ASSERT(newIdxRidListHdr.idxRidListSize.type == 0);
CPPUNIT_ASSERT(newIdxRidListHdr.key == key);
CPPUNIT_ASSERT(newIdxRidListHdr.firstIdxRidListEntry.type == 7);
CPPUNIT_ASSERT(newIdxRidListHdr.firstIdxRidListEntry.rid == 0);
m_indexlist.closeFile(pFile);
printf("\nSuccessfully Running testIndexListDelete\n");
} // testIndexListDelete
void testIndexListReleaseMgrBack()
{
FILE* pFile = NULL;
int rc, allocSize;
int file_number = 8006;
DataBlock BlockZero;
int i;
IdxEmptyListEntry newIdxListHdrPtr;
IdxRidListHdr idxRidListHdr;
int rowId = 0;
int newCnt = 2000;
CommBlock cb;
File file;
file.oid = file_number;
file.pFile = pFile;
cb.file = file;
BRMWrapper::setUseBrm(true);
m_indexlist.init(cb, LIST);
int key = 123;
printf("\nRunning testIndexListReleaseMgrBack\n");
memset(BlockZero.data, 0, sizeof(BlockZero.data));
m_indexlist.deleteFile(file_number);
m_indexlist.createFile(file_number, 10, allocSize);
pFile = m_indexlist.openFile(file_number);
file.oid = file_number;
file.pFile = pFile;
cb.file = file;
CPPUNIT_ASSERT(pFile != NULL);
m_indexlist.init(cb, LIST);
rc = m_indexlist.addIndexListHdr(cb, rowId, key, &newIdxListHdrPtr);
/*
if (rc != NO_ERROR)
{
//cout << "rc -> " << rc << endl;
//cout << "i->"<< i << endl;
//cout << "rowId->" << rowId << endl;
//cout << "key->" << key << endl;
}
*/
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_indexlist.getHdrInfo(&newIdxListHdrPtr, &idxRidListHdr);
// if (rc!= NO_ERROR)
// printf("724. error code:%i \n", rc);
CPPUNIT_ASSERT(rc == NO_ERROR);
rowId++;
rc = m_indexlist.updateIndexList(pFile, rowId, key + 1, &newIdxListHdrPtr);
/*
if (rc != NO_ERROR)
{
//cout << "rc -> " << rc << endl;
//cout << "rowId->" << rowId << endl;
//cout << "key+1->" << key+1 << endl;
}
*/
CPPUNIT_ASSERT(rc != NO_ERROR);
rc = m_indexlist.getHdrInfo(&newIdxListHdrPtr, &idxRidListHdr);
/*
if (rc != NO_ERROR)
{
//cout <<" getHdrInfo has error-> rc " << rc << endl;
}
*/
CPPUNIT_ASSERT(rc == NO_ERROR);
for (i = 0; i < newCnt; i++)
{
rc = m_indexlist.updateIndexList(pFile, rowId, key, &newIdxListHdrPtr);
/*
if (rc != NO_ERROR)
{
//cout <<" updateIndexList has error->" << endl;
//cout << "rc -> " << rc << endl;
//cout << "i->"<< i << endl;
//cout << "rowId->" << rowId << endl;
//cout << "key->" << key << endl;
}
*/
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_indexlist.getHdrInfo(&newIdxListHdrPtr, &idxRidListHdr);
/*
if (rc != NO_ERROR)
{
//cout <<" getHdrInfo has error->" << endl;
//cout << "rc -> " << rc << endl;
//cout << "i->"<< i << endl;
//cout << "rowId->" << rowId << endl;
//cout << "key->" << key << endl;
}
*/
CPPUNIT_ASSERT(rc == NO_ERROR);
rowId++;
}
rowId--;
rc = m_indexlist.getHdrInfo(&newIdxListHdrPtr, &idxRidListHdr);
rc = m_indexlist.deleteIndexList(pFile, rowId, key + 1, &newIdxListHdrPtr);
CPPUNIT_ASSERT(rc != NO_ERROR);
rc = m_indexlist.getHdrInfo(&newIdxListHdrPtr, &idxRidListHdr);
for (i = newCnt; i >= 0; i--)
{
rc = m_indexlist.deleteIndexList(pFile, rowId, key, &newIdxListHdrPtr);
rc = m_indexlist.getHdrInfo(&newIdxListHdrPtr, &idxRidListHdr);
CPPUNIT_ASSERT(rc == NO_ERROR);
rowId--;
}
rowId++;
for (i = 0; i < newCnt; i++)
{
rc = m_indexlist.updateIndexList(pFile, rowId, key, &newIdxListHdrPtr);
rc = m_indexlist.getHdrInfo(&newIdxListHdrPtr, &idxRidListHdr);
/*
if (rc!=NO_ERROR)
{
//cout << " tindex 3099-> i " << i << " rc " << rc << endl;
}
*/
CPPUNIT_ASSERT(rc == NO_ERROR);
rowId++;
}
m_indexlist.closeFile(pFile);
printf("\nSuccessfully Running testIndexListReleaseMgrBack\n");
return;
}
void testIndexListMultipleAddHdr()
{
DataBlock curBlock;
DataBlock curBlock2;
DataBlock curBlock3;
DataBlock curBlock4;
FILE* pFile = NULL;
int rc, fbo, sbid, entry;
int fbo2, sbid2, entry2;
int fbo3, sbid3, entry3;
int fbo4, sbid4, entry4;
uint64_t key = 1;
uint64_t key2 = 2;
uint64_t key3 = 3;
uint64_t key4 = 4;
int count = 2000;
int i = 0;
int delete_count;
int file_number = 8010;
RID rowIdArray[count + 1];
RID rowIdArray2[count + 1];
RID rowIdArray3[count + 1];
RID rowIdArray4[count + 1];
int j, k, l;
RID rowId;
IdxEmptyListEntry newIdxListHdrPtr;
IdxRidListHdr newIdxRidListHdr;
IdxEmptyListEntry newIdxListHdrPtr2;
IdxRidListHdr newIdxRidListHdr2;
IdxEmptyListEntry newIdxListHdrPtr3;
IdxRidListHdr newIdxRidListHdr3;
IdxEmptyListEntry newIdxListHdrPtr4;
IdxRidListHdr newIdxRidListHdr4;
bool found = false;
int p_sbid, p_entry, allocSize;
uint64_t p_fbo;
BRMWrapper::setUseBrm(true);
m_indexlist.setUseSortFlag(false);
printf("\nRunning testIndexListMultipleAddHdr\n");
delete_count = 0;
memset(curBlock.data, 0, sizeof(curBlock.data));
m_indexlist.deleteFile(file_number);
m_indexlist.createFile(file_number, 10, allocSize);
pFile = m_indexlist.openFile(file_number);
CPPUNIT_ASSERT(pFile != NULL);
CommBlock cb;
File file;
file.oid = file_number;
file.pFile = pFile;
cb.file = file;
m_indexlist.init(cb, LIST);
for (i = 0; i < count + 1; i++)
{
rowIdArray[i] = i;
}
for (j = 0; j < count + 1; j++)
{
rowIdArray2[j] = i;
i++;
}
for (k = 0; k < count + 1; k++)
{
rowIdArray3[k] = i;
i++;
}
for (l = 0; l < count + 1; l++)
{
rowIdArray4[l] = i;
i++;
}
i = count + 1;
// Initialize first rowId to 0
// cout << " start Timer :inserting " << count << " rowId " << endl;
m_indexlist.startfTimer();
int count_size = count + 1;
rc = m_indexlist.addIndexListHdr(cb, &rowIdArray[0], count_size, key, &newIdxListHdrPtr);
rc = m_indexlist.addIndexListHdr(cb, &rowIdArray2[0], count_size, key2, &newIdxListHdrPtr2);
rc = m_indexlist.addIndexListHdr(cb, &rowIdArray3[0], count_size, key3, &newIdxListHdrPtr3);
rc = m_indexlist.addIndexListHdr(cb, &rowIdArray4[0], count_size, key4, &newIdxListHdrPtr4);
m_indexlist.stopfTimer();
// cout << " End Timer :inserting " << count << " rowId " << endl;
// cout << " Total used time (msec) " << m_indexlist.getTotalfRunTime() << endl;
// if (rc!= NO_ERROR)
// printf("245. error code:%i \n", rc);
CPPUNIT_ASSERT(rc == NO_ERROR);
fbo = newIdxListHdrPtr.fbo; // fbo=? from the free manager
sbid = newIdxListHdrPtr.sbid; // sbid =? from the free manager
entry = newIdxListHdrPtr.entry; // entry=? from the free manager
fbo2 = newIdxListHdrPtr2.fbo; // fbo=? from the free manager
sbid2 = newIdxListHdrPtr2.sbid; // sbid =? from the free manager
entry2 = newIdxListHdrPtr2.entry; // entry=? from the free manager
fbo3 = newIdxListHdrPtr3.fbo; // fbo=? from the free manager
sbid3 = newIdxListHdrPtr3.sbid; // sbid =? from the free manager
entry3 = newIdxListHdrPtr3.entry; // entry=? from the free manager
fbo4 = newIdxListHdrPtr4.fbo; // fbo=? from the free manager
sbid4 = newIdxListHdrPtr4.sbid; // sbid =? from the free manager
entry4 = newIdxListHdrPtr4.entry; // entry=? from the free manager
memset(curBlock.data, 0, sizeof(curBlock.data));
memset(curBlock2.data, 0, sizeof(curBlock2.data));
memset(curBlock3.data, 0, sizeof(curBlock.data));
memset(curBlock4.data, 0, sizeof(curBlock2.data));
rc = m_indexlist.readDBFile(pFile, curBlock.data, fbo);
m_indexlist.getSubBlockEntry(curBlock.data, sbid, entry, 32, &newIdxRidListHdr);
RID ridArray[count + 1];
int ridSize;
rc = m_indexlist.getRIDArrayFromListHdr(pFile, key, &newIdxListHdrPtr, ridArray, ridSize);
// cout << "ridSize ->" << ridSize << endl;
CPPUNIT_ASSERT(ridSize == (int)newIdxRidListHdr.idxRidListSize.size);
rc = m_indexlist.readDBFile(pFile, curBlock2.data, fbo2);
m_indexlist.getSubBlockEntry(curBlock2.data, sbid2, entry2, 32, &newIdxRidListHdr2);
RID ridArray2[count + 1];
int ridSize2;
rc = m_indexlist.getRIDArrayFromListHdr(pFile, key2, &newIdxListHdrPtr2, ridArray2, ridSize2);
// cout << "ridSize2 ->" << ridSize2 << endl;
CPPUNIT_ASSERT(ridSize2 == (int)newIdxRidListHdr2.idxRidListSize.size);
rc = m_indexlist.readDBFile(pFile, curBlock3.data, fbo3);
m_indexlist.getSubBlockEntry(curBlock3.data, sbid3, entry3, 32, &newIdxRidListHdr3);
RID ridArray3[count + 1];
int ridSize3;
rc = m_indexlist.getRIDArrayFromListHdr(pFile, key3, &newIdxListHdrPtr3, ridArray3, ridSize3);
// cout << "ridSize3 ->" << ridSize3 << endl;
CPPUNIT_ASSERT(ridSize3 == (int)newIdxRidListHdr3.idxRidListSize.size);
rc = m_indexlist.readDBFile(pFile, curBlock4.data, fbo4);
m_indexlist.getSubBlockEntry(curBlock4.data, sbid4, entry4, 32, &newIdxRidListHdr4);
RID ridArray4[count + 1];
int ridSize4;
rc = m_indexlist.getRIDArrayFromListHdr(pFile, key4, &newIdxListHdrPtr4, ridArray4, ridSize4);
// cout << "ridSize4 ->" << ridSize4 << endl;
CPPUNIT_ASSERT(ridSize4 == (int)newIdxRidListHdr4.idxRidListSize.size);
// m_indexlist.stopTimer();
////cout << " Total used time (sec) " << m_indexlist.getTotalRunTime() << endl;
uint64_t firstLbid;
uint64_t firstLbid2;
uint64_t firstLbid3;
uint64_t firstLbid4;
rc = m_indexlist.findFirstBlk(pFile, key, &newIdxListHdrPtr, firstLbid);
rc = m_indexlist.findFirstBlk(pFile, key2, &newIdxListHdrPtr2, firstLbid2);
rc = m_indexlist.findFirstBlk(pFile, key3, &newIdxListHdrPtr3, firstLbid3);
rc = m_indexlist.findFirstBlk(pFile, key4, &newIdxListHdrPtr4, firstLbid4);
// cout << " Multiple RIDS Header insert->FirstLbid is ->" << firstLbid << endl;
// cout << " Multiple RIDS Header insert->FirstLbid2 is ->" << firstLbid2 << endl;
// cout << " Multiple RIDS Header insert->FirstLbid3 is ->" << firstLbid3 << endl;
// cout << " Multiple RIDS Header insert->FirstLbid4 is ->" << firstLbid4 << endl;
// cout << " This will print level and counts for Children " << endl;
/*
if (m_indexlist.getUseNarray())
{
m_indexlist.printBlocks(firstLbid);
m_indexlist.printBlocks(firstLbid2);
m_indexlist.printBlocks(firstLbid3);
m_indexlist.printBlocks(firstLbid4);
}
*/
CPPUNIT_ASSERT(rc == NO_ERROR);
m_indexlist.closeFile(pFile);
//
memset(curBlock.data, 0, sizeof(curBlock.data));
pFile = m_indexlist.openFile(file_number);
CPPUNIT_ASSERT(pFile != NULL);
/*
rc = m_indexlist.readDBFile( pFile, curBlock.data, fbo );
m_indexlist.getSubBlockEntry( curBlock.data, sbid, entry, 32, &newIdxRidListHdr );
CPPUNIT_ASSERT( newIdxRidListHdr.idxRidListSize.size == (uint64_t)(count+1));
int arraySize=0;
arraySize = newIdxRidListHdr.idxRidListSize.size;
if (arraySize >0)
{
RID ridArray[arraySize];
int ridSize;
rc= m_indexlist.getRIDArrayFromListHdr(pFile,
key,
&newIdxListHdrPtr,
ridArray, ridSize);
//cout << "ridSize->" << ridSize << endl;
CPPUNIT_ASSERT(ridSize==arraySize);
if (rc!= NO_ERROR)
{
printf("ERROR CODE :%i \n", rc);
}
}
*/
// uint64_t p2_fbo ;
// int p2_sbid, p2_entry;
rowId = 0;
int rowId2 = count + 1;
int rowId3 = 2 * (count + 1);
int rowId4 = 3 * (count + 1);
for (i = 0; i < count; i++)
{
found = m_indexlist.findRowId(pFile, rowId, key, &newIdxListHdrPtr, p_fbo, p_sbid, p_entry);
/*
if (!found)
{
printf(" \n Not Found tindex 3659->i %i rowId %i Not Found \n", i, (int)rowId);
}
else
{
//cout << " findRowId-> count in findRowId line 3663-> " << i <<" rowId " << rowId << endl;
//cout << " p_fbo " << p_fbo << " p_sbid " << p_sbid << " p_entry " << p_entry << endl;
}
*/
CPPUNIT_ASSERT(found == true);
/*rc = m_indexlist.deleteIndexList( pFile, rowId,
key, &newIdxListHdrPtr,
p2_fbo, p2_sbid, p2_entry);
*/
// //cout << " deleteIndexList-> p2_fbo " << p2_fbo << " p2_sbid " << p2_sbid << " p2_entry " <<
// p2_entry << endl;
// CPPUNIT_ASSERT( rc == NO_ERROR );
found = m_indexlist.findRowId(pFile, rowId2, key2, &newIdxListHdrPtr2, p_fbo, p_sbid, p_entry);
/*
if (!found)
{
printf(" \n Not Found tindex 3678->i %i rowId2 %i Not Found \n", i, (int)rowId2);
}
else
{
//cout << " findRowId-> count in findRowId line 3682-> " << i <<" rowId2 " << rowId2 << endl;
//cout << " p_fbo " << p_fbo << " p_sbid " << p_sbid << " p_entry " << p_entry << endl;
}
*/
CPPUNIT_ASSERT(found == true);
found = m_indexlist.findRowId(pFile, rowId3, key3, &newIdxListHdrPtr3, p_fbo, p_sbid, p_entry);
/*
if (!found)
{
printf(" \n Not Found tindex 3691->i %i rowId3 %i Not Found \n", i, (int)rowId3);
}
else
{
//cout << " findRowId-> count in findRowId line 3695-> " << i <<" rowId3 " << rowId3 << endl;
//cout << " p_fbo " << p_fbo << " p_sbid " << p_sbid << " p_entry " << p_entry << endl;
}
*/
CPPUNIT_ASSERT(found == true);
found = m_indexlist.findRowId(pFile, rowId4, key4, &newIdxListHdrPtr4, p_fbo, p_sbid, p_entry);
/*
if (!found)
{
printf(" \n Not Found tindex 3704->i %i rowId4 %i Not Found \n", i, (int)rowId4);
}
else
{
//cout << " findRowId-> count in findRowId line 3708-> " << i <<" rowId4 " << rowId4 << endl;
//cout << " p_fbo " << p_fbo << " p_sbid " << p_sbid << " p_entry " << p_entry << endl;
}
*/
CPPUNIT_ASSERT(found == true);
rowId++;
rowId2++;
rowId3++;
rowId4++;
}
/*
rc = m_indexlist.deleteIndexList( pFile, rowId,
key, &newIdxListHdrPtr,
p_fbo, p_sbid, p_entry);
////cout << " p_fbo " << p_fbo << " p_sbid " << p_sbid << " p_entry " << p_entry << endl;
CPPUNIT_ASSERT( rc == NO_ERROR );
m_indexlist.closeFile(pFile);
//
memset( curBlock.data, 0, sizeof(curBlock.data));
pFile= m_indexlist.openFile( file_number );
CPPUNIT_ASSERT( pFile != NULL );
rc = m_indexlist.readDBFile( pFile, curBlock.data, fbo );
m_indexlist.getSubBlockEntry( curBlock.data, sbid, entry, 32, &newIdxRidListHdr );
CPPUNIT_ASSERT( newIdxRidListHdr.idxRidListSize.size == 0 );
*/
m_indexlist.closeFile(pFile);
printf("\nSuccessfully Running testIndexListMultipleAddHdr\n");
} // testIndexListMultipleAddHdr
void testIndexListMultipleUpdate()
{
DataBlock curBlock;
FILE* pFile = NULL;
int rc, fbo, sbid, entry;
uint64_t key = 123;
int count = 10000;
int rowId;
int i;
int delete_count;
int file_number = 8012;
RID rowIdArray[count + 1];
IdxEmptyListEntry newIdxListHdrPtr;
IdxRidListHdr newIdxRidListHdr;
bool found = false;
int p_sbid, p_entry, allocSize;
uint64_t p_fbo;
BRMWrapper::setUseBrm(true);
m_indexlist.setUseSortFlag(false);
printf("\nRunning testIndexListMultipleUpdate\n");
rowId = 0;
delete_count = 0;
memset(curBlock.data, 0, sizeof(curBlock.data));
m_indexlist.deleteFile(file_number);
m_indexlist.createFile(file_number, 10, allocSize);
pFile = m_indexlist.openFile(file_number);
CPPUNIT_ASSERT(pFile != NULL);
// Free Manager
CommBlock cb;
File file;
file.oid = file_number;
file.pFile = pFile;
cb.file = file;
m_indexlist.init(cb, LIST);
for (int i = 0; i < count + 1; i++)
{
rowIdArray[i] = i;
}
rowId = 0;
// Initialize first rowId to 0
rc = m_indexlist.addIndexListHdr(cb, rowId, key, &newIdxListHdrPtr);
/*
if (rc!= NO_ERROR)
printf("245. error code:%i \n", rc);
*/
CPPUNIT_ASSERT(rc == NO_ERROR);
fbo = newIdxListHdrPtr.fbo; // fbo=? from the free manager
sbid = newIdxListHdrPtr.sbid; // sbid =? from the free manager
entry = newIdxListHdrPtr.entry; // entry=? from the free manager
memset(curBlock.data, 0, sizeof(curBlock.data));
rc = m_indexlist.readDBFile(pFile, curBlock.data, fbo);
m_indexlist.getSubBlockEntry(curBlock.data, sbid, entry, 32, &newIdxRidListHdr);
RID ridArray2[count + 5];
int ridSize2;
rc = m_indexlist.getRIDArrayFromListHdr(pFile, key, &newIdxListHdrPtr, ridArray2, ridSize2);
CPPUNIT_ASSERT(ridSize2 == 1);
// Then increment the rowId as it goes
string timeStr;
m_indexlist.startfTimer();
// cout << " line 3571->startTimer for inserting "<< count <<" rowId " << endl;
rc = m_indexlist.updateIndexList(cb, &rowIdArray[1], count, key, &newIdxListHdrPtr);
/*
if (rc != NO_ERROR)
{
printf("rc %i i %i \n", rc, i);
}
*/
m_indexlist.stopfTimer();
// cout << " End Time :inserting "<< count << "rowId " << endl;
// cout << " Total used time (msec) " << m_indexlist.getTotalfRunTime() << endl;
m_indexlist.closeFile(pFile);
//
memset(curBlock.data, 0, sizeof(curBlock.data));
pFile = m_indexlist.openFile(file_number);
CPPUNIT_ASSERT(pFile != NULL);
rc = m_indexlist.readDBFile(pFile, curBlock.data, fbo);
m_indexlist.getSubBlockEntry(curBlock.data, sbid, entry, 32, &newIdxRidListHdr);
// cout << "newIdxRidListHdr.idxRidListSize.size->" << newIdxRidListHdr.idxRidListSize.size << endl;
CPPUNIT_ASSERT(newIdxRidListHdr.idxRidListSize.size == (uint64_t)(count + 1));
// CPPUNIT_ASSERT( newIdxRidListHdr.idxRidListSize.size == (int64_t)ridSize2);
int arraySize = 0;
rowId = 0;
arraySize = newIdxRidListHdr.idxRidListSize.size;
if (arraySize > 0)
{
RID ridArray[arraySize];
int ridSize;
rc = m_indexlist.getRIDArrayFromListHdr(pFile, key, &newIdxListHdrPtr, ridArray, ridSize);
CPPUNIT_ASSERT(ridSize == arraySize);
/*
if (rc!= NO_ERROR)
{
printf("ERROR CODE :%i \n", rc);
}
*/
// for (int i=0; i< ridSize ; i++)
// //cout<< " line 3591->ridArray[i]->" << ridArray[i] << " i->" << i << endl;
}
uint64_t firstLbid;
rc = m_indexlist.findFirstBlk(pFile, key, &newIdxListHdrPtr, firstLbid);
// cout << " Multiple RIDS insert->FirstLbid is ->" << firstLbid << endl;
// cout << " This will print level and counts for Children " << endl;
/*
if (m_indexlist.getUseNarray())
m_indexlist.printBlocks(firstLbid);
*/
uint64_t p2_fbo;
int p2_sbid, p2_entry;
rowId = 0;
for (i = 0; i < count + 1; i++)
{
found = m_indexlist.findRowId(pFile, rowId, key, &newIdxListHdrPtr, p_fbo, p_sbid, p_entry);
/*
if (!found)
{
printf(" tindex 3600->i %i rowId %i Not Found \n", i, rowId);
//return;
}
else
{
////cout << " Found count in findRowId line 3605-> " << i <<" rowId " << rowId << endl;
////cout << " p_fbo " << p_fbo << " p_sbid " << p_sbid << " p_entry " << p_entry << endl;
}
*/
CPPUNIT_ASSERT(found == true);
rc = m_indexlist.deleteIndexList(pFile, rowId, key, &newIdxListHdrPtr, p2_fbo, p2_sbid, p2_entry);
////cout << " p2_fbo " << p2_fbo << " p2_sbid " << p2_sbid << " p2_entry " << p2_entry << endl;
CPPUNIT_ASSERT(rc == NO_ERROR);
rowId++;
}
rc = m_indexlist.deleteIndexList(pFile, rowId, key, &newIdxListHdrPtr, p_fbo, p_sbid, p_entry);
CPPUNIT_ASSERT(rc != NO_ERROR);
m_indexlist.closeFile(pFile);
//
memset(curBlock.data, 0, sizeof(curBlock.data));
pFile = m_indexlist.openFile(file_number);
CPPUNIT_ASSERT(pFile != NULL);
rc = m_indexlist.readDBFile(pFile, curBlock.data, fbo);
m_indexlist.getSubBlockEntry(curBlock.data, sbid, entry, 32, &newIdxRidListHdr);
CPPUNIT_ASSERT(newIdxRidListHdr.idxRidListSize.size == 0);
m_indexlist.closeFile(pFile);
printf("\nSuccessfully Running testIndexListMultipleUpdate\n");
} // testIndexListMultipleUpdate
};
CPPUNIT_TEST_SUITE_REGISTRATION(IndexTest);
#include <cppunit/extensions/TestFactoryRegistry.h>
#include <cppunit/ui/text/TestRunner.h>
int main(int argc, char** argv)
{
CppUnit::TextUi::TestRunner runner;
CppUnit::TestFactoryRegistry& registry = CppUnit::TestFactoryRegistry::getRegistry();
runner.addTest(registry.makeTest());
bool wasSuccessful = runner.run("", false);
return (wasSuccessful ? 0 : 1);
}
View Git Blame Copy Permalink