xref: /aoo41x/main/sal/workben/testfile.cxx (revision 87d2adbc)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sal.hxx"

#define UNICODE


#include <osl/file.hxx>
#include <osl/process.h>
#include <osl/time.h>
#include <rtl/alloc.h>
#include <rtl/ustring.hxx>
#include <stdio.h>
#include <string.h>
#include <time.h>


#ifdef UNX
#include <wchar.h>
#endif

#ifdef WNT
#include <windows.h>
#endif

using namespace	osl;
using namespace	rtl;

#define MAXIMPATH	256

rtl::OUString	root;

rtl::OUString	dir1;
rtl::OUString	dir2;
rtl::OUString	dir_on_server;
rtl::OUString	dir_not_exist;
rtl::OUString	dir_not_exist_on_server;
rtl::OUString	dir_wrong_semantic;

rtl::OUString	file1;
rtl::OUString	file2;
rtl::OUString	file3;
rtl::OUString	file_on_server;
rtl::OUString	file_not_exist;



void print_error(::rtl::OString& str, FileBase::RC rc);

void PressKey()
{
	printf("\nPress Return !\n");
	int i=getchar();
}

void printFileName(::rtl::OUString& str)
{
	rtl::OString		aString;

	aString = rtl::OUStringToOString( str, RTL_TEXTENCODING_ASCII_US );

	printf( "%s", aString.getStr() );

	return;
}

//--------------------------------------------------
// Initialization
//--------------------------------------------------

sal_Bool testLineBreak( sal_Char *pCount , sal_uInt64 nLen , sal_uInt32 *cLineBreak )
{
	sal_Bool fSuccess=sal_False;
	*cLineBreak=0;

	if (nLen==0)
		return fSuccess;

	if ( *pCount==13 )
	{
		if (nLen>=1 && *(pCount+1)==10)
			*cLineBreak=2;
		else
			*cLineBreak=1;

		if (nLen>=2 && *(pCount+2)==10)
			(*cLineBreak)++;

		fSuccess=sal_True;
	}
	else if ( *pCount==10 )
	{
		*cLineBreak=1;
		fSuccess=sal_True;
	}

	return fSuccess;
}

// Initialization

sal_Bool Initialize( void )
{
	DirectoryItem	aItem;
	FileStatus		aStatus( FileStatusMask_All );
	rtl_uString		*strExeFileURL=NULL;
	oslProcessError	ProcessError;

	rtl::OUString	iniFileURL;
	File			*pFile;
	sal_Unicode		*pExeFileCount;

	FileBase::RC	rc;

	sal_uInt64		uBytesRequested;
	sal_uInt64		uBytesRead;
    sal_Char		*pBuffer;
	sal_Char		*pBegin;
	sal_Char		*pCount;

	rtl::OUString	dir[12];

	// Open to the ini-file

	ProcessError=osl_getExecutableFile(&strExeFileURL);

	if ( ProcessError == osl_Process_E_None)
	{
		pExeFileCount=rtl_uString_getStr(strExeFileURL)+rtl_uString_getLength(strExeFileURL);

		// Search for the last slash in the Path
		while (*pExeFileCount!=L'/' && pExeFileCount>rtl_uString_getStr(strExeFileURL))
			pExeFileCount--;

		// iniFileURL = strExeFileURL without the filename of the exe-File
		iniFileURL=rtl::OUString( rtl_uString_getStr(strExeFileURL) ,(int) (pExeFileCount-rtl_uString_getStr(strExeFileURL)) );

		// add "/testfile.ini" to iniFileURL
		iniFileURL+=rtl::OUString::createFromAscii("/testfile.ini");

		// Open the ini-File
		pFile=new File( iniFileURL );
		rc=pFile->open( OpenFlag_Read | OpenFlag_Write );
		if ( rc!=FileBase::E_None )
		{
			rtl_uString_release(strExeFileURL);
			return sal_False;
		}
	}
	else
	{
		rtl_uString_release(strExeFileURL);
		return sal_False;
	}

	// Get filesize of the ini-File

	rc=DirectoryItem::get( iniFileURL, aItem );
	if ( rc!=FileBase::E_None )
		return sal_False;

	rc=aItem.getFileStatus( aStatus );
	if ( rc!=FileBase::E_None )
		return sal_False;

	uBytesRequested=aStatus.getFileSize();

	// read ini-File
	rc=pFile->setPos( Pos_Absolut, 0 );
	pBuffer=(sal_Char*) rtl_allocateMemory( (sal_uInt32) (uBytesRequested+1)*sizeof(sal_Char) );
	rtl_zeroMemory( pBuffer, (sal_uInt32)(uBytesRequested+1)*sizeof(sal_Char) );

	rc=pFile->read( pBuffer , uBytesRequested , uBytesRead );
	if ( rc!=FileBase::E_None )
		return sal_False;


	pBegin=pBuffer;
	pCount=pBegin;

	for ( int i=0 ; i<12 ; i++ )
	{
		sal_uInt32		cLineBrake=0;
		while ( (pCount-pBuffer < uBytesRead) && *pCount!='=')
			pCount++;

		pCount++;
		pBegin=pCount;

		while ( (pCount-pBuffer < uBytesRead) && !testLineBreak(pCount,uBytesRead-(pCount-pBuffer), &cLineBrake))
			pCount++;

		dir[i]=rtl::OUString(pBegin, pCount-pBegin, RTL_TEXTENCODING_ASCII_US);

		pCount+=cLineBrake;
		pBegin=pCount;
	}

	root=rtl::OUString(dir[0]);
	dir1=rtl::OUString(dir[1]);
	dir2=rtl::OUString(dir[2]);
	dir_on_server=rtl::OUString(dir[3]);
	dir_not_exist=rtl::OUString(dir[4]);
	dir_not_exist_on_server=rtl::OUString(dir[5]);
	dir_wrong_semantic=rtl::OUString(dir[6]);

	file1=rtl::OUString(dir[7]);
	file2=rtl::OUString(dir[8]);
	file3=rtl::OUString(dir[9]);
	file_on_server=rtl::OUString(dir[10]);
	file_not_exist=rtl::OUString(dir[11]);

	// close the ini-file
	rc=pFile->close();

	rtl_freeMemory( pBuffer );


	// Create directories
	rc=Directory::create( dir1 );
	if ( rc!=FileBase::E_None )
		return sal_False;

	rc=Directory::create( dir2 );
	if ( rc!=FileBase::E_None )
		return sal_False;

	rc=Directory::create( dir_on_server );
	if ( rc!=FileBase::E_None )
		return sal_False;

	pFile=new File( file1 );
	rc=pFile->open( OpenFlag_Write | OpenFlag_Create );
	if ( rc!=FileBase::E_None )
		return sal_False;
	rc=pFile->close();
	delete pFile;

	pFile=new File( file2 );
	rc=pFile->open( OpenFlag_Write | OpenFlag_Create );
	if ( rc!=FileBase::E_None )
		return sal_False;
	rc=pFile->close();
	delete pFile;

	pFile=new File( file_on_server );
	rc=pFile->open( OpenFlag_Write | OpenFlag_Create );
	if ( rc!=FileBase::E_None )
		return sal_False;
	rc=pFile->close();
	delete pFile;

	return sal_True;
}

//--------------------------------------------------
// Shutdown
//--------------------------------------------------

sal_Bool Shutdown( void )
{
	sal_Bool		fSuccess=sal_True;
	FileBase::RC	rc;
	File			*pFile;

	// remove created files

	pFile=new File( file1 );
	rc=pFile->remove( file1 );
	if ( rc!=FileBase::E_None )
		fSuccess=sal_False;
	delete pFile;

	pFile=new File( file2 );
	rc=pFile->remove( file2 );
	if ( rc!=FileBase::E_None )
		fSuccess=sal_False;
	delete pFile;

	// remove created directories

	rc=Directory::remove( dir1 );
	if ( rc!=FileBase::E_None )
		fSuccess=sal_False;

	rc=Directory::remove( dir2 );
	if ( rc!=FileBase::E_None )
		fSuccess=sal_False;

	// remove created file on the server

	pFile=new File( file_on_server );
	rc=pFile->remove( file_on_server );
	if ( rc!=FileBase::E_None )
		fSuccess=sal_False;
	delete pFile;

	// remove created directory on the server

	rc=Directory::remove( dir_on_server );
	if ( rc!=FileBase::E_None )
		fSuccess=sal_False;

	return fSuccess;
}

//--------------------------------------------------
// helper functions
//--------------------------------------------------

// Show FileType
void showFileType( FileStatus::Type aType )
{
	if ( aType==FileStatus::Directory )
		printf( "FileType: Directory \n" );
	else if ( aType==FileStatus::Volume )
		printf( "FileType: Volume \n" );
	else if ( aType==FileStatus::Regular )
		printf( "FileType: Regular \n" );
	else if ( aType==FileStatus::Unknown )
		printf( "FileType: Unknown \n" );

}

// Show Attributes
void showAttributes( sal_uInt64 uAttributes )
{
	if ( uAttributes==0 )
		printf( "No Attributes \n" );
	if ( uAttributes & Attribute_ReadOnly )
		printf( "Attribute: ReadOnly \n" );
	if ( uAttributes & Attribute_Hidden )
		printf( "Attribute: Hidden \n" );
	if ( uAttributes & Attribute_Executable )
		printf( "Attribute: Executable \n");
	if ( uAttributes & Attribute_GrpWrite )
		printf( "Attribute: GrpWrite \n");
	if ( uAttributes & Attribute_GrpRead )
		printf( "Attribute: GrpRead \n" );
	if ( uAttributes & Attribute_GrpExe )
		printf( "Attribute: GrpExe \n" );
	if ( uAttributes & Attribute_OwnWrite )
		printf( "Attribute: OwnWrite \n");
	if ( uAttributes & Attribute_OwnRead )
		printf( "Attribute: OwnRead \n" );
	if ( uAttributes & Attribute_OwnExe )
		printf( "Attribute: OwnExe \n" );
	if ( uAttributes & Attribute_OthWrite )
		printf( "Attribute: OthWrite \n" );
	if ( uAttributes & Attribute_OthRead )
		printf( "Attribute: OthRead \n");
	if ( uAttributes & Attribute_OthExe )
		printf( "Attribute: OthExe \n" );

	return;
}

// Show Time
void showTime( TimeValue aTime )
{
	TimeValue	aLocalTimeVal, aSystemTimeVal , aSysTimeVal;
	oslDateTime	aDateTime, aSystemTime;

	if ( osl_getLocalTimeFromSystemTime( &aTime, &aLocalTimeVal ) )
	{
		if ( osl_getDateTimeFromTimeValue( &aLocalTimeVal, &aDateTime ) )
		{
			printf("\t%02i.%02i.%4i , %02i.%02i.%02i Uhr\n", aDateTime.Day, aDateTime.Month, aDateTime.Year, aDateTime.Hours, aDateTime.Minutes, aDateTime.Seconds);
		}
		else
			printf("Error !\n");
	}

	if ( osl_getDateTimeFromTimeValue( &aTime, &aSystemTime ) )
	{
		printf("SystemTime: \t\t%02i.%02i.%4i , %02i.%02i.%02i Uhr\n", aSystemTime.Day, aSystemTime.Month, aSystemTime.Year, aSystemTime.Hours, aSystemTime.Minutes, aSystemTime.Seconds);
	}
	else
		printf("Error !\n");

	//Verify

	if ( osl_getTimeValueFromDateTime( &aSystemTime, &aSystemTimeVal ) )
	{
		if ( ( aSystemTimeVal.Seconds == aTime.Seconds ) && ( aSystemTimeVal.Nanosec == aTime.Nanosec ))
			printf ("Verify : TimeValue : ok! \n");
		else
		{
			printf ("Verify : TimeValue : Error! \n");
			printf ("aTime : %u \n", aTime.Seconds);
			printf ("aSystemTimeVal : %u \n", aSystemTimeVal.Seconds);
		}
	}
	else
		printf ("Verify : TimeValue : Error! \n");


	if ( osl_getSystemTimeFromLocalTime( &aLocalTimeVal , &aSysTimeVal ) )
	{
		if ( ( aSysTimeVal.Seconds == aTime.Seconds ) && ( aSysTimeVal.Nanosec == aTime.Nanosec ))
			printf ("Verify : SystemTime : ok! \n");
		else
		{
			printf ("Verify : SystemTime : Error! \n");
			printf ("aTime : %u\n", aTime.Seconds);
			printf ("aSystemTimeVal : %u\n", aSysTimeVal.Seconds);
		}
	}
	else
		printf ("Verify : SystemTime : Error! \n");

	return;
}

TimeValue getSystemTime()
{
	TimeValue	aTime;
	time_t ltime;

	time( &ltime );

	aTime.Seconds = ltime;
	aTime.Nanosec = 0;

	return aTime;
}


//--------------------------------------------------
// DirectoryOpenAndCloseTest
//--------------------------------------------------

void DirectoryOpenAndCloseTest( void )
{
	FileBase::RC	rc;
	int i=0;
	Directory	*pDir;

	printf( "--------------------------------------------\n");
	printf( "Directory-Open-And-Close-Test\n");
	printf( "--------------------------------------------\n\n");

	//--------------------------------------------------
	// open an existing directory
	//--------------------------------------------------

	pDir=new Directory( dir1 );
	printf( "Open an existing directory: ");
	printFileName( dir1 );
	printf( "\n" );

	rc= pDir->open();
	print_error( rtl::OString( "Open Directory" ), rc );

	if ( pDir->isOpen() )
	{
		print_error( rtl::OString( "Directory is Open" ), rc );
	}

	// Close Directory
	rc=pDir->close();
	print_error( rtl::OString( "Close Directory" ), rc );

	delete pDir;
	printf( "\n" );

	//--------------------------------------------------
	// open a not existing directory
	//--------------------------------------------------

	pDir=new Directory( dir_not_exist );

	printf( "Open a not existing directory: ");
	printFileName( dir_not_exist );
	printf( "\n" );

	rc= pDir->open();

	print_error( rtl::OString( "Open Directory" ), rc );

	delete pDir;

	printf( "\n" );

	//--------------------------------------------------
	// open a directory with a wrong semantic
	//--------------------------------------------------
	pDir=new Directory( dir_wrong_semantic );

	printf( "Open a directory with a wrong semantic: ");
	printFileName( dir_wrong_semantic );
	printf( "\n" );

	rc= pDir->open();
	print_error( rtl::OString( "Open Directory" ), rc );

	delete pDir;

	printf( "\n" );

	//--------------------------------------------------
	// open an existing directory on a server
	//--------------------------------------------------

	pDir=new Directory( dir_on_server );

	printf( "Open an existing directory on a server: ");
	printFileName( dir_on_server );
	printf( "\n" );

	rc= pDir->open();
	print_error( rtl::OString( "Open Directory" ), rc );

	// Close Directory
	rc=pDir->close();
	print_error( rtl::OString( "Close Directory" ), rc );

	delete pDir;
	printf( "\n" );

	//--------------------------------------------------
	// open a not existing directory on a server
	//--------------------------------------------------

	pDir=new Directory( dir_not_exist_on_server );

	printf( "Open a not existing directory on a server: ");
	printFileName( dir_not_exist_on_server );
	printf( "\n" );

	rc= pDir->open();
	print_error( rtl::OString( "Open Directory" ), rc );

	delete pDir;
	printf( "\n" );

	//--------------------------------------------------
	// Close a not existing directory
	//--------------------------------------------------

	pDir=new Directory( dir_not_exist );
	printf( "Close a not existing directory: ");
	printFileName( dir_not_exist );
	printf( "\n" );

	rc=pDir->close();
	print_error( rtl::OString( "Close Directory" ), rc );

	PressKey();
	return;

}

//--------------------------------------------------
// DirectoryCreateAndRemoveTest
//--------------------------------------------------

void DirectoryCreateAndRemoveTest( void )
{
	FileBase::RC	rc,rc1;
	int i=0;
	Directory	*pDir;

	printf( "--------------------------------------------\n" );
	printf( "Directory-Create-And-Remove-Test\n" );
	printf( "--------------------------------------------\n\n" );

	//--------------------------------------------------
	// Create directory
	//--------------------------------------------------
	printf( "Create a not existing directory: ");
	printFileName( dir_not_exist );
	printf( "\n" );

	rc=Directory::create( dir_not_exist) ;
	print_error( rtl::OString( "Create Directory" ), rc );

	// Verify
	pDir=new Directory( dir_not_exist );

	rc= pDir->open();
	print_error( rtl::OString( "Verify" ), rc );
	pDir->close();
	delete pDir;

	printf( "\n" );

	//--------------------------------------------------
	// Create a directory on a server
	//--------------------------------------------------

	printf( "Create a not existing directory on a server: ");
	printFileName( dir_not_exist_on_server );
	printf( "\n" );

	rc=Directory::create( dir_not_exist_on_server );
	print_error( rtl::OString( "Create Directory" ), rc );

	// Verify
	pDir=new Directory( dir_not_exist_on_server );
	rc= pDir->open();
	print_error( rtl::OString( "Verify" ), rc );
	pDir->close();
	delete pDir;

	printf( "\n" );

	//--------------------------------------------------
	// Remove Directories
	//--------------------------------------------------

	printf( "Remove the created directories: \n" );

	rc=Directory::remove( dir_not_exist );

	rc1=Directory::remove( dir_not_exist_on_server );

	if ( rc==FileBase::E_None && rc1==FileBase::E_None )
		print_error( rtl::OString( "Remove Directories" ), FileBase::E_None );
	else if ( rc!=FileBase::E_None )
		print_error( rtl::OString( "Remove local Directory" ),rc );
	else
		print_error( rtl::OString( "Remove Directory on a server" ),rc1 );

	printf( "\n" );

	//--------------------------------------------------
	// Remove a not existing directory
	//--------------------------------------------------

	printf( "Remove a not existing directory: ");
	printFileName( dir_not_exist );
	printf( "\n" );

	rc=Directory::remove( dir_not_exist );
	print_error( rtl::OString( "Remove" ),rc );

	PressKey();
	return;
}

//--------------------------------------------------
// FileOpenAndCloseTest
//--------------------------------------------------

static void FileOpenAndCloseTest( void )
{
	FileBase::RC	rc;
	int i=0;

	printf( "--------------------------------------------\n" );
	printf( "File-Open-And-Close-Test\n" );
	printf( "--------------------------------------------\n\n" );

	File	*pFile;

	pFile=new File( file1 );

	printf( "Open an existing file: ");
	printFileName( file1 );
	printf( "\n" );

	//--------------------------------------------------
	// open an existing file (Read)
	//--------------------------------------------------

	rc=pFile->open( OpenFlag_Read );
	print_error( rtl::OString( "Open File (Read)" ), rc );

	//--------------------------------------------------
	// close the file
	//--------------------------------------------------

	rc=pFile->close();
	print_error( rtl::OString( "Close File" ), rc );

	printf( "\n" );

	//--------------------------------------------------
	// open an existing file (Write)
	//--------------------------------------------------

	rc=pFile->open( OpenFlag_Write );
	print_error( rtl::OString( "Open File (Write)" ), rc );

	//--------------------------------------------------
	// close the file
	//--------------------------------------------------

 	rc=pFile->close();
	print_error( rtl::OString( "Close File" ), rc );

	printf( "\n" );

	//--------------------------------------------------
	// close the file a second time
	//--------------------------------------------------

 	rc=pFile->close();
	print_error( rtl::OString( "Close the file a second time" ), rc );

	delete pFile;
	PressKey();
}

//--------------------------------------------------
// FileCreateAndRemoveTest
//--------------------------------------------------

void FileCreateAndRemoveTest()
{
	FileBase::RC	rc;
	File	*pFile;

	printf( "--------------------------------------------\n" );
	printf( "File-Create-And-Remove-Test\n" );
	printf( "--------------------------------------------\n\n" );

	pFile=new File( file_not_exist );

	printf( "Create File: ");
	printFileName( file_not_exist );
	printf( "\n" );

	//----------------------------------------------------
	// open (create) a not existing file (Read and write)
	//----------------------------------------------------

	rc = pFile->open( OpenFlag_Read | OpenFlag_Write | osl_File_OpenFlag_Create );

	print_error( rtl::OString( "Create and Open File (Read & Write)" ), rc );

	//----------------------------------------------------
	// close the file
	//----------------------------------------------------

	rc=pFile->close();
	print_error( rtl::OString( "Close File" ), rc );

	//----------------------------------------------------
	// remove the file
	//----------------------------------------------------

	rc=pFile->remove( file_not_exist );
	print_error( rtl::OString(" Remove File" ), rc );

	printf( "\n" );

	//----------------------------------------------------
	// remove the same file a second time
	//----------------------------------------------------
	rc=pFile->remove( file_not_exist );
	print_error( rtl::OString( "Remove a not existing File" ), rc );

	//----------------------------------------------------
	// remove an open file
	//----------------------------------------------------

	pFile->open( OpenFlag_Read | OpenFlag_Write | osl_File_OpenFlag_Create );

	rc=pFile->remove( file_not_exist );
	print_error( rtl::OString( "Remove an open File" ), rc );

	pFile->close();
	pFile->remove( file_not_exist );

	PressKey();

	return;
}

//--------------------------------------------------
// FileWriteAndReadTest
//--------------------------------------------------

void FileWriteAndReadTest( void )
{
	FileBase::RC	rc;

	sal_uInt64 uWritten;
	sal_uInt64 uRead;
	sal_Char	*pWriteBuffer="Hier kommt der Osterhase !";
	sal_uInt64	nLen=strlen( pWriteBuffer );
	sal_Char *pReadBuffer;

	printf( "--------------------------------------------\n" );
	printf( "File-Write-And-Read-Test\n" );
	printf( "--------------------------------------------\n\n" );

	File	*pFile;

	pFile=new File( file_not_exist );

	printf( "Create File: ");
	printFileName( file_not_exist );
	printf("\n");

	//----------------------------------------------------
	// open (create) a not existing file (Read and write)
	//----------------------------------------------------

	rc = pFile->open( OpenFlag_Read | OpenFlag_Write | osl_File_OpenFlag_Create );

	print_error( rtl::OString( "Create and Open File (Read & Write)" ), rc );

	printf( "\n" );

	//----------------------------------------------------
	// write a string to the file
	//----------------------------------------------------
	rc=pFile->write( pWriteBuffer , nLen , uWritten );
	print_error( rtl::OString( "Write File" ), rc );

	if(uWritten==nLen)
		printf( "Verify: OK! \n" );
	else
		printf( "Verify: Error\n" );

	printf( "\n" );

	//----------------------------------------------------
	// move the filepointer to the beginning
	//----------------------------------------------------

	rc=pFile->setPos( Pos_Absolut , 0 );
	print_error( rtl::OString( "Set FilePointer to the beginning of the file" ), rc );

	printf( "\n" );

	//----------------------------------------------------
	// read the string
	//----------------------------------------------------

	pReadBuffer=(sal_Char*) rtl_allocateMemory( (sal_uInt32)(nLen+1)*sizeof(sal_Char) );
	rtl_zeroMemory( pReadBuffer, (sal_uInt32)(nLen+1)*sizeof(sal_Char) );
	rc=pFile->read( pReadBuffer , nLen,uRead );
	print_error( rtl::OString( "Read File" ), rc );

	if (strcmp(pWriteBuffer, pReadBuffer)==0)
	{
		printf( "Verify: OK !\n" );
		printf( "Text: %s\n",pReadBuffer );
	}
	else
		printf( "Verify: Error\n" );

	rtl_freeMemory( pReadBuffer );

	printf( "\n" );

	// close the file
	rc=pFile->close();
	print_error( rtl::OString( "Close File" ), rc );

	// remove the file
	rc=pFile->remove( file_not_exist );
	print_error( rtl::OString( "Remove File" ), rc );

	PressKey();

	return;

}

//--------------------------------------------------
// FileCopyMoveTest
//--------------------------------------------------

void FileCopyAndMoveTest( void )
{
	FileBase::RC	rc;

	printf( "--------------------------------------------\n" );
	printf( "File-Copy-Move-Test\n" );
	printf( "--------------------------------------------\n\n" );


	File	*pFile;
	rtl::OUString	destPath(dir2);

	//--------------------------------------------------
	// FileCopyTest
	//--------------------------------------------------

	destPath+=rtl::OUString::createFromAscii("/");
	destPath+=file3;

	printf( "Copy the file ");
	printFileName( file1 );
	printf( " to ");
	printFileName( destPath );
	printf( "\n" );


	rc=File::copy( file1 , destPath );
	print_error( rtl::OString( "FileCopy" ), rc );

	pFile=new File( destPath );

	rc=pFile->open( OpenFlag_Read );
	if ( rc == FileBase::E_None)
	{
		printf( "Verify: OK!\n" );
		pFile->close();
		File::remove( destPath );
	}
	else
		printf( "Verify: Error!\n" );

	delete pFile;

	printf( "\n" );

	//--------------------------------------------------
	// Copy a file to a not existing directory
	//--------------------------------------------------

	destPath=rtl::OUString( dir_not_exist );
	destPath+=rtl::OUString::createFromAscii("/");
	destPath+=file3;

	printf( "Copy a file to a not existing directory \n");
	printf( "Copy the file  %s to %s\n", file1.getStr(), destPath.getStr() );

	rc=File::copy( file1, destPath );
	print_error( rtl::OString( "FileCopy" ), rc );

	printf( "\n" );

	//--------------------------------------------------
	// Copy a directory
	//--------------------------------------------------

	printf( "Copy the directory: ");
	printFileName( dir1 );
	printf( " to ");
	printFileName( dir2 );
	printf( "\n" );

	rc=File::copy( dir1 , dir2 );
	print_error( rtl::OString( "FileCopy" ), rc );

	printf( "\n" );

	//--------------------------------------------------
	// FileMoveTest
	//--------------------------------------------------

	destPath=rtl::OUString( dir2 );
	destPath+=rtl::OUString::createFromAscii("/");
	destPath+=file3;

	printf( "Move the file ");
	printFileName( file1 );
	printf( " to ");
	printFileName( destPath );
	printf( "\n" );

	rc=File::move( file1, destPath );
	print_error( rtl::OString( "FileMove" ), rc );

	pFile=new File( destPath );

	rc=pFile->open( OpenFlag_Read );
	if ( rc==FileBase::E_None )
	{
		pFile->close();

		delete pFile;
		pFile=new File( file1 );

		rc=pFile->open( OpenFlag_Read );

		if ( rc!=FileBase::E_None )
		{
			printf( "Verify: OK!\n" );
			File::move( destPath, file1 );
		}
		else
		{
			printf( "Verify: Error!\n" );
			pFile->close();
			File::remove( destPath );
		}
	}
	else
		printf( "Verify: Error!\n" );

	delete pFile;

	printf( "\n" );


	//--------------------------------------------------
	// Move a file to a not existing directory
	//--------------------------------------------------

	destPath=rtl::OUString( dir_not_exist );
	destPath+=rtl::OUString::createFromAscii("/");
	destPath+=file3;

	printf( "Move a file to a not existing directory: \n");
	printf( "Move the file ");
	printFileName( file1 );
	printf( " to ");
	printFileName( destPath );
	printf( "\n" );

	rc=File::move( file1 , destPath );
	print_error( rtl::OString( "FileMove" ), rc );

	printf( "\n" );

	//--------------------------------------------------
	// Move a directory
	//--------------------------------------------------

	printf( "Move a directory: \n");

	printf( "Move the directory ");
	printFileName( dir1 );
	printf( " to ");
	printFileName( dir_not_exist );
	printf( "\n" );


	rc=File::move( dir1 , dir_not_exist);
	print_error( rtl::OString( "FileMove" ), rc );

	if ( rc == FileBase::E_None )
		File::move( dir_not_exist , dir1);

	printf( "\n" );


	PressKey();
	return;
}

//----------------------------------------------------
// FileSizeTest
//----------------------------------------------------

void FileSizeTest( void )
{
	FileBase::RC	rc;
	sal_uInt64		filesize;
	DirectoryItem	aItem;

	printf( "--------------------------------------------\n" );
	printf( "File-Size-Test\n" );
	printf( "--------------------------------------------\n\n" );


	File	aFile( file_not_exist );

	printf( "Create File: ");
	printFileName( file_not_exist );
	printf( "\n\n");

	rc = aFile.open( OpenFlag_Read | OpenFlag_Write | osl_File_OpenFlag_Create );
	print_error( rtl::OString( "Create and Open File (Read & Write)" ), rc );
	printf( "\n" );

	if ( rc == FileBase::E_None )
	{
		//----------------------------------------------------
		// Set Filesize to 5000
		//----------------------------------------------------

		printf( "Set FileSize to 5000\n" );
		rc=aFile.setSize( 5000 );
		print_error( rtl::OString( "Set FileSize" ), rc );

		printf( "\n" );
		printf( "Verify:\n" );

		//----------------------------------------------------
		// Check whether Filesize is set to 5000
		//----------------------------------------------------

		rc=DirectoryItem::get( file_not_exist, aItem );
		print_error( rtl::OString( "Get DirectoryItem" ), rc );

		if ( rc == FileBase::E_None )
		{
			FileStatus rStatus( FileStatusMask_FileSize  );
			rc=aItem.getFileStatus( rStatus );
			print_error( rtl::OString( "Get FileStatus" ), rc );

			if ( rc == FileBase::E_None )
			{
				filesize=rStatus.getFileSize();

				if ( filesize == 5000 )
					printf( "\nOK : FileSize: %i\n", filesize );
				else
					printf( "\nError : FileSize: %i\n", filesize );
			}
		}

		printf( "\n" );

		//----------------------------------------------------
		// Set Filesize to -1
		//----------------------------------------------------

		printf( "Set FileSize to -1\n" );
		rc=aFile.setSize( -1 );
		print_error( rtl::OString( "Set FileSize" ), rc );

		printf( "\n" );

		// close the file
		rc=aFile.close();
		print_error( rtl::OString( "Close File" ), rc );

		// remove the file
		rc=File::remove( file_not_exist );
		print_error( rtl::OString( "Remove File" ), rc );
	}

	PressKey();

	return;
}


//----------------------------------------------------
// FilePointerTest
//----------------------------------------------------

void FilePointerTest( void )
{
	FileBase::RC	rc;
	sal_uInt64 filepointer;

	printf( "--------------------------------------------\n" );
	printf( "File-Pointer-Test\n" );
	printf( "--------------------------------------------\n\n" );


	File	rFile( file_not_exist );

	printf( "Create File: ");
	printFileName( file_not_exist );
	printf( "\n\n");

	rc = rFile.open( OpenFlag_Read | OpenFlag_Write | osl_File_OpenFlag_Create );
	print_error( rtl::OString( "Create and Open File (Read & Write) "), rc );
	printf( "\n" );

	if ( rc==FileBase::E_None )
	{

		//----------------------------------------------------
		// get the position of the filepointer
		//----------------------------------------------------

		rc =rFile.getPos( filepointer );
		print_error( rtl::OString( "GetPos" ), rc );
		printf( "Position of the FilePointer: %i\n", filepointer );

		printf( "\n" );

		//----------------------------------------------------
		// set the filepointer at the end of a file
		//----------------------------------------------------

		printf( "Set FileSize to 5000\n" );
		rFile.setSize( 5000 );

		printf( "Set the FilePointer at the end of the file (5000)\n" );
		rc=rFile.setPos( Pos_End,0 );
		print_error( rtl::OString( "SetPos" ), rc );

		rc=rFile.getPos( filepointer );

		if ( filepointer==5000 )
		{
			print_error( rtl::OString( "GetPos" ), rc );
			printf( "\nVerify: OK !\n" );
			printf( "Filepointer-Position: %llu\n",filepointer );
		}
		else
		{
			print_error( rtl::OString( "GetPos" ), rc );
			printf( "\nFilePointer-Test: Error\n" );
			printf( "Filepointer-Position: %i != 5000 \n",filepointer );
		}

		printf( "\n" );

		// close the file
		rc=rFile.close();
		print_error( rtl::OString( "Close File" ), rc );

		// remove the file
		rc=File::remove( file_not_exist );
		print_error( rtl::OString( "Remove File" ), rc );
	}

	PressKey();

	return;
}

//--------------------------------------------------
// FileAttributesTest
//--------------------------------------------------

void verifyFileAttributes( void )
{
	FileBase::RC	rc;
	DirectoryItem	aItem;
	FileStatus rStatus( FileStatusMask_Attributes  );

	printf( "\nVerify:\n" );

	rc=DirectoryItem::get( file1, aItem );

	if ( rc==FileBase::E_None )
	{
		rc=aItem.getFileStatus( rStatus );

		if ( rc==FileBase::E_None )
		{
			sal_uInt64 uAttributes=rStatus.getAttributes();
			showAttributes(uAttributes);
			printf( "\n" );
		}
		else
			print_error( rtl::OString( "Get FileStatus" ), rc );
	}
	else
		print_error( rtl::OString( "Get DirectoryItem" ), rc );

	return;
}

#ifdef UNX
void FileAttributesTest( void )
{
	FileBase::RC	rc;

	printf( "--------------------------------------------\n" );
	printf( "File-Attributes-Test\n" );
	printf( "--------------------------------------------\n\n" );

	printf( "File: ");
	printFileName( file1 );
	printf( "\n\n" );


	rc=File::setAttributes( file1, Attribute_GrpWrite );
	print_error( rtl::OString( "Set Attribute: GrpWrite" ), rc );

	verifyFileAttributes();

	rc=File::setAttributes( file1, 0 );
	if ( rc!=FileBase::E_None )
		print_error( rtl::OString( "Reset Attributes" ), rc );

	rc=File::setAttributes( file1, Attribute_GrpRead );
	print_error( rtl::OString( "Set Attribute: GrpRead" ), rc );

	verifyFileAttributes();

	rc=File::setAttributes( file1, 0 );
	if ( rc!=FileBase::E_None )
		print_error( rtl::OString( "Reset Attributes" ), rc );

	rc=File::setAttributes( file1, Attribute_GrpExe );
	print_error( rtl::OString( "Set Attribute: GrpExe" ), rc );

	verifyFileAttributes();

	rc=File::setAttributes( file1, 0 );
	if ( rc!=FileBase::E_None )
		print_error( rtl::OString( "Reset Attributes" ), rc );

	rc=File::setAttributes( file1, Attribute_OwnWrite );
	print_error( rtl::OString( "Set Attribute: OwnWrite" ), rc );

	verifyFileAttributes();

	rc=File::setAttributes( file1, 0 );
	if ( rc!=FileBase::E_None )
		print_error( rtl::OString( "Reset Attributes" ), rc );

	rc=File::setAttributes( file1, Attribute_OwnRead );
	print_error( rtl::OString( "Set Attribute: OwnRead" ), rc );

	verifyFileAttributes();

	rc=File::setAttributes( file1, 0 );
	if ( rc!=FileBase::E_None )
		print_error( rtl::OString( "Reset Attributes" ), rc );

	rc=File::setAttributes( file1, Attribute_OwnExe );
	print_error( rtl::OString( "Set Attribute: OwnExe" ), rc );

	verifyFileAttributes();

	rc=File::setAttributes( file1, 0 );
	if ( rc!=FileBase::E_None )
		print_error( rtl::OString( "Reset Attributes" ), rc );

	rc=File::setAttributes( file1, Attribute_OthWrite );
	print_error( rtl::OString( "Set Attribute: OthWrite" ), rc );

	verifyFileAttributes();

	rc=File::setAttributes( file1, 0 );
	if ( rc!=FileBase::E_None )
		print_error( rtl::OString( "Reset Attributes" ), rc );

	rc=File::setAttributes( file1, Attribute_OthRead );
	print_error( rtl::OString( "Set Attribute: OthRead" ), rc );

	verifyFileAttributes();

	rc=File::setAttributes( file1, 0 );
	if ( rc!=FileBase::E_None )
		print_error( rtl::OString( "Reset Attributes" ), rc );

	rc=File::setAttributes( file1, Attribute_OthExe );
	print_error( rtl::OString( "Set Attribute: OthExe" ), rc );

	verifyFileAttributes();

	rc=File::setAttributes( file1, 0 );
	if ( rc!=FileBase::E_None )
		print_error( rtl::OString( "Reset Attributes" ), rc );


	rc=File::setAttributes( file1, Attribute_GrpWrite | Attribute_GrpRead | Attribute_GrpExe | Attribute_OwnWrite | Attribute_OwnRead | Attribute_OwnExe | Attribute_OthWrite | Attribute_OthRead | Attribute_OthExe );
	print_error( rtl::OString( "Set all Attributes" ), rc );

	verifyFileAttributes();

	PressKey();

	return;
}
#endif

#ifdef WNT
void FileAttributesTest( void )
{
	FileBase::RC	rc;

	printf( "--------------------------------------------\n" );
	printf( "File-Attributes-Test\n" );
	printf( "--------------------------------------------\n\n" );

	printf( "File: ");
	printFileName( file1 );
	printf( "\n\n" );


	rc=File::setAttributes( file1, Attribute_ReadOnly );
	print_error( rtl::OString( "Set Attribute: ReadOnly" ), rc );

	verifyFileAttributes();

	rc=File::setAttributes( file1, 0 );
	print_error( rtl::OString( "Reset Attributes" ), rc );

	verifyFileAttributes();

	rc=File::setAttributes( file1, Attribute_Hidden );
	print_error( rtl::OString( "Set Attribute: Hidden" ), rc );

	verifyFileAttributes();

	rc=File::setAttributes( file1, 0 );
	print_error( rtl::OString( "Reset Attributes" ), rc );

	verifyFileAttributes();

	rc=File::setAttributes( file1, Attribute_Hidden | Attribute_ReadOnly );
	print_error( rtl::OString( "Set Attribute: Hidden & ReadOnly" ), rc );

	verifyFileAttributes();

	rc=File::setAttributes( file1, 0 );
	print_error( rtl::OString( "Reset Attributes") , rc );

	verifyFileAttributes();

	PressKey();

	return;
}
#endif

//--------------------------------------------------
// FileTimeTest
//--------------------------------------------------

void FileTimeTest( void )
{
	FileBase::RC	rc;

	DirectoryItem	aItem;

	struct tm sSysCreationTime = { 0, 20, 12, 4, 9, 100 };
	struct tm sSysAccessTime = { 0, 40, 1, 6, 5, 98 };
	struct tm sSysModifyTime = { 0, 1, 24, 13, 11, 95 };

	time_t aSysCreationTime =  mktime( &sSysCreationTime );
	time_t aSysAccessTime =  mktime( &sSysAccessTime );
	time_t aSysModifyTime =  mktime( &sSysModifyTime );

	TimeValue		aCreationTime	= { aSysCreationTime, 0};
	TimeValue		aAccessTime		= { aSysAccessTime, 0};
	TimeValue		aModifyTime		= { aSysModifyTime, 0};

	TimeValue		aCreationTimeRead;
	TimeValue		aAccessTimeRead;
	TimeValue		aModifyTimeRead;


	printf( "--------------------------------------------\n" );
	printf( "File-Time-Test\n" );
	printf( "--------------------------------------------\n\n" );

	printf( "File: ");
	printFileName( file1 );
	printf( "\n\n" );

	printf( "CreationTime \t : ");
	showTime( aCreationTime );

	printf( "\nAccessTime \t : ");
	showTime( aAccessTime );

	printf( "\nModifyTime \t : ");
	showTime( aModifyTime );

	//--------------------------------------------------
	// setTime
	//--------------------------------------------------

	printf( "\n" );
	rc=File::setTime( file1 , aCreationTime , aAccessTime , aModifyTime );
	print_error( rtl::OString( "SetTime" ), rc );

	//--------------------------------------------------
	// Verify
	//--------------------------------------------------

	FileStatus rStatus( FileStatusMask_CreationTime | FileStatusMask_AccessTime | FileStatusMask_ModifyTime);

	printf( "\nVerify:\n" );

	rc=DirectoryItem::get( file1, aItem );
	print_error( rtl::OString( "Get DirectoryItem" ), rc );

	if ( rc==FileBase::E_None )
	{
		rc=aItem.getFileStatus( rStatus );
		print_error( rtl::OString( "Get FileStatus" ), rc );
		printf( "\n" );

		if ( rc==FileBase::E_None )
		{
			//--------------------------------------------------
			// GetCreationTime
			//--------------------------------------------------

			aCreationTimeRead=rStatus.getCreationTime();
#ifdef WNT
			if ( aCreationTime.Seconds == aCreationTimeRead.Seconds && aCreationTime.Nanosec == aCreationTimeRead.Nanosec )
				printf( "GetCreationTime: ok : " );
			else
				printf( "GetCreationTime: Error : " );

			showTime( aCreationTimeRead );
			printf( "\n" );
#endif
			//--------------------------------------------------
			// GetAccessTime
			//--------------------------------------------------

			aAccessTimeRead=rStatus.getAccessTime();

			if ( aAccessTime.Seconds == aAccessTimeRead.Seconds && aAccessTime.Nanosec == aAccessTimeRead.Nanosec )
				printf( "GetAccessTime: ok : " );
			else
				printf( "GetAccessTime: Error : " );

			showTime( aAccessTimeRead );
			printf( "\n" );

			//--------------------------------------------------
			// GetModifyTime
			//--------------------------------------------------

			aModifyTimeRead=rStatus.getModifyTime();

			if ( aModifyTime.Seconds == aModifyTimeRead.Seconds && aModifyTime.Nanosec == aModifyTimeRead.Nanosec )
				printf( "GetModifyTime: ok : " );
			else
				printf( "GetModifyTime: Error : " );

			showTime( aModifyTimeRead );
			printf( "\n" );
		}
	}

	PressKey();
	return;
}


//--------------------------------------------------
// DirectoryItemTest
//--------------------------------------------------

void DirectoryItemTest( void )
{
	FileBase::RC	rc;
	Directory		*pDir;
	DirectoryItem	aItem;
	FileStatus		*pStatus;
	File			*pFile;

	printf( "--------------------------------------------\n" );
	printf( "Directory-Item-Test\n" );
	printf( "--------------------------------------------\n\n" );

	//--------------------------------------------------
	// get DirectoryItem from an existing directory
	//--------------------------------------------------

	printf( "Get DirectoryItem from an existing Directory: ");
	printFileName( dir1 );
	printf( "\n");

	rc=DirectoryItem::get( dir1 , aItem );
	print_error( rtl::OString( "GetDirectoryItem" ), rc );

	pStatus=new FileStatus( FileStatusMask_All );
	rc=aItem.getFileStatus( *pStatus );

	if ( rc==FileBase::E_None )
	{
		printf( "GetFileStatus: FileURL: ");
		printFileName(pStatus->getFileURL() );
		printf( "\n" );
	}

	delete pStatus;

	printf( "\n" );

	//--------------------------------------------------
	// get DirectoryItem from a not existing directory
	//--------------------------------------------------

	printf( "Get DirectoryItem from a not existing Directory: ");
	printFileName( dir_not_exist );
	printf( "\n" );

	rc=DirectoryItem::get( dir_not_exist , aItem );
	print_error( rtl::OString( "Get DirectoryItem" ), rc );

	printf( "\n" );

	//--------------------------------------------------
	// get DirectoryItem from an existing file
	//--------------------------------------------------

	printf( "Get DirectoryItem from an existing File: ");
	printFileName( file1 );
	printf( "\n" );

	rc=DirectoryItem::get( file1 , aItem );
	print_error( rtl::OString( "GetDirectoryItem" ), rc );

	pStatus=new FileStatus( FileStatusMask_All );
	rc=aItem.getFileStatus( *pStatus );

	if ( rc==FileBase::E_None )
	{
		printf( "GetFileStatus: FileURL: ");
		printFileName( pStatus->getFileURL() );
		printf( "\n" );
	}

	delete pStatus;

	printf( "\n" );

	//--------------------------------------------------
	// get DirectoryItem from a not existing file
	//--------------------------------------------------

	printf( "Get DirectoryItem from a not existing File: ");
	printFileName( file_not_exist );
	printf( "\n" );

	rc=DirectoryItem::get( file_not_exist , aItem );
	print_error( rtl::OString( "Get DirectoryItem" ), rc );

	printf( "\n" );

	//----------------------------------------------------------
	// get DirectoryItem from a directory with a wrong semantic
	//----------------------------------------------------------

	printf( "Get DirectoryItem from a Directory with a wrong semantic: ");
	printFileName( dir_not_exist );
	printf( "\n" );

	rc=DirectoryItem::get( dir_wrong_semantic, aItem );
	print_error( rtl::OString( "Get DirectoryItem" ),rc );

	printf( "\n" );

	//---------------------------------------------------
	// get DirectoryItem from a file-handle
	//--------------------------------------------------

	pFile=new File( file1 );

	rc=pFile->open( OpenFlag_Read );
	if ( rc==FileBase::E_None )
	{
		printf( "Get DirectoryItem from a File-Handle: ");
		printFileName( file1 );
		printf( "\n" );

		rc=DirectoryItem::get( *pFile , aItem );
		print_error( rtl::OString( "GetDirectoryItem" ), rc );

		pStatus=new FileStatus( FileStatusMask_All );
		rc=aItem.getFileStatus( *pStatus );

		if ( rc==FileBase::E_None )
		{
			printf( "GetFileStatus: FileURL:  ");
			printFileName( pStatus->getFileURL() );
			printf( "\n");
		}

		delete pStatus;

		pFile->close();
	}

	delete pFile;

	printf( "\n" );

	//---------------------------------------------------
	// get DirectoryItem from an empty file-handle
	//--------------------------------------------------

	pFile=new File( file1 );

	printf( "Get DirectoryItem from an empty File-Handle\n" );
	rc=DirectoryItem::get( *pFile , aItem );
	print_error( rtl::OString( "GetDirectoryItem" ), rc );

	delete pFile;

	printf( "\n" );

	//--------------------------------------------------
	// GetNextItem from a directory
	//--------------------------------------------------

	pDir=new Directory( dir1 );
	printf( "Get next DirectoryItem from a directory: ");
	printFileName( dir1);
	printf( "\n" );

	rc= pDir->open();
	print_error( rtl::OString( "Open Directory" ), rc );

	printf( "\n" );

	if ( pDir->isOpen() )
	{
		//--------------------------------------------------
		// get all files from the directory
		//--------------------------------------------------

		rtl::OUString	str;
		rtl::OUString	str1[2];

		aItem=DirectoryItem();
		rc=pDir->getNextItem( aItem );
		print_error( rtl::OString( "GetNextItem" ),rc );

		while( rc==FileBase::E_None )
		{

			FileStatus rStatus( FileStatusMask_All );
			aItem.getFileStatus( rStatus );

			str=rStatus.getFileName();
			printf( "Filename: ");
			printFileName( str );
			printf( "\n");

			aItem=DirectoryItem();
			rc=pDir->getNextItem( aItem );
			print_error( rtl::OString( "GetNextItem" ),rc );
		}

		printf( "\n" );

		//--------------------------------------------------
		// Reset-Test
		//--------------------------------------------------

		for (int i=0; i<2; i++)
		{
			aItem=DirectoryItem();
			rc=pDir->reset();
			rc=pDir->getNextItem( aItem );

			FileStatus rStatus( FileStatusMask_All );
			aItem.getFileStatus( rStatus );

			str1[i]=rStatus.getFileName();
		}


		if ( str1[0].compareTo(str1[1]) == 0 )
			print_error( rtl::OString( "Reset" ),FileBase::E_None );
		else
			print_error( rtl::OString( "Reset" ),FileBase::E_invalidError );

		printf( "\n" );

		// Close Directory
		rc=pDir->close();
		print_error( rtl::OString( "Close Directory" ), rc );
	}

	printf( "\n");

	//--------------------------------------------------
	// GetNextItem from a closed directory
	//--------------------------------------------------

	printf( "Get next DirectoryItem from a closed directory: ");
	printFileName( dir1 );
	printf( "\n" );

	aItem=DirectoryItem();
	rc=pDir->getNextItem( aItem );
	print_error( rtl::OString( "GetNextItem" ),rc );

	delete pDir;

	PressKey();
	return;
}

//--------------------------------------------------
// FileStatusTest (for different types)
//--------------------------------------------------

void FileStatusTest( FileStatus *pStatus )
{
	//--------------------------------------------------
	// GetFileType of the directory
	//--------------------------------------------------

	FileStatus::Type	aType;

	printf( "\ngetFileType:\n" );
	aType=pStatus->getFileType();
	showFileType( aType );

	//--------------------------------------------------
	// GetAttributes
	//--------------------------------------------------

	sal_uInt64			uAttributes;

	printf( "\ngetAttributes:\n" );
	uAttributes=pStatus->getAttributes();
	showAttributes( uAttributes );

	//--------------------------------------------------
	// GetCreationTime
	//--------------------------------------------------

	TimeValue	aCreationTime;

	printf( "\ngetCreationTime:\n" );
	aCreationTime=pStatus->getCreationTime();

	printf( "CreationTime: " );
	showTime( aCreationTime );

	//--------------------------------------------------
	// GetAccessTime
	//--------------------------------------------------

	TimeValue	aAccessTime;

	printf( "\ngetAccessTime:\n" );
	aAccessTime=pStatus->getAccessTime();

	printf( "AccessTime: " );
	showTime( aAccessTime );

	//--------------------------------------------------
	// GetModifyTime
	//--------------------------------------------------

	TimeValue	aModifyTime;

	printf( "\ngetModifyTime:\n" );
	aModifyTime=pStatus->getModifyTime();

	printf( "ModifyTime: " );
	showTime( aModifyTime );

	//--------------------------------------------------
	// GetFileSize
	//--------------------------------------------------

	sal_uInt64			FileSize;

	printf( "\ngetFileSize:\n" );

	FileSize=pStatus->getFileSize();
	printf( "FileSize: %i\n", FileSize);

	//--------------------------------------------------
	// GetFileName
	//--------------------------------------------------

	rtl::OUString			FileName;

	printf( "\ngetFileName:\n" );

	FileName=pStatus->getFileName();
	printf( "FileName: ");
	printFileName( FileName );
	printf( "\n" );

	//--------------------------------------------------
	// GetFileURL
	//--------------------------------------------------

	rtl::OUString			FileURL;

	printf( "\ngetFileURL:\n" );

	FileURL=pStatus->getFileURL();
	printf( "FileURL: ");
	printFileName( FileURL );
	printf( "\n" );

	//--------------------------------------------------
	// GetLinkTargetURL
	//--------------------------------------------------

	rtl::OUString			LinkTargetURL;

	printf( "\ngetLinkTargetURL:\n");

	LinkTargetURL=pStatus->getLinkTargetURL();
	printf( "LinkTargetURL: ");
	printFileName( LinkTargetURL );
	printf( "\n" );

	return;
}

//--------------------------------------------------
// DirectoryFileStatusTest
//--------------------------------------------------

void DirectoryFileStatusTest( void )
{
	FileBase::RC	rc;
	DirectoryItem	aItem;
	FileStatus		*pStatus;

	printf( "--------------------------------------------\n" );
	printf( "Directory-FileStatus-Test\n" );
	printf( "--------------------------------------------\n\n" );

	printf( "FileStatus of the directory: ");
	printFileName( dir1 );
	printf( "\n" );

	aItem=DirectoryItem();

	rc=DirectoryItem::get( dir1, aItem );
	print_error( rtl::OString( "Get DirectoryItem" ), rc );

	if ( rc==FileBase::E_None )
	{
		pStatus=new FileStatus( FileStatusMask_All );
		rc=aItem.getFileStatus( *pStatus );

		FileStatusTest( pStatus );

		delete pStatus;
	}

	printf( "\n" );

	PressKey();
	return;
}

//--------------------------------------------------
// FileFileStatusTest
//--------------------------------------------------

void FileFileStatusTest( void )
{
	FileBase::RC	rc;
	DirectoryItem	aItem;
	FileStatus		*pStatus;

	printf( "--------------------------------------------\n" );
	printf( "File-FileStatus-Test\n" );
	printf( "--------------------------------------------\n\n" );

	printf( "FileStatus of the file: ");
	printFileName( file1 );
	printf( "\n" );

	aItem=DirectoryItem();

	rc=DirectoryItem::get( file1 , aItem );
	print_error( rtl::OString( "Get DirectoryItem" ), rc );

	if ( rc==FileBase::E_None )
	{
		pStatus=new FileStatus( FileStatusMask_All );
		rc=aItem.getFileStatus( *pStatus );

		FileStatusTest( pStatus );

		delete pStatus;
	}

	printf( "\n" );

	PressKey();
	return;
}

//--------------------------------------------------
// VolumeFileStatusTest
//--------------------------------------------------

void VolumeFileStatusTest( void )
{
	FileBase::RC	rc;
	DirectoryItem	aItem;
	FileStatus		*pStatus;

	printf( "--------------------------------------------\n" );
	printf( "Volume-FileStatus-Test\n" );
	printf( "--------------------------------------------\n\n" );

	printf( "FileStatus of the Volume: ");
	printFileName( root );
	printf( "\n" );

	aItem=DirectoryItem();

	rc=DirectoryItem::get( root , aItem );
	print_error( rtl::OString( "Get DirectoryItem" ), rc );

	if ( rc==FileBase::E_None )
	{
		pStatus=new FileStatus( FileStatusMask_All) ;
		rc=aItem.getFileStatus( *pStatus );

		FileStatusTest( pStatus );

		delete pStatus;
	}

	printf( "\n" );

	PressKey();
	return;
}


//--------------------------------------------------
// VolumeInfoTest
//--------------------------------------------------

void VolumeInfoTest( void )
{
	FileBase::RC	rc;

	printf( "--------------------------------------------\n" );
	printf( "Volume-Info-Test\n" );
	printf( "--------------------------------------------\n\n" );

	printf( "VolumeInfo of the volume ");
	printFileName( root );

	printf( "\n" );

	VolumeInfo rInfo( VolumeInfoMask_FreeSpace );
	rc=Directory::getVolumeInfo( root , rInfo );
	print_error( rtl::OString( "GetVolumeInfo" ),rc );

	printf( "\n" );

	//--------------------------------------------------
	// getRemoteFlag
	//--------------------------------------------------

	if ( rInfo.getRemoteFlag() )
		printf( "RemoteFlag: Yes\n" );
	else
		printf( "RemoteFlag: No\n" );

	//--------------------------------------------------
	// getRemoveableFlag
	//--------------------------------------------------

	if ( rInfo.getRemoveableFlag() )
		printf( "RemoveableFlag: Yes\n" );
	else
		printf( "RemoveableFlag: No\n" );

	//--------------------------------------------------
	// getTotalSpace
	//--------------------------------------------------

	sal_uInt64	TotalSpace;
	TotalSpace=rInfo.getTotalSpace();
	printf( "Total Space: %i\n",TotalSpace );

	//--------------------------------------------------
	// getFreeSpace
	//--------------------------------------------------

	sal_uInt64	FreeSpace;
	FreeSpace=rInfo.getFreeSpace();
	printf( "Free Space: %i\n",FreeSpace );

	//--------------------------------------------------
	// getUsedSpace
	//--------------------------------------------------

	sal_uInt64	UsedSpace;
	UsedSpace=rInfo.getUsedSpace();
	printf( "Used Space: %i\n",UsedSpace );

	//--------------------------------------------------
	// getMaxNameLength
	//--------------------------------------------------

	sal_uInt32	MaxNameLength;
	MaxNameLength=rInfo.getMaxNameLength();
	printf( "MaxNameLength: %i\n",MaxNameLength );

	//--------------------------------------------------
	// getMaxPathLength
	//--------------------------------------------------

	sal_uInt32	MaxPathLength;
	MaxPathLength=rInfo.getMaxPathLength();
	printf( "MaxPathLength: %i\n",MaxPathLength );

	//--------------------------------------------------
	// getFileSystemName
	//--------------------------------------------------

	rtl::OUString	FileSystemName;
	FileSystemName=rInfo.getFileSystemName();
	printf( "File-System-Name: ");
	printFileName( FileSystemName );
	printf( "\n" );

	PressKey();
	return;
}

//--------------------------------------------------
// FileBaseTest
//--------------------------------------------------

void ConvertPathTest(rtl::OUString& strPath)
{
	FileBase::RC	rc;

	rtl::OUString		strNormPath;
	rtl::OUString		strFileURL;
	rtl::OUString		strNormPathFromFileURL;
	rtl::OUString		strSystemPath;

	//--------------------------------------------------
	// normalizePath
	//--------------------------------------------------

	rc=FileBase::getFileURLFromSystemPath( strPath, strNormPath );

	if ( rc == FileBase::E_None )
	{
		printf( "Normalized Path: \t\t");
		printFileName( strNormPath );
		printf( "\n" );
	}
	else
		printf( "normalizePath: Error \n" );

	//--------------------------------------------------
	// getFileURLFromSystemPath
	//--------------------------------------------------

	if ( strNormPath.getLength() != 0 )
	{
		rc=FileBase::getFileURLFromSystemPath( strNormPath, strFileURL );

		if ( rc == FileBase::E_None )
		{
			printf( "File-URL: \t\t\t");
			printFileName( strFileURL );
			printf( "\n" );
		}
		else
			printf( "getFileURLFromSystemPath: Error \n" );
	}
	else
		printf( "getFileURLFromSystemPath: not tested \n" );

	//--------------------------------------------------
	// getNormalizedPathFromFileURL
	//--------------------------------------------------

	if ( strFileURL.getLength() != 0 )
	{
		rc=FileBase::getSystemPathFromFileURL( strFileURL, strNormPathFromFileURL );

		if ( rc == FileBase::E_None )
		{
			printf( "Normalized Path from File-URL: \t");
			printFileName( strNormPathFromFileURL );
			printf( "\n" );
		}
		else
			printf( "getNormalizedPathFromFileURL: Error \n" );
	}
	else
		printf( "getNormalizedPathFromFileURL: not tested \n" );


	//--------------------------------------------------
	// getSystemPathFromFileURL
	//--------------------------------------------------

	if ( strNormPath.getLength() != 0 )
	{
		rc=FileBase::getSystemPathFromFileURL( strNormPath, strSystemPath );

		if ( rc == FileBase::E_None )
		{
			printf( "System-Path: \t\t\t");
			printFileName( strSystemPath );
			printf( "\n");
		}
		else
			printf( "getSystemPathFromFileURL: Error \n" );
	}
	else
		printf( "getSystemPathFromFileURL: not tested \n" );

	//--------------------------------------------------
	// Verify
	//--------------------------------------------------

	if ( strNormPathFromFileURL == strNormPath )
		printf( "\nVerify: OK ! ( Normalized-Path == Normalized-Path-From-File-URL )\n" );
	else
		printf( "\nVerify: Error ! ( Normalized-Path != Normalized-Path-From-File-URL )\n" );

	return;
}

void FileBaseTest()
{
	printf( "--------------------------------------------\n" );
	printf( "FileBase-Test\n" );
	printf( "--------------------------------------------\n\n" );

	//--------------------------------------------------
	// ConvertPath-Test (Local File)
	//--------------------------------------------------

	printf( "- Local File: ");
	printFileName( file1 );
	printf( "\n\n" );

	ConvertPathTest(file1);

	//--------------------------------------------------
	// ConvertPath-Test (File on a server)
	//--------------------------------------------------

	printf( "\n- File on server: ");
	printFileName( file_on_server );
	printf( "\n\n" );
	ConvertPathTest(file_on_server);

	PressKey();

	return;
}


//--------------------------------------------------
// AbsolutePathTest
//--------------------------------------------------
void DoAbsolutePathTest(rtl::OUString strDirBase, rtl::OUString	strRelative)
{
	FileBase::RC	rc;

	rtl::OUString		strAbsolute;

	printf( "Base-Directory: \t");
	printFileName( strDirBase );
	printf( "\n" );
	printf( "Relative-Path: \t\t");
	printFileName ( strRelative );
	printf( "\n" );

	rc=FileBase::getAbsoluteFileURL( strDirBase, strRelative, strAbsolute );

	if ( rc == FileBase::E_None )
	{
		printf( "Absolute-Path: \t\t");
		printFileName ( strAbsolute );
		printf( "\n" );
	}
	else
		printf( "Absolute-Path: Error \n" );

	printf( "\n" );
	return;
}

void AbsolutePathTest(void)
{
	printf( "--------------------------------------------\n" );
	printf( "AbsolutePath-Test\n" );
	printf( "--------------------------------------------\n\n" );

	DoAbsolutePathTest(dir1, rtl::OUString::createFromAscii("."));
	DoAbsolutePathTest(dir1, rtl::OUString::createFromAscii(".."));
	DoAbsolutePathTest(dir1, rtl::OUString::createFromAscii("../.."));
	DoAbsolutePathTest(dir1, rtl::OUString::createFromAscii("../HUHU"));

	DoAbsolutePathTest(dir_on_server, rtl::OUString::createFromAscii("."));
	DoAbsolutePathTest(dir_on_server, rtl::OUString::createFromAscii(".."));
	DoAbsolutePathTest(dir_on_server, rtl::OUString::createFromAscii("../.."));
	DoAbsolutePathTest(dir_on_server, rtl::OUString::createFromAscii("../HUHU"));

	PressKey();
	return;
}


//--------------------------------------------------
// searchPathTest
//--------------------------------------------------

void SearchPathTest(void)
{
	FileBase::RC	rc;

	rtl::OUString		strNormPath(file1);
	rtl::OUString		strFileURL;
	rtl::OUString		strSystemPath;
	rtl::OUString		strResultPath;

	printf( "--------------------------------------------\n" );
	printf( "SearchPath-Test\n" );
	printf( "--------------------------------------------\n\n" );


	rc=FileBase::getFileURLFromSystemPath( strNormPath, strFileURL );
	print_error( rtl::OString( "getFileURLFromSystemPath" ), rc );
	rc=FileBase::getSystemPathFromFileURL( strNormPath, strSystemPath );
	print_error( rtl::OString( "getSystemPathFromFileURL" ), rc );

	//--------------------------------------------------
	// searchFileURL (with a normalized path)
	//--------------------------------------------------

	if ( strNormPath.getLength() != 0 )
	{
		printf( "\nSearch-Normalized-Path (with a normalized path) : ");
		printFileName ( strNormPath );
		printf( "\n" );

		rc=FileBase::searchFileURL( strNormPath , rtl::OUString() , strResultPath );

		if ( rc == FileBase::E_None )
		{
			printf( "Result: \t\t\t");
			printFileName ( strResultPath );
			printf( "\n" );
		}
		else
			printf( "searchFileURL (with a normalized path): Error\n" );
	}
	else
		printf( "searchFileURL (with a normalized path): not tested\n" );

	//--------------------------------------------------
	// searchFileURL (with a File-URL)
	//--------------------------------------------------

	if ( strFileURL.getLength() != 0 )
	{
		printf( "\nSearch-Normalized-Path (with a FileURL) : ");
		printFileName( strFileURL );
		printf( "\n" );

		rc=FileBase::searchFileURL( strFileURL , rtl::OUString() , strResultPath );

		if ( rc == FileBase::E_None )
		{
			printf( "Result: \t\t\t");
			printFileName ( strResultPath );
			printf( "\n" );
		}
		else
			printf( "searchFileURL (with a FileURL path): Error\n" );
	}
	else
		printf( "searchFileURL (with a FileURL path): not tested\n" );

	//--------------------------------------------------
	// searchFileURL (with a systempath)
	//--------------------------------------------------

	if ( strSystemPath.getLength() != 0 )
	{
		printf( "\nSearch-Normalized-Path (with a SystemPath) : ");
		printFileName( strSystemPath );
		printf( "\n" );

		rc=FileBase::searchFileURL( strSystemPath , rtl::OUString() , strResultPath );

		if ( rc == FileBase::E_None )
		{
			printf( "Result: \t\t\t");
			printFileName( strResultPath );
			printf( "\n" );
		}
		else
			printf( "searchFileURL (with a systempath): Error\n" );
	}
	else
		printf( "searchFileURL (with a systempath): not tested\n" );

	//--------------------------------------------------
	// searchFileURL (File and no searchpath)
	//--------------------------------------------------

	printf( "\nsearchFileURL:  File (no searchpath) : ");
	printFileName( file3 );
	printf( "\n" );

	rc=FileBase::searchFileURL( file3 , rtl::OUString::createFromAscii("") , strResultPath );

	if ( rc == FileBase::E_None )
	{
		printf( "Result: \t\t\t");
		printFileName( strResultPath );
		printf( "\n" );
	}
	else
		printf( "searchFileURL:  File not found: OK ! \n" );

	//--------------------------------------------------
	// searchFileURL (File and Path)
	//--------------------------------------------------

	printf( "\nsearchFileURL:  File : ");
	printFileName( file3 );
	printf( "\tSearchPath ");
	printFileName( dir1 );
	printf( "\n");

	rc=FileBase::searchFileURL( file3 , dir1 , strResultPath );

	if ( rc == FileBase::E_None )
	{
		printf( "Result: \t\t\t");
		printFileName( strResultPath );
		printf( "\n");
	}
	else
		printf( "searchFileURL:  File not found: Error\n" );

	//------------------------------------------------------------
	// searchFileURL (File and searchpath with two entries)
	//------------------------------------------------------------

	rtl::OUString		strSearchPath( dir_not_exist );
	strSearchPath+=rtl::OUString::createFromAscii(";");
	strSearchPath+=dir_on_server;

	printf( "\nsearchFileURL:  File : ");
	printFileName( file3 );
	printf( "SearchPath ");
	printFileName( strSearchPath );
	printf( "\n");

	rc=FileBase::searchFileURL( file3 , strSearchPath , strResultPath );

	if ( rc == FileBase::E_None )
	{
		printf( "Result: \t\t\t");
		printFileName( strResultPath );
		printf( "\n" );
	}
	else
		printf( "searchFileURL:  File not found: Error\n" );

	//-------------------------------------------------------------------
	// searchFileURL (File and searchpath (with a wrong semantic))
	//-------------------------------------------------------------------

	strSearchPath=rtl::OUString( dir_wrong_semantic );

	printf( "\nsearchFileURL:  File : ");
	printFileName( file3 );
	printf( "SearchPath ");
	printFileName( strSearchPath );
	printf( "\n");

	rc=FileBase::searchFileURL( file3 , strSearchPath , strResultPath );

	if ( rc == FileBase::E_None )
		printf( "Error: Wrong Semantich but no error occurs !\n" );
	else
		printf( "searchFileURL:  File not found: OK !\n" );

	return;
}

//--------------------------------------------------
// CanonicalNameTest
//--------------------------------------------------

void getCanonicalNameTest(rtl::OUString strPath)
{
	FileBase::RC	rc;

	rtl::OUString	strValid;

	printf( "Original-Name: \t\t");
	printFileName( strPath );
	printf( "\n" );

	rc=FileBase::getCanonicalName( strPath, strValid );

	if ( rc == FileBase::E_None)
	{
		printf( "Canonical-Name: \t");
		printFileName( strValid );
		printf( "\n");

	}
	else
		printf( "Canonical-Name: Error \n" );

	printf( "\n" );
	return;
}

void CanonicalNameTest(void)
{
	printf( "--------------------------------------------\n" );
	printf( "CanonicalName-Test\n" );
	printf( "--------------------------------------------\n\n" );

	getCanonicalNameTest( dir1 );
	getCanonicalNameTest( dir_on_server );
	getCanonicalNameTest( file1 );
	getCanonicalNameTest( file_on_server );

	PressKey();
	return;
}

//--------------------------------------------------
// print_error
//--------------------------------------------------

void print_error( ::rtl::OString& str, FileBase::RC rc )
{

	printf( "%s : ",str.getStr() );
	switch(rc)
	{
	case FileBase::E_None:
		printf("OK !\n");
		break;
	case FileBase::E_PERM:
		printf("E_PERM\n");
		break;
	case FileBase::E_NOENT:
		printf("E_NOENT\n");
		break;
	case FileBase::E_SRCH:
		printf("E_SRCH\n");
		break;
	case FileBase::E_INTR:
		printf("E_INTR\n");
		break;
	case FileBase::E_IO:
		printf("E_IO\n");
		break;
	case FileBase::E_NXIO:
		printf("E_NXIO\n");
		break;
	case FileBase::E_2BIG:
		printf("E_2BIG\n");
		break;
	case FileBase::E_NOEXEC:
		printf("E_NOEXEC\n");
		break;
	case FileBase::E_BADF:
		printf("E_BADF\n");
		break;
	case FileBase::E_CHILD:
		printf("E_CHILD\n");
		break;
	case FileBase::E_AGAIN:
		printf("E_AGAIN\n");
		break;
	case FileBase::E_NOMEM:
		printf("E_NOMEM\n");
		break;
	case FileBase::E_ACCES:
		printf("E_ACCES\n");
		break;
	case FileBase::E_FAULT:
		printf("E_FAULT\n");
		break;
	case FileBase::E_BUSY:
		printf("E_BUSY\n");
		break;
	case FileBase::E_EXIST:
		printf("E_EXIST\n");
		break;
	case FileBase::E_XDEV:
		printf("E_XDEV\n");
		break;
	case FileBase::E_NODEV:
		printf("E_NODEV\n");
		break;
	case FileBase::E_NOTDIR:
		printf("E_NOTDIR\n");
		break;
	case FileBase::E_ISDIR:
		printf("E_ISDIR\n");
		break;
	case FileBase::E_INVAL:
		printf("E_INVAL\n");
		break;
	case FileBase::E_NFILE:
		printf("E_NFILE\n");
		break;
	case FileBase::E_MFILE:
		printf("E_MFILE\n");
		break;
	case FileBase::E_NOTTY:
		printf("E_NOTTY\n");
		break;
	case FileBase::E_FBIG:
		printf("E_FBIG\n");
		break;
	case FileBase::E_NOSPC:
		printf("E_NOSPC\n");
		break;
	case FileBase::E_SPIPE:
		printf("E_SPIPE\n");
		break;
	case FileBase::E_ROFS:
		printf("E_ROFS\n");
		break;
	case FileBase::E_MLINK:
		printf("E_MLINK\n");
		break;
	case FileBase::E_PIPE:
		printf("E_PIPE\n");
		break;
	case FileBase::E_DOM:
		printf("E_DOM\n");
		break;
	case FileBase::E_RANGE:
		printf("E_RANGE\n");
		break;
	case FileBase::E_DEADLK:
		printf("E_DEADLK\n");
		break;
	case FileBase::E_NAMETOOLONG:
		printf("E_NAMETOOLONG\n");
		break;
	case FileBase::E_NOLCK:
		printf("E_NOLCK\n");
		break;
	case FileBase::E_NOSYS:
		printf("E_NOSYS\n");
		break;
	case FileBase::E_NOTEMPTY:
		printf("E_NOTEMPTY\n");
		break;
	case FileBase::E_LOOP:
		printf("E_LOOP\n");
		break;
	case FileBase::E_ILSEQ:
		printf("E_ILSEQ\n");
		break;
	case FileBase::E_NOLINK:
		printf("E_NOLINK\n");
		break;
	case FileBase::E_MULTIHOP:
		printf("E_MULTIHOP\n");
		break;
	case FileBase::E_USERS:
		printf("E_USERS\n");
		break;
	case FileBase::E_OVERFLOW:
		printf("E_OVERFLOW\n");
		break;
	default:
		printf("E_Unknown\n");
		break;
	}
	return;
}

//--------------------------------------------------
// main
//--------------------------------------------------
#if defined WNT
        #define MAIN _cdecl main
#else
        #define MAIN main
#endif

int MAIN( int argc, char* argv[] )
{
	sal_Bool fSuccess=sal_False;

	//Initialization
	fSuccess=Initialize();
	if ( !fSuccess )
	{
		printf("Error during Initialization");
		return -1;
	}


	if (argc==1)
	{
		DirectoryOpenAndCloseTest();
		DirectoryCreateAndRemoveTest();

		FileOpenAndCloseTest();
		FileCreateAndRemoveTest();
		FileWriteAndReadTest();
		FileCopyAndMoveTest();
		FileSizeTest();
		FilePointerTest();
		FileAttributesTest();
		FileTimeTest();
		DirectoryItemTest();
		DirectoryFileStatusTest();
		VolumeFileStatusTest();
		FileFileStatusTest();
		VolumeInfoTest();
		FileBaseTest();
		SearchPathTest();
		AbsolutePathTest();
		CanonicalNameTest();
	}
	// command line arguments ?
	else
	{
		int i=1;

		while (i<argc)
		{
			if (strcmp(argv[i], "doc")==0)
				DirectoryOpenAndCloseTest();
			else if (strcmp(argv[i], "dcr")==0)
				DirectoryCreateAndRemoveTest();
			else if (strcmp(argv[i], "foc")==0)
				FileOpenAndCloseTest();
			else if (strcmp(argv[i], "fcr")==0)
				FileCreateAndRemoveTest();
			else if (strcmp(argv[i], "fwr")==0)
				FileWriteAndReadTest();
			else if (strcmp(argv[i], "fcm")==0)
				FileCopyAndMoveTest();
			else if (strcmp(argv[i], "fs")==0)
				FileSizeTest();
			else if (strcmp(argv[i], "fp")==0)
				FilePointerTest();
			else if (strcmp(argv[i], "fa")==0)
				FileAttributesTest();
			else if (strcmp(argv[i], "ft")==0)
				FileTimeTest();
			else if (strcmp(argv[i], "di")==0)
				DirectoryItemTest();
			else if (strcmp(argv[i], "dfs")==0)
				DirectoryFileStatusTest();
			else if (strcmp(argv[i], "vfs")==0)
				VolumeFileStatusTest();
			else if (strcmp(argv[i], "ffs")==0)
				FileFileStatusTest();
			else if (strcmp(argv[i], "vi")==0)
				VolumeInfoTest();
			else if (strcmp(argv[i], "fb")==0)
				FileBaseTest();
			else if (strcmp(argv[i], "sp")==0)
				SearchPathTest();
			else if (strcmp(argv[i], "ap")==0)
				AbsolutePathTest();
			else if (strcmp(argv[i], "cn")==0)
				CanonicalNameTest();

			i++;
		}
	}

	// Shutdown
	fSuccess=Shutdown();
	if ( !fSuccess )
	{
		printf("Error during Shutdown");
		return -1;
	}

	return 0;
}