New upstream version 4.0.2upstream/4.0.2

24 files changed, 6821 insertions, 0 deletions

diff --git a/src/tests/tstfuncs.cpp b/src/tests/tstfuncs.cpp
new file mode 100755
index 0000000..c499d3f
--- /dev/null
+++ b/src/tests/tstfuncs.cpp
@@ -0,0 +1,581 @@
+/*  tstfuncs.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+
+The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
+
+Email Contact:
+
+    XDB-devel@lists.sourceforge.net
+    XDB-users@lists.sourceforge.net
+
+*/
+
+time_t timer;
+
+xbDouble ChronTime();
+void InitTime();
+
+xbBool dblEquals( xbDouble a, xbDouble b, xbDouble epsilon );
+xbInt16 TestMethod( xbInt16 PrintOption, const char * title, const xbString &result, const char * expectedResult, size_t expectedLen );
+xbInt16 TestMethod( xbInt16 PrintOption, const char * title, char result, char expectedResult );
+xbInt16 TestMethod( xbInt16 PrintOption, const char * title, xbInt32 result, xbInt32 expectedResult );
+//xbInt16 TestMethod( xbInt16 PrintOption, const char * title, xbUInt32 result, xbUInt32 expectedResult );
+xbInt16 TestMethod( xbInt16 PrintOption, const char * title, xbUInt64 result, xbUInt64 expectedResult );
+xbInt16 TestMethod( xbInt16 PrintOption, const char * title, xbFloat result, xbFloat expectedResult );
+xbInt16 TestMethod( xbInt16 PrintOption, const char * title, xbDouble result, xbDouble expectedResult );
+xbInt16 TestMethod( xbInt16 PrintOption, const char * title, xbDouble result, xbDouble expectedResult, xbDouble dEpsilon );
+
+
+xbInt16 FileCompare( xbXBase &x, xbInt16 iPo, const xbString &sFile1, const xbString &sFile2, const xbString &sSkipBytes );
+
+
+#ifdef XB_LOCKING_SUPORT
+xbInt16 SetCmd( xbXBase &x, const xbString &sFileName, const xbString &sCmd, const char cSrc, xbInt16 iPo );
+xbInt16 GetCmd( xbXBase &x, const xbString &sFileName, xbString &sCmd, const char cSrc, xbInt16 iPo );
+#endif
+
+#if defined( XB_DBF4_SUPPORT ) && defined( XB_MEMO_SUPPORT )
+
+xbInt16 TestDbt4Method( xbInt16 PrintOption, const char * title, xbMemo * m, xbUInt32 ulHdrNext, xbUInt32 ulBlockCnt, xbString sNodeChain );
+xbInt16 TestDbt4Method( xbInt16 PrintOption, const char * title, xbMemo * m, xbUInt32 ulHdrNext, xbUInt32 ulBlockCnt, xbString sNodeChain ){
+
+  xbUInt32 ulLastDataBlock = 0L;
+  xbUInt32 ulHdrNextBlock = 0L;
+  xbInt16  iRc = 0;
+
+  iRc = m->GetHdrNextBlock( ulHdrNextBlock );
+  if( iRc != XB_NO_ERROR ){
+    std::cout << std::endl << "[FAIL 1] " << title << std::endl;
+    std::cout << "Error [" << iRc << "] in GetHdrNextBlock" << std::endl;
+    return -1;
+  }
+
+  iRc = m->CalcLastDataBlock( ulLastDataBlock );
+  if( iRc != XB_NO_ERROR ){
+    std::cout << std::endl << "[FAIL 2] " << title << std::endl;
+    std::cout << "Error [" << iRc << "] in CalcLastDataBlock" << std::endl;
+    return -1;
+  }
+
+  if( ulHdrNext > 0 ){
+    if( ulHdrNextBlock != ulHdrNext ){
+      std::cout << std::endl << "[FAIL 3] " << title << std::endl;
+      std::cout << "Expected Header Next Block = [" << ulHdrNext << "] Actual = [" << ulHdrNextBlock << "]" << std::endl;
+      return -1;
+    }
+    if( PrintOption == 2 ){
+      xbString sMsg;
+      sMsg.Sprintf( "[PASS][%3.4f] %s Expected matches actual Len=[%ld] Data=[%lds]\n", 
+         ChronTime(), title, ulHdrNextBlock, ulHdrNext );
+     std::cout << sMsg.Str();
+     // std::cout << "[PASS][" << ChronTime() << "] " << title << " Expected matches actual HdrBlock=[" << ulHdrNextBlock << "] Data=[" << ulHdrNext << "]" << std::endl;
+    } else if( PrintOption == 1 )
+      std::cout << "[PASS] " << title << std::endl;
+  }
+
+  if( ulBlockCnt > 0 ){
+    if( ulLastDataBlock != ulBlockCnt ){
+      std::cout << std::endl << "[FAIL 4] " << title << std::endl;
+      std::cout << "Expected Block Count = [" << ulBlockCnt << "] Actual = [" << ulLastDataBlock << "]" << std::endl;
+      return -1;
+    }
+    if( PrintOption == 2 ){
+      xbString sMsg;
+      sMsg.Sprintf( "[PASS][%3.4f] %s Expected matches actual Len=[%ld] Data=[%lds]\n",
+         ChronTime(), title, ulLastDataBlock, ulBlockCnt );
+     std::cout << sMsg.Str();
+     // std::cout << "[PASS][" << ChronTime() << "] " << title << " Expected matches actual LastBlock=[" << ulLastDataBlock << "] Data=[" << ulBlockCnt << "]" << std::endl;
+    } else if( PrintOption == 1 )
+      std::cout << "[PASS] " << title << std::endl;
+  }
+
+  #ifdef XB_DEBUG_SUPPORT
+  xbMemoDbt4 *m4 = (xbMemoDbt4 *) m;
+  if( sNodeChain != "-1" ){
+    xbUInt32 ulNode = ulHdrNextBlock;
+    xbUInt32 ulNextBlock;
+    xbUInt32 ulFreeBlockCnt;
+    xbString sActualNodeChain;
+
+    while( ulNode < ulLastDataBlock ){
+      iRc = m4->ReadFreeBlockHeader( ulNode, ulNextBlock, ulFreeBlockCnt ); 
+      if( iRc != XB_NO_ERROR ){
+        std::cout << std::endl << "[FAIL 5] " << title << std::endl;
+        std::cout << "Error [" << iRc << "] in CalcLastDataBlock" << std::endl;
+        return -1;
+      }
+      if( sActualNodeChain != "" )
+        sActualNodeChain += ",";
+      sActualNodeChain.Sprintf( "%s%ld,%ld,%ld", sActualNodeChain.Str(), ulNode, ulFreeBlockCnt, ulNextBlock );
+      ulNode = ulNextBlock;
+    }
+  if( sNodeChain != sActualNodeChain ){
+    std::cout << std::endl << "[FAIL 6] " << title << std::endl;
+    std::cout << "Expected Block Chain = [" << sNodeChain.Str() << "] Actual = [" << sActualNodeChain.Str() << "]" << std::endl;
+    return -1;
+  }
+  if( PrintOption == 2 ){
+    xbString sMsg;
+    sMsg.Sprintf( "[PASS][%3.4f] %s Expected matches actual Len=[%d] Data=[%s]\n", ChronTime(), title, sNodeChain.Str() );
+    std::cout << sMsg.Str();
+    //std::cout << "[PASS][" << ChronTime() << "] " << title << " Expected matches actual BlockChain=[" << sNodeChain.Str() << "]" << std::endl;
+  } else if( PrintOption == 1 )
+    std::cout << "[PASS] " << title << std::endl;
+  }
+  #endif  // XB_DEBUG_SUPPORT"
+
+  return 0;
+}
+#endif
+
+
+
+xbInt16 TestMethod( xbInt16 PrintOption, const char * title, const xbString &sResult, const char * expectedResult, size_t expectedLen ){
+  xbInt16 rc = 0;
+
+  if( sResult == expectedResult && sResult.Len() == expectedLen ){
+    if( PrintOption == 2 ){
+     xbString sMsg;
+     sMsg.Sprintf( "[PASS][%3.4f] %s Expected matches actual Len=[%d] Data=[%s]\n", ChronTime(), title, expectedLen, expectedResult );
+     std::cout << sMsg.Str();
+    } else if( PrintOption == 1 ) {
+      std::cout << "[PASS] " << title << std::endl;
+    }
+  } else {
+    std::cout << std::endl << "[FAIL 1] " << title << std::endl;
+    std::cout << "  Expected Len = [" << expectedLen  << "] Expected Data = [" <<  expectedResult << "]" << std::endl;
+    std::cout << "  Actual Len   = [" << sResult.Len() << "] Actual Data   = [" << sResult.Str() << "]" << std::endl;
+
+    if( sResult.Len() == expectedLen )
+      printf( "lengths match\n" );
+    else
+      printf( "lengths dont match\n" );
+
+    if( sResult == expectedResult )
+      printf( "result matches\n" );
+    else
+      printf( "result does not match\n" );
+
+    rc = -1;
+  }
+  return rc;
+}
+
+xbInt16 TestMethod( xbInt16 PrintOption, const char * title, char result, char expectedResult ){
+  xbInt16 rc = 0;
+  if( result == expectedResult ){
+    if( PrintOption == 2 ){
+      xbString sMsg;
+      sMsg.Sprintf( "[PASS][%3.4f] %s Expected matches actual Data=[%c]\n", ChronTime(), title,  expectedResult );
+      std::cout << sMsg.Str();
+      // std::cout << "[PASS][" << ChronTime() << "] " << title << " Expected matches actual Data=[" << expectedResult << "]" << std::endl;
+    } else if( PrintOption == 1 )
+      std::cout << "[PASS] " << title << std::endl;
+    rc = 0;
+  } else {
+    std::cout << std::endl << "[FAIL 2] " << title << std::endl;
+    std::cout << "  Expected Data = [" <<  expectedResult << "]" << std::endl;
+    std::cout << "  Actual Data   = [" << result << "]" << std::endl;
+    rc = -1;
+  }
+  return rc;
+}
+
+xbInt16 TestMethod( xbInt16 PrintOption, const char * title, xbInt32 result, xbInt32 expectedResult ){
+  xbInt16 rc = 0;
+  if( result == expectedResult ){
+    if( PrintOption == 2 ){
+      xbString sMsg;
+      sMsg.Sprintf( "[PASS][%3.4f] %s Expected matches actual Data=[%d]\n", ChronTime(), title,  expectedResult );
+      std::cout << sMsg.Str();
+      //  std::cout << "[PASS][" << ChronTime() << "] "  << title << " Expected matches actual Data=[" << expectedResult << "]" << std::endl;
+    } else if( PrintOption == 1 )
+      std::cout << "[PASS] " << title << std::endl;
+    rc = 0;
+  } else {
+    std::cout << std::endl << "[FAIL 3] " << title << std::endl;
+    std::cout << "  Expected Data = [" <<  expectedResult << "]" << std::endl;
+    std::cout << "  Actual Data   = [" << result << "]" << std::endl;
+    rc = -1;
+  }
+  return rc;
+}
+
+
+/*
+xbInt16 TestMethod( xbInt16 PrintOption, const char * title, xbUInt32 result, xbUInt32 expectedResult ){
+  xbInt16 rc = 0;
+  if( result == expectedResult ){
+    if( PrintOption == 2 )
+      std::cout << "[PASS][" << ChronTime() << "] "  << title << " Expected matches actual Data=[" << expectedResult << "]" << std::endl;
+    else if( PrintOption == 1 )
+      std::cout << "[PASS] " << title << std::endl;
+    rc = 0;
+  } else {
+    std::cout << std::endl << "[FAIL 3] " << title << std::endl;
+    std::cout << "  Expected Data = [" <<  expectedResult << "]" << std::endl;
+    std::cout << "  Actual Data   = [" << result << "]" << std::endl;
+    rc = -1;
+  }
+  return rc;
+}
+*/
+
+xbInt16 TestMethod( xbInt16 PrintOption, const char * title, xbUInt64 result, xbUInt64 expectedResult ){
+  xbInt16 rc = 0;
+  if( result == expectedResult ){
+    if( PrintOption == 2 ){
+      xbString sMsg;
+      sMsg.Sprintf( "[PASS][%f] %3.4s Expected matches actual Data=[%ld]\n", ChronTime(), title, expectedResult );
+      std::cout << sMsg.Str();
+      //  std::cout << "[PASS][" << ChronTime() << "] "  << title << " Expected matches actual Data=[" << expectedResult << "]" << std::endl;
+    } else if( PrintOption == 1 )
+      std::cout << "[PASS] " << title << std::endl;
+    rc = 0;
+  } else {
+    std::cout << std::endl << "[FAIL 4] " << title << std::endl;
+    std::cout << "  Expected Data = [" <<  expectedResult << "]" << std::endl;
+    std::cout << "  Actual Data   = [" << result << "]" << std::endl;
+    rc = -1;
+  }
+  return rc;
+}
+
+xbInt16 TestMethod( xbInt16 PrintOption, const char * title, xbFloat result, xbFloat expectedResult ){
+  xbInt16 rc = 0;
+  if( result == expectedResult ){
+    if( PrintOption == 2 ){ 
+      xbString sMsg;
+      sMsg.Sprintf( "[PASS][%f] %3.4s Expected matches actual Data=[%f]\n", ChronTime(), title, expectedResult );
+      std::cout << sMsg.Str();
+      // std::cout << "[PASS][" << ChronTime() << "] " << title << " Expected matches actual Data=[" << expectedResult << "]" << std::endl;
+    } else if( PrintOption == 1 )
+      std::cout << "[PASS] " << title << std::endl;
+    rc = 0;
+  } else {
+    std::cout << std::endl << "[FAIL 5] " << title << std::endl;
+    std::cout << "  Expected Data = [" <<  expectedResult << "]" << std::endl;
+    std::cout << "  Actual Data   = [" << result << "]" << std::endl;
+    rc = -1;
+  }
+  return rc;
+}
+
+xbInt16 TestMethod( xbInt16 PrintOption, const char * title, xbDouble result, xbDouble expectedResult ){
+  xbInt16 rc = 0;
+  if( result == expectedResult ){
+  // if( dblEquals( result, expectedResult ) == 0 ){
+    if( PrintOption == 2 ){ 
+      xbString sMsg;
+      sMsg.Sprintf( "[PASS][%3.4f] %s Expected matches actual Data=[%f]\n", ChronTime(), title, expectedResult );
+      std::cout << sMsg.Str();
+      //std::cout << "[PASS][" << ChronTime() << "] " << title << " Expected matches actual Data=[" << expectedResult << "]" << std::endl;
+    } else if( PrintOption == 1 )
+      std::cout << "[PASS] " << title << std::endl;
+    rc = 0;
+  } else {
+    std::cout << std::endl << "[FAIL 6] " << title << std::endl;
+    std::cout << "  Expected Data = [" <<  expectedResult << "]" << std::endl;
+    std::cout << "  Actual Data   = [" << result << "]" << std::endl;
+    rc = -1;
+  }
+  return rc;
+}
+
+
+// next three routines used to do a compare on double values
+xbDouble dblMax( xbDouble a, xbDouble b ){
+  if( a > b )
+    return a;
+  else
+    return b;
+}
+xbDouble dblMin( xbDouble a, xbDouble b ){
+  if( a < b )
+    return a;
+  else
+    return b;
+}
+xbBool dblEquals( xbDouble a, xbDouble b, xbDouble epsilon = 0.0001 ){
+
+  // std::cout << "a=[" << a << "] b=[ " << b << "] dblmax [" << dblAbsMax( a, b ) << "] min [" << dblAbsMin( a, b ) << "]\n";
+  if( a < 0 && b >= 0 )
+    return xbFalse;
+  else if( a >= 0 && b < 0 )
+    return xbFalse;
+  if( (dblMax( a ,b ) - dblMin( a, b )) < epsilon )
+    return xbTrue;
+  else
+  { 
+//    std::cout << "no match a=[" << a << "] b=[" << b << "] dblmax [" << dblAbsMax( a, b ) << "] min [" << dblAbsMin( a, b ) << "]\n";
+    return xbFalse;
+  }
+}
+
+xbInt16 TestMethod( xbInt16 PrintOption, const char * title, xbDouble result, xbDouble expectedResult, xbDouble dEpsilon ){
+  xbInt16 rc;
+  if( dblEquals( result, expectedResult, dEpsilon ) == xbTrue ){
+    if( PrintOption == 2 ){
+     xbString sMsg;
+     sMsg.Sprintf( "[PASS][%3.4f] %s Expected matches actual Data=[%f]\n", ChronTime(), title, expectedResult );
+     std::cout << sMsg.Str();
+      //std::cout << "[PASS][" << ChronTime() << "] " << title << " Expected matches actual Data=[" << expectedResult << "]" << std::endl;
+    } else if( PrintOption == 1 )
+      std::cout << "[PASS] " << title << std::endl;
+    rc = 0;
+  } else {
+    std::cout << std::endl << "[FAIL 6] " << title << std::endl;
+    std::cout << "  Expected Data = [" <<  expectedResult << "]" << std::endl;
+    std::cout << "  Actual Data   = [" << result << "]" << std::endl;
+    rc = -1;
+  }
+  return rc;
+}
+
+
+#ifdef XB_LOCKING_SUPPORT
+
+xbInt16 GetCmd( xbXBase &x, const xbString &sFileName, xbString &sCmd, const char cSrc, xbInt16 iPo ){
+  xbInt16  iTryCnt = 0;
+  xbInt16  iMaxTries = 10;
+  char     cInBuf[256];
+  FILE     *f;
+  xbBool   bDone = xbFalse;
+  xbString sMsg;
+
+  while( !bDone && iTryCnt < iMaxTries ){
+
+    #ifdef HAVE__FSOPEN_F
+    // 0x40 is SH_DENYNO or _SH_DENYNO
+    if(( f = _fsopen( sFileName.Str(), "r", 0x40 )) == NULL){
+      sMsg.Sprintf( "GetCmd _fsopen() error opening [%s]", sFileName.Str() );
+      x.WriteLogMessage( sMsg );
+      std::cout << sMsg.Str() << "\n";
+      x.xbSleep( 250 );
+      iTryCnt++;
+    }
+
+    #else
+
+    if(( f = fopen( sFileName.Str(), "r" )) == NULL ){
+      sMsg.Sprintf( "GetCmd fopen() error opening [%s]", sFileName.Str() );
+      x.WriteLogMessage( sMsg );
+      std::cout << sMsg.Str() << "\n";
+      x.xbSleep( 250 );
+      iTryCnt++;
+    }
+    #endif
+
+    else {
+      memset( cInBuf, 0x00, 256 );
+      fgets( cInBuf, 256, f );
+      fclose( f );
+      sCmd = cInBuf;
+      if( sCmd != "" )
+        bDone = xbTrue;
+      else{
+        x.xbSleep( 250 );
+      }
+    }
+  }
+
+  #ifdef XB_LOGGING_SUPPORT
+  if( iPo > 0 ){
+    sMsg.Sprintf( "[%c] GetCmd [%s]", cSrc, sCmd.Str());
+    x.WriteLogMessage( sMsg );
+    x.FlushLog();
+  }
+  #endif
+
+  if( iTryCnt >= iMaxTries )
+    return -1;
+  else
+    return 0;
+}
+
+xbInt16 SetCmd( xbXBase &x, const xbString &sFileName, const xbString &sCmd, const char cSrc, xbInt16 iPo ){
+
+  xbInt16 iTryCnt = 0;
+  FILE    *f;
+  xbBool  bDone = xbFalse;
+
+  #ifdef XB_LOGGING_SUPPORT
+  if( iPo > 0 ){
+    xbString sMsg;
+    sMsg.Sprintf( "[%c] SetCmd [%s] FileName [%s]", cSrc, sCmd.Str(), sFileName.Str());
+    x.WriteLogMessage( sMsg );
+    x.FlushLog();
+  }
+  #endif
+
+  while( !bDone && iTryCnt < 10 ){
+
+    #ifdef HAVE__FSOPEN_F
+    // 0x40 is SH_DENYNO or _SH_DENYNO
+    if(( f = _fsopen( sFileName.Str(), "r", 0x40 )) == NULL){
+      x.xbSleep( 250 );
+      iTryCnt++;
+    }
+
+    #else
+    if(( f = fopen( sFileName.Str(), "w" )) == NULL ){
+      x.xbSleep( 250 );
+      iTryCnt++;
+    }
+    #endif
+
+    else {
+      fputs( sCmd.Str(), f );
+      fflush( f );
+      fclose( f );
+      bDone = xbTrue;
+    }
+  }
+  if( iTryCnt == 10 )
+    return -1;
+  else{
+    x.xbSleep( 250 );
+    return 0;
+  }
+}
+
+
+
+#endif
+void InitTime(){
+  time( &timer );
+}
+
+
+xbDouble ChronTime(){
+  time_t tWork = timer;
+  time( &timer );
+  return difftime( timer, tWork );
+
+}
+
+
+
+xbInt16 FileCompare( xbXBase &x, xbInt16 iPo, const xbString &sFile1, const xbString &sFile2, const xbString &sSkipBytes ){
+
+/*
+  iPo print option
+  sFile1 - File 1
+  sFile2 - File 2
+  sSkipBytes - comma separated list of bytes to skip the compare on
+*/
+
+  xbInt16  iRc = 0;
+  xbInt16  iErrorStop = 0;
+  xbInt16  iErrorCnt = 0;
+  xbFile   f1( &x );
+  xbFile   f2( &x );
+  xbString sMsg;
+  char     c1;
+  char     c2;
+
+  if( iPo > 0 ){
+    std::cout << "FileCompare\n";
+    std::cout << "Skip bytes = " << sSkipBytes.Str() << std::endl;
+    std::cout << sFile1.Str() << std::endl;
+    std::cout << sFile2.Str() << std::endl;
+  }
+
+  xbLinkListOrd<xbInt32> llO;
+  llO.SetDupKeys( 0 );
+  if( sSkipBytes.Len() > 0 ){
+    xbString sNode;
+    xbUInt32 iCommaCnt = sSkipBytes.CountChar( ',' );
+    for( xbUInt32 i = 0; i < (iCommaCnt+1); i++ ){
+      sNode.ExtractElement( sSkipBytes, ',', i+1, 0 );
+      //std::cout << "Adding key = " << atol( sNode.Str()) << std::endl;
+      llO.InsertKey( atol( sNode.Str()));
+    }
+  }
+
+  xbInt32 iPos = 0;
+  try{
+
+    if(( iRc = f1.xbFopen( "r", sFile1, XB_SINGLE_USER )) != XB_NO_ERROR ){
+      iErrorStop = 10;
+      iErrorCnt++;
+      throw iRc;
+    }
+
+    if(( iRc = f2.xbFopen( "r", sFile2, XB_SINGLE_USER )) != XB_NO_ERROR ){
+      iErrorStop = 20;
+      iErrorCnt++;
+      throw iRc;
+    }
+
+    xbUInt64 uiFs1;
+    xbUInt64 uiFs2;
+
+    if(( iRc = f1.GetFileSize( uiFs1 )) != XB_NO_ERROR ){
+      iErrorStop = 30;
+      iErrorCnt++;
+      throw iRc;
+    }
+
+    if(( iRc = f2.GetFileSize( uiFs2 )) != XB_NO_ERROR ){
+      iErrorStop = 40;
+      iErrorCnt++;
+      throw iRc;
+    }
+
+   // std::cout << "file size " <<  uiFs1 << " " <<  uiFs2 << "\n";
+
+    f1.xbRewind();
+    f2.xbRewind();
+
+    while( !f1.xbFeof() && !f2.xbFeof()){
+      f1.xbFgetc( c1 );
+      f2.xbFgetc( c2 );
+      if( c1 != c2 ){
+        if( !llO.KeyExists( iPos )){
+          iErrorCnt++;
+          if( iPo > 0 ){
+            sMsg.Sprintf( "Diff  %ld   %x  %x\n", iPos, c1, c2 );
+            std::cout << sMsg.Str();
+          }
+        }
+      }
+      iPos++;
+    }
+  }
+
+  catch( xbInt16 ){
+    if( iPo > 0 ){
+      std::cout << "File Compare Error Count = " << iErrorCnt << std::endl;
+
+      switch( iErrorStop ){
+        case 10:
+          std::cout << "Error opening file = " << sFile1.Str() << std::endl;
+          break;
+        case 20:
+          std::cout << "Error opening file = " << sFile2.Str() << std::endl;
+          break;
+        case 30:
+          std::cout << "GetFileSize() error " << sFile1.Str() << std::endl;
+          break;
+        case 40:
+          std::cout << "GetFileSize() error " << sFile2.Str() << std::endl;
+          break;
+        default:
+          break;
+      }
+    }
+  }
+
+  if( f1.FileIsOpen() )
+      f1.xbFclose();
+  if( f1.FileIsOpen() )
+      f1.xbFclose();
+
+  return iRc;
+}
+
+
diff --git a/src/tests/xb_test_bcd.cpp b/src/tests/xb_test_bcd.cpp
new file mode 100755
index 0000000..1eab20f
--- /dev/null
+++ b/src/tests/xb_test_bcd.cpp
@@ -0,0 +1,128 @@
+/* xb_test_bcd.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2017,2022 Gary A Kunkel
+
+The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
+
+Email Contact:
+
+    XDB-devel@lists.sourceforge.net
+    XDB-users@lists.sourceforge.net
+
+*/
+
+// This program tests the xb bcd functions
+// usage:   xb_test_expnode QUITE|NORMAL|VERBOSE
+
+#include "xbase.h"
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+/**************************************************************************/
+
+int main( int argCnt, char **av )
+{
+
+  #ifdef XB_INDEX_SUPPORT
+
+  xbInt16 iRc  = 0;
+  xbInt16 iPo  = 1;     /* print option */
+                       /* 0 - QUIET    */
+                       /* 1 - NORMAL   */
+                       /* 2 - VERBOSE  */
+
+  if( argCnt > 1 ) {
+    if( av[1][0] == 'Q' )
+      iPo = 0;
+    else if( av[1][0] == 'V' )
+      iPo = 2;
+  }
+
+
+  xbXBase x;
+
+  #ifdef XB_LOGGING_SUPPORT
+  x.EnableMsgLogging();
+  if( iPo ){
+    std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+  }
+  xbString sMsg;
+  sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+  x.WriteLogMessage( sMsg );
+  #endif
+
+  x.SetDataDirectory( PROJECT_DATA_DIR );
+  x.EnableMsgLogging();
+
+
+  if( iPo > 0 ){
+    std::cout << "XBase bcd testing program.." << std::endl;
+    std::cout << "This program tests the bcd logic." << std::endl;
+  }
+
+  iRc += TestMethod( iPo, "sizeof( xbBcdStruct )", (xbInt32) sizeof( xbBcdStruct ), (xbInt32) 12 );
+
+  xbString s1( -12345.60 );
+  xbBcd bcd1( s1 );
+  xbDouble d1;
+  bcd1.ToDouble( d1 );
+  xbString s2( d1 );
+  bcd1.ToString( s2 );
+
+  iRc += TestMethod( iPo, "String Constructor1", d1, -12345.6 );
+  iRc += TestMethod( iPo, "String Constructor2", s2.Str(), "-12345.6", 8 );
+
+  d1 = 0034.04;
+  xbBcd bcd2( d1 );
+  bcd2.ToString( s2 );
+  iRc += TestMethod( iPo, "xbDouble Constructor1", s2.Str(), "34.04", 5 );
+
+  // test the sign comparison logic
+  xbInt16 iComp = bcd1.Compare( bcd2 );
+  iRc += TestMethod( iPo, "Sign Compare 1", iComp, -1 );
+  iComp = bcd2.Compare( bcd1 );
+  iRc += TestMethod( iPo, "Sign Compare 2", iComp, 1 );
+
+  // bcd length compare scenarios
+  bcd1.Set( 123 );
+  iRc += TestMethod( iPo, "Length Compare 1", bcd1.Compare( 12 ), 1 );
+  iRc += TestMethod( iPo, "Length Compare 2", bcd1.Compare( 1234 ), -1 );
+  bcd1.Set( -456 );
+  iRc += TestMethod( iPo, "Length Compare 3", bcd1.Compare( -12 ), -1 );
+  iRc += TestMethod( iPo, "Length Compare 4", bcd1.Compare( -1234 ), 1 );
+
+  // same length, value compares
+  bcd1.Set( 11 );
+  iRc += TestMethod( iPo, "Value Compare 1", bcd1.Compare( 10 ), 1 );
+
+  bcd1.Set( 111 );
+  iRc += TestMethod( iPo, "Value Compare 2", bcd1.Compare( 110 ), 1 );
+
+
+  bcd1.Set( 111.111 );
+  iRc += TestMethod( iPo, "Value Compare 3", bcd1.Compare( 111.112 ), -1 );
+
+  bcd1.Set( -100 );
+  iRc += TestMethod( iPo, "Value Compare 4", bcd1.Compare( -111 ), 1 );
+  iRc += TestMethod( iPo, "Value Compare 5", bcd1.Compare( -99 ), -1 );
+
+  bcd1.Set( (xbDouble) 0 );
+  iRc += TestMethod( iPo, "Value Compare 6", bcd1.Compare( (xbDouble) 0 ), 0 );
+
+  if( iPo > 0 || iRc < 0 )
+    fprintf( stdout, "Total Errors = %d\n", iRc * -1 );
+
+  #ifdef XB_LOGGING_SUPPORT
+  sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], iRc * -1 );
+  x.WriteLogMessage( sMsg );
+  #endif
+
+  return iRc;
+  #else
+  return XB_NO_ERROR;
+  #endif     // XB_INDEX_SUPPORT
+  
+}
diff --git a/src/tests/xb_test_date.cpp b/src/tests/xb_test_date.cpp
new file mode 100755
index 0000000..1d9b523
--- /dev/null
+++ b/src/tests/xb_test_date.cpp
@@ -0,0 +1,189 @@
+/* xb_test_date.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+
+The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
+
+Email Contact:
+
+    XDB-devel@lists.sourceforge.net
+    XDB-users@lists.sourceforge.net
+
+*/
+
+// This program tests the date class xbDate
+
+// usage:   xb_test_date QUITE|NORMAL|VERBOSE
+
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+
+int main( int argCnt, char **av )
+{
+  int iRc  = 0;
+  xbInt16 po = 1;      /* print option */
+                       /* 0 - QUIET    */
+                       /* 1 - NORMAL   */
+                       /* 2 - VERBOSE  */
+
+  if( argCnt > 1 ) {
+    if( av[1][0] == 'Q' )
+      po = 0;
+    else if( av[1][0] == 'V' )
+      po = 2;
+  }
+
+#ifdef XB_LOGGING_SUPPORT
+  xbXBase x;
+  x.EnableMsgLogging();
+  if( po ){
+    std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+  }
+  xbString sMsg;
+  sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+  x.WriteLogMessage( sMsg );
+#endif
+  InitTime();
+
+  xbDate d1;
+#ifdef XB_DEBUG_SUPPORT
+  if( po > 0 )
+    d1.DumpDateTables();
+#endif
+
+  xbDate d2( "19890209" );
+  xbString s3 = "20120709";
+  xbDate d3( s3 );
+  xbString s4;
+  xbString sFmt = "";
+  xbString sOutDate; 
+  xbString s;
+
+  iRc += TestMethod( po, "FormatDate( '', sOutDate ) (sys default format)", d3.FormatDate( sFmt, sOutDate ), 0 );
+  iRc += TestMethod( po, "FormatDate( '', sOutDate ) (sys default format)", sOutDate, "07/09/12", 8 );
+  iRc += TestMethod( po, "CenturyOf()" , d3.CenturyOf(), 20 );
+  iRc += TestMethod( po, "YearOf()", d3.YearOf(), 2012 );
+  iRc += TestMethod( po, "MonthOf()", d3.MonthOf(), 7 );
+
+  iRc += TestMethod( po, "DayOf( XB_FMT_DAY )", d3.DayOf( XB_FMT_WEEK ), 2 );
+  iRc += TestMethod( po, "DayOf( XB_FMT_MONTH )", d3.DayOf( XB_FMT_MONTH ), 9 );
+  iRc += TestMethod( po, "DayOf( XB_FMT_YEAR )", d3.DayOf( XB_FMT_YEAR ), 191 );
+
+  iRc += TestMethod( po, "DateIsValid( '12345678' )", d3.DateIsValid( "12345678" ), 0 );
+  iRc += TestMethod( po, "d3.DateIsValid( '20120708' )", d3.DateIsValid( "20120708" ), 1 );
+  iRc += TestMethod( po, "d3.IsLeapYear()", d3.IsLeapYear(), 1 );
+  iRc += TestMethod( po, "d2.IsLeapYear()", d2.IsLeapYear(), 0 );
+
+  d1.Set( "20010102" );
+  iRc += TestMethod( po, "d1.Set('20010102')", d1.Str(), "20010102", 8 );
+  iRc += TestMethod( po, "d1.CalcRollingCenturyForYear(10)", d1.CalcRollingCenturyForYear( 10 ), 20 );
+
+  iRc += TestMethod( po, "d1.JulianDays()", d1.JulianDays(), 2451912 );
+
+
+  iRc += TestMethod( po, "d1.Set( '20140709' )", d1.Set( "20140709" ) , 0 );
+  d1.CharDayOf( s );
+  iRc += TestMethod( po, "d1.CharDayOf(s)", s, "Wednesday", 9 );
+
+  d1.CharMonthOf( s );
+  iRc += TestMethod( po, "d1.CharMonthOf()", s, "July", 4 );
+
+  iRc += TestMethod( po, "d1.JulToDate8( 2451913 )", d1.JulToDate8( 2451912 ), 0 );
+  iRc += TestMethod( po, "d1.JulToDate8( 2451913 )", d1.Str(), "20010102", 8 );
+  iRc += TestMethod( po, "d1.LastDayOfMonth()", d1.LastDayOfMonth(), 0 );
+  iRc += TestMethod( po, "d1.LastDayOfMonth()", d1.Str(), "20010131", 8 );
+
+  iRc += TestMethod( po, "d1.CTOD( '12/01/02' )", d1.CTOD( "12/01/02" ), 0 );
+  iRc += TestMethod( po, "d1.CTOD( '12/01/02' )", d1.Str(), "20021201", 8 );
+
+  xbString s1, s2;
+  s1 = "MM-DD-YY";
+  d1 = "20130402";
+  iRc+= TestMethod( po, "d1.FormatDate( s1, sOutDate )", d1.FormatDate( s1, sOutDate ), 0 );
+  iRc+= TestMethod( po, "d1.FormatDate( s1, sOutDate )", sOutDate, "04-02-13", 8 );
+
+  d1 = "20120203";
+  iRc += TestMethod( po, "d1=20120203", d1.Str(), "20120203", 8 );
+
+  s1 = "20130405";
+  d1 = s1;
+  iRc += TestMethod( po, "d1=s1", d1.Str(), "20130405", 8 );
+
+  d2 = d1;
+  iRc += TestMethod( po, "d2=d1", d2.Str(), "20130405", 8 );
+
+  d2+=5;
+  iRc += TestMethod( po, "d2+=5", d2.Str(), "20130410", 8 );
+
+  d2-=7;
+  iRc += TestMethod( po, "d2-=5", d2.Str(), "20130403", 8 );
+
+  d2++;
+  iRc += TestMethod( po, "d2++", d2.Str(), "20130404", 8 );
+
+  d2--;
+  iRc+= TestMethod( po, "d2--", d2.Str(), "20130403", 8 );
+  iRc+= TestMethod( po, "d2-d1", d1-d2, 2 );
+  iRc+= TestMethod( po, "d1+2", d1+2, "20130407", 8 );
+  iRc+= TestMethod( po, "d1-5", d1-5, "20130402", 8 );
+
+//  d1.Dump( "d1" );
+//  d2.Dump( "d2" );
+
+  iRc+= TestMethod( po, "d1==d2", d1==d2, 0 );
+  d2 = d1;
+  iRc+= TestMethod( po, "d1==d2", d1==d2, 1 );
+  iRc+= TestMethod( po, "d1>=d2", d1>=d2, 1 );
+  iRc+= TestMethod( po, "d1<=d2", d1<=d2, 1 );
+  iRc+= TestMethod( po, "d1!=d2", d1!=d2, 0 );
+  d2++;
+  iRc+= TestMethod( po, "d1!=d2", d1!=d2, 1 );
+
+  iRc+= TestMethod( po, "d1>d2", d1>d2, 0 );
+  iRc+= TestMethod( po, "d1>=d2", d1>=d2, 0 );
+  iRc+= TestMethod( po, "d1<d2", d1<d2, 1 );
+  iRc+= TestMethod( po, "d1<=d2", d1<=d2, 1 );
+
+  d2-=2;
+  iRc+= TestMethod( po, "d1>d2", d1>d2, 1 );
+  iRc+= TestMethod( po, "d1>=d2", d1>=d2, 1 );
+  iRc+= TestMethod( po, "d1<d2", d1<d2, 0 );
+  iRc+= TestMethod( po, "d1<=d2", d1<=d2, 0 );
+  iRc+= TestMethod( po, "d1-d2", d1-d2, 1 );
+
+/*
+  xbDate d4( "20171015" );
+  std::cout << "day of [" << d4.Str() << "][" << d4.DayOf( XB_FMT_WEEK ) << "]\n";
+  d4++;
+  std::cout << "day of [" << d4.Str() << "][" << d4.DayOf( XB_FMT_WEEK ) << "]\n";
+  d4++;
+  std::cout << "day of [" << d4.Str() << "][" << d4.DayOf( XB_FMT_WEEK ) << "]\n";
+  d4++;
+  std::cout << "day of [" << d4.Str() << "][" << d4.DayOf( XB_FMT_WEEK ) << "]\n";
+  d4++;
+  std::cout << "day of [" << d4.Str() << "][" << d4.DayOf( XB_FMT_WEEK ) << "]\n";
+  d4++;
+  std::cout << "day of [" << d4.Str() << "][" << d4.DayOf( XB_FMT_WEEK ) << "]\n";
+  d4++;
+  std::cout << "day of [" << d4.Str() << "][" << d4.DayOf( XB_FMT_WEEK ) << "]\n";
+  d4++;
+  std::cout << "day of [" << d4.Str() << "][" << d4.DayOf( XB_FMT_WEEK ) << "]\n";
+*/
+
+  if( po > 0 || iRc < 0 )
+    fprintf( stdout, "Total Errors = %d\n", iRc * -1 );
+
+#ifdef XB_LOGGING_SUPPORT
+  sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], iRc * -1 );
+  x.WriteLogMessage( sMsg );
+#endif
+
+  return iRc;
+}
diff --git a/src/tests/xb_test_dbf_v3_memos.cpp b/src/tests/xb_test_dbf_v3_memos.cpp
new file mode 100755
index 0000000..e364741
--- /dev/null
+++ b/src/tests/xb_test_dbf_v3_memos.cpp
@@ -0,0 +1,233 @@
+/* xb_test_xbdbf_v3_memos.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+
+The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
+
+Email Contact:
+
+    XDB-devel@lists.sourceforge.net
+    XDB-users@lists.sourceforge.net
+
+*/
+
+// This program tests the version III memo field logic
+
+// usage:   xb_test_dbf_v3_memos QUITE|NORMAL|VERBOSE
+
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+
+int main( int argCnt, char **av )
+{
+  int rc = 0;
+  int rc2 = 0;
+  int po = 1;          /* print option */
+                       /* 0 - QUIET    */
+                       /* 1 - NORMAL   */
+                       /* 2 - VERBOSE  */
+
+
+  if( argCnt > 1 ) {
+    if( av[1][0] == 'Q' )
+      po = 0;
+    else if( av[1][0] == 'V' )
+      po = 2;
+  }
+
+
+  xbSchema MyV3Record[] = 
+  {
+    { "RECID",      XB_NUMERIC_FLD,   8, 0 },
+    { "MEMOFLD1",   XB_MEMO_FLD,     10, 0 },
+    { "MEMOFLD2",   XB_MEMO_FLD,     10, 0 },
+    { "",0,0,0 }
+  };
+
+
+  xbXBase x;
+
+#ifdef XB_LOGGING_SUPPORT
+
+  x.EnableMsgLogging();
+  if( po ){
+    std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+  }
+  xbString sMsg;
+  sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+  x.WriteLogMessage( sMsg );
+
+#endif
+
+  x.SetDataDirectory( PROJECT_DATA_DIR );
+  x.EnableMsgLogging();
+  x.DisableDefaultAutoLock();
+  InitTime();
+
+  if( po > 0 )
+    std::cout << "Default Data Directory is [" << x.GetDataDirectory().Str() << "]" << std::endl;
+
+  xbDbf3 V3Dbf( &x );                /* version 3 dbf file */
+
+  rc2 = V3Dbf.CreateTable( "TestV3_memos.DBF", "TestV3", MyV3Record, XB_OVERLAY, XB_MULTI_USER );
+  rc += TestMethod( po, "CreateTable()", (xbInt32) rc2, XB_NO_ERROR );
+
+
+  if( rc2 )
+    x.DisplayError( rc2 );
+  else{
+
+    xbInt16  fldRecId = V3Dbf.GetFieldNo( "RECID" );
+    xbInt16  fldMemo1 = V3Dbf.GetFieldNo( "MEMOFLD1" );
+    xbInt16  fldMemo2 = V3Dbf.GetFieldNo( "MEMOFLD2" );
+    xbString sData;
+
+    // Record 1
+    rc += TestMethod( po, "BlankRecord()", V3Dbf.BlankRecord(), XB_NO_ERROR );
+    rc += TestMethod( po, "PutField()", V3Dbf.PutField( fldRecId, "1" ), XB_NO_ERROR );
+    sData = "Memo data";
+    rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+
+    sData = "Some other memo data";
+    rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+    rc += TestMethod( po, "AppendRecord()", V3Dbf.AppendRecord(), XB_NO_ERROR );
+
+    // Record 2
+    rc += TestMethod( po, "BlankRecord()", V3Dbf.BlankRecord(), XB_NO_ERROR );
+    rc += TestMethod( po, "PutField()", V3Dbf.PutField( fldRecId, "2" ), XB_NO_ERROR );
+    sData = "Memo data Rec 2 ..[";
+    sData.PadRight( 'Z', 1036 );
+    sData += ']';
+    rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+    sData = "Some other memo data Rec 2 ... [";
+    sData.PadRight( 'W', 1555 );
+    sData += ']';
+    rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+    rc += TestMethod( po, "AppendRecord()", V3Dbf.AppendRecord(), XB_NO_ERROR );
+
+    // Check memo header file
+    xbUInt32 ulNextBlock;
+    xbMemo *Memo = V3Dbf.GetMemoPtr();
+    rc += TestMethod( po, "GetHdrNextBlock()", Memo->GetHdrNextBlock( ulNextBlock ), XB_NO_ERROR );
+    rc += TestMethod( po, "GetHdrNextBlock()", (xbInt32) ulNextBlock, 10 );
+
+
+    // Zap a table with memo fields
+    rc += TestMethod( po, "Zap(0)", V3Dbf.Zap(), XB_NO_ERROR );
+    xbUInt32 ulRecCnt = 0;
+    rc += TestMethod( po, "GetRecCount()", V3Dbf.GetRecordCnt( ulRecCnt ), XB_NO_ERROR );
+    rc += TestMethod( po, "GetRecCount() b", (xbInt32) ulRecCnt, 0 );
+    Memo = V3Dbf.GetMemoPtr();
+    rc += TestMethod( po, "GetHdrNextBlock()", Memo->GetHdrNextBlock( ulNextBlock ), XB_NO_ERROR );
+    rc += TestMethod( po, "GetHdrNextBlock()", (xbInt32) ulNextBlock, 1 );
+
+
+
+    // Add records back into the table 
+    // Record 1
+    rc += TestMethod( po, "BlankRecord()", V3Dbf.BlankRecord(), XB_NO_ERROR );
+    rc += TestMethod( po, "PutField()", V3Dbf.PutField( fldRecId, "1" ), XB_NO_ERROR );
+    sData = "Memo data rec 1 memo 1";
+    rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+
+    sData = "Memo data rec 1 memo 2";
+    rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+    rc += TestMethod( po, "AppendRecord()", V3Dbf.AppendRecord(), XB_NO_ERROR );
+
+    // Record 2
+    rc += TestMethod( po, "BlankRecord()", V3Dbf.BlankRecord(), XB_NO_ERROR );
+    rc += TestMethod( po, "PutField()", V3Dbf.PutField( fldRecId, "2" ), XB_NO_ERROR );
+    sData = "Memo data Rec 2 memo 1..[";
+    sData.PadRight( 'Z', 1036 );
+    sData += ']';
+    rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+    sData = "Some other memo data Rec 2 memo 2 ... [";
+    sData.PadRight( 'W', 1555 );
+    sData += ']';
+    rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+    rc += TestMethod( po, "AppendRecord()", V3Dbf.AppendRecord(), XB_NO_ERROR );
+
+    // Record 3
+    rc += TestMethod( po, "BlankRecord()", V3Dbf.BlankRecord(), XB_NO_ERROR );
+    rc += TestMethod( po, "PutField()", V3Dbf.PutField( fldRecId, "3" ), XB_NO_ERROR );
+    sData = "Memo data Rec 3 memo 1";
+    rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+
+    sData = "Memo data Rec 3 memo 2";
+    rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+    rc += TestMethod( po, "AppendRecord()", V3Dbf.AppendRecord(), XB_NO_ERROR );
+
+
+    // Record 4
+    rc += TestMethod( po, "BlankRecord()", V3Dbf.BlankRecord(), XB_NO_ERROR );
+    rc += TestMethod( po, "PutField()", V3Dbf.PutField( fldRecId, "4" ), XB_NO_ERROR );
+    sData = "Memo data Rec 4 memo 1";
+    rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+    sData = "Memo data Rec 4 memo 2";
+    rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+    rc += TestMethod( po, "AppendRecord()", V3Dbf.AppendRecord(), XB_NO_ERROR );
+
+
+    // Record 5
+    rc += TestMethod( po, "BlankRecord()", V3Dbf.BlankRecord(), XB_NO_ERROR );
+    rc += TestMethod( po, "PutField()", V3Dbf.PutField( fldRecId, "5" ), XB_NO_ERROR );
+    sData = "Memo data Rec 5 memo 1";
+    rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+    sData = "Memo data Rec 5 memo 2";
+    rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+    rc += TestMethod( po, "AppendRecord()", V3Dbf.AppendRecord(), XB_NO_ERROR );
+
+
+    // Record 6
+    rc += TestMethod( po, "BlankRecord()", V3Dbf.BlankRecord(), XB_NO_ERROR );
+    rc += TestMethod( po, "PutField()", V3Dbf.PutField( fldRecId, "6" ), XB_NO_ERROR );
+    sData = "Memo data Rec 6 memo 1";
+    rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+    sData = "Memo data Rec 6 memo 2";
+    rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+    rc += TestMethod( po, "AppendRecord()", V3Dbf.AppendRecord(), XB_NO_ERROR );
+
+
+    // Record 7
+    rc += TestMethod( po, "BlankRecord()", V3Dbf.BlankRecord(), XB_NO_ERROR );
+    rc += TestMethod( po, "PutField()", V3Dbf.PutField( fldRecId, "7" ), XB_NO_ERROR );
+    sData = "Memo data Rec 7 memo 1";
+    rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+    sData = "Memo data Rec 7 memo 2";
+    rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+    rc += TestMethod( po, "AppendRecord()", V3Dbf.AppendRecord(), XB_NO_ERROR );
+
+
+    // Flag 1, 3, 5 and 7 for deletion
+    rc += TestMethod( po, "GetRecord()", V3Dbf.GetRecord( 1 ), XB_NO_ERROR );
+    rc += TestMethod( po, "DeleteRecord()", V3Dbf.DeleteRecord(), XB_NO_ERROR );
+
+    rc += TestMethod( po, "GetRecord()", V3Dbf.GetRecord( 3 ), XB_NO_ERROR );
+    rc += TestMethod( po, "DeleteRecord()", V3Dbf.DeleteRecord(), XB_NO_ERROR );
+
+    rc += TestMethod( po, "GetRecord()", V3Dbf.GetRecord( 5 ), XB_NO_ERROR );
+    rc += TestMethod( po, "DeleteRecord()", V3Dbf.DeleteRecord(), XB_NO_ERROR );
+
+    rc += TestMethod( po, "GetRecord()", V3Dbf.GetRecord( 7 ), XB_NO_ERROR );
+    rc += TestMethod( po, "DeleteRecord()", V3Dbf.DeleteRecord(), XB_NO_ERROR );
+    rc += TestMethod( po, "Pack()", V3Dbf.Pack(), XB_NO_ERROR );
+    rc += TestMethod( po, "Close()", V3Dbf.Close(), XB_NO_ERROR );
+  }
+
+  if( po > 0 || rc < 0 )
+    fprintf( stdout, "Total Errors = %d\n", rc * -1 );
+
+#ifdef XB_LOGGING_SUPPORT
+  sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], rc * -1 );
+  x.WriteLogMessage( sMsg );
+#endif
+
+  return rc;
+}
diff --git a/src/tests/xb_test_dbf_v3_nomemos.cpp b/src/tests/xb_test_dbf_v3_nomemos.cpp
new file mode 100755
index 0000000..aab118f
--- /dev/null
+++ b/src/tests/xb_test_dbf_v3_nomemos.cpp
@@ -0,0 +1,323 @@
+/* xb_test_xbdbf_v3_nomemos.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+
+The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
+
+Email Contact:
+
+    XDB-devel@lists.sourceforge.net
+    XDB-users@lists.sourceforge.net
+
+*/
+
+// This program tests the class xbXdbf
+
+// usage:   xb_test_dbf_v3_nomemos QUITE|NORMAL|VERBOSE
+
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+
+int main( int argCnt, char **av )
+{
+  int iRc = 0;
+  int iRc2 = 0;
+  int po = 1;          /* print option */
+                       /* 0 - QUIET    */
+                       /* 1 - NORMAL   */
+                       /* 2 - VERBOSE  */
+
+  if( argCnt > 1 ) {
+    if( av[1][0] == 'Q' )
+      po = 0;
+    else if( av[1][0] == 'V' )
+      po = 2;
+  }
+
+
+  xbSchema MyV3Record[] = 
+  {
+    { "FIRSTNAME",  XB_CHAR_FLD,     15, 0 },
+    { "LASTNAME",   XB_CHAR_FLD,     20, 0 },
+    { "MIDDLEINIT", XB_CHAR_FLD,      1, 0 },
+    { "BIRTHDATE",  XB_DATE_FLD,      8, 0 },
+    { "STARTDATE",  XB_DATE_FLD,      8, 0 },
+    { "AMOUNT",     XB_NUMERIC_FLD,   9, 2 },
+    { "TESTNUM",    XB_NUMERIC_FLD,  12, 4 },
+    { "SWITCH",     XB_LOGICAL_FLD,   1, 0 },
+    { "ZIPCODE",    XB_NUMERIC_FLD,   5, 0 },
+    { "",0,0,0 }
+  };
+
+
+  xbXBase x;
+
+#ifdef XB_LOGGING_SUPPORT
+  x.EnableMsgLogging();
+  if( po ){
+    std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+  }
+  xbString sMsg;
+  sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+  x.WriteLogMessage( sMsg );
+#endif
+
+  x.SetDataDirectory( PROJECT_DATA_DIR );
+  x.EnableMsgLogging();
+  x.DisableDefaultAutoLock();
+  InitTime();
+
+  if( po > 0 )
+    std::cout << "Default Data Directory is [" << x.GetDataDirectory().Str() << "]" << std::endl;
+
+
+  xbDbf3 V3Dbf( &x );   /* version 3 dbf file */
+
+  iRc2 = V3Dbf.CreateTable( "TestV3.DBF", "TestV3", MyV3Record, XB_OVERLAY, XB_MULTI_USER );
+
+  iRc += TestMethod( po, "CreateTable()", (xbInt32) iRc2, XB_NO_ERROR );
+  if( iRc2 )
+    x.DisplayError( iRc2 );
+
+  if( po == 2 ){
+    std::cout << "There should be one entry in the table list" << std::endl;
+    x.DisplayTableList();
+  }
+
+  xbDbf3 V3Dbf2( &x );
+  // next occurrence should error as a dup
+  x.WriteLogMessage( "Second create attempt" );
+  iRc2 = V3Dbf2.CreateTable( "TestV3.DBF", "TestV3", MyV3Record, XB_DONTOVERLAY, XB_MULTI_USER );
+  iRc += TestMethod( po, "CreateTable()", iRc2, XB_FILE_EXISTS );
+  if( iRc2 != XB_FILE_EXISTS ){
+    x.DisplayError( iRc2 );
+  }
+
+  if( po == 2 ){
+    std::cout << "There should be one entry in the table list" << std::endl;
+    x.DisplayTableList();
+  }
+
+  iRc += TestMethod( po, "BlankRecord()", V3Dbf.BlankRecord(), XB_NO_ERROR );
+  iRc += TestMethod( po, "GetFieldNo()", V3Dbf.GetFieldNo("LASTNAME"), 1 );
+  iRc += TestMethod( po, "GetFieldNo()", V3Dbf.GetFieldNo("MIDDLEINIT"), 2 );
+
+  xbInt16 fldLastName = V3Dbf.GetFieldNo( "LASTNAME" );
+
+  iRc += TestMethod( po, "PutField()", V3Dbf.PutField( fldLastName, "NELSON" ), XB_NO_ERROR );
+  iRc += TestMethod( po, "PutField()", V3Dbf.PutField( "FIRSTNAME", "WILLIE" ), XB_NO_ERROR );
+
+  iRc += TestMethod( po, "PutField()", V3Dbf.PutField( "AMOUNT", "12.34" ), XB_NO_ERROR );
+  xbDate d( "19991201" );
+  iRc += TestMethod( po, "PutDateField()", V3Dbf.PutDateField( "STARTDATE", d ), XB_NO_ERROR );
+  iRc += TestMethod( po, "PutField()", V3Dbf.PutField( "STARTDATE", "19991301" ), XB_INVALID_DATA );
+  iRc += TestMethod( po, "PutField()", V3Dbf.PutField( "STARTDATE", "19991201" ), XB_NO_ERROR );
+
+
+  iRc += TestMethod( po, "PutLongField()", V3Dbf.PutLongField( "ZIPCODE", 12345 ), XB_NO_ERROR );
+  iRc += TestMethod( po, "PutLogicalField()", V3Dbf.PutLogicalField( "SWITCH", "Y" ), XB_NO_ERROR );
+  iRc += TestMethod( po, "PutFloatField()", V3Dbf.PutFloatField( "TESTNUM", (xbFloat) 1234.5678 ), XB_NO_ERROR );
+  iRc += TestMethod( po, "AppendRecord()", V3Dbf.AppendRecord(), XB_NO_ERROR );
+
+  xbString sf;
+  iRc += TestMethod( po, "GetField1()", V3Dbf.GetField( fldLastName, sf, 0 ), XB_NO_ERROR );
+  iRc += TestMethod( po, "GetField2()", sf, "NELSON              ", 20 );
+  iRc += TestMethod( po, "GetField3()", V3Dbf.GetField( fldLastName, sf ), XB_NO_ERROR );
+  iRc += TestMethod( po, "GetField4()", sf, "NELSON              ", 20 );
+  iRc += TestMethod( po, "GetField5()", V3Dbf.GetField( "LASTNAME", sf ), XB_NO_ERROR );
+  iRc += TestMethod( po, "GetField6()", sf, "NELSON              ", 20 );
+  xbInt16 iNoOfDecimals;
+  iRc += TestMethod( po, "GetFieldDecimal()", V3Dbf.GetFieldDecimal( "AMOUNT", iNoOfDecimals ), XB_NO_ERROR );
+  iRc += TestMethod( po, "GetFieldDecimal()", iNoOfDecimals, 2 );
+
+  char FieldType;
+  iRc += TestMethod( po, "GetFieldType()", V3Dbf.GetFieldType( "STARTDATE", FieldType ), XB_NO_ERROR );
+  iRc += TestMethod( po, "GetFieldType()", FieldType , 'D' );
+
+  xbInt16 iFieldLen;
+  iRc += TestMethod( po, "GetFieldLen()", V3Dbf.GetFieldLen( "STARTDATE", iFieldLen ), XB_NO_ERROR );
+  iRc += TestMethod( po, "GetFieldLen()", iFieldLen, 8 );
+
+  xbInt16 fldAMT = V3Dbf.GetFieldNo( "AMOUNT" );
+  iRc += TestMethod( po, "GetRawField1()", V3Dbf.GetField( fldAMT, sf ), XB_NO_ERROR );
+  iRc += TestMethod( po, "GetRawField2()", sf, "    12.34", 9 );
+
+  xbInt32 lZip;
+  iRc += TestMethod( po, "GetLongField()", V3Dbf.GetLongField( "ZIPCODE", lZip ), XB_NO_ERROR );
+  iRc += TestMethod( po, "GetLongField()", lZip, 12345 );
+
+  xbString sSwitch;
+  iRc += TestMethod( po, "GetLogicalField()", V3Dbf.GetLogicalField( "SWITCH", sSwitch ), XB_NO_ERROR );
+  iRc += TestMethod( po, "GetLogicalField()", sSwitch, "Y", 1 );
+
+  xbFloat fNum;
+  iRc += TestMethod( po, "GetFloatField()", V3Dbf.GetFloatField( "TESTNUM", fNum ), 0 );
+  iRc += TestMethod( po, "GetFloatField()", fNum, (xbFloat) 1234.5678 );
+
+  iRc += TestMethod( po, "GetDateField()", V3Dbf.GetDateField( "STARTDATE", d ), 0 );
+  iRc += TestMethod( po, "GetDateField()", d.Str(), "19991201", 8 );
+
+  // init a second record for more testing
+  iRc += TestMethod( po, "BlankRecord()", V3Dbf.BlankRecord(), XB_NO_ERROR );
+  iRc += TestMethod( po, "PutLogicalField()", V3Dbf.PutLogicalField( "SWITCH", xbTrue ), XB_NO_ERROR );
+  iRc += TestMethod( po, "AppendRecord()", V3Dbf.AppendRecord(), XB_NO_ERROR );
+  xbBool bSwitch;
+  iRc += TestMethod( po, "GetLogicalField()", V3Dbf.GetLogicalField( "SWITCH", bSwitch ), XB_NO_ERROR );
+  iRc += TestMethod( po, "GetLogicalField()", bSwitch, xbTrue );
+
+  // init a third record for more testing
+  iRc += TestMethod( po, "BlankRecord()", V3Dbf.BlankRecord(), XB_NO_ERROR );
+  iRc += TestMethod( po, "PutLogicalField()", V3Dbf.PutLogicalField( "SWITCH", xbFalse ), XB_NO_ERROR );
+  iRc += TestMethod( po, "AppendRecord()", V3Dbf.AppendRecord(), XB_NO_ERROR );
+
+
+  iRc += TestMethod( po, "GetLogicalField()", V3Dbf.GetLogicalField( "SWITCH", bSwitch ), XB_NO_ERROR );
+  iRc += TestMethod( po, "GetLogicalField()", bSwitch, xbFalse );
+
+  iRc += TestMethod( po, "PutField()", V3Dbf.PutField( "TESTNUM", "12345678" ), XB_INVALID_DATA );
+  iRc += TestMethod( po, "PutField()", V3Dbf.PutField( "TESTNUM", "1234567" ), XB_NO_ERROR );
+  iRc += TestMethod( po, "PutField()", V3Dbf.PutField( "TESTNUM", "1234567.12345" ), XB_INVALID_DATA );
+  iRc += TestMethod( po, "PutField()", V3Dbf.PutField( "TESTNUM", ".12345" ), XB_INVALID_DATA );
+  iRc += TestMethod( po, "PutField()", V3Dbf.PutField( "TESTNUM", ".1234" ), XB_NO_ERROR );
+  iRc += TestMethod( po, "PutField()", V3Dbf.PutField( "TESTNUM", "12345678.1234" ), XB_INVALID_DATA );
+  iRc += TestMethod( po, "PutField()", V3Dbf.PutField( "TESTNUM", "1234567.1234" ), XB_NO_ERROR );
+  iRc += TestMethod( po, "AppendRecord()", V3Dbf.AppendRecord(), XB_NO_ERROR );
+
+  iRc += TestMethod( po, "GetFieldCnt()", V3Dbf.GetFieldCnt(), 9 );
+  iRc += TestMethod( po, "GetTblAlias()", V3Dbf.GetTblAlias(), "TestV3", 6 );
+  iRc += TestMethod( po, "GetDbfStatus()", V3Dbf.GetDbfStatus(), XB_OPEN );
+  iRc += TestMethod( po, "GetCurRecNo()", (xbInt32) V3Dbf.GetCurRecNo(), 4 );
+  iRc += TestMethod( po, "GetFirstRecord()", V3Dbf.GetFirstRecord(), XB_NO_ERROR );
+  iRc += TestMethod( po, "GetCurRecNo()", (xbInt32) V3Dbf.GetCurRecNo(), 1 );
+  iRc += TestMethod( po, "GetNextRecord()", V3Dbf.GetNextRecord(), XB_NO_ERROR );
+  iRc += TestMethod( po, "GetCurRecNo()", (xbInt32) V3Dbf.GetCurRecNo(), 2 );
+  iRc += TestMethod( po, "GetLastRecord()", V3Dbf.GetLastRecord(), XB_NO_ERROR );
+  iRc += TestMethod( po, "GetCurRecNo()", (xbInt32) V3Dbf.GetCurRecNo(), 4 );
+  iRc += TestMethod( po, "GetPrevRecord()", V3Dbf.GetPrevRecord(), XB_NO_ERROR );
+  iRc += TestMethod( po, "GetCurRecNo()", (xbInt32) V3Dbf.GetCurRecNo(), 3 );
+  iRc += TestMethod( po, "GetRecordLen()", V3Dbf.GetRecordLen(), 80 );
+
+  iRc += TestMethod( po, "GetFirstRecord( XB_ALL_RECS )", V3Dbf.GetFirstRecord( XB_ALL_RECS ), XB_NO_ERROR );
+  iRc += TestMethod( po, "GetCurRecNo()", (xbInt32) V3Dbf.GetCurRecNo(), 1 );
+  iRc += TestMethod( po, "GetNextRecord( XB_ALL_RECS )", V3Dbf.GetNextRecord( XB_ALL_RECS ), XB_NO_ERROR );
+  iRc += TestMethod( po, "GetCurRecNo()", (xbInt32) V3Dbf.GetCurRecNo(), 2 );
+  iRc += TestMethod( po, "GetLastRecord( XB_ALL_RECS )", V3Dbf.GetLastRecord( XB_ALL_RECS ), XB_NO_ERROR );
+  iRc += TestMethod( po, "GetCurRecNo()", (xbInt32) V3Dbf.GetCurRecNo(), 4 );
+  iRc += TestMethod( po, "GetPrevRecord( XB_ALL_RECS )", V3Dbf.GetPrevRecord( XB_ALL_RECS ), XB_NO_ERROR );
+  iRc += TestMethod( po, "GetCurRecNo()", (xbInt32) V3Dbf.GetCurRecNo(), 3 );
+
+  iRc += TestMethod( po, "GetFirstRecord( XB_DELETED_RECS )", V3Dbf.GetFirstRecord( XB_DELETED_RECS ), XB_EOF );
+  iRc += TestMethod( po, "GetLastRecord( XB_DELETED_RECS )",  V3Dbf.GetLastRecord( XB_DELETED_RECS ),  XB_EOF );
+
+  iRc += TestMethod( po, "GetFirstRecord( XB_ALL_RECS )", V3Dbf.GetFirstRecord( XB_ALL_RECS ), XB_NO_ERROR );
+  iRc += TestMethod( po, "GetNextRecord( XB_DELETED_RECS )", V3Dbf.GetNextRecord( XB_DELETED_RECS ), XB_EOF );
+
+  iRc += TestMethod( po, "GetLastRecord( XB_ALL_RECS )", V3Dbf.GetLastRecord( XB_ALL_RECS ), XB_NO_ERROR );
+  iRc += TestMethod( po, "GetPrevRecord( XB_DELETED_RECS )", V3Dbf.GetPrevRecord( XB_DELETED_RECS ), XB_BOF );
+
+  iRc += TestMethod( po, "DeleteAllRecords()", V3Dbf.DeleteAllRecords(), XB_NO_ERROR );
+
+
+  iRc += TestMethod( po, "GetFirstRecord()", V3Dbf.GetFirstRecord(), XB_EOF );
+  iRc += TestMethod( po, "GetLastRecord()", V3Dbf.GetLastRecord(), XB_EOF );
+
+  iRc += TestMethod( po, "GetFirstRecord( XB_ALL_RECS )", V3Dbf.GetFirstRecord( XB_ALL_RECS ), XB_NO_ERROR );
+  iRc += TestMethod( po, "GetCurRecNo()", (xbInt32) V3Dbf.GetCurRecNo(), 1 );
+
+  iRc += TestMethod( po, "GetNextRecord( XB_ALL_RECS )", V3Dbf.GetNextRecord( XB_ALL_RECS ), XB_NO_ERROR );
+  iRc += TestMethod( po, "GetCurRecNo()", (xbInt32) V3Dbf.GetCurRecNo(), 2 );
+
+  iRc += TestMethod( po, "GetNextRecord()", V3Dbf.GetNextRecord(), XB_EOF );
+
+  iRc += TestMethod( po, "GetLastRecord( XB_ALL_RECS )", V3Dbf.GetLastRecord( XB_ALL_RECS ), XB_NO_ERROR );
+  iRc += TestMethod( po, "GetCurRecNo()", (xbInt32) V3Dbf.GetCurRecNo(), 4 );
+
+  iRc += TestMethod( po, "GetPrevRecord( XB_ALL_RECS )", V3Dbf.GetPrevRecord( XB_ALL_RECS ), XB_NO_ERROR );
+  iRc += TestMethod( po, "GetCurRecNo()", (xbInt32) V3Dbf.GetCurRecNo(), 3 );
+
+  iRc += TestMethod( po, "UndeleteAllRecords()", V3Dbf.UndeleteAllRecords(), XB_NO_ERROR );
+
+  char * p = V3Dbf.GetRecordBuf();
+  iRc += TestMethod( po, "GetRecordBuf()", p[0], ' ' );
+
+  if( po == 2 ){
+    V3Dbf.DumpHeader( 3 );
+    V3Dbf.DumpRecord( 4 );
+  }
+
+
+
+  iRc += TestMethod( po, "PutField()", V3Dbf.PutField( "LASTNAME", "CLINTON" ), XB_NO_ERROR );
+  iRc += TestMethod( po, "PutRecord()", V3Dbf.PutRecord(), XB_NO_ERROR );
+  iRc += TestMethod( po, "DeleteRecord()", V3Dbf.DeleteRecord(), XB_NO_ERROR );
+  iRc += TestMethod( po, "UndeleteRecord()", V3Dbf.UndeleteRecord(), XB_NO_ERROR );
+  xbUInt32 ulRecCnt = 0;
+  iRc += TestMethod( po, "GetRecordCnt()", V3Dbf.GetRecordCnt( ulRecCnt ), XB_NO_ERROR );
+  iRc += TestMethod( po, "GetRecordCnt()b",(xbInt32) ulRecCnt, 4 );
+  iRc += TestMethod( po, "DeleteAllRecords()", V3Dbf.DeleteAllRecords(), XB_NO_ERROR );
+  iRc += TestMethod( po, "UndeleteAllRecords()", V3Dbf.UndeleteAllRecords(), XB_NO_ERROR );
+  iRc += TestMethod( po, "GetRecord()", V3Dbf.GetRecord( 4 ), XB_NO_ERROR );
+  iRc += TestMethod( po, "DeleteRecord()", V3Dbf.DeleteRecord(), XB_NO_ERROR );
+  iRc += TestMethod( po, "Commit()", V3Dbf.Commit(), XB_NO_ERROR );
+  iRc += TestMethod( po, "GetDbfStatus()", V3Dbf.GetDbfStatus(), XB_OPEN );
+
+  if( po == 2 ){
+    V3Dbf.DumpRecord( 4 );
+  }
+
+  xbDbf3 CopyDbf( &x );
+  iRc += TestMethod( po, "CopyDbfStructure()", V3Dbf.CopyDbfStructure( &CopyDbf, "CopyStructureV3NoMemos", "CopyAliasV3NoMemos", XB_OVERLAY, XB_MULTI_USER ), XB_NO_ERROR );
+  iRc += TestMethod( po, "CopyDbf.Close()", CopyDbf.Close(), XB_NO_ERROR );
+
+  if( po == 2 ){
+    std::cout << "There should be one entry in the table list" << std::endl;
+    x.DisplayTableList();
+  }
+
+  iRc += TestMethod( po, "GetDbfStatus()", CopyDbf.GetDbfStatus(), XB_CLOSED );
+  iRc += TestMethod( po, "Open()", CopyDbf.xbDbf::Open( "CopyStructureV3NoMemos.DBF", "CopyAliasV3NoMemos" ), XB_NO_ERROR );
+
+  if( po == 2 ){
+    std::cout << "There should be two entries in the table list" << std::endl;
+    x.DisplayTableList();
+  }
+
+  iRc += TestMethod( po, "CopyDbf.Close()", CopyDbf.Close(), XB_NO_ERROR );
+
+  #ifdef XB_DEBUG_SUPPORT
+   #ifdef XB_LOCKING_SUPPORT
+    V3Dbf.DumpTableLockStatus();
+   #endif
+  #endif
+
+  iRc += TestMethod( po, "PackTable( 0, 0 )", V3Dbf.Pack(), XB_NO_ERROR );
+  iRc += TestMethod( po, "GetDbfStatus()", V3Dbf.GetDbfStatus(), XB_OPEN );
+
+  iRc += TestMethod( po, "Zap()", V3Dbf.Zap(), XB_NO_ERROR );
+  if( po == 2 )
+    x.DisplayTableList();
+
+  iRc += TestMethod( po, "Close()", V3Dbf.Close(), XB_NO_ERROR );
+  if( po == 2 )
+    x.DisplayTableList();
+
+  if( po > 0 || iRc < 0 )
+    fprintf( stdout, "Total Errors = %d\n", iRc * -1 );
+
+
+  V3Dbf.Abort();   // don't crash the program if uncommited updates
+
+#ifdef XB_LOGGING_SUPPORT
+  sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], iRc * -1 );
+  x.WriteLogMessage( sMsg );
+#endif
+
+  return iRc;
+}
diff --git a/src/tests/xb_test_dbf_v4_memos.cpp b/src/tests/xb_test_dbf_v4_memos.cpp
new file mode 100755
index 0000000..e92b5b2
--- /dev/null
+++ b/src/tests/xb_test_dbf_v4_memos.cpp
@@ -0,0 +1,335 @@
+/* xb_test_xbdbf_v4_memos.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+
+The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
+
+Email Contact:
+
+    XDB-devel@lists.sourceforge.net
+    XDB-users@lists.sourceforge.net
+
+*/
+
+// This program tests the version III memo field logic
+// usage:   xb_test_dbf_v4_memos QUITE|NORMAL|VERBOSE
+
+#include "xbase.h"
+using namespace xb;
+#include "tstfuncs.cpp"
+
+int main( int argCnt, char **av )
+{
+  int rc = 0;
+  int rc2 = 0;
+  int po = 1;          /* print option */
+                       /* 0 - QUIET    */
+                       /* 1 - NORMAL   */
+                       /* 2 - VERBOSE  */
+
+  if( argCnt > 1 ) {
+    if( av[1][0] == 'Q' )
+      po = 0;
+    else if( av[1][0] == 'V' )
+      po = 2;
+  }
+
+  xbSchema MyV4Record[] = 
+  {
+    { "RECID",      XB_NUMERIC_FLD,   8, 0 },
+    { "MEMOFLD1",   XB_MEMO_FLD,     10, 0 },
+    { "MEMOFLD2",   XB_MEMO_FLD,     10, 0 },
+    { "MEMOFLD3",   XB_MEMO_FLD,     10, 0 },
+    { "",0,0,0 }
+  };
+
+  xbXBase x;
+
+#ifdef XB_LOGGING_SUPPORT
+
+  x.EnableMsgLogging();
+  if( po ){
+    std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+  }
+  xbString sMsg;
+  sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+  x.WriteLogMessage( sMsg );
+
+#endif
+
+  x.SetDataDirectory( PROJECT_DATA_DIR );
+  x.EnableMsgLogging();
+  x.DisableDefaultAutoLock();
+  InitTime();
+
+
+  if( po > 0 )
+    std::cout << "Default Data Directory is [" << x.GetDataDirectory().Str() << "]" << std::endl;
+
+  xbDbf4 V4Dbf( &x );
+  rc += TestMethod( po, "SetCreateMemoBlockSize", V4Dbf.SetCreateMemoBlockSize( 1024 ), XB_NO_ERROR );
+  rc2 = V4Dbf.CreateTable( "TestV4_memos.DBF", "TestV4", MyV4Record, XB_OVERLAY, XB_MULTI_USER );
+
+  xbUInt64 ullDbfOrigFileSize = 0;
+  xbUInt64 ullDbtOrigFileSize = 0;
+  rc = V4Dbf.GetFileSize( ullDbfOrigFileSize );
+  rc = V4Dbf.GetMemoPtr()->GetFileSize( ullDbtOrigFileSize );
+
+  rc += TestMethod( po, "CreateTable()", (xbInt32) rc2, XB_NO_ERROR );
+  if( rc2 )
+    x.DisplayError( rc2 );
+  else{
+
+    xbInt16  fldRecId = V4Dbf.GetFieldNo( "RECID" );
+    xbInt16  fldMemo1 = V4Dbf.GetFieldNo( "MEMOFLD1" );
+    xbInt16  fldMemo2 = V4Dbf.GetFieldNo( "MEMOFLD2" );
+    xbInt16  fldMemo3 = V4Dbf.GetFieldNo( "MEMOFLD3" );
+    xbString sData;
+
+
+
+
+    // Record 1
+    rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+    rc += TestMethod( po, "PutField()", V4Dbf.PutField( fldRecId, "1" ), XB_NO_ERROR );
+    sData = "Memo data";
+
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+    rc += TestDbt4Method( po, "Add one block", V4Dbf.GetMemoPtr(), 2, 2, "" );
+
+    sData = "Some other memo data";
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+    rc += TestDbt4Method( po, "Add one block", V4Dbf.GetMemoPtr(), 3, 3, "" );
+    rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+
+
+
+
+    // Record 2
+    rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+    rc += TestMethod( po, "PutField()", V4Dbf.PutField( fldRecId, "2" ), XB_NO_ERROR );
+    sData = "Memo data Rec 2 ..[";
+    sData.PadRight( 'Z', 1036 );
+    sData += ']';
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+    sData = "Some other memo data Rec 2 ... [";
+    sData.PadRight( 'W', 1555 );
+    sData += ']';
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+    rc += TestDbt4Method( po, "Add 7 blocks", V4Dbf.GetMemoPtr(), 7, 7, "" );
+
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, "" ), XB_NO_ERROR );
+    rc += TestDbt4Method( po, "Delete 2 blocks", V4Dbf.GetMemoPtr(), 3, 7, "3,2,7" );
+    rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+
+    // Record 3
+    rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+    rc += TestMethod( po, "PutField()", V4Dbf.PutField( fldRecId, "3" ), XB_NO_ERROR );
+    sData = "Memo data r3f1";
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+    rc += TestDbt4Method( po, "Add one block", V4Dbf.GetMemoPtr(), 4, 7, "4,1,7" );
+    sData = "Memo data r3f2";
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+    rc += TestDbt4Method( po, "Add one block", V4Dbf.GetMemoPtr(), 7, 7, "" );
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, "" ), XB_NO_ERROR );
+    rc += TestDbt4Method( po, "Delete one block", V4Dbf.GetMemoPtr(), 3, 7, "3,1,7" );
+    rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+
+    // Record 4
+    rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+    rc += TestMethod( po, "PutField()", V4Dbf.PutField( fldRecId, "4" ), XB_NO_ERROR );
+    sData = "Memo data Rec 4 fld1 ..[";
+    sData.PadRight( 'Q', 1036 );
+    sData += ']';
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+    rc += TestDbt4Method( po, "Update Memo Field", V4Dbf.GetMemoPtr(), 3, 9, "3,1,9" );
+    rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+
+    // go back a record and delete a memo field and test if all blocks filled in
+    rc += TestMethod( po, "GetPrevRecord()", V4Dbf.GetPrevRecord(), XB_NO_ERROR );
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo2, "" ), XB_NO_ERROR );
+    rc += TestMethod( po, "Commit()", V4Dbf.Commit(), XB_NO_ERROR );
+    rc += TestDbt4Method( po, "Delete one block", V4Dbf.GetMemoPtr(), 3, 9, "3,2,9" );
+
+    // Record 5
+    rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+    rc += TestMethod( po, "PutField()", V4Dbf.PutField( fldRecId, "5" ), XB_NO_ERROR );
+    rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+
+    // Zap a table with memo fields
+    rc += TestMethod( po, "Zap()", V4Dbf.Zap(), XB_NO_ERROR );
+    xbUInt32 ulRecCnt = 0;
+    rc += TestMethod( po, "GetRecCount()", V4Dbf.GetRecordCnt( ulRecCnt ), XB_NO_ERROR );
+    rc += TestMethod( po, "GetRecCount()b", (xbInt32) ulRecCnt, 0 );
+
+    // Add records back into the table, and verify the block chains created as designed
+    // Record 1
+    rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+    rc += TestMethod( po, "PutField()", V4Dbf.PutField( fldRecId, "1" ), XB_NO_ERROR );
+    sData = "Memo data rec 1 memo 1";
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+    rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+    rc += TestDbt4Method( po, "Update Memo Field", V4Dbf.GetMemoPtr(), 2, 2, "" );
+
+    // Revise the memo field
+    sData = "Updated memo data rec1 memo 1";
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+    rc += TestMethod( po, "Commit()", V4Dbf.Commit(), XB_NO_ERROR );
+    rc += TestDbt4Method( po, "UpdateMemoField", V4Dbf.GetMemoPtr(), 2, 2, "" );
+
+    sData = "Memo data rec 1 memo 2";
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+    rc += TestMethod( po, "Commit()", V4Dbf.Commit(), XB_NO_ERROR );
+    rc += TestDbt4Method( po, "UpdateMemoField", V4Dbf.GetMemoPtr(), 3, 3, "" );
+
+    // Record 2
+    rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+    rc += TestMethod( po, "PutField()", V4Dbf.PutField( fldRecId, "2" ), XB_NO_ERROR );
+    sData = "Memo data rec 2 memo 1";
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+    sData = "Memo data rec 2 memo 2";
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+    rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+    rc += TestDbt4Method( po, "Add one block", V4Dbf.GetMemoPtr(), 5, 5, "" );
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, "" ), XB_NO_ERROR );
+    rc += TestMethod( po, "Commit()", V4Dbf.Commit(), XB_NO_ERROR );
+    rc += TestDbt4Method( po, "UpdateMemoField", V4Dbf.GetMemoPtr(), 3, 5, "3,1,5" );
+
+    sData = "Test the abort code";
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+    rc += TestMethod( po, "Abort()", V4Dbf.Abort(), XB_NO_ERROR );
+    rc += TestDbt4Method( po, "UpdateMemoField", V4Dbf.GetMemoPtr(), 3, 5, "3,1,5" );
+
+    sData = "Test mulitple updates before commit";
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+    sData = "Test mulitple updates before commit2";
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+    rc += TestDbt4Method( po, "UpdateMemoField", V4Dbf.GetMemoPtr(), 5, 5, "" );
+    sData = "Test mulitple updates before commit3";
+
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+    rc += TestMethod( po, "Commit()", V4Dbf.Commit(), XB_NO_ERROR );
+    rc += TestDbt4Method( po, "UpdateMemoField", V4Dbf.GetMemoPtr(), 5, 5, "" );
+
+//    V4Dbf.GetMemoPtr()->DumpMemoInternals();
+
+    rc += TestMethod( po, "Zap(0)", V4Dbf.Zap(), XB_NO_ERROR );
+
+    xbUInt64 ullDbfPostZapFileSize = 0;
+    xbUInt64 ullDbtPostZapFileSize = 0;
+    rc += V4Dbf.GetFileSize( ullDbfPostZapFileSize );
+    rc += V4Dbf.GetMemoPtr()->GetFileSize( ullDbtPostZapFileSize );
+
+    rc += TestMethod( po, "Zap()", ullDbfPostZapFileSize, ullDbfOrigFileSize );
+    rc += TestMethod( po, "Memo->Zap()", ullDbtPostZapFileSize, ullDbtOrigFileSize );
+    rc += TestDbt4Method( po, "Zap() block check", V4Dbf.GetMemoPtr(), 1, 1, "" );
+
+    rc += TestMethod( po, "GetRecCount()", V4Dbf.GetRecordCnt( ulRecCnt ), XB_NO_ERROR );
+    rc += TestMethod( po, "GetRecCount()", (xbInt32) ulRecCnt, 0 );
+
+    rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+    rc += TestMethod( po, "PutField()", V4Dbf.PutField( fldRecId, "1" ), XB_NO_ERROR );
+    sData = "Memo data rec 1 memo 1";
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+    sData = "Memo data rec 1 memo 2";
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+    sData = "Memo data rec 1 memo 3";
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo3, sData ), XB_NO_ERROR );
+    rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+
+    sData = "Memo data rec 1 memo 1 A";
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+    sData = "Memo data rec 1 memo 2 A";
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+    sData = "Memo data rec 1 memo 3A ";
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo3, sData ), XB_NO_ERROR );
+    rc += TestMethod( po, "Commit()", V4Dbf.Commit(), XB_NO_ERROR );
+    rc += TestDbt4Method( po, "Update Memo Field", V4Dbf.GetMemoPtr(), 4, 4, "" );
+
+    // Record 2
+    rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+    rc += TestMethod( po, "PutField()", V4Dbf.PutField( fldRecId, "2" ), XB_NO_ERROR );
+    sData = "Memo data rec 2 memo 1";
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+    sData = "Memo data rec 2 memo 2";
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+    rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+    rc += TestDbt4Method( po, "Add two blocks", V4Dbf.GetMemoPtr(), 6, 6, "" );
+
+    // Record 3
+    rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+    rc += TestMethod( po, "PutField()", V4Dbf.PutField( fldRecId, "3" ), XB_NO_ERROR );
+    sData = "Memo data rec 3 memo 1";
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+    sData = "Memo data rec 3 memo 2";
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+    rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+    rc += TestDbt4Method( po, "Add two blocks", V4Dbf.GetMemoPtr(), 8, 8, "" );
+
+    // Record 4
+    rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+    rc += TestMethod( po, "PutField()", V4Dbf.PutField( fldRecId, "4" ), XB_NO_ERROR );
+    sData = "Memo data rec 4 memo 1";
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+    sData = "Memo data rec 4 memo 2";
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+    rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+    rc += TestDbt4Method( po, "Add two blocks", V4Dbf.GetMemoPtr(), 10, 10, "" );
+
+    // Record 5
+    rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+    rc += TestMethod( po, "PutField()", V4Dbf.PutField( fldRecId, "5" ), XB_NO_ERROR );
+    sData = "Memo data rec 5 memo 1";
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+    sData = "Memo data rec 5 memo 2";
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+    rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+    rc += TestDbt4Method( po, "Add two blocks", V4Dbf.GetMemoPtr(), 12, 12, "" );
+
+    // Record 6
+    rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+    rc += TestMethod( po, "PutField()", V4Dbf.PutField( fldRecId, "6" ), XB_NO_ERROR );
+    sData = "Memo data rec 6 memo 1";
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+    sData = "Memo data rec 6 memo 2";
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+    rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+    rc += TestDbt4Method( po, "Add two blocks", V4Dbf.GetMemoPtr(), 14, 14, "" );
+
+    // Record 7
+    rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+    rc += TestMethod( po, "PutField()", V4Dbf.PutField( fldRecId, "7" ), XB_NO_ERROR );
+    sData = "Memo data rec 6 memo 1";
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+    sData = "Memo data rec 6 memo 2";
+    rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+    rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+    rc += TestDbt4Method( po, "Add two blocks", V4Dbf.GetMemoPtr(), 16, 16, "" );
+
+    // delete records 1, 3, 5, 7
+    rc += TestMethod( po, "GetRecord()", V4Dbf.GetRecord( 1 ), XB_NO_ERROR );
+    rc += TestMethod( po, "DeleteRecord()", V4Dbf.DeleteRecord(), XB_NO_ERROR );
+    rc += TestMethod( po, "GetRecord()", V4Dbf.GetRecord( 3 ), XB_NO_ERROR );
+    rc += TestMethod( po, "DeleteRecord()", V4Dbf.DeleteRecord(), XB_NO_ERROR );
+    rc += TestMethod( po, "GetRecord()", V4Dbf.GetRecord( 5 ), XB_NO_ERROR );
+    rc += TestMethod( po, "DeleteRecord()", V4Dbf.DeleteRecord(), XB_NO_ERROR );
+    rc += TestMethod( po, "GetRecord()", V4Dbf.GetRecord( 7 ), XB_NO_ERROR );
+    rc += TestMethod( po, "DeleteRecord()", V4Dbf.DeleteRecord(), XB_NO_ERROR );
+
+
+    rc += TestMethod( po, "Pack()", V4Dbf.Pack(), XB_NO_ERROR );
+    rc += TestMethod( po, "Close()", V4Dbf.Close(), XB_NO_ERROR );
+  }
+
+  if( po > 0 || rc < 0 )
+    fprintf( stdout, "Total Errors = %d\n", rc * -1 );
+
+#ifdef XB_LOGGING_SUPPORT
+  sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], rc * -1 );
+  x.WriteLogMessage( sMsg );
+#endif
+
+  return rc;
+}
diff --git a/src/tests/xb_test_dbf_v4_nomemos.cpp b/src/tests/xb_test_dbf_v4_nomemos.cpp
new file mode 100755
index 0000000..68ecda0
--- /dev/null
+++ b/src/tests/xb_test_dbf_v4_nomemos.cpp
@@ -0,0 +1,330 @@
+/* xb_test_xbdbf_v4_nomemos.cpp
+
+XBase Software Library
+
+Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+
+The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
+
+Email Contact:
+
+    XDB-devel@lists.sourceforge.net
+    XDB-users@lists.sourceforge.net
+
+*/
+
+// This program tests the class xbXdbf
+
+// usage:   xb_test_dbf_v4_nomemos QUITE|NORMAL|VERBOSE
+
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+
+int main( int argCnt, char **av )
+{
+  int rc = 0;
+  int rc2 = 0;
+  int po = 1;          /* print option */
+                       /* 0 - QUIET    */
+                       /* 1 - NORMAL   */
+                       /* 2 - VERBOSE  */
+
+  if( argCnt > 1 ) {
+    if( av[1][0] == 'Q' )
+      po = 0;
+    else if( av[1][0] == 'V' )
+      po = 2;
+  }
+
+  xbSchema MyV4Record[] = 
+  {
+    { "FIRSTNAME",  XB_CHAR_FLD,     15, 0 },
+    { "LASTNAME",   XB_CHAR_FLD,     20, 0 },
+    { "MIDDLEINIT", XB_CHAR_FLD,      1, 0 },
+    { "BIRTHDATE",  XB_DATE_FLD,      8, 0 },
+    { "STARTDATE",  XB_DATE_FLD,      8, 0 },
+    { "AMOUNT",     XB_NUMERIC_FLD,   9, 2 },
+    { "TESTNUM",    XB_NUMERIC_FLD,  12, 4 },
+    { "SWITCH",     XB_LOGICAL_FLD,   1, 0 },
+    { "ZIPCODE",    XB_NUMERIC_FLD,   5, 0 },
+    { "DBLFLDTST",  XB_FLOAT_FLD,    14, 4 },
+    { "",0,0,0 }
+  };
+
+  xbXBase x;
+
+#ifdef XB_LOGGING_SUPPORT
+  x.EnableMsgLogging();
+  if( po ){
+    std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+  }
+  xbString sMsg;
+  sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+  x.WriteLogMessage( sMsg );
+#endif
+
+  x.SetDataDirectory( PROJECT_DATA_DIR );
+  x.EnableMsgLogging();
+  x.DisableDefaultAutoLock();
+  InitTime();
+
+  if( po > 0 )
+    std::cout << "Default Data Directory is [" << x.GetDataDirectory().Str() << "]" << std::endl;
+
+  xbDbf4 V4Dbf( &x );                // version 4 dbf file
+  rc2 = V4Dbf.CreateTable( "TestV4.DBF", "TestV4", MyV4Record, XB_OVERLAY, XB_MULTI_USER );
+  rc += TestMethod( po, "CreateTable()", (xbInt32) rc2, XB_NO_ERROR );
+  if( rc2 )
+    x.DisplayError( rc2 );
+
+  xbUInt64 ullFileSize;
+  rc2 = V4Dbf.GetFileSize( ullFileSize );
+
+  rc = TestMethod( po, "CheckTableSize", ullFileSize, (xbUInt64) 353 );
+
+  if( po == 2 ){
+    std::cout << "There should be one entry in the table list" << std::endl;
+    x.DisplayTableList();
+  }
+
+  xbDbf4 V4Dbf2( &x );
+
+  // next occurrence should error as a dup
+  x.WriteLogMessage( "Second create attempt" );
+  rc2 = V4Dbf2.CreateTable( "TestV4.DBF", "TestV4", MyV4Record, XB_DONTOVERLAY, XB_MULTI_USER );
+  rc += TestMethod( po, "CreateTable()", rc2, XB_FILE_EXISTS );
+  if( rc2 != XB_FILE_EXISTS ){
+    x.DisplayError( rc2 );
+  }
+
+  if( po == 2 ){
+    std::cout << "There should be one entry in the table list" << std::endl;
+    x.DisplayTableList();
+  }
+
+
+  rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+  rc += TestMethod( po, "GetFieldNo()", V4Dbf.GetFieldNo("LASTNAME"), 1 );
+  rc += TestMethod( po, "GetFieldNo()", V4Dbf.GetFieldNo("MIDDLEINIT"), 2 );
+
+  xbInt16 fldLastName = V4Dbf.GetFieldNo( "LASTNAME" );
+  rc += TestMethod( po, "PutField()", V4Dbf.PutField( fldLastName, "NELSON" ), XB_NO_ERROR );
+  rc += TestMethod( po, "PutField()", V4Dbf.PutField( "FIRSTNAME", "WILLIE" ), XB_NO_ERROR );
+  rc += TestMethod( po, "PutField()", V4Dbf.PutField( "AMOUNT", "12.34" ), XB_NO_ERROR );
+  xbDate dt( "19500209" );
+  rc += TestMethod( po, "PutDateField()", V4Dbf.PutDateField( "BIRTHDATE", dt ), XB_NO_ERROR );
+  rc += TestMethod( po, "PutLongField()", V4Dbf.PutLongField( "ZIPCODE", 12345 ), XB_NO_ERROR );
+  rc += TestMethod( po, "PutLogicalField()", V4Dbf.PutLogicalField( "SWITCH", "Y" ), XB_NO_ERROR );
+  rc += TestMethod( po, "PutFloatField()", V4Dbf.PutFloatField( "TESTNUM", (xbFloat) 1234.5678 ), XB_NO_ERROR );
+  rc += TestMethod( po, "PutDoubleField()", V4Dbf.PutDoubleField( "DBLFLDTST", (xbDouble) 9876.5432 ), XB_NO_ERROR );
+  rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+
+
+  xbString sf;
+  rc += TestMethod( po, "GetField()", V4Dbf.GetField( fldLastName, sf, 0 ), XB_NO_ERROR );
+  rc += TestMethod( po, "GetField()", sf, "NELSON              ", 20 );
+  rc += TestMethod( po, "GetField()", V4Dbf.GetField( fldLastName, sf ), XB_NO_ERROR );
+  rc += TestMethod( po, "GetField()", sf, "NELSON              ", 20 );
+  rc += TestMethod( po, "GetField()", V4Dbf.GetField( "LASTNAME", sf ), XB_NO_ERROR );
+  rc += TestMethod( po, "GetField()", sf, "NELSON              ", 20 );
+  xbInt16 iNoOfDecimals;
+  rc += TestMethod( po, "GetFieldDecimal()", V4Dbf.GetFieldDecimal( "AMOUNT", iNoOfDecimals ), XB_NO_ERROR );
+  rc += TestMethod( po, "GetFieldDecimal()", iNoOfDecimals, 2 );
+
+  xbDouble d;
+  rc += TestMethod( po, "GetDoubleField()", V4Dbf.GetDoubleField( "DBLFLDTST", d ), XB_NO_ERROR );
+  rc += TestMethod( po, "GetDoubleField()-b", d, (xbDouble) 9876.5432 );
+
+  char FieldType;
+  rc += TestMethod( po, "GetFieldType()", V4Dbf.GetFieldType( "STARTDATE", FieldType ), XB_NO_ERROR );
+  rc += TestMethod( po, "GetFieldType()", FieldType , 'D' );
+
+  xbInt16 iFieldLen;
+  rc += TestMethod( po, "GetFieldLen()", V4Dbf.GetFieldLen( "STARTDATE", iFieldLen ), XB_NO_ERROR );
+  rc += TestMethod( po, "GetFieldLen()", iFieldLen, 8 );
+
+  xbInt16 fldAMT = V4Dbf.GetFieldNo( "AMOUNT" );
+  rc += TestMethod( po, "GetField()", V4Dbf.GetField( fldAMT, sf ), XB_NO_ERROR );
+  rc += TestMethod( po, "GetField()", sf, "    12.34", 9 );
+
+  xbInt32 lZip;
+  rc += TestMethod( po, "GetLongField()", V4Dbf.GetLongField( "ZIPCODE", lZip ), XB_NO_ERROR );
+  rc += TestMethod( po, "GetLongField()", lZip, 12345 );
+
+  xbString sSwitch;
+  rc += TestMethod( po, "GetLogicalField()", V4Dbf.GetLogicalField( "SWITCH", sSwitch ), XB_NO_ERROR );
+  rc += TestMethod( po, "GetLogicalField()", sSwitch, "Y", 1 );
+
+  xbFloat fNum;
+  rc += TestMethod( po, "GetFloatField()", V4Dbf.GetFloatField( "TESTNUM", fNum ), 0 );
+  rc += TestMethod( po, "GetFloatField()", fNum, (xbFloat) 1234.5678 );
+
+  // init a second record for more testing
+  rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+  rc += TestMethod( po, "PutLogicalField()", V4Dbf.PutLogicalField( "SWITCH", xbTrue ), XB_NO_ERROR );
+  rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+  xbBool bSwitch;
+  rc += TestMethod( po, "GetLogicalField()", V4Dbf.GetLogicalField( "SWITCH", bSwitch ), 0 );
+  rc += TestMethod( po, "GetLogicalField()", bSwitch, xbTrue );
+
+  // init a third record for more testing
+  rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+  rc += TestMethod( po, "PutLogicalField()", V4Dbf.PutLogicalField( "SWITCH", xbFalse ), XB_NO_ERROR );
+  rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+  rc += TestMethod( po, "GetLogicalField()", V4Dbf.GetLogicalField( "SWITCH", bSwitch ), 0 );
+  rc += TestMethod( po, "GetLogicalField()", bSwitch, xbFalse );
+
+  rc += TestMethod( po, "PutField()", V4Dbf.PutField( "TESTNUM", "12345678" ), XB_INVALID_DATA );
+  rc += TestMethod( po, "PutField()", V4Dbf.PutField( "TESTNUM", "1234567" ), XB_NO_ERROR );
+  rc += TestMethod( po, "PutField()", V4Dbf.PutField( "TESTNUM", "1234567.12345" ), XB_INVALID_DATA );
+  rc += TestMethod( po, "PutField()", V4Dbf.PutField( "TESTNUM", ".12345" ), XB_INVALID_DATA );
+  rc += TestMethod( po, "PutField()", V4Dbf.PutField( "TESTNUM", ".1234" ), XB_NO_ERROR );
+  rc += TestMethod( po, "PutField()", V4Dbf.PutField( "TESTNUM", "12345678.1234" ), XB_INVALID_DATA );
+  rc += TestMethod( po, "PutField()", V4Dbf.PutField( "TESTNUM", "1234567.1234" ), XB_NO_ERROR );
+
+  rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+
+  rc += TestMethod( po, "GetFieldCnt()", V4Dbf.GetFieldCnt(), 10 );
+  rc += TestMethod( po, "GetTblAlias()", V4Dbf.GetTblAlias(), "TestV4", 6 );
+  rc += TestMethod( po, "GetDbfStatus()", V4Dbf.GetDbfStatus(), XB_OPEN );
+  rc += TestMethod( po, "GetCurRecNo()", (xbInt32) V4Dbf.GetCurRecNo(), 4 );
+  rc += TestMethod( po, "GetFirstRecord()", V4Dbf.GetFirstRecord(), XB_NO_ERROR );
+  rc += TestMethod( po, "GetCurRecNo()", (xbInt32) V4Dbf.GetCurRecNo(), 1 );
+  rc += TestMethod( po, "GetNextRecord()", V4Dbf.GetNextRecord(), XB_NO_ERROR );
+  rc += TestMethod( po, "GetCurRecNo()", (xbInt32) V4Dbf.GetCurRecNo(), 2 );
+  rc += TestMethod( po, "GetLastRecord()", V4Dbf.GetLastRecord(), XB_NO_ERROR );
+  rc += TestMethod( po, "GetCurRecNo()", (xbInt32) V4Dbf.GetCurRecNo(), 4 );
+  rc += TestMethod( po, "GetPrevRecord()", V4Dbf.GetPrevRecord(), XB_NO_ERROR );
+  rc += TestMethod( po, "GetCurRecNo()", (xbInt32) V4Dbf.GetCurRecNo(), 3 );
+  rc += TestMethod( po, "GetRecordLen()", (xbInt32) V4Dbf.GetRecordLen(), 94 );
+
+  char * p = V4Dbf.GetRecordBuf();
+  rc += TestMethod( po, "GetRecordBuf()", p[0], ' ' );
+
+  if( po == 2 ){
+    V4Dbf.DumpHeader( 3 );
+    V4Dbf.DumpRecord( 4 );
+  }
+
+  rc += TestMethod( po, "PutField()", V4Dbf.PutField( "LASTNAME", "CLINTON" ), XB_NO_ERROR );
+  rc += TestMethod( po, "PutRecord()", V4Dbf.PutRecord(), XB_NO_ERROR );
+  rc += TestMethod( po, "DeleteRecord()", V4Dbf.DeleteRecord(), XB_NO_ERROR );
+  rc += TestMethod( po, "UndeleteRecord()", V4Dbf.UndeleteRecord(), XB_NO_ERROR );
+  xbUInt32 ulRecCnt = 0;
+  rc += TestMethod( po, "GetRecordCnt()", V4Dbf.GetRecordCnt( ulRecCnt ), XB_NO_ERROR );
+  rc += TestMethod( po, "GetRecordCnt()", (xbInt32) ulRecCnt, 4 );
+  rc += TestMethod( po, "DeleteAllRecords()", V4Dbf.DeleteAllRecords(), XB_NO_ERROR );
+  rc += TestMethod( po, "UndeleteAllRecords()", V4Dbf.UndeleteAllRecords(), XB_NO_ERROR );
+  rc += TestMethod( po, "GetRecord()", V4Dbf.GetRecord( 2L ), XB_NO_ERROR );
+  rc += TestMethod( po, "DeleteRecord()", V4Dbf.DeleteRecord(), XB_NO_ERROR );
+
+  if( po == 2 ){
+    V4Dbf.DumpRecord( 4 );
+  }
+
+  xbDbf4 CopyDbf( &x );
+  rc += TestMethod( po, "CopyDbfStructure()", V4Dbf.CopyDbfStructure( &CopyDbf, "CopyStructureV4NoMemos", "CopyAliasV4NoMemos", XB_OVERLAY, XB_MULTI_USER ), XB_NO_ERROR );
+  rc += TestMethod( po, "CopyDbf.Close()", CopyDbf.Close(), XB_NO_ERROR );
+
+  if( po == 2 ){
+    std::cout << "There should be one entry in the table list" << std::endl;
+    x.DisplayTableList();
+  }
+
+  rc += TestMethod( po, "GetDbfStatus()", CopyDbf.GetDbfStatus(), XB_CLOSED );
+  rc += TestMethod( po, "Open()", CopyDbf.xbDbf::Open( "CopyStructureV4NoMemos.DBF", "CopyAliasV4NoMemos" ), XB_NO_ERROR );
+
+  if( po == 2 ){
+    std::cout << "There should be two entries in the table list" << std::endl;
+    x.DisplayTableList();
+  }
+
+  rc += TestMethod( po, "Pack()", V4Dbf.Pack(), XB_NO_ERROR );
+  rc += TestMethod( po, "GetDbfStatus()", V4Dbf.GetDbfStatus(), XB_OPEN );
+
+  rc += TestMethod( po, "Zap()", V4Dbf.Zap(), XB_NO_ERROR );
+  if( po == 2 )
+    x.DisplayTableList();
+
+  xbUInt64 ullFileSize2 = 0;
+  rc2 = V4Dbf.GetFileSize( ullFileSize2 );
+  rc = TestMethod( po, "CheckTableSize", ullFileSize2, ullFileSize );
+
+// Test of auto commit code here
+  rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+  rc += TestMethod( po, "PutField()", V4Dbf.PutField( fldLastName, "NELSON" ), XB_NO_ERROR );
+  rc += TestMethod( po, "PutField()", V4Dbf.PutField( "FIRSTNAME", "WILLIE" ), XB_NO_ERROR );
+  rc += TestMethod( po, "PutField()", V4Dbf.PutField( "AMOUNT", "12.34" ), XB_NO_ERROR );
+  rc += TestMethod( po, "PutLongField()", V4Dbf.PutLongField( "ZIPCODE", 12345 ), XB_NO_ERROR );
+  rc += TestMethod( po, "PutLogicalField()", V4Dbf.PutLogicalField( "SWITCH", "Y" ), XB_NO_ERROR );
+  rc += TestMethod( po, "PutFloatField()", V4Dbf.PutFloatField( "TESTNUM", (xbFloat) 1234.5678 ), XB_NO_ERROR );
+  rc += TestMethod( po, "PutDoubleField()", V4Dbf.PutDoubleField( "DBLFLDTST", (xbDouble) 9876.5432 ), XB_NO_ERROR );
+  rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+
+  rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+  rc += TestMethod( po, "PutField()", V4Dbf.PutField( fldLastName, "JOHNSON" ), XB_NO_ERROR );
+  rc += TestMethod( po, "PutField()", V4Dbf.PutField( "FIRSTNAME", "JIMMY" ), XB_NO_ERROR );
+  rc += TestMethod( po, "PutField()", V4Dbf.PutField( "AMOUNT", "555.33" ), XB_NO_ERROR );
+  rc += TestMethod( po, "PutLongField()", V4Dbf.PutLongField( "ZIPCODE", 76523 ), XB_NO_ERROR );
+  rc += TestMethod( po, "PutLogicalField()", V4Dbf.PutLogicalField( "SWITCH", "N" ), XB_NO_ERROR );
+  rc += TestMethod( po, "PutFloatField()", V4Dbf.PutFloatField( "TESTNUM", (xbFloat) 8765.4321 ), XB_NO_ERROR );
+  rc += TestMethod( po, "PutDoubleField()", V4Dbf.PutDoubleField( "DBLFLDTST", (xbDouble) 9876.5432 ), XB_NO_ERROR );
+  rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+
+  rc += TestMethod( po, "PutField()", V4Dbf.PutField( "AMOUNT", "666.22" ), XB_NO_ERROR );
+  rc += TestMethod( po, "Abort()", V4Dbf.Abort(), XB_NO_ERROR );
+  rc += TestMethod( po, "GetField()", V4Dbf.GetField( "AMOUNT", sf ), XB_NO_ERROR );
+  rc += TestMethod( po, "GetField()", sf, "   555.33", 9 );
+
+  rc += TestMethod( po, "PutField()", V4Dbf.PutField( "AMOUNT", "666.22" ), XB_NO_ERROR );
+  rc += TestMethod( po, "Commit()", V4Dbf.Commit(), XB_NO_ERROR );
+  rc += TestMethod( po, "GetField()", V4Dbf.GetField( fldAMT, sf ), XB_NO_ERROR );
+  rc += TestMethod( po, "GetField()", sf, "   666.22", 9 );
+
+  rc += TestMethod( po, "GetPrevRecord()", V4Dbf.GetPrevRecord(), XB_NO_ERROR );
+  rc += TestMethod( po, "GetNextRecord()", V4Dbf.GetNextRecord(), XB_NO_ERROR );
+  rc += TestMethod( po, "GetField()", V4Dbf.GetField( fldAMT, sf ), XB_NO_ERROR );
+  rc += TestMethod( po, "GetField()", sf, "   666.22", 9 );
+
+  rc += TestMethod( po, "AutoCommit()", V4Dbf.SetAutoCommit( 0 ), XB_NO_ERROR );
+  rc += TestMethod( po, "PutField()", V4Dbf.PutField( "AMOUNT", "999.33" ), XB_NO_ERROR );
+  rc += TestMethod( po, "GetPrevRecord()", V4Dbf.GetPrevRecord(), XB_NO_ERROR );
+  rc += TestMethod( po, "GetNextRecord()", V4Dbf.GetNextRecord(), XB_NO_ERROR );
+  rc += TestMethod( po, "GetField()", V4Dbf.GetField( fldAMT, sf ), XB_NO_ERROR );
+  rc += TestMethod( po, "GetField()", sf, "   666.22", 9 );
+
+  rc += TestMethod( po, "AutoCommit()", V4Dbf.SetAutoCommit( -1 ), XB_NO_ERROR );
+  rc += TestMethod( po, "PutField()", V4Dbf.PutField( "AMOUNT", "999.33" ), XB_NO_ERROR );
+  rc += TestMethod( po, "GetCurRecNo()", (xbInt32) V4Dbf.GetCurRecNo(), 2 );
+  rc += TestMethod( po, "GetPrevRecord()", V4Dbf.GetPrevRecord(), XB_NO_ERROR );
+  rc += TestMethod( po, "GetNextRecord()", V4Dbf.GetNextRecord(), XB_NO_ERROR );
+  rc += TestMethod( po, "GetField()", V4Dbf.GetField( fldAMT, sf ), XB_NO_ERROR );
+  rc += TestMethod( po, "GetField()", sf, "   999.33", 9 );
+
+  rc += TestMethod( po, "AutoCommit()", V4Dbf.SetAutoCommit( 1 ), XB_NO_ERROR );
+  rc += TestMethod( po, "PutField()", V4Dbf.PutField( "AMOUNT", "432.55" ), XB_NO_ERROR );
+  rc += TestMethod( po, "GetCurRecNo()", (xbInt32) V4Dbf.GetCurRecNo(), 2 );
+  rc += TestMethod( po, "GetPrevRecord()", V4Dbf.GetPrevRecord(), XB_NO_ERROR );
+  rc += TestMethod( po, "GetNextRecord()", V4Dbf.GetNextRecord(), XB_NO_ERROR );
+  rc += TestMethod( po, "GetField()", V4Dbf.GetField( fldAMT, sf ), XB_NO_ERROR );
+  rc += TestMethod( po, "GetField()", sf, "   432.55", 9 );
+
+  rc += TestMethod( po, "Close()", V4Dbf.Close(), XB_NO_ERROR );
+  if( po == 2 )
+    x.DisplayTableList();
+
+  if( po > 0 || rc < 0 )
+    fprintf( stdout, "Total Errors = %d\n", rc * -1 );
+
+#ifdef XB_LOGGING_SUPPORT
+  sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], rc * -1 );
+  x.WriteLogMessage( sMsg );
+#endif
+
+  return rc;
+}
diff --git a/src/tests/xb_test_expnode.cpp b/src/tests/xb_test_expnode.cpp
new file mode 100755
index 0000000..3fb716d
--- /dev/null
+++ b/src/tests/xb_test_expnode.cpp
@@ -0,0 +1,123 @@
+/* xb_test_expnode.cpp
+
+XBase Software Library
+
+Copyright (c) 1997,2003,2014,2017,2022 Gary A Kunkel
+
+The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
+
+Email Contact:
+
+    XDB-devel@lists.sourceforge.net
+    XDB-users@lists.sourceforge.net
+
+*/
+
+// This program tests the xb expression node functions
+// usage:   xb_test_expnode QUITE|NORMAL|VERBOSE
+
+#include "xbase.h"
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+
+/**************************************************************************/
+
+int main( int argCnt, char **av )
+{
+  xbInt16 iRc  = 0;
+  xbInt16 po  = 1;     /* print option */
+                       /* 0 - QUIET    */
+                       /* 1 - NORMAL   */
+                       /* 2 - VERBOSE  */
+
+  if( argCnt > 1 ) {
+    if( av[1][0] == 'Q' )
+      po = 0;
+    else if( av[1][0] == 'V' )
+      po = 2;
+  }
+
+  xbXBase x;
+
+  #ifdef XB_LOGGING_SUPPORT
+  x.EnableMsgLogging();
+  if( po ){
+    std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+  }
+  xbString sMsg;
+  sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+  x.WriteLogMessage( sMsg );
+  #endif
+
+  x.SetDataDirectory( PROJECT_DATA_DIR );
+  x.EnableMsgLogging();
+  InitTime();
+
+  if( po > 0 ){
+    std::cout << "XBase Expression Node testing program.." << std::endl;
+    std::cout << "This program tests the XBase expression node logic." << std::endl;
+  }
+
+  xbString s1 = "TestNode1";
+  xbExpNode *n1  = new xbExpNode();
+  n1->SetNodeText( s1 );
+  n1->SetNodeType( XB_EXP_OPERATOR );
+  n1->SetReturnType( XB_EXP_LOGICAL );
+
+  iRc += TestMethod( po, "GetNodeType()", n1->GetNodeType(), 'O' );
+  iRc += TestMethod( po, "GetReturnType()", n1->GetReturnType(), 'L' );
+
+  xbString s2 = "TestNode2";
+  xbExpNode *n2  = new xbExpNode( s2, XB_EXP_FUNCTION, XB_EXP_CHAR );
+
+  xbString s3 = "TestNode3";
+  xbExpNode *n3  = new xbExpNode( s3, XB_EXP_CONSTANT, XB_EXP_NUMERIC );
+
+  xbString s4 = "TestNode4";
+  xbExpNode *n4  = new xbExpNode( s4, XB_EXP_OPERATOR, XB_EXP_DATE );
+
+  xbString s5 = "TestNode5";
+  xbExpNode *n5  = new xbExpNode( s5, XB_EXP_FIELD, XB_EXP_LOGICAL );
+
+  n1->AddChild( n2 );
+  n1->AddChild( n3 );
+  n1->AddChild( n4 );
+  n1->AddChild( n5 );
+
+  iRc += TestMethod( po, "GetChildCnt()", (xbInt32) n1->GetChildCnt(), 4 );
+
+  n1->SetResult( s1 );
+  iRc += TestMethod( po, "SetResult() / GetStringResult()", s1, n1->GetStringResult(), 9 );
+
+  xbBool bVal = xbTrue;
+  n1->SetResult( bVal );
+  iRc += TestMethod( po, "SetResult() / GetBoolResult()", xbTrue, n1->GetBoolResult() );
+
+  xbDouble d = 123456.789;
+  n1->SetResult( d );
+  iRc += TestMethod( po, "SetResult() / GetNumericResult()", d, n1->GetNumericResult() );
+
+  #ifdef XB_DEBUG_SUPPORT 
+  if( po > 0 ){
+    n1->DumpNode( xbTrue );
+    n1->GetChild( 0 )->DumpNode( xbTrue );
+    n1->GetChild( 1 )->DumpNode( xbTrue );
+    n1->GetChild( 2 )->DumpNode( xbTrue );
+    n1->GetChild( 3 )->DumpNode( xbTrue );
+  }
+  #endif
+
+  delete n1;
+
+  if( po > 0 || iRc < 0 )
+    fprintf( stdout, "Total Errors = %d\n", iRc * -1 );
+
+  #ifdef XB_LOGGING_SUPPORT
+  sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], iRc * -1 );
+  x.WriteLogMessage( sMsg );
+  #endif
+
+  return iRc;
+}
diff --git a/src/tests/xb_test_expression.cpp b/src/tests/xb_test_expression.cpp
new file mode 100755
index 0000000..e3b47cc
--- /dev/null
+++ b/src/tests/xb_test_expression.cpp
@@ -0,0 +1,791 @@
+/* xb_test_expression.cpp
+
+XBase Software Library
+
+Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+
+The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
+
+Email Contact:
+
+    XDB-devel@lists.sourceforge.net
+    XDB-users@lists.sourceforge.net
+
+*/
+
+// This program tests the class xbExp
+// usage:   xb_test_expression QUITE|NORMAL|VERBOSE
+
+#include "xbase.h"
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+
+/**************************************************************************/
+///@cond DOXYOFF
+
+class xbExpTest : public xbExp {
+
+ public:
+   xbExpTest( xbXBase * x );
+   xbInt16 GetNextTokenTest( xbExpToken &t );
+   xbInt16 OperatorWeightTest( const xbString &sOperator );
+   xbExpNode *GetNextNodeTest( xbExpNode * );
+};
+
+/**************************************************************************/
+xbExpTest::xbExpTest( xbXBase * x ) : xbExp( x ){
+}
+/**************************************************************************/
+xbExpNode *xbExpTest::GetNextNodeTest( xbExpNode *n ){
+  return GetNextNode( n );
+}
+/**************************************************************************/
+xbInt16 xbExpTest::GetNextTokenTest( xbExpToken &t ){
+  return GetNextToken( t );
+}
+/**************************************************************************/
+xbInt16 xbExpTest::OperatorWeightTest( const xbString &sOperator ){
+  return OperatorWeight( sOperator );
+}
+///@endcond DOXYOFF
+
+
+/**************************************************************************/
+xbInt16 DevTester( xbXBase * xb, xbDbf * dbf, const char * sExpIn ){
+
+  xbExpTest exp( xb );
+  xbExpNode *n;
+
+  std::cout << "going to parse expression [" << sExpIn << "]\n";
+  xbInt16 iRc = exp.ParseExpression( dbf, sExpIn );
+
+  std::cout << "back from parse expression\n";
+  std::cout << "dump nodes\n";
+  n = exp.GetNextNodeTest( NULL );
+  if( iRc == XB_NO_ERROR ){
+    exp.DumpTree( xbTrue );
+    std::cout << "dump nodes\n";
+    n = exp.GetNextNodeTest( NULL );
+    if( !n ){
+      std::cout << "n is null\n";
+    } else {
+      xbInt16 i = 0;
+      while( n && i < 30 ){
+        std::cout << "Node Text = [" << n->GetStringResult().Str() << "]\n";
+        n = exp.GetNextNodeTest( n );
+        i++;
+      }
+    }
+    std::cout << "end dump nodes\n";
+    return 0;
+  }else{
+    std::cout << "Parse Error [" << iRc << "]\n";
+    return -1;
+  }
+  return 0;
+}
+
+/**************************************************************************/
+xbInt16 TestWeight( xbXBase * xb, xbInt16 iPrintOption, const char * title, const char *sOperator, xbInt16 iExpectedWeight );
+xbInt16 TestWeight( xbXBase * xb, xbInt16 iPrintOption, const char * title, const char *sOperator, xbInt16 iExpectedWeight ){
+
+  xbInt16   iRc = 0;
+  xbExpTest expT1( xb );
+
+  if(( iRc = expT1.OperatorWeightTest( sOperator )) != iExpectedWeight ){
+    std::cout << std::endl << "[FAIL O1] " << title << std::endl;
+    std::cout << " Operator [" << sOperator << "] Weight [" << iRc << "] Expected [" << iExpectedWeight << "]" << std::endl;
+    return -1;
+  }
+
+  if( iPrintOption == 2 )
+    std::cout << "[PASS] " << title << " Expected matches actual Data=[" << sOperator << "][" << iExpectedWeight << "]" << std::endl;
+  else if( iPrintOption == 1 )
+    std::cout << "[PASS] " << title << std::endl;
+
+  return XB_NO_ERROR;
+}
+/**************************************************************************/
+xbInt16 TestTokenMethod( xbXBase *xb, xbInt16 iPrintOption, const char * title, const char *sExpression, 
+               const char *sExpectedToken, const char *sExpectedRemainder, char cExpectedNodeType, 
+               char cExpectedReturnType, xbInt16 iErc, xbInt16 iTrc );
+
+xbInt16 TestTokenMethod( xbXBase *xb, xbInt16 iPrintOption, const char * title, const char *sExpression, 
+                         const char *sExpectedToken, const char *sExpectedRemainder, char cExpectedNodeType, 
+                         char cExpectedReturnType, xbInt16 iErc, xbInt16 iTrc ){
+
+  xbExpTest expT1( xb );
+  xbExpToken t;
+  xbInt16  iRc = XB_NO_ERROR;
+  t.sExpression = sExpression;
+
+  if(( iRc = expT1.GetNextTokenTest( t )) != iErc ){
+    std::cout << std::endl << "[FAIL T1] " << title << std::endl;
+    std::cout << " Expression [" << sExpression << "]" << std::endl;
+    std::cout << " GetNextToken iRc = [" <<  iRc << "]" << std::endl;
+    return -1;
+  }
+
+  if( iTrc != t.iSts ){
+    std::cout << std::endl << "[FAIL T2] " << title << std::endl;
+    std::cout << " Expression [" << sExpression << "]" << std::endl;
+    std::cout << " GetNextToken Token Return Code = [" <<  iTrc << "]" << std::endl;
+    return -1;
+  }
+  if( iErc == XB_NO_ERROR && iTrc == XB_NO_ERROR && t.sToken != sExpectedToken ){
+    std::cout << std::endl << "[FAIL T3] " << title << std::endl;
+    std::cout << " Expression " << sExpression << std::endl;
+    std::cout << "  Expected Result = [" << sExpectedToken << "] Actual = [" << t.sToken.Str() << "]\n";
+    return -1;
+  }
+  if( iErc == XB_NO_ERROR && iTrc == XB_NO_ERROR && t.sExpression != sExpectedRemainder ){
+    std::cout << std::endl << "[FAIL T4] " << title << std::endl;
+    std::cout << " Expression " << sExpression << std::endl;
+    std::cout << "  Expected Remainder = [" << sExpectedRemainder << "] Actual = [" << t.sExpression.Str() << "]\n";
+    return -1;
+  }
+  if( iErc == XB_NO_ERROR && iTrc == XB_NO_ERROR&& t.cNodeType != cExpectedNodeType ){
+    std::cout << std::endl << "[FAIL T5] " << title << std::endl;
+    std::cout << " Expression " << sExpression << std::endl;
+    std::cout << "  Expected Node type = [" <<  cExpectedNodeType  << "] Actual = [" << t.cNodeType << "]\n";
+    return -1;
+  }
+  if( iErc == XB_NO_ERROR && iTrc == XB_NO_ERROR&& t.cReturnType != cExpectedReturnType ){
+    std::cout << std::endl << "[FAIL T6] " << title << std::endl;
+    std::cout << " Expression " << sExpression << std::endl;
+    std::cout << "  Expected Return type = [" << cExpectedReturnType << "] Actual = [" << t.cReturnType  << "]\n";
+    return -1;
+  }
+  if( iPrintOption == 2 ){
+    if( iErc == XB_NO_ERROR )
+      std::cout << "[PASS] " << title << " Expected matches actual Data=[" << sExpectedToken << "]" << std::endl;
+    else
+      std::cout << "[PASS] " << title << " Expected return code matches actual =[" << iErc << "]" << std::endl;
+  } else if( iPrintOption == 1 )
+    std::cout << "[PASS] " << title << std::endl;
+
+  return 0;
+}
+
+/**************************************************************************/
+xbInt16 TestMethod( xbXBase *xb, xbDbf *d, xbInt16 PrintOption, const char * title,
+                    const xbString &sExpression, const char * sExpectedResult, xbInt16 iExpectedResultLen );
+
+xbInt16 TestMethod( xbXBase *xb, xbDbf *d, xbInt16 PrintOption, const char * title,
+                    const xbString &sExpression, const char * sExpectedResult, xbInt16 iExpectedResultLen ){
+
+  xbInt16 iRc = XB_NO_ERROR;
+  xbString sResult;
+  xbExp exp( xb );
+
+  if(( iRc = exp.ParseExpression( d, sExpression )) != XB_NO_ERROR ){
+    std::cout << std::endl << "[FAIL 1] " << title << std::endl;
+    std::cout << "  Return Code  = [" << iRc << "]" << std::endl;
+    return -1;
+  }
+  if(( iRc = exp.GetReturnType()) != XB_EXP_CHAR ){
+    std::cout << std::endl << "[FAIL 2] " << title << std::endl;
+    std::cout << "  Result type not XB_EXP_CHAR  = [" << exp.GetReturnType() << "]" << std::endl;
+    return -1;
+  }
+  if(( iRc = exp.ProcessExpression()) != XB_NO_ERROR ){
+    std::cout << std::endl << "[FAIL 3] " << title << std::endl;
+    std::cout << "  Return Code  = [" << iRc << "]" << std::endl;
+    return -1;
+  }
+  if(( iRc = exp.GetStringResult( sResult )) != XB_NO_ERROR ){
+    std::cout << std::endl << "[FAIL 4] " << title << std::endl;
+    std::cout << "  Return Code  = [" << iRc << "]" << std::endl;
+    return -1;
+  }
+  if( sResult != sExpectedResult ){
+    std::cout << std::endl << "[FAIL 5] " << title << std::endl;
+    std::cout << "  Expected Result = [" << sExpectedResult << "] Actual Result =[" << sResult.Str() << "]" << std::endl;
+    exp.DumpTree( 1 );
+    return -1;
+  }
+  if( exp.GetResultLen() != iExpectedResultLen ){
+    std::cout << std::endl << "[FAIL 6] " << title << std::endl;
+    std::cout << "  Expected Result Len = [" << iExpectedResultLen << "] Actual Result =[" << exp.GetResultLen() << "]" << std::endl;
+    exp.DumpTree( 1 );
+    return -1;
+  }
+  if( PrintOption == 2 )
+    std::cout << "[PASS] " << title << " Expected [" << sExpectedResult << "] matches actual [" << exp.GetResultLen() << "]" << std::endl;
+  else if( PrintOption == 1 )
+    std::cout << "[PASS] " << title << std::endl;
+
+  return 0;
+}
+
+/**************************************************************************/
+xbInt16 TestMethod( xbXBase * xb, xbDbf * d, xbInt16 PrintOption, const char * title,
+                    const xbString &sExpression, xbDouble dExpectedResult );
+
+xbInt16 TestMethod( xbXBase * xb, xbDbf * d, xbInt16 PrintOption, const char * title,
+                    const xbString &sExpression, xbDouble dExpectedResult ){
+
+  xbDouble dResult;
+  xbInt16 iRc = XB_NO_ERROR;
+  xbExp exp( xb );
+
+  if(( iRc = exp.ParseExpression( d, sExpression )) != XB_NO_ERROR ){
+    std::cout << std::endl << "[FAIL 1] " << title << std::endl;
+    std::cout << "  Return Code  = [" << iRc << "]" << std::endl;
+    return -1;
+  }
+  if(( iRc = exp.GetReturnType()) != XB_EXP_NUMERIC ){
+    std::cout << std::endl << "[FAIL 2] " << title << std::endl;
+    std::cout << "  Result type not XB_EXP_NUMERIC  = [" << exp.GetReturnType() << "]" << std::endl;
+    return -1;
+  }
+  if(( iRc = exp.ProcessExpression()) != XB_NO_ERROR ){
+    std::cout << std::endl << "[FAIL 3] " << title << std::endl;
+    std::cout << "  Return Code  = [" << iRc << "]" << std::endl;
+    return -1;
+  }
+  if(( iRc = exp.GetNumericResult( dResult )) != XB_NO_ERROR ){
+    std::cout << std::endl << "[FAIL 4] " << title << std::endl;
+    std::cout << "  Return Code  = [" << iRc << "]" << std::endl;
+    return -1;
+  }
+  if( !dblEquals( dResult, dExpectedResult, .01 )){
+    std::cout << std::endl << "[FAIL 5] " << title << std::endl;
+    std::cout << "  Expected Result = [" << dExpectedResult << "] Actual Result =[" << dResult << "]" << std::endl;
+    // dump out the tree
+    exp.DumpTree( 1 );
+    return -1;
+  }
+  if( PrintOption == 2 )
+    std::cout << "[PASS] " << title << " Expected [" << dExpectedResult << "] matches actual [" << exp.GetResultLen() << "]" << std::endl;
+  else if( PrintOption == 1 )
+    std::cout << "[PASS] " << title << std::endl;
+  return 0;
+}
+/**************************************************************************/
+xbInt16 TestMethod( xbXBase * xb, xbDbf * d, xbInt16 PrintOption, const char * title,
+                    const xbString &sExpression, xbDate dtExpectedResult );
+xbInt16 TestMethod( xbXBase * xb, xbDbf * d, xbInt16 PrintOption, const char * title,
+                    const xbString &sExpression, xbDate dtExpectedResult ){
+
+  xbDate dtResult;
+  xbInt16 iRc = XB_NO_ERROR;
+  xbExp exp( xb );
+  if(( iRc = exp.ParseExpression( d, sExpression )) != XB_NO_ERROR ){
+    std::cout << std::endl << "[FAIL 1] " << title << std::endl;
+    std::cout << "  Return Code  = [" << iRc << "]" << std::endl;
+    return -1;
+  }
+  if(( iRc = exp.GetReturnType()) != XB_EXP_DATE ){
+    std::cout << std::endl << "[FAIL 2] " << title << std::endl;
+    std::cout << "  Result type not XB_EXP_DATE  = [" << exp.GetReturnType() << "]" << std::endl;
+    return -1;
+  }
+  if(( iRc = exp.ProcessExpression()) != XB_NO_ERROR ){
+    std::cout << std::endl << "[FAIL 3] " << title << std::endl;
+    std::cout << "  Return Code  = [" << iRc << "]" << std::endl;
+    return -1;
+  }
+  if(( iRc = exp.GetDateResult( dtResult )) != XB_NO_ERROR ){
+    std::cout << std::endl << "[FAIL 4] " << title << std::endl;
+    std::cout << "  Return Code  = [" << iRc << "]" << std::endl;
+    return -1;
+  }
+  if( dtResult != dtExpectedResult ){
+    std::cout << std::endl << "[FAIL 5] " << title << std::endl;
+    std::cout << "  Expected Result = [" << dtExpectedResult.Str() << "] Actual Result =[" << dtResult.Str() << "]" << std::endl;
+    // dump out the tree
+    exp.DumpTree( 1 );
+    return -1;
+  }
+  if( PrintOption == 2 )
+    std::cout << "[PASS] " << title << " Expected [" << dtExpectedResult.Str() << "] matches actual [" << exp.GetResultLen() << "]" << std::endl;
+  else if( PrintOption == 1 )
+    std::cout << "[PASS] " << title << std::endl;
+
+  return 0;
+}
+/**************************************************************************/
+xbInt16 TestMethod( xbXBase * xb, xbDbf * d, xbInt16 PrintOption, const char * title,
+                    const xbString &sExpression, xbBool bExpectedResult );
+xbInt16 TestMethod( xbXBase * xb, xbDbf * d, xbInt16 PrintOption, const char * title,
+                    const xbString &sExpression, xbBool bExpectedResult ){
+
+  xbInt16 iRc = XB_NO_ERROR;
+
+  xbBool bResult;
+  xbExp exp( xb );
+  if(( iRc = exp.ParseExpression( d, sExpression )) != XB_NO_ERROR ){
+    std::cout << std::endl << "[FAIL 1] " << title << std::endl;
+    std::cout << "  Return Code  = [" << iRc << "]" << std::endl;
+    return -1;
+  }
+  if(( iRc = exp.GetReturnType()) != XB_EXP_LOGICAL ){
+    std::cout << std::endl << "[FAIL 2] " << title << std::endl;
+    std::cout << "  Result type not XB_EXP_LOGICAL = [" << exp.GetReturnType() << "]" << std::endl;
+    return -1;
+  }
+  if(( iRc = exp.ProcessExpression()) != XB_NO_ERROR ){
+    std::cout << std::endl << "[FAIL 3] " << title << std::endl;
+    std::cout << "  Return Code  = [" << iRc << "]" << std::endl;
+    return -1;
+  }
+  if(( iRc = exp.GetBoolResult( bResult )) != XB_NO_ERROR ){
+    std::cout << std::endl << "[FAIL 4] " << title << std::endl;
+    std::cout << "  Return Code  = [" << iRc << "]" << std::endl;
+    return -1;
+  }
+  if( bResult != bExpectedResult ){
+    std::cout << std::endl << "[FAIL 5] " << title << std::endl;
+    std::cout << "  Expected Result = [" << bExpectedResult << "] Actual Result =[" << bResult << "]" << std::endl;
+    // dump out the tree
+    exp.DumpTree( 1 );
+    return -1;
+  }
+  if( PrintOption == 2 )
+    std::cout << "[PASS] " << title << " Expected [" << bExpectedResult << "] matches actual [" << bResult << "]"  << std::endl;
+  else if( PrintOption == 1 )
+    std::cout << "[PASS] " << title << std::endl;
+  return 0;
+}
+/**************************************************************************/
+int main( int argCnt, char **av )
+{
+  xbInt16 iRc  = 0;
+  xbInt16 rc2 = 0;
+  xbInt16 po  = 1;     /* print option */
+                       /* 0 - QUIET    */
+                       /* 1 - NORMAL   */
+                       /* 2 - VERBOSE  */
+
+  if( argCnt > 1 ) {
+    if( av[1][0] == 'Q' )
+      po = 0;
+    else if( av[1][0] == 'V' )
+      po = 2;
+  }
+
+  xbSchema MyRecord[] = 
+  {
+    { "CHAR1",      XB_CHAR_FLD,      5, 0 },
+    { "CHAR2",      XB_CHAR_FLD,      7, 0 },
+    { "DATE1",      XB_DATE_FLD,      8, 0 },
+    { "DATE2",      XB_DATE_FLD,      8, 0 },
+    { "NUM1",       XB_NUMERIC_FLD,   9, 2 },
+    { "",0,0,0 }
+  };
+
+  xbXBase x;
+  xbDbf * MyFile;
+  xbDate d;
+
+  #ifdef XB_LOGGING_SUPPORT
+  x.EnableMsgLogging();
+  if( po ){
+    std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+  }
+  xbString sMsg;
+  sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+  x.WriteLogMessage( sMsg );
+  #endif
+
+  x.SetDataDirectory( PROJECT_DATA_DIR );
+  x.EnableMsgLogging();
+  InitTime();
+
+  if( po > 0 ){
+    std::cout << "XBase Expression testing program.." << std::endl;
+    std::cout << "This program tests the XBase expression logic." << std::endl;
+    std::cout << "Default Data Directory is [" << x.GetDataDirectory().Str() << "]" << std::endl;
+  }
+
+// return 0;
+
+  #ifdef XB_DBF4_SUPPORT
+  MyFile = new xbDbf4( &x );                /* version 4 dbf file */
+  #else
+  MyFile = new xbDbf3( &x );                /* version 3 dbf file */
+  #endif
+
+
+
+// return 0;
+
+  rc2 = MyFile->CreateTable( "ExpTest.DBF", "ExpTest", MyRecord, XB_OVERLAY, XB_MULTI_USER );
+
+// return 0;
+
+  iRc += TestMethod( po, "CreateTable()", rc2, XB_NO_ERROR );
+  iRc += TestMethod( po, "PutField()",     MyFile->PutField( "CHAR1", "TEST" ),      XB_NO_ERROR );
+  iRc += TestMethod( po, "PutField()",     MyFile->PutField( "CHAR2", "TEST7B" ),    XB_NO_ERROR );
+  iRc += TestMethod( po, "PutField()",     MyFile->PutFloatField( "NUM1", 5 ),       XB_NO_ERROR );
+  iRc += TestMethod( po, "PutField()",     MyFile->PutField( "DATE1", "19890303" ),  XB_NO_ERROR );
+  iRc += TestMethod( po, "PutField()",     MyFile->PutField ( "DATE2", "20120708" ), XB_NO_ERROR );
+  iRc += TestMethod( po, "AppendRecord()", MyFile->AppendRecord(),                   XB_NO_ERROR );
+
+
+// return 0;
+
+
+  iRc += TestTokenMethod( &x, po, "EOX Test1", "", "", "", '?', XB_EXP_UNKNOWN, XB_NO_ERROR, XB_END_OF_EXPRESSION );
+  iRc += TestTokenMethod( &x, po, "EOX Test2 ", "  ", "", "", '?', XB_EXP_UNKNOWN, XB_NO_ERROR, XB_END_OF_EXPRESSION );
+  iRc += TestTokenMethod( &x, po, "Paren Test1 ", "(SOMETOKEN)+5-100", "SOMETOKEN", "+5-100", XB_EXP_NOTROOT, XB_EXP_UNKNOWN, XB_NO_ERROR , XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Paren Test2 ", "{ANOTHERTOKEN} + 55-100", "ANOTHERTOKEN", " + 55-100", XB_EXP_NOTROOT, XB_EXP_UNKNOWN, XB_NO_ERROR, XB_NO_ERROR  );
+  iRc += TestTokenMethod( &x, po, "Paren Test3 ", "{{NESTED}TOKEN} + 55-100", "{NESTED}TOKEN", " + 55-100", XB_EXP_NOTROOT, XB_EXP_UNKNOWN, XB_NO_ERROR, XB_NO_ERROR  );
+
+  // next line generates log message
+  iRc += TestTokenMethod( &x, po, "Paren Test4 ", "{{NESTED}TOKEN + 55-100", "{NESTED}TOKEN", " + 55-100", XB_EXP_NOTROOT, XB_EXP_UNKNOWN, XB_PARSE_ERROR, XB_UNBALANCED_PARENS );
+  iRc += TestTokenMethod( &x, po, "Paren Test5 ", " (SOMETOKEN )+5-100", "SOMETOKEN ", "+5-100", XB_EXP_NOTROOT, XB_EXP_UNKNOWN, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Quote Test1 ", "\"SOMETOKEN\"+5-100", "SOMETOKEN", "+5-100", XB_EXP_CONSTANT, XB_EXP_CHAR,  XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Quote Test2 ", "'SOMETOKEN2'", "SOMETOKEN2", "", XB_EXP_CONSTANT, XB_EXP_CHAR,  XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Quote Test3 ", " 'SOMETOKEN3 '", "SOMETOKEN3 ", "", XB_EXP_CONSTANT, XB_EXP_CHAR, XB_NO_ERROR, XB_NO_ERROR );
+
+
+
+  // next line generates log message
+
+  iRc += TestTokenMethod( &x, po, "Quote Test3 ", " 'SOMETOKEN4 ", "SOMETOKEN3 ", "", XB_EXP_CONSTANT, XB_EXP_CHAR, XB_PARSE_ERROR, XB_UNBALANCED_QUOTES );
+
+
+  iRc += TestTokenMethod( &x, po, "Logical Constant1 ", ".T.", "T", "", XB_EXP_CONSTANT, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Logical Constant2 ", ".F.", "F", "", XB_EXP_CONSTANT, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Logical Constant3 ", ".TRUE.", "T", "", XB_EXP_CONSTANT, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Logical Constant4 ", ".FALSE.", "F", "", XB_EXP_CONSTANT, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Logical Constant5 ", ".T. and x", "T", " and x", XB_EXP_CONSTANT, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Numeric Constant1 ", "123", "123", "", XB_EXP_CONSTANT, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+
+
+
+  iRc += TestTokenMethod( &x, po, "Numeric Constant2 ", "-123", "-123", "", XB_EXP_CONSTANT, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Numeric Constant3 ", " - 123", "-123", "", XB_EXP_CONSTANT, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Numeric Constant4 ", " - .456", "-.456", "", XB_EXP_CONSTANT, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Numeric Constant5 ", " -.002", "-.002", "", XB_EXP_CONSTANT, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Numeric Constant6 ", " - .002 + 1", "-.002", " + 1", XB_EXP_CONSTANT, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Operator 1", "-", "-", "", XB_EXP_OPERATOR, XB_EXP_UNKNOWN, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Operator 2", "+", "+", "", XB_EXP_OPERATOR, XB_EXP_UNKNOWN, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Operator 3", "*", "*", "", XB_EXP_OPERATOR, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Operator 4", "/", "/", "", XB_EXP_OPERATOR, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Operator 5", "^", "^", "", XB_EXP_OPERATOR, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Operator 6", "%", "%", "", XB_EXP_OPERATOR, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Operator 7", "=", "=", "", XB_EXP_OPERATOR, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Operator 8", "<", "<", "", XB_EXP_OPERATOR, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Operator 9", ">", ">", "", XB_EXP_OPERATOR, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Operator 10", "$", "$", "", XB_EXP_OPERATOR, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Operator 11", "**", "**", "", XB_EXP_OPERATOR, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Operator 12", "++", "++", "", XB_EXP_POST_OPERATOR, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Operator 13", "--", "--", "", XB_EXP_POST_OPERATOR, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Operator 14", "-- ", "--", " ", XB_EXP_POST_OPERATOR, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Operator 15", "--X", "--", "X", XB_EXP_PRE_OPERATOR, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Operator 16", "++X", "++", "X", XB_EXP_PRE_OPERATOR, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Operator 17", "+=", "+=", "", XB_EXP_OPERATOR, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Operator 18", "-=", "-=", "", XB_EXP_OPERATOR, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Operator 19", "*=", "*=", "", XB_EXP_OPERATOR, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Operator 20", "/=", "/=", "", XB_EXP_OPERATOR, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Operator 21", "<>", "<>", "", XB_EXP_OPERATOR, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Operator 22", "<=", "<=", "", XB_EXP_OPERATOR, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Operator 23", ">=", ">=", "", XB_EXP_OPERATOR, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Operator 24", ">= grapes", ">=", " grapes", XB_EXP_OPERATOR, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Operator 25", "< apples ", "<", " apples ", XB_EXP_OPERATOR, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Operator 26", ".NOT.", ".NOT.", "", XB_EXP_OPERATOR, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Operator 27", ".AND.", ".AND.", "", XB_EXP_OPERATOR, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Operator 28", ".OR.", ".OR.", "", XB_EXP_OPERATOR, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+
+  iRc += TestTokenMethod( &x, po, "Function 1", "STOD ( \"08252017\" )", "STOD ( \"08252017\" )", "", XB_EXP_FUNCTION, XB_EXP_DATE, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Function 2", "STR( 8 )", "STR( 8 )", "", XB_EXP_FUNCTION, XB_EXP_CHAR, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Function 3", "STR( (8-3)+3 )", "STR( (8-3)+3 )", "", XB_EXP_FUNCTION, XB_EXP_CHAR, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Function 4", "STR( (8-3)+3 ) + \"A\"", "STR( (8-3)+3 )", " + \"A\"", XB_EXP_FUNCTION, XB_EXP_CHAR, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Function 5", "ISALPHA( \"A\" )", "ISALPHA( \"A\" )", "", XB_EXP_FUNCTION, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Function 6", "EXP( 6 )", "EXP( 6 )", "", XB_EXP_FUNCTION, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Field 1", "NUM1", "NUM1", "", XB_EXP_FIELD, XB_EXP_UNKNOWN, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Field 2", "NUM1 + X", "NUM1", " + X", XB_EXP_FIELD, XB_EXP_UNKNOWN, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Field 3", "ExpTest->NUM1", "ExpTest->NUM1", "", XB_EXP_FIELD, XB_EXP_UNKNOWN, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Field 4", "ExpTest ->NUM1", "ExpTest ->NUM1", "", XB_EXP_FIELD, XB_EXP_UNKNOWN, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Field 5", "ExpTest ->  NUM1", "ExpTest ->  NUM1", "", XB_EXP_FIELD, XB_EXP_UNKNOWN, XB_NO_ERROR, XB_NO_ERROR );
+  iRc += TestTokenMethod( &x, po, "Field 6", "ExpTest ->  NUM1+1", "ExpTest ->  NUM1", "+1", XB_EXP_FIELD, XB_EXP_UNKNOWN, XB_NO_ERROR, XB_NO_ERROR );
+
+  iRc += TestWeight( &x, po, "Weight Test", "", 0 );
+  iRc += TestWeight( &x, po, "Weight Test", "toobig", 0 );
+  iRc += TestWeight( &x, po, ".OR. Weight Test",  ".OR.",  1 );
+  iRc += TestWeight( &x, po, ".AND. Weight Test", ".AND.", 2 );
+  iRc += TestWeight( &x, po, ".NOT. Weight Test", ".NOT.", 3 );
+  iRc += TestWeight( &x, po, ">  Weight Test", ">",  4 );
+  iRc += TestWeight( &x, po, ">= Weight Test", ">=", 4 );
+  iRc += TestWeight( &x, po, "<  Weight Test", "<",  4 );
+  iRc += TestWeight( &x, po, "<= Weight Test", "<=", 4 );
+  iRc += TestWeight( &x, po, "<> Weight Test", "<>", 4 );
+  iRc += TestWeight( &x, po, "#  Weight Test", "#",  4 );
+  iRc += TestWeight( &x, po, "$  Weight Test", "$",  4 );
+  iRc += TestWeight( &x, po, "=  Weight Test", "=",  4 );
+  iRc += TestWeight( &x, po, "-- Prefix decrement Weight Test", "--0",  9 );
+  iRc += TestWeight( &x, po, "++ Prefix increment Weight Test", "++0",  9 );
+  iRc += TestWeight( &x, po, "** Weight Test", "**", 8 );
+  iRc += TestWeight( &x, po, "^  Weight Test", "^",  8 );
+  iRc += TestWeight( &x, po, "*  Weight Test", "*",  7 );
+  iRc += TestWeight( &x, po, "*  Weight Test", "/",  7 );
+  iRc += TestWeight( &x, po, "*  Weight Test", "%",  7 );
+  iRc += TestWeight( &x, po, "*  Weight Test", "*=", 7 );
+  iRc += TestWeight( &x, po, "*  Weight Test", "/=", 7 );
+  iRc += TestWeight( &x, po, "+  Weight Test", "+",  6 );
+  iRc += TestWeight( &x, po, "-  Weight Test", "-",  6 );
+  iRc += TestWeight( &x, po, "+= Weight Test", "+=",  6 );
+  iRc += TestWeight( &x, po, "-= Weight Test", "-=",  6 );
+  iRc += TestWeight( &x, po, "-- Postfix decrement Weight Test", "--1",  5 );
+  iRc += TestWeight( &x, po, "++ Postfix increment Weight Test", "++1",  5 );
+
+  iRc += TestMethod( &x, MyFile, po, "CharTest1", "CHAR1", "TEST ", 5 );
+  iRc += TestMethod( &x, MyFile, po, "CharTest2", "ExpTest->CHAR1", "TEST ", 5 );
+  iRc += TestMethod( &x, MyFile, po, "CharTest3", "ExpTest->CHAR1+CHAR1", "TEST TEST ", 10 );
+  iRc += TestMethod( &x, MyFile, po, "CharTest4", "\"PRE_ \"+\" _POST\"", "PRE_  _POST", 11 );
+  iRc += TestMethod( &x, MyFile, po, "CharTest5", "\"PRE_ \"-\" _POST\"", "PRE_ _POST ", 11 );
+  iRc += TestMethod( &x, MyFile, po, "CharTest6", "\"PRE_\"+ExpTest->CHAR1+\"_POST\"", "PRE_TEST _POST", 14 );
+  iRc += TestMethod( &x, MyFile, po, "CharTest7", "STR(123)", "       123", 10 );
+  iRc += TestMethod( &x, MyFile, po, "CharTest8", "STR(123)+LTRIM(STR(456))", "       123456", 20 );
+  iRc += TestMethod( &x, MyFile, po, "CharTest9", "STR(8)+STR(7)", "         8         7", 20 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest1", "ALLTRIM( \"    ABCD   \" )", "ABCD", 11 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest2", "CDOW( STOD( \"20171014\" ))", "Saturday", 9 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest3", "CHR( 66 )", "B", 1 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest4", "CMONTH( STOD( \"20171114\" ) )", "November", 9 );
+
+  // next line causes MAC compiler to cough up a furball
+  //iRc += TestMethod( &x, MyFile, po, "FuncTest5", "DESCEND( \"ABCDE\" )", "¾½¼»º", 5 );
+
+  char sDescendResult[6];  // = "¾½¼»º";
+  sDescendResult[0] = (char) 0xBE;
+  sDescendResult[1] = (char) 0xBD;
+  sDescendResult[2] = (char) 0xBC;
+  sDescendResult[3] = (char) 0xBB;
+  sDescendResult[4] = (char) 0xBA;
+  sDescendResult[5] = (char) 0x00;
+  iRc += TestMethod( &x, MyFile, po, "FuncTest5", "DESCEND( \"ABCDE\" )", sDescendResult, 5 );
+
+  iRc += TestMethod( &x, MyFile, po, "FuncTest6", "DTOC( STOD( \"20171114\" ))", "11/14/17", 8 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest7", "DTOS( STOD( \"20171114\" ))", "20171114", 8 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest8", "LEFT( \"ABCDEFGH\", 5 )", "ABCDE", 5 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest9", "LOWER( \"ABCDEFGH\" )", "abcdefgh", 8 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest10", "LTRIM( \"   ABC\" )", "ABC", 6 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest11", "REPLICATE( \"ABC\", 3 )", "ABCABCABC", 9 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest12", "RIGHT( \"ABCDEFGH\", 5 )", "DEFGH", 5 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest13", "RTRIM( \"ABCD   \" )", "ABCD", 7 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest14", "SPACE( 5 )", "     ", 5 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest15", "STR( 8 )", "         8", 10 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest16", "STR( 3, 4 )", "   3", 4 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest17", "STR( 12.7, 5, 2 )", "12.70", 5 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest18", "STR( 43.17, 9, 4, \"0\" )", "0043.1700", 9 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest19", "STRZERO( 56.21, 9, 4  )", "0056.2100", 9 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest20", "SUBSTR( \"SOMESTRING\", 3, 5  )", "MESTR", 5 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest21", "TRIM( \"   abc123   \" )", "   abc123", 12 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest22", "UPPER( \"abc123RRR\" )", "ABC123RRR", 9 );
+
+  // numeric logic tests
+  iRc += TestMethod( &x, MyFile, po, "NumericTest1", "1 + 1", (xbDouble) 2 );
+  iRc += TestMethod( &x, MyFile, po, "NumericTest2", "6 - 1", (xbDouble) 5 );
+  iRc += TestMethod( &x, MyFile, po, "NumericTest3", "6 * 4", (xbDouble) 24 );
+  iRc += TestMethod( &x, MyFile, po, "NumericTest4", "8 / 2", (xbDouble) 4 );
+  iRc += TestMethod( &x, MyFile, po, "NumericTest5", "3 ^ 3", (xbDouble) 27 );
+  iRc += TestMethod( &x, MyFile, po, "NumericTest6", "4 ** 4", (xbDouble) 256 );
+  iRc += TestMethod( &x, MyFile, po, "NumericTest7", "NUM1", (xbDouble) 5 );
+  iRc += TestMethod( &x, MyFile, po, "NumericTest8", "NUM1 + 2.3", (xbDouble) 7.3 );
+  iRc += TestMethod( &x, MyFile, po, "NumericTest9", "++NUM1", (xbDouble) 6 );
+  iRc += TestMethod( &x, MyFile, po, "NumericTest10", "NUM1++", (xbDouble)  5 );
+  iRc += TestMethod( &x, MyFile, po, "NumericTest11", "--NUM1", (xbDouble) 4 );
+  iRc += TestMethod( &x, MyFile, po, "NumericTest12", "NUM1--", (xbDouble) 5 );
+  iRc += TestMethod( &x, MyFile, po, "NumericTest13", "3++", (xbDouble) 3 );
+  iRc += TestMethod( &x, MyFile, po, "NumericTest14", "++3", (xbDouble)  4 );
+  iRc += TestMethod( &x, MyFile, po, "NumericTest15", "4--", (xbDouble) 4 );
+  iRc += TestMethod( &x, MyFile, po, "NumericTest16", "--4", (xbDouble) 3 );
+  iRc += TestMethod( &x, MyFile, po, "NumericTest17", "3 += 12", (xbDouble) 15 );
+  iRc += TestMethod( &x, MyFile, po, "NumericTest18", "3 -= 12", (xbDouble) -9 );
+  iRc += TestMethod( &x, MyFile, po, "NumericTest19", "3 *= 12", (xbDouble) 36 );
+  iRc += TestMethod( &x, MyFile, po, "NumericTest20", "12 /= 3", (xbDouble) 4 );
+  iRc += TestMethod( &x, MyFile, po, "NumericTest21", "(12+3)*(15-13)", (xbDouble) 30 );
+
+  // numeric functions
+  iRc += TestMethod( &x, MyFile, po, "FuncTest23", "ABS( -22 )", (xbDouble) 22 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest24", "ABS( 23 )", (xbDouble) 23 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest25", "ASC( \"A\" )", (xbDouble) 65 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest26", "AT( \",\", \"Booth, Joseph\" )", (xbDouble) 6 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest27", "DAY( STOD( \"20171017\" ))", (xbDouble) 17 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest28", "DESCEND( 1991 )", (xbDouble) -1991 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest29", "DOW( STOD( \"20171017\" ) )", (xbDouble) 3 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest30", "DOW( STOD( \"20171021\" ) )", (xbDouble) 0 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest31", "EXP( 0 )", (xbDouble) 1 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest32", "INT( 123.45 )", (xbDouble) 123 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest33", "LEN( \"ABC123\" )", (xbDouble) 6 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest34", "LOG( 10 )", (xbDouble) 2.3 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest35", "MAX( 10, 20 )", (xbDouble)  20 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest36", "MIN( 10, 20 )", (xbDouble) 10 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest37", "MONTH( STOD( \"20171017\" ))", (xbDouble) 10 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest38", "RECCOUNT()", (xbDouble) 1 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest39", "RECNO()", (xbDouble) 1 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest40", "SQRT( 9 )", (xbDouble) 3 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest41", "VAL( \"89\" )", (xbDouble) 89 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest42", "VAL( \"22.13 and some text\" )", (xbDouble) 22.13 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest43", "YEAR( STOD( \"20171017\" ))", (xbDouble) 2017 );
+
+  // date logic tests
+  xbDate dtTest1( "19890303" );
+  xbDate dtTest2( "20120708" );
+  iRc += TestMethod( &x, MyFile, po, "DateTest1", "ExpTest->DATE1", dtTest1 );
+  iRc += TestMethod( &x, MyFile, po, "DateTest2", "DATE1", dtTest1 );
+  iRc += TestMethod( &x, MyFile, po, "DateTest3", "ExpTest->DATE2", dtTest2 );
+  iRc += TestMethod( &x, MyFile, po, "DateTest4", "DATE2", dtTest2 );
+  iRc += TestMethod( &x, MyFile, po, "DateTest5", "DATE2 - DATE1", (xbDouble) 8528 );
+
+  dtTest1.Set( "20120705" );
+  iRc += TestMethod( &x, MyFile, po, "DateTest6", "DATE2 - 3", dtTest1 );
+  iRc += TestMethod( &x, MyFile, po, "DateTest7", "DATE2 -= 3", dtTest1 );
+
+  dtTest1.Set( "20120718" );
+  iRc += TestMethod( &x, MyFile, po, "DateTest8", "DATE2 + 10", dtTest1 );
+  iRc += TestMethod( &x, MyFile, po, "DateTest9", "DATE2 += 10", dtTest1 );
+
+  dtTest1.Set( "20120709" );
+  iRc += TestMethod( &x, MyFile, po, "DateTest10", "++DATE2", dtTest1 );
+  dtTest1.Set( "20120707" );
+  iRc += TestMethod( &x, MyFile, po, "DateTest11", "--DATE2", dtTest1 );
+
+  dtTest1.Set( "20120708" );
+  iRc += TestMethod( &x, MyFile, po, "DateTest12", "DATE2++", dtTest1 );
+  iRc += TestMethod( &x, MyFile, po, "DateTest13", "DATE2--", dtTest1 );
+
+  iRc += TestMethod( &x, MyFile, po, "DateTest14", "{07/08/12}", dtTest1 );
+  iRc += TestMethod( &x, MyFile, po, "DateTest15", "{07/08/2012}", dtTest1 );
+
+  iRc += TestMethod( &x, MyFile, po, "DateTest16", "{07/11/12} -3", dtTest1 );
+  iRc += TestMethod( &x, MyFile, po, "DateTest17", "{07/06/2012} + 2", dtTest1 );
+
+  iRc += TestMethod( &x, MyFile, po, "FuncTest44", "CTOD( \"07\\08\\12\" )", dtTest1 );
+
+  xbDate dtToday;
+  iRc += TestMethod( &x, MyFile, po, "FuncTest45", "DATE()", dtToday );
+
+  dtTest2 = "28870625";
+  iRc += TestMethod( &x, MyFile, po, "FuncTest46", "DESCEND( DATE2 )", dtTest2 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest47", "STOD( \"20120708\" )", dtTest1 );
+
+  // boolean logic tests
+  iRc += TestMethod( &x, MyFile, po, "LogicTest1", "3=5", (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest2", "5=5", (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest3", "\"abc\"=\"def\"", (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest4", "\"abc\"=\"abc\"", (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest5", "CTOD( \"07\\08\\12\" ) = CTOD ( \"07\\08\\12\" )", (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest6", "CTOD( \"07\\09\\12\" ) = CTOD ( \"07\\08\\12\" )", (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest7",  "3<>5",  (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest8",  "5<>5",  (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest9",  "3!=5",  (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest10", "5!=5",  (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest11", "3 # 5", (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest12", "5#5",   (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest13", "\"3\"<>\"5\"",  (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest14", "\"5\"<>\"5\"",  (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest15", "\"3\"!=\"5\"",  (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest16", "\"5\"!=\"5\"",  (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest17", "\"3\" # \"5\"", (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest18", "\"5\"#\"5\"",   (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest19", "CTOD( \"07\\08\\12\" ) <> CTOD ( \"07\\08\\12\" )", (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest20", "CTOD( \"07\\09\\12\" ) <> CTOD ( \"07\\08\\12\" )", (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest21", "CTOD( \"07\\08\\12\" ) != CTOD ( \"07\\08\\12\" )", (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest22", "CTOD( \"07\\09\\12\" ) != CTOD ( \"07\\08\\12\" )", (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest23", "CTOD( \"07\\08\\12\" ) #  CTOD ( \"07\\08\\12\" )", (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest24", "CTOD( \"07\\09\\12\" ) #  CTOD ( \"07\\08\\12\" )", (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest25",  "3<5",  (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest26",  "5<5",  (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest27",  "5<4",  (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest28",  "\"a\"<\"b\"",  (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest29",  "\"a\"<\"a\"",  (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest30",  "\"c\"<\"b\"",  (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest31", "CTOD( \"07\\07\\12\" ) < CTOD ( \"07\\08\\12\" )", (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest32", "CTOD( \"07\\08\\12\" ) < CTOD ( \"07\\08\\12\" )", (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest33", "CTOD( \"07\\09\\12\" ) < CTOD ( \"07\\08\\12\" )", (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest34",  "3>5",  (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest35",  "5>5",  (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest36",  "5>4",  (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest37",  "\"a\">\"b\"",  (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest38",  "\"a\">\"a\"",  (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest39",  "\"c\">\"b\"",  (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest40", "CTOD( \"07\\07\\12\" ) > CTOD ( \"07\\08\\12\" )", (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest41", "CTOD( \"07\\08\\12\" ) > CTOD ( \"07\\08\\12\" )", (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest42", "CTOD( \"07\\09\\12\" ) > CTOD ( \"07\\08\\12\" )", (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest43",  "3<=5",  (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest44",  "5<=5",  (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest45",  "5<=4",  (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest46",  "\"a\"<=\"b\"",  (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest47",  "\"a\"<=\"a\"",  (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest48",  "\"c\"<=\"b\"",  (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest49", "CTOD( \"07\\07\\12\" ) <= CTOD ( \"07\\08\\12\" )", (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest50", "CTOD( \"07\\08\\12\" ) <= CTOD ( \"07\\08\\12\" )", (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest51", "CTOD( \"07\\09\\12\" ) <= CTOD ( \"07\\08\\12\" )", (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest52",  "3>=5",  (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest53",  "5>=5",  (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest54",  "5>=4",  (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest55",  "\"a\">=\"b\"",  (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest56",  "\"a\">=\"a\"",  (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest57",  "\"c\">=\"b\"",  (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest58", "CTOD( \"07\\07\\12\" ) >= CTOD ( \"07\\08\\12\" )", (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest59", "CTOD( \"07\\08\\12\" ) >= CTOD ( \"07\\08\\12\" )", (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest60", "CTOD( \"07\\09\\12\" ) >= CTOD ( \"07\\08\\12\" )", (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest61", "\"abc123\" $ \"abc\"", (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest62", "\"abc\" $ \"abc123\"", (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest63", "\"abc\" $ \"zzabc123\"", (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest64", ".T.", (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest65", ".F.", (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest66", ".TRUE.", (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest67", ".FALSE.", (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest68", ".NOT. .F.", (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest69", " NOT  .F.", (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest70", ".NOT. .T.", (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest71", " NOT  .T.", (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest72", ".T. .AND. .T.", (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest73", ".T.  AND  .T.", (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest74", ".T. .AND. .NOT. .T.", (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest75", ".T.  AND   NOT  .T.", (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest76", ".NOT. .T. .AND. .T.", (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest77", " NOT  .T.  AND  .T.", (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest78", ".NOT. .T. .AND. .NOT. .T.", (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest79", " NOT  .T.  AND   NOT .T.", (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest80", ".T. .OR. .T.", (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest81", ".T.  OR  .T.", (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest82", ".T. .OR. .NOT. .T.", (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest83", ".T.  OR   NOT  .T.", (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest84", ".NOT. .T. .OR. .T.", (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest85", " NOT  .T.  OR  .T.", (xbBool) xbTrue );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest86", ".NOT. .T. .OR. .NOT. .T.", (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "LogicTest87", " NOT  .T.  OR   NOT  .T.", (xbBool) xbFalse );
+
+  iRc += TestMethod( &x, MyFile, po, "FuncTest48", "ISALPHA( \"12345\" )",  (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest49", "ISALPHA( \"ABCDEF\" )", (xbBool) xbTrue  );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest50", "ISALPHA( \"A1234\" )",  (xbBool) xbTrue  );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest51", "ISLOWER( \"12345\" )",   (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest52", "ISLOWER( \"ABCDEF\" )",  (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest53", "ISLOWER( \"abc123\" )",  (xbBool) xbTrue  );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest54", "ISLOWER( \"xyz\" )",     (xbBool) xbTrue  );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest55", "ISUPPER( \"12345\" )",   (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest56", "ISUPPER( \"ABCDEF\" )",  (xbBool) xbTrue  );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest57", "ISUPPER( \"abc123\" )",  (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest58", "ISUPPER( \"xyz\" )",     (xbBool) xbFalse );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest59", "ISUPPER( \"Xyz\" )",     (xbBool) xbTrue  );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest60", "IIF( .T., \"TRUE \", \"FALSE\" )", "TRUE ", 5 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest61", "IIF( .F., \"TRUE \", \"FALSE\" )", "FALSE", 5 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest62", "DEL()", " ", 1 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest63", "DELETED()", (xbBool) xbFalse );
+  iRc += TestMethod( po, "DeleteRecord()", MyFile->DeleteRecord(),           XB_NO_ERROR );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest64", "DEL()", "*", 1 );
+  iRc += TestMethod( &x, MyFile, po, "FuncTest65", "DELETED()", (xbBool) xbTrue );
+  iRc += TestMethod( po, "UndeleteRecord()", MyFile->UndeleteRecord(),       XB_NO_ERROR );
+
+
+  iRc += TestMethod( po, "Close()", MyFile->Close(), XB_NO_ERROR );
+  delete MyFile;
+
+  if( po > 0 || iRc < 0 )
+    fprintf( stdout, "Total Errors = %d\n", iRc * -1 );
+
+  #ifdef XB_LOGGING_SUPPORT
+  sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], iRc * -1 );
+  x.WriteLogMessage( sMsg );
+  #endif
+
+  return iRc;
+}
diff --git a/src/tests/xb_test_file.cpp b/src/tests/xb_test_file.cpp
new file mode 100755
index 0000000..ca32693
--- /dev/null
+++ b/src/tests/xb_test_file.cpp
@@ -0,0 +1,212 @@
+/* xb_test_file.cpp
+
+Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+
+The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
+
+Email Contact:
+
+    XDB-devel@lists.sourceforge.net
+    XDB-users@lists.sourceforge.net
+
+*/
+
+// This program tests the file functions
+
+// usage:   xb_test_file QUITE|NORMAL|VERBOSE
+
+
+#include "xbase.h"
+
+
+using namespace xb;
+
+
+#include "tstfuncs.cpp"
+
+
+int main( int argCnt, char **av )
+{
+  int rc = 0;
+  int po = 1;          /* print option */
+                       /* 0 - QUIET    */
+                       /* 1 - NORMAL   */
+                       /* 2 - VERBOSE  */
+
+  if( argCnt > 1 ) {
+    if( av[1][0] == 'Q' )
+      po = 0;
+    else if( av[1][0] == 'V' )
+      po = 2;
+  }
+
+#ifdef XB_LOGGING_SUPPORT
+  xbXBase x;
+  x.EnableMsgLogging();
+  if( po ){
+    std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+  }
+  xbString sMsg;
+  sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+  x.WriteLogMessage( sMsg );
+#endif
+
+  InitTime();
+  xbFile  f( &x );
+  xbString sWrkStr;
+  xbString sWrkStr2;
+  sWrkStr = PROJECT_DATA_DIR;
+  f.SetDataDirectory( PROJECT_DATA_DIR );
+    
+  #ifdef WIN32
+    sWrkStr.SwapChars( '/', '\\' );
+  #else
+    sWrkStr.SwapChars( '\\', '/' );
+  #endif
+    
+  rc += TestMethod( po, "Set/GetDataDirectory()", f.GetDataDirectory(), sWrkStr, sWrkStr.Len());
+
+  f.SetFileName( "TestFile.txt" );
+  sWrkStr = "TestFile.txt";
+  rc += TestMethod( po, "Set/GetFileName()", f.GetFileName(), sWrkStr, sWrkStr.Len());
+
+  f.GetFileType( sWrkStr );
+  rc += TestMethod( po, "GetFileType()", sWrkStr, "TXT", 3 );
+
+  #ifdef WIN32
+  sWrkStr = "\\my\\directory\\";
+  #else
+  sWrkStr = "/my/directory/";
+  #endif
+
+  f.SetDirectory( sWrkStr );
+  rc += TestMethod( po, "Set/GetDirectory()", f.GetDirectory(), sWrkStr, sWrkStr.Len());
+
+  sWrkStr += "TestFile.txt";
+  rc += TestMethod( po, "GetFqFileName()", f.GetFqFileName(), sWrkStr, 26 );
+
+#ifdef WIN32
+  sWrkStr  = "\\some\\directory\\myfile.dat";
+  sWrkStr2 = "\\some\\directory\\";
+#else
+  sWrkStr  = "/some/directory/myfile.dat";
+  sWrkStr2 = "/some/directory/";
+#endif
+
+
+  f.SetFqFileName( sWrkStr );
+  rc += TestMethod( po, "GetDirectory()", f.GetDirectory(), sWrkStr2, 16 );
+  rc += TestMethod( po, "GetFileName()", f.GetFileName(), "myfile.dat", 10 );
+
+  rc += TestMethod( po, "NameSuffixMissing()", f.NameSuffixMissing( "myfile.dbf", 1 ), 0 );
+  rc += TestMethod( po, "NameSuffixMissing()", f.NameSuffixMissing( "myfile", 1 ), 1 );
+  rc += TestMethod( po, "NameSuffixMissing()", f.NameSuffixMissing( "MYFILE", 1 ), 2 );
+
+  f.SetDirectory( PROJECT_DATA_DIR );
+  f.SetFileName( "xbfile.txt" );
+
+  rc += TestMethod( po, "xbFopen()", f.xbFopen( "w+b", XB_MULTI_USER ), XB_NO_ERROR );
+
+
+  xbString sTest;
+  sTest = "Test Data";
+  rc += TestMethod( po, "xbWrite()", f.xbFwrite( sTest.Str(), 9, 1 ), XB_NO_ERROR );
+  rc += TestMethod( po, "xbFclose()", f.xbFclose(), XB_NO_ERROR );
+
+  rc += TestMethod( po, "xbFopen()", f.xbFopen( "r+b", XB_MULTI_USER ), XB_NO_ERROR );
+  rc += TestMethod( po, "xbFseek()", f.xbFseek( 0, SEEK_SET ), XB_NO_ERROR );
+  char buf[10];
+  for( int i = 0; i < 10; i++ )
+    buf[i] = 0x00;
+  rc += TestMethod( po, "xbFread()", f.xbFread( buf, 5, 1 ), XB_NO_ERROR );
+  rc += TestMethod( po, "xbFread()", buf, "Test ", 5 );
+
+  rc += TestMethod( po, "xbFclose()", f.xbFclose(), XB_NO_ERROR );
+  rc += TestMethod( po, "xbRemove()", f.xbRemove(), XB_NO_ERROR );
+  xbInt16 iWork = 100;
+  char cBuf[9];
+  char *p = cBuf;
+  f.ePutInt16( cBuf, iWork );
+  rc += TestMethod( po, "Put/GetShort()", f.eGetInt16( p ), 100 );
+
+  xbInt32 lWork = 10101;
+  f.ePutInt32( p, lWork );
+  rc += TestMethod( po, "Put/GetLong()", f.eGetInt32( p ), 10101 );
+
+  lWork = 2147483647;
+  f.ePutInt32( p, lWork );
+  rc += TestMethod( po, "Put/GetLong()", f.eGetInt32( p ), 2147483647 );
+  rc += TestMethod( po, "Put/GetLong()", (xbInt32) f.eGetUInt32( p ), 2147483647 );
+
+  xbDouble d = 123456.789;
+  f.ePutDouble( p, d );
+  rc += TestMethod( po, "Put/GetDouble()", f.eGetDouble( p ), 123456.789 );
+
+  xbString sFqnS;
+  xbString sFqnT;
+  xbFile f2( &x );
+  rc += TestMethod( po, "CreateUniqueFileName()", f2.CreateUniqueFileName( PROJECT_DATA_DIR, "dbf", sFqnS ), XB_NO_ERROR );
+
+  rc += TestMethod( po, "FileExists()", f2.FileExists( sFqnS ), xbFalse );
+  rc += TestMethod( po, "xbFopen()",  f2.xbFopen( "w+b", sFqnS, XB_SINGLE_USER ), XB_NO_ERROR );
+  rc += TestMethod( po, "xbFclose()", f2.xbFclose(), XB_NO_ERROR );
+  rc += TestMethod( po, "FileExists()", f2.FileExists( sFqnS ), xbTrue );
+
+  rc += TestMethod( po, "CreateUniqueFileName()", f2.CreateUniqueFileName( PROJECT_DATA_DIR, "dbf", sFqnT ), XB_NO_ERROR );
+  rc += TestMethod( po, "xbRename()", f2.xbRename( sFqnS, sFqnT ), XB_NO_ERROR );
+  rc += TestMethod( po, "xbRemove()", f.xbRemove( sFqnT ), XB_NO_ERROR );
+
+  xbString sFn;
+  rc += TestMethod( po, "GetFileNamePart()", f2.GetFileNamePart( sFqnS , sFn ), XB_NO_ERROR );
+  rc += TestMethod( po, "GetFileExtPart()",  f2.GetFileExtPart( sFqnS , sFn ), XB_NO_ERROR );
+  rc += TestMethod( po, "GetFileExtPart()",  f2.GetFileDirPart( sFqnS , sFn ), XB_NO_ERROR );
+
+
+  rc += TestMethod( po, "SetBlockSize()",    f.SetBlockSize( 100 ), XB_INVALID_BLOCK_SIZE );
+  rc += TestMethod( po, "SetBlockSize()",    f.SetBlockSize( 512 ), XB_NO_ERROR );
+  rc += TestMethod( po, "GetBlockSize()",    (xbInt32) f.GetBlockSize(), 512 );
+
+
+  char BlockBuf[513];
+  memset( BlockBuf, 0x00, 513 );
+  rc += TestMethod( po, "xbFopen()", f.xbFopen( "w+b", XB_SINGLE_USER ), XB_NO_ERROR );
+
+  for( int i = 0; i < 512; i++ )
+    BlockBuf[i] = 'A';
+  rc += TestMethod( po, "WriteBlock()", f.WriteBlock( 0L, 512, BlockBuf ), XB_NO_ERROR );
+
+  for( int i = 0; i < 512; i++ )
+    BlockBuf[i] = 'B';
+  rc += TestMethod( po, "WriteBlock()", f.WriteBlock( 1L, 512, BlockBuf ), XB_NO_ERROR );
+
+  for( int i = 0; i < 512; i++ )
+    BlockBuf[i] = 'C';
+  rc += TestMethod( po, "WriteBlock()", f.WriteBlock( 2L, 512, BlockBuf ), XB_NO_ERROR );
+
+  char BlockBuf2[513];
+  memset( BlockBuf2, 0x00, 513 );
+  rc += TestMethod( po, "ReadBlock()", f.ReadBlock( 2L, 512, BlockBuf2 ), XB_NO_ERROR );
+
+  xbString s1 = BlockBuf;
+  xbString s2 = BlockBuf2;
+
+  rc += TestMethod( po, "ReadBlock()", s1, s2, 512 );
+
+  rc += TestMethod( po, "xbTruncate()", f.xbTruncate( 1000 ), XB_NO_ERROR );
+
+  xbUInt64 ullFsize;
+  rc += TestMethod( po, "GetFileSize()", f.GetFileSize( ullFsize ), XB_NO_ERROR );
+  rc += TestMethod( po, "xbGetFileSize()", (xbInt32) ullFsize, 1000 );
+  rc += TestMethod( po, "xbFclose()", f.xbFclose(), XB_NO_ERROR );
+
+  if( po > 0 || rc < 0 )
+    fprintf( stdout, "Total Errors = %d\n", rc * -1 );
+
+#ifdef XB_LOGGING_SUPPORT
+  sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], rc * -1 );
+  x.WriteLogMessage( sMsg );
+#endif
+
+  return rc;
+}
+
diff --git a/src/tests/xb_test_filter.cpp b/src/tests/xb_test_filter.cpp
new file mode 100755
index 0000000..2aeade3
--- /dev/null
+++ b/src/tests/xb_test_filter.cpp
@@ -0,0 +1,185 @@
+/* xb_test_filter.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2020,2022 Gary A Kunkel
+
+The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
+
+Email Contact:
+
+    XDB-devel@lists.sourceforge.net
+    XDB-users@lists.sourceforge.net
+
+*/
+
+// This program tests the class xbIxFilter
+
+// usage:   xb_test_filter QUITE|NORMAL|VERBOSE
+
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+
+int main( int argCnt, char **av )
+{
+  int iRc = 0;
+  int iRc2 = 0;
+  int iPo = 1;          /* print option */
+                       /* 0 - QUIET    */
+                       /* 1 - NORMAL   */
+                       /* 2 - VERBOSE  */
+
+  if( argCnt > 1 ) {
+    if( av[1][0] == 'Q' )
+      iPo = 0;
+    else if( av[1][0] == 'V' )
+      iPo = 2;
+  }
+
+
+  xbSchema MyV4Record[] = 
+  {
+    { "CFLD",       XB_CHAR_FLD,      6, 0 },
+    { "NFLD",       XB_NUMERIC_FLD,   6, 0 },
+    { "ZFLD",       XB_CHAR_FLD,      1, 0 },
+    { "",0,0,0 }
+  };
+
+
+  xbXBase x;
+#ifdef XB_LOGGING_SUPPORT
+  x.EnableMsgLogging();
+  if( iPo ){
+    std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+  }
+  xbString sMsg;
+  sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+  x.WriteLogMessage( sMsg );
+  x.SetLogSize( 1000000 );
+#endif
+
+  x.SetDataDirectory( PROJECT_DATA_DIR );
+  x.EnableMsgLogging();
+
+  char c;
+  xbString s;
+  xbInt32 lRecCnt = 0;
+  iRc = 0;
+
+  if( iPo > 0 )
+    std::cout << "Default Data Directory is [" << x.GetDataDirectory().Str() << "]" << std::endl;
+
+  xbDbf *V4Dbf = new xbDbf4( &x );
+
+  iRc2 = V4Dbf->CreateTable( "TestFilt.DBF", "TestFilter", MyV4Record, XB_OVERLAY, XB_MULTI_USER );
+  iRc += TestMethod( iPo, "CreateTable()", (xbInt32) iRc2, XB_NO_ERROR );
+
+
+  #ifdef XB_NDX_SUPPORT
+  xbIx *ixPtr;
+  void *ndx;
+  iRc2 = V4Dbf->CreateTag( "NDX", "TestFilt.NDX", "CFLD", "", 0, 0, XB_OVERLAY, &ixPtr, &ndx );
+  iRc += TestMethod( iPo, "CreateTag()", (xbInt32) iRc2, XB_NO_ERROR );
+  if( iRc2 )
+    x.DisplayError( iRc2 );
+  #endif   // XB_NDX_SUPPORT
+
+
+  if( iRc2 )
+    x.DisplayError( iRc2 );
+
+  for( xbUInt16 i = 0; i < 5 && iRc == XB_NO_ERROR; i++ ){
+    // for( xbUInt16 j = 0; j < 26 && iRc == XB_NO_ERROR; j++ ){ 
+    for( xbInt16 j = 25; j >= 0 && iRc == XB_NO_ERROR; j-- ){ 
+      c = j + 65;
+      s = c;
+      s.PadRight( c, (xbUInt32) i + 1 );
+      V4Dbf->BlankRecord();
+      V4Dbf->PutField( "CFLD", s );
+      V4Dbf->PutLongField( "NFLD", ++lRecCnt );
+      iRc = V4Dbf->AppendRecord();
+    }
+  }
+
+  iRc += TestMethod( iPo, "SetCurTag()", V4Dbf->SetCurTag( "" ), XB_NO_ERROR );
+  xbFilter f1( &x, V4Dbf );
+  xbString sMyFilterExpression = "LEFT( CFLD, 2 ) = 'YY'";
+  iRc += TestMethod( iPo, "Set()", f1.Set( sMyFilterExpression ), XB_NO_ERROR );
+
+  iRc += TestMethod( iPo, "SetCurTag()", V4Dbf->SetCurTag( "" ), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "Set()", f1.Set( sMyFilterExpression ), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "GetFirstRecord()", f1.GetFirstRecord(), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4Dbf->GetCurRecNo(), 28 );
+  iRc += TestMethod( iPo, "GetNextRecord()", f1.GetNextRecord(), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4Dbf->GetCurRecNo(), 54 );
+  iRc += TestMethod( iPo, "GetNextRecord()", f1.GetNextRecord(), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4Dbf->GetCurRecNo(), 80 );
+  iRc += TestMethod( iPo, "GetLast()", f1.GetLastRecord(), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4Dbf->GetCurRecNo(), 106 );
+  iRc += TestMethod( iPo, "GetPrev()", f1.GetPrevRecord(), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4Dbf->GetCurRecNo(), 80 );
+
+  sMyFilterExpression = "LEFT( CFLD, 2 ) = 'CC'";
+  iRc += TestMethod( iPo, "Set()", f1.Set( sMyFilterExpression ), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "GetFirstRecord()", f1.GetFirstRecord(), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4Dbf->GetCurRecNo(), 50 );
+  iRc += TestMethod( iPo, "GetNextRecord()", f1.GetNextRecord(), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4Dbf->GetCurRecNo(), 76 );
+  iRc += TestMethod( iPo, "GetNextRecord()", f1.GetNextRecord(), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4Dbf->GetCurRecNo(), 102 );
+  iRc += TestMethod( iPo, "GetLast()", f1.GetLastRecord(), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4Dbf->GetCurRecNo(), 128 );
+  iRc += TestMethod( iPo, "GetPrev()", f1.GetPrevRecord(), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4Dbf->GetCurRecNo(), 102 );
+
+
+  #ifdef XB_NDX_SUPPORT
+  f1.SetLimit( 0 );
+
+  // change things up a bit
+  iRc += TestMethod( iPo, "GetRecord()", V4Dbf->GetRecord( 32 ), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "PutField()",  V4Dbf->PutField( "ZFLD", "Z" ), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "GetRecord()", V4Dbf->GetRecord( 52 ), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "PutField()",  V4Dbf->PutField( "ZFLD", "Z" ), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "GetRecord()", V4Dbf->GetRecord( 76 ), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "PutField()",  V4Dbf->PutField( "ZFLD", "Z" ), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "GetRecord()", V4Dbf->GetRecord( 103 ), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "PutField()",  V4Dbf->PutField( "ZFLD", "Z" ), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "Commit()",  V4Dbf->Commit(), XB_NO_ERROR );
+
+  iRc += TestMethod( iPo, "SetCurTag()", V4Dbf->SetCurTag( "TestFilt" ), XB_NO_ERROR );
+  sMyFilterExpression = "ZFLD = 'Z'";
+  iRc += TestMethod( iPo, "Set()", f1.Set( sMyFilterExpression ), XB_NO_ERROR );
+
+  iRc += TestMethod( iPo, "GetFirstRecord()", f1.GetFirstRecord(), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4Dbf->GetCurRecNo(), 52 );
+  iRc += TestMethod( iPo, "GetNextRecord()", f1.GetNextRecord(), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4Dbf->GetCurRecNo(), 103 );
+  iRc += TestMethod( iPo, "GetNextRecord()", f1.GetNextRecord(), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4Dbf->GetCurRecNo(), 76 );
+  iRc += TestMethod( iPo, "GetLast()", f1.GetLastRecord(), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4Dbf->GetCurRecNo(), 32 );
+  iRc += TestMethod( iPo, "GetPrev()", f1.GetPrevRecord(), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4Dbf->GetCurRecNo(), 76 );
+
+  #endif  // XB_NDX_SUPPORT
+
+
+  iRc += TestMethod( iPo, "Close()", V4Dbf->Close(), XB_NO_ERROR );
+  delete V4Dbf;
+
+  if( iPo > 0 || iRc < 0 )
+    fprintf( stdout, "Total Errors = %d\n", iRc * -1 );
+
+#ifdef XB_LOGGING_SUPPORT
+  sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], iRc * -1 );
+  x.WriteLogMessage( sMsg, 2 );
+#endif
+
+  return iRc;
+}
diff --git a/src/tests/xb_test_funcs.cpp b/src/tests/xb_test_funcs.cpp
new file mode 100755
index 0000000..07e2c17
--- /dev/null
+++ b/src/tests/xb_test_funcs.cpp
@@ -0,0 +1,288 @@
+/* xb_test_funcs.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+
+The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
+
+Email Contact:
+
+    XDB-devel@lists.sourceforge.net
+    XDB-users@lists.sourceforge.net
+
+*/
+
+// This program tests the xb functions
+// usage:   xb_test_funcs QUITE|NORMAL|VERBOSE
+
+#include "xbase.h"
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+
+/**************************************************************************/
+
+int main( int argCnt, char **av )
+{
+  xbInt16 iRc  = 0;
+  xbInt16 rc2 = 0;
+  xbInt16 po  = 1;     /* print option */
+                       /* 0 - QUIET    */
+                       /* 1 - NORMAL   */
+                       /* 2 - VERBOSE  */
+
+  if( argCnt > 1 ) {
+    if( av[1][0] == 'Q' )
+      po = 0;
+    else if( av[1][0] == 'V' )
+      po = 2;
+  }
+
+  xbSchema MyRecord[] = 
+  {
+    { "NUM1",       XB_NUMERIC_FLD,   9, 2 },
+    { "DATE1",      XB_DATE_FLD,      8, 0 },
+    { "DATE2",      XB_DATE_FLD,      8, 0 },
+    { "",0,0,0 }
+  };
+
+
+  xbXBase x;
+  xbDbf * MyFile;
+  xbDate d;
+
+  xbString sResult;
+  xbDate   dtResult;
+  xbDouble dResult;
+  xbBool   bResult;
+  xbDate   dtIn( "19890209" );
+
+
+  #ifdef XB_LOGGING_SUPPORT
+  x.EnableMsgLogging();
+  if( po ){
+    std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+  }
+  xbString sMsg;
+  sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+  x.WriteLogMessage( sMsg );
+  #endif
+
+  x.SetDataDirectory( PROJECT_DATA_DIR );
+  x.EnableMsgLogging();
+  InitTime();
+
+  if( po > 0 ){
+    std::cout << "XBase Expression testing program.." << std::endl;
+    std::cout << "This program tests the XBase expression logic." << std::endl;
+    std::cout << "Default Data Directory is [" << x.GetDataDirectory().Str() << "]" << std::endl;
+  }
+
+  #ifdef XB_DBF4_SUPPORT
+  MyFile = new xbDbf4( &x );                /* version 4 dbf file */
+  #else
+  MyFile = new xbDbf3( &x );                /* version 3 dbf file */
+  #endif
+
+  rc2 = MyFile->CreateTable( "Functest.DBF", "ExpTest", MyRecord, XB_OVERLAY, XB_MULTI_USER );
+  iRc += TestMethod( po, "CreateTable()", rc2, XB_NO_ERROR );
+  iRc += TestMethod( po, "PutField()",     MyFile->PutFloatField( "NUM1", 5 ),       XB_NO_ERROR );
+  iRc += TestMethod( po, "PutField()",     MyFile->PutField( "DATE1", "19890303" ),  XB_NO_ERROR );
+  iRc += TestMethod( po, "PutField()",     MyFile->PutField ( "DATE2", "20120708" ), XB_NO_ERROR );
+
+  MyFile->SetAutoLock( xbFalse );
+  iRc += TestMethod( po, "AppendRecord()", MyFile->AppendRecord(),                   XB_NO_ERROR );
+
+  iRc += TestMethod( po, "ABS( -222, dResult )", x.ABS( -222, dResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "ABS( -222, dResult )", -222, -222 );
+  iRc += TestMethod( po, "ABS( 333, dResult )", x.ABS( 333, dResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "ABS( 333, dResult )", 333, 333 );
+
+  iRc += TestMethod( po, "x.ALLTRIM( \"   zzz   \", sResult )", x.ALLTRIM( "   zzz   ", sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.ALLTRIM( \"   zzz   \", sResult )", sResult, "zzz", 3 );
+
+  iRc += TestMethod( po, "ASC( \"A\", dResult )", x.ASC( "A", dResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "ASC( \"A\" )", dResult, (xbDouble) 65 );
+  iRc += TestMethod( po, "ASC( \"B\", dResult )", x.ASC( "B", dResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "ASC( \"B\" )", dResult, (xbDouble) 66 );
+  iRc += TestMethod( po, "AT( \"ABC\", \"XYZABC\", 4 )",  x.AT( "ABC", "XYZABC", dResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "AT( \"ABC\", \"XYZABC\", 4 )",  dResult, (xbDouble) 4 );
+  iRc += TestMethod( po, "CDOW( dtIn, sResult )", x.CDOW( dtIn, sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "CDOW( dtIn, sResult )", sResult, "Thursday", 8 );
+  iRc += TestMethod( po, "CHR( 101, sResult )", x.CHR( 101, sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "CHR( 101, sResult )", sResult, "e", 1 );
+
+  dtIn = "19870103";
+  iRc += TestMethod( po, "CMONTH( dtIn, sResult )", x.CMONTH( dtIn, sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "CMONTH( dtIn, sResult )", sResult, "January", 7 );
+  iRc += TestMethod( po, "CTOD( \"01\\03\\87\", dtResult )", x.CTOD( "01\\03\\87", dtResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "CTOD( \"01\\03\\87\", dtResult )", dtResult.Str(), "19870103", 8 );
+  iRc += TestMethod( po, "DATE( dtResult )", x.DATE( dtResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "DATE( dtResult )", dtResult.Str(), d.Str(), 8 );
+  iRc += TestMethod( po, "DAY(\"19870103\", dResult )", x.DAY( "19870103", dResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "DAY(\"19870103\", dResult )", dResult, (xbDouble) 3 );
+
+  iRc += TestMethod( po, "DEL( MyFile, sResult )", x.DEL( MyFile, sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "DEL( MyFile, sResult )", sResult, " ", 1 );
+
+  iRc += TestMethod( po, "DELETED( MyFile, bResult )", x.DELETED( MyFile, bResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "DELETED( MyFile, bResult )", (xbInt32) bResult, xbFalse );
+
+  iRc += TestMethod( po, "DeleteRecord()", MyFile->DeleteRecord(), XB_NO_ERROR );
+
+  iRc += TestMethod( po, "DEL( MyFile, sResult )", x.DEL( MyFile, sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "DEL( MyFile, sResult )", sResult, "*", 1 );
+  iRc += TestMethod( po, "DELETED( MyFile, bResult )", x.DELETED( MyFile, bResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "DELETED( MyFile, bResult )", (xbInt32) bResult, xbTrue );
+
+  iRc += TestMethod( po, "UndeleteRecord()", MyFile->UndeleteRecord(),  XB_NO_ERROR );
+
+  iRc += TestMethod( po, "DESCEND(\"ABCDE\", sResult )", x.DESCEND( "ABCDE", sResult ), XB_NO_ERROR );
+
+  char sDescendResult[6];  // = "¾½¼»º";
+  sDescendResult[0] = (char) 0xBE;
+  sDescendResult[1] = (char) 0xBD;
+  sDescendResult[2] = (char) 0xBC;
+  sDescendResult[3] = (char) 0xBB;
+  sDescendResult[4] = (char) 0xBA;
+  sDescendResult[5] = (char) 0x00;
+  iRc += TestMethod( po, "DESCEND(\"ABCDE\", sResult )", sResult, sDescendResult, 5 );
+
+  iRc += TestMethod( po, "DESCEND( 12345, dResult )", x.DESCEND( 12345, dResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "DESCEND( 12345, dResult )", dResult, (xbDouble) -12345 );
+  dtIn = "19890303";
+  iRc += TestMethod( po, "DESCEND( dtIn, dtResult )", x.DESCEND( dtIn, dtResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "DESCEND( dtIn, dtResult )", dtResult.Str(), "29101031", 8 );
+  dtIn = "20120708";
+  iRc += TestMethod( po, "DESCEND( dtIn, dtResult )", x.DESCEND( dtIn, dtResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "DESCEND( dtIn, dtResult )", dtResult.Str(), "28870625" , 8 );
+
+  dtIn = "20171014";
+  iRc += TestMethod( po, "DOW( dtIn, dResult )", x.DOW( dtIn, dResult ),  XB_NO_ERROR );
+  iRc += TestMethod( po, "DOW(\"20171015\", dResult )", dResult, (xbDouble) 0 );
+  dtIn++;
+  iRc += TestMethod( po, "DOW( dtIn, dResult )", x.DOW( dtIn, dResult ),  XB_NO_ERROR );
+  iRc += TestMethod( po, "DOW(\"20171016\", dResult )", dResult, (xbDouble) 1 );
+  dtIn++;
+  iRc += TestMethod( po, "DOW( dtIn, dResult )", x.DOW( dtIn, dResult ),  XB_NO_ERROR );
+  iRc += TestMethod( po, "DOW(\"20171021\", dResult )", dResult, (xbDouble) 2 );
+
+  dtIn = "20000101";
+  iRc += TestMethod( po, "DTOC( dtIn, sResult )", x.DTOC( dtIn, sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "DTOC( dtIn, sResult )", sResult, "01/01/00", 8 );
+  iRc += TestMethod( po, "DTOS( dtIn, sResult )", x.DTOS( dtIn, sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "DTOS( dtIn, sResult )", sResult, "20000101", 8 );
+  iRc += TestMethod( po, "EXP( 1, dResult )", x.EXP( 1, dResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "EXP( 1, dResult )", dResult, 2.71828, .001 );
+  iRc += TestMethod( po, "x.INT( 621.5, dResult )", x.INT( 621.5, dResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.INT( 621.5, dResult )", dResult, (xbDouble) 621 );
+  iRc += TestMethod( po, "x.ISALPHA( \"1\", bResult )", x.ISALPHA( "1", bResult ), 0 );
+  iRc += TestMethod( po, "x.ISALPHA( \"1\", bResult )", (xbInt32) bResult, xbFalse );
+  iRc += TestMethod( po, "x.ISALPHA( \"A\", bResult )", x.ISALPHA( "A", bResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.ISALPHA( \"A\", bResult )", (xbInt32) bResult, xbTrue );
+  iRc += TestMethod( po, "x.ISLOWER( \"A\", bResult )", x.ISLOWER( "A", bResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.ISLOWER( \"A\", bResult )", bResult, xbFalse );
+  iRc += TestMethod( po, "x.ISLOWER( \"a\", bResult )", x.ISLOWER( "a", bResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.ISLOWER( \"a\", bResult )", bResult, xbTrue );
+  iRc += TestMethod( po, "x.ISUPPER( \"A\", bResult )", x.ISUPPER( "A", bResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.ISUPPER( \"A\", bResult )", bResult, xbTrue );
+  iRc += TestMethod( po, "x.ISUPPER( \"a\", bResult )", x.ISUPPER( "a", bResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.ISUPPER( \"a\", bResult )", bResult, xbFalse );
+  iRc += TestMethod( po, "x.LEFT( \"STRING\", 3, sResult )", x.LEFT( "STRING", 3, sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.LEFT( \"STRING\", 3, sResult )", sResult, "STR", 3 );
+  iRc += TestMethod( po, "x.LEN( \"AAAAA\", dResult )", x.LEN( "AAAAA", dResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.LEN( \"AAAAA\", dResult )", dResult, (xbDouble) 5 );
+  iRc += TestMethod( po, "x.LOG( 2, dResult )", x.LOG( 2, dResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.LOG( 2, dResult )", dResult, (xbDouble) 0.69314700, .0001 );
+  iRc += TestMethod( po, "x.LOWER( \"AAAA\", sResult )", x.LOWER( "AAAA", sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.LOWER( \"AAAA\", sResult )", sResult, "aaaa", 4 );
+  iRc += TestMethod( po, "x.LTRIM( \"   xxxxxx\" )", x.LTRIM( "   xxxxxx", sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.LTRIM( \"   xxxxxx\" )", sResult, "xxxxxx", 6 );
+  iRc += TestMethod( po, "x.MAX( 10, 27, dResult )", x.MAX( 10, 27, dResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.MAX( 10, 27, dResult )", dResult, (xbDouble) 27 );
+  iRc += TestMethod( po, "x.MIN( 10, 5, dResult )", x.MIN( 10, 5, dResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.MIN( 10, 5, dResult )", dResult, (xbDouble) 5 );
+  iRc += TestMethod( po, "x.MONTH( dtIn, dResult )", x.MONTH( dtIn, dResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.MONTH( dtIn, dResult )", dResult, (xbDouble) 1 );
+  iRc += TestMethod( po, "x.RECCOUNT( MyFile, dResult)", x.RECNO( MyFile, dResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.RECCOUNT( MyFile, dResult)", dResult, (xbDouble) 1 );
+  iRc += TestMethod( po, "x.RECNO( MyFile, dResult)", x.RECNO( MyFile, dResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.RECNO( MyFile, dResult)", dResult, (xbDouble) 1 );
+  iRc += TestMethod( po, "x.REPLICATE( \"abc\", 3, sResult )", x.REPLICATE( "abc", 3, sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.REPLICATE( \"abc\", 3, sResult )", sResult, "abcabcabc", 9 );
+  iRc += TestMethod( po, "x.RIGHT( \"STRING\", 3, sResult )", x.RIGHT( "STRING", 3, sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.RIGHT( \"STRING\", 3, sResult )", sResult, "ING", 3 );
+  iRc += TestMethod( po, "x.RIGHT( \"STRING\", 3, sResult )", x.RIGHT( "STRING", 5, sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.RIGHT( \"STRING\", 3, sResult )", sResult, "TRING", 5 );
+  iRc += TestMethod( po, "x.RIGHT( \"STRING\", 3, sResult )", x.RIGHT( "STRING", 6, sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.RIGHT( \"STRING\", 3, sResult )", sResult, "STRING", 6 );
+  iRc += TestMethod( po, "x.RIGHT( \"STRING\", 3, sResult )", x.RIGHT( "STRING", 7, sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.RIGHT( \"STRING\", 3, sResult )", sResult, "STRING", 6 );
+  iRc += TestMethod( po, "x.RTRIM( \"zzz   \", sResult )", x.RTRIM( "zzz   ", sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.RTRIM( \"zzz   \", sResult )", sResult, "zzz", 3 );
+  iRc += TestMethod( po, "x.TRIM( \"aaa   \", sResult )", x.TRIM( "aaa   ", sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.TRIM( \"aaa   \", sResult )", sResult, "aaa", 3 );
+  iRc += TestMethod( po, "x.SPACE( 3, sResult )", x.SPACE( 3, sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.SPACE( 3, sResult )", sResult, "   ", 3 );
+  iRc += TestMethod( po, "x.SQRT( 9, dResult )", x.SQRT( 9, dResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.SQRT( 9, dResult )", dResult, (xbDouble) 3 );
+  iRc += TestMethod( po, "x.STOD( \"20000101\", dtResult )", x.STOD( "20000101", dtResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.STOD( \"20000101\", dtResult )",dtResult.Str(), "20000101", 8 );
+
+  xbString sPadChar = " ";
+  iRc += TestMethod( po, "x.STR( 2001, 4, 0, sPadChar, sResult )", x.STR( 2001, 4, 0, sPadChar, sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.STR( 2001, 4, 0, sPadChar, sResult )", sResult, "2001", 4 );
+  iRc += TestMethod( po, "x.STR( 2002, 3, 0, sPadChar, sResult )", x.STR( 2002, 3, 0, sPadChar, sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.STR( 2002, 3, 0, sPadChar, sResult )", sResult, "***", 3 );
+  iRc += TestMethod( po, "x.STR( 203.2, 6, 2, sPadChar, sResult )", x.STR( 203.2, 6, 2, sPadChar, sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.STR( 203.2, 6, 2, sPadChar, sResult )", sResult, "203.20", 6 );
+  iRc += TestMethod( po, "x.STR( 204.11, 8, 2, sPadChar, sResult )", x.STR( 204.11, 8, 2, sPadChar, sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.STR( 204.11, 8, 2, sPadChar, sResult )", sResult, "  204.11", 8 );
+  iRc += TestMethod( po, "x.STR( -205.45, 8, 2, sPadChar, sResult )", x.STR( -205.45, 8, 2, sPadChar, sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.STR( -205.45, 8, 2, sPadChar, sResult )", sResult, " -205.45", 8 );
+  iRc += TestMethod( po, "x.STR( -306.45, 8, 2, sPadChar, sResult )", x.STR( -306.45, 8, 2, sPadChar, sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.STR( -306.45, 8, 2, sPadChar, sResult )", sResult, " -306.45", 8 );
+  iRc += TestMethod( po, "x.STR( 6.56, 5, 0, sResult )", x.STR( 6.56, 5, 0, sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.STR( 6.56, 5, 0, sResult )", sResult, "    7", 5 );
+  iRc += TestMethod( po, "x.STR( 7.77, 5, sResult )", x.STR( 7.77, 5, sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.STR( 7.77, 5, sResult )", sResult, "    8", 5 );
+  iRc += TestMethod( po, "x.STR( 8, sResult )", x.STR( 8, sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.STR( 8, sResult )", sResult, "         8", 10 );
+
+  sPadChar = "0";
+  iRc += TestMethod( po, "x.STR( -5.2, 10, 2, sPadChar, sResult )", x.STR( -5.2, 10, 2, sPadChar, sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.STR( -5.2, 10, 2, sPadChar, sResult )", sResult, "00000-5.20", 10 );
+  iRc += TestMethod( po, "x.STRZERO( 8, 8, 0, sResult )", x.STRZERO( 8, 8, 0, sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.STRZERO( 8, 8, 0, sResult )", sResult, "00000008", 8 );
+  iRc += TestMethod( po, "x.STRZERO( -8, 8, 0, sResult )", x.STRZERO( -8, 8, 0, sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.STRZERO( -8, 8, 0, sResult )", sResult, "-0000008", 8 );
+  iRc += TestMethod( po, "x.STRZERO( -205.45, 10, 3 )", x.STRZERO( -205.45, 10, 3, sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.STRZERO( -205.45, 10, 3 )", sResult, "-00205.450", 10 );
+  iRc += TestMethod( po, "x.STRZERO( -205.45, 3, 1 )", x.STRZERO( -205.45, 3, 1, sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.STRZERO( -205.45, 3, 1 )", sResult, "***", 3 );
+  iRc += TestMethod( po, "x.SUBSTR( \"TESTSTRING\", 5, 2, sResult )", x.SUBSTR( "TESTSTRING", 5, 2, sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.SUBSTR( \"TESTSTRING\", 5, 2, sResult )", sResult, "ST", 2 );
+  iRc += TestMethod( po, "x.UPPER( \"abababa\", sResult )", x.UPPER( "abababa", sResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.UPPER( \"abababa\", sResult )", sResult, "ABABABA", 7 );
+  iRc += TestMethod( po, "x.VAL( \"65\", dResult )", x.VAL( "65", dResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.VAL( \"65\", dResult )", dResult, (xbDouble) 65 );
+  iRc += TestMethod( po, "x.YEAR( dtIn, dResult )", x.YEAR( dtIn, dResult ), XB_NO_ERROR );
+  iRc += TestMethod( po, "x.YEAR( dtIn, dResult )", dResult, (xbDouble) 2000 );
+
+
+  iRc += TestMethod( po, "Close()", MyFile->Close(), XB_NO_ERROR );
+
+
+  delete MyFile;
+  if( po > 0 || iRc < 0 )
+    fprintf( stdout, "Total Errors = %d\n", iRc * -1 );
+
+  #ifdef XB_LOGGING_SUPPORT
+  sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], iRc * -1 );
+  x.WriteLogMessage( sMsg );
+  #endif
+
+  return iRc;
+}
diff --git a/src/tests/xb_test_linklist.cpp b/src/tests/xb_test_linklist.cpp
new file mode 100755
index 0000000..dc253af
--- /dev/null
+++ b/src/tests/xb_test_linklist.cpp
@@ -0,0 +1,340 @@
+/* xb_test_linklist.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+
+The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
+
+Email Contact:
+
+    XDB-devel@lists.sourceforge.net
+    XDB-users@lists.sourceforge.net
+
+*/
+
+// This program tests the class xblnklst and xblnknod
+// usage:   xb_test_linklist QUITE|NORMAL|VERBOSE
+
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+
+
+int main( int argCnt, char **av )
+{
+  int rc = 0;
+
+  int po = 1;          /* print option */
+                       /* 0 - QUIET    */
+                       /* 1 - NORMAL   */
+                       /* 2 - VERBOSE  */
+
+  if( argCnt > 1 ) {
+    if( av[1][0] == 'Q' )
+      po = 0;
+    else if( av[1][0] == 'V' )
+      po = 2;
+  }
+
+  xbXBase x;
+#ifdef XB_LOGGING_SUPPORT
+  x.EnableMsgLogging();
+  if( po ){
+    std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+  }
+  xbString sMsg;
+  sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+  x.WriteLogMessage( sMsg );
+#endif
+  InitTime();
+
+  xbLinkList<xbString> ll;
+  ll.InsertAtFront( "A" );
+  ll.InsertAtFront( "B" );
+  ll.InsertAtFront( "C" );
+  ll.InsertAtFront( "D" );
+  ll.InsertAtFront( "E" );
+  ll.InsertAtFront( "F" );
+  ll.InsertAtFront( "G" );
+  ll.InsertAtFront( "H" );
+  ll.InsertAtFront( "I" );
+  ll.InsertAtFront( "J" );
+  ll.InsertAtFront( "K" );
+  ll.InsertAtFront( "L" );
+  ll.InsertAtFront( "M" );
+  ll.InsertAtFront( "N" );
+  ll.InsertAtFront( "O" );
+
+  xbLinkListNode<xbString> * llN = ll.GetHeadNode();
+  xbString s;
+  xbString s2;
+  xbUInt32 ulCnt = ll.GetNodeCnt();
+  for( xbUInt32 i = 0; i < ulCnt; i++ ){
+    s2 = llN->GetKey();
+    s.Sprintf( "%s%s", s.Str(), s2.Str() );
+    llN = llN->GetNextNode();
+  }
+  rc += TestMethod( po, "InsertAtFront()", s, "ONMLKJIHGFEDCBA", 15 );
+
+  s = "";
+  llN = ll.GetHeadNode();
+  while( llN ){
+    s2 = llN->GetKey();
+    s.Sprintf( "%s%s", s.Str(), s2.Str() );
+    llN = llN->GetNextNode();
+  }
+  rc += TestMethod( po, "GetNextNode()", s, "ONMLKJIHGFEDCBA", 15 );
+
+  s = "";
+  llN = ll.GetEndNode();
+  while( llN ){
+    s2 = llN->GetKey();
+    s.Sprintf( "%s%s", s.Str(), s2.Str() );
+    llN = llN->GetPrevNode();
+  }
+  rc += TestMethod( po, "GetNextNode()", s, "ABCDEFGHIJKLMNO", 15 );
+
+
+  ll.RemoveFromFront( s );
+  rc += TestMethod( po, "RemoveFromFront()", s, "O", 1 );
+
+  llN = ll.GetHeadNode();
+  ulCnt = ll.GetNodeCnt();
+  rc += TestMethod( po, "RemoveFromFront()", (xbInt32) ulCnt, 14 );
+
+  s = "";
+  for( xbUInt32 i = 0; i < ulCnt; i++ ){
+    s2 = llN->GetKey();
+    s.Sprintf( "%s%s", s.Str(), s2.Str() );
+    llN = llN->GetNextNode();
+  }
+  rc += TestMethod( po, "RemoveFromFront()", s, "NMLKJIHGFEDCBA", 14 );
+
+
+  s = "";
+  llN = ll.GetHeadNode();
+  while( llN ){
+    s2 = llN->GetKey();
+    s.Sprintf( "%s%s", s.Str(), s2.Str() );
+    llN = llN->GetNextNode();
+  }
+  rc += TestMethod( po, "RemoveFromFront()", s, "NMLKJIHGFEDCBA", 14 );
+
+
+  s = "";
+  llN = ll.GetEndNode();
+  while( llN ){
+    s2 = llN->GetKey();
+    s.Sprintf( "%s%s", s.Str(), s2.Str() );
+    llN = llN->GetPrevNode();
+  }
+  rc += TestMethod( po, "RemoveFromFront()", s, "ABCDEFGHIJKLMN", 14 );
+
+
+  ll.RemoveFromEnd( s );
+  rc = TestMethod( po, "RemoveFromEnd()", s, "A", 1 );
+  ulCnt = ll.GetNodeCnt();
+  rc += TestMethod( po, "RemoveFromFront()", (xbInt32) ulCnt, 13 );
+
+  s = "";
+  llN = ll.GetHeadNode();
+  for( xbUInt32 i = 0; i < ulCnt; i++ ){
+    s2 = llN->GetKey();
+    s.Sprintf( "%s%s", s.Str(), s2.Str() );
+    llN = llN->GetNextNode();
+  }
+  rc += TestMethod( po, "RemoveFromEnd()", s, "NMLKJIHGFEDCB", 13 );
+
+  s = "";
+  llN = ll.GetHeadNode();
+  while( llN ){
+    s2 = llN->GetKey();
+    s.Sprintf( "%s%s", s.Str(), s2.Str() );
+    llN = llN->GetNextNode();
+  }
+  rc += TestMethod( po, "RemoveFromEnd()", s, "NMLKJIHGFEDCB", 13 );
+
+  s = "";
+  llN = ll.GetEndNode();
+  while( llN ){
+    s2 = llN->GetKey();
+    s.Sprintf( "%s%s", s.Str(), s2.Str() );
+    llN = llN->GetPrevNode();
+  }
+  rc += TestMethod( po, "RemoveFromEnd()", s, "BCDEFGHIJKLMN", 13 );
+
+  s = "J";
+  ll.RemoveByVal( s );
+  rc += TestMethod( po, "RemoveByVal()", s, "J", 1 );
+  ulCnt = ll.GetNodeCnt();
+  rc += TestMethod( po, "RemoveByVal()", (xbInt32) ulCnt, 12 );
+
+  llN = ll.GetHeadNode();
+  s = "";
+  for( xbUInt32 i = 0; i < ulCnt; i++ ){
+    s2 = llN->GetKey();
+    s.Sprintf( "%s%s", s.Str(), s2.Str() );
+    llN = llN->GetNextNode();
+  }
+  rc += TestMethod( po, "RemoveByVal()", s, "NMLKIHGFEDCB", 12 );
+
+  s = "";
+  llN = ll.GetHeadNode();
+  while( llN ){
+    s2 = llN->GetKey();
+    s.Sprintf( "%s%s", s.Str(), s2.Str() );
+    llN = llN->GetNextNode();
+  }
+  rc += TestMethod( po, "RemoveByVal()", s, "NMLKIHGFEDCB", 12 );
+
+  s = "";
+  llN = ll.GetEndNode();
+  while( llN ){
+    s2 = llN->GetKey();
+    s.Sprintf( "%s%s", s.Str(), s2.Str() );
+    llN = llN->GetPrevNode();
+  }
+  rc += TestMethod( po, "RemoveByVal()", s, "BCDEFGHIKLMN", 12 );
+
+
+// ordered link list 
+  xbLinkListOrd<xbString> llO;
+  llO.SetDupKeys( 0 );
+  rc += TestMethod( po, "InsertKey( J )", llO.InsertKey( "J" ), 0);
+  rc += TestMethod( po, "InsertKey( J )", llO.InsertKey( "J" ), XB_KEY_NOT_UNIQUE );
+  rc += TestMethod( po, "InsertKey( M )", llO.InsertKey( "M" ), 0 );
+  rc += TestMethod( po, "InsertKey( C )", llO.InsertKey( "C" ), 0 );
+  rc += TestMethod( po, "InsertKey( F )", llO.InsertKey( "F" ), 0 );
+  rc += TestMethod( po, "InsertKey( Q )", llO.InsertKey( "Q" ), 0 );
+  rc += TestMethod( po, "InsertKey( A )", llO.InsertKey( "A" ), 0 );
+  rc += TestMethod( po, "InsertKey( T )", llO.InsertKey( "T" ), 0 );
+
+  if( po > 1 ){
+    std::cout << "dumping node chain from beginning to end\n";
+    llN = llO.GetHeadNode();
+    while( llN ){
+      s2 = llN->GetKey();
+      std::cout << "node = " <<  s2.Str() << "\n";
+      llN = llN->GetNextNode();
+    }
+
+    std::cout << "dumping node chain from beginning to beginning\n";
+    llN = llO.GetHeadNode();
+    while( llN ){
+      s2 = llN->GetKey();
+      std::cout << "node = " <<  s2.Str() << "\n";
+      llN = llN->GetPrevNode();
+    }
+
+    std::cout << "dumping node chain from end to end\n";
+    llN = llO.GetEndNode();
+    while( llN ){
+      s2 = llN->GetKey();
+      std::cout << "node = " <<  s2.Str() << "\n";
+      llN = llN->GetNextNode();
+    }
+
+    std::cout << "dumping node chain from end to beginning\n";
+    llN = llO.GetEndNode();
+    while( llN ){
+      s2 = llN->GetKey();
+      std::cout << "node = " <<  s2.Str() << "\n";
+      llN = llN->GetPrevNode();
+    }
+
+
+  }
+
+  // xbLinkListNode<xbString> * psN;
+  s2 = "A";
+  rc += TestMethod( po, "KeyExists('A')", llO.KeyExists( s2 ), xbTrue );
+  rc += TestMethod( po, "RemoveKey('A')", llO.RemoveKey( s2 ), 0 );
+  s2 = "J";
+  rc += TestMethod( po, "RemoveKey('J')", llO.RemoveKey( s2 ), 0 );
+  s2 = "T";
+  rc += TestMethod( po, "RemoveKey('T')", llO.RemoveKey( s2 ), 0 );
+  rc += TestMethod( po, "RemoveKey('T')", llO.RemoveKey( s2 ), XB_NOT_FOUND );
+  rc += TestMethod( po, "KeyExists('T')", llO.KeyExists( s2 ), xbFalse );
+
+
+
+  xbLinkListOrd<xbUInt32> lloi;
+  lloi.SetDupKeys( 0 );
+  xbUInt32 i = 3;
+
+  rc += TestMethod( po, "InsertKey( 1 )", lloi.InsertKey( i ), 0 );
+  rc += TestMethod( po, "RemoveKey( 1 )", lloi.RemoveKey( i ), 0 );
+  rc += TestMethod( po, "RemoveKey( 1 )", lloi.RemoveKey( i ), XB_NOT_FOUND );
+
+
+  if( po > 1 ){
+    std::cout << "dumping node chains after delete\n";
+    std::cout << "dumping node chain from beginning to end\n";
+    llN = llO.GetHeadNode();
+    while( llN ){
+      s2 = llN->GetKey();
+      std::cout << "node = " <<  s2.Str() << "\n";
+      llN = llN->GetNextNode();
+    }
+
+    std::cout << "dumping node chain from beginning to beginning\n";
+    llN = llO.GetHeadNode();
+    while( llN ){
+      s2 = llN->GetKey();
+      std::cout << "node = " <<  s2.Str() << "\n";
+      llN = llN->GetPrevNode();
+    }
+
+    std::cout << "dumping node chain from end to end\n";
+    llN = llO.GetEndNode();
+    while( llN ){
+      s2 = llN->GetKey();
+      std::cout << "node = " <<  s2.Str() << "\n";
+      llN = llN->GetNextNode();
+    }
+
+    std::cout << "dumping node chain from end to beginning\n";
+    llN = llO.GetEndNode();
+    while( llN ){
+      s2 = llN->GetKey();
+      std::cout << "node = " <<  s2.Str() << "\n";
+      llN = llN->GetPrevNode();
+    }
+  }
+
+
+  xbLinkListOrd<xbUInt32> ll32;
+  // xbLinkListNode<xbUInt32> * ll32n;
+
+//  for( xbUInt32 ul = 0; ul < 1; ul++ )
+//    ll32.InsertKey( ul, ul );
+
+
+  xbUInt32 ul3 = 0;
+//  ll32.InsertKey( 1, "1" );
+
+  ll32.InsertKey( ul3, ul3 );
+
+  ll.Clear();
+
+
+
+#ifdef XB_LOGGING_SUPPORT
+  sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], rc * -1 );
+  x.WriteLogMessage( sMsg );
+#endif
+
+  if( po > 0 || rc < 0 )
+    fprintf( stdout, "Total Errors = %d\n", rc * -1 );
+
+  return rc;
+}
+
+
+
+
diff --git a/src/tests/xb_test_lock.cpp b/src/tests/xb_test_lock.cpp
new file mode 100755
index 0000000..7e9865b
--- /dev/null
+++ b/src/tests/xb_test_lock.cpp
@@ -0,0 +1,874 @@
+/*  xb_test_lock.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+
+The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
+
+Email Contact:
+
+    XDB-devel@lists.sourceforge.net
+    XDB-users@lists.sourceforge.net
+
+*/
+
+// This program tests the locking functions of xbase
+// usage:   xb_test_lock QUITE|NORMAL|VERBOSE
+
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+/****************************************************************/
+int main( int argCnt, char **av )
+{
+  xbInt16 iRc = 0;
+  xbInt16 iRc2;
+  xbInt16 po = 1;      /* print option */
+                       /* 0 - QUIET    */
+                       /* 1 - NORMAL   */
+                       /* 2 - VERBOSE  */
+
+  xbInt16  iErrorStop  = 0;
+  xbString sLockFile   = "locktest.txt";
+  xbString sLockCmd;
+  xbString sResult;
+
+  xbXBase x;
+  xbDbf * MyFile;
+
+  if( argCnt > 1 ) {
+    if( av[1][0] == 'Q' )
+      po = 0;
+    else if( av[1][0] == 'V' )
+      po = 2;
+  }
+
+  xbSchema MyRecord[] = 
+  {
+    { "LOCKTEST",      XB_CHAR_FLD,      5, 0 },
+    #ifdef XB_MEMO_SUPPORT
+    { "MEMOTEST",      XB_MEMO_FLD,     10, 0 },
+    #endif
+    { "",0,0,0 }
+  };
+
+
+  #ifdef XB_LOGGING_SUPPORT
+  x.EnableMsgLogging();
+  if( po > 0 ){
+    std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+  }
+  xbString sMsg;
+  sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+  x.WriteLogMessage( sMsg );
+  #endif
+
+  x.SetDataDirectory( PROJECT_DATA_DIR );
+  x.EnableMsgLogging();
+  InitTime();
+  #ifdef XB_DBF4_SUPPORT
+  MyFile = new xbDbf4( &x );                /* version 4 dbf file */
+  #else
+  MyFile = new xbDbf3( &x );                /* version 3 dbf file */
+  #endif
+
+  iRc2 = MyFile->CreateTable( "LockTest.DBF", "LockTest", MyRecord, XB_OVERLAY, XB_MULTI_USER );
+  iRc += TestMethod( po, "CreateTable()",  iRc2, XB_NO_ERROR );
+  iRc += TestMethod( po, "PutField()",     MyFile->PutField( "LOCKTEST", "TEST" ),   XB_NO_ERROR );
+  iRc += TestMethod( po, "AppendRecord()", MyFile->AppendRecord(),                   XB_NO_ERROR );
+  iRc += TestMethod( po, "Close()", MyFile->Close(), XB_NO_ERROR );
+  MyFile->Close();
+
+  //unlink( sLockFile );
+  remove( sLockFile );
+
+  #if defined (HAVE_FORK_F)
+  pid_t pid;
+  if(( pid = fork()) < 0 ){
+    std::cout << "fork error\n";
+    exit(1);
+  }
+
+  if( pid == 0 ){
+    // child task
+    xbDbf    * MyFileChld;
+    xbInt16  iRcChld      = 0;
+    xbBool   bTblOpenChld = xbFalse;
+    xbInt32  iChildLoop   = 0;
+    xbBool   bDone        = xbFalse;
+    xbString sLastLockCmd;
+
+    #ifdef XB_DBF4_SUPPORT
+    MyFileChld = new xbDbf4( &x );                /* version 4 dbf file */
+    #else
+    MyFileChld = new xbDbf3( &x );                /* version 3 dbf file */
+    #endif
+
+    x.xbSleep( 250 );
+
+    while( !bDone ){
+      iRc2 = GetCmd( x, sLockFile, sLockCmd, 'C', po );
+
+      if( sLockCmd == sLastLockCmd )
+        iChildLoop++;
+      else
+        sLastLockCmd = sLockCmd;
+
+      #ifdef XB_LOGGING_SUPPORT
+      if( sLockCmd != "OK" && sLockCmd != "FAIL" ){
+        sMsg.Sprintf( "Program [%s] Child task retrieved command=[%s] RC=[%d]", av[0], sLockCmd.Str(), iRc2 );
+        x.WriteLogMessage( sMsg );
+      }
+      #endif
+
+      if( iRc2 == 0 ){
+
+        if( sLockCmd == "OK" || sLockCmd == "FAIL" )
+          x.xbSleep( 250 );
+
+        else if( sLockCmd == "EXIT" ){
+          bDone = xbTrue;
+
+        } else if( sLockCmd == "START" && bTblOpenChld ){
+          // came back before the parent task could process the result
+          x.xbSleep( 250 );
+
+        } else {
+
+          if( sLockCmd == "START" ){
+            // begin the process
+            iRcChld =  MyFileChld->Open( "LockTest.DBF" );
+            if( iRcChld != XB_NO_ERROR ){
+              sResult = "FAIL";
+            } else {
+              sResult = "OK";
+              bTblOpenChld = xbTrue;
+            }
+
+          } else if( sLockCmd == "TL" ){
+            // table lock
+            if(( iRcChld = MyFileChld->LockTable( XB_LOCK )) != XB_NO_ERROR )
+              sResult = "FAIL";
+            else
+              sResult = "OK";
+
+          } else if( sLockCmd == "TU" ){
+            // table unlock
+            if(( iRcChld = MyFileChld->LockTable( XB_UNLOCK )) != XB_NO_ERROR )
+              sResult = "FAIL";
+            else
+              sResult = "OK";
+
+          } else if( sLockCmd == "RL" ){
+            // record lock
+            if(( iRcChld = MyFileChld->LockRecord( XB_LOCK, 1 )) != XB_NO_ERROR )
+              sResult = "FAIL";
+            else
+              sResult = "OK";
+
+          } else if( sLockCmd == "RU" ){
+            // record unlock
+            if(( iRcChld = MyFileChld->LockRecord( XB_UNLOCK, 1 )) != XB_NO_ERROR )
+              sResult = "FAIL";
+            else
+              sResult = "OK";
+
+          } else if( sLockCmd == "ML" ){
+            // memo lock
+            #ifdef XB_MEMO_SUPPORT
+            if(( iRcChld = MyFileChld->LockMemo( XB_LOCK )) != XB_NO_ERROR )
+              sResult = "FAIL";
+            else
+              sResult = "OK";
+            #else
+            sLockCmd = "OK";
+            #endif
+
+          } else if( sLockCmd == "MU" ){
+            // memo unlock
+            #ifdef XB_MEMO_SUPPORT
+            if(( iRcChld = MyFileChld->LockMemo( XB_UNLOCK )) != XB_NO_ERROR )
+              sResult = "FAIL";
+            else
+              sResult = "OK";
+            #else
+            sLockCmd = "OK";
+            #endif
+          }
+
+          #ifdef XB_LOGGING_SUPPORT
+          sMsg.Sprintf( "Program [%s] Child task [%s] Result [%s] RC = [%d]", av[0], sLockCmd.Str(), sResult.Str(), iRcChld );
+          x.WriteLogMessage( sMsg );
+          #endif
+          SetCmd( x, sLockFile, sResult, 'C', po );
+          if( sResult == "FAIL" ){
+            bDone = xbTrue;
+            MyFileChld->Close();
+            delete MyFileChld;
+          }
+        }
+
+      } else {
+        iRc = iRc2;
+        bDone = xbTrue;
+      }
+      //std::cout << "clc [" << iChildLoop++ << "][" << bDone << "][" << sLockCmd.Str() << "]\n";
+      x.xbSleep( 250 );
+      if( iChildLoop > 15 )
+        bDone = xbTrue;
+    }
+    MyFileChld->Close();
+    delete MyFile;
+    delete MyFileChld;
+
+    if( po > 0 )
+      std::cout << "Exiting child\n";
+
+    #ifdef XB_LOGGING_SUPPORT
+    sMsg.Sprintf( "Program [%s] Child task terminating", av[0] );
+    x.WriteLogMessage( sMsg );
+    #endif
+
+
+  } else {
+
+    // parent logic
+    xbInt16 iLoopCtr = 0;
+
+    try{
+
+      // start
+
+      #ifdef XB_LOGGING_SUPPORT
+      sMsg.Sprintf( "Program [%s] Parent task issuing START command", av[0] );
+      x.WriteLogMessage( sMsg );
+      #endif
+
+      sLockCmd = "START";
+      SetCmd( x, sLockFile, sLockCmd, 'P', po );
+      sResult = "";
+
+      GetCmd( x, sLockFile, sResult, 'P', po );
+      while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 30 ){
+        GetCmd( x, sLockFile, sResult, 'P', po );
+        x.xbSleep( 250 );
+        iLoopCtr++;
+      }
+
+      #ifdef XB_LOGGING_SUPPORT
+      sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+      x.WriteLogMessage( sMsg );
+      #endif
+
+      if( sResult != "OK" ){
+        iErrorStop = 10;
+        iRc2 = -1;
+        throw iRc2;
+      }
+
+      // table lock
+      #ifdef XB_LOGGING_SUPPORT
+      sMsg.Sprintf( "Program [%s] Parent task issuing TL command", av[0] );
+      x.WriteLogMessage( sMsg );
+      #endif
+
+      sLockCmd = "TL";
+      SetCmd( x, sLockFile, sLockCmd, 'P', po );
+      sResult = "";
+
+      GetCmd( x, sLockFile, sResult, 'P', po );
+      while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 30 ){
+        GetCmd( x, sLockFile, sResult, 'P', po );
+        x.xbSleep( 250 );
+        iLoopCtr++;
+      }
+
+      #ifdef XB_LOGGING_SUPPORT
+      sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+      x.WriteLogMessage( sMsg );
+      #endif
+
+      if( sResult != "OK" ){
+        iErrorStop = 20;
+        iRc2 = -1;
+        throw iRc2;
+      }
+
+      // attempt to lock table, should fail
+      if(( iRc2 =  MyFile->Open( "LockTest.DBF" )) != XB_NO_ERROR ){
+        iErrorStop = 30;
+        throw iRc2;
+      }
+
+      if(( iRc2 =  MyFile->LockTable( XB_LOCK )) == XB_NO_ERROR ){
+        iErrorStop = 40;
+        throw iRc2;
+      }
+
+      if( po > 0 )
+        std::cout << "[PASS] LockTable Test 1\n";
+
+      // table unlock
+      #ifdef XB_LOGGING_SUPPORT
+      sMsg.Sprintf( "Program [%s] Parent task issuing TU command", av[0] );
+      x.WriteLogMessage( sMsg );
+      #endif
+
+      sLockCmd = "TU";
+      SetCmd( x, sLockFile, sLockCmd, 'P', po );
+      sResult = "";
+
+      GetCmd( x, sLockFile, sResult, 'P', po );
+      while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 30 ){
+        GetCmd( x, sLockFile, sResult, 'P', po );
+        x.xbSleep( 250 );
+        iLoopCtr++;
+      }
+
+      #ifdef XB_LOGGING_SUPPORT
+      sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+      x.WriteLogMessage( sMsg );
+      #endif
+
+      if( sResult != "OK" ){
+        iErrorStop = 50;
+        iRc2 = -1;
+        throw iRc2;
+      }
+
+      if(( iRc2 =  MyFile->LockTable( XB_LOCK )) != XB_NO_ERROR ){
+        iErrorStop = 60;
+        throw iRc2;
+      }
+      if( po > 0 )
+        std::cout << "[PASS] LockTable Test 2\n";
+
+      if(( iRc2 =  MyFile->LockTable( XB_UNLOCK )) != XB_NO_ERROR ){
+        iErrorStop = 70;
+        throw iRc2;
+      }
+
+      /* record lock */
+      #ifdef XB_LOGGING_SUPPORT
+      sMsg.Sprintf( "Program [%s] Parent task issuing RL command", av[0] );
+      x.WriteLogMessage( sMsg );
+      #endif
+
+      sLockCmd = "RL";
+      SetCmd( x, sLockFile, sLockCmd, 'P', po );
+      sResult = "";
+
+      GetCmd( x, sLockFile, sResult, 'P', po );
+      while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 30 ){
+        GetCmd( x, sLockFile, sResult, 'P', po );
+        x.xbSleep( 250 );
+        iLoopCtr++;
+      }
+
+      #ifdef XB_LOGGING_SUPPORT
+      sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+      x.WriteLogMessage( sMsg );
+      #endif
+
+      if( sResult != "OK" ){
+        iErrorStop = 80;
+        iRc2 = -1;
+        throw iRc2;
+      }
+
+      if(( iRc2 =  MyFile->LockRecord( XB_LOCK, 1 )) == XB_NO_ERROR ){
+        iErrorStop = 90;
+        throw iRc2;
+      }
+      if( po > 0 )
+        std::cout << "[PASS] LockRecord Test 1\n";
+
+      /* record unlock */
+      #ifdef XB_LOGGING_SUPPORT
+      sMsg.Sprintf( "Program [%s] Parent task issuing RU command", av[0] );
+      x.WriteLogMessage( sMsg );
+      #endif
+
+      sLockCmd = "RU";
+      SetCmd( x, sLockFile, sLockCmd, 'P', po );
+      sResult = "";
+
+      GetCmd( x, sLockFile, sResult, 'P', po );
+      while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 30 ){
+        GetCmd( x, sLockFile, sResult, 'P', po );
+        x.xbSleep( 250 );
+        iLoopCtr++;
+      }
+
+      #ifdef XB_LOGGING_SUPPORT
+      sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+      x.WriteLogMessage( sMsg );
+      #endif
+
+      if( sResult != "OK" ){
+        iErrorStop = 100;
+        iRc2 = -1;
+        throw iRc2;
+      }
+
+      if(( iRc2 =  MyFile->LockRecord( XB_LOCK, 1 )) != XB_NO_ERROR ){
+        iErrorStop = 110;
+        throw iRc2;
+      }
+
+      std::cout << "[PASS] LockRecord Test 2\n";
+      if(( iRc2 =  MyFile->LockRecord( XB_UNLOCK, 1 )) != XB_NO_ERROR ){
+        iErrorStop = 120;
+        throw iRc2;
+      }
+
+
+      /*     memo lock */
+      #ifdef XB_MEMO_SUPPORT
+      #ifdef XB_LOGGING_SUPPORT
+      sMsg.Sprintf( "Program [%s] Parent task issuing ML command", av[0] );
+      x.WriteLogMessage( sMsg );
+      #endif
+
+      sLockCmd = "ML";
+      SetCmd( x, sLockFile, sLockCmd, 'P', po );
+      sResult = "";
+
+      GetCmd( x, sLockFile, sResult, 'P', po );
+      while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 30 ){
+        GetCmd( x, sLockFile, sResult, 'P', po );
+        x.xbSleep( 250 );
+        iLoopCtr++;
+      }
+
+      #ifdef XB_LOGGING_SUPPORT
+      sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+      x.WriteLogMessage( sMsg );
+      #endif
+
+      if( sResult != "OK" ){
+        iErrorStop = 130;
+        iRc2 = -1;
+        throw iRc2;
+      }
+
+      if(( iRc2 =  MyFile->LockMemo( XB_LOCK )) == XB_NO_ERROR ){
+        iErrorStop = 140;
+        throw iRc2;
+      }
+      if( po > 0 )
+        std::cout << "[PASS] LockMemo Test 1\n";
+
+      /* memo unlock */
+      #ifdef XB_LOGGING_SUPPORT
+      sMsg.Sprintf( "Program [%s] Parent task issuing MU command", av[0] );
+      x.WriteLogMessage( sMsg );
+      #endif
+
+      sLockCmd = "MU";
+      SetCmd( x, sLockFile, sLockCmd, 'P', po );
+      sResult = "";
+
+      GetCmd( x, sLockFile, sResult, 'P', po );
+      while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 30 ){
+        GetCmd( x, sLockFile, sResult, 'P', po );
+        x.xbSleep( 250 );
+        iLoopCtr++;
+      }
+
+      #ifdef XB_LOGGING_SUPPORT
+      sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+      x.WriteLogMessage( sMsg );
+      #endif
+
+      if( sResult != "OK" ){
+        iErrorStop = 150;
+        iRc2 = -1;
+        throw iRc2;
+      }
+
+      if(( iRc2 =  MyFile->LockMemo( XB_LOCK )) != XB_NO_ERROR ){
+        iErrorStop = 160;
+        throw iRc2;
+      }
+
+      std::cout << "[PASS] LockMemo Test 2\n";
+      if(( iRc2 =  MyFile->LockMemo( XB_UNLOCK )) != XB_NO_ERROR ){
+        iErrorStop = 170;
+        throw iRc2;
+      }
+      #endif
+
+      // exit
+      sLockCmd = "EXIT";
+      SetCmd( x, sLockFile, sLockCmd, 'P', po );
+
+    } catch (xbInt16 iRc3 ){
+      iRc = iRc3;
+      if( po > 0 )
+        std::cout << "Parent lock task exiting on failure [" << sLockCmd.Str() << "][" << iErrorStop << "]\n";
+
+
+      #ifdef XB_LOGGING_SUPPORT
+      sMsg.Sprintf( "Program [%s] Parent task terminating with errors [%s][%d][%d][%d]...", av[0], sLockCmd.Str(), iErrorStop, iLoopCtr, iRc3 );
+      x.WriteLogMessage( sMsg );
+      #endif
+
+    }
+
+    #ifdef XB_LOGGING_SUPPORT
+    sMsg.Sprintf( "Program [%s] Parent task terminating", av[0] );
+    x.WriteLogMessage( sMsg );
+    #endif
+
+    if( po > 0 )
+      std::cout << "Exiting parent\n";
+
+    sLockCmd = "EXIT";
+    SetCmd( x, sLockFile, sLockCmd, 'P', po );
+    MyFile->Close();
+    delete MyFile;
+  }
+  #elif defined (HAVE_CREATEPROCESSW_F)
+
+    STARTUPINFO si;
+    PROCESS_INFORMATION pi;
+    ZeroMemory( &si, sizeof( si ));
+    si.cb = sizeof( si );
+    ZeroMemory( &pi, sizeof( pi ));
+
+    xbString strCmdLine = "xb_test_lock2";
+    if( argCnt > 1 ){
+      strCmdLine += " ";
+      strCmdLine += av[1];
+    }
+
+    char sCmdLineBuf[25];
+    memset( sCmdLineBuf, 0x00, 25 );
+    for( xbUInt32 i = 0; i < strCmdLine.Len(); i++ )
+      sCmdLineBuf[i] = strCmdLine[i+1];
+
+    if( !CreateProcess( NULL, sCmdLineBuf, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi )){
+      sMsg.Sprintf( "Program [%s] error in CreateProcess call.  Processing aborted" );
+      #ifdef XB_LOGGING_SUPPORT
+      x.WriteLogMessage( sMsg );
+      #endif
+      std::cout << sMsg.Str() << "\n";
+      iRc -=1;
+    } else {
+
+      xbInt16 iLoopCtr = 0;
+
+      try{
+        #ifdef XB_LOGGING_SUPPORT
+        sMsg.Sprintf( "Program [%s] Parent task issuing START command", av[0] );
+        x.WriteLogMessage( sMsg );
+        #endif
+
+
+        sLockCmd = "START";
+        SetCmd( x, sLockFile, sLockCmd, 'P', po );
+        sResult = "";
+
+        GetCmd( x, sLockFile, sResult, 'P', po );
+        while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 10 ){
+          GetCmd( x, sLockFile, sResult, 'P', po );
+          x.xbSleep( 250 );
+          iLoopCtr++;
+        }
+
+        #ifdef XB_LOGGING_SUPPORT
+        sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+        x.WriteLogMessage( sMsg );
+        #endif
+
+        // table lock
+        #ifdef XB_LOGGING_SUPPORT
+        sMsg.Sprintf( "Program [%s] Parent task issuing TL command", av[0] );
+        x.WriteLogMessage( sMsg );
+        #endif
+
+        sLockCmd = "TL";
+        SetCmd( x, sLockFile, sLockCmd, 'P', po );
+        sResult = "";
+
+        GetCmd( x, sLockFile, sResult, 'P', po );
+        while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 10 ){
+          GetCmd( x, sLockFile, sResult, 'P', po );
+          x.xbSleep( 250 );		  
+          iLoopCtr++;
+        }
+
+        #ifdef XB_LOGGING_SUPPORT
+        sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+        x.WriteLogMessage( sMsg );
+        #endif
+
+        if( sResult != "OK" ){
+          iErrorStop = 200;
+          iRc2 = -1;
+          throw iRc2;
+        }
+
+        // attempt to lock table, should fail
+        if(( iRc2 = MyFile->Open( "LockTest.DBF" )) != XB_NO_ERROR ){
+          iErrorStop = 210;
+          throw iRc2;
+        }
+
+        if(( iRc2 =  MyFile->LockTable( XB_LOCK )) == XB_NO_ERROR ){
+          iErrorStop = 220;
+          throw iRc2;
+        }
+
+        if( po > 0 ){
+          std::cout << "[PASS] LockTable Test 1\n";
+
+          #ifdef XB_LOGGING_SUPPORT
+          sMsg.Sprintf( "Program [%s] Parent task LockTable Test 1 Success.", av[0] );
+          x.WriteLogMessage( sMsg );
+          #endif
+        }
+
+        // table unlock
+        #ifdef XB_LOGGING_SUPPORT
+        sMsg.Sprintf( "Program [%s] Parent task issuing TU command", av[0] );
+        x.WriteLogMessage( sMsg );
+        #endif
+
+        sLockCmd = "TU";
+        SetCmd( x, sLockFile, sLockCmd, 'P', po );
+        sResult = "";
+
+        GetCmd( x, sLockFile, sResult, 'P', po );
+        while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 10 ){
+          GetCmd( x, sLockFile, sResult, 'P', po );
+          x.xbSleep( 250 );
+          iLoopCtr++;
+        }
+
+        #ifdef XB_LOGGING_SUPPORT
+        sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+        x.WriteLogMessage( sMsg );
+        #endif
+
+        if( sResult != "OK" ){
+          iErrorStop = 230;
+          iRc2 = -1;
+          throw iRc2;
+        }
+
+        if(( iRc2 =  MyFile->LockTable( XB_LOCK )) != XB_NO_ERROR ){
+          iErrorStop = 240;
+          throw iRc2;
+        }
+        if( po > 0 ){
+          std::cout << "[PASS] LockTable Test 2\n";
+          #ifdef XB_LOGGING_SUPPORT
+          sMsg.Sprintf( "Program [%s] Parent task LockTable Test 1 Success.", av[0] );
+          x.WriteLogMessage( sMsg );
+          #endif
+        }
+
+        if(( iRc2 =  MyFile->LockTable( XB_UNLOCK )) != XB_NO_ERROR ){
+          iErrorStop = 250;
+          throw iRc2;
+        }
+
+        /* record lock */
+        #ifdef XB_LOGGING_SUPPORT
+        sMsg.Sprintf( "Program [%s] Parent task issuing RL command", av[0] );
+        x.WriteLogMessage( sMsg );
+        #endif
+
+        sLockCmd = "RL";
+        SetCmd( x, sLockFile, sLockCmd, 'P', po );
+        sResult = "";
+
+        GetCmd( x, sLockFile, sResult, 'P', po );
+        while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 10 ){
+          GetCmd( x, sLockFile, sResult, 'P', po );
+          x.xbSleep( 250 );
+          iLoopCtr++;
+        }
+
+        #ifdef XB_LOGGING_SUPPORT
+        sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+        x.WriteLogMessage( sMsg );
+        #endif
+
+        if( sResult != "OK" ){
+          iErrorStop = 260;
+          iRc2 = -1;
+          throw iRc2;
+        }
+
+        if(( iRc2 =  MyFile->LockRecord( XB_LOCK, 1 )) == XB_NO_ERROR ){
+          iErrorStop = 270;
+          throw iRc2;
+        }
+        if( po > 0 )
+          std::cout << "[PASS] LockRecord Test 1\n";
+
+        /* record unlock */
+        #ifdef XB_LOGGING_SUPPORT
+        sMsg.Sprintf( "Program [%s] Parent task issuing RU command", av[0] );
+        x.WriteLogMessage( sMsg );
+        #endif
+
+        sLockCmd = "RU";
+        SetCmd( x, sLockFile, sLockCmd, 'P', po );
+        sResult = "";
+
+        GetCmd( x, sLockFile, sResult, 'P', po );
+        while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 10 ){
+          GetCmd( x, sLockFile, sResult, 'P', po );
+          x.xbSleep( 250 );
+          iLoopCtr++;
+        }
+
+        #ifdef XB_LOGGING_SUPPORT
+        sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+        x.WriteLogMessage( sMsg );
+        #endif
+
+        if( sResult != "OK" ){
+          iErrorStop = 280;
+          iRc2 = -1;
+          throw iRc2;
+        }
+
+        if(( iRc2 =  MyFile->LockRecord( XB_LOCK, 1 )) != XB_NO_ERROR ){
+          iErrorStop = 290;
+          throw iRc2;
+        }
+
+        std::cout << "[PASS] LockRecord Test 2\n";
+        if(( iRc2 =  MyFile->LockRecord( XB_UNLOCK, 1 )) != XB_NO_ERROR ){
+          iErrorStop = 300;
+          throw iRc2;
+        }
+
+
+        /*     memo lock */
+        #ifdef XB_MEMO_SUPPORT
+        #ifdef XB_LOGGING_SUPPORT
+        sMsg.Sprintf( "Program [%s] Parent task issuing ML command", av[0] );
+        x.WriteLogMessage( sMsg );
+        #endif
+
+        sLockCmd = "ML";
+        SetCmd( x, sLockFile, sLockCmd, 'P', po );
+        sResult = "";
+
+        GetCmd( x, sLockFile, sResult, 'P', po );
+        while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 10 ){
+          GetCmd( x, sLockFile, sResult, 'P', po );
+          x.xbSleep( 250 );
+          iLoopCtr++;
+        }
+
+        #ifdef XB_LOGGING_SUPPORT
+        sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+        x.WriteLogMessage( sMsg );
+        #endif
+
+        if( sResult != "OK" ){
+          iErrorStop = 310;
+          iRc2 = -1;
+          throw iRc2;
+        }
+
+        if(( iRc2 =  MyFile->LockMemo( XB_LOCK )) == XB_NO_ERROR ){
+          iErrorStop = 320;
+          throw iRc2;
+        }
+        if( po > 0 )
+          std::cout << "[PASS] LockMemo Test 1\n";
+
+        /* memo unlock */
+        #ifdef XB_LOGGING_SUPPORT
+        sMsg.Sprintf( "Program [%s] Parent task issuing MU command", av[0] );
+        x.WriteLogMessage( sMsg );
+        #endif
+
+        sLockCmd = "MU";
+        SetCmd( x, sLockFile, sLockCmd, 'P', po );
+        sResult = "";
+
+        GetCmd( x, sLockFile, sResult, 'P', po );
+        while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 10 ){
+          GetCmd( x, sLockFile, sResult, 'P', po );
+          x.xbSleep( 250 );
+          iLoopCtr++;
+        }
+
+        #ifdef XB_LOGGING_SUPPORT
+        sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+        x.WriteLogMessage( sMsg );
+        #endif
+
+        if( sResult != "OK" ){
+          iErrorStop = 330;
+          iRc2 = -1;
+          throw iRc2;
+        }
+
+        if(( iRc2 =  MyFile->LockMemo( XB_LOCK )) != XB_NO_ERROR ){
+          iErrorStop = 340;
+          throw iRc2;
+        }
+
+        std::cout << "[PASS] LockMemo Test 2\n";
+        if(( iRc2 =  MyFile->LockMemo( XB_UNLOCK )) != XB_NO_ERROR ){
+          iErrorStop = 350;
+          throw iRc2;
+        }
+        #endif
+
+        // exit
+        sLockCmd = "EXIT";
+        SetCmd( x, sLockFile, sLockCmd, 'P', po );
+
+      } catch (xbInt16 iRc3 ){
+        if( po > 0 )
+          std::cout << "Parent lock task exiting on failure [" << sLockCmd.Str() << "][" << iErrorStop << "]\n";
+
+        #ifdef XB_LOGGING_SUPPORT
+        sMsg.Sprintf( "Program [%s] Parent task terminating with errors [%s][%d][%d][%d]...", av[0], sLockCmd.Str(), iErrorStop, iLoopCtr, iRc3 );
+        x.WriteLogMessage( sMsg );
+        #endif
+
+        sLockCmd = "EXIT";
+        SetCmd( x, sLockFile, sLockCmd, 'P', po );
+        MyFile->Close();
+        delete MyFile;
+      }
+  }
+
+  #else
+    iRc--;
+    sMsg.Sprintf( "Program [%s] not executed.  Library does not support 'fork' or 'CreateProcess' function call", av[0] );
+    #ifdef XB_LOGGING_SUPPORT
+    x.WriteLogMessage( sMsg );
+    #endif
+    if( po > 0 )
+      std::cout << sMsg.Str() << "\n";
+  #endif
+
+  if( po > 0 || iRc < 0 )
+    fprintf( stdout, "[%s] Total Errors = %d\n", av[0], iRc * -1 );
+
+  #ifdef XB_LOGGING_SUPPORT
+  sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], iRc * -1 );
+  x.WriteLogMessage( sMsg ); 
+  #endif
+
+  return iRc;
+}
+
diff --git a/src/tests/xb_test_lock2.cpp b/src/tests/xb_test_lock2.cpp
new file mode 100755
index 0000000..3dd4b57
--- /dev/null
+++ b/src/tests/xb_test_lock2.cpp
@@ -0,0 +1,208 @@
+/*  xb_test_lock2.cpp
+
+XBase Software Library
+
+Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+
+The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
+
+Email Contact:
+
+    XDB-devel@lists.sourceforge.net
+    XDB-users@lists.sourceforge.net
+
+*/
+
+// This program tests the locking functions
+//  This program is the child process that is called if used
+//  in an environment that supports the CreateProcess library function (ie Windows)
+
+// usage:   xb_test_lock QUITE|NORMAL|VERBOSE
+
+
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+/****************************************************************/
+int main( int argCnt, char **av )
+{
+  xbInt16 iRc = 0;
+  xbInt16 iRc2;
+  xbInt16 po = 1;      /* print option */
+                       /* 0 - QUIET    */
+                       /* 1 - NORMAL   */
+                       /* 2 - VERBOSE  */
+
+  xbBool   bDone       = xbFalse;
+//  xbInt16  iErrorStop  = 0;
+  xbString sLockFile   = "locktest.txt";
+  xbString sLockCmd;
+  xbString sResult;
+  xbInt32  iChildLoop  = 0;
+
+  xbXBase x;
+  xbDbf * MyFile;
+
+  xbBool  bTblOpen     = xbFalse;
+
+  if( argCnt > 1 ) {
+    if( av[1][0] == 'Q' )
+      po = 0;
+    else if( av[1][0] == 'V' )
+      po = 2;
+  }
+
+  #ifdef XB_LOGGING_SUPPORT
+  xbString sLogFileName =  x.GetLogFqFileName().Str();
+
+  sLogFileName.Resize( sLogFileName.Len() - 3 );
+  sLogFileName += "_l2.txt";
+  x.SetLogFileName( sLogFileName );
+  x.EnableMsgLogging();
+  if( po > 0 ){
+    std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+  }
+  xbString sMsg;
+  sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+  x.WriteLogMessage( sMsg );
+  #endif
+
+  x.SetDataDirectory( PROJECT_DATA_DIR );
+  x.EnableMsgLogging();
+  InitTime();
+
+  #ifdef XB_DBF4_SUPPORT
+  MyFile = new xbDbf4( &x );                /* version 4 dbf file */
+  #else
+  MyFile = new xbDbf3( &x );                /* version 3 dbf file */
+  #endif
+
+  x.xbSleep( 250 );
+  while( !bDone ){
+    iRc2 = GetCmd( x, sLockFile, sLockCmd, 'C', po );
+
+    #ifdef XB_LOGGING_SUPPORT
+    if( sLockCmd != "OK" && sLockCmd != "FAIL" ){
+      sMsg.Sprintf( "Program [%s] Child task retrieved command=[%s] RC=[%d]", av[0], sLockCmd.Str(), iRc2 );
+      x.WriteLogMessage( sMsg );
+    }
+    #endif
+
+    if( iRc2 == 0 ){
+
+      if( sLockCmd == "OK" || sLockCmd == "FAIL" )
+        x.xbSleep( 250 );
+
+      else if( sLockCmd == "EXIT" ){
+        bDone = xbTrue;
+
+      } else if( sLockCmd == "START" && bTblOpen ){
+        // came back before the parent task could process the result
+        x.xbSleep( 250 );
+
+      } else {
+
+        if( sLockCmd == "START" ){
+
+          // begin the process
+          iRc2 =  MyFile->Open( "LockTest.DBF" );
+          if( iRc2 != XB_NO_ERROR ){
+            sResult = "FAIL";
+          } else {
+            sResult = "OK";
+            bTblOpen = xbTrue;
+          }
+
+        } else if( sLockCmd == "TL" ){
+          // table lock
+          if(( iRc2 = MyFile->LockTable( XB_LOCK )) != XB_NO_ERROR )
+            sResult = "FAIL";
+          else
+            sResult = "OK";
+
+        } else if( sLockCmd == "TU" ){
+          // table unlock
+          if(( iRc2 = MyFile->LockTable( XB_UNLOCK )) != XB_NO_ERROR )
+            sResult = "FAIL";
+          else
+            sResult = "OK";
+
+        } else if( sLockCmd == "RL" ){
+          // record lock
+          if(( iRc2 = MyFile->LockRecord( XB_LOCK, 1 )) != XB_NO_ERROR )
+            sResult = "FAIL";
+          else
+            sResult = "OK";
+
+
+        } else if( sLockCmd == "RU" ){
+          // record unlock
+          if(( iRc2 = MyFile->LockRecord( XB_UNLOCK, 1 )) != XB_NO_ERROR )
+            sResult = "FAIL";
+          else
+            sResult = "OK";
+
+        } else if( sLockCmd == "ML" ){
+          // memo lock
+          #ifdef XB_MEMO_SUPPORT
+          if(( iRc2 = MyFile->LockMemo( XB_LOCK )) != XB_NO_ERROR )
+            sResult = "FAIL";
+          else
+            sResult = "OK";
+          #else
+          sLockCmd = "OK";
+          #endif
+
+        } else if( sLockCmd == "MU" ){
+          // memo unlock
+          #ifdef XB_MEMO_SUPPORT
+          if(( iRc2 = MyFile->LockMemo( XB_UNLOCK )) != XB_NO_ERROR )
+            sResult = "FAIL";
+          else
+            sResult = "OK";
+          #else
+          sLockCmd = "OK";
+          #endif
+        }
+        #ifdef XB_LOGGING_SUPPORT
+        sMsg.Sprintf( "Program [%s] Child task [%s] Result [%s] RC = [%d]", av[0], sLockCmd.Str(), sResult.Str(), iRc2 );
+        x.WriteLogMessage( sMsg );
+        #endif
+        SetCmd( x, sLockFile, sResult, 'C', po );
+      }
+    } else {
+      iRc = iRc2;
+      bDone = xbTrue;
+    }
+
+    // std::cout << "clc [" << iChildLoop++ << "][" << bDone << "][" << sLockCmd << "]\n";
+    x.xbSleep( 250 );
+    if( iChildLoop > 10 )
+      bDone = xbTrue;
+  }
+  MyFile->Close();
+  delete MyFile;
+  if( po > 0 )
+    std::cout << "Exiting child\n";
+
+  remove( sLockFile );
+  #ifdef XB_LOGGING_SUPPORT
+  sMsg.Sprintf( "Program [%s] Child task terminating", av[0] );
+  x.WriteLogMessage( sMsg );
+  #endif
+
+  if( po > 0 || iRc < 0 )
+    fprintf( stdout, "Total Errors = %d\n", iRc * -1 );
+
+  #ifdef XB_LOGGING_SUPPORT
+  sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], iRc * -1 );
+  x.WriteLogMessage( sMsg );
+  #endif
+
+  ExitProcess( iRc );
+}
+
diff --git a/src/tests/xb_test_log.cpp b/src/tests/xb_test_log.cpp
new file mode 100755
index 0000000..613b7dd
--- /dev/null
+++ b/src/tests/xb_test_log.cpp
@@ -0,0 +1,88 @@
+/*  xb_test_log.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+
+The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
+
+Email Contact:
+
+    XDB-devel@lists.sourceforge.net
+    XDB-users@lists.sourceforge.net
+
+*/
+
+// This program tests the class xbLog
+
+// usage:   xb_test_log QUITE|NORMAL|VERBOSE
+
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+
+
+int main( int argCnt, char **av )
+{
+  int rc = 0;
+
+#ifdef XB_LOGGING_SUPPORT
+
+
+  int po = 1;          /* print option */
+                       /* 0 - QUIET    */
+                       /* 1 - NORMAL   */
+                       /* 2 - VERBOSE  */
+
+  if( argCnt > 1 ) {
+    if( av[1][0] == 'Q' )
+      po = 0;
+    else if( av[1][0] == 'V' )
+      po = 2;
+  }
+
+  xbXBase x;
+  x.EnableMsgLogging();
+  InitTime();
+  if( po ){
+    std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+  }
+  xbString sMsg;
+  sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+  x.WriteLogMessage( sMsg );
+
+
+  xbString sNewLogFileName = "Logfile2.txt";
+  sMsg.Sprintf( "Switching to logfile [%s]", sNewLogFileName.Str() );
+  x.WriteLogMessage( sMsg );
+
+
+  x.DisableMsgLogging();
+  rc += TestMethod( po, "Set/Get Log Status()", x.GetLogStatus(), xbFalse );
+  x.SetLogFileName( sNewLogFileName );
+  x.EnableMsgLogging();
+
+  rc += TestMethod( po, "Set/Get Log Status()", x.GetLogStatus(), 1 );
+  rc += TestMethod( po,"WriteLogMessage()", x.WriteLogMessage( "Test log message........" ), XB_NO_ERROR );
+
+
+  sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], rc * -1 );
+  x.WriteLogMessage( sMsg );
+
+  if( po > 0 || rc < 0 )
+    fprintf( stdout, "Total Errors = %d\n", rc * -1 );
+
+
+  #endif         /* XB_LOGGING_SUPPORT */
+
+
+  return rc;
+}
+
+
+
+
diff --git a/src/tests/xb_test_mdx.cpp b/src/tests/xb_test_mdx.cpp
new file mode 100755
index 0000000..9351e4d
--- /dev/null
+++ b/src/tests/xb_test_mdx.cpp
@@ -0,0 +1,243 @@
+/* xb_test_ndx.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+
+The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
+
+Email Contact:
+
+    XDB-devel@lists.sourceforge.net
+    XDB-users@lists.sourceforge.net
+
+*/
+
+// This program tests the class xbIxNdx
+
+// usage:   xb_test_ndx QUITE|NORMAL|VERBOSE
+
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+int main( int argCnt, char **av )
+{
+  int iRc = 0;
+  int iRc2;
+  int iPo = 1;          /* print option */
+                       /* 0 - QUIET    */
+                       /* 1 - NORMAL   */
+                       /* 2 - VERBOSE  */
+
+  xbString sMsg;
+  char c;
+  xbString s;
+
+  if( argCnt > 1 ) {
+    if( av[1][0] == 'Q' )
+      iPo = 0;
+    else if( av[1][0] == 'V' )
+      iPo = 2;
+  }
+
+
+  xbSchema MyV4Record[] = 
+  {
+    { "CITY",   XB_CHAR_FLD,    100, 0 },
+    { "STATE",  XB_CHAR_FLD,      2, 0 },
+    { "ZIP",    XB_NUMERIC_FLD,   9, 0 },
+    { "DATE1",  XB_DATE_FLD,      8, 0  },
+    { "",0,0,0 }
+  };
+
+
+  xbXBase x;
+
+#ifdef XB_LOGGING_SUPPORT
+  x.EnableMsgLogging();
+  if( iPo ){
+    std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+  }
+  sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+  x.WriteLogMessage( sMsg );
+#endif
+
+  x.SetDataDirectory( PROJECT_DATA_DIR );
+  x.EnableMsgLogging();
+  x.SetMultiUser( false );
+  InitTime();
+
+  if( iPo > 0 )
+    std::cout << "Default Data Directory is [" << x.GetDataDirectory().Str() << "]" << std::endl;
+
+
+  xbFile f( &x );
+  xbIx *pIx;
+  void *pTag;
+  xbDate dt = "19890209";
+  xbString sKey;
+
+  xbDbf *V4DbfX1 = new xbDbf4( &x );
+
+
+  iRc2 = V4DbfX1->CreateTable( "TMDXDB01.DBF", "TestMdxX2", MyV4Record, XB_OVERLAY, XB_MULTI_USER );
+  iRc += TestMethod( iPo, "CreateTable(1)", iRc2, 0 );
+
+  /*
+   CreateTag( const xbString &sIxType, const xbString &sName, const xbString &sKey, const xbString &sFilter, 
+           xbInt16 iDescending, xbInt16 iUnique, xbInt16 iOverLay, xbIx **xbIxOut, void **vpTagOut );
+  */
+
+  iRc2 = V4DbfX1->CreateTag( "MDX", "CITY_TAGA",  "CITY", "", 0, 0, XB_OVERLAY, &pIx, &pTag );
+  iRc += TestMethod( iPo, "CreateTag(1)", iRc2, 0 );
+
+  iRc2 = V4DbfX1->CreateTag( "MDX", "ZIP_TAG",   "ZIP", "",  xbTrue, 0, XB_OVERLAY, &pIx, &pTag );
+  iRc += TestMethod( iPo, "CreateTag(2)", iRc2, 0 );
+
+  iRc2 = V4DbfX1->CreateTag( "MDX", "DATE_TAG",  "DATE1", "", 0, xbTrue, XB_OVERLAY, &pIx, &pTag );
+  iRc += TestMethod( iPo, "CreateTag(3)", iRc2, 0 );
+
+
+  // std::cout << "Cur Tag Name = " << V4DbfX1->GetCurTagName().Str() << "\n";
+
+ // xbDouble d = 4000;
+//  iRc2 = V4DbfX1->Find( d );
+//  std::cout << iRc2 << "\n";
+
+
+// something in th following block of code causing issues
+
+  xbInt32 uZip = 10000;
+  for( xbUInt16 i = 0; i < 35; i++ ){
+   for( xbUInt16 j = 0; j < 14; j++ ){ 
+
+      c = j + 65;
+      s = c;
+      s.PadRight( c, (xbUInt32) i + 1 );
+      //std::cout << "*********** adding s=[" << s.Str() << "] length = " << s.Len() << "\n";
+      iRc2 = V4DbfX1->BlankRecord();
+      if( iRc2 != XB_NO_ERROR )
+        iRc += TestMethod( iPo, "BlankRecord()", iRc2, XB_NO_ERROR );
+
+      iRc2 = V4DbfX1->PutField( "CITY", s );
+      if( iRc2 != XB_NO_ERROR )
+        iRc += TestMethod( iPo, "PutField()", iRc2, XB_NO_ERROR );
+
+      iRc2 = V4DbfX1->PutLongField( "ZIP", uZip++ );
+      if( iRc2 != XB_NO_ERROR )
+        iRc += TestMethod( iPo, "PutField()", iRc2, XB_NO_ERROR );
+
+      iRc2 = V4DbfX1->PutDateField( "DATE1", dt );
+      dt++;
+      if( iRc2 != XB_NO_ERROR )
+        iRc += TestMethod( iPo, "PutField()", iRc2, XB_NO_ERROR );
+
+      iRc2 = V4DbfX1->AppendRecord();
+      if( iRc2 != XB_NO_ERROR )
+        iRc += TestMethod( iPo, "AppendRecord()", iRc2, XB_NO_ERROR );
+
+      iRc2 = V4DbfX1->Commit();
+      if( iRc2 != XB_NO_ERROR )
+        iRc += TestMethod( iPo, "Commit()", iRc2, XB_NO_ERROR );
+    }
+  }
+
+
+  iRc += TestMethod( iPo, "CheckTagIntegrity()", V4DbfX1->CheckTagIntegrity( 1, 2 ), XB_NO_ERROR );
+
+  // attempt to add a dup key, should fail with XB_KEY_NOT_UNIQUE
+  iRc2 = V4DbfX1->BlankRecord();
+  if( iRc2 != XB_NO_ERROR )
+    iRc += TestMethod( iPo, "BlankRecord()", iRc2, XB_NO_ERROR );
+
+  iRc2 = V4DbfX1->PutField( "CITY", "Tampa" );
+  if( iRc2 != XB_NO_ERROR )
+    iRc += TestMethod( iPo, "PutField()", iRc2, XB_NO_ERROR );
+
+  iRc2 = V4DbfX1->PutLongField( "ZIP", uZip++ );
+  if( iRc2 != XB_NO_ERROR )
+    iRc += TestMethod( iPo, "PutField()", iRc2, XB_NO_ERROR );
+
+  dt.Set( "19890209" );
+  iRc2 = V4DbfX1->PutDateField( "DATE1", dt );
+  dt++;
+  if( iRc2 != XB_NO_ERROR )
+    iRc += TestMethod( iPo, "PutField()", iRc2, XB_NO_ERROR );
+
+  iRc2 = V4DbfX1->AppendRecord();
+  if( iRc2 != XB_KEY_NOT_UNIQUE )
+    iRc += TestMethod( iPo, "AppendRecord()", iRc2, XB_NO_ERROR );
+
+  iRc2 = V4DbfX1->Abort();
+  if( iRc2 != XB_NO_ERROR )
+    iRc += TestMethod( iPo, "Abort()", iRc2, XB_NO_ERROR );
+
+  iRc += TestMethod( iPo, "DeleteTag()", V4DbfX1->DeleteTag( "MDX", "CITY_TAGA" ), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "CheckTagIntegrity()", V4DbfX1->CheckTagIntegrity( 1, 2 ), XB_NO_ERROR );
+
+  iRc2 = V4DbfX1->CreateTag( "MDX", "CITY_TAGF",  "CITY", ".NOT. DELETED()", 0, 0, XB_OVERLAY, &pIx, &pTag );
+  iRc += TestMethod( iPo, "CreateTag(4)", iRc2, 0 );
+
+  iRc2 = V4DbfX1->SetCurTag( "CITY_TAGF" );
+  iRc += TestMethod( iPo, "SetCurTag()", iRc2, XB_NO_ERROR );
+  iRc += TestMethod( iPo, "GetCurTagName()", V4DbfX1->GetCurTagName().Str(), "CITY_TAGF", 9 );
+
+  iRc += TestMethod( iPo, "CheckTagIntegrity()", V4DbfX1->CheckTagIntegrity( 1, 2 ), XB_INVALID_INDEX );
+
+  iRc2 = V4DbfX1->Reindex( 0 );
+  iRc += TestMethod( iPo, "Reindex( 0 )", iRc2, XB_NO_ERROR );
+  iRc += TestMethod( iPo, "CheckTagIntegrity()", V4DbfX1->CheckTagIntegrity( 1, 2 ), XB_NO_ERROR );
+
+  iRc += TestMethod( iPo, "GetCurTagName()", V4DbfX1->GetCurTagName().Str(), "CITY_TAGF", 9 );
+
+  iRc2 = V4DbfX1->Reindex( 1 );
+  iRc += TestMethod( iPo, "Reindex( 1 )", iRc2, XB_NO_ERROR );
+  iRc += TestMethod( iPo, "CheckTagIntegrity()", V4DbfX1->CheckTagIntegrity( 1, 2 ), XB_NO_ERROR );
+
+  // delete everything, all keys should be removed from the filtered index
+  iRc += TestMethod( iPo, "DeleteAll(0)", V4DbfX1->DeleteAll( 0 ), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "Commit()", V4DbfX1->Commit(), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "CheckTagIntegrity()", V4DbfX1->CheckTagIntegrity( 1, 2 ), XB_NO_ERROR );
+
+  // undelete everything, all keys should be added back into the filtered index
+  iRc += TestMethod( iPo, "DeleteAll(1)", V4DbfX1->DeleteAll( 1 ), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "Commit()", V4DbfX1->Commit(), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "CheckTagIntegrity()", V4DbfX1->CheckTagIntegrity( 1, 2 ), XB_NO_ERROR );
+
+  // std::cout << "Cur Tag Name = " << V4DbfX1->GetCurTagName().Str() << "\n";
+  sKey = "abc";
+  iRc += TestMethod( iPo, "Find()", V4DbfX1->Find( sKey ), XB_NOT_FOUND );
+  sKey = "EEEEE";
+  iRc += TestMethod( iPo, "Find()", V4DbfX1->Find( sKey ), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4DbfX1->GetCurRecNo(), (xbInt32) 61 );
+
+  iRc += TestMethod( iPo, "GetNextKey()", V4DbfX1->GetNextKey(), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4DbfX1->GetCurRecNo(), (xbInt32) 75 );
+
+  iRc += TestMethod( iPo, "GetPrevKey()", V4DbfX1->GetPrevKey(), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4DbfX1->GetCurRecNo(), (xbInt32) 61 );
+
+  iRc += TestMethod( iPo, "GetLastKey()", V4DbfX1->GetLastKey(), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4DbfX1->GetCurRecNo(), (xbInt32) 490 );
+
+  iRc += TestMethod( iPo, "GetFirstKey()", V4DbfX1->GetFirstKey(), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4DbfX1->GetCurRecNo(), (xbInt32) 1 );
+
+
+   x.CloseAllTables();
+   delete V4DbfX1;
+
+   if( iPo > 0 || iRc < 0 )
+    fprintf( stdout, "Total Errors = %d\n", iRc * -1 );
+
+#ifdef XB_LOGGING_SUPPORT
+  sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], iRc * -1 );
+  x.WriteLogMessage( sMsg );
+#endif
+
+  return iRc;
+}
diff --git a/src/tests/xb_test_ndx.cpp b/src/tests/xb_test_ndx.cpp
new file mode 100755
index 0000000..31306c0
--- /dev/null
+++ b/src/tests/xb_test_ndx.cpp
@@ -0,0 +1,330 @@
+/* xb_test_ndx.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+
+The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
+
+Email Contact:
+
+    XDB-devel@lists.sourceforge.net
+    XDB-users@lists.sourceforge.net
+
+*/
+
+// This program tests the class xbIxNdx
+
+// usage:   xb_test_ndx QUITE|NORMAL|VERBOSE
+
+
+
+// fix me - this program needs to test GetUnique
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+
+int main( int argCnt, char **av )
+{
+  int iRc = 0;
+  int iRc2 = 0;
+  int iPo = 1;          /* print option */
+                       /* 0 - QUIET    */
+                       /* 1 - NORMAL   */
+                       /* 2 - VERBOSE  */
+
+  if( argCnt > 1 ) {
+    if( av[1][0] == 'Q' )
+      iPo = 0;
+    else if( av[1][0] == 'V' )
+      iPo = 2;
+  }
+
+
+  xbSchema MyV3Record[] = 
+  {
+    { "CFLD",       XB_CHAR_FLD,     30, 0 },
+    { "DFLD",       XB_DATE_FLD,      8, 0 },
+    { "NFLD",       XB_NUMERIC_FLD,  12, 0 },
+    { "",0,0,0 }
+  };
+
+
+  xbXBase x;
+#ifdef XB_LOGGING_SUPPORT
+  x.EnableMsgLogging();
+  if( iPo ){
+    std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+  }
+  xbString sMsg;
+  sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+  x.WriteLogMessage( sMsg );
+  x.SetLogSize( 1000000 );
+#endif
+
+  x.SetDataDirectory( PROJECT_DATA_DIR );
+  x.EnableMsgLogging();
+//  x.DisableDefaultAutoLock();
+  InitTime();
+
+  char c;
+  xbString s;
+  xbInt32 lRecCnt = 0;
+  iRc = 0;
+
+
+  if( iPo > 0 )
+    std::cout << "Default Data Directory is [" << x.GetDataDirectory().Str() << "]" << std::endl;
+
+  xbDbf *V3Dbf = new xbDbf3( &x );
+
+  xbIx *ixPtr;
+  void *ndx;
+
+  iRc2 = V3Dbf->CreateTable( "TestNdx.DBF", "TestNdx", MyV3Record, XB_OVERLAY, XB_MULTI_USER );
+  iRc += TestMethod( iPo, "CreateTable()", (xbInt32) iRc2, XB_NO_ERROR );
+
+  if( iRc2 )
+    x.DisplayError( iRc2 );
+
+
+  iRc2 = V3Dbf->CreateTag( "NDX", "TestNdxC.NDX", "CFLD", "", 0, 0, XB_OVERLAY, &ixPtr, &ndx );
+  iRc += TestMethod( iPo, "CreateTag()", (xbInt32) iRc2, XB_NO_ERROR );
+  if( iRc2 )
+    x.DisplayError( iRc2 );
+
+  iRc2 = V3Dbf->AssociateIndex( "NDX", "TestNdxC.NDX", 0 );
+  iRc += TestMethod( iPo, "Associate()", (xbInt32) iRc2, XB_NO_ERROR );
+
+  iRc2 = V3Dbf->CreateTag( "NDX", "TestNdxD.NDX", "DFLD", "", 0, 0, XB_OVERLAY, &ixPtr, &ndx );
+  iRc += TestMethod( iPo, "CreateTag()", (xbInt32) iRc2, XB_NO_ERROR );
+  if( iRc2 )
+    x.DisplayError( iRc2 );
+
+  iRc2 = V3Dbf->AssociateIndex( "NDX", "TestNdxD.NDX", 0 );
+  iRc += TestMethod( iPo, "Associate()", (xbInt32) iRc2, XB_NO_ERROR );
+
+  iRc2 = V3Dbf->CreateTag( "NDX", "TestNdxN.NDX", "NFLD", "", 0, 0, XB_OVERLAY, &ixPtr, &ndx );
+  iRc += TestMethod( iPo, "CreateTag()", (xbInt32) iRc2, XB_NO_ERROR );
+  if( iRc2 )
+    x.DisplayError( iRc2 );
+
+  iRc2 = V3Dbf->AssociateIndex( "NDX", "TestNdxN.NDX", 0 );
+  iRc += TestMethod( iPo, "Associate()", (xbInt32) iRc2, XB_NO_ERROR );
+
+
+  iRc += TestMethod( iPo, "GetCurTagName()", V3Dbf->GetCurTagName().Str(), "TestNdxC", 8 );
+  iRc += TestMethod( iPo, "SetCurTag()", V3Dbf->SetCurTag( "TestNdxN" ), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "GetCurTagName()", V3Dbf->GetCurTagName().Str(), "TestNdxN", 8 );
+  xbDouble dbl = 100;
+  iRc += TestMethod( iPo, "Find( 100 )", V3Dbf->Find( dbl ), XB_NOT_FOUND );
+
+  iRc += TestMethod( iPo, "SetCurTag()", V3Dbf->SetCurTag( "TestNdxD" ), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "GetCurTagName()", V3Dbf->GetCurTagName().Str(), "TestNdxD", 8 );
+  xbDate dt;
+  iRc += TestMethod( iPo, "Find( dt )", V3Dbf->Find( dt ), XB_NOT_FOUND );
+
+  iRc += TestMethod( iPo, "GetFirstKey()",    ixPtr->GetFirstKey(), XB_EMPTY );
+  iRc += TestMethod( iPo, "GetNextKey()",     ixPtr->GetFirstKey(), XB_EMPTY );
+  iRc += TestMethod( iPo, "GetLasttKey()",    ixPtr->GetLastKey(),  XB_EMPTY );
+  iRc += TestMethod( iPo, "GetPrevKey()",     ixPtr->GetPrevKey(),  XB_EMPTY );
+  iRc += TestMethod( iPo, "FindKey()",        ixPtr->FindKey( NULL, "19611101", 8, 0 ), XB_NOT_FOUND );
+
+  iRc += TestMethod( iPo, "BlankRecord()",    V3Dbf->BlankRecord(),                     XB_NO_ERROR );
+  iRc += TestMethod( iPo, "Putfield()",       V3Dbf->PutField( "CFLD", "AAA" ),         XB_NO_ERROR );
+  iRc += TestMethod( iPo, "Putfield()",       V3Dbf->PutField( "DFLD", "19611109" ),    XB_NO_ERROR );
+  iRc += TestMethod( iPo, "PutfieldDouble()", V3Dbf->PutDoubleField( "NFLD", 50 ), XB_NO_ERROR );
+
+  iRc += TestMethod( iPo, "AppendRecord()",   V3Dbf->AppendRecord(),                    XB_NO_ERROR );
+
+  xbDate d( "19890209" );
+
+  //for( xbUInt16 i = 0; i < 35 && iRc == XB_NO_ERROR; i++ ){
+  for( xbUInt16 i = 0; i < 2 && iRc == XB_NO_ERROR; i++ ){
+    for( xbUInt16 j = 0; j < 35 && iRc == XB_NO_ERROR; j++ ){ 
+      c = j + 65;
+      s = c;
+      s.PadRight( c, (xbUInt32) i + 1 );
+      V3Dbf->BlankRecord();
+      V3Dbf->PutField( "CFLD", s );
+      V3Dbf->PutLongField( "NFLD", ++lRecCnt );
+      V3Dbf->PutField( "DFLD", d.Str() );
+      d++;
+
+      iRc = V3Dbf->AppendRecord();
+    }
+  }
+
+  iRc += TestMethod( iPo, "SetCurTag()", V3Dbf->SetCurTag( "TestNdxN" ), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "GetCurTagName()", V3Dbf->GetCurTagName().Str(), "TestNdxN", 8 );
+
+  dbl = 55.0;
+  iRc += TestMethod( iPo, "Find( 55.0 )", V3Dbf->Find( dbl ), XB_NO_ERROR );
+
+  iRc += TestMethod( iPo, "SetCurTag()", V3Dbf->SetCurTag( "TestNdxC" ), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "GetCurTagName()", V3Dbf->GetCurTagName().Str(), "TestNdxC", 8 );
+
+  s = "AAA";
+  iRc += TestMethod( iPo, "Find( 'AAA' )", V3Dbf->Find( s ), XB_NO_ERROR );
+
+  s = "AzAA";
+  iRc += TestMethod( iPo, "Find( 'AzAA' )", V3Dbf->Find( s ), XB_NOT_FOUND );
+
+  iRc += TestMethod( iPo, "SetCurTag()", V3Dbf->SetCurTag( "TestNdxD" ), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "GetCurTagName()", V3Dbf->GetCurTagName().Str(), "TestNdxD", 8 );
+
+  std::cout << d.Str() << "\n";
+  iRc += TestMethod( iPo, "Find( '19890420' )", V3Dbf->Find(  d ), XB_NOT_FOUND );
+
+  V3Dbf->GetRecord( 26 );
+  V3Dbf->PutField( "CFLD", "AAA" );
+  V3Dbf->PutRecord( 26 );
+
+  V3Dbf->GetRecord( 14 );
+  V3Dbf->PutField( "CFLD", "AAAA" );
+  V3Dbf->PutRecord( 14 );
+
+  V3Dbf->GetRecord( 11 );
+  V3Dbf->PutField( "CFLD", "III" );
+  V3Dbf->PutRecord( 11 );
+
+  V3Dbf->GetRecord( 25 );
+  V3Dbf->PutField( "CFLD", "DDD" );
+  V3Dbf->PutRecord( 25 );
+
+  V3Dbf->GetRecord( 12 );
+  V3Dbf->PutField( "CFLD", "EEE" );
+  V3Dbf->PutRecord( 12 );
+
+  V3Dbf->GetRecord( 26 );
+  V3Dbf->PutField( "CFLD", "CCC" );
+  V3Dbf->PutRecord( 26 );
+
+  V3Dbf->GetRecord( 13 );
+  V3Dbf->PutField( "CFLD", "CCCC" );
+  V3Dbf->PutRecord( 13 );
+
+  V3Dbf->GetRecord( 27 );
+  V3Dbf->PutField( "CFLD", "AAA" );
+  V3Dbf->PutRecord( 27 );
+
+  V3Dbf->GetRecord( 28 );
+  V3Dbf->PutField( "CFLD", "CCC" );
+  V3Dbf->PutRecord( 28 );
+
+  V3Dbf->GetRecord( 24 );
+  V3Dbf->PutField( "CFLD", "FFF" );
+  V3Dbf->PutRecord( 24 );
+
+  V3Dbf->GetRecord( 10 );
+  V3Dbf->PutField( "CFLD", "HHH" );
+  V3Dbf->PutRecord( 10 );
+
+
+  for( xbUInt16 i = 0; i < 35 && iRc == XB_NO_ERROR; i++ ){
+    for( xbUInt16 j = 0; j < 14 && iRc == XB_NO_ERROR; j++ ){ 
+      c = j + 65;
+      s = c;
+      s.PadRight( c, (xbUInt32) i + 1 );
+      V3Dbf->BlankRecord();
+      V3Dbf->PutField( "CFLD", s );
+      V3Dbf->PutLongField( "NFLD", ++lRecCnt );
+      V3Dbf->PutField( "DFLD", d.Str() );
+      d++;
+      iRc = V3Dbf->AppendRecord();
+    }
+  }
+
+  for( xbUInt16 i = 0; i < 2 && iRc == XB_NO_ERROR; i++ ){
+    for( xbUInt16 j = 0; j < 14 && iRc == XB_NO_ERROR; j++ ){ 
+      c = j + 65;
+      s = c;
+      s.PadRight( c, (xbUInt32) i + 1 );
+
+      V3Dbf->BlankRecord();
+      V3Dbf->PutField( "CFLD", s );
+      V3Dbf->PutLongField( "NFLD", ++lRecCnt );
+      V3Dbf->PutField( "DFLD", d.Str() );
+      d++;
+
+      iRc = V3Dbf->AppendRecord();
+    }
+  }
+
+  V3Dbf->GetRecord( 26 );
+  V3Dbf->PutField( "CFLD", "AAA" );
+  V3Dbf->PutRecord( 26 );
+
+  V3Dbf->GetRecord( 14 );
+  V3Dbf->PutField( "CFLD", "AAAA" );
+  V3Dbf->PutRecord( 14 );
+
+  V3Dbf->GetRecord( 11 );
+  V3Dbf->PutField( "CFLD", "III" );
+  V3Dbf->PutRecord( 11 );
+
+  V3Dbf->GetRecord( 25 );
+  V3Dbf->PutField( "CFLD", "DDD" );
+  V3Dbf->PutRecord( 25 );
+
+  V3Dbf->GetRecord( 12 );
+  V3Dbf->PutField( "CFLD", "EEE" );
+  V3Dbf->PutRecord( 12 );
+
+  V3Dbf->GetRecord( 26 );
+  V3Dbf->PutField( "CFLD", "CCC" );
+  V3Dbf->PutRecord( 26 );
+
+  V3Dbf->GetRecord( 13 );
+  V3Dbf->PutField( "CFLD", "CCCC" );
+  V3Dbf->PutRecord( 13 );
+
+  V3Dbf->GetRecord( 27 );
+  V3Dbf->PutField( "CFLD", "AAA" );
+  V3Dbf->PutRecord( 27 );
+
+  V3Dbf->GetRecord( 28 );
+  V3Dbf->PutField( "CFLD", "CCC" );
+  V3Dbf->PutRecord( 28 );
+
+  V3Dbf->GetRecord( 24 );
+  V3Dbf->PutField( "CFLD", "FFF" );
+  V3Dbf->PutRecord( 24 );
+
+  V3Dbf->GetRecord( 10 );
+  V3Dbf->PutField( "CFLD", "HHH" );
+  V3Dbf->PutRecord( 10 );
+
+  // just in case there are any issues outstanding
+  V3Dbf->Abort();
+
+  xbIxList *ixl = V3Dbf->GetIxList();
+  xbIxNdx *ix;
+  xbString sTagName;
+  while( ixl ){
+    if( *ixl->sFmt == "NDX" ){
+      ix = (xbIxNdx *) ixl->ix;
+      //ix->GetTagName( 0, sTagName );
+      sMsg.Sprintf( "CheckTagIntegrity() - [%s]", ix->GetTagName(ix->GetCurTag()).Str());
+      iRc += TestMethod( iPo, sMsg, ix->CheckTagIntegrity( ix->GetCurTag(), 2 ), XB_NO_ERROR );
+      ixl = ixl->next;
+    }
+  }
+
+  iRc += TestMethod( iPo, "Close()", V3Dbf->Close(), XB_NO_ERROR );
+  delete V3Dbf;
+
+  if( iPo > 0 || iRc < 0 )
+    fprintf( stdout, "Total Errors = %d\n", iRc * -1 );
+
+#ifdef XB_LOGGING_SUPPORT
+  sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], iRc * -1 );
+  x.WriteLogMessage( sMsg, 2 );
+#endif
+
+  return iRc;
+}
diff --git a/src/tests/xb_test_ndx2.cpp b/src/tests/xb_test_ndx2.cpp
new file mode 100755
index 0000000..f406b05
--- /dev/null
+++ b/src/tests/xb_test_ndx2.cpp
@@ -0,0 +1,145 @@
+/* xb_test_ndx2.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014, 2022 Gary A Kunkel
+
+The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
+
+Email Contact:
+
+    xb64-devel@lists.sourceforge.net
+    xb64-users@lists.sourceforge.net
+
+*/
+
+// This program tests the class xbIxNdx
+
+// usage:   xb_test_ndx QUITE|NORMAL|VERBOSE
+
+
+
+// fix me - this program needs to test GetUnique
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+
+int main( int argCnt, char **av )
+{
+  int iRc = 0;
+  int iRc2 = 0;
+  int po = 1;          /* print option */
+                       /* 0 - QUIET    */
+                       /* 1 - NORMAL   */
+                       /* 2 - VERBOSE  */
+
+  if( argCnt > 1 ) {
+    if( av[1][0] == 'Q' )
+      po = 0;
+    else if( av[1][0] == 'V' )
+      po = 2;
+  }
+
+
+  xbSchema MyV3Record[] = 
+  {
+    { "CFLD",       XB_CHAR_FLD,     30, 0 },
+    { "DFLD",       XB_DATE_FLD,      8, 0 },
+    { "NFLD",       XB_NUMERIC_FLD,  12, 0 },
+    { "",0,0,0 }
+  };
+
+
+  xbXBase x;
+#ifdef XB_LOGGING_SUPPORT
+  x.EnableMsgLogging();
+  if( po ){
+    std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+  }
+  xbString sMsg;
+  sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+  x.WriteLogMessage( sMsg );
+  x.SetLogSize( 1000000 );
+#endif
+
+  x.SetDataDirectory( PROJECT_DATA_DIR );
+  x.EnableMsgLogging();
+//  x.DisableDefaultAutoLock();
+
+  x.SetUniqueKeyOpt( XB_EMULATE_DBASE );
+  InitTime();
+  xbString s;
+  iRc = 0;
+
+  if( po > 0 )
+    std::cout << "Default Data Directory is [" << x.GetDataDirectory().Str() << "]" << std::endl;
+
+  xbDbf *V3Dbf = new xbDbf3( &x );
+  xbIx *ixPtr;
+  void *ndx;
+
+  iRc2 = V3Dbf->CreateTable( "TestNdx.DBF", "TestNdx", MyV3Record, XB_OVERLAY, XB_MULTI_USER );
+  iRc += TestMethod( po, "CreateTable()", (xbInt32) iRc2, XB_NO_ERROR );
+
+  if( iRc2 )
+    x.DisplayError( iRc2 );
+
+  iRc2 = V3Dbf->CreateTag( "NDX", "TestNdxC.NDX", "CFLD", "", 0, xbTrue, XB_OVERLAY, &ixPtr, &ndx );
+  iRc += TestMethod( po, "CreateTag()", (xbInt32) iRc2, XB_NO_ERROR );
+  if( iRc2 )
+    x.DisplayError( iRc2 );
+
+  iRc2 = V3Dbf->AssociateIndex( "NDX", "TestNdxC.NDX", 0 );
+  iRc += TestMethod( po, "Associate()", (xbInt32) iRc2, XB_NO_ERROR );
+
+
+  iRc += TestMethod( po, "BlankRecord()",    V3Dbf->BlankRecord(),                     XB_NO_ERROR );
+  iRc += TestMethod( po, "Putfield()",       V3Dbf->PutField( "CFLD", "AAA" ),         XB_NO_ERROR );
+  iRc += TestMethod( po, "Putfield()",       V3Dbf->PutField( "DFLD", "19611109" ),    XB_NO_ERROR );
+  iRc += TestMethod( po, "PutfieldDouble()", V3Dbf->PutDoubleField( "NFLD", 50 ), XB_NO_ERROR );
+  iRc += TestMethod( po, "AppendRecord()",   V3Dbf->AppendRecord(),                    XB_NO_ERROR );
+
+
+  iRc += TestMethod( po, "BlankRecord()",    V3Dbf->BlankRecord(),                     XB_NO_ERROR );
+  iRc += TestMethod( po, "Putfield()",       V3Dbf->PutField( "CFLD", "BBB" ),         XB_NO_ERROR );
+  iRc += TestMethod( po, "Putfield()",       V3Dbf->PutField( "DFLD", "19611109" ),    XB_NO_ERROR );
+  iRc += TestMethod( po, "PutfieldDouble()", V3Dbf->PutDoubleField( "NFLD", 50 ), XB_NO_ERROR );
+  iRc += TestMethod( po, "AppendRecord()",   V3Dbf->AppendRecord(),                    XB_NO_ERROR );
+
+  iRc += TestMethod( po, "BlankRecord()",    V3Dbf->BlankRecord(),                     XB_NO_ERROR );
+  iRc += TestMethod( po, "Putfield()",       V3Dbf->PutField( "CFLD", "BBB" ),         XB_NO_ERROR );
+  iRc += TestMethod( po, "Putfield()",       V3Dbf->PutField( "DFLD", "19611109" ),    XB_NO_ERROR );
+  iRc += TestMethod( po, "PutfieldDouble()", V3Dbf->PutDoubleField( "NFLD", 50 ), XB_NO_ERROR );
+  iRc += TestMethod( po, "AppendRecord()",   V3Dbf->AppendRecord(),                    XB_NO_ERROR );
+
+
+  xbIxList *ixl = V3Dbf->GetIxList();
+  xbIxNdx *ix;
+  xbString sTagName;
+  while( ixl ){
+    if( *ixl->sFmt == "NDX" ){
+      ix = (xbIxNdx *) ixl->ix;
+      //ix->GetTagName( 0, sTagName );
+      sMsg.Sprintf( "CheckTagIntegrity() - [%s]", ix->GetTagName(ix->GetCurTag()).Str());
+      iRc += TestMethod( po, sMsg, ix->CheckTagIntegrity( ix->GetCurTag(), 2 ), XB_NO_ERROR );
+      ixl = ixl->next;
+    }
+  }
+
+  iRc += TestMethod( po, "Close()", V3Dbf->Close(), XB_NO_ERROR );
+  delete V3Dbf;
+
+  if( po > 0 || iRc < 0 )
+    fprintf( stdout, "Total Errors = %d\n", iRc * -1 );
+
+#ifdef XB_LOGGING_SUPPORT
+  sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], iRc * -1 );
+  x.WriteLogMessage( sMsg, 2 );
+#endif
+
+  return iRc;
+}
diff --git a/src/tests/xb_test_sql.cpp b/src/tests/xb_test_sql.cpp
new file mode 100755
index 0000000..630cc89
--- /dev/null
+++ b/src/tests/xb_test_sql.cpp
@@ -0,0 +1,107 @@
+/* xb_test_sql.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014, 2022 Gary A Kunkel
+
+The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
+
+Email Contact:
+
+    xb64-devel@lists.sourceforge.net
+    xb64-users@lists.sourceforge.net
+
+*/
+
+// This program tests the SQL functions
+
+// usage:   xb_test_sql QUITE|NORMAL|VERBOSE
+
+
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+
+int main( int argCnt, char **av )
+{
+  int iRc = 0;
+  int iRc2 = 0;
+  int po = 1;          /* print option */
+                       /* 0 - QUIET    */
+                       /* 1 - NORMAL   */
+                       /* 2 - VERBOSE  */
+
+  if( argCnt > 1 ) {
+    if( av[1][0] == 'Q' )
+      po = 0;
+    else if( av[1][0] == 'V' )
+      po = 2;
+  }
+
+
+  xbSchema MySqlRecord[] = 
+  {
+    { "CITY",        XB_CHAR_FLD,     30, 0 },
+    { "STATE",       XB_CHAR_FLD,      2, 0 },
+    { "ZIPCODE",     XB_NUMERIC_FLD,   9, 0 },
+    { "NOTES",       XB_MEMO_FLD,     10, 0 },
+    { "LASTUPDATE",  XB_DATE_FLD,      8, 1 },
+    { "ACTIVE",      XB_LOGICAL_FLD,   1, 0 },
+    { "",0,0,0 }
+  };
+
+
+  xbXBase x;
+#ifdef XB_LOGGING_SUPPORT
+  x.EnableMsgLogging();
+  if( po ){
+    std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+  }
+  xbString sMsg;
+  sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+  x.WriteLogMessage( sMsg );
+#endif
+
+
+
+  x.SetDataDirectory( PROJECT_DATA_DIR );
+  x.EnableMsgLogging();
+  InitTime();
+
+  xbSql sql( &x );
+
+  if( po > 0 )
+    std::cout << "Default Data Directory is [" << x.GetDataDirectory().Str() << "]" << std::endl;
+
+  xbDbf4 SqlDbf( &x );                // version 4 dbf file
+  iRc2 = SqlDbf.CreateTable( "TestSQL.DBF", "TestSQL", MySqlRecord, XB_OVERLAY, XB_MULTI_USER );
+  iRc += TestMethod( po, "CreateTable()", (xbInt32) iRc2, XB_NO_ERROR );
+  if( iRc2 )
+    x.DisplayError( iRc2 );
+
+
+  xbString sSql = "INSERT INTO TestSQL (CITY, STATE, ZIPCODE, NOTES, LASTUPDATE, ACTIVE ) VALUES ( 'San Diego', 'CA', 92007, 'San Diego is a cool place', '1989-02-09', 'Y')";
+
+  iRc2 = sql.ExecuteNonQuery( sSql );
+  iRc += TestMethod( po, "Insert()", (xbInt32) iRc2, XB_NO_ERROR );
+  if( iRc2 )
+    x.DisplayError( iRc2 );
+
+  iRc += TestMethod( po, "Close()", SqlDbf.Close(), XB_NO_ERROR );
+
+  if( po > 0 || iRc < 0 )
+    fprintf( stdout, "Total Errors = %d\n", iRc * -1 );
+
+
+#ifdef XB_LOGGING_SUPPORT
+  sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], iRc * -1 );
+  x.WriteLogMessage( sMsg );
+#endif
+
+  return iRc;
+}
+
diff --git a/src/tests/xb_test_string.cpp b/src/tests/xb_test_string.cpp
new file mode 100755
index 0000000..f39c101
--- /dev/null
+++ b/src/tests/xb_test_string.cpp
@@ -0,0 +1,397 @@
+/* xb_test_string.cpp
+
+XBase63 Software Library
+
+Copyright (c) 1997,2003,2014, 2022 Gary A Kunkel
+
+The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
+
+Email Contact:
+
+    XDB-devel@lists.sourceforge.net
+    XDB-users@lists.sourceforge.net
+
+*/
+
+// This program tests the string class xbString
+
+// usage:  xb_test_string QUIET|NORMAL|VERBOSE
+
+#define VERBOSE
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+int main( int argCnt, char **av = NULL )
+
+//int main( int argCnt, char *argv[] )
+{
+  int rc = 0;
+  int po = 1;                   /* print option   */
+                                /* 0 - QUIET      */
+                                /* 1 - NORMAL     */
+                                /* 2 - VERBOSE    */
+
+  if( argCnt > 1 ) {
+    if( av[1][0] == 'Q' )
+      po = 0;
+    else if( av[1][0] == 'V' )
+      po = 2;
+  }
+
+  xbXBase x;
+
+  #ifdef XB_LOGGING_SUPPORT
+  x.EnableMsgLogging();
+  if( po ){
+    std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+  }
+  xbString sMsg;
+  sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+  x.WriteLogMessage( sMsg );
+  #endif
+
+  x.SetDataDirectory( PROJECT_DATA_DIR );
+  x.EnableMsgLogging();
+
+  InitTime();
+
+  // create a string, assign a value
+  xbString s1;
+  s1 = "Test String 1";
+  rc += TestMethod( po, "Constructor s1" , s1, "Test String 1", 13 );
+
+  // create another string, copy the value from s1 into it
+  xbString s2;
+  s2 = s1;
+  rc += TestMethod( po, "Operator '=' " , s2, "Test String 1",  13 );
+
+  // create another string with a single character
+  xbString s3( 'X' );
+
+  //std::cout << "s3 = [" << s3 << "]" << std::endl;
+  rc += TestMethod( po, "Constructor s3" , s3, "X",  1 );
+
+  // create another string and assign data to it yet another way
+  xbString s4( "Class constructor test 4" );
+  rc += TestMethod( po, "Constructor s4" , s4, "Class constructor test 4",  24 );
+
+  // create another string with a size limit
+  xbString s5( "Class constructor test 4", 7 );
+  rc += TestMethod( po, "Constructor s5" , s5, "Class c",  7 );
+
+  // create another string from a string
+  xbString s6( s5 );
+  rc += TestMethod( po, "Constructor s6" , s6, "Class c",  7 );
+
+  // create 15 byte string with nothing in it
+  xbString s7( (xbUInt32) 15 );
+  rc += TestMethod( po, "Constructor s7" , s7, "",  0 );
+
+  xbString s8( "some test data", 6 );
+  rc += TestMethod( po, "Constructor s8" , s8, "some t",  6 );
+
+  xbString s9( "some test data", 30 );
+  rc += TestMethod( po, "Constructor s9" , s9, "some test data",  14 );
+
+  // Extract character from a particular position in the string
+  rc += TestMethod( po, "Operator [] ", s1[7], 't' );
+  rc += TestMethod( po, "Operator [] ", s1.GetCharacter(7), 't' );
+
+  s1[6] = 'X';
+  rc += TestMethod( po, "Operator assignment [] ", s1.GetCharacter(6), 'X' );
+
+  // set string 7 to a character
+  s7 = 'Z';
+  rc += TestMethod( po, "Operator =", s7.Str(), "Z", 1 );
+
+  // Concatenation tests - I
+  s1  = " part 1 ";
+  s1 += " part 2 ";
+  s2  = " part 3 ";
+  s1 += s2;
+  s1 += 'Z';
+  rc += TestMethod( po, "Concatenation test 1", s1, " part 1  part 2  part 3 Z", 25 );
+
+  // Concatenation tests - II
+  s1 = "part 1    ";
+  s1 -= "part 2    ";
+  s1 -= 'X';
+  s1 -= s2;
+  rc += TestMethod( po, "Concatenation test 2", s1, "part 1part 2X part 3", 20 );
+
+  // Concatenation tests - III
+  s1 = "s1data  ";
+  s2 = "s2data ";
+  s3 = s1 - s2;
+  rc += TestMethod( po, "Concatenation test 3", s3, "s1datas2data", 12 );
+
+  // Concatenation tests - IV
+  s3 = s1 + s2;
+  rc += TestMethod( po, "Concatenation test 4", s3, "s1data  s2data ", 15 );
+
+  // Concatenation tests - V
+  s3 = s1 + " (char * data) " + "xyz  " + s2 + 'z';
+  rc += TestMethod( po, "Concatenation test 1", s3, "s1data   (char * data) xyz  s2data z", 36 );
+
+  //Operator tests
+  s1 = "aaa";
+  s2 = "bbb";
+  rc  += TestMethod( po, "Operator == ", s1 == s2, 0 );
+  rc  += TestMethod( po, "Operator != ", s1 != s2, 1 );
+  rc  += TestMethod( po, "Operator < ",  s1 <  s2, 1 );
+  rc  += TestMethod( po, "Operator > ",  s1 >  s2, 0 );
+  rc  += TestMethod( po, "Operator < ",  s1 <= s2, 1 );
+  rc  += TestMethod( po, "Operator > ",  s1 >= s2, 0 );
+
+  s1 = s2;
+  rc  += TestMethod( po, "Operator == ", s1 == s2, 1 );
+  rc  += TestMethod( po, "Operator != ", s1 == s2, 1 );
+  rc  += TestMethod( po, "Operator < ",  s1 <  s2, 0 );
+  rc  += TestMethod( po, "Operator > ",  s1 >  s2, 0 );
+  rc  += TestMethod( po, "Operator < ",  s1 <= s2, 1 );
+  rc  += TestMethod( po, "Operator > ",  s1 >= s2, 1 );
+
+  s1 = "XYZ";
+  rc  += TestMethod( po, "Operator * ", (const char *) s1, "XYZ", 3 );
+
+  s1 = 'Z';
+  rc += TestMethod( po, "Operator = ", s1, "Z", 1 ); 
+
+  s1 = "ABC,xyz";
+  rc += TestMethod( po, "CountChar(c,1) ", (xbInt32) s1.CountChar( ',',1 ), 1 );
+
+  s1 = "ABC,xy,z";
+  rc += TestMethod( po, "CountChar(c,1) ", (xbInt32) s1.CountChar( ',',1 ), 2 );
+
+  s1 = "ABC,xy,z'asad,as'adss";
+  rc += TestMethod( po, "CountChar(c,1) ", (xbInt32) s1.CountChar( ',',1 ), 2 );
+
+  s1 = "ABADFDSGA";
+  rc += TestMethod( po, "CountChar() ", (xbInt32) s1.CountChar( 'A' ), 3 );
+
+  s1.Ltrunc( 4 );
+  rc += TestMethod( po, "Ltrunc(4) ", s1, "FDSGA", 5 );
+
+  s1.PutAt( 3, 'Z' );
+  rc += TestMethod( po, "PutAt(3,'Z') ", s1, "FDZGA", 5 );
+
+  s1.AddBackSlash( 'Z' );
+  rc += TestMethod( po, "AddBackSlash( 'Z' ) ", s1, "FD\\ZGA", 6 );
+
+  s1 = "ABCDEFG";
+  rc += TestMethod( po, "s1.Append( 'Z' )", s1.Append( 'Z' ).Str(), "ABCDEFGZ", 8 );
+  rc += TestMethod( po, "s1.Append( '999' )", s1.Append( "999" ), "ABCDEFGZ999", 11 );
+  s2 = "!@#";
+  rc += TestMethod( po, "s1.Append( '!@#' )", s1.Append( s2 ), "ABCDEFGZ999!@#", 14 );
+
+  rc += TestMethod( po, "s1.Assign( 'ABCDE', 3, 2 )",  s1.Assign( "ABCDE", 3, 2 ), "CD", 2 );
+  rc += TestMethod( po, "s1.Assign( 'ABCDE', 2, 7 )",  s1.Assign( "ABCDE", 2, 7 ), "BCDE", 4 );
+  rc += TestMethod( po, "s1.Assign( 'ABCDE', 1, 4 )",  s1.Assign( "ABCDE", 1, 4 ), "ABCD", 4 );
+  rc += TestMethod( po, "s1.Assign( 'ABCDE', 5, 5 )",  s1.Assign( "ABCDE", 5, 5 ), "E", 1 );
+  rc += TestMethod( po, "s1.Assign( 'ABCDE', 15, 5 )", s1.Assign( "ABCDE", 15, 5 ), "", 0 );
+
+  rc += TestMethod( po, "s1.Assign( 'ABCDE', 1 )",  s1.Assign( "ABCDE", 1 ), "ABCDE", 5 );
+  rc += TestMethod( po, "s1.Assign( 'ABCDE', 3 )",  s1.Assign( "ABCDE", 3 ), "CDE", 3 );
+  rc += TestMethod( po, "s1.Assign( 'ABCDE', 10 )", s1.Assign( "ABCDE", 10 ), "", 0 );
+
+  s2 = "ABCDE";
+  rc += TestMethod( po, "s1.Assign( s2, 3, 2 )",  s1.Assign( s2, 3, 2 ), "CD", 2 );
+  rc += TestMethod( po, "s1.Assign( s2, 2, 7 )",  s1.Assign( s2, 2, 7 ), "BCDE", 4 );
+  rc += TestMethod( po, "s1.Assign( s2, 1, 4 )",  s1.Assign( s2, 1, 4 ), "ABCD", 4 );
+  rc += TestMethod( po, "s1.Assign( s2, 5, 5 )",  s1.Assign( s2, 5, 5 ), "E", 1 );
+  rc += TestMethod( po, "s1.Assign( s2, 15, 5 )", s1.Assign( s2, 15, 5 ), "", 0 );
+
+  rc += TestMethod( po, "s1.Assign( s2, 1 )",  s1.Assign( s2, 1 ), "ABCDE", 5 );
+  rc += TestMethod( po, "s1.Assign( s2, 3 )",  s1.Assign( s2, 3 ), "CDE", 3 );
+  rc += TestMethod( po, "s1.Assign( s2, 10 )", s1.Assign( s2, 10 ), "", 0 );
+
+  s2 = "1234567890";
+  s1 = s2.Copy();
+  rc += TestMethod( po, "Copy() ", s1, "1234567890", 10 );
+
+  s1 = "0x35";
+  char hexChar;
+  s1.CvtHexChar( hexChar );
+  rc += TestMethod( po, "CvtHexChar(hexChar) ", hexChar, '5' );
+
+  s1 = "0x610x620x630x640x65";
+  s1.CvtHexString( s2 );
+  rc += TestMethod( po, "CvtHexString() ", s2, "abcde", 5 );
+
+  s1 = "123";
+  s2 = "ABC";
+  rc += TestMethod( po, "HasAlphaChars()", s1.HasAlphaChars(), 0 );
+  rc += TestMethod( po, "HasAlphaChars()", s2.HasAlphaChars(), 1 );
+
+  s1 = "\\ABC\\XYZ";
+  rc += TestMethod( po, "GetPathSeparator()", s1.GetPathSeparator(), '\\' );
+
+  s1 = "/ABC/XYZ";
+  rc += TestMethod( po, "GetPathSeparator()", s1.GetPathSeparator(), '/' );
+
+  s2 = "";
+  rc += TestMethod( po, "IsEmpty()", s2.IsEmpty(), 1 );
+
+  // trim tests
+  s1 = "   ABC   ";
+  rc += TestMethod( po, "Ltrim()", s1.Ltrim(), "ABC   ", 6 );
+  s1 = "   ABC   ";
+  rc += TestMethod( po, "Rtrim()", s1.Rtrim(), "   ABC", 6 );
+  s1 = "   ABC   ";
+  rc += TestMethod( po, "Trim() ", s1.Trim(), "ABC", 3 );
+
+  s1 = "ABC   ";
+  rc += TestMethod( po, "Ltrim()", s1.Ltrim(), "ABC   ", 6 );
+
+  s1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  rc += TestMethod( po, "Mid(3,0) ", s1.Mid(3,0), "", 0 );
+
+  s1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  rc += TestMethod( po, "Mid(4,5) ", s1.Mid(4,5), "DEFGH", 5 );
+
+  rc += TestMethod( po, "Pos('G') ", (xbInt32) s1.Pos( 'G' ), 4 );
+  rc += TestMethod( po, "Pos(\"EFG\") ", (xbInt32) s1.Pos( "EFG" ), 2 );
+
+  rc += TestMethod( po, "Pos('0') ", (xbInt32) s1.Pos( '0' ), 0 );
+  rc += TestMethod( po, "Pos(\"000\") ", (xbInt32) s1.Pos( "000" ), 0 );
+  rc += TestMethod( po, "Pos(\"DEF\") ", (xbInt32) s1.Pos( "DEF" ), 1 );
+
+  s1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  rc += TestMethod( po, "Remove(3,5) ", s1.Remove( 3, 5 ), "ABHIJKLMNOPQRSTUVWXYZ", 21 );
+
+  s1 = "ABCABCABZ";
+  s1.SwapChars( 'A', '9' );
+  rc += TestMethod( po, "SwapChars() ", s1, "9BC9BC9BZ", 9 );
+
+  s1.ToLowerCase();
+  rc += TestMethod( po, "ToLowerCase() ", s1, "9bc9bc9bz", 9 );
+
+  s1.ToUpperCase();
+  rc += TestMethod( po, "ToUpperCase() ", s1, "9BC9BC9BZ", 9 );
+
+  s1.ZapChar( '9' );
+  rc += TestMethod( po, "ZapChar('9') ", s1, "BCBCBZ", 6 );
+
+  s1.ZapLeadingChar( 'B' );
+  rc += TestMethod( po, "ZapLeadingChar('B') ", s1, "CBCBZ", 5 );
+
+  s1.ZapTrailingChar( 'Z' );
+  rc += TestMethod( po, "ZapLeadingChar('B') ", s1, "CBCB", 4 );
+
+  s1.ExtractElement( "aaaa|bbbb|cccc|dddd", '|', 2, 0 );
+  rc += TestMethod( po, "ExtractElement() ", s1, "bbbb", 4 );
+
+  s1.ExtractElement( "aaaa|b'bb|c'ccc|dddd", '|', 3, 1 );
+  rc += TestMethod( po, "ExtractElement() ", s1, "dddd", 4 );
+
+  s1 = "123";
+  s1.PadLeft( '0', 9 );
+  rc += TestMethod( po, "PadLeft() ", s1, "000000123", 9 );
+
+  s1 = "abc";
+  s1.PadRight( 'Z', 9 );
+  rc += TestMethod( po, "PadRight() ", s1, "abcZZZZZZ", 9 );
+
+  s1.Left( 4 );
+  rc += TestMethod( po, "Left(4) ", s1, "abcZ", 4 );
+
+  s1.Left( 1 );
+  rc += TestMethod( po, "Left(1) ", s1, "a", 1 );
+
+  s1.Left( 0 );
+  rc += TestMethod( po, "Left(0) ", s1, "", 0 );
+
+
+  char buf[5];
+  buf[0] = 'W';
+  buf[1] = 'X';
+  buf[2] = 'Y';
+  buf[3] = 'Z';
+  buf[4] = 0x00;
+  xbInt32 l = 1234567;
+  xbFloat f = (xbFloat) 12.35;
+  s2 = "test string";
+
+  rc += TestMethod( po, "s1.Sprintf()", s1.Sprintf( "%s %d %s %ld", buf, 12, s2.Str(), l  ), "WXYZ 12 test string 1234567", 27 );
+
+  // %f format varies depending on compiler
+  s1.Sprintf( "%6.2f", f );
+  s1.Ltrim();
+  rc += TestMethod( po, "s1.Sprintf()/s.Trim()", s1, "12.35", 5 );
+
+  s1.SetNum( (long) 123456 );
+  rc += TestMethod( po, "SetNum() ", s1, "123456", 6 );
+
+  s1 = "T";
+  rc += TestMethod( po, "ValidLogicalValue", s1.ValidLogicalValue(), 1 );
+
+  s1 = "xyz";
+  rc += TestMethod( po, "ValidLogicalValue", s1.ValidLogicalValue(), 0 );
+
+  s1 = "-123456.89";
+  rc += TestMethod( po, "ValidNumericValue", s1.ValidNumericValue(), 1 );
+
+  s1 = "ABC-123456.89";
+  rc += TestMethod( po, "ValidNumericValue", s1.ValidNumericValue(), 0 );
+
+  s1 = "abcabcabx";
+  rc += TestMethod( po, "GetLastPos", (xbInt16) s1.GetLastPos( 'b' ), 8 );
+  s1 = "abcabcabx";
+  rc += TestMethod( po, "GetLastPos", (xbInt16) s1.GetLastPos( 'x' ), 9 );
+  s1 = "abcabcabx";
+  rc += TestMethod( po, "GetLastPos", (xbInt16) s1.GetLastPos( '$' ), 0 );
+  rc += TestMethod( po, "GetLastPos", (xbInt16) s1.GetLastPos( "ab" ), 7 );
+
+  s1 = ")";
+  rc += TestMethod( po, "GetLastPos", (xbInt16) s1.GetLastPos( ')' ), 1 );
+  s1 = "))))";
+  rc += TestMethod( po, "GetLastPos", (xbInt16) s1.GetLastPos( ')' ), 4 );
+
+  char * p; 
+  p = (char *) malloc( 5 );
+  p[0] = '1';
+  p[1] = '2';
+  p[2] = '3';
+  p[3] = '4';
+  p[4] = 0x00;
+  s1.Set( p, 5 );
+  free( p );
+  rc += TestMethod( po, "Set", s1, "1234", 4 );
+
+
+  xbDouble d = 12345678.876543;
+  xbString sD( d );
+  rc += TestMethod( po, "xbDouble Constructor", sD, "12345678.876543", 15 );
+
+  xbString sSet;
+  sSet.Set( sD );
+  rc += TestMethod( po, "Set", sD, sD, 15 );
+  sSet.Set( s2 );
+  rc += TestMethod( po, "Set", sSet, s2, 11 );
+  sSet.Set( "" );
+  rc += TestMethod( po, "Set", sSet, "", 0 );
+
+  s1.Sprintf( "string %d", 1 );
+  s2.Sprintf( "string %1.1f", 2.0 );
+  s3.Sprintf( "%s and %s", s1.Str(), s2.Str());
+  rc += TestMethod( po, "Sprintf", s3, "string 1 and string 2.0", 23 );
+
+  xbInt16 iErrorStop = 10;
+  xbInt16 iRc = -100;
+  sMsg.Sprintf( "class::method() Exception Caught. Error Stop = [%d] iRc = [%d] Expression = [%s]", iErrorStop, iRc, s3.Str() );
+
+  if( po > 0 || rc < 0 )
+    fprintf( stdout, "Total Errors = %d\n", rc * -1 );
+
+#ifdef XB_LOGGING_SUPPORT
+  sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], rc * -1 );
+  x.WriteLogMessage( sMsg );
+#endif
+
+  return rc;
+}
+
diff --git a/src/tests/xb_test_tblmgr.cpp b/src/tests/xb_test_tblmgr.cpp
new file mode 100755
index 0000000..26ec96a
--- /dev/null
+++ b/src/tests/xb_test_tblmgr.cpp
@@ -0,0 +1,167 @@
+/*  xb_test_tblmgr.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014, 2022 Gary A Kunkel
+
+The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
+
+Email Contact:
+
+    XDB-devel@lists.sourceforge.net
+    XDB-users@lists.sourceforge.net
+
+*/
+
+// This program tests the class xbXBase
+// usage:   xb_test_tblmgr QUITE|NORMAL|VERBOSE
+
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+int main( int argCnt, char **av )
+{
+  int rc = 0;
+  int po = 1;          /* print option */
+                       /* 0 - QUIET    */
+                       /* 1 - NORMAL   */
+                       /* 2 - VERBOSE  */
+
+  if( argCnt > 1 ) {
+    if( av[1][0] == 'Q' )
+      po = 0;
+    else if( av[1][0] == 'V' )
+      po = 2;
+  }
+
+  xbXBase x;
+
+#ifdef XB_LOGGING_SUPPORT
+  x.EnableMsgLogging();
+  if( po ){
+    std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+  }
+  xbString sMsg;
+  sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+  x.WriteLogMessage( sMsg );
+#endif
+  InitTime();
+
+  if( po == 2 ){
+    std::cout << "DisplayError Test ==> ";
+    x.DisplayError( 0 );
+	#ifdef WIN32
+	std::cout << "WIN32 environment" << std::endl;
+	#else
+	std::cout << "Not WIN32 environment" << std::endl;
+	#endif
+  }
+
+  xbDbf * d1;
+  xbDbf * d2;
+
+  #if defined (XB_DBF3_SUPPORT )
+    d1 = new xbDbf3( &x );
+  #elif defined( XB_DBF4_SUPPORT )
+    d1 = new xbDbf4( &x );
+  #else
+    std::cout << "No dbf file support built into library" << std::endl;
+    return -1;
+  #endif
+
+  rc += TestMethod( po, "AddTblToTblLst()", x.AddTblToTblList( d1, "TestTableC" ), 0 );
+  rc += TestMethod( po, "AddTblToTblLst()", x.AddTblToTblList( d1, "TestTableA" ), 0 );
+  rc += TestMethod( po, "AddTblToTblLst()", x.AddTblToTblList( d1, "TestTableB" ), 0 );
+  rc += TestMethod( po, "AddTblToTblLst()", x.AddTblToTblList( d1, "TestTableD" ), 0 );
+  
+  
+  // Next line should generate an exception
+  rc += TestMethod( po, "AddTblToTblLst()", x.AddTblToTblList( d1, "TestTableC" ), XB_DUP_TABLE_OR_ALIAS );
+
+  std::cout << "**** Next list should have one each of TestTableA, B, C, D sorted in alpha order ****" << std::endl;
+  x.DisplayTableList();
+
+  d2 = (xbDbf *) x.GetDbfPtr( "TestTableA" );
+  if( d2 )
+    std::cout << "[PASS] GetDbfPtr()" << std::endl;
+  else{
+    std::cout << "[FAIL] GetDbfPtr()" << std::endl;
+    rc--;
+  }
+
+
+std::cout << "cp0\n";
+  x.SetDataDirectory( "/ABCDEFG/" );
+
+  #ifdef WIN32
+    rc += TestMethod( po, "Set/GetDataDirectory()", x.GetDataDirectory(),  "\\ABCDEFG\\", 9 );
+  #else
+    rc += TestMethod( po, "Set/GetDataDirectory()", x.GetDataDirectory(),  "/ABCDEFG/", 9 );
+  #endif
+std::cout << "cp1\n";
+  x.SetDataDirectory( "/ABCDEFG" );
+  #ifdef WIN32
+    rc += TestMethod( po, "Set/GetDataDirectory()", x.GetDataDirectory(),  "\\ABCDEFG", 8 );
+  #else
+    rc += TestMethod( po, "Set/GetDataDirectory()", x.GetDataDirectory(),  "/ABCDEFG", 8 );
+  #endif
+
+
+  std::cout << "cp2\n";
+
+
+  x.SetDataDirectory( "\\ABCDEFG\\");
+  #ifdef WIN32
+    rc += TestMethod( po, "Set/GetDataDirectory()", x.GetDataDirectory(),  "\\ABCDEFG\\", 9 );
+  #else
+    rc += TestMethod( po, "Set/GetDataDirectory()", x.GetDataDirectory(),  "/ABCDEFG/", 9 );
+  #endif
+
+  std::cout << "cp3\n";
+
+
+  x.SetDataDirectory( "\\ABCDEFG" );
+  #ifdef WIN32
+    rc += TestMethod( po, "Set/GetDataDirectory()", x.GetDataDirectory(),  "\\ABCDEFG", 8 );
+  #else
+    rc += TestMethod( po, "Set/GetDataDirectory()", x.GetDataDirectory(),  "/ABCDEFG", 8 );
+  #endif
+
+
+  std::cout << "cp4\n";
+
+
+  x.SetDataDirectory( "ABCDEFG" );
+  rc += TestMethod( po, "Set/GetDataDirectory()", x.GetDataDirectory(),  "ABCDEFG", 7 );
+
+
+  rc += TestMethod( po, "RemoveTblFromDbList()", x.RemoveTblFromTblList( "TestTableB" ), 0 );
+  rc += TestMethod( po, "RemoveTblFromDbList()", x.RemoveTblFromTblList( "TestTableB" ), XB_NOT_FOUND );
+  std::cout << "**** Next list should not have TestTableB in it ****" << std::endl;
+  x.DisplayTableList();
+
+
+  rc += TestMethod( po, "RemoveTblFromDbList()", x.RemoveTblFromTblList( "TestTableA" ), 0 );
+  rc += TestMethod( po, "RemoveTblFromDbList()", x.RemoveTblFromTblList( "TestTableC" ), 0 );
+  rc += TestMethod( po, "RemoveTblFromDbList()", x.RemoveTblFromTblList( "TestTableD" ), 0 );
+
+
+  delete d1;
+
+  if( po > 0 || rc < 0 )
+    fprintf( stdout, "Total Errors = %d\n", rc * -1 );
+
+
+#ifdef XB_LOGGING_SUPPORT
+  sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], rc * -1 );
+  x.WriteLogMessage( sMsg );
+#endif
+
+
+  return rc;
+}
+
diff --git a/src/tests/xb_test_uda.cpp b/src/tests/xb_test_uda.cpp
new file mode 100755
index 0000000..dec41fa
--- /dev/null
+++ b/src/tests/xb_test_uda.cpp
@@ -0,0 +1,98 @@
+/* xb_test_uda.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014, 2022 Gary A Kunkel
+
+The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
+
+Email Contact:
+
+    XDB-devel@lists.sourceforge.net
+    XDB-users@lists.sourceforge.net
+
+*/
+
+// This program tests the uda (user data area) functions
+
+// usage:   xb_test_uda QUITE|NORMAL|VERBOSE
+
+
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+
+int main( int argCnt, char **av )
+{
+  int iRc = 0;
+  //int iRc2 = 0;
+  int po = 1;          /* print option */
+                       /* 0 - QUIET    */
+                       /* 1 - NORMAL   */
+                       /* 2 - VERBOSE  */
+
+  if( argCnt > 1 ) {
+    if( av[1][0] == 'Q' )
+      po = 0;
+    else if( av[1][0] == 'V' )
+      po = 2;
+  }
+
+
+
+  xbXBase x;
+#ifdef XB_LOGGING_SUPPORT
+  x.EnableMsgLogging();
+  if( po ){
+    std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+  }
+  xbString sMsg;
+  sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+  x.WriteLogMessage( sMsg );
+#endif
+
+
+  x.SetDataDirectory( PROJECT_DATA_DIR );
+  x.EnableMsgLogging();
+
+  xbUda uda;
+  iRc += TestMethod( po, "GetTokencCnt()",  uda.GetTokenCnt(), 0 );
+  xbString s1;
+  xbString s2;
+  iRc += TestMethod( po, "AddTokenForKey()", uda.AddTokenForKey( "B", "BBBB" ), XB_NO_ERROR );
+  s1 = "C";
+  iRc += TestMethod( po, "AddTokenForKey()", uda.AddTokenForKey( s1, "CCCC" ), XB_NO_ERROR );
+  s2 = "DDDD";
+  iRc += TestMethod( po, "AddTokenForKey()", uda.AddTokenForKey( "D", s2 ), XB_NO_ERROR );
+
+  s1 = "A";
+  s2 = "AAAA";
+  iRc += TestMethod( po, "AddTokenForKey()", uda.AddTokenForKey( s1, s2 ), XB_NO_ERROR );
+  iRc += TestMethod( po, "AddTokenForKey()", uda.AddTokenForKey( "AA", "AAAAA" ), XB_NO_ERROR );
+  iRc += TestMethod( po, "AddTokenForKey()", uda.AddTokenForKey( "BB", "BBBBB" ), XB_NO_ERROR );
+  iRc += TestMethod( po, "AddTokenForKey()", uda.AddTokenForKey( "CC", "CCCCC" ), XB_NO_ERROR );
+  iRc += TestMethod( po, "AddTokenForKey()", uda.AddTokenForKey( "DD", "DDDDD" ), XB_NO_ERROR );
+  iRc += TestMethod( po, "GetTokencCnt()",  uda.GetTokenCnt(), 8);
+
+  iRc += TestMethod( po, "UpdTokenForKey()", uda.UpdTokenForKey( "BB", "9999" ), XB_NO_ERROR );
+  iRc += TestMethod( po, "UpdTokenForKey()", uda.DelTokenForKey( "CC" ), XB_NO_ERROR );
+  iRc += TestMethod( po, "GetTokencCnt()",  uda.GetTokenCnt(), 7 );
+
+#ifdef XB_DEBUG_SUPPORT
+   uda.DumpUda();
+#endif  // XB_DEBUG_SUPPORT
+
+   uda.Clear();
+   iRc += TestMethod( po, "GetTokencCnt()",  uda.GetTokenCnt(), 0 );
+
+#ifdef XB_LOGGING_SUPPORT
+  sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], iRc * -1 );
+  x.WriteLogMessage( sMsg );
+#endif
+
+  return iRc;
+}
diff --git a/src/tests/xb_test_xbase.cpp b/src/tests/xb_test_xbase.cpp
new file mode 100755
index 0000000..6dad3f7
--- /dev/null
+++ b/src/tests/xb_test_xbase.cpp
@@ -0,0 +1,106 @@
+/*  xb_test_xbase.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014, 2022 Gary A Kunkel
+
+The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
+
+Email Contact:
+
+    XDB-devel@lists.sourceforge.net
+    XDB-users@lists.sourceforge.net
+
+*/
+
+// This program tests the class xbXBase
+
+// usage:   xb_test_xbase QUITE|NORMAL|VERBOSE
+
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+int main( int argCnt, char **av )
+{
+  int iRc = 0;
+  int po = 1;          /* print option */
+                       /* 0 - QUIET    */
+                       /* 1 - NORMAL   */
+                       /* 2 - VERBOSE  */
+
+  if( argCnt > 1 ) {
+    if( av[1][0] == 'Q' )
+      po = 0;
+    else if( av[1][0] == 'V' )
+      po = 2;
+  }
+
+
+  xbXBase x;
+
+
+#ifdef XB_LOGGING_SUPPORT
+  x.EnableMsgLogging();
+  if( po ){
+    std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+  }
+  xbString sMsg;
+  sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+  x.WriteLogMessage( sMsg );
+#endif
+  InitTime();
+
+
+  x.SetDefaultDateFormat( "YY-MM-DD" );
+  iRc += TestMethod( po, "SetDefaultDateFormat", x.GetDefaultDateFormat(), "YY-MM-DD", 8 );
+
+  if( po == 2 ){
+    if( x.GetEndianType() == 'L' )
+      std::cout << "Little Endian Architecture" << std::endl;
+    else if( x.GetEndianType() == 'B' )
+      std::cout << "Big Endian Architecture" << std::endl;
+    else
+      std::cout << "Undefine Endian Architecture" << std::endl;
+  }
+
+  iRc += TestMethod( po, "GetErrorMessage", x.GetErrorMessage( XB_DBF_FILE_NOT_OPEN ), "DBF File Not Open", 17 );
+
+
+#ifdef XB_LOGGING_SUPPORT
+  xbString sLogDir = PROJECT_LOG_DIR;
+  iRc += TestMethod( po, "GetDefaultLogDirectory()", x.GetDefaultLogDirectory(), sLogDir, sLogDir.Len());
+
+  xbString sLogName = CMAKE_SYSTEM_NAME;
+  sLogName += "_";
+  sLogName += XB_PLATFORM;
+  sLogName += ".xbLog.txt";
+  iRc += TestMethod( po, "GetDefaultLogFileName()", x.GetDefaultLogFileName(), sLogName, sLogName.Len());
+
+  x.WriteLogMessage( "test" );
+#endif
+
+  x.xbSleep( 250 );
+
+ 
+
+  if( po == 2 ){
+    std::cout << "DisplayError Test ==> ";
+    x.DisplayError( 0 );
+  }
+
+  if( po > 0 || iRc < 0 )
+    fprintf( stdout, "Total Errors = %d\n", iRc * -1 );
+
+
+#ifdef XB_LOGGING_SUPPORT
+  sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], iRc * -1 );
+  x.WriteLogMessage( sMsg );
+#endif
+
+  return iRc;
+}
+