/* 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);
}