database/mariadb-columnstore-engine
1
0
Fork 0
mirror of https://github.com/mariadb-corporation/mariadb-columnstore-engine.git synced 2025-11-03 17:13:17 +03:00
Code Activity
Files
a7810f0d3cac7e94cde5eb35485dac0c9eb3f757
mariadb-columnstore-engine/writeengine/index/tindex.cpp
Andrew Hutchings 01446d1e22 Reformat all code to coding standard
2017-10-26 17:18:17 +01:00

4257 lines
164 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