    // ------------------------------- //
    // -------- Start of File -------- //
    // ------------------------------- //
    // ----------------------------------------------------------- //
    // C++ Source Code File Name: testprog.cpp
    // C++ Compiler Used: MSVC, BCC32, GCC, HPUX aCC, SOLARIS CC
    // Produced By: DataReel Software Development Team
    // File Creation Date: 01/25/2000
    // Date Last Modified: 06/17/2016
    // Copyright (c) 2001-2024 DataReel Software Development
    // ----------------------------------------------------------- //
    // ------------- Program Description and Details ------------- //
    // ----------------------------------------------------------- //
    /*
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
    USA

    This is a test program for the DiskFileB class.
    */
    // ----------------------------------------------------------- //
    #include "gxdlcode.h"

    #if defined (__USE_ANSI_CPP__) // Use the ANSI Standard C++ library
    #include <iostream>
    #include <iomanip>
    using namespace std; // Use unqualified names for Standard C++ library
    #else // Use the old iostream library by default
    #include <iostream.h>
    #include <iomanip.h>
    #endif // __USE_ANSI_CPP__

    #include <string.h>
    #include <stdio.h>
    #include "dfileb.h"

    #ifdef __MSVC_DEBUG__
    #include "leaktest.h"
    #endif

    void PausePrg()
    {
      cout << "\n";
      cout << "Press enter to continue..." << "\n";
      cin.get();
    }

    void DirectoryTest()
    {
      cout << "Testing general purpose directory functions"
           << "\n";

      const char *dirname = "testdir"; // Directory to be created

      // Directory immediately above the current directory position
      const char *parentdir = "..";

      DiskFileB dir;
      cout << "Creating " << dirname << " directory" <<"\n";
      if(dir.df_mkdir(dirname) != 0) {
        cout << dir.df_ExceptionMessage() << "\n";
        return;
      }

      if((dir.df_Exists(dirname)) && (dir.df_IsDirectory(dirname))) {
        cout << "The " << dirname << " directory was created" << "\n";
      }

      cout << "Changing directory to " << dirname << " directory" <<"\n";
      if(dir.df_chdir(dirname) != 0) {
        cout << dir.df_ExceptionMessage() << "\n";
        return;
      }

      char *pwd[df_MAX_DIR_LENGTH]; char drive_letter;
      if(dir.df_pwd((char *)pwd) == 0) {
        cout << "Present working directory: " << (char *)pwd << "\n";
        if(dir.df_HasDriveLetter((const char *)pwd, drive_letter)) {
          cout << "DOS Drive letter = " << drive_letter << "\n";
        }
      }

      cout << "Changing directory to " << parentdir << " directory" <<"\n";
      if(dir.df_chdir(parentdir) != 0) {
        cout << dir.df_ExceptionMessage() << "\n";
        return;
      }

      if(dir.df_pwd((char *)pwd) == 0) {
        cout << "Present working directory: " << (char *)pwd << "\n";
        if(dir.df_HasDriveLetter((const char *)pwd, drive_letter)) {
          cout << "DOS Drive letter = " << drive_letter << "\n";
        }
      }

      cout << "Removing " << dirname << " directory" <<"\n";
      if(dir.df_rmdir(dirname) != 0) {
        cout << dir.df_ExceptionMessage() << "\n";
        return;
      }
    }

    void FileTest()
    {
      cout << "Testing general purpose file functions"
           << "\n";

      const char *testfile1 = "testfile1.dat";
      const char *testfile2 = "testfile2.dat";
      const char *testfile3 = "testfile3.dat";
      DiskFileB dfile(testfile1, DiskFileB::df_READWRITE, DiskFileB::df_CREATE);
      if(!dfile) {
        cout << "Could not open the " << testfile1 << "\n";
        return;
      }

      if((dfile.df_Exists(testfile1)) && (dfile.df_IsFile(testfile1))) {
        cout << "The " << testfile1 << " file was opened with read/write access"
    	 << "\n";
       }

      const char *teststr1 = "The quick brown fox jumps over the lazy dog \
    0123456789\r\n";

      cout << "Writing " << strlen(teststr1) << " bytes to " << testfile1 << "\n";
      if(dfile.df_Write((const char *)teststr1, strlen(teststr1)) != 0) {
        cout << dfile.df_ExceptionMessage() << "\n";
        return;
      }

      cout << testfile1 << " Dynamic file size = " << (int)dfile.df_GetEOF()
           << "\n";
      dfile.df_Flush();
      cout << testfile1 << " Static file size  = "
           << (int)dfile.df_FileSize(testfile1) << "\n";

      char *sbuf = new char[strlen(teststr1)+1];
      cout << "Reading the file contents..." << "\n";
      if(dfile.df_Read((char *)sbuf, strlen(teststr1), (FAU_t)0) != 0) {
        cout << dfile.df_ExceptionMessage() << "\n";
        delete[] sbuf;
        return;
      }
      sbuf[strlen(teststr1)] = '\0';
      cout << sbuf;
      delete[] sbuf;

      dfile.df_Close();
      cout << "Renaming the " << testfile1 << " to " << testfile2 << "\n";
      if(dfile.df_rename(testfile1, testfile2) != 0) {
        cout << dfile.df_ExceptionMessage() << "\n";
        return;
      }
      cout << "Copying " << testfile2 << " to " << testfile3 << "\n";
      if(dfile.df_copy(testfile2, testfile3) != 0) {
        cout << dfile.df_ExceptionMessage() << "\n";
        return;
      }
      cout << "Removing " << testfile2 << " and " << testfile3 << "\n";
      if(dfile.df_remove(testfile2) != 0) {
        cout << dfile.df_ExceptionMessage() << "\n";
        return;
      }
      if(dfile.df_remove(testfile3) != 0) {
        cout << dfile.df_ExceptionMessage() << "\n";
        return;
      }

      // Add routine to change file attributes/permissions here
      // ------------------------------------------------------
    }

    void RandomSeekTest()
    {
      struct fileblock {
        unsigned block_length;
      };

      cout << "Performing random read/write test" << "\n";

      const char *testfile = "testfile.dat";
      DiskFileB dfile(testfile, DiskFileB::df_READWRITE, DiskFileB::df_CREATE);

      if(!dfile) {
        cout << "Could not open the " << testfile << "\n";
        return;
      }

      if((dfile.df_Exists(testfile)) && (dfile.df_IsFile(testfile))) {
        cout << "The " << testfile << " file was opened with read/write access"
    	 << "\n";
      }

      const char *teststr = "The quick brown fox jumps over the lazy dog";

      unsigned i;
      unsigned len = strlen(teststr)+4;
      char *str = new char[len+1];
      for(i = 0; i< len; i++) str[i] = '\0';
      memmove(str, teststr, strlen(teststr));

      const unsigned blocks_to_write = 10;
      FAU_t pos[blocks_to_write];
      fileblock hdr;
      char sbuf[df_MAX_LINE_LENGTH];

      cout << "Writing " << blocks_to_write << " blocks of data..." << "\n";
      for(i = 0; i < blocks_to_write; i++) {
        pos[i] = dfile.df_Tell();
        sprintf(sbuf, " %u", i);
        memmove(str+strlen(teststr), sbuf, strlen(sbuf));
        str[strlen(teststr)+strlen(sbuf)] = '\0';
        hdr.block_length = sizeof(fileblock) + (strlen(str)-1);
        dfile.df_Write(&hdr,sizeof(fileblock));
        dfile.df_Write((char *)str, hdr.block_length);
      }

      cout << "Reading back the blocks..." << "\n";
      PausePrg();

      const int max_lines = 10;
      int lines_printed = 0;
      hdr.block_length = 0;
      int ii;

      for(i = 0; i <  blocks_to_write; i++) {
        for(ii = 0; ii < (int)len; ii++) str[ii] = '\0';
        dfile.df_Read(&hdr, sizeof(fileblock), pos[i]);
        dfile.df_Read((char *)str, hdr.block_length, (pos[i]+sizeof(fileblock)));
        cout << "Block address = " << (long)pos[i] << "\n";
        cout << "Block size = " << hdr.block_length << "\n";
        cout << "Data = " << str << "\n";
        lines_printed++;
        if(lines_printed >= max_lines) {
          PausePrg();
          lines_printed = 0;
        }
      }

      dfile.df_Rewind();

      cout << "Reading back the blocks in reverse order..." << "\n";
      PausePrg();

      for(ii = (int)blocks_to_write-1; ii >= 0; ii--) {
        for(i = 0; i < len; i++) str[i] = '\0';
        dfile.df_Read((char *)&hdr, sizeof(fileblock), pos[ii]);
        dfile.df_Read((char *)str, hdr.block_length);
        cout << "Block address = " << (long)pos[ii] << "\n";
        cout << "Block size = " << hdr.block_length << "\n";
        cout << "Data = " << str << "\n";
        lines_printed++;
        if(lines_printed >= max_lines) {
          PausePrg();
          lines_printed = 0;
        }
      }

      delete[] str;
      dfile.df_Close();

      cout << "Removing " << testfile << "\n";
      if(dfile.df_remove(testfile) != 0) {
        cout << dfile.df_ExceptionMessage() << "\n";
        return;
      }
      return;
    }

    void GetLineTest()
    {
      cout << "Testing the read line function" << "\n";

      const char *DOSTextLine = "The quick brown fox jumps over the lazy dog\r\n";
      const char *UNIXTextLine = "The quick brown fox jumps over the lazy dog\n";

      cout << "Creating DOS and UNIX text files" << "\n";
      const char *fname1 = "dostext.txt";
      const char *fname2 = "unixtext.txt";

      DiskFileB f1(fname1, DiskFileB::df_READWRITE, DiskFileB::df_CREATE);
      if(!f1) {
        cout << "Error opening text file" << "\n";
        return;
      }
      DiskFileB f2(fname2, DiskFileB::df_READWRITE, DiskFileB::df_CREATE);
      if(!f2) {
        cout << "Error opening text file" << "\n";
        return;
      }

      const int num_lines = 10;
      int i;
      cout << "Writing " << num_lines << " lines to the text files" << "\n";
      for(i = 0; i < num_lines; i++) {
        f1.df_Write(DOSTextLine, strlen(DOSTextLine));
        f2.df_Write(UNIXTextLine, strlen(UNIXTextLine));
        if((f1.df_CheckError()) || (f2.df_CheckError())) {
          cout << "Error writing to text file" << "\n";
          return;
        }
      }

      cout << "Reading the DOS text file" << "\n";
      PausePrg();
      char sbuf[255];
      int line_number = 1;
      f1.df_Rewind(); // Reset the file pointer to the beginning of the stream
      while(!f1.df_EOF()) {
        f1.df_GetLine(sbuf, sizeof(sbuf));
        if(f1.df_GetError() != DiskFileB::df_NO_ERROR) {
          cout << "Error reading from the text file" << "\n";
          cout << f1.df_ExceptionMessage() << "\n";
          break;
        }
        cout << line_number++ << ' ' << sbuf << "\n";
      }

      cout << "\n";
      cout << "Reading the UNIX text file" << "\n";
      PausePrg();

      line_number = 1;
      f2.df_Rewind(); // Reset the file pointer to the beginning of the stream
      while(!f2.df_EOF()) { // Loop until EOF error
        f2.df_GetLine(sbuf, sizeof(sbuf));
        if(f2.df_GetError() != DiskFileB::df_NO_ERROR) {
          cout << "Error reading from the text file" << "\n";
          cout << f2.df_ExceptionMessage() << "\n";
          break;
        }
        cout << line_number++ << ' ' << sbuf << "\n";
      }

      // Close and remove the text files
      f1.df_Close(); f2.df_Close();
      f1.df_remove(fname1); f2.df_remove(fname2);
    }

    void OverLoadTest()
    {
      cout << "Testing overloaded << and >> operators" << "\n";
      cout << "\n";

      const char *fname = "strtest.dat";

      DiskFileB stream(fname, DiskFileB::df_READWRITE, DiskFileB::df_CREATE);
      if(!stream) {
        cout << "Error opening text file" << "\n";
        cout << stream.df_ExceptionMessage() << "\n";
        return;
      }

      const char *s1 = "The quick brown fox jumps over the lazy dog";
      char *s2 = "0123456789";
      char c1 = 'A';
      const char c2 = 'B';

      cout << "Writing some text to the stream" << "\n";
      stream << s1 << ' ' << s2 << "\n";
      stream << c1 << ' ' << c2 << "\n";

      cout << "Reading back the text from the stream" << "\n";
      stream.df_Rewind();
      char sbuf1[df_MAX_LINE_LENGTH]; char sbuf2[df_MAX_LINE_LENGTH];
      char ch1, ch2, ch3;
      stream >> sbuf1;
      stream >> ch1; stream >> ch2; stream >> ch3;

      // Echo the text to the console
      cout << sbuf1;
      cout << ch1 << ch2 << ch3 << "\n";

      cout << "Writing some integer values to the stream in binary" << "\n";
      FAU_t stream_pos = stream.df_Tell(); // Record the current position
      const short i1 = 1; short i2 = 2;
      const unsigned short i3 = 3; unsigned short i4 = 4;
      const int i5 = 5; int i6 = 6;
      const unsigned int i7 = 7; unsigned int i8 = 8;
      const long i9 = 9; long i10 = 10;
      const unsigned long i11 = 11; unsigned long i12 = 12;

      stream << i1 << i2 << i3 << i4 << i5 << i6 << i7 << i8 << i9
    	 << i10 << i11 << i12;

      cout << "Reading the binary integer values from the stream" << "\n";
      stream.df_Seek(stream_pos); // Reset the stream position to the first value
      short in1, in2; unsigned short in3, in4;
      int in5, in6; unsigned int in7, in8;
      long in9, in10; unsigned long in11, in12;

      stream >> in1 >> in2 >> in3 >> in4 >> in5 >> in6 >> in7 >> in8 >> in9
    	 >> in10 >> in11 >> in12;

      // Echo the values to the console
      cout << in1 << " " << in2 << " " << in3 << " " << in4 << " " << in5
           << " " << in6 << " " << in7 << " " << in8 << " " << in9
           << " " << in10 << " " << in11 << " " << in12 << "\n";

      cout << "Writing some integer values to the stream in text mode" << "\n";
      stream_pos = stream.df_Tell(); // Record the current position

      // Use decimal and hex text modes
      stream << text << i1 << " " << i2 << " " << i3 << " " << i4 << " "
    	 << i5 << " " << i6 << " " << i7 << " " << i8 << " " << i9 << " "
    	 << i10 << " " << i11 << " " << i12 << "\n" << flush;

      stream.df_SetWidth(2); stream.df_SetFill('0');
      stream << hex << i1 << " " << i2 << " " << i3 << " " << i4 << " "
    	 << i5 << " " << i6 << " " << i7 << " " << i8 << " " << i9 << " "
    	 << i10 << " " << i11 << " " << i12 << "\n" << clear;

      cout << "Reading the text strings from the stream" << "\n";
      stream.df_Seek(stream_pos); // Reset the stream position to the first value

      stream >> sbuf1 >> sbuf2;

      // Echo the text to the console
      cout << sbuf1 << "\n" << sbuf2 << "\n";

      cout << "Writing some floating point values to the stream in binary" << "\n";
      stream_pos = stream.df_Tell(); // Record the current position
      float f1 = 1.1011; const float f2 = 2.2022;
      double f3 = 3.3033; const double f4 = 4.4044;

      stream << f1 << f2 << f3 << f4;

      cout << "Reading the binary floating point values from the stream" << "\n";
      stream.df_Seek(stream_pos); // Reset the stream position to the first value
      float fn1, fn2;
      double fn3, fn4;

      stream >> fn1 >> fn2 >> fn3 >> fn4;

      // Echo the values to the console
      cout << fn1 << " " << fn2 << " " << fn3 << " " << fn4 << "\n";

      cout << "Writing some floating point values to the stream in text mode"
           << "\n";
      stream_pos = stream.df_Tell(); // Record the current position

      stream << text << f1 << " " << f2 << " " << f3 << " " << f4 << "\n";
      stream.df_Precision(4);
      stream << f1 << " " << f2 << " " << f3 << " " << f4 << "\n"<< clear;

      cout << "Reading the text strings from the stream" << "\n";
      stream.df_Seek(stream_pos); // Reset the stream position to the first value

      stream >> sbuf1 >> sbuf2;

      // Echo the text to the console
      cout << sbuf1 << "\n" << sbuf2 << "\n";

    #if defined (__64_BIT_DATABASE_ENGINE__)
      PausePrg();

      cout << "Writing some 64-bit integer values to the stream in binary" << "\n";
      stream_pos = stream.df_Tell(); // Record the current position
      __LLWORD__ LL1 = (__LLWORD__)1; const __LLWORD__ LL2 = (__LLWORD__)2;
      __ULLWORD__ LL3 = (__ULLWORD__)3; const __ULLWORD__ LL4 = (__LLWORD__)4;

      stream << LL1 << LL2 << LL3 << LL4;

      cout << "Reading the binary 64-bit integer point values from the stream"
           << "\n";
      stream.df_Seek(stream_pos); // Reset the stream position to the first value
      __LLWORD__ LLn1, LLn2;
      __ULLWORD__ LLn3, LLn4;

      stream >> LLn1 >> LLn2 >> LLn3 >> LLn4;

      // Echo the values to the console
      cout << (int)LLn1 << " " << (int)LLn2 << " " << (int)LLn3 << " "
           << (int) LLn4 << "\n";

      cout << "Writing some 64-bit integer values to the stream in text mode"
           << "\n";
      stream_pos = stream.df_Tell(); // Record the current position

      // Use decimal and hex text modes
      LL1 = __LLWORD__(9223372036854775808);
      LL3 = __ULLWORD__(18446744073709551615);

      stream << text << LL1 << " " << LL2 << " " << LL3 << " " << LL4 << "\n";

      stream.df_SetWidth(4); stream.df_SetFill('0');
      stream << hex << LL1 << " " << LL2 << " " << LL3 << " " << LL4 << "\n"
    	 << clear;

      cout << "Reading the text strings from the stream" << "\n";
      stream.df_Seek(stream_pos); // Reset the stream position to the first value

      stream >> sbuf1 >> sbuf2;

      // Echo the text to the console
      cout << sbuf1 << "\n" << sbuf2 << "\n";
    #endif // __64_BIT_DATABASE_ENGINE__

      // Close and remove the text files
      stream.df_Close();
      stream.df_remove(fname);
    }

    int main()
    {
    #ifdef __MSVC_DEBUG__
      InitLeakTest();
    #endif

      cout << "\n";

      OverLoadTest();
      PausePrg();

      DirectoryTest();
      PausePrg();

      FileTest();
      PausePrg();

      RandomSeekTest();
      PausePrg();

      GetLineTest();

      cout << "\n";
      cout << "Exiting..." << "\n";
      cout << "\n";
      return 0;
    }
    // ----------------------------------------------------------- //
    // ------------------------------- //
    // --------- End of File --------- //
    // ------------------------------- //