/************************************************************** * * 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 #include #include #include #include #include #include #include #ifdef UNX #include #endif #ifdef WNT #include #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( <ime ); 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