database/mariadb-columnstore-engine
1
0
Fork 0
mirror of https://github.com/mariadb-corporation/mariadb-columnstore-engine.git synced 2025-04-18 21:44:02 +03:00
Code
mariadb-columnstore-engine/writeengine/dictionary/qdctnry.cpp
Leonid Fedorov 04752ec546 clang format apply
2022-01-21 16:43:49 +00:00

806 lines
22 KiB
C++
Raw Permalink 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>
using namespace std;
#include <boost/scoped_ptr.hpp>
using namespace boost;
#include <cppunit/extensions/HelperMacros.h>
#include "we_dctnry.h"
#include "we_dctnrystore.h"
using namespace WriteEngine;
class DctnryTest : public CppUnit::TestFixture
{
CPPUNIT_TEST_SUITE(DctnryTest);
// Dctnry basic testing
// CPPUNIT_TEST( testDctnryInsertLarge );
// CPPUNIT_TEST( testDctnryInsertDelete );
/// CPPUNIT_TEST( testDctnryInsertStress);
// CPPUNIT_TEST( testGetBlockHdr);
// CPPUNIT_TEST( testGetFreeSpace);
CPPUNIT_TEST(testDctnryInsertDeleteStore);
CPPUNIT_TEST_SUITE_END();
private:
Dctnry m_Dctnry;
DctnryStore m_DctnryStore;
int m_oId;
public:
void setUp()
{
}
void tearDown()
{
}
DctnryTest()
{
m_oId = 0;
}
void testDctnryInsertLarge()
{
int oId = 2000;
// int blockCount =10;
FILE* dFile = NULL;
int rc = 0;
DataBlock curBlock;
// int largeSize=6144;
int largeSize = 2724;
int smallSize = 2032;
uint16_t freeSpace;
uint64_t nextPtr;
uint16_t offSet0;
uint16_t endHeader;
unsigned char dctnryHeader[14];
m_Dctnry.setUseSmallSize(false);
m_Dctnry.setDebugLevel(DEBUG_3);
m_oId = oId;
memset(curBlock.data, 0, sizeof(curBlock.data));
memset(dctnryHeader, 0, sizeof(dctnryHeader));
printf("\nRunning testDctnryInsertLarge \n");
rc = m_Dctnry.deleteFile(oId);
rc = m_Dctnry.createDctnry(oId, 3);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_Dctnry.openDctnry(oId);
CPPUNIT_ASSERT(rc == NO_ERROR);
dFile = m_Dctnry.getDctnryFile();
CPPUNIT_ASSERT(dFile != NULL);
rc = m_Dctnry.initDctnryHdr(dFile);
CPPUNIT_ASSERT(rc == NO_ERROR);
m_Dctnry.closeDctnry();
printf("After initDctnryHdr \n");
testGetBlockHdr();
// dFile= m_Dctnry.openFile( oId);
rc = m_Dctnry.openDctnry();
CPPUNIT_ASSERT(rc == NO_ERROR);
dFile = m_Dctnry.getDctnryFile();
CPPUNIT_ASSERT(dFile != NULL);
// 12 for 6 bytes and 14 for 8 bytes
rc = m_Dctnry.readSubBlockEntry(dFile, &curBlock, 0, 0, 0, 14, &dctnryHeader);
CPPUNIT_ASSERT(rc == NO_ERROR);
memcpy(&freeSpace, dctnryHeader, 2);
memcpy(&nextPtr, dctnryHeader + 2, 8); // 8 bytes
memcpy(&offSet0, dctnryHeader + 10, 2);
memcpy(&endHeader, dctnryHeader + 12, 2);
unsigned char sgnature_value[largeSize];
memset(sgnature_value, 0, sizeof(sgnature_value));
int j = 0;
for (int i = 0; i < largeSize; i++)
{
// if (j>255)
// j=0;
sgnature_value[i] = 119;
// j++;
}
// insert a signature value
Token token;
rc = m_Dctnry.insertDctnry(dFile, largeSize, sgnature_value, token);
CPPUNIT_ASSERT(rc == NO_ERROR);
testGetBlockHdr();
rc = m_Dctnry.insertDctnry(dFile, largeSize, sgnature_value, token);
CPPUNIT_ASSERT(rc == NO_ERROR);
testGetBlockHdr();
rc = m_Dctnry.insertDctnry(dFile, largeSize, sgnature_value, token);
CPPUNIT_ASSERT(rc == NO_ERROR);
testGetBlockHdr();
token.fbo = 0;
token.op = 3;
rc = m_Dctnry.deleteDctnryValue(dFile, token);
testGetBlockHdr();
rc = m_Dctnry.insertDctnry(dFile, largeSize, sgnature_value, token);
CPPUNIT_ASSERT(rc == NO_ERROR);
testGetBlockHdr();
return;
// add the same dictionary again. it should not be added
rc = m_Dctnry.insertDctnry(dFile, largeSize, sgnature_value, token);
testGetBlockHdr();
// add the same dictionary again. it should not be added to the next block
rc = m_Dctnry.insertDctnry(dFile, largeSize, sgnature_value, token);
testGetBlockHdr();
printf("token fbo = %i", token.fbo);
printf("token op = %i", token.op);
token.fbo = 0;
token.op = 2;
// token.op++;
rc = m_Dctnry.deleteDctnryValue(dFile, token);
testGetBlockHdr();
return;
// add a 2nd dictionary to fillup the whole file block
unsigned char sgnature_value_s[smallSize];
memset(sgnature_value_s, 0, sizeof(sgnature_value_s));
for (int i = 0; i < smallSize; i++)
{
// if (j>255)
// j=0;
sgnature_value_s[i] = 118;
// j++;
}
// insert a signature value
rc = m_Dctnry.insertDctnry(dFile, smallSize, sgnature_value_s, token);
CPPUNIT_ASSERT(rc == NO_ERROR);
testGetBlockHdr();
return;
// insert a signature value
Token token3;
rc = m_Dctnry.insertDctnry(dFile, largeSize, sgnature_value, token3);
CPPUNIT_ASSERT(rc == NO_ERROR);
m_Dctnry.closeDctnry(dFile);
printf("After insert dictionary \n");
testGetBlockHdr();
rc = m_Dctnry.openDctnry(oId);
CPPUNIT_ASSERT(rc == NO_ERROR);
dFile = m_Dctnry.getDctnryFile();
rc = m_Dctnry.deleteDctnryValue(dFile, token);
m_Dctnry.closeDctnry(dFile);
printf("After delete dictionary \n");
testGetBlockHdr();
CPPUNIT_ASSERT(rc == NO_ERROR);
j = 255;
for (int i = 0; i < smallSize; i++)
{
if (j == 0)
j = 255;
sgnature_value[i] = j;
j--;
}
// insert another signature value
rc = m_Dctnry.openDctnry(oId);
CPPUNIT_ASSERT(rc == NO_ERROR);
dFile = m_Dctnry.getDctnryFile();
CPPUNIT_ASSERT(dFile != NULL);
Token token2;
rc = m_Dctnry.insertDctnry(dFile, smallSize, sgnature_value, token2);
CPPUNIT_ASSERT(rc == NO_ERROR);
m_Dctnry.closeDctnry(dFile);
printf("After insert dictionary \n");
testGetBlockHdr();
m_Dctnry.dropDctnry(oId);
return;
} // testDctnryInsert
void testDctnryInsertDelete()
{
int oId = 2001;
// int blockCount =10;
FILE* dFile = NULL;
int rc = 0;
DataBlock curBlock;
int largeSize = 9000;
int smallSize = 1000;
unsigned char dctnryHeader[14];
uint16_t freeSpace;
uint64_t nextPtr;
uint16_t offSet0;
uint16_t endHeader;
m_Dctnry.setDebugLevel(DEBUG_3);
m_Dctnry.setUseSmallSize(true);
m_oId = oId;
memset(curBlock.data, 0, sizeof(curBlock.data));
memset(dctnryHeader, 0, sizeof(dctnryHeader));
printf("\nRunning testDctnryInsertDelete \n");
rc = m_Dctnry.deleteFile(oId);
rc = m_Dctnry.createDctnry((FID)-1);
CPPUNIT_ASSERT(rc == ERR_OPEN_FILE);
rc = m_Dctnry.createDctnry(oId, 10);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_Dctnry.openDctnry();
dFile = m_Dctnry.getDctnryFile();
CPPUNIT_ASSERT(dFile != NULL);
rc = m_Dctnry.initDctnryHdr(dFile);
CPPUNIT_ASSERT(rc == NO_ERROR);
// CPPUNIT_ASSERT(rc==NO_ERROR);
// m_Dctnry.closeFile(dFile);
m_Dctnry.closeDctnry();
printf("After initDctnryHdr");
testGetBlockHdr();
// testGetFreeSpace();
rc = m_Dctnry.openDctnry();
CPPUNIT_ASSERT(rc == NO_ERROR);
dFile = m_Dctnry.getDctnryFile();
CPPUNIT_ASSERT(dFile != NULL);
// 12 for 6 bytes and 14 for 8 bytes
rc = m_Dctnry.readSubBlockEntry(dFile, &curBlock, 0, 0, 0, 14, &dctnryHeader);
CPPUNIT_ASSERT(rc == NO_ERROR);
memcpy(&freeSpace, dctnryHeader, 2);
memcpy(&nextPtr, dctnryHeader + 2, 8); // 8 bytes
memcpy(&offSet0, dctnryHeader + 10, 2);
memcpy(&endHeader, dctnryHeader + 12, 2);
unsigned char sgnature_value[largeSize];
memset(sgnature_value, 0, sizeof(sgnature_value));
int j = 0;
for (int i = 0; i < largeSize; i++)
{
if (j > 255)
j = 0;
sgnature_value[i] = j;
j++;
}
// insert a signature value
Token token;
rc = m_Dctnry.insertDctnry(dFile, largeSize, sgnature_value, token);
CPPUNIT_ASSERT(rc == ERR_DICT_SIZE_GT_8000);
largeSize = 6000;
Token token3;
for (int i = 0; i < largeSize; i++)
{
if (j > 255)
j = 0;
sgnature_value[i] = j;
j++;
}
rc = m_Dctnry.insertDctnry(dFile, largeSize, sgnature_value, token3);
CPPUNIT_ASSERT(rc == NO_ERROR);
CPPUNIT_ASSERT(token3.fbo == 0);
CPPUNIT_ASSERT(token3.op == 1);
m_Dctnry.closeDctnry(dFile);
printf("After insert token 3 into dictionary \n");
testGetBlockHdr();
rc = m_Dctnry.openDctnry();
CPPUNIT_ASSERT(rc == NO_ERROR);
dFile = m_Dctnry.getDctnryFile();
CPPUNIT_ASSERT(dFile != NULL);
j = 255;
for (int i = 0; i < smallSize; i++)
{
if (j == 0)
j = 255;
sgnature_value[i] = j;
j--;
}
// insert another signature value
Token token2;
rc = m_Dctnry.insertDctnry(dFile, smallSize, sgnature_value, token2);
CPPUNIT_ASSERT(rc == NO_ERROR);
CPPUNIT_ASSERT(rc == NO_ERROR);
CPPUNIT_ASSERT(token2.fbo == 0);
CPPUNIT_ASSERT(token2.op == 2);
m_Dctnry.closeDctnry(dFile);
printf("After insert token 2 into dictionary \n");
testGetBlockHdr();
// delete
memset(&token, 0, sizeof(token));
rc = m_Dctnry.openDctnry();
CPPUNIT_ASSERT(rc == NO_ERROR);
dFile = m_Dctnry.getDctnryFile();
CPPUNIT_ASSERT(dFile != NULL);
// token dose not exist in dictionary
rc = m_Dctnry.deleteDctnryValue(dFile, token);
CPPUNIT_ASSERT(rc == ERR_DICT_NO_OP_DELETE);
// rc =m_Dctnry.deleteDctnryValue( dFile, token3);
rc = m_Dctnry.deleteDctnryValue(dFile, token2);
CPPUNIT_ASSERT(rc == NO_ERROR);
m_Dctnry.closeDctnry();
printf("After delete dictionary token2 \n");
testGetBlockHdr();
// delete right after
rc = m_Dctnry.openDctnry();
CPPUNIT_ASSERT(rc == NO_ERROR);
dFile = m_Dctnry.getDctnryFile();
CPPUNIT_ASSERT(dFile != NULL);
// rc =m_Dctnry.deleteDctnryValue( dFile, token2);
rc = m_Dctnry.deleteDctnryValue(dFile, token3);
CPPUNIT_ASSERT(rc == NO_ERROR);
// m_Dctnry.closeFile( dFile );
m_Dctnry.closeDctnry();
printf("After delete dictionary token3\n");
testGetBlockHdr();
rc = m_Dctnry.openDctnry();
CPPUNIT_ASSERT(rc == NO_ERROR);
dFile = m_Dctnry.getDctnryFile();
CPPUNIT_ASSERT(dFile != NULL);
// rc =m_Dctnry.deleteDctnryValue( dFile, token2);
rc = m_Dctnry.deleteDctnryValue(dFile, token3);
CPPUNIT_ASSERT(rc == ERR_DICT_NO_OP_DELETE);
rc = m_Dctnry.deleteDctnryValue(dFile, token2);
CPPUNIT_ASSERT(rc == ERR_DICT_NO_OP_DELETE);
// CPPUNIT_ASSERT( rc == ERR_DICT_ZERO_LEN );
m_Dctnry.closeDctnry();
return;
} // testDctnryInsertDelete
void testDctnryInsertStress()
{
int oId = 2002;
int blockCount = 2;
FILE* dFile = NULL;
int rc = 0;
DataBlock curBlock;
int smallSize = 1000;
uint16_t freeSpace;
Offset hdrOffsets[4039];
int opCount = 0;
m_Dctnry.setDebugLevel(DEBUG_3);
m_Dctnry.setUseSmallSize(true);
m_oId = oId;
memset(curBlock.data, 0, sizeof(curBlock.data));
memset(hdrOffsets, 0, sizeof(hdrOffsets));
printf("\nRunning testDctnryInsertStress \n");
rc = m_Dctnry.deleteFile(oId);
rc = m_Dctnry.createFile(oId, blockCount);
dFile = m_Dctnry.openFile(oId);
CPPUNIT_ASSERT(dFile != NULL);
rc = m_Dctnry.initDctnryHdr(dFile);
CPPUNIT_ASSERT(rc == NO_ERROR);
// m_Dctnry.closeFile(dFile);
m_Dctnry.closeDctnry();
printf("After initDctnryHdr");
testGetBlockHdr();
dFile = m_Dctnry.openFile(oId);
unsigned char sgnature_value[smallSize];
Token token[100];
int i, j, k;
j = 255;
for (k = 0; k < 18; k++)
{
for (int i = 0; i < smallSize; i++)
{
if (j == 0)
j = 255;
sgnature_value[i] = k;
j--;
} // endfor i
rc = m_Dctnry.insertDctnry(dFile, smallSize, sgnature_value, token[k]);
if (rc != NO_ERROR)
{
printf("k: %i Error Code is: %i \n", k, rc);
// return;
}
if (k > 15)
{
CPPUNIT_ASSERT(rc != NO_ERROR);
printf("294. Error code is: %i \n", rc);
}
else
CPPUNIT_ASSERT(rc == NO_ERROR);
} // endfor k
Offset prevOffset, curOffset;
j = 0;
unsigned char* value = NULL;
// This is to get the value out
for (i = 0; i < blockCount; i++)
{
rc = m_Dctnry.readSubBlockEntry(dFile, &curBlock, i, 0, 0, 2, &freeSpace);
CPPUNIT_ASSERT(rc == NO_ERROR);
j = 0;
prevOffset.hdrLoc = 2 + 8; // 8 bytes
memcpy(&(prevOffset.offset), &(curBlock.data[prevOffset.hdrLoc]), 2);
curOffset.hdrLoc = prevOffset.hdrLoc + 2;
memcpy(&(curOffset.offset), &(curBlock.data[curOffset.hdrLoc]), 2);
int op = 1;
int size = prevOffset.offset - curOffset.offset;
value = (unsigned char*)malloc(sizeof(unsigned char) * size);
memcpy(value, &curBlock.data[curOffset.offset], size);
while (curOffset.offset != 0xFFFF)
{
// printf("fbo: %i op: %i starting offset: %i ending offset %i size: %i \n",
// i, op, curOffset.offset, prevOffset.offset, size);
// printf("value : ");
for (k = 0; k < size; k++)
{
// printf("%u",value[k]);
}
// printf("\n");
// start again
free(value);
value = NULL;
prevOffset.hdrLoc = curOffset.hdrLoc;
prevOffset.offset = curOffset.offset;
curOffset.hdrLoc += 2;
memcpy(&(curOffset.offset), &curBlock.data[curOffset.hdrLoc], 2);
size = prevOffset.offset - curOffset.offset;
if (curOffset.offset != 0xFFFF)
{
value = (unsigned char*)malloc(sizeof(unsigned char) * size);
memcpy(value, &curBlock.data[curOffset.offset], size);
}
op++;
} // end while
// Get Offset info
m_Dctnry.closeDctnry();
printf("After insertDctnry");
testGetBlockHdr();
dFile = m_Dctnry.openFile(oId);
CPPUNIT_ASSERT(dFile != NULL);
m_Dctnry.getBlockHdr(dFile, i, opCount, hdrOffsets);
int opCount2 = 0;
for (k = 0; k < opCount; k++)
{
Token token;
token.fbo = i;
token.op = k + 1;
rc = m_Dctnry.findTokenValue(dFile, token, sgnature_value, size);
CPPUNIT_ASSERT(rc == NO_ERROR);
CPPUNIT_ASSERT(size == smallSize);
rc = m_Dctnry.deleteDctnryValue(dFile, token);
printf("After deleteDctnryValue fbo %i op %i\n", (int)i, k + 1);
m_Dctnry.getBlockHdr(dFile, i, opCount2, hdrOffsets);
Offset startOffset, endOffset;
printf("Header Info for fbo: %i \n %i %llu ", i, (int)m_Dctnry.getFree(), m_Dctnry.getNextPtr());
endOffset.hdrLoc = 10;
endOffset.offset = 8192;
printf("%i ", endOffset.offset);
for (int k1 = 0; k1 < opCount2; k1++)
{
startOffset.hdrLoc = hdrOffsets[k1].hdrLoc;
startOffset.offset = hdrOffsets[k1].offset;
printf("%i ", startOffset.offset);
} // end for k1
rc = m_Dctnry.deleteDctnryValue(dFile, token);
printf("%x \n", 0xFFFF);
printf("k-> %i i-> %i error code -> %i \n ", k, i, rc);
if (k < opCount - 1)
CPPUNIT_ASSERT(rc == ERR_DICT_ZERO_LEN);
else
CPPUNIT_ASSERT(rc == ERR_DICT_NO_OP_DELETE);
} // end for k
} // end for i
// m_Dctnry.closeFile( dFile );
char sigString[] =
"Hello, I am a string; what are you? I am testing dictionary as a signature value, I don't know how "
"long I am but we will find out in a minute";
int sigStringSize = strlen(sigString);
char resultString[sigStringSize + 1];
Token stringToken;
rc = m_Dctnry.insertDctnry(dFile, sigStringSize, (unsigned char*)sigString, stringToken);
rc = m_Dctnry.findTokenValue(dFile, stringToken, (unsigned char*)resultString, sigStringSize);
resultString[sigStringSize] = '\0';
printf("result String is %s --->size is %i\n", resultString, strlen(resultString));
m_Dctnry.closeDctnry();
printf("After insert the result string, the header look like the following:\n");
testGetBlockHdr();
return;
} // testDctnryInsertStress
void testGetBlockHdr()
{
int blockCount = 2;
int oId = 2002;
int i = 0, k = 0;
FILE* dFile;
int opCount;
Offset hdrOffsets[4040];
memset(hdrOffsets, 0, sizeof(hdrOffsets));
m_Dctnry.setDebugLevel(DEBUG_3);
printf("\nRunning testGetBlockHdr \n");
dFile = m_Dctnry.openFile(m_oId);
if (dFile == NULL)
dFile = m_Dctnry.openFile(oId);
CPPUNIT_ASSERT(dFile != NULL);
blockCount = m_Dctnry.getFileSize(dFile) / BYTE_PER_BLOCK;
for (i = 0; i < blockCount; i++)
{
m_Dctnry.getBlockHdr(dFile, i, opCount, hdrOffsets);
Offset startOffset, endOffset;
int sigSize;
printf("Header Info for fbo: %i \n %i %llu ", i, (int)m_Dctnry.getFree(), m_Dctnry.getNextPtr());
// printf(" fbo %i total offset number %i \n", i, opCount);
endOffset.hdrLoc = 10;
endOffset.offset = 8192;
printf("%i ", endOffset.offset);
for (k = 0; k < opCount; k++)
{
startOffset.hdrLoc = hdrOffsets[k].hdrLoc;
startOffset.offset = hdrOffsets[k].offset;
sigSize = endOffset.offset - startOffset.offset;
// printf(" OP %i signature size : %i \n from %i to %i \n", k+1,
// sigSize, startOffset.offset,endOffset.offset );
endOffset.hdrLoc = startOffset.hdrLoc;
endOffset.offset = startOffset.offset;
printf("%i ", endOffset.offset);
} // end for k
printf("%x \n", 0xFFFF);
} // endfor i
m_Dctnry.closeDctnry();
}
void testGetFreeSpace()
{
int oId = 2002;
FILE* dFile;
m_Dctnry.setDebugLevel(DEBUG_1);
printf("\nRunning testGetFreeSpace \n");
dFile = m_Dctnry.openFile(m_oId);
if (dFile == NULL)
dFile = m_Dctnry.openFile(oId);
CPPUNIT_ASSERT(dFile != NULL);
m_Dctnry.getFreeSpaceArray(dFile);
for (int i = 0; i < m_Dctnry.getNumBlocks(); i++)
{
printf("fbo %i -->free space:%i \n", i, m_Dctnry.m_freeSpaceArray[i]);
}
m_Dctnry.closeDctnry();
}
void testDctnryInsertDeleteStore()
{
int rc = 0;
int smallSize = 1000;
FID dctnryOID = 2002;
FID treeOID = 101;
FID listOID = 102;
m_DctnryStore.setDebugLevel(DEBUG_3);
printf("\nRunning testDctnryInsertDeleteStore \n");
rc = m_DctnryStore.dropDctnryStore(treeOID, dctnryOID, listOID);
// CPPUNIT_ASSERT( rc == NO_ERROR );
rc = m_DctnryStore.createDctnryStore(dctnryOID, treeOID, listOID);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_DctnryStore.dropDctnryStore(dctnryOID, treeOID, listOID);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_DctnryStore.createDctnryStore(dctnryOID, treeOID, listOID);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_DctnryStore.dropDctnryStore(treeOID, dctnryOID, listOID);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_DctnryStore.createDctnryStore(dctnryOID, treeOID, listOID);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_DctnryStore.dropDctnryStore();
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_DctnryStore.createDctnryStore(dctnryOID, treeOID, listOID);
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_DctnryStore.openDctnryStore(dctnryOID, treeOID, listOID);
CPPUNIT_ASSERT(rc == NO_ERROR);
m_DctnryStore.closeDctnryStore();
CPPUNIT_ASSERT(rc == NO_ERROR);
rc = m_DctnryStore.openDctnryStore();
CPPUNIT_ASSERT(rc == NO_ERROR);
unsigned char sgnature_value[smallSize];
Token token[100];
memset(token, 0, sizeof(token));
int i, j, k;
for (int i = 0; i < smallSize; i++)
{
// if (j>255)
// j=0;
sgnature_value[i] = 119;
// j++;
}
// insert a signature value
for (k = 1; k < 12; k++)
{
rc = m_DctnryStore.updateDctnryStore(sgnature_value, smallSize, token[k]);
printf("token fbo = %i", token[k].fbo);
printf("token op = %i", token[k].op);
}
testGetBlockHdr();
return;
rc = m_DctnryStore.updateDctnryStore(sgnature_value, smallSize, token[1]);
testGetBlockHdr();
// Recheck if the tokens are all inserted
for (k = 1; k < 99; k++)
{
for (i = 0; i < smallSize; i++)
{
if (j == 0)
j = 255;
if (k > 10)
sgnature_value[i] = k;
else
{
if (i < 8)
sgnature_value[i] = 1;
else
sgnature_value[i] = k;
}
j--;
} // endfor i ; second time
rc = m_DctnryStore.updateDctnryStore(sgnature_value, smallSize, token[k]);
if (rc != NO_ERROR)
{
printf("443. Attentione!!! ERROR CODE : %i \n", rc);
}
CPPUNIT_ASSERT(rc == NO_ERROR);
} // endof for k; second time
int tempSize = 7;
rc = m_DctnryStore.updateDctnryStore(sgnature_value, tempSize, token[k]);
if (rc != NO_ERROR)
{
printf("452. Predicted Error Code should be 1363: The result ERROR CODE : %i \n", rc);
}
CPPUNIT_ASSERT(rc == 1363);
tempSize = 8;
rc = m_DctnryStore.updateDctnryStore(sgnature_value, tempSize, token[k]);
if (rc != NO_ERROR)
{
printf("461. Attention!!! ERROR CODE : %i \n", rc);
}
CPPUNIT_ASSERT(rc == NO_ERROR);
for (i = 1; i < 99; i++)
{
if (m_DctnryStore.isDebug(DEBUG_3))
{
printf("i : %i token.fbo %i token.op %i \n", i, (int)token[i].fbo, (int)token[i].op);
}
}
for (i = 1; i < 99; i++)
{
rc = m_DctnryStore.deleteDctnryToken(token[i]);
if (rc != NO_ERROR)
{
printf("475 . Attention!!! ERROR CODE : %i \n", rc);
}
CPPUNIT_ASSERT(rc == NO_ERROR);
}
m_DctnryStore.closeDctnryStore();
// rc = m_DctnryStore.dropDctnryStore();
// CPPUNIT_ASSERT( rc == NO_ERROR );
return;
} // testDctnryInsertDeleteStore
};
CPPUNIT_TEST_SUITE_REGISTRATION(DctnryTest);
#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