// ------------------------------- //
// -------- Start of File -------- //
// ------------------------------- //
// ----------------------------------------------------------- //
// C++ Source Code File Name: testprog.cpp
// C++ Compiler Used: MSVC, BCC32, GCC, HPUX aCC, SOLARIS CC
// Produced By: glNET Software
// File Creation Date: 01/25/2000
// Date Last Modified: 05/25/2001
// Copyright (c) 2001 glNET Software
// ----------------------------------------------------------- //
// ------------- 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 <iostream.h>
#include <iomanip.h>
#include <string.h>
#include <stdio.h>
#include "dfileb.h"
#ifdef __MSVC_DEBUG__
#include "leaktest.h"
#endif
void PausePrg()
{
cout << endl;
cout << "Press enter to continue..." << endl;
cin.get();
}
struct fileblock {
unsigned block_length;
};
void DirectoryTest()
{
cout << "Testing general purpose directory functions"
<< endl;
const char *dirname = "testdir"; // Directory to be created
const char *currentdir = "."; // Current directory poisition
// Directory immediately above the current directory position
const char *parentdir = "..";
DiskFileB dir;
cout << "Creating " << dirname << " directory" <<endl;
if(dir.df_mkdir(dirname) != 0) {
cout << dir.df_GetFileError() << endl;
return;
}
if((dir.df_Exists(dirname)) && (dir.df_IsDirectory(dirname))) {
cout << "The " << dirname << " directory was created" << endl;
}
cout << "Changing directory to " << dirname << " directory" <<endl;
if(dir.df_chdir(dirname) != 0) {
cout << dir.df_GetFileError() << endl;
return;
}
char *pwd[df_MAX_DIR_LENGTH]; char drive_letter;
if(dir.df_pwd((char *)pwd) == 0) {
cout << "Present working directory: " << (char *)pwd << endl;
if(dir.df_HasDriveLetter((const char *)pwd, drive_letter)) {
cout << "DOS Drive letter = " << drive_letter << endl;
}
}
cout << "Changing directory to " << parentdir << " directory" <<endl;
if(dir.df_chdir(parentdir) != 0) {
cout << dir.df_GetFileError() << endl;
return;
}
if(dir.df_pwd((char *)pwd) == 0) {
cout << "Present working directory: " << (char *)pwd << endl;
if(dir.df_HasDriveLetter((const char *)pwd, drive_letter)) {
cout << "DOS Drive letter = " << drive_letter << endl;
}
}
cout << "Removing " << dirname << " directory" <<endl;
if(dir.df_rmdir(dirname) != 0) {
cout << dir.df_GetFileError() << endl;
return;
}
}
void FileTest()
{
cout << "Testing general purpose file functions"
<< endl;
const char *testfile1 = "testfile1.dat";
const char *testfile2 = "testfile2.dat";
const char *testfile3 = "testfile3.dat";
DiskFileB dfile(testfile1, DiskFileB::df_READWRITE, DiskFileB::df_CREATE,
DiskFileB::df_TRUNCATE, DiskFileB::df_SHARE);
if(!dfile) {
cout << "Could not open the " << testfile1 << endl;
return;
}
if((dfile.df_Exists(testfile1)) && (dfile.df_IsFile(testfile1))) {
cout << "The " << testfile1 << " file was opened with read/write access"
<< endl;
}
const char *teststr1 = "The quick brown fox jumps over the lazy dog \
0123456789\r\n";
cout << "Writing " << strlen(teststr1) << " bytes to " << testfile1 << endl;
if(dfile.df_Write((const char *)teststr1, strlen(teststr1)) != 0) {
cout << dfile.df_GetFileError() << endl;
return;
}
cout << testfile1 << " is " << (int)dfile.df_FileSize(testfile1)
<< " bytes long" << endl;
char *sbuf = new char[strlen(teststr1)+1];
cout << "Reading the file contents..." << endl;
if(dfile.df_Read((char *)sbuf, strlen(teststr1), (df_StreamPos)0) != 0) {
cout << dfile.df_GetFileError() << endl;
return;
}
sbuf[strlen(teststr1)] = '\0';
cout << sbuf;
delete sbuf;
dfile.df_Close();
cout << "Renaming the " << testfile1 << " to " << testfile2 << endl;
if(dfile.df_rename(testfile1, testfile2) != 0) {
cout << dfile.df_GetFileError() << endl;
return;
}
cout << "Copying " << testfile2 << " to " << testfile3 << endl;
if(dfile.df_copy(testfile2, testfile3) != 0) {
cout << dfile.df_GetFileError() << endl;
return;
}
cout << "Removing " << testfile2 << " and " << testfile3 << endl;
if(dfile.df_remove(testfile2) != 0) {
cout << dfile.df_GetFileError() << endl;
return;
}
if(dfile.df_remove(testfile3) != 0) {
cout << dfile.df_GetFileError() << endl;
return;
}
// Add routine to change file attributes/permissions here
// ------------------------------------------------------
}
void RandomSeekTest()
{
cout << "Performing random read/write test" << endl;
const char *testfile = "testfile.dat";
DiskFileB dfile(testfile, DiskFileB::df_READWRITE, DiskFileB::df_CREATE,
DiskFileB::df_TRUNCATE, DiskFileB::df_SHARE);
if(!dfile) {
cout << "Could not open the " << testfile << endl;
return;
}
if((dfile.df_Exists(testfile)) && (dfile.df_IsFile(testfile))) {
cout << "The " << testfile << " file was opened with read/write access"
<< endl;
}
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;
df_StreamPos pos[blocks_to_write];
fileblock hdr;
char sbuf[255];
cout << "Writing " << blocks_to_write << " blocks of data..." << endl;
for(i = 0; i < blocks_to_write; i++) {
pos[i] = dfile.df_FilePosition();
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..." << endl;
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] << endl;
cout << "Block size = " << hdr.block_length << endl;
cout << "Data = " << str << endl;
lines_printed++;
if(lines_printed >= max_lines) {
PausePrg();
lines_printed = 0;
}
}
dfile.df_Rewind();
cout << "Reading back the blocks in reverse order..." << endl;
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] << endl;
cout << "Block size = " << hdr.block_length << endl;
cout << "Data = " << str << endl;
lines_printed++;
if(lines_printed >= max_lines) {
PausePrg();
lines_printed = 0;
}
}
delete str;
dfile.df_Close();
cout << endl;
cout << "Removing " << testfile << endl;
if(dfile.df_remove(testfile) != 0) {
cout << dfile.df_GetFileError() << endl;
return;
}
return;
}
int main()
{
#ifdef __MSVC_DEBUG__
InitLeakTest();
#endif
cout << endl;
DirectoryTest();
PausePrg();
FileTest();
PausePrg();
RandomSeekTest();
cout << endl;
cout << "Exiting..." << endl;
cout << endl;
return 0;
}
// ----------------------------------------------------------- //
// ------------------------------- //
// --------- End of File --------- //
// ------------------------------- //