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
6aedf1d0957cf9a3d92d149ff2a57ad6b4f11d75
mariadb-columnstore-engine/writeengine/shared/tshared.cpp
Andrew Hutchings 01446d1e22 Reformat all code to coding standard
2017-10-26 17:18:17 +01:00

1402 lines
47 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. */
// Define __STDC_LIMIT_MACROS so that we can pick up UINT64_MAX from stdint.h
#define __STDC_LIMIT_MACROS 1
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <stdexcept>
#include <stdint.h>
using namespace std;
#include <boost/scoped_ptr.hpp>
using namespace boost;
#include <cppunit/extensions/HelperMacros.h>
#include <we_dbfileop.h>
#include <we_type.h>
#include <we_semop.h>
#include <we_log.h>
#include <we_convertor.h>
#include <we_brm.h>
#include <we_cache.h>
using namespace WriteEngine;
using namespace BRM;
int compare (const void* a, const void* b)
{
return ( *(uint32_t*)a - * (uint32_t*)b );
}
int compare1(const void* a, const void* b)
{
return ( (*(SortTuple*)a).key - (*(SortTuple*)b).key );
}
class SharedTest : public CppUnit::TestFixture
{
CPPUNIT_TEST_SUITE( SharedTest );
//CPPUNIT_TEST(setUp);
//CPPUNIT_TEST( test1 );
// File operation testing
CPPUNIT_TEST( testFileNameOp );
CPPUNIT_TEST( testFileHandleOp );
CPPUNIT_TEST( testDirBasic );
// Data block related testing
CPPUNIT_TEST( testCalculateRowIdBitmap );
CPPUNIT_TEST( testBlockBuffer );
CPPUNIT_TEST( testBitBasic );
CPPUNIT_TEST( testBufferBit );
CPPUNIT_TEST( testBitShift );
CPPUNIT_TEST( testEmptyRowValue );
CPPUNIT_TEST( testCorrectRowWidth );
// DB File Block related testing
CPPUNIT_TEST( testDbBlock );
CPPUNIT_TEST( testCopyDbFile );
// Semaphore related testing
CPPUNIT_TEST( testSem );
// Log related testing
CPPUNIT_TEST( testLog );
// Version Buffer related testing
CPPUNIT_TEST( testHWM );
CPPUNIT_TEST( testVB );
// Disk manager related testing
CPPUNIT_TEST( testDM );
CPPUNIT_TEST( tearDown );
// Cache related testing
CPPUNIT_TEST( testCacheBasic );
CPPUNIT_TEST( testCacheReadWrite );
CPPUNIT_TEST( testCleanup ); // NEVER COMMENT OUT THIS LINE
CPPUNIT_TEST_SUITE_END();
private:
public:
void setUp()
{
}
void tearDown()
{
}
void test1()
{
//m_wrapper.test();
// int numOfBlock = 10240;
int numOfBlock = 1024;
FILE* pFile;
unsigned char writeBuf[BYTE_PER_BLOCK * 10];
char diskBuf[BYTE_PER_BLOCK * 11];
char fileName[40];
for ( int k = 0; k < 273; k++ )
{
snprintf( fileName, sizeof(fileName), "testwr%d.tst", k );
pFile = fopen( fileName, "w+b" );
if ( pFile != NULL )
{
setvbuf ( pFile, diskBuf, _IOFBF, 81920 );
memset( writeBuf, 0, BYTE_PER_BLOCK * sizeof( unsigned char ));
for ( int i = 0; i < numOfBlock; i++ )
fwrite( writeBuf, sizeof( writeBuf ), 1, pFile );
// fwrite( writeBuf, sizeof( writeBuf ), numOfBlock, pFile );
fclose( pFile );
}
}
}
void testFileNameOp()
{
FileOp fileOp;
bool bStatus;
char fileName[20];
int rc;
strcpy( fileName, "FILE_999.dat" );
BRMWrapper::setUseBrm(true);
// file opertaions
fileOp.deleteFile( fileName );
CPPUNIT_ASSERT( fileOp.exists( fileName ) == false );
rc = fileOp.deleteFile( fileName );
CPPUNIT_ASSERT( rc == ERR_FILE_NOT_EXIST );
rc = fileOp.createFile( fileName, 10 );
CPPUNIT_ASSERT( rc == NO_ERROR );
rc = fileOp.createFile( fileName, 10 );
CPPUNIT_ASSERT( rc == ERR_FILE_EXIST );
bStatus = fileOp.exists( fileName );
CPPUNIT_ASSERT( bStatus == true );
// init different value
fileOp.deleteFile( fileName );
CPPUNIT_ASSERT( fileOp.exists( fileName ) == false );
rc = fileOp.createFile( fileName, 10, 0xFF, 1 );
CPPUNIT_ASSERT( rc == NO_ERROR );
fileOp.deleteFile( fileName );
CPPUNIT_ASSERT( fileOp.exists( fileName ) == false );
rc = fileOp.createFile( fileName, 10, 0x8001, 2 );
CPPUNIT_ASSERT( rc == NO_ERROR );
fileOp.deleteFile( fileName );
CPPUNIT_ASSERT( fileOp.exists( fileName ) == false );
rc = fileOp.createFile( fileName, 10, 0xFFAAAAAB, 4 );
CPPUNIT_ASSERT( rc == NO_ERROR );
fileOp.deleteFile( fileName );
CPPUNIT_ASSERT( fileOp.exists( fileName ) == false );
//Not use block resolution manager
BRMWrapper::setUseBrm(false);
// file opertaions
fileOp.deleteFile( fileName );
CPPUNIT_ASSERT( fileOp.exists( fileName ) == false );
rc = fileOp.deleteFile( fileName );
CPPUNIT_ASSERT( rc == ERR_FILE_NOT_EXIST );
rc = fileOp.createFile( fileName, 10 );
CPPUNIT_ASSERT( rc == NO_ERROR );
rc = fileOp.createFile( fileName, 10 );
CPPUNIT_ASSERT( rc == ERR_FILE_EXIST );
bStatus = fileOp.exists( fileName );
CPPUNIT_ASSERT( bStatus == true );
// init different value
fileOp.deleteFile( fileName );
CPPUNIT_ASSERT( fileOp.exists( fileName ) == false );
rc = fileOp.createFile( fileName, 10, 0xFF, 1 );
CPPUNIT_ASSERT( rc == NO_ERROR );
fileOp.deleteFile( fileName );
CPPUNIT_ASSERT( fileOp.exists( fileName ) == false );
rc = fileOp.createFile( fileName, 10, 0x8001, 2 );
CPPUNIT_ASSERT( rc == NO_ERROR );
fileOp.deleteFile( fileName );
CPPUNIT_ASSERT( fileOp.exists( fileName ) == false );
rc = fileOp.createFile( fileName, 10, 0xFFAAAAAB, 4 );
CPPUNIT_ASSERT( rc == NO_ERROR );
fileOp.deleteFile( fileName );
CPPUNIT_ASSERT( fileOp.exists( fileName ) == false );
}
void testFileHandleOp()
{
FileOp fileOp;
char fileName[100], testStr[50];
unsigned char dataBuf[BYTE_PER_BLOCK];
long fileSize;
FILE* pFile;
int rc;
int allocSize = 0;
BRMWrapper::setUseBrm(true);
// strcpy( fileName, "FILE_999.dat" );
strcpy( testStr, "String write test data" );
fileOp.deleteFile( 999 );
rc = fileOp.createFile( 999, 10, allocSize);
CPPUNIT_ASSERT( rc == NO_ERROR );
pFile = fileOp.openFile( 999 );
CPPUNIT_ASSERT( pFile != NULL );
fileSize = fileOp.getFileSize( 999 );
CPPUNIT_ASSERT( fileSize == allocSize * BYTE_PER_BLOCK );
rc = fileOp.setFileOffset( pFile, -1, SEEK_SET );
CPPUNIT_ASSERT( rc == ERR_FILE_SEEK );
uint64_t lbid1;
rc = BRMWrapper::getInstance()->getBrmInfo( 1999, 1, lbid1 );
CPPUNIT_ASSERT( rc != NO_ERROR );
rc = BRMWrapper::getInstance()->getBrmInfo( 999, 1, lbid1 );
CPPUNIT_ASSERT( rc == NO_ERROR );
rc = fileOp.setFileOffset( pFile, lbid1 * BYTE_PER_BLOCK, SEEK_SET );
CPPUNIT_ASSERT( rc == NO_ERROR );
uint64_t lbid9;
rc = BRMWrapper::getInstance()->getBrmInfo( 999, 9, lbid9 );
CPPUNIT_ASSERT( rc == NO_ERROR );
rc = fileOp.setFileOffset( pFile, BYTE_PER_BLOCK * lbid9, SEEK_SET );
CPPUNIT_ASSERT( rc == NO_ERROR );
// write something to block 1
memset( dataBuf, 0, sizeof( unsigned char ) * BYTE_PER_BLOCK );
memcpy( dataBuf + 8, testStr, strlen( testStr ) );
CPPUNIT_ASSERT( fileOp.setFileOffset( pFile, lbid1 * BYTE_PER_BLOCK, SEEK_SET ) == NO_ERROR );
rc = fileOp.writeFile( pFile, dataBuf, BYTE_PER_BLOCK );
CPPUNIT_ASSERT( rc == NO_ERROR );
rc = fileOp.writeFile( NULL, dataBuf, BYTE_PER_BLOCK );
CPPUNIT_ASSERT( rc == ERR_FILE_NULL );
// read something from block 1
memset( dataBuf, 0, sizeof( unsigned char ) * BYTE_PER_BLOCK );
rc = BRMWrapper::getInstance()->getBrmInfo( 999, 1, lbid1 );
CPPUNIT_ASSERT( rc == NO_ERROR );
CPPUNIT_ASSERT( fileOp.setFileOffset( pFile, lbid1 * BYTE_PER_BLOCK, SEEK_SET ) == NO_ERROR );
rc = fileOp.readFile( pFile, dataBuf, BYTE_PER_BLOCK );
printf( "\ndataBuf=%s\n", dataBuf + 8 );
CPPUNIT_ASSERT( rc == NO_ERROR );
CPPUNIT_ASSERT( memcmp( dataBuf + 8, testStr, strlen(testStr)) == 0 );
CPPUNIT_ASSERT( fileOp.getFileSize( 999 ) == allocSize * 8192 );
fileOp.closeFile( pFile );
fileOp.deleteFile(999);
// No block resolution manager
BRMWrapper::setUseBrm(false);
// strcpy( fileName, "FILE_999.dat" );
rc = fileOp.getFileName( 999, fileName );
strcpy( testStr, "String write test data" );
fileOp.deleteFile( 999 );
CPPUNIT_ASSERT( fileOp.exists( 999 ) == false );
rc = fileOp.createFile( 999, 10, allocSize);
CPPUNIT_ASSERT( rc == NO_ERROR );
pFile = fileOp.openFile( fileName );
CPPUNIT_ASSERT( pFile != NULL );
fileSize = fileOp.getFileSize( 999 );
CPPUNIT_ASSERT( fileSize == 81920 );
rc = fileOp.setFileOffset( pFile, -1, SEEK_SET );
CPPUNIT_ASSERT( rc == ERR_FILE_SEEK );
rc = fileOp.setFileOffset( pFile, BYTE_PER_BLOCK, SEEK_SET );
CPPUNIT_ASSERT( rc == NO_ERROR );
rc = fileOp.setFileOffset( pFile, BYTE_PER_BLOCK * 9, SEEK_SET );
CPPUNIT_ASSERT( rc == NO_ERROR );
// write something to block 1
memset( dataBuf, 0, sizeof( unsigned char ) * BYTE_PER_BLOCK );
memcpy( dataBuf + 8, testStr, strlen( testStr ) );
CPPUNIT_ASSERT( fileOp.setFileOffset( pFile, BYTE_PER_BLOCK, SEEK_SET ) == NO_ERROR );
rc = fileOp.writeFile( pFile, dataBuf, BYTE_PER_BLOCK );
CPPUNIT_ASSERT( rc == NO_ERROR );
rc = fileOp.writeFile( NULL, dataBuf, BYTE_PER_BLOCK );
CPPUNIT_ASSERT( rc == ERR_FILE_NULL );
// read something from block 1
memset( dataBuf, 0, sizeof( unsigned char ) * BYTE_PER_BLOCK );
CPPUNIT_ASSERT( fileOp.setFileOffset( pFile, BYTE_PER_BLOCK, SEEK_SET ) == NO_ERROR );
rc = fileOp.readFile( pFile, dataBuf, BYTE_PER_BLOCK );
printf( "\ndataBuf=%s\n", dataBuf + 8 );
CPPUNIT_ASSERT( rc == NO_ERROR );
CPPUNIT_ASSERT( memcmp( dataBuf + 8, testStr, strlen(testStr)) == 0 );
CPPUNIT_ASSERT( fileOp.getFileSize( 999 ) == 81920 );
fileOp.closeFile( pFile );
fileOp.deleteFile(999);
}
void testDirBasic()
{
FileOp fileOp;
char dirName[30];
int rc;
strcpy( dirName, "testdir" );
fileOp.removeDir( dirName );
CPPUNIT_ASSERT( fileOp.isDir( dirName ) == false );
rc = fileOp.createDir( dirName );
CPPUNIT_ASSERT( rc == NO_ERROR );
CPPUNIT_ASSERT( fileOp.isDir( dirName ) == true );
fileOp.removeDir( dirName );
}
void testCalculateRowIdBitmap()
{
BlockOp blockOp;
RID rowId = numeric_limits<WriteEngine::RID>max();
int fbo = 0, bio = 0, bbo = 0;
// Assuming 1024 per data block, 8 byte width
CPPUNIT_ASSERT( blockOp.calculateRowId( rowId, 1024, 8, fbo, bio ) == false );
rowId = 1026;
CPPUNIT_ASSERT( blockOp.calculateRowId( rowId, 1024, 8, fbo, bio ) == true );
CPPUNIT_ASSERT( fbo == 1 );
CPPUNIT_ASSERT( bio == 16 );
// Assuming 2048 per data block, 4 byte width
/* rowId = 2049;
CPPUNIT_ASSERT( blockOp.calculateRowId( rowId, 2048, 4, fbo, bio ) == true );
CPPUNIT_ASSERT( fbo == 1 );
CPPUNIT_ASSERT( bio == 16 );
// Assuming 4096 per data block, 2 byte width
rowId = 2049;
CPPUNIT_ASSERT( blockOp.calculateRowId( rowId, 4096, 2, fbo, bio ) == true );
CPPUNIT_ASSERT( fbo == 1 );
CPPUNIT_ASSERT( bio == 16 );
// Assuming 8192 per data block, 1 byte width
rowId = 2049;
CPPUNIT_ASSERT( blockOp.calculateRowId( rowId, 8192, 1, fbo, bio ) == true );
CPPUNIT_ASSERT( fbo == 1 );
CPPUNIT_ASSERT( bio == 16 );
*/
rowId = 65546;
CPPUNIT_ASSERT( blockOp.calculateRowBitmap( rowId, BYTE_PER_BLOCK * 8, fbo, bio, bbo ) == true );
CPPUNIT_ASSERT( fbo == 1 );
CPPUNIT_ASSERT( bio == 1 );
CPPUNIT_ASSERT( bbo == 2 );
// CPPUNIT_ASSERT( blockOp.getRowId( fbo, bio, bbo ) == 65546 );
rowId = numeric_limits<WriteEngine::RID>max();
CPPUNIT_ASSERT( blockOp.calculateRowBitmap( rowId, BYTE_PER_BLOCK * 8, fbo, bio, bbo ) == false );
}
void testBlockBuffer()
{
BlockOp blockOp;
unsigned char buf[BYTE_PER_BLOCK];
int writeVal = 80, readVal;
blockOp.resetBuf( buf, sizeof( buf ) );
CPPUNIT_ASSERT( buf[1] == '\0' );
// copy to byte 8 area
blockOp.writeBufValue( buf + 8, &writeVal, 4, true );
// blockOp.writeBufValue( buf + 8, &writeVal, 4 );
blockOp.readBufValue( buf + 8, &readVal, 4 );
CPPUNIT_ASSERT( readVal == 80 );
}
void testBitBasic()
{
BlockOp blockOp;
unsigned int val;
val = 7;
CPPUNIT_ASSERT( blockOp.getByteTotalOnBit( val, 8 ) == 3 );
val = 33;
CPPUNIT_ASSERT( blockOp.getByteTotalOnBit( val, 8 ) == 2 );
val = 255;
CPPUNIT_ASSERT( blockOp.getByteTotalOnBit( val, 8 ) == 8 );
val = 0;
CPPUNIT_ASSERT( blockOp.getByteTotalOnBit( val, 8 ) == 0 );
val = 3;
CPPUNIT_ASSERT( blockOp.getBitFlag( val, 0 ) == 1 );
CPPUNIT_ASSERT( blockOp.getBitFlag( val, 1 ) == 1 );
CPPUNIT_ASSERT( blockOp.getBitFlag( val, 2 ) == 0 );
CPPUNIT_ASSERT( blockOp.getBitFlag( val, 3 ) == 0 );
blockOp.setBitFlag( &val, 2, true );
CPPUNIT_ASSERT( blockOp.getBitFlag( val, 2 ) == true );
CPPUNIT_ASSERT( val == 7 );
blockOp.setBitFlag( &val, 1, false );
CPPUNIT_ASSERT( blockOp.getBitFlag( val, 1 ) == false );
CPPUNIT_ASSERT( val == 5 );
}
void testBufferBit()
{
BlockOp blockOp;
unsigned char buf[BYTE_PER_BLOCK];
blockOp.resetBuf( buf, sizeof( buf ) );
blockOp.setBitFlag( (unsigned int*)&buf[1], 0, true );
blockOp.setBitFlag( (unsigned int*)&buf[1], 3, true );
blockOp.setBitFlag( (unsigned int*)&buf[6], 1, true );
blockOp.setBitFlag( (unsigned int*)&buf[6], 2, true );
blockOp.setBitFlag( (unsigned int*)&buf[6], 3, true );
blockOp.setBitFlag( (unsigned int*)&buf[6], 5, true );
CPPUNIT_ASSERT( blockOp.getBufTotalOnBit( buf, sizeof( buf )) == 6 );
CPPUNIT_ASSERT( blockOp.getBufByteBitFlag( buf, 6, 5 ) == true );
CPPUNIT_ASSERT( blockOp.getBufByteBitFlag( buf, 6, 3 ) == true );
CPPUNIT_ASSERT( blockOp.getBufByteBitFlag( buf, 1, 0 ) == true );
CPPUNIT_ASSERT( blockOp.getBufByteBitFlag( buf, 1, 3 ) == true );
blockOp.setBufByteBitFlag( buf, 6, 2, false );
CPPUNIT_ASSERT( blockOp.getBufByteBitFlag( buf, 6, 2 ) == false );
CPPUNIT_ASSERT( blockOp.getBufTotalOnBit( buf, sizeof( buf )) == 5 );
}
void testBitShift()
{
BlockOp blockOp;
uint64_t curVal, result, mask;
curVal = 0x6a;
mask = 0xe0; // first three bit
result = blockOp.getBitValue( curVal, 5, 0xF );
CPPUNIT_ASSERT( result == 3 );
result = blockOp.setBitValue( curVal, 0x4, 5, mask );
CPPUNIT_ASSERT( result == 138 );
}
void testEmptyRowValue( )
{
BlockOp blockOp;
uint64_t curVal;
RID curRID;
curRID = blockOp.getRowId( 0, 1, 3 );
CPPUNIT_ASSERT( curRID == 3 );
curRID = blockOp.getRowId( 0, 2, 3 );
CPPUNIT_ASSERT( curRID == 3 );
curRID = blockOp.getRowId( 2, 4, 3 );
CPPUNIT_ASSERT( curRID == 4099 );
curVal = blockOp.getEmptyRowValue( WriteEngine::TINYINT, 1 );
CPPUNIT_ASSERT( curVal == 0x81 );
curVal = blockOp.getEmptyRowValue( WriteEngine::SMALLINT, 2 );
CPPUNIT_ASSERT( curVal == 0x8001 );
curVal = blockOp.getEmptyRowValue( WriteEngine::MEDINT, 4 );
CPPUNIT_ASSERT( curVal == 0x80000001 );
curVal = blockOp.getEmptyRowValue( WriteEngine::INT, 4 );
CPPUNIT_ASSERT( curVal == 0x80000001 );
curVal = blockOp.getEmptyRowValue( WriteEngine::BIGINT, 8 );
CPPUNIT_ASSERT( curVal == 0x8000000000000001LL );
curVal = blockOp.getEmptyRowValue( WriteEngine::FLOAT, 4 );
CPPUNIT_ASSERT( curVal == 0xFFAAAAAB );
curVal = blockOp.getEmptyRowValue( WriteEngine::DOUBLE, 8 );
CPPUNIT_ASSERT( curVal == 0xFFFAAAAAAAAAAAABLL );
curVal = blockOp.getEmptyRowValue( WriteEngine::DECIMAL, 1 );
CPPUNIT_ASSERT( curVal == 0x8001 );
curVal = blockOp.getEmptyRowValue( WriteEngine::DECIMAL, 2 );
CPPUNIT_ASSERT( curVal == 0x8001 );
curVal = blockOp.getEmptyRowValue( WriteEngine::DECIMAL, 3 );
CPPUNIT_ASSERT( curVal == 0x80000001 );
curVal = blockOp.getEmptyRowValue( WriteEngine::DECIMAL, 4 );
CPPUNIT_ASSERT( curVal == 0x80000001 );
curVal = blockOp.getEmptyRowValue( WriteEngine::DECIMAL, 5 );
CPPUNIT_ASSERT( curVal == 0x8000000000000001LL );
curVal = blockOp.getEmptyRowValue( WriteEngine::DECIMAL, 6 );
CPPUNIT_ASSERT( curVal == 0x8000000000000001LL );
curVal = blockOp.getEmptyRowValue( WriteEngine::DECIMAL, 7 );
CPPUNIT_ASSERT( curVal == 0x8000000000000001LL );
curVal = blockOp.getEmptyRowValue( WriteEngine::DECIMAL, 8 );
CPPUNIT_ASSERT( curVal == 0x8000000000000001LL );
/*
curVal = blockOp.getEmptyRowValue( WriteEngine::DECIMAL, 9 );
CPPUNIT_ASSERT( curVal == 0x80000001 );
curVal = blockOp.getEmptyRowValue( WriteEngine::DECIMAL, 10 );
CPPUNIT_ASSERT( curVal == 0x8000000000000001LL );
curVal = blockOp.getEmptyRowValue( WriteEngine::DECIMAL, 12 );
CPPUNIT_ASSERT( curVal == 0x8000000000000001LL );
curVal = blockOp.getEmptyRowValue( WriteEngine::DECIMAL, 19 );
CPPUNIT_ASSERT( curVal == 0xFFFFFFFFFFFFFFFFLL );
*/
curVal = blockOp.getEmptyRowValue( WriteEngine::DATE, 4 );
CPPUNIT_ASSERT( curVal == 0xFFFFFFFF );
curVal = blockOp.getEmptyRowValue( WriteEngine::DATETIME, 8 );
CPPUNIT_ASSERT( curVal == 0xFFFFFFFFFFFFFFFFLL );
curVal = blockOp.getEmptyRowValue( WriteEngine::CHAR, 1 );
CPPUNIT_ASSERT( curVal == 0xFF );
curVal = blockOp.getEmptyRowValue( WriteEngine::CHAR, 2 );
CPPUNIT_ASSERT( curVal == 0xFFFF );
curVal = blockOp.getEmptyRowValue( WriteEngine::CHAR, 4 );
CPPUNIT_ASSERT( curVal == 0xFFFFFFFF );
curVal = blockOp.getEmptyRowValue( WriteEngine::CHAR, 5 );
CPPUNIT_ASSERT( curVal == 0xFFFFFFFFFFFFFFFFLL );
curVal = blockOp.getEmptyRowValue( WriteEngine::CHAR, 8 );
CPPUNIT_ASSERT( curVal == 0xFFFFFFFFFFFFFFFFLL );
curVal = blockOp.getEmptyRowValue( WriteEngine::CHAR, 10 );
CPPUNIT_ASSERT( curVal == 0xFFFFFFFFFFFFFFFFLL );
curVal = blockOp.getEmptyRowValue( WriteEngine::VARCHAR, 1 );
CPPUNIT_ASSERT( curVal == 0xFFFF );
curVal = blockOp.getEmptyRowValue( WriteEngine::VARCHAR, 2 );
CPPUNIT_ASSERT( curVal == 0xFFFFFFFF );
curVal = blockOp.getEmptyRowValue( WriteEngine::VARCHAR, 3 );
CPPUNIT_ASSERT( curVal == 0xFFFFFFFF );
curVal = blockOp.getEmptyRowValue( WriteEngine::VARCHAR, 4 );
CPPUNIT_ASSERT( curVal == 0xFFFFFFFFFFFFFFFFLL );
curVal = blockOp.getEmptyRowValue( WriteEngine::VARCHAR, 5 );
CPPUNIT_ASSERT( curVal == 0xFFFFFFFFFFFFFFFFLL );
curVal = blockOp.getEmptyRowValue( WriteEngine::VARCHAR, 10 );
CPPUNIT_ASSERT( curVal == 0xFFFFFFFFFFFFFFFFLL );
}
void testCorrectRowWidth()
{
BlockOp blockOp;
int curVal;
curVal = blockOp.getCorrectRowWidth( WriteEngine::TINYINT, 1 );
CPPUNIT_ASSERT( curVal == 1 );
curVal = blockOp.getCorrectRowWidth( WriteEngine::SMALLINT, 1 ); // intentionally put 1 rather than 2
CPPUNIT_ASSERT( curVal == 2 );
curVal = blockOp.getCorrectRowWidth( WriteEngine::MEDINT, 8 ); // intentionally put 8 rather than 4
CPPUNIT_ASSERT( curVal == 4 );
curVal = blockOp.getCorrectRowWidth( WriteEngine::INT, 4 );
CPPUNIT_ASSERT( curVal == 4 );
curVal = blockOp.getCorrectRowWidth( WriteEngine::BIGINT, 4 ); // should be 8
CPPUNIT_ASSERT( curVal == 8 );
curVal = blockOp.getCorrectRowWidth( WriteEngine::FLOAT, 8 ); // should be 4
CPPUNIT_ASSERT( curVal == 4 );
curVal = blockOp.getCorrectRowWidth( WriteEngine::DOUBLE, 4 ); // should be 8
CPPUNIT_ASSERT( curVal == 8 );
curVal = blockOp.getCorrectRowWidth( WriteEngine::DECIMAL, 1 );
CPPUNIT_ASSERT( curVal == 2 );
curVal = blockOp.getCorrectRowWidth( WriteEngine::DECIMAL, 2 );
CPPUNIT_ASSERT( curVal == 2 );
curVal = blockOp.getCorrectRowWidth( WriteEngine::DECIMAL, 3 );
CPPUNIT_ASSERT( curVal == 4 );
curVal = blockOp.getCorrectRowWidth( WriteEngine::DECIMAL, 4 );
CPPUNIT_ASSERT( curVal == 4 );
curVal = blockOp.getCorrectRowWidth( WriteEngine::DECIMAL, 5 );
CPPUNIT_ASSERT( curVal == 8 );
curVal = blockOp.getCorrectRowWidth( WriteEngine::DECIMAL, 6 );
CPPUNIT_ASSERT( curVal == 8 );
curVal = blockOp.getCorrectRowWidth( WriteEngine::DECIMAL, 7 );
CPPUNIT_ASSERT( curVal == 8 );
curVal = blockOp.getCorrectRowWidth( WriteEngine::DECIMAL, 8 );
CPPUNIT_ASSERT( curVal == 8 );
/* curVal = blockOp.getCorrectRowWidth( WriteEngine::DECIMAL, 9 );
CPPUNIT_ASSERT( curVal == 4 );
curVal = blockOp.getCorrectRowWidth( WriteEngine::DECIMAL, 10 );
CPPUNIT_ASSERT( curVal == 8 );
curVal = blockOp.getCorrectRowWidth( WriteEngine::DECIMAL, 12 );
CPPUNIT_ASSERT( curVal == 8 );
curVal = blockOp.getCorrectRowWidth( WriteEngine::DECIMAL, 19 );
CPPUNIT_ASSERT( curVal == 8 );
*/
curVal = blockOp.getCorrectRowWidth( WriteEngine::DATE, 8 );
CPPUNIT_ASSERT( curVal == 4 );
curVal = blockOp.getCorrectRowWidth( WriteEngine::DATETIME, 4 );
CPPUNIT_ASSERT( curVal == 8 );
curVal = blockOp.getCorrectRowWidth( WriteEngine::CHAR, 1 );
CPPUNIT_ASSERT( curVal == 1 );
curVal = blockOp.getCorrectRowWidth( WriteEngine::CHAR, 2 );
CPPUNIT_ASSERT( curVal == 2 );
curVal = blockOp.getCorrectRowWidth( WriteEngine::CHAR, 3 );
CPPUNIT_ASSERT( curVal == 4 );
curVal = blockOp.getCorrectRowWidth( WriteEngine::CHAR, 5 );
CPPUNIT_ASSERT( curVal == 8 );
curVal = blockOp.getCorrectRowWidth( WriteEngine::CHAR, 8 );
CPPUNIT_ASSERT( curVal == 8 );
curVal = blockOp.getCorrectRowWidth( WriteEngine::CHAR, 10 );
CPPUNIT_ASSERT( curVal == 8 );
curVal = blockOp.getCorrectRowWidth( WriteEngine::VARCHAR, 1 );
CPPUNIT_ASSERT( curVal == 2 );
curVal = blockOp.getCorrectRowWidth( WriteEngine::VARCHAR, 2 );
CPPUNIT_ASSERT( curVal == 4 );
curVal = blockOp.getCorrectRowWidth( WriteEngine::VARCHAR, 3 );
CPPUNIT_ASSERT( curVal == 4 );
curVal = blockOp.getCorrectRowWidth( WriteEngine::VARCHAR, 4 );
CPPUNIT_ASSERT( curVal == 8 );
curVal = blockOp.getCorrectRowWidth( WriteEngine::VARCHAR, 5 );
CPPUNIT_ASSERT( curVal == 8 );
curVal = blockOp.getCorrectRowWidth( WriteEngine::VARCHAR, 10 );
CPPUNIT_ASSERT( curVal == 8 );
}
void testDbBlock()
{
DbFileOp dbFileOp;
DataBlock block;
uint64_t outVal = 12345, inVal;
int rc;
FILE* pFile;
int allocSize = 0;
Stats::setUseStats( true );
BRMWrapper::setUseBrm(true);
dbFileOp.deleteFile( 999 );
CPPUNIT_ASSERT( dbFileOp.exists( 999 ) == false );
CPPUNIT_ASSERT( dbFileOp.createFile( 999, 10, allocSize ) == NO_ERROR );
pFile = dbFileOp.openFile( 999 );
CPPUNIT_ASSERT( pFile != NULL );
uint64_t lbid0;
BRMWrapper::getInstance()->getBrmInfo( 999, 0, lbid0 );
rc = dbFileOp.readDBFile( pFile, block.data, lbid0 );
CPPUNIT_ASSERT( rc == NO_ERROR );
dbFileOp.setSubBlockEntry( block.data, 1, 2, 8, &outVal );
rc = dbFileOp.writeDBFile( pFile, block.data, lbid0 );
CPPUNIT_ASSERT( rc == NO_ERROR );
rc = dbFileOp.readSubBlockEntry( pFile, &block, lbid0, 1, 2, 8, &inVal );
CPPUNIT_ASSERT( rc == NO_ERROR );
CPPUNIT_ASSERT( inVal == outVal );
inVal = 0;
dbFileOp.getSubBlockEntry( block.data, 1, 2, 8, &inVal );
CPPUNIT_ASSERT( inVal == outVal );
rc = dbFileOp.writeSubBlockEntry( pFile, &block, lbid0, 1, 2, 8, &inVal );
CPPUNIT_ASSERT( rc == NO_ERROR );
rc = dbFileOp.readDBFile( pFile, &block, lbid0 );
CPPUNIT_ASSERT( rc == NO_ERROR );
rc = dbFileOp.writeDBFile( pFile, &block, lbid0 );
CPPUNIT_ASSERT( rc == NO_ERROR );
// Not Use Block resolution manager
BRMWrapper::setUseBrm(false);
dbFileOp.deleteFile( 999 );
CPPUNIT_ASSERT( dbFileOp.exists( 999 ) == false );
CPPUNIT_ASSERT( dbFileOp.createFile( 999, 10, allocSize ) == NO_ERROR );
pFile = dbFileOp.openFile( 999 );
CPPUNIT_ASSERT( pFile != NULL );
rc = dbFileOp.readDBFile( pFile, block.data, 0 );
CPPUNIT_ASSERT( rc == NO_ERROR );
dbFileOp.setSubBlockEntry( block.data, 1, 2, 8, &outVal );
rc = dbFileOp.writeDBFile( pFile, block.data, 0 );
CPPUNIT_ASSERT( rc == NO_ERROR );
rc = dbFileOp.readSubBlockEntry( pFile, &block, 0, 1, 2, 8, &inVal );
CPPUNIT_ASSERT( rc == NO_ERROR );
CPPUNIT_ASSERT( inVal == outVal );
inVal = 0;
dbFileOp.getSubBlockEntry( block.data, 1, 2, 8, &inVal );
CPPUNIT_ASSERT( inVal == outVal );
rc = dbFileOp.writeSubBlockEntry( pFile, &block, (uint64_t)0, 1, 2, 8, &inVal );
CPPUNIT_ASSERT( rc == NO_ERROR );
rc = dbFileOp.readDBFile( pFile, &block, 0 );
CPPUNIT_ASSERT( rc == NO_ERROR );
rc = dbFileOp.writeDBFile( pFile, &block, 0 );
CPPUNIT_ASSERT( rc == NO_ERROR );
long readCounter, writeCounter;
readCounter = Stats::getIoBlockRead();
writeCounter = Stats::getIoBlockWrite();
printf( "\nTotal number of blocks read: %ld", readCounter );
printf( "\nTotal number of blocks write: %ld", writeCounter );
Stats::setUseStats( false );
}
void testCopyDbFile()
{
DbFileOp dbFileOp;
int rc, startFbo = 5, copyBlock = 15, bufBlock = 30, extendBlock;
FILE* pSourceFile = NULL;
FILE* pTargetFile = NULL;
int allocSize999 = 0, allocSize998 = 0;
BRMWrapper::setUseBrm(true);
rc = dbFileOp.copyFileValidation( pSourceFile, pTargetFile, startFbo,
copyBlock, bufBlock, extendBlock );
CPPUNIT_ASSERT( rc == ERR_FILE_NULL );
dbFileOp.deleteFile( 999 );
dbFileOp.deleteFile( 998 );
CPPUNIT_ASSERT( dbFileOp.exists( 999 ) == false );
CPPUNIT_ASSERT( dbFileOp.exists( 998 ) == false );
CPPUNIT_ASSERT( dbFileOp.createFile( 999, 10, allocSize999 ) == NO_ERROR );
CPPUNIT_ASSERT( dbFileOp.createFile( 998, 20, allocSize998, 0xFFFF, 2 ) == NO_ERROR );
pTargetFile = dbFileOp.openFile( 999 );
CPPUNIT_ASSERT( pTargetFile != NULL );
pSourceFile = dbFileOp.openFile( 998 );
CPPUNIT_ASSERT( pSourceFile != NULL );
// rc = dbFileOp.copyFileValidation( pSourceFile, pTargetFile, startFbo,
// copyBlock, bufBlock, extendBlock );
// CPPUNIT_ASSERT( rc == ERR_SIZE_NOT_MATCH );
//CPPUNIT_ASSERT( rc == ERR_SIZE_NOT_MATCH );
//copyBlock = 20;
copyBlock = allocSize998;
bufBlock = allocSize999;
rc = dbFileOp.copyFileValidation( pSourceFile, pTargetFile, startFbo,
copyBlock, bufBlock, extendBlock );
CPPUNIT_ASSERT( rc == ERR_FILE_NEED_EXTEND );
//CPPUNIT_ASSERT( extendBlock == 10245 );
int allocExtSize999 = 0;
rc = dbFileOp.extendFile( pTargetFile, 999, extendBlock, allocExtSize999, 0, 8 );
CPPUNIT_ASSERT( rc == NO_ERROR );
rc = dbFileOp.copyFileValidation( pSourceFile, pTargetFile, startFbo,
copyBlock, bufBlock, extendBlock );
CPPUNIT_ASSERT( rc == NO_ERROR );
CPPUNIT_ASSERT( extendBlock == 0 );
uint64_t lbidTarget;
BRMWrapper::getInstance()->getBrmInfo( 999, startFbo, lbidTarget );
rc = dbFileOp.copyDBFile( pSourceFile, pTargetFile, lbidTarget );
CPPUNIT_ASSERT( rc == NO_ERROR );
dbFileOp.closeFile( pSourceFile );
dbFileOp.closeFile( pTargetFile );
//Not Use BRM
BRMWrapper::setUseBrm(false);
pSourceFile = NULL;
pTargetFile = NULL;
rc = dbFileOp.copyFileValidation( pSourceFile, pTargetFile, startFbo,
copyBlock, bufBlock, extendBlock );
CPPUNIT_ASSERT( rc == ERR_FILE_NULL );
dbFileOp.deleteFile( 999 );
dbFileOp.deleteFile( 998 );
CPPUNIT_ASSERT( dbFileOp.exists( 999 ) == false );
CPPUNIT_ASSERT( dbFileOp.exists( 998 ) == false );
CPPUNIT_ASSERT( dbFileOp.createFile( 999, 10, allocSize999 ) == NO_ERROR );
CPPUNIT_ASSERT( dbFileOp.createFile( 998, 20, allocSize998, 0xFFFF, 2 ) == NO_ERROR );
pTargetFile = dbFileOp.openFile( 999 );
CPPUNIT_ASSERT( pTargetFile != NULL );
pSourceFile = dbFileOp.openFile( 998 );
CPPUNIT_ASSERT( pSourceFile != NULL );
// rc = dbFileOp.copyFileValidation( pSourceFile, pTargetFile, startFbo,
// copyBlock, bufBlock, extendBlock );
// CPPUNIT_ASSERT( rc == ERR_SIZE_NOT_MATCH );
//CPPUNIT_ASSERT( rc == ERR_SIZE_NOT_MATCH );
//CPPUNIT_ASSERT( rc == NO_ERROR);
copyBlock = 20;
bufBlock = 30;
rc = dbFileOp.copyFileValidation( pSourceFile, pTargetFile, startFbo,
copyBlock, bufBlock, extendBlock );
CPPUNIT_ASSERT( rc == ERR_FILE_NEED_EXTEND );
CPPUNIT_ASSERT( extendBlock == 45 );
rc = dbFileOp.extendFile( pTargetFile, 999, extendBlock, 0, 8 );
CPPUNIT_ASSERT( rc == NO_ERROR );
rc = dbFileOp.copyFileValidation( pSourceFile, pTargetFile, startFbo,
copyBlock, bufBlock, extendBlock );
CPPUNIT_ASSERT( rc == NO_ERROR );
CPPUNIT_ASSERT( extendBlock == 0 );
rc = dbFileOp.copyDBFile( pSourceFile, pTargetFile, startFbo );
CPPUNIT_ASSERT( rc == NO_ERROR );
dbFileOp.closeFile( pSourceFile );
dbFileOp.closeFile( pTargetFile );
}
void testSem()
{
SemOp semOp;
FileOp fileOp;
int rc;
bool bSuccess;
key_t key;
int sid, totalNum = 5;
char fileName[100];
semOp.setMaxSemVal( 3 );
bSuccess = semOp.getKey( NULL, key );
CPPUNIT_ASSERT( bSuccess == false );
rc = fileOp.getFileName( 9991, fileName );
CPPUNIT_ASSERT( rc == NO_ERROR );
bSuccess = semOp.getKey( fileName, key );
CPPUNIT_ASSERT( bSuccess == false );
rc = fileOp.getFileName( 999, fileName );
CPPUNIT_ASSERT( rc == NO_ERROR );
bSuccess = semOp.getKey( fileName, key );
printf( "\nkey=%d", key );
CPPUNIT_ASSERT( bSuccess == true );
if ( semOp.existSem( sid, key ) )
semOp.deleteSem( sid );
rc = semOp.createSem( sid, key, 1000 );
CPPUNIT_ASSERT( rc == ERR_MAX_SEM );
rc = semOp.createSem( sid, key, totalNum );
CPPUNIT_ASSERT( rc == NO_ERROR );
rc = semOp.createSem( sid, key, totalNum );
CPPUNIT_ASSERT( rc == ERR_SEM_EXIST );
rc = semOp.openSem( sid, key );
CPPUNIT_ASSERT( rc == NO_ERROR );
semOp.printAllVal( sid );
// lock
printf( "\nlock one in 2" );
rc = semOp.lockSem( sid, 2 );
CPPUNIT_ASSERT( rc == NO_ERROR );
CPPUNIT_ASSERT( semOp.getVal( sid, 2 ) == 2 );
semOp.printAllVal( sid );
printf( "\nlock one in 2" );
rc = semOp.lockSem( sid, 2 );
CPPUNIT_ASSERT( rc == NO_ERROR );
CPPUNIT_ASSERT( semOp.getVal( sid, 2 ) == 1 );
semOp.printAllVal( sid );
printf( "\nlock one in 2" );
rc = semOp.lockSem( sid, 2 );
CPPUNIT_ASSERT( rc == NO_ERROR );
CPPUNIT_ASSERT( semOp.getVal( sid, 2 ) == 0 );
semOp.printAllVal( sid );
rc = semOp.lockSem( sid, 2 );
CPPUNIT_ASSERT( rc == ERR_NO_SEM_RESOURCE );
CPPUNIT_ASSERT( semOp.getVal( sid, 2 ) == 0 );
rc = semOp.lockSem( sid, -2 );
CPPUNIT_ASSERT( rc == ERR_VALUE_OUTOFRANGE );
rc = semOp.lockSem( sid + 1, 1 );
CPPUNIT_ASSERT( rc == ERR_LOCK_FAIL );
// unlock
rc = semOp.unlockSem( sid, -2 );
CPPUNIT_ASSERT( rc == ERR_VALUE_OUTOFRANGE );
rc = semOp.unlockSem( sid, 1 );
CPPUNIT_ASSERT( rc == ERR_NO_SEM_LOCK );
rc = semOp.unlockSem( sid + 1, 2 );
CPPUNIT_ASSERT( rc == ERR_UNLOCK_FAIL );
printf( "\nunlock one in 2" );
rc = semOp.unlockSem( sid, 2 );
CPPUNIT_ASSERT( rc == NO_ERROR );
CPPUNIT_ASSERT( semOp.getVal( sid, 2 ) == 1 );
semOp.printAllVal( sid );
semOp.deleteSem( sid );
CPPUNIT_ASSERT( semOp.existSem( sid, key ) == false );
CPPUNIT_ASSERT( semOp.getSemCount( sid + 1 ) == 0 );
}
void testLog()
{
Log log;
string msg;
int iVal = 3;
float fVal = 2.0;
log.setLogFileName( "test1.log", "test1err.log" );
msg = Convertor::int2Str( iVal );
log.logMsg( msg + " this is a info message", INFO );
msg = Convertor::getTimeStr();
log.logMsg( Convertor::float2Str( fVal ) + " this is a warning message", WARNING );
log.logMsg( "this is an error message ", 1011, ERROR );
log.logMsg( "this is a critical message", 1211, CRITICAL );
//...Test formatting an unsigned 64 bit integer.
uint64_t i64Value(UINT64_MAX);
msg = Convertor::i64ToStr( i64Value );
CPPUNIT_ASSERT( (msg == "18446744073709551615") );
log.logMsg( msg + " this is an info message with the max uint64_t integer value", INFO );
}
void testHWM()
{
int rc ;
int hwm = 0;
int allocSize = 0, allocSize1 = 0;
OID oid = 999;
DbFileOp dbFileOp;
VER_t transId = 11;
BRMWrapper::setUseBrm(true);
BRMWrapper::getInstance()->rollBack( transId );
// create something to increase LBID number
dbFileOp.deleteFile( oid - 1 );
rc = dbFileOp.createFile( oid - 1, 10, allocSize1 );
CPPUNIT_ASSERT( rc == NO_ERROR );
dbFileOp.deleteFile( oid );
CPPUNIT_ASSERT( dbFileOp.exists( oid ) == false );
CPPUNIT_ASSERT( dbFileOp.createFile( oid, 10, allocSize1 ) == NO_ERROR );
rc = BRMWrapper::getInstance()->getHWM( oid, hwm);
CPPUNIT_ASSERT( rc == NO_ERROR );
hwm = 10;
rc = BRMWrapper::getInstance()->setHWM( oid, hwm );
CPPUNIT_ASSERT( rc == NO_ERROR );
rc = BRMWrapper::getInstance()->getHWM( oid, hwm);
CPPUNIT_ASSERT( rc == NO_ERROR );
CPPUNIT_ASSERT( hwm == 10 );
rc = BRMWrapper::getInstance()->allocateExtent( oid, -1, allocSize);
CPPUNIT_ASSERT( rc != NO_ERROR );
rc = BRMWrapper::getInstance()->allocateExtent( oid, 20, allocSize);
CPPUNIT_ASSERT( rc == NO_ERROR );
CPPUNIT_ASSERT( allocSize > 0 );
}
void testVB()
{
FileOp fileOp;
FILE* pFile;
OID oid = 999;
LBIDRange range;
vector<struct LBIDRange> rangeList;
vector<uint32_t> fboList;
uint64_t curLbid;
int rc;
VER_t transId = 11;
BRMWrapper::getInstance()->setDebugLevel( DEBUG_3 );
// change fbo 3
rc = BRMWrapper::getInstance()->getBrmInfo( oid, 3, curLbid );
CPPUNIT_ASSERT( rc == NO_ERROR );
CPPUNIT_ASSERT( curLbid >= 0 );
range.start = 0;
range.size = 1;
rangeList.push_back( range );
printf( "\ncur lbid=%ld", (long)curLbid );
pFile = fileOp.openFile( oid );
CPPUNIT_ASSERT( pFile != NULL );
fboList.push_back( 3 );
rc = BRMWrapper::getInstance()->writeVB( pFile, transId, oid, fboList, rangeList );
CPPUNIT_ASSERT( rc == NO_ERROR );
rc = BRMWrapper::getInstance()->writeVB( pFile, transId, oid, fboList, rangeList );
CPPUNIT_ASSERT( rc == NO_ERROR );
// commit
rc = BRMWrapper::getInstance()->commit( transId );
CPPUNIT_ASSERT( rc == NO_ERROR );
// write to the same block
transId++;
rc = BRMWrapper::getInstance()->writeVB( pFile, transId, oid, fboList, rangeList );
CPPUNIT_ASSERT( rc == NO_ERROR );
// commit
rc = BRMWrapper::getInstance()->commit( transId );
CPPUNIT_ASSERT( rc == NO_ERROR );
// the same block should be locked by BRM
transId++;
rc = BRMWrapper::getInstance()->writeVB( pFile, transId, oid, fboList, rangeList );
CPPUNIT_ASSERT( rc == NO_ERROR );
transId++;
// rollback
fboList[0] += 1;
rangeList[0].start += 1;
rc = BRMWrapper::getInstance()->writeVB( pFile, transId, oid, fboList, rangeList );
CPPUNIT_ASSERT( rc == NO_ERROR );
rc = BRMWrapper::getInstance()->commit( transId );
CPPUNIT_ASSERT( rc == NO_ERROR );
transId++;
// write lbid
rc = BRMWrapper::getInstance()->writeVB( pFile, transId, oid, curLbid + 5);
CPPUNIT_ASSERT( rc == NO_ERROR );
rc = BRMWrapper::getInstance()->writeVB( pFile, transId, oid, curLbid + 6);
CPPUNIT_ASSERT( rc == NO_ERROR );
rc = BRMWrapper::getInstance()->commit( transId );
CPPUNIT_ASSERT( rc == NO_ERROR );
fileOp.closeFile( pFile );
// test rollback whether can write back the original value after three insert
printf( "\n\nThis is the test for rollback after three insert for the same trans\n" );
DbFileOp dbFileOp;
DataBlock block, originBlock;
uint64_t lbid0;
pFile = dbFileOp.openFile( oid );
CPPUNIT_ASSERT( pFile != NULL );
BRMWrapper::getInstance()->getBrmInfo( oid, 10, lbid0 );
memset( block.data, 'a', BYTE_PER_BLOCK );
rc = dbFileOp.writeDBFile( pFile, block.data, lbid0 );
CPPUNIT_ASSERT( rc == NO_ERROR );
rc = dbFileOp.readDBFile( pFile, originBlock.data, lbid0 );
CPPUNIT_ASSERT( rc == NO_ERROR );
transId++;
fboList.clear();
fboList.push_back( 10 );
// first time
rc = BRMWrapper::getInstance()->writeVB( pFile, transId, oid, fboList );
CPPUNIT_ASSERT( rc == NO_ERROR );
memset( block.data, 'b', BYTE_PER_BLOCK );
rc = dbFileOp.writeDBFile( pFile, block.data, lbid0 );
CPPUNIT_ASSERT( rc == NO_ERROR );
// second time
rc = BRMWrapper::getInstance()->writeVB( pFile, transId, oid, fboList );
CPPUNIT_ASSERT( rc == NO_ERROR );
memset( block.data, 'c', BYTE_PER_BLOCK );
rc = dbFileOp.writeDBFile( pFile, block.data, lbid0 );
CPPUNIT_ASSERT( rc == NO_ERROR );
// third time
rc = BRMWrapper::getInstance()->writeVB( pFile, transId, oid, fboList );
CPPUNIT_ASSERT( rc == NO_ERROR );
memset( block.data, 'd', BYTE_PER_BLOCK );
rc = dbFileOp.writeDBFile( pFile, block.data, lbid0 );
CPPUNIT_ASSERT( rc == NO_ERROR );
fflush(pFile);
rc = BRMWrapper::getInstance()->rollBack( transId );
CPPUNIT_ASSERT( rc == NO_ERROR );
fflush(pFile);
rc = dbFileOp.readDBFile( pFile, block.data, lbid0 );
CPPUNIT_ASSERT( rc == NO_ERROR );
CPPUNIT_ASSERT( memcmp( block.data, originBlock.data, BYTE_PER_BLOCK ) == 0 );
// test commit twice and rollback to see whether rollback commit values
printf( "\n\nThis is the test for commit twice and then rollback to see whether the previous two committed one got rollback\n" );
// first commit
transId++;
rc = BRMWrapper::getInstance()->writeVB( pFile, transId, oid, fboList );
CPPUNIT_ASSERT( rc == NO_ERROR );
memset( block.data, 'e', BYTE_PER_BLOCK );
rc = dbFileOp.writeDBFile( pFile, block.data, lbid0 );
CPPUNIT_ASSERT( rc == NO_ERROR );
rc = BRMWrapper::getInstance()->commit( transId );
CPPUNIT_ASSERT( rc == NO_ERROR );
// second commit
transId++;
rc = BRMWrapper::getInstance()->writeVB( pFile, transId, oid, fboList );
CPPUNIT_ASSERT( rc == NO_ERROR );
memset( block.data, 'f', BYTE_PER_BLOCK );
rc = dbFileOp.writeDBFile( pFile, block.data, lbid0 );
CPPUNIT_ASSERT( rc == NO_ERROR );
fflush(pFile);
rc = BRMWrapper::getInstance()->commit( transId );
CPPUNIT_ASSERT( rc == NO_ERROR );
memcpy( originBlock.data, block.data, BYTE_PER_BLOCK );
// rollback
transId++;
rc = BRMWrapper::getInstance()->writeVB( pFile, transId, oid, fboList );
CPPUNIT_ASSERT( rc == NO_ERROR );
memset( block.data, 'g', BYTE_PER_BLOCK );
rc = dbFileOp.writeDBFile( pFile, block.data, lbid0 );
CPPUNIT_ASSERT( rc == NO_ERROR );
fflush(pFile);
rc = BRMWrapper::getInstance()->rollBack( transId );
CPPUNIT_ASSERT( rc == NO_ERROR );
// check whether they are the same one
rc = dbFileOp.readDBFile( pFile, block.data, lbid0 );
CPPUNIT_ASSERT( rc == NO_ERROR );
fflush(pFile);
CPPUNIT_ASSERT( memcmp( block.data, originBlock.data, BYTE_PER_BLOCK ) == 0 );
}
void testDM()
{
FileOp fileOp;
char fileName[FILE_NAME_SIZE];
int rc;
rc = fileOp.oid2FileName( 100, fileName, true );
CPPUNIT_ASSERT( rc == NO_ERROR );
rc = fileOp.oid2FileName( 3071, fileName, true );
CPPUNIT_ASSERT( rc == NO_ERROR );
}
void testCacheBasic()
{
DataBlock block;
OID oid = 15;
uint64_t lbid = 1234, fbo = 3;
int rc;
CacheKey key;
CommBlock cb;
Cache::init();
cb.file.oid = oid;
memset( block.data, 'a', BYTE_PER_BLOCK );
rc = Cache::insertLRUList( cb, lbid, fbo, block );
CPPUNIT_ASSERT( rc == NO_ERROR );
CPPUNIT_ASSERT( Cache::cacheKeyExist( oid, lbid ) == true );
// add a second block
block.data[1] = '1';
lbid = 1235;
rc = Cache::insertLRUList( cb, lbid, fbo, block );
CPPUNIT_ASSERT( rc == NO_ERROR );
CPPUNIT_ASSERT( Cache::cacheKeyExist( oid, lbid ) == true );
// add one more block
block.data[1] = '2';
lbid = 1237;
rc = Cache::insertLRUList( cb, lbid, fbo, block );
CPPUNIT_ASSERT( rc == NO_ERROR );
CPPUNIT_ASSERT( Cache::cacheKeyExist( oid, lbid ) == true );
// load one from lruList
memset( block.data, 0, BYTE_PER_BLOCK );
lbid = 1235;
key = Cache::getCacheKey( oid, lbid );
rc = Cache::loadCacheBlock( key, block );
CPPUNIT_ASSERT( rc == NO_ERROR );
CPPUNIT_ASSERT( block.data[1] == '1' );
CPPUNIT_ASSERT( block.data[2] == 'a' );
// move one block from lrulist to write list
block.data[2] = 'm';
rc = Cache::modifyCacheBlock( key, block );
CPPUNIT_ASSERT( rc == NO_ERROR );
memset( block.data, 0, BYTE_PER_BLOCK ); // clear
rc = Cache::loadCacheBlock( key, block );
CPPUNIT_ASSERT( rc == NO_ERROR );
CPPUNIT_ASSERT( block.data[2] == 'm' );
Cache::printCacheList();
// flush cache
Cache::flushCache();
Cache::printCacheList();
// shutdown
// Cache::freeMemory();
}
void testCacheReadWrite()
{
DbFileOp dbFileOp;
DataBlock block;
CommBlock cb;
OID oid = 16;
uint64_t lbid = 1234;
int rc, totalBlock;
int allocSize = 0;
BRMWrapper::setUseBrm(true);
dbFileOp.setTransId( 3 );
Cache::clear();
cb.session.txnid = 10;
cb.file.oid = oid;
dbFileOp.deleteFile( oid );
CPPUNIT_ASSERT( dbFileOp.exists( oid ) == false );
CPPUNIT_ASSERT( dbFileOp.createFile( oid, 10, allocSize ) == NO_ERROR );
cb.file.pFile = dbFileOp.openFile( oid );
CPPUNIT_ASSERT( cb.file.pFile != NULL );
BRMWrapper::getInstance()->getBrmInfo( oid, 3, lbid );
Cache::setUseCache( true );
Cache::clear();
int size;
size = Cache::getListSize( FREE_LIST );
CPPUNIT_ASSERT( size == DEFAULT_CACHE_BLOCK );
size = Cache::getListSize( WRITE_LIST );
CPPUNIT_ASSERT( size == 0 );
totalBlock = Cache::getTotalBlock();
for ( long i = 0; i < totalBlock; i++ )
{
rc = dbFileOp.readDBFile( cb, block.data, lbid );
CPPUNIT_ASSERT( rc == NO_ERROR );
block.data[1] = 'k';
rc = dbFileOp.writeDBFile( cb, block.data, lbid );
CPPUNIT_ASSERT( rc == NO_ERROR );
lbid++;
if ( i == DEFAULT_CACHE_BLOCK - 20 )
BRMWrapper::getInstance()->getBrmInfo( oid, 3, lbid );
if ( i % 5000 == 0 && i != 0 )
{
printf( "\ni=%ld", i );
Cache::printCacheList();
}
if ( i == totalBlock - 2 )
{
dbFileOp.flushCache();
Cache::setUseCache( false );
}
}
}
void testCleanup()
{
// shutdown
Cache::freeMemory();
}
};
CPPUNIT_TEST_SUITE_REGISTRATION( SharedTest );
#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