/* 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_indextree.h"
#include "we_freemgr.h"
#include "we_indexlist.h"

using namespace WriteEngine;

typedef struct
{
  IdxRidListHdr hdrRec;
  IdxRidListPtr listPtr;
  int fbo;
  int sbid;
  int entry;
  int sbSeqNo;
  int recCnt;
  int sbCnt;
  int fullSbCnt;
} IdxListStat;

typedef struct
{
  int mapSize;
  int entryCnt;
} IdxFreeSpaceStat;

const int QA_FILE_TYPE_TREE = 1;
const int QA_FILE_TYPE_LIST = 2;

const int QA_FREEMAP_1ENTRY = 1;
const int QA_FREEMAP_2ENTRY = 2;
const int QA_FREEMAP_4ENTRY = 3;
const int QA_FREEMAP_8ENTRY = 4;
const int QA_FREEMAP_16ENTRY = 5;
const int QA_FREEMAP_32ENTRY = 6;

class IndexTest : public CppUnit::TestFixture
{
  CPPUNIT_TEST_SUITE(IndexTest);

  /* ====================================================
     Index stress test
     These tests will create the maxium number:
     1) index key records, one row ID for each
     2) row IDs for an index key
  ======================================================= */

  // CPPUNIT_TEST( testCreateIndex );

  /* ====================================================
     TTest Suites
     ======================================================= */

  CPPUNIT_TEST(qaTSCStressTestMaxRowID);
  // CPPUNIT_TEST(qaTSCStressTestMaxKey);
  // CPPUNIT_TEST(qaTSCIndexTestUpdate);
  // CPPUNIT_TEST(qaTSCIndexTestDelete);
  // CPPUNIT_TEST(qaTSCFreeSpaceMapTest);

  // CPPUNIT_TEST(qatestIndexList);

  CPPUNIT_TEST_SUITE_END();

 private:
  IndexTree m_index;
  IndexList m_indexlist;
  FILE* curFile;

 public:
  void setUp()
  {
  }

  void tearDown()
  {
  }

  /* ==========================================================
  Create maximum number of row ids for key and verify all
  index list header records
  ============================================================= */

  void qaTSCStressTestMaxRowID()
  {
    IdxFreeSpaceStat mapInfo;

    uint64_t idxKey = 1;
    int testCaseNo;
    int numOfRowID;
    int expSbCnt;
    int expFullSbCnt;
    char testCaseDesc[256];

    int tokenLen = 1;
    int rc;
    int execMode;

    m_index.setUseFreeMgr(true);
    m_index.setUseListMgr(true);
    execMode = 0;

    strcpy(testCaseDesc, "8 bit key, max row stress test");

    tokenLen = 8;
    testCaseNo = 10520;
    numOfRowID = 256;
    expSbCnt = 9;
    expFullSbCnt = 8;

    qaSupCreateMaxRowID(idxKey, tokenLen);
    qaTstIndexListDriver(testCaseNo, testCaseDesc, idxKey, tokenLen, numOfRowID, expSbCnt, expFullSbCnt);
    qaDspIndexListByKey(idxKey, tokenLen);

    strcpy(testCaseDesc, "16 bit key, max row stress test");

    testCaseNo = 10521;
    numOfRowID = 65536;
    expSbCnt = 2115;
    expFullSbCnt = 2114;

    qaSupCreateMaxRowID(idxKey, tokenLen);
    qaTstIndexListDriver(testCaseNo, testCaseDesc, idxKey, tokenLen, numOfRowID, expSbCnt, expFullSbCnt);
  }
  /* ==========================================================
  Create maximum number key for a given key length and
  verify each index list header record
  ============================================================= */

  void qaTSCStressTestMaxKey()
  {
    IdxFreeSpaceStat mapInfo;

    int testCaseNo;
    char testCaseDesc[256];
    int tokenLen;
    int entryCnt;
    int execMode;

    execMode = 1;
    //		qaSupCreateMaxHdrRec(tokenLen);

    strcpy(testCaseDesc, "8 bit key, max key stress test");

    tokenLen = 8;
    testCaseNo = 10522;

    qaSupCreateMaxHdrRec(tokenLen);
    qaTstStressMaxKeyDriver(testCaseNo, testCaseDesc, tokenLen);

    //		qaSupCreateMaxHdrRec(tokenLen);

    strcpy(testCaseDesc, "16 bit key, max key stress test");

    tokenLen = 16;
    testCaseNo = 10523;

    qaSupCreateMaxHdrRec(tokenLen);
    qaTstStressMaxKeyDriver(testCaseNo, testCaseDesc, tokenLen);
  }

  /* ==========================================================
  Test cases for for updating index
  ============================================================= */
  void qaTSCIndexTestUpdate()
  {
    uint64_t idxKey = 1;
    int tokenLen = 16;
    int testCaseNo;
    int startRowID = 1;
    int numOfRowID;
    int expSbCnt;
    int expFullSbCnt;
    char testCaseDesc[256];

    strcpy(testCaseDesc, "Create 1 index key with one row ID, expecting no sub block and no full sub block.");

    testCaseNo = 10524;
    numOfRowID = 1;
    expSbCnt = 0;
    expFullSbCnt = 0;

    qaSupCreateRangeRowID(idxKey, tokenLen, startRowID, numOfRowID);
    qaTstIndexListDriver(testCaseNo, testCaseDesc, idxKey, tokenLen, numOfRowID, expSbCnt, expFullSbCnt);

    strcpy(testCaseDesc, "Create 2 index key with one row ID, expecting no sub block and no full sub block.");

    testCaseNo = 10525;
    numOfRowID = 2;
    expSbCnt = 0;
    expFullSbCnt = 0;

    qaSupCreateRangeRowID(idxKey, tokenLen, startRowID, numOfRowID);
    qaTstIndexListDriver(testCaseNo, testCaseDesc, idxKey, tokenLen, numOfRowID, expSbCnt, expFullSbCnt);

    strcpy(testCaseDesc, "Create 3 index key with one row ID, expecting 1 sub block and no full sub block.");

    testCaseNo = 10526;
    numOfRowID = 3;
    expSbCnt = 1;
    expFullSbCnt = 0;

    qaSupCreateRangeRowID(idxKey, tokenLen, startRowID, numOfRowID);
    qaTstIndexListDriver(testCaseNo, testCaseDesc, idxKey, tokenLen, numOfRowID, expSbCnt, expFullSbCnt);

    strcpy(testCaseDesc, "Create 1 index key with 32 row IDs, expecting 1 sub block and 1 full sub block.");

    testCaseNo = 10527;
    numOfRowID = 32;
    expSbCnt = 1;
    expFullSbCnt = 1;

    qaSupCreateRangeRowID(idxKey, tokenLen, startRowID, numOfRowID);
    qaTstIndexListDriver(testCaseNo, testCaseDesc, idxKey, tokenLen, numOfRowID, expSbCnt, expFullSbCnt);

    strcpy(testCaseDesc, "Create 1 index key with 33 row IDs, expecting 2 sub block and 1 full sub block.");

    testCaseNo = 10528;
    numOfRowID = 33;
    expSbCnt = 2;
    expFullSbCnt = 1;

    qaSupCreateRangeRowID(idxKey, tokenLen, startRowID, numOfRowID);
    qaTstIndexListDriver(testCaseNo, testCaseDesc, idxKey, tokenLen, numOfRowID, expSbCnt, expFullSbCnt);

    strcpy(testCaseDesc, "Create 1 index key with 63 row IDs, expecting 2 sub block and 2 full sub block.");
    testCaseNo = 10529;
    numOfRowID = 63;
    expSbCnt = 2;
    expFullSbCnt = 2;

    qaSupCreateRangeRowID(idxKey, tokenLen, startRowID, numOfRowID);
    qaTstIndexListDriver(testCaseNo, testCaseDesc, idxKey, tokenLen, numOfRowID, expSbCnt, expFullSbCnt);
  }
  /* ==========================================================
      Test cases deleting index
      ============================================================= */
  void qaTSCIndexTestDelete()
  {
    uint64_t idxKey = 1;
    int tokenLen = 16;
    int testCaseNo;
    int startRowID = 1;
    int numOfRowID;
    int expSbCnt;
    int expFullSbCnt;
    char testCaseDesc[256];

    int i;
    int rc;

    // Create 1 row IDs, then remove it.
    // Expecting 0 row IDs, 0 sub blocks and 0 full sub blocks.

    strcpy(testCaseDesc,
           "Create 1 row ID, then remove it.  Expecting 0 row ID, 0 sub block and 0 full sub block.");
    testCaseNo = 10530;
    numOfRowID = 1;
    expSbCnt = 0;
    expFullSbCnt = 0;

    m_index.setUseFreeMgr(true);
    m_index.setUseListMgr(true);

    qaSupCreateRangeRowID(idxKey, tokenLen, startRowID, numOfRowID);

    rc = m_index.openIndex(990, 991);
    CPPUNIT_ASSERT(rc == NO_ERROR);
    rc = m_index.deleteIndex(idxKey, tokenLen, startRowID);
    CPPUNIT_ASSERT(rc == NO_ERROR);
    m_index.closeIndex();

    numOfRowID = 0;
    qaTstIndexListDriver(testCaseNo, testCaseDesc, idxKey, tokenLen, numOfRowID, expSbCnt, expFullSbCnt);
    //		qaDspIndexListStatsByKey(idxKey, tokenLen);

    // Create 3 row IDs, then remove the first two.
    // Expecting 1 row IDs, 1 sub blocks and 0 full sub blocks.

    strcpy(testCaseDesc,
           "Create 3 row IDs, then remove the first two.  Expecting 1 row ID, 1 sub block and 0 full sub "
           "block.");
    testCaseNo = 10531;
    numOfRowID = 3;
    expSbCnt = 1;
    expFullSbCnt = 0;

    qaSupCreateRangeRowID(idxKey, tokenLen, startRowID, numOfRowID);

    rc = m_index.openIndex(990, 991);
    CPPUNIT_ASSERT(rc == NO_ERROR);

    for (i = startRowID; i < startRowID + numOfRowID - 1; i++)
    {
      rc = m_index.deleteIndex(idxKey, tokenLen, i);
      CPPUNIT_ASSERT(rc == NO_ERROR);
    }

    m_index.closeIndex();

    numOfRowID = 1;
    qaTstIndexListDriver(testCaseNo, testCaseDesc, idxKey, tokenLen, numOfRowID, expSbCnt, expFullSbCnt);
    //		qaDspIndexListStatsByKey(idxKey, tokenLen);

    // Create 100 row IDs, then remove them.
    // Expecting 0 row IDs, 0 sub blocks and 0 full sub blocks.

    strcpy(testCaseDesc,
           "Create 100 row IDs, then remove them.  Expecting 0 row ID, 0 sub block and 0 full sub block.");
    testCaseNo = 10532;
    numOfRowID = 100;
    expSbCnt = 0;
    expFullSbCnt = 0;

    qaSupCreateRangeRowID(idxKey, tokenLen, startRowID, numOfRowID);

    rc = m_index.openIndex(990, 991);
    CPPUNIT_ASSERT(rc == NO_ERROR);

    for (i = startRowID; i < startRowID + numOfRowID; i++)
    {
      rc = m_index.deleteIndex(idxKey, tokenLen, i);
      CPPUNIT_ASSERT(rc == NO_ERROR);
    }

    m_index.closeIndex();

    numOfRowID = 0;
    qaTstIndexListDriver(testCaseNo, testCaseDesc, idxKey, tokenLen, numOfRowID, expSbCnt, expFullSbCnt);
    //		qaDspIndexListStatsByKey(idxKey, tokenLen);

    // create 63 row ids so that two full sub blocks will be allocated.
    // delete all row ids, 2 to 32, in the first sub block

    strcpy(testCaseDesc,
           "Create 63 row ids, then remove all in the 2nd sub block.  Verify that row id sub block gets "
           "released when empty.");
    testCaseNo = 10533;
    numOfRowID = 63;
    expSbCnt = 1;
    expFullSbCnt = 1;

    qaSupCreateRangeRowID(idxKey, tokenLen, startRowID, numOfRowID);

    rc = m_index.openIndex(990, 991);
    CPPUNIT_ASSERT(rc == NO_ERROR);

    for (i = 2; i < 33; i++)
    {
      rc = m_index.deleteIndex(idxKey, tokenLen, i);
      CPPUNIT_ASSERT(rc == NO_ERROR);
    }

    m_index.closeIndex();

    numOfRowID = 32;
    qaTstIndexListDriver(testCaseNo, testCaseDesc, idxKey, tokenLen, numOfRowID, expSbCnt, expFullSbCnt);
  }
  /* ==========================================================
      Test cases for empty maps
      ============================================================= */

  void qaTSCFreeSpaceMapTest()
  {
    IdxFreeSpaceStat mapInfo;
    uint64_t idxKey = 1;
    int tokenLen = 16;
    int execMode = 0;
    int testCaseNo, startKey, numOfKey;
    int startRowID, numOfRowID;
    int i;
    int expMapSize, expEntryCnt;
    char testCaseDesc[256];

    strcpy(testCaseDesc, "No keys created.  There should not be a empty list for header record.");
    testCaseNo = 10534;
    startKey = 1;
    numOfKey = 0;
    expMapSize = 0;
    expEntryCnt = 0;

    qaSupCreateRangeKey(idxKey, tokenLen, startKey, numOfKey);
    qaDspFreeSpaceMap(QA_FILE_TYPE_LIST, QA_FREEMAP_4ENTRY, execMode, mapInfo);
    qaTstFreeMapDriver(testCaseNo, testCaseDesc, expMapSize, expEntryCnt, mapInfo);

    strcpy(testCaseDesc, "Create 1 key.  There will be space left for 7 more header records.");
    testCaseNo = 10535;
    startKey = 1;
    numOfKey = 1;
    expMapSize = 1;
    expEntryCnt = 7;

    qaSupCreateRangeKey(idxKey, tokenLen, startKey, numOfKey);
    qaDspFreeSpaceMap(QA_FILE_TYPE_LIST, QA_FREEMAP_4ENTRY, execMode, mapInfo);
    qaTstFreeMapDriver(testCaseNo, testCaseDesc, expMapSize, expEntryCnt, mapInfo);

    strcpy(testCaseDesc, "Create 8 row ids.  There will be space left for 0 more header records.");
    testCaseNo = 10536;
    startKey = 1;
    numOfKey = 8;
    expMapSize = 1;
    expEntryCnt = 0;

    qaSupCreateRangeKey(idxKey, tokenLen, startKey, numOfKey);
    qaDspFreeSpaceMap(QA_FILE_TYPE_LIST, QA_FREEMAP_4ENTRY, execMode, mapInfo);
    qaTstFreeMapDriver(testCaseNo, testCaseDesc, expMapSize, expEntryCnt, mapInfo);

    strcpy(testCaseDesc, "Create 9 key.  There will be space left for 7 more header records.");
    testCaseNo = 10537;
    startKey = 1;
    numOfKey = 1;
    expMapSize = 1;
    expEntryCnt = 7;

    qaSupCreateRangeKey(idxKey, tokenLen, startKey, numOfKey);
    qaDspFreeSpaceMap(QA_FILE_TYPE_LIST, QA_FREEMAP_4ENTRY, execMode, mapInfo);
    qaTstFreeMapDriver(testCaseNo, testCaseDesc, expMapSize, expEntryCnt, mapInfo);
    /*
                    strcpy(testCaseDesc, "Verify that a sub block holding empty list entries will be released
       when empty."); testCaseNo		= 10538; startRowID		= 1; expMapSize		= 0;
                    expEntryCnt		= 0;
                    //Create files without key records, then get number of 32-entry free blocks.
                    numOfRowID		= 0;
                    qaSupCreateRangeKey(idxKey, tokenLen, startRowID, numOfRowID);
                    qaDspFreeSpaceMap(QA_FILE_TYPE_LIST, QA_FREEMAP_32ENTRY, execMode, mapInfo);
                    int initialSize = mapInfo.mapSize;
                    int initialEntry = mapInfo.entryCnt;
                    execMode = 1;
                    qaDspFreeSpaceMap(QA_FILE_TYPE_LIST, QA_FREEMAP_32ENTRY, execMode, mapInfo);
            printf("      size:   %d\n", mapInfo.mapSize);
            printf("      entry:   %d\n", mapInfo.entryCnt);

                    numOfRowID		= 900;  //There are 31 entries in a 32-entry empty list sub block.
                                                                    //1 ptr allocated for 4-entry free map, 1
       for hdr, 29 entries remaining.
                                                                    //29 entriess, pointing 29 sub blocks.  29
       x 31 = 899, plus 1 in hdr = 900 entries qaSupCreateRangeRowID(idxKey, tokenLen, startRowID,
       numOfRowID); qaDspFreeSpaceMap(QA_FILE_TYPE_LIST, QA_FREEMAP_32ENTRY, execMode, mapInfo); expMapSize
       = initialSize - 1 - 1 + 1;		// - 1 hdr block, -1 4-entry list, + 1 free 32-entry block.
                    expEntryCnt		= initialEntry - 29 - 1 - 1 + 1;	// -29 data sub blocks, - 1 for
       4-entry list ptr, 1 for hdr record ptr, +1 free 32-entry ptr
                    expEntryCnt++					;	// add 1 for the free 32-entry sub
       block.

                    qaTstFreeMapDriver(testCaseNo, testCaseDesc, expMapSize, expEntryCnt, mapInfo);
                    qaDspIndexListByKey(idxKey, tokenLen);
                    qaDspIndexListStatsByKey(idxKey, tokenLen);

    */

    execMode = 1;
    //		qaDspFreeSpaceMap(QA_FILE_TYPE_LIST, QA_FREEMAP_32ENTRY, execMode, mapInfo);

    //   		qaDspIndexListByKey(idxKey, tokenLen);
    //		qaDspIndexListStatsByKey(idxKey, tokenLen);
  }

  /* ==========================================================
      verify each index list header record for a given key length
      ============================================================= */

  void qaTstStressMaxKeyDriver(int testCaseNo, char* testCaseDesc, int tokenLen)
  {
    bool rc, passed, ;
    int checkMode = 2;
    int i, maxKey;
    int numOfRowID = 1;
    int expSbCnt = 0;
    int expFullSbCnt = 0;

    qaDspTestStatusHeader(testCaseNo, testCaseDesc);

    maxKey = (1 << tokenLen);

    if (maxKey > 160)
      maxKey = 120;

    passed = true;

    for (i = 0; i < maxKey; i++)
    {
      rc = qaSupVerifyIndexByKey(i, tokenLen, checkMode, numOfRowID, expSbCnt, expFullSbCnt);

      if (rc != NO_ERROR)
        passed = false;
    }

    qaDspTestStatusFooter(testCaseNo, passed);
  }

  /* ==========================================================
  A driver function to execution test cases for the
  index list.
  ============================================================= */
  void qaTstIndexListDriver(int testCaseNo, char* testCaseDesc, uint64_t idxKey, int tokenLen, int numOfRowID,
                            int expSbCnt, int expFullSbCnt)
  {
    bool passed;
    int checkMode = 2;

    qaDspTestStatusHeader(testCaseNo, testCaseDesc);
    passed = qaSupVerifyIndexByKey(idxKey, tokenLen, checkMode, numOfRowID, expSbCnt, expFullSbCnt);
    qaDspTestStatusFooter(testCaseNo, passed);
  }

  /* ==========================================================
      A driver function to verify free map list
      ============================================================= */
  void qaTstFreeMapDriver(int testCaseNo, char* testCaseDesc, int expMapSize, int expEntryCnt,
                          IdxFreeSpaceStat mapInfo)
  {
    int passed = true;

    qaDspTestStatusHeader(testCaseNo, testCaseDesc);

    if (mapInfo.mapSize != expMapSize)
    {
      printf("      Free map size mismatch:     Expected: %d    Returned: %d\n", expMapSize,
             (int)mapInfo.mapSize);
      passed = false;
    }

    if (mapInfo.entryCnt != expEntryCnt)
    {
      printf("      Free map entry mismatch:    Expected: %d    Returned: %d\n", expEntryCnt,
             (int)mapInfo.entryCnt);
      passed = false;
    }

    qaDspTestStatusFooter(testCaseNo, passed);
  }
  /* ==========================================================
      Verify index list record with it's integral components
      and expected values from the calling program.
  ============================================================= */
  bool qaSupVerifyIndexByKey(uint64_t idxKey, int tokenLen, int checkMode, int expRowIDCnt, int expSbCnt,
                             int expFullSbCnt)
  {
    IdxListStat idxKeyInfo;

    int execMode = 0;
    int passed = true;

    // checkMode != 1		Verify index header information only
    // checkMode  = 2		verify header information, plus matching expected results.

    qaSupWalkIndexList(idxKey, tokenLen, execMode, idxKeyInfo);

    // verify for matching record keys
    if (idxKeyInfo.hdrRec.key != idxKey)
    {
      printf("      Index key mismatch:         Expected: %d    Returned: %d\n", (int)idxKey,
             (int)idxKeyInfo.hdrRec.key);
      passed = false;
    }

    //	verify row id count in the hdr record against row id count gathered from the index list record.
    if (idxKeyInfo.hdrRec.idxRidListSize.size != idxKeyInfo.recCnt)
    {
      printf("      Index Hdr cnt mismatch:     In Hdr  : %d    In SB:    %d\n",
             idxKeyInfo.hdrRec.idxRidListSize.size, idxKeyInfo.recCnt);
      passed = false;
    }

    // verify that when there is not sub blocks for the row IDs, the header's link list pointer should not be
    // used.
    if ((idxKeyInfo.sbCnt == 0) && (idxKeyInfo.hdrRec.nextIdxRidListPtr.type == 4))
    {
      printf("      Incorrect list pointer:     Ptr type: %d     SB Cnt:  %d\n",
             idxKeyInfo.hdrRec.idxRidListSize.size, idxKeyInfo.recCnt);
      passed = false;
    }

    if (checkMode = 2)
    {
      // verify row id count in the hdr record against expected row id count
      if (idxKeyInfo.hdrRec.idxRidListSize.size != expRowIDCnt)
      {
        printf("      Row ID cnt mismatch:        Expected: %d    Returned: %d\n", expRowIDCnt,
               idxKeyInfo.hdrRec.idxRidListSize.size);
        passed = false;
      }

      //	verify sub block count gathered from the index list record against the expected sub block
      //count
      if (idxKeyInfo.sbCnt != expSbCnt)
      {
        printf("      Subblock cnt mismatch:      Expected: %d    Returned: %d\n", expSbCnt,
               idxKeyInfo.sbCnt);
        passed = false;
      }

      //	verify full sub block count gathered from the index list record against the expected full sub
      //block count
      if (idxKeyInfo.fullSbCnt != expFullSbCnt)
      {
        printf("      Full subblock cnt mismatch: Expected: %d    Returned: %d\n", expFullSbCnt,
               idxKeyInfo.fullSbCnt);
        passed = false;
      }
    }

    return passed;
  }

  /* ==========================================================
      Display index record for a given key
  ============================================================= */

  void qaGetListSubblockByKey(uint64_t idxKey, int tokenLen, int sbSeqNo, int& fbo, int& sbid, int& entry)
  {
    int p_fbo, p_sbid, p_entry;
    int execMode = 1;
    bool exist;

    //	   qaSupWalkIndexList(idxKey, tokenLen, execMode, sbSeqNo, p_fbo, p_sbid, p_entry, hdrCntMatch,
    //hdrRecCnt, hdrSbCnt, hdrFullSbCnt);
    fbo = p_fbo;
    sbid = p_sbid;
    entry = p_entry;
  }

  /* ==========================================================
      Display tree empty list map for a given block size
  ============================================================= */
  void qaDspFreeSpaceMap(int fileType, int mapType, int execMode, IdxFreeSpaceStat& mapInfo)
  {
    DataBlock curBlock;
    FILE* pFile = NULL;

    int fileNum;
    int p_fbo, p_sbid, p_entry, p_type, p_group;
    int i, j;
    int p_mapType;
    bool done;

    IdxEmptyListEntry emptyMap;

    if (fileType == QA_FILE_TYPE_TREE)
      fileNum = 990;  // index tree
    else
      fileNum = 991;  // index list

    memset(curBlock.data, 0, sizeof(curBlock.data));
    pFile = m_indexlist.openFile(fileNum);
    CPPUNIT_ASSERT(pFile != NULL);

    // Free Manager
    m_indexlist.setUseFreeMgr(true);

    p_fbo = 0;
    p_sbid = 0;
    p_entry = mapType;  // Entry location in Fb 0 and SB 0;

    if (execMode == 1)
    {
      printf("\n------------------------------------\n");

      if (fileType == 1)
        printf("Index Tree %d-ENTRY free space map\n", 1 << (mapType - 1));
      else
        printf("Index list %d-ENTRY free space map\n", 1 << (mapType - 1));

      printf("------------------------------------\n");
    }

    m_indexlist.readSubBlockEntry(pFile, &curBlock, p_fbo, p_sbid, p_entry, 8, &emptyMap);

    if (execMode == 1)
    {
      //			printf("\nList Ptr:  Type = %d  Group = %d  fbo = %d  sbid = %d Entry = %d\n",
      //p_type, p_group, p_fbo, p_sbid, p_entry);
      printf("\nList:       Type = %d  Group = %d Addr(%d, %d, %d) ----> Addr(%d, %d, %d)\n",
             int(emptyMap.type), int(emptyMap.group), p_fbo, p_sbid, p_entry, (int)emptyMap.fbo,
             (int)emptyMap.sbid, (int)emptyMap.entry);
      printf("-------------------------------------------------------------------------\n");
    }

    p_type = emptyMap.type;
    p_group = emptyMap.group;
    p_fbo = emptyMap.fbo;
    p_sbid = emptyMap.sbid;
    p_entry = emptyMap.entry;

    p_mapType = emptyMap.type;
    mapInfo.mapSize = 0;
    mapInfo.entryCnt = 0;

    done = ((p_mapType == 1) && (p_fbo == 0) && (p_sbid == 0) && (p_entry == 0));

    while (not done)
    {
      j = p_entry;
      mapInfo.mapSize++;

      for (i = j; i >= 0; i--)
      {
        m_indexlist.readSubBlockEntry(pFile, &curBlock, p_fbo, p_sbid, i, 8, &emptyMap);

        if (execMode == 1)
          //					printf("EntryPtr: %d Type = %d  Group = %d  fbo = %d  sbid = %d Entry = %d\n",
          //i, int(emptyMap.type), int(emptyMap.group), (int)emptyMap.fbo, (int)emptyMap.sbid,
          //(int)emptyMap.entry);
          printf("Entry: %d   Type = %d  Group = %d Addr(%d, %d, %d) ----> Addr(%d, %d, %d)\n", i,
                 int(emptyMap.type), int(emptyMap.group), p_fbo, p_sbid, i, (int)emptyMap.fbo,
                 (int)emptyMap.sbid, (int)emptyMap.entry);

        if (i != 0)
          mapInfo.entryCnt++;
      }

      p_fbo = emptyMap.fbo;
      p_sbid = emptyMap.sbid;
      p_entry = emptyMap.entry;
      p_mapType = emptyMap.type;

      done = ((p_fbo == 0) && (p_sbid == 0) && (p_entry == 0));

      if (not done && (execMode == 1))
      {
        //				printf("\nList Ptr:  Type: %d  Group: %d  FBO: %d  SBID: %d ENTRY: %d\n",
        //p_type, p_group, p_fbo, p_sbid, p_entry);
        printf("\nList:       Type = %d  Group = %d Addr(%d, %d, %d) ----> Addr(%d, %d, %d)\n",
               int(emptyMap.type), int(emptyMap.group), p_fbo, p_sbid, p_entry, (int)emptyMap.fbo,
               (int)emptyMap.sbid, (int)emptyMap.entry);
        printf("-------------------------------------------------------------------------\n");
      }
    }

    m_indexlist.closeFile(pFile);

  }  // qaDspFreeSpaceMap

  /* ==========================================================
      Show branch list for all keys for a given key length
  ============================================================= */

  void qaDspTreePathAll(uint64_t idxKey, int tokenLen)
  {
    uint64_t i;
    int maxKey;

    maxKey = (1 << tokenLen);

    for (i = 0; i < maxKey; i++)
      qaDspTreePathByKey(idxKey, tokenLen);
  }

  /*******************************************************
  .   Display branch list for a key
  *******************************************************/
  void qaDspTreePathByKey(uint64_t idxKey, int tokenLen)
  {
    int p_fbo, p_sbid, p_entry;
    bool exist;
    int execMode = 1;

    qaSupWalkIndexTree(idxKey, tokenLen, execMode, p_fbo, p_sbid, p_entry, exist);

  }  // qaDspTreePathByKey
  /* ==========================================================
      Verfiy hdr records all keys for a given key length
  ============================================================= */
  void qaDspIndexListStatsByKey(uint64_t idxKey, int tokenLen)
  {
    IdxListStat idxKeyInfo;

    int execMode = 0;
    int sbSeqNo = 0;

    qaSupWalkIndexList(idxKey, tokenLen, execMode, idxKeyInfo);

    printf("\nINDEX STATS for key: %d\n", (int)idxKey);
    printf("--------------------------------------\n");
    printf("Key:                %d\n", (int)idxKeyInfo.hdrRec.key);
    printf("Hdr Record Count:   %d\n", idxKeyInfo.hdrRec.idxRidListSize.size);

    if (idxKeyInfo.hdrRec.firstIdxRidListEntry.type == 3)
      printf("RowID 0   :         %d\n", idxKeyInfo.hdrRec.firstIdxRidListEntry.rid);

    if (idxKeyInfo.hdrRec.nextIdxRidListPtr.type == 3)
      printf("RowID 1   :         %d\n", (int)idxKeyInfo.hdrRec.nextIdxRidListPtr.llp);

    printf("File Block:         %d\n", idxKeyInfo.fbo);
    printf("Sub Block:          %d\n", idxKeyInfo.sbid);
    printf("Entry:              %d\n", idxKeyInfo.entry);
    printf("Actual Row ID Cnt:  %d\n", idxKeyInfo.recCnt);
    printf("Sub Block Cnt:      %d\n", idxKeyInfo.sbCnt);
    printf("Full Sub Block Cnt: %d\n", idxKeyInfo.fullSbCnt);
    printf("Row ID Cnt Match?:  ");

    if (idxKeyInfo.hdrRec.idxRidListSize.size == idxKeyInfo.recCnt)
      printf("Yes\n");
    else
      printf("No\n");
  }
  /* ==========================================================
      Display index record all keys for a given key length
  ============================================================= */

  void qaDspIndexListAll(uint64_t, int tokenLen)
  {
    uint64_t i;
    int maxKey;

    maxKey = (1 << tokenLen);

    for (i = 0; i < maxKey; i++)
      qaDspIndexListByKey(i, tokenLen);
  }

  /* ==========================================================
      Display index record for a given key
  ============================================================= */
  void qaDspIndexListByKey(uint64_t idxKey, int tokenLen)
  {
    IdxListStat idxKeyInfo;

    int p_fbo, p_sbid, p_entry;
    int execMode = 1;
    bool exist;
    int sbSeqNo = 0;

    qaSupWalkIndexList(idxKey, tokenLen, execMode, idxKeyInfo);
  }
  /* ==========================================================
      Display test case status header
      ============================================================= */
  void qaDspTestStatusHeader(int testCaseNo, char* testCaseDesc)
  {
    printf("\nBEGIN IdxHdrTestCase %d\n", testCaseNo);
    printf("      Desc:   %s\n", testCaseDesc);
  }

  /* ==========================================================
      Display test case status header
      ============================================================= */
  void qaDspTestStatusFooter(int testCaseNo, bool passed)
  {
    if (passed)
      printf("      Status: Passed\n");
    else
    {
      printf("      Status: Failed  -- [**ERROR**]\n");
    }

    printf("END   IdxHdrTestCase %d\n", testCaseNo);
  }
  /* ==========================================================
     Populate tree with max key for a given bit length
     Populate tree row ID for a given bitlength
  ============================================================= */
  void qaSupCreateMaxRowID(uint64_t idxKey, int tokenLen)
  {
    int maxKey;
    int startRowID = 0;

    maxKey = (1 << tokenLen);

    qaSupCreateRangeRowID(idxKey, tokenLen, startRowID, maxKey);

  }  // qaSupCreateMaxRowID

  /* ==========================================================
     Populate tree with a range of row IDs for a key.
  ============================================================= */
  void qaSupCreateRangeRowID(uint64_t idxKey, int tokenLen, int startRowID, int numOfRowID)
  {
    int rc;
    int i;
    int maxKey;

    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);

    // here is the correct check
    rc = m_index.openIndex(990, 991);
    CPPUNIT_ASSERT(rc == NO_ERROR);

    for (i = 0; i < numOfRowID; i++)
    {
      rc = m_index.updateIndex(idxKey, tokenLen, startRowID + i);  // 1 key, multiple rows, multiple row ids
      CPPUNIT_ASSERT(rc == NO_ERROR);
    }

    m_index.closeIndex();

  }  // qaSupCreateMaxRowID

  /* ==========================================================
  Populate tree with max key for a given bit length
  Populate tree row ID for a given bitlength
  ============================================================= */
  void qaSupCreateMaxHdrRec(int tokenLen)
  {
    int rc;
    uint64_t i;
    int maxKey;

    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);

    // here is the correct check
    rc = m_index.openIndex(990, 991);
    CPPUNIT_ASSERT(rc == NO_ERROR);

    maxKey = (1 << tokenLen);

    if (maxKey > 160)
      maxKey = 160;

    for (i = 0; i < maxKey; i++)
      rc = m_index.updateIndex(i, tokenLen, i);  // 1 row id per key.

    m_index.closeIndex();

  }  // qaSupCreateMaxHdrRec
  /* ==========================================================
  Populate tree with range of keys
  ============================================================= */

  void qaSupCreateRangeKey(uint64_t idxKey, int tokenLen, int startKey, int numOfKey)
  {
    int rc;
    uint64_t i;
    int maxKey;

    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);

    // here is the correct check
    rc = m_index.openIndex(990, 991);
    CPPUNIT_ASSERT(rc == NO_ERROR);

    for (i = startKey; i < startKey + numOfKey; i++)
      rc = m_index.updateIndex(i, tokenLen, i);  // 1 row id per key.

    m_index.closeIndex();

  }  // qaSupCreateRangeKey

  /*******************************************************
  .  This function navigate through the index list record.
  few global variables are set relating to index list.
  *******************************************************/
  void qaSupWalkIndexList(uint64_t idxKey, int tokenLen, int execMode, IdxListStat& idxKeyInfo)
  {
    DataBlock indexBlock;
    FILE* pFileIndexList = NULL;
    int file_indexList = 991;

    int p_fbo, p_sbid, p_entry;
    int i, ;
    int SBRecCnt;
    bool endOfList;
    bool exist;
    int tempExecMode;

    IdxRidListEntry listEntry;
    IdxRidListPtr listPtr;
    IdxRidListHdr indexListHdrRec;

    // Free Manager
    m_indexlist.setUseFreeMgr(true);
    tempExecMode = execMode;
    execMode = 0;
    qaSupWalkIndexTree(idxKey, tokenLen, execMode, p_fbo, p_sbid, p_entry, exist);
    execMode = tempExecMode;

    idxKeyInfo.fbo = p_fbo;  // Save the address for the header
    idxKeyInfo.sbid = p_sbid;
    idxKeyInfo.entry = p_entry;

    if (not exist)
      printf("Tree node not found: Key = %d\n", (int)idxKey);
    else
    {
      // read index list header record

      i = 0;

      idxKeyInfo.sbCnt = 0;
      idxKeyInfo.fullSbCnt = 0;
      idxKeyInfo.recCnt = 0;  // first entry in the hdr
      endOfList = false;

      memset(indexBlock.data, 0, sizeof(indexBlock.data));
      pFileIndexList = m_indexlist.openFile(file_indexList);
      CPPUNIT_ASSERT(pFileIndexList != NULL);

      m_indexlist.readSubBlockEntry(pFileIndexList, &indexBlock, p_fbo, p_sbid, p_entry, 32,
                                    &indexListHdrRec);

      idxKeyInfo.hdrRec = indexListHdrRec;

      if (execMode == 1)
      {
        printf("\n---------------------------------\n");
        printf("Index record for key: %d\n", (int)idxKey);
        printf("---------------------------------\n");
        printf("Size:    %d\n", (int)indexListHdrRec.idxRidListSize.size);
        printf("Key:     %d\n", (int)indexListHdrRec.key);
        printf("RowID 1: %d    Type:  %d\n", (int)indexListHdrRec.firstIdxRidListEntry.rid,
               (int)indexListHdrRec.firstIdxRidListEntry.type);

        if (indexListHdrRec.nextIdxRidListPtr.type == 3)
          printf("RowID 2: %d    Type: %d\\nn", (int)indexListHdrRec.nextIdxRidListPtr.llp,
                 (int)indexListHdrRec.nextIdxRidListPtr.type);
        else if (indexListHdrRec.nextIdxRidListPtr.type == 4)
          printf("Ptr:     Addr(%d, %d, %d) Type = %d\n\n",
                 (int)((IdxEmptyListEntry*)&(indexListHdrRec.nextIdxRidListPtr))->fbo,
                 (int)((IdxEmptyListEntry*)&(indexListHdrRec.nextIdxRidListPtr))->sbid,
                 (int)((IdxEmptyListEntry*)&(indexListHdrRec.nextIdxRidListPtr))->entry,
                 (int)indexListHdrRec.nextIdxRidListPtr.type);
      }

      if (int(indexListHdrRec.firstIdxRidListEntry.type) == 3)
        idxKeyInfo.recCnt++;

      if (indexListHdrRec.nextIdxRidListPtr.type == 3)
      {
        idxKeyInfo.recCnt++;
      }
      else if (indexListHdrRec.nextIdxRidListPtr.type == 4)
      {
        p_fbo = ((IdxEmptyListEntry*)&(indexListHdrRec.nextIdxRidListPtr))->fbo;
        p_sbid = ((IdxEmptyListEntry*)&(indexListHdrRec.nextIdxRidListPtr))->sbid;
        p_entry = ((IdxEmptyListEntry*)&(indexListHdrRec.nextIdxRidListPtr))->entry;

        while (not endOfList)
        {
          idxKeyInfo.sbCnt++;
          SBRecCnt = 0;
          m_indexlist.readSubBlockEntry(pFileIndexList, &indexBlock, p_fbo, p_sbid, 31, 8, &listPtr);
          printf("Index list subblock: #%d\n", idxKeyInfo.sbCnt);

          for (i = 0; i <= 30; i++)
          {
            m_indexlist.readSubBlockEntry(pFileIndexList, &indexBlock, p_fbo, p_sbid, i, 8, &listEntry);

            if (listEntry.type == 3)
            {
              SBRecCnt++;

              if (execMode == 1)
                printf("Entry %d: Addr(%d, %d, %d)  RowId: %d \n", i, p_fbo, p_sbid, i, listEntry.rid);
            }
          }

          p_fbo = ((IdxEmptyListEntry*)&(listPtr))->fbo;
          p_sbid = ((IdxEmptyListEntry*)&(listPtr))->sbid;

          if ((idxKeyInfo.sbSeqNo != 0) && (idxKeyInfo.sbSeqNo == (idxKeyInfo.sbCnt - 1)))
          {
            idxKeyInfo.fbo = p_fbo;  // Save the address for the request block
            idxKeyInfo.sbid = p_sbid;
            idxKeyInfo.entry = p_entry;
          }

          if (execMode == 1)
            printf("Entry 31: Addr(%d, %d, %d)   RecCnt = %d\n\n", p_fbo, p_sbid, p_entry,
                   (int)listPtr.count);

          idxKeyInfo.recCnt += SBRecCnt;

          if (SBRecCnt == 31)
            idxKeyInfo.fullSbCnt++;

          if (SBRecCnt != listPtr.count)
            printf("[**ERROR**] Sub Block entry count Error: In Ptr Rec: %d  In sub block: %d\n",
                   listPtr.count, SBRecCnt);

          endOfList = (listPtr.type == 0);
        }
      }
    }

    m_indexlist.closeFile(pFileIndexList);
  }

  /*******************************************************
  .  This function navigate through the tree, from the
  bitmap entry to the leaf.  It can be used for many
  functions that require access to the hdr record also.
  *******************************************************/
  void qaSupWalkIndexTree(uint64_t idxKey, int tokenLen, int execMode, int& fbo, int& sbid, int& entry,
                          bool& exist)
  {
    DataBlock curBlock;
    FILE* pFile = NULL;
    int file_number = 990;

    IdxBitmapPointerEntry bitmapRec;
    IdxBitTestEntry treeNodeRec;
    int p_fbo, p_sbid, p_entry, p_type, p_group, p_bitTest;
    int i;
    int maskValue = 31;  // mask for 11111.
    int bitMapLoc, key1, shiftBits;
    int bitCnt;
    bool found;
    int mask[5] = {1, 3, 7, 15, 31};
    int group[7] = {1, 2, 4, 8, 16, 32, 64};

    memset(curBlock.data, 0, sizeof(curBlock.data));
    pFile = m_indexlist.openFile(file_number);
    CPPUNIT_ASSERT(pFile != NULL);

    // Free Manager
    m_indexlist.setUseFreeMgr(true);

    if (tokenLen > 5)
      bitMapLoc = ((idxKey >> tokenLen - 5) & maskValue);
    else
      bitMapLoc = idxKey;

    p_fbo = 0;
    p_sbid = 1;
    p_entry = bitMapLoc;

    if (execMode == 1)
    {
      printf("\n---------------------------------\n");
      printf("Tree branch path for key: %d\n", (int)idxKey);
      printf("---------------------------------\n");
    }

    m_indexlist.readSubBlockEntry(pFile, &curBlock, p_fbo, p_sbid, p_entry, 8, &bitmapRec);

    shiftBits = 1;
    p_type = bitmapRec.type;
    p_fbo = bitmapRec.fbo;
    p_sbid = bitmapRec.sbid;
    p_entry = bitmapRec.entry;

    if (execMode == 1)  // branch list
      printf("Bitmap:   Type= %d            BitTest= %d  FBO= %d  SBID= %d Entry= %d\n", int(p_type),
             int(p_bitTest), (int)p_fbo, (int)p_sbid, (int)p_entry);

    bitCnt = tokenLen - 5;

    while (bitCnt > 0)
    {
      if (bitCnt > 5)
        key1 = ((idxKey >> (bitCnt - 5)) & maskValue);
      else
        key1 = ((idxKey)&mask[bitCnt - 1]);

      m_indexlist.readSubBlockEntry(pFile, &curBlock, p_fbo, p_sbid, p_entry, 8, &treeNodeRec);

      int groupIdx = treeNodeRec.group;
      //		printf("group: %d  count: %d\n", groupIdx, group[groupIdx]);

      found = false;

      for (i = 0; i < group[groupIdx]; i++)
      {
        m_indexlist.readSubBlockEntry(pFile, &curBlock, p_fbo, p_sbid, p_entry + i, 8, &treeNodeRec);
        found = (treeNodeRec.bitTest == key1);
        p_type = treeNodeRec.type;

        //			printf("key1: %d  bitTest: %d\n", key1, treeNodeRec.bitTest);
        if (found)
          i = group[groupIdx];
      };

      //			m_indexlist.readSubBlockEntry( pFile, &curBlock, p_fbo, p_sbid, p_entry, 8,
      //&treeNodeRec);

      p_type = treeNodeRec.type;

      p_group = treeNodeRec.group;

      p_bitTest = treeNodeRec.bitTest;

      p_fbo = treeNodeRec.fbo;

      p_sbid = treeNodeRec.sbid;

      p_entry = treeNodeRec.entry;

      bitCnt = bitCnt - 5;

      if (execMode == 1)  // branch list
        printf("Level:    Type= %d  Group= %d  BitTest= %d  FBO= %d  SBID= %d Entry= %d\n", int(p_type),
               int(p_group), int(p_bitTest), (int)p_fbo, (int)p_sbid, (int)p_entry);
    }

    // set global variables so that calling functions can access to the address of the index header record

    exist = found;
    fbo = p_fbo;
    sbid = p_sbid;
    entry = p_entry;

    m_indexlist.closeFile(pFile);
  }  // qaSupWalkIndexTree
};

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