sal/workben/testfile.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2000, 2010 Oracle and/or its affiliates.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * This file is part of OpenOffice.org.
  10  *
  11  * OpenOffice.org is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU Lesser General Public License version 3
  13  * only, as published by the Free Software Foundation.
  14  *
  15  * OpenOffice.org is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Lesser General Public License version 3 for more details
  19  * (a copy is included in the LICENSE file that accompanied this code).
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * version 3 along with OpenOffice.org.  If not, see
  23  * <http://www.openoffice.org/license.html>
  24  * for a copy of the LGPLv3 License.
  25  *
  26  ************************************************************************/
  27
  28 // MARKER(update_precomp.py): autogen include statement, do not remove
  29 #include "precompiled_sal.hxx"
  30
  31 #define UNICODE
  32
  33
  34 #include <osl/file.hxx>
  35 #include <osl/process.h>
  36 #include <osl/time.h>
  37 #include <rtl/alloc.h>
  38 #include <rtl/ustring.hxx>
  39 #include <stdio.h>
  40 #include <string.h>
  41 #include <time.h>
  42
  43
  44 #ifdef UNX
  45 #include <wchar.h>
  46 #endif
  47
  48 #ifdef WNT
  49 #include <windows.h>
  50 #endif
  51
  52 using namespace osl;
  53 using namespace rtl;
  54
  55 #define MAXIMPATH   256
  56
  57 rtl::OUString   root;
  58
  59 rtl::OUString   dir1;
  60 rtl::OUString   dir2;
  61 rtl::OUString   dir_on_server;
  62 rtl::OUString   dir_not_exist;
  63 rtl::OUString   dir_not_exist_on_server;
  64 rtl::OUString   dir_wrong_semantic;
  65
  66 rtl::OUString   file1;
  67 rtl::OUString   file2;
  68 rtl::OUString   file3;
  69 rtl::OUString   file_on_server;
  70 rtl::OUString   file_not_exist;
  71
  72
  73
  74 void print_error(::rtl::OString& str, FileBase::RC rc);
  75
  76 void PressKey()
  77 {
  78     printf("\nPress Return !\n");
  79     int i=getchar();
  80 }
  81
  82 void printFileName(::rtl::OUString& str)
  83 {
  84     rtl::OString        aString;
  85
  86     aString = rtl::OUStringToOString( str, RTL_TEXTENCODING_ASCII_US );
  87
  88     printf( "%s", aString.getStr() );
  89
  90     return;
  91 }
  92
  93 //--------------------------------------------------
  94 // Initialization
  95 //--------------------------------------------------
  96
  97 sal_Bool testLineBreak( sal_Char *pCount , sal_uInt64 nLen , sal_uInt32 *cLineBreak )
  98 {
  99     sal_Bool fSuccess=sal_False;
 100     *cLineBreak=0;
 101
 102     if (nLen==0)
 103         return fSuccess;
 104
 105     if ( *pCount==13 )
 106     {
 107         if (nLen>=1 && *(pCount+1)==10)
 108             *cLineBreak=2;
 109         else
 110             *cLineBreak=1;
 111
 112         if (nLen>=2 && *(pCount+2)==10)
 113             (*cLineBreak)++;
 114
 115         fSuccess=sal_True;
 116     }
 117     else if ( *pCount==10 )
 118     {
 119         *cLineBreak=1;
 120         fSuccess=sal_True;
 121     }
 122
 123     return fSuccess;
 124 }
 125
 126 // Initialization
 127
 128 sal_Bool Initialize( void )
 129 {
 130     DirectoryItem   aItem;
 131     FileStatus      aStatus( FileStatusMask_All );
 132     rtl_uString     *strExeFileURL=NULL;
 133     oslProcessError ProcessError;
 134
 135     rtl::OUString   iniFileURL;
 136     File            *pFile;
 137     sal_Unicode     *pExeFileCount;
 138
 139     FileBase::RC    rc;
 140
 141     sal_uInt64      uBytesRequested;
 142     sal_uInt64      uBytesRead;
 143     sal_Char        *pBuffer;
 144     sal_Char        *pBegin;
 145     sal_Char        *pCount;
 146
 147     rtl::OUString   dir[12];
 148
 149     // Open to the ini-file
 150
 151     ProcessError=osl_getExecutableFile(&strExeFileURL);
 152
 153     if ( ProcessError == osl_Process_E_None)
 154     {
 155         pExeFileCount=rtl_uString_getStr(strExeFileURL)+rtl_uString_getLength(strExeFileURL);
 156
 157         // Search for the last slash in the Path
 158         while (*pExeFileCount!=L'/' && pExeFileCount>rtl_uString_getStr(strExeFileURL))
 159             pExeFileCount--;
 160
 161         // iniFileURL = strExeFileURL without the filename of the exe-File
 162         iniFileURL=rtl::OUString( rtl_uString_getStr(strExeFileURL) ,(int) (pExeFileCount-rtl_uString_getStr(strExeFileURL)) );
 163
 164         // add "/testfile.ini" to iniFileURL
 165         iniFileURL+=rtl::OUString::createFromAscii("/testfile.ini");
 166
 167         // Open the ini-File
 168         pFile=new File( iniFileURL );
 169         rc=pFile->open( OpenFlag_Read | OpenFlag_Write );
 170         if ( rc!=FileBase::E_None )
 171         {
 172             rtl_uString_release(strExeFileURL);
 173             return sal_False;
 174         }
 175     }
 176     else
 177     {
 178         rtl_uString_release(strExeFileURL);
 179         return sal_False;
 180     }
 181
 182     // Get filesize of the ini-File
 183
 184     rc=DirectoryItem::get( iniFileURL, aItem );
 185     if ( rc!=FileBase::E_None )
 186         return sal_False;
 187
 188     rc=aItem.getFileStatus( aStatus );
 189     if ( rc!=FileBase::E_None )
 190         return sal_False;
 191
 192     uBytesRequested=aStatus.getFileSize();
 193
 194     // read ini-File
 195     rc=pFile->setPos( Pos_Absolut, 0 );
 196     pBuffer=(sal_Char*) rtl_allocateMemory( (sal_uInt32) (uBytesRequested+1)*sizeof(sal_Char) );
 197     rtl_zeroMemory( pBuffer, (sal_uInt32)(uBytesRequested+1)*sizeof(sal_Char) );
 198
 199     rc=pFile->read( pBuffer , uBytesRequested , uBytesRead );
 200     if ( rc!=FileBase::E_None )
 201         return sal_False;
 202
 203
 204     pBegin=pBuffer;
 205     pCount=pBegin;
 206
 207     for ( int i=0 ; i<12 ; i++ )
 208     {
 209         sal_uInt32      cLineBrake=0;
 210         while ( (pCount-pBuffer < uBytesRead) && *pCount!='=')
 211             pCount++;
 212
 213         pCount++;
 214         pBegin=pCount;
 215
 216         while ( (pCount-pBuffer < uBytesRead) && !testLineBreak(pCount,uBytesRead-(pCount-pBuffer), &cLineBrake))
 217             pCount++;
 218
 219         dir[i]=rtl::OUString(pBegin, pCount-pBegin, RTL_TEXTENCODING_ASCII_US);
 220
 221         pCount+=cLineBrake;
 222         pBegin=pCount;
 223     }
 224
 225     root=rtl::OUString(dir[0]);
 226     dir1=rtl::OUString(dir[1]);
 227     dir2=rtl::OUString(dir[2]);
 228     dir_on_server=rtl::OUString(dir[3]);
 229     dir_not_exist=rtl::OUString(dir[4]);
 230     dir_not_exist_on_server=rtl::OUString(dir[5]);
 231     dir_wrong_semantic=rtl::OUString(dir[6]);
 232
 233     file1=rtl::OUString(dir[7]);
 234     file2=rtl::OUString(dir[8]);
 235     file3=rtl::OUString(dir[9]);
 236     file_on_server=rtl::OUString(dir[10]);
 237     file_not_exist=rtl::OUString(dir[11]);
 238
 239     // close the ini-file
 240     rc=pFile->close();
 241
 242     rtl_freeMemory( pBuffer );
 243
 244
 245     // Create directories
 246     rc=Directory::create( dir1 );
 247     if ( rc!=FileBase::E_None )
 248         return sal_False;
 249
 250     rc=Directory::create( dir2 );
 251     if ( rc!=FileBase::E_None )
 252         return sal_False;
 253
 254     rc=Directory::create( dir_on_server );
 255     if ( rc!=FileBase::E_None )
 256         return sal_False;
 257
 258     pFile=new File( file1 );
 259     rc=pFile->open( OpenFlag_Write | OpenFlag_Create );
 260     if ( rc!=FileBase::E_None )
 261         return sal_False;
 262     rc=pFile->close();
 263     delete pFile;
 264
 265     pFile=new File( file2 );
 266     rc=pFile->open( OpenFlag_Write | OpenFlag_Create );
 267     if ( rc!=FileBase::E_None )
 268         return sal_False;
 269     rc=pFile->close();
 270     delete pFile;
 271
 272     pFile=new File( file_on_server );
 273     rc=pFile->open( OpenFlag_Write | OpenFlag_Create );
 274     if ( rc!=FileBase::E_None )
 275         return sal_False;
 276     rc=pFile->close();
 277     delete pFile;
 278
 279     return sal_True;
 280 }
 281
 282 //--------------------------------------------------
 283 // Shutdown
 284 //--------------------------------------------------
 285
 286 sal_Bool Shutdown( void )
 287 {
 288     sal_Bool        fSuccess=sal_True;
 289     FileBase::RC    rc;
 290     File            *pFile;
 291
 292     // remove created files
 293
 294     pFile=new File( file1 );
 295     rc=pFile->remove( file1 );
 296     if ( rc!=FileBase::E_None )
 297         fSuccess=sal_False;
 298     delete pFile;
 299
 300     pFile=new File( file2 );
 301     rc=pFile->remove( file2 );
 302     if ( rc!=FileBase::E_None )
 303         fSuccess=sal_False;
 304     delete pFile;
 305
 306     // remove created directories
 307
 308     rc=Directory::remove( dir1 );
 309     if ( rc!=FileBase::E_None )
 310         fSuccess=sal_False;
 311
 312     rc=Directory::remove( dir2 );
 313     if ( rc!=FileBase::E_None )
 314         fSuccess=sal_False;
 315
 316     // remove created file on the server
 317
 318     pFile=new File( file_on_server );
 319     rc=pFile->remove( file_on_server );
 320     if ( rc!=FileBase::E_None )
 321         fSuccess=sal_False;
 322     delete pFile;
 323
 324     // remove created directory on the server
 325
 326     rc=Directory::remove( dir_on_server );
 327     if ( rc!=FileBase::E_None )
 328         fSuccess=sal_False;
 329
 330     return fSuccess;
 331 }
 332
 333 //--------------------------------------------------
 334 // helper functions
 335 //--------------------------------------------------
 336
 337 // Show FileType
 338 void showFileType( FileStatus::Type aType )
 339 {
 340     if ( aType==FileStatus::Directory )
 341         printf( "FileType: Directory \n" );
 342     else if ( aType==FileStatus::Volume )
 343         printf( "FileType: Volume \n" );
 344     else if ( aType==FileStatus::Regular )
 345         printf( "FileType: Regular \n" );
 346     else if ( aType==FileStatus::Unknown )
 347         printf( "FileType: Unknown \n" );
 348
 349 }
 350
 351 // Show Attributes
 352 void showAttributes( sal_uInt64 uAttributes )
 353 {
 354     if ( uAttributes==0 )
 355         printf( "No Attributes \n" );
 356     if ( uAttributes & Attribute_ReadOnly )
 357         printf( "Attribute: ReadOnly \n" );
 358     if ( uAttributes & Attribute_Hidden )
 359         printf( "Attribute: Hidden \n" );
 360     if ( uAttributes & Attribute_Executable )
 361         printf( "Attribute: Executable \n");
 362     if ( uAttributes & Attribute_GrpWrite )
 363         printf( "Attribute: GrpWrite \n");
 364     if ( uAttributes & Attribute_GrpRead )
 365         printf( "Attribute: GrpRead \n" );
 366     if ( uAttributes & Attribute_GrpExe )
 367         printf( "Attribute: GrpExe \n" );
 368     if ( uAttributes & Attribute_OwnWrite )
 369         printf( "Attribute: OwnWrite \n");
 370     if ( uAttributes & Attribute_OwnRead )
 371         printf( "Attribute: OwnRead \n" );
 372     if ( uAttributes & Attribute_OwnExe )
 373         printf( "Attribute: OwnExe \n" );
 374     if ( uAttributes & Attribute_OthWrite )
 375         printf( "Attribute: OthWrite \n" );
 376     if ( uAttributes & Attribute_OthRead )
 377         printf( "Attribute: OthRead \n");
 378     if ( uAttributes & Attribute_OthExe )
 379         printf( "Attribute: OthExe \n" );
 380
 381     return;
 382 }
 383
 384 // Show Time
 385 void showTime( TimeValue aTime )
 386 {
 387     TimeValue   aLocalTimeVal, aSystemTimeVal , aSysTimeVal;
 388     oslDateTime aDateTime, aSystemTime;
 389
 390     if ( osl_getLocalTimeFromSystemTime( &aTime, &aLocalTimeVal ) )
 391     {
 392         if ( osl_getDateTimeFromTimeValue( &aLocalTimeVal, &aDateTime ) )
 393         {
 394             printf("\t%02i.%02i.%4i , %02i.%02i.%02i Uhr\n", aDateTime.Day, aDateTime.Month, aDateTime.Year, aDateTime.Hours, aDateTime.Minutes, aDateTime.Seconds);
 395         }
 396         else
 397             printf("Error !\n");
 398     }
 399
 400     if ( osl_getDateTimeFromTimeValue( &aTime, &aSystemTime ) )
 401     {
 402         printf("SystemTime: \t\t%02i.%02i.%4i , %02i.%02i.%02i Uhr\n", aSystemTime.Day, aSystemTime.Month, aSystemTime.Year, aSystemTime.Hours, aSystemTime.Minutes, aSystemTime.Seconds);
 403     }
 404     else
 405         printf("Error !\n");
 406
 407     //Verify
 408
 409     if ( osl_getTimeValueFromDateTime( &aSystemTime, &aSystemTimeVal ) )
 410     {
 411         if ( ( aSystemTimeVal.Seconds == aTime.Seconds ) && ( aSystemTimeVal.Nanosec == aTime.Nanosec ))
 412             printf ("Verify : TimeValue : ok! \n");
 413         else
 414         {
 415             printf ("Verify : TimeValue : Error! \n");
 416             printf ("aTime : %u \n", aTime.Seconds);
 417             printf ("aSystemTimeVal : %u \n", aSystemTimeVal.Seconds);
 418         }
 419     }
 420     else
 421         printf ("Verify : TimeValue : Error! \n");
 422
 423
 424     if ( osl_getSystemTimeFromLocalTime( &aLocalTimeVal , &aSysTimeVal ) )
 425     {
 426         if ( ( aSysTimeVal.Seconds == aTime.Seconds ) && ( aSysTimeVal.Nanosec == aTime.Nanosec ))
 427             printf ("Verify : SystemTime : ok! \n");
 428         else
 429         {
 430             printf ("Verify : SystemTime : Error! \n");
 431             printf ("aTime : %u\n", aTime.Seconds);
 432             printf ("aSystemTimeVal : %u\n", aSysTimeVal.Seconds);
 433         }
 434     }
 435     else
 436         printf ("Verify : SystemTime : Error! \n");
 437
 438     return;
 439 }
 440
 441 TimeValue getSystemTime()
 442 {
 443     TimeValue   aTime;
 444     time_t ltime;
 445
 446     time( &ltime );
 447
 448     aTime.Seconds = ltime;
 449     aTime.Nanosec = 0;
 450
 451     return aTime;
 452 }
 453
 454
 455 //--------------------------------------------------
 456 // DirectoryOpenAndCloseTest
 457 //--------------------------------------------------
 458
 459 void DirectoryOpenAndCloseTest( void )
 460 {
 461     FileBase::RC    rc;
 462     int i=0;
 463     Directory   *pDir;
 464
 465     printf( "--------------------------------------------\n");
 466     printf( "Directory-Open-And-Close-Test\n");
 467     printf( "--------------------------------------------\n\n");
 468
 469     //--------------------------------------------------
 470     // open an existing directory
 471     //--------------------------------------------------
 472
 473     pDir=new Directory( dir1 );
 474     printf( "Open an existing directory: ");
 475     printFileName( dir1 );
 476     printf( "\n" );
 477
 478     rc= pDir->open();
 479     print_error( rtl::OString( "Open Directory" ), rc );
 480
 481     if ( pDir->isOpen() )
 482     {
 483         print_error( rtl::OString( "Directory is Open" ), rc );
 484     }
 485
 486     // Close Directory
 487     rc=pDir->close();
 488     print_error( rtl::OString( "Close Directory" ), rc );
 489
 490     delete pDir;
 491     printf( "\n" );
 492
 493     //--------------------------------------------------
 494     // open a not existing directory
 495     //--------------------------------------------------
 496
 497     pDir=new Directory( dir_not_exist );
 498
 499     printf( "Open a not existing directory: ");
 500     printFileName( dir_not_exist );
 501     printf( "\n" );
 502
 503     rc= pDir->open();
 504
 505     print_error( rtl::OString( "Open Directory" ), rc );
 506
 507     delete pDir;
 508
 509     printf( "\n" );
 510
 511     //--------------------------------------------------
 512     // open a directory with a wrong semantic
 513     //--------------------------------------------------
 514     pDir=new Directory( dir_wrong_semantic );
 515
 516     printf( "Open a directory with a wrong semantic: ");
 517     printFileName( dir_wrong_semantic );
 518     printf( "\n" );
 519
 520     rc= pDir->open();
 521     print_error( rtl::OString( "Open Directory" ), rc );
 522
 523     delete pDir;
 524
 525     printf( "\n" );
 526
 527     //--------------------------------------------------
 528     // open an existing directory on a server
 529     //--------------------------------------------------
 530
 531     pDir=new Directory( dir_on_server );
 532
 533     printf( "Open an existing directory on a server: ");
 534     printFileName( dir_on_server );
 535     printf( "\n" );
 536
 537     rc= pDir->open();
 538     print_error( rtl::OString( "Open Directory" ), rc );
 539
 540     // Close Directory
 541     rc=pDir->close();
 542     print_error( rtl::OString( "Close Directory" ), rc );
 543
 544     delete pDir;
 545     printf( "\n" );
 546
 547     //--------------------------------------------------
 548     // open a not existing directory on a server
 549     //--------------------------------------------------
 550
 551     pDir=new Directory( dir_not_exist_on_server );
 552
 553     printf( "Open a not existing directory on a server: ");
 554     printFileName( dir_not_exist_on_server );
 555     printf( "\n" );
 556
 557     rc= pDir->open();
 558     print_error( rtl::OString( "Open Directory" ), rc );
 559
 560     delete pDir;
 561     printf( "\n" );
 562
 563     //--------------------------------------------------
 564     // Close a not existing directory
 565     //--------------------------------------------------
 566
 567     pDir=new Directory( dir_not_exist );
 568     printf( "Close a not existing directory: ");
 569     printFileName( dir_not_exist );
 570     printf( "\n" );
 571
 572     rc=pDir->close();
 573     print_error( rtl::OString( "Close Directory" ), rc );
 574
 575     PressKey();
 576     return;
 577
 578 }
 579
 580 //--------------------------------------------------
 581 // DirectoryCreateAndRemoveTest
 582 //--------------------------------------------------
 583
 584 void DirectoryCreateAndRemoveTest( void )
 585 {
 586     FileBase::RC    rc,rc1;
 587     int i=0;
 588     Directory   *pDir;
 589
 590     printf( "--------------------------------------------\n" );
 591     printf( "Directory-Create-And-Remove-Test\n" );
 592     printf( "--------------------------------------------\n\n" );
 593
 594     //--------------------------------------------------
 595     // Create directory
 596     //--------------------------------------------------
 597     printf( "Create a not existing directory: ");
 598     printFileName( dir_not_exist );
 599     printf( "\n" );
 600
 601     rc=Directory::create( dir_not_exist) ;
 602     print_error( rtl::OString( "Create Directory" ), rc );
 603
 604     // Verify
 605     pDir=new Directory( dir_not_exist );
 606
 607     rc= pDir->open();
 608     print_error( rtl::OString( "Verify" ), rc );
 609     pDir->close();
 610     delete pDir;
 611
 612     printf( "\n" );
 613
 614     //--------------------------------------------------
 615     // Create a directory on a server
 616     //--------------------------------------------------
 617
 618     printf( "Create a not existing directory on a server: ");
 619     printFileName( dir_not_exist_on_server );
 620     printf( "\n" );
 621
 622     rc=Directory::create( dir_not_exist_on_server );
 623     print_error( rtl::OString( "Create Directory" ), rc );
 624
 625     // Verify
 626     pDir=new Directory( dir_not_exist_on_server );
 627     rc= pDir->open();
 628     print_error( rtl::OString( "Verify" ), rc );
 629     pDir->close();
 630     delete pDir;
 631
 632     printf( "\n" );
 633
 634     //--------------------------------------------------
 635     // Remove Directories
 636     //--------------------------------------------------
 637
 638     printf( "Remove the created directories: \n" );
 639
 640     rc=Directory::remove( dir_not_exist );
 641
 642     rc1=Directory::remove( dir_not_exist_on_server );
 643
 644     if ( rc==FileBase::E_None && rc1==FileBase::E_None )
 645         print_error( rtl::OString( "Remove Directories" ), FileBase::E_None );
 646     else if ( rc!=FileBase::E_None )
 647         print_error( rtl::OString( "Remove local Directory" ),rc );
 648     else
 649         print_error( rtl::OString( "Remove Directory on a server" ),rc1 );
 650
 651     printf( "\n" );
 652
 653     //--------------------------------------------------
 654     // Remove a not existing directory
 655     //--------------------------------------------------
 656
 657     printf( "Remove a not existing directory: ");
 658     printFileName( dir_not_exist );
 659     printf( "\n" );
 660
 661     rc=Directory::remove( dir_not_exist );
 662     print_error( rtl::OString( "Remove" ),rc );
 663
 664     PressKey();
 665     return;
 666 }
 667
 668 //--------------------------------------------------
 669 // FileOpenAndCloseTest
 670 //--------------------------------------------------
 671
 672 static void FileOpenAndCloseTest( void )
 673 {
 674     FileBase::RC    rc;
 675     int i=0;
 676
 677     printf( "--------------------------------------------\n" );
 678     printf( "File-Open-And-Close-Test\n" );
 679     printf( "--------------------------------------------\n\n" );
 680
 681     File    *pFile;
 682
 683     pFile=new File( file1 );
 684
 685     printf( "Open an existing file: ");
 686     printFileName( file1 );
 687     printf( "\n" );
 688
 689     //--------------------------------------------------
 690     // open an existing file (Read)
 691     //--------------------------------------------------
 692
 693     rc=pFile->open( OpenFlag_Read );
 694     print_error( rtl::OString( "Open File (Read)" ), rc );
 695
 696     //--------------------------------------------------
 697     // close the file
 698     //--------------------------------------------------
 699
 700     rc=pFile->close();
 701     print_error( rtl::OString( "Close File" ), rc );
 702
 703     printf( "\n" );
 704
 705     //--------------------------------------------------
 706     // open an existing file (Write)
 707     //--------------------------------------------------
 708
 709     rc=pFile->open( OpenFlag_Write );
 710     print_error( rtl::OString( "Open File (Write)" ), rc );
 711
 712     //--------------------------------------------------
 713     // close the file
 714     //--------------------------------------------------
 715
 716      rc=pFile->close();
 717     print_error( rtl::OString( "Close File" ), rc );
 718
 719     printf( "\n" );
 720
 721     //--------------------------------------------------
 722     // close the file a second time
 723     //--------------------------------------------------
 724
 725      rc=pFile->close();
 726     print_error( rtl::OString( "Close the file a second time" ), rc );
 727
 728     delete pFile;
 729     PressKey();
 730 }
 731
 732 //--------------------------------------------------
 733 // FileCreateAndRemoveTest
 734 //--------------------------------------------------
 735
 736 void FileCreateAndRemoveTest()
 737 {
 738     FileBase::RC    rc;
 739     File    *pFile;
 740
 741     printf( "--------------------------------------------\n" );
 742     printf( "File-Create-And-Remove-Test\n" );
 743     printf( "--------------------------------------------\n\n" );
 744
 745     pFile=new File( file_not_exist );
 746
 747     printf( "Create File: ");
 748     printFileName( file_not_exist );
 749     printf( "\n" );
 750
 751     //----------------------------------------------------
 752     // open (create) a not existing file (Read and write)
 753     //----------------------------------------------------
 754
 755     rc = pFile->open( OpenFlag_Read | OpenFlag_Write | osl_File_OpenFlag_Create );
 756
 757     print_error( rtl::OString( "Create and Open File (Read & Write)" ), rc );
 758
 759     //----------------------------------------------------
 760     // close the file
 761     //----------------------------------------------------
 762
 763     rc=pFile->close();
 764     print_error( rtl::OString( "Close File" ), rc );
 765
 766     //----------------------------------------------------
 767     // remove the file
 768     //----------------------------------------------------
 769
 770     rc=pFile->remove( file_not_exist );
 771     print_error( rtl::OString(" Remove File" ), rc );
 772
 773     printf( "\n" );
 774
 775     //----------------------------------------------------
 776     // remove the same file a second time
 777     //----------------------------------------------------
 778     rc=pFile->remove( file_not_exist );
 779     print_error( rtl::OString( "Remove a not existing File" ), rc );
 780
 781     //----------------------------------------------------
 782     // remove an open file
 783     //----------------------------------------------------
 784
 785     pFile->open( OpenFlag_Read | OpenFlag_Write | osl_File_OpenFlag_Create );
 786
 787     rc=pFile->remove( file_not_exist );
 788     print_error( rtl::OString( "Remove an open File" ), rc );
 789
 790     pFile->close();
 791     pFile->remove( file_not_exist );
 792
 793     PressKey();
 794
 795     return;
 796 }
 797
 798 //--------------------------------------------------
 799 // FileWriteAndReadTest
 800 //--------------------------------------------------
 801
 802 void FileWriteAndReadTest( void )
 803 {
 804     FileBase::RC    rc;
 805
 806     sal_uInt64 uWritten;
 807     sal_uInt64 uRead;
 808     sal_Char    *pWriteBuffer="Hier kommt der Osterhase !";
 809     sal_uInt64  nLen=strlen( pWriteBuffer );
 810     sal_Char *pReadBuffer;
 811
 812     printf( "--------------------------------------------\n" );
 813     printf( "File-Write-And-Read-Test\n" );
 814     printf( "--------------------------------------------\n\n" );
 815
 816     File    *pFile;
 817
 818     pFile=new File( file_not_exist );
 819
 820     printf( "Create File: ");
 821     printFileName( file_not_exist );
 822     printf("\n");
 823
 824     //----------------------------------------------------
 825     // open (create) a not existing file (Read and write)
 826     //----------------------------------------------------
 827
 828     rc = pFile->open( OpenFlag_Read | OpenFlag_Write | osl_File_OpenFlag_Create );
 829
 830     print_error( rtl::OString( "Create and Open File (Read & Write)" ), rc );
 831
 832     printf( "\n" );
 833
 834     //----------------------------------------------------
 835     // write a string to the file
 836     //----------------------------------------------------
 837     rc=pFile->write( pWriteBuffer , nLen , uWritten );
 838     print_error( rtl::OString( "Write File" ), rc );
 839
 840     if(uWritten==nLen)
 841         printf( "Verify: OK! \n" );
 842     else
 843         printf( "Verify: Error\n" );
 844
 845     printf( "\n" );
 846
 847     //----------------------------------------------------
 848     // move the filepointer to the beginning
 849     //----------------------------------------------------
 850
 851     rc=pFile->setPos( Pos_Absolut , 0 );
 852     print_error( rtl::OString( "Set FilePointer to the beginning of the file" ), rc );
 853
 854     printf( "\n" );
 855
 856     //----------------------------------------------------
 857     // read the string
 858     //----------------------------------------------------
 859
 860     pReadBuffer=(sal_Char*) rtl_allocateMemory( (sal_uInt32)(nLen+1)*sizeof(sal_Char) );
 861     rtl_zeroMemory( pReadBuffer, (sal_uInt32)(nLen+1)*sizeof(sal_Char) );
 862     rc=pFile->read( pReadBuffer , nLen,uRead );
 863     print_error( rtl::OString( "Read File" ), rc );
 864
 865     if (strcmp(pWriteBuffer, pReadBuffer)==0)
 866     {
 867         printf( "Verify: OK !\n" );
 868         printf( "Text: %s\n",pReadBuffer );
 869     }
 870     else
 871         printf( "Verify: Error\n" );
 872
 873     rtl_freeMemory( pReadBuffer );
 874
 875     printf( "\n" );
 876
 877     // close the file
 878     rc=pFile->close();
 879     print_error( rtl::OString( "Close File" ), rc );
 880
 881     // remove the file
 882     rc=pFile->remove( file_not_exist );
 883     print_error( rtl::OString( "Remove File" ), rc );
 884
 885     PressKey();
 886
 887     return;
 888
 889 }
 890
 891 //--------------------------------------------------
 892 // FileCopyMoveTest
 893 //--------------------------------------------------
 894
 895 void FileCopyAndMoveTest( void )
 896 {
 897     FileBase::RC    rc;
 898
 899     printf( "--------------------------------------------\n" );
 900     printf( "File-Copy-Move-Test\n" );
 901     printf( "--------------------------------------------\n\n" );
 902
 903
 904     File    *pFile;
 905     rtl::OUString   destPath(dir2);
 906
 907     //--------------------------------------------------
 908     // FileCopyTest
 909     //--------------------------------------------------
 910
 911     destPath+=rtl::OUString::createFromAscii("/");
 912     destPath+=file3;
 913
 914     printf( "Copy the file ");
 915     printFileName( file1 );
 916     printf( " to ");
 917     printFileName( destPath );
 918     printf( "\n" );
 919
 920
 921     rc=File::copy( file1 , destPath );
 922     print_error( rtl::OString( "FileCopy" ), rc );
 923
 924     pFile=new File( destPath );
 925
 926     rc=pFile->open( OpenFlag_Read );
 927     if ( rc == FileBase::E_None)
 928     {
 929         printf( "Verify: OK!\n" );
 930         pFile->close();
 931         File::remove( destPath );
 932     }
 933     else
 934         printf( "Verify: Error!\n" );
 935
 936     delete pFile;
 937
 938     printf( "\n" );
 939
 940     //--------------------------------------------------
 941     // Copy a file to a not existing directory
 942     //--------------------------------------------------
 943
 944     destPath=rtl::OUString( dir_not_exist );
 945     destPath+=rtl::OUString::createFromAscii("/");
 946     destPath+=file3;
 947
 948     printf( "Copy a file to a not existing directory \n");
 949     printf( "Copy the file  %s to %s\n", file1.getStr(), destPath.getStr() );
 950
 951     rc=File::copy( file1, destPath );
 952     print_error( rtl::OString( "FileCopy" ), rc );
 953
 954     printf( "\n" );
 955
 956     //--------------------------------------------------
 957     // Copy a directory
 958     //--------------------------------------------------
 959
 960     printf( "Copy the directory: ");
 961     printFileName( dir1 );
 962     printf( " to ");
 963     printFileName( dir2 );
 964     printf( "\n" );
 965
 966     rc=File::copy( dir1 , dir2 );
 967     print_error( rtl::OString( "FileCopy" ), rc );
 968
 969     printf( "\n" );
 970
 971     //--------------------------------------------------
 972     // FileMoveTest
 973     //--------------------------------------------------
 974
 975     destPath=rtl::OUString( dir2 );
 976     destPath+=rtl::OUString::createFromAscii("/");
 977     destPath+=file3;
 978
 979     printf( "Move the file ");
 980     printFileName( file1 );
 981     printf( " to ");
 982     printFileName( destPath );
 983     printf( "\n" );
 984
 985     rc=File::move( file1, destPath );
 986     print_error( rtl::OString( "FileMove" ), rc );
 987
 988     pFile=new File( destPath );
 989
 990     rc=pFile->open( OpenFlag_Read );
 991     if ( rc==FileBase::E_None )
 992     {
 993         pFile->close();
 994
 995         delete pFile;
 996         pFile=new File( file1 );
 997
 998         rc=pFile->open( OpenFlag_Read );
 999
1000         if ( rc!=FileBase::E_None )
1001         {
1002             printf( "Verify: OK!\n" );
1003             File::move( destPath, file1 );
1004         }
1005         else
1006         {
1007             printf( "Verify: Error!\n" );
1008             pFile->close();
1009             File::remove( destPath );
1010         }
1011     }
1012     else
1013         printf( "Verify: Error!\n" );
1014
1015     delete pFile;
1016
1017     printf( "\n" );
1018
1019
1020     //--------------------------------------------------
1021     // Move a file to a not existing directory
1022     //--------------------------------------------------
1023
1024     destPath=rtl::OUString( dir_not_exist );
1025     destPath+=rtl::OUString::createFromAscii("/");
1026     destPath+=file3;
1027
1028     printf( "Move a file to a not existing directory: \n");
1029     printf( "Move the file ");
1030     printFileName( file1 );
1031     printf( " to ");
1032     printFileName( destPath );
1033     printf( "\n" );
1034
1035     rc=File::move( file1 , destPath );
1036     print_error( rtl::OString( "FileMove" ), rc );
1037
1038     printf( "\n" );
1039
1040     //--------------------------------------------------
1041     // Move a directory
1042     //--------------------------------------------------
1043
1044     printf( "Move a directory: \n");
1045
1046     printf( "Move the directory ");
1047     printFileName( dir1 );
1048     printf( " to ");
1049     printFileName( dir_not_exist );
1050     printf( "\n" );
1051
1052
1053     rc=File::move( dir1 , dir_not_exist);
1054     print_error( rtl::OString( "FileMove" ), rc );
1055
1056     if ( rc == FileBase::E_None )
1057         File::move( dir_not_exist , dir1);
1058
1059     printf( "\n" );
1060
1061
1062     PressKey();
1063     return;
1064 }
1065
1066 //----------------------------------------------------
1067 // FileSizeTest
1068 //----------------------------------------------------
1069
1070 void FileSizeTest( void )
1071 {
1072     FileBase::RC    rc;
1073     sal_uInt64      filesize;
1074     DirectoryItem   aItem;
1075
1076     printf( "--------------------------------------------\n" );
1077     printf( "File-Size-Test\n" );
1078     printf( "--------------------------------------------\n\n" );
1079
1080
1081     File    aFile( file_not_exist );
1082
1083     printf( "Create File: ");
1084     printFileName( file_not_exist );
1085     printf( "\n\n");
1086
1087     rc = aFile.open( OpenFlag_Read | OpenFlag_Write | osl_File_OpenFlag_Create );
1088     print_error( rtl::OString( "Create and Open File (Read & Write)" ), rc );
1089     printf( "\n" );
1090
1091     if ( rc == FileBase::E_None )
1092     {
1093         //----------------------------------------------------
1094         // Set Filesize to 5000
1095         //----------------------------------------------------
1096
1097         printf( "Set FileSize to 5000\n" );
1098         rc=aFile.setSize( 5000 );
1099         print_error( rtl::OString( "Set FileSize" ), rc );
1100
1101         printf( "\n" );
1102         printf( "Verify:\n" );
1103
1104         //----------------------------------------------------
1105         // Check whether Filesize is set to 5000
1106         //----------------------------------------------------
1107
1108         rc=DirectoryItem::get( file_not_exist, aItem );
1109         print_error( rtl::OString( "Get DirectoryItem" ), rc );
1110
1111         if ( rc == FileBase::E_None )
1112         {
1113             FileStatus rStatus( FileStatusMask_FileSize  );
1114             rc=aItem.getFileStatus( rStatus );
1115             print_error( rtl::OString( "Get FileStatus" ), rc );
1116
1117             if ( rc == FileBase::E_None )
1118             {
1119                 filesize=rStatus.getFileSize();
1120
1121                 if ( filesize == 5000 )
1122                     printf( "\nOK : FileSize: %i\n", filesize );
1123                 else
1124                     printf( "\nError : FileSize: %i\n", filesize );
1125             }
1126         }
1127
1128         printf( "\n" );
1129
1130         //----------------------------------------------------
1131         // Set Filesize to -1
1132         //----------------------------------------------------
1133
1134         printf( "Set FileSize to -1\n" );
1135         rc=aFile.setSize( -1 );
1136         print_error( rtl::OString( "Set FileSize" ), rc );
1137
1138         printf( "\n" );
1139
1140         // close the file
1141         rc=aFile.close();
1142         print_error( rtl::OString( "Close File" ), rc );
1143
1144         // remove the file
1145         rc=File::remove( file_not_exist );
1146         print_error( rtl::OString( "Remove File" ), rc );
1147     }
1148
1149     PressKey();
1150
1151     return;
1152 }
1153
1154
1155 //----------------------------------------------------
1156 // FilePointerTest
1157 //----------------------------------------------------
1158
1159 void FilePointerTest( void )
1160 {
1161     FileBase::RC    rc;
1162     sal_uInt64 filepointer;
1163
1164     printf( "--------------------------------------------\n" );
1165     printf( "File-Pointer-Test\n" );
1166     printf( "--------------------------------------------\n\n" );
1167
1168
1169     File    rFile( file_not_exist );
1170
1171     printf( "Create File: ");
1172     printFileName( file_not_exist );
1173     printf( "\n\n");
1174
1175     rc = rFile.open( OpenFlag_Read | OpenFlag_Write | osl_File_OpenFlag_Create );
1176     print_error( rtl::OString( "Create and Open File (Read & Write) "), rc );
1177     printf( "\n" );
1178
1179     if ( rc==FileBase::E_None )
1180     {
1181
1182         //----------------------------------------------------
1183         // get the position of the filepointer
1184         //----------------------------------------------------
1185
1186         rc =rFile.getPos( filepointer );
1187         print_error( rtl::OString( "GetPos" ), rc );
1188         printf( "Position of the FilePointer: %i\n", filepointer );
1189
1190         printf( "\n" );
1191
1192         //----------------------------------------------------
1193         // set the filepointer at the end of a file
1194         //----------------------------------------------------
1195
1196         printf( "Set FileSize to 5000\n" );
1197         rFile.setSize( 5000 );
1198
1199         printf( "Set the FilePointer at the end of the file (5000)\n" );
1200         rc=rFile.setPos( Pos_End,0 );
1201         print_error( rtl::OString( "SetPos" ), rc );
1202
1203         rc=rFile.getPos( filepointer );
1204
1205         if ( filepointer==5000 )
1206         {
1207             print_error( rtl::OString( "GetPos" ), rc );
1208             printf( "\nVerify: OK !\n" );
1209             printf( "Filepointer-Position: %llu\n",filepointer );
1210         }
1211         else
1212         {
1213             print_error( rtl::OString( "GetPos" ), rc );
1214             printf( "\nFilePointer-Test: Error\n" );
1215             printf( "Filepointer-Position: %i != 5000 \n",filepointer );
1216         }
1217
1218         printf( "\n" );
1219
1220         // close the file
1221         rc=rFile.close();
1222         print_error( rtl::OString( "Close File" ), rc );
1223
1224         // remove the file
1225         rc=File::remove( file_not_exist );
1226         print_error( rtl::OString( "Remove File" ), rc );
1227     }
1228
1229     PressKey();
1230
1231     return;
1232 }
1233
1234 //--------------------------------------------------
1235 // FileAttributesTest
1236 //--------------------------------------------------
1237
1238 void verifyFileAttributes( void )
1239 {
1240     FileBase::RC    rc;
1241     DirectoryItem   aItem;
1242     FileStatus rStatus( FileStatusMask_Attributes  );
1243
1244     printf( "\nVerify:\n" );
1245
1246     rc=DirectoryItem::get( file1, aItem );
1247
1248     if ( rc==FileBase::E_None )
1249     {
1250         rc=aItem.getFileStatus( rStatus );
1251
1252         if ( rc==FileBase::E_None )
1253         {
1254             sal_uInt64 uAttributes=rStatus.getAttributes();
1255             showAttributes(uAttributes);
1256             printf( "\n" );
1257         }
1258         else
1259             print_error( rtl::OString( "Get FileStatus" ), rc );
1260     }
1261     else
1262         print_error( rtl::OString( "Get DirectoryItem" ), rc );
1263
1264     return;
1265 }
1266
1267 #ifdef UNX
1268 void FileAttributesTest( void )
1269 {
1270     FileBase::RC    rc;
1271
1272     printf( "--------------------------------------------\n" );
1273     printf( "File-Attributes-Test\n" );
1274     printf( "--------------------------------------------\n\n" );
1275
1276     printf( "File: ");
1277     printFileName( file1 );
1278     printf( "\n\n" );
1279
1280
1281     rc=File::setAttributes( file1, Attribute_GrpWrite );
1282     print_error( rtl::OString( "Set Attribute: GrpWrite" ), rc );
1283
1284     verifyFileAttributes();
1285
1286     rc=File::setAttributes( file1, 0 );
1287     if ( rc!=FileBase::E_None )
1288         print_error( rtl::OString( "Reset Attributes" ), rc );
1289
1290     rc=File::setAttributes( file1, Attribute_GrpRead );
1291     print_error( rtl::OString( "Set Attribute: GrpRead" ), rc );
1292
1293     verifyFileAttributes();
1294
1295     rc=File::setAttributes( file1, 0 );
1296     if ( rc!=FileBase::E_None )
1297         print_error( rtl::OString( "Reset Attributes" ), rc );
1298
1299     rc=File::setAttributes( file1, Attribute_GrpExe );
1300     print_error( rtl::OString( "Set Attribute: GrpExe" ), rc );
1301
1302     verifyFileAttributes();
1303
1304     rc=File::setAttributes( file1, 0 );
1305     if ( rc!=FileBase::E_None )
1306         print_error( rtl::OString( "Reset Attributes" ), rc );
1307
1308     rc=File::setAttributes( file1, Attribute_OwnWrite );
1309     print_error( rtl::OString( "Set Attribute: OwnWrite" ), rc );
1310
1311     verifyFileAttributes();
1312
1313     rc=File::setAttributes( file1, 0 );
1314     if ( rc!=FileBase::E_None )
1315         print_error( rtl::OString( "Reset Attributes" ), rc );
1316
1317     rc=File::setAttributes( file1, Attribute_OwnRead );
1318     print_error( rtl::OString( "Set Attribute: OwnRead" ), rc );
1319
1320     verifyFileAttributes();
1321
1322     rc=File::setAttributes( file1, 0 );
1323     if ( rc!=FileBase::E_None )
1324         print_error( rtl::OString( "Reset Attributes" ), rc );
1325
1326     rc=File::setAttributes( file1, Attribute_OwnExe );
1327     print_error( rtl::OString( "Set Attribute: OwnExe" ), rc );
1328
1329     verifyFileAttributes();
1330
1331     rc=File::setAttributes( file1, 0 );
1332     if ( rc!=FileBase::E_None )
1333         print_error( rtl::OString( "Reset Attributes" ), rc );
1334
1335     rc=File::setAttributes( file1, Attribute_OthWrite );
1336     print_error( rtl::OString( "Set Attribute: OthWrite" ), rc );
1337
1338     verifyFileAttributes();
1339
1340     rc=File::setAttributes( file1, 0 );
1341     if ( rc!=FileBase::E_None )
1342         print_error( rtl::OString( "Reset Attributes" ), rc );
1343
1344     rc=File::setAttributes( file1, Attribute_OthRead );
1345     print_error( rtl::OString( "Set Attribute: OthRead" ), rc );
1346
1347     verifyFileAttributes();
1348
1349     rc=File::setAttributes( file1, 0 );
1350     if ( rc!=FileBase::E_None )
1351         print_error( rtl::OString( "Reset Attributes" ), rc );
1352
1353     rc=File::setAttributes( file1, Attribute_OthExe );
1354     print_error( rtl::OString( "Set Attribute: OthExe" ), rc );
1355
1356     verifyFileAttributes();
1357
1358     rc=File::setAttributes( file1, 0 );
1359     if ( rc!=FileBase::E_None )
1360         print_error( rtl::OString( "Reset Attributes" ), rc );
1361
1362
1363     rc=File::setAttributes( file1, Attribute_GrpWrite | Attribute_GrpRead | Attribute_GrpExe | Attribute_OwnWrite | Attribute_OwnRead | Attribute_OwnExe | Attribute_OthWrite | Attribute_OthRead | Attribute_OthExe );
1364     print_error( rtl::OString( "Set all Attributes" ), rc );
1365
1366     verifyFileAttributes();
1367
1368     PressKey();
1369
1370     return;
1371 }
1372 #endif
1373
1374 #ifdef WNT
1375 void FileAttributesTest( void )
1376 {
1377     FileBase::RC    rc;
1378
1379     printf( "--------------------------------------------\n" );
1380     printf( "File-Attributes-Test\n" );
1381     printf( "--------------------------------------------\n\n" );
1382
1383     printf( "File: ");
1384     printFileName( file1 );
1385     printf( "\n\n" );
1386
1387
1388     rc=File::setAttributes( file1, Attribute_ReadOnly );
1389     print_error( rtl::OString( "Set Attribute: ReadOnly" ), rc );
1390
1391     verifyFileAttributes();
1392
1393     rc=File::setAttributes( file1, 0 );
1394     print_error( rtl::OString( "Reset Attributes" ), rc );
1395
1396     verifyFileAttributes();
1397
1398     rc=File::setAttributes( file1, Attribute_Hidden );
1399     print_error( rtl::OString( "Set Attribute: Hidden" ), rc );
1400
1401     verifyFileAttributes();
1402
1403     rc=File::setAttributes( file1, 0 );
1404     print_error( rtl::OString( "Reset Attributes" ), rc );
1405
1406     verifyFileAttributes();
1407
1408     rc=File::setAttributes( file1, Attribute_Hidden | Attribute_ReadOnly );
1409     print_error( rtl::OString( "Set Attribute: Hidden & ReadOnly" ), rc );
1410
1411     verifyFileAttributes();
1412
1413     rc=File::setAttributes( file1, 0 );
1414     print_error( rtl::OString( "Reset Attributes") , rc );
1415
1416     verifyFileAttributes();
1417
1418     PressKey();
1419
1420     return;
1421 }
1422 #endif
1423
1424 //--------------------------------------------------
1425 // FileTimeTest
1426 //--------------------------------------------------
1427
1428 void FileTimeTest( void )
1429 {
1430     FileBase::RC    rc;
1431
1432     DirectoryItem   aItem;
1433
1434     struct tm sSysCreationTime = { 0, 20, 12, 4, 9, 100 };
1435     struct tm sSysAccessTime = { 0, 40, 1, 6, 5, 98 };
1436     struct tm sSysModifyTime = { 0, 1, 24, 13, 11, 95 };
1437
1438     time_t aSysCreationTime =  mktime( &sSysCreationTime );
1439     time_t aSysAccessTime =  mktime( &sSysAccessTime );
1440     time_t aSysModifyTime =  mktime( &sSysModifyTime );
1441
1442     TimeValue       aCreationTime   = { aSysCreationTime, 0};
1443     TimeValue       aAccessTime     = { aSysAccessTime, 0};
1444     TimeValue       aModifyTime     = { aSysModifyTime, 0};
1445
1446     TimeValue       aCreationTimeRead;
1447     TimeValue       aAccessTimeRead;
1448     TimeValue       aModifyTimeRead;
1449
1450
1451     printf( "--------------------------------------------\n" );
1452     printf( "File-Time-Test\n" );
1453     printf( "--------------------------------------------\n\n" );
1454
1455     printf( "File: ");
1456     printFileName( file1 );
1457     printf( "\n\n" );
1458
1459     printf( "CreationTime \t : ");
1460     showTime( aCreationTime );
1461
1462     printf( "\nAccessTime \t : ");
1463     showTime( aAccessTime );
1464
1465     printf( "\nModifyTime \t : ");
1466     showTime( aModifyTime );
1467
1468     //--------------------------------------------------
1469     // setTime
1470     //--------------------------------------------------
1471
1472     printf( "\n" );
1473     rc=File::setTime( file1 , aCreationTime , aAccessTime , aModifyTime );
1474     print_error( rtl::OString( "SetTime" ), rc );
1475
1476     //--------------------------------------------------
1477     // Verify
1478     //--------------------------------------------------
1479
1480     FileStatus rStatus( FileStatusMask_CreationTime | FileStatusMask_AccessTime | FileStatusMask_ModifyTime);
1481
1482     printf( "\nVerify:\n" );
1483
1484     rc=DirectoryItem::get( file1, aItem );
1485     print_error( rtl::OString( "Get DirectoryItem" ), rc );
1486
1487     if ( rc==FileBase::E_None )
1488     {
1489         rc=aItem.getFileStatus( rStatus );
1490         print_error( rtl::OString( "Get FileStatus" ), rc );
1491         printf( "\n" );
1492
1493         if ( rc==FileBase::E_None )
1494         {
1495             //--------------------------------------------------
1496             // GetCreationTime
1497             //--------------------------------------------------
1498
1499             aCreationTimeRead=rStatus.getCreationTime();
1500 #ifdef WNT
1501             if ( aCreationTime.Seconds == aCreationTimeRead.Seconds && aCreationTime.Nanosec == aCreationTimeRead.Nanosec )
1502                 printf( "GetCreationTime: ok : " );
1503             else
1504                 printf( "GetCreationTime: Error : " );
1505
1506             showTime( aCreationTimeRead );
1507             printf( "\n" );
1508 #endif
1509             //--------------------------------------------------
1510             // GetAccessTime
1511             //--------------------------------------------------
1512
1513             aAccessTimeRead=rStatus.getAccessTime();
1514
1515             if ( aAccessTime.Seconds == aAccessTimeRead.Seconds && aAccessTime.Nanosec == aAccessTimeRead.Nanosec )
1516                 printf( "GetAccessTime: ok : " );
1517             else
1518                 printf( "GetAccessTime: Error : " );
1519
1520             showTime( aAccessTimeRead );
1521             printf( "\n" );
1522
1523             //--------------------------------------------------
1524             // GetModifyTime
1525             //--------------------------------------------------
1526
1527             aModifyTimeRead=rStatus.getModifyTime();
1528
1529             if ( aModifyTime.Seconds == aModifyTimeRead.Seconds && aModifyTime.Nanosec == aModifyTimeRead.Nanosec )
1530                 printf( "GetModifyTime: ok : " );
1531             else
1532                 printf( "GetModifyTime: Error : " );
1533
1534             showTime( aModifyTimeRead );
1535             printf( "\n" );
1536         }
1537     }
1538
1539     PressKey();
1540     return;
1541 }
1542
1543
1544 //--------------------------------------------------
1545 // DirectoryItemTest
1546 //--------------------------------------------------
1547
1548 void DirectoryItemTest( void )
1549 {
1550     FileBase::RC    rc;
1551     Directory       *pDir;
1552     DirectoryItem   aItem;
1553     FileStatus      *pStatus;
1554     File            *pFile;
1555
1556     printf( "--------------------------------------------\n" );
1557     printf( "Directory-Item-Test\n" );
1558     printf( "--------------------------------------------\n\n" );
1559
1560     //--------------------------------------------------
1561     // get DirectoryItem from an existing directory
1562     //--------------------------------------------------
1563
1564     printf( "Get DirectoryItem from an existing Directory: ");
1565     printFileName( dir1 );
1566     printf( "\n");
1567
1568     rc=DirectoryItem::get( dir1 , aItem );
1569     print_error( rtl::OString( "GetDirectoryItem" ), rc );
1570
1571     pStatus=new FileStatus( FileStatusMask_All );
1572     rc=aItem.getFileStatus( *pStatus );
1573
1574     if ( rc==FileBase::E_None )
1575     {
1576         printf( "GetFileStatus: FileURL: ");
1577         printFileName(pStatus->getFileURL() );
1578         printf( "\n" );
1579     }
1580
1581     delete pStatus;
1582
1583     printf( "\n" );
1584
1585     //--------------------------------------------------
1586     // get DirectoryItem from a not existing directory
1587     //--------------------------------------------------
1588
1589     printf( "Get DirectoryItem from a not existing Directory: ");
1590     printFileName( dir_not_exist );
1591     printf( "\n" );
1592
1593     rc=DirectoryItem::get( dir_not_exist , aItem );
1594     print_error( rtl::OString( "Get DirectoryItem" ), rc );
1595
1596     printf( "\n" );
1597
1598     //--------------------------------------------------
1599     // get DirectoryItem from an existing file
1600     //--------------------------------------------------
1601
1602     printf( "Get DirectoryItem from an existing File: ");
1603     printFileName( file1 );
1604     printf( "\n" );
1605
1606     rc=DirectoryItem::get( file1 , aItem );
1607     print_error( rtl::OString( "GetDirectoryItem" ), rc );
1608
1609     pStatus=new FileStatus( FileStatusMask_All );
1610     rc=aItem.getFileStatus( *pStatus );
1611
1612     if ( rc==FileBase::E_None )
1613     {
1614         printf( "GetFileStatus: FileURL: ");
1615         printFileName( pStatus->getFileURL() );
1616         printf( "\n" );
1617     }
1618
1619     delete pStatus;
1620
1621     printf( "\n" );
1622
1623     //--------------------------------------------------
1624     // get DirectoryItem from a not existing file
1625     //--------------------------------------------------
1626
1627     printf( "Get DirectoryItem from a not existing File: ");
1628     printFileName( file_not_exist );
1629     printf( "\n" );
1630
1631     rc=DirectoryItem::get( file_not_exist , aItem );
1632     print_error( rtl::OString( "Get DirectoryItem" ), rc );
1633
1634     printf( "\n" );
1635
1636     //----------------------------------------------------------
1637     // get DirectoryItem from a directory with a wrong semantic
1638     //----------------------------------------------------------
1639
1640     printf( "Get DirectoryItem from a Directory with a wrong semantic: ");
1641     printFileName( dir_not_exist );
1642     printf( "\n" );
1643
1644     rc=DirectoryItem::get( dir_wrong_semantic, aItem );
1645     print_error( rtl::OString( "Get DirectoryItem" ),rc );
1646
1647     printf( "\n" );
1648
1649     //---------------------------------------------------
1650     // get DirectoryItem from a file-handle
1651     //--------------------------------------------------
1652
1653     pFile=new File( file1 );
1654
1655     rc=pFile->open( OpenFlag_Read );
1656     if ( rc==FileBase::E_None )
1657     {
1658         printf( "Get DirectoryItem from a File-Handle: ");
1659         printFileName( file1 );
1660         printf( "\n" );
1661
1662         rc=DirectoryItem::get( *pFile , aItem );
1663         print_error( rtl::OString( "GetDirectoryItem" ), rc );
1664
1665         pStatus=new FileStatus( FileStatusMask_All );
1666         rc=aItem.getFileStatus( *pStatus );
1667
1668         if ( rc==FileBase::E_None )
1669         {
1670             printf( "GetFileStatus: FileURL:  ");
1671             printFileName( pStatus->getFileURL() );
1672             printf( "\n");
1673         }
1674
1675         delete pStatus;
1676
1677         pFile->close();
1678     }
1679
1680     delete pFile;
1681
1682     printf( "\n" );
1683
1684     //---------------------------------------------------
1685     // get DirectoryItem from an empty file-handle
1686     //--------------------------------------------------
1687
1688     pFile=new File( file1 );
1689
1690     printf( "Get DirectoryItem from an empty File-Handle\n" );
1691     rc=DirectoryItem::get( *pFile , aItem );
1692     print_error( rtl::OString( "GetDirectoryItem" ), rc );
1693
1694     delete pFile;
1695
1696     printf( "\n" );
1697
1698     //--------------------------------------------------
1699     // GetNextItem from a directory
1700     //--------------------------------------------------
1701
1702     pDir=new Directory( dir1 );
1703     printf( "Get next DirectoryItem from a directory: ");
1704     printFileName( dir1);
1705     printf( "\n" );
1706
1707     rc= pDir->open();
1708     print_error( rtl::OString( "Open Directory" ), rc );
1709
1710     printf( "\n" );
1711
1712     if ( pDir->isOpen() )
1713     {
1714         //--------------------------------------------------
1715         // get all files from the directory
1716         //--------------------------------------------------
1717
1718         rtl::OUString   str;
1719         rtl::OUString   str1[2];
1720
1721         aItem=DirectoryItem();
1722         rc=pDir->getNextItem( aItem );
1723         print_error( rtl::OString( "GetNextItem" ),rc );
1724
1725         while( rc==FileBase::E_None )
1726         {
1727
1728             FileStatus rStatus( FileStatusMask_All );
1729             aItem.getFileStatus( rStatus );
1730
1731             str=rStatus.getFileName();
1732             printf( "Filename: ");
1733             printFileName( str );
1734             printf( "\n");
1735
1736             aItem=DirectoryItem();
1737             rc=pDir->getNextItem( aItem );
1738             print_error( rtl::OString( "GetNextItem" ),rc );
1739         }
1740
1741         printf( "\n" );
1742
1743         //--------------------------------------------------
1744         // Reset-Test
1745         //--------------------------------------------------
1746
1747         for (int i=0; i<2; i++)
1748         {
1749             aItem=DirectoryItem();
1750             rc=pDir->reset();
1751             rc=pDir->getNextItem( aItem );
1752
1753             FileStatus rStatus( FileStatusMask_All );
1754             aItem.getFileStatus( rStatus );
1755
1756             str1[i]=rStatus.getFileName();
1757         }
1758
1759
1760         if ( str1[0].compareTo(str1[1]) == 0 )
1761             print_error( rtl::OString( "Reset" ),FileBase::E_None );
1762         else
1763             print_error( rtl::OString( "Reset" ),FileBase::E_invalidError );
1764
1765         printf( "\n" );
1766
1767         // Close Directory
1768         rc=pDir->close();
1769         print_error( rtl::OString( "Close Directory" ), rc );
1770     }
1771
1772     printf( "\n");
1773
1774     //--------------------------------------------------
1775     // GetNextItem from a closed directory
1776     //--------------------------------------------------
1777
1778     printf( "Get next DirectoryItem from a closed directory: ");
1779     printFileName( dir1 );
1780     printf( "\n" );
1781
1782     aItem=DirectoryItem();
1783     rc=pDir->getNextItem( aItem );
1784     print_error( rtl::OString( "GetNextItem" ),rc );
1785
1786     delete pDir;
1787
1788     PressKey();
1789     return;
1790 }
1791
1792 //--------------------------------------------------
1793 // FileStatusTest (for different types)
1794 //--------------------------------------------------
1795
1796 void FileStatusTest( FileStatus *pStatus )
1797 {
1798     //--------------------------------------------------
1799     // GetFileType of the directory
1800     //--------------------------------------------------
1801
1802     FileStatus::Type    aType;
1803
1804     printf( "\ngetFileType:\n" );
1805     aType=pStatus->getFileType();
1806     showFileType( aType );
1807
1808     //--------------------------------------------------
1809     // GetAttributes
1810     //--------------------------------------------------
1811
1812     sal_uInt64          uAttributes;
1813
1814     printf( "\ngetAttributes:\n" );
1815     uAttributes=pStatus->getAttributes();
1816     showAttributes( uAttributes );
1817
1818     //--------------------------------------------------
1819     // GetCreationTime
1820     //--------------------------------------------------
1821
1822     TimeValue   aCreationTime;
1823
1824     printf( "\ngetCreationTime:\n" );
1825     aCreationTime=pStatus->getCreationTime();
1826
1827     printf( "CreationTime: " );
1828     showTime( aCreationTime );
1829
1830     //--------------------------------------------------
1831     // GetAccessTime
1832     //--------------------------------------------------
1833
1834     TimeValue   aAccessTime;
1835
1836     printf( "\ngetAccessTime:\n" );
1837     aAccessTime=pStatus->getAccessTime();
1838
1839     printf( "AccessTime: " );
1840     showTime( aAccessTime );
1841
1842     //--------------------------------------------------
1843     // GetModifyTime
1844     //--------------------------------------------------
1845
1846     TimeValue   aModifyTime;
1847
1848     printf( "\ngetModifyTime:\n" );
1849     aModifyTime=pStatus->getModifyTime();
1850
1851     printf( "ModifyTime: " );
1852     showTime( aModifyTime );
1853
1854     //--------------------------------------------------
1855     // GetFileSize
1856     //--------------------------------------------------
1857
1858     sal_uInt64          FileSize;
1859
1860     printf( "\ngetFileSize:\n" );
1861
1862     FileSize=pStatus->getFileSize();
1863     printf( "FileSize: %i\n", FileSize);
1864
1865     //--------------------------------------------------
1866     // GetFileName
1867     //--------------------------------------------------
1868
1869     rtl::OUString           FileName;
1870
1871     printf( "\ngetFileName:\n" );
1872
1873     FileName=pStatus->getFileName();
1874     printf( "FileName: ");
1875     printFileName( FileName );
1876     printf( "\n" );
1877
1878     //--------------------------------------------------
1879     // GetFileURL
1880     //--------------------------------------------------
1881
1882     rtl::OUString           FileURL;
1883
1884     printf( "\ngetFileURL:\n" );
1885
1886     FileURL=pStatus->getFileURL();
1887     printf( "FileURL: ");
1888     printFileName( FileURL );
1889     printf( "\n" );
1890
1891     //--------------------------------------------------
1892     // GetLinkTargetURL
1893     //--------------------------------------------------
1894
1895     rtl::OUString           LinkTargetURL;
1896
1897     printf( "\ngetLinkTargetURL:\n");
1898
1899     LinkTargetURL=pStatus->getLinkTargetURL();
1900     printf( "LinkTargetURL: ");
1901     printFileName( LinkTargetURL );
1902     printf( "\n" );
1903
1904     return;
1905 }
1906
1907 //--------------------------------------------------
1908 // DirectoryFileStatusTest
1909 //--------------------------------------------------
1910
1911 void DirectoryFileStatusTest( void )
1912 {
1913     FileBase::RC    rc;
1914     DirectoryItem   aItem;
1915     FileStatus      *pStatus;
1916
1917     printf( "--------------------------------------------\n" );
1918     printf( "Directory-FileStatus-Test\n" );
1919     printf( "--------------------------------------------\n\n" );
1920
1921     printf( "FileStatus of the directory: ");
1922     printFileName( dir1 );
1923     printf( "\n" );
1924
1925     aItem=DirectoryItem();
1926
1927     rc=DirectoryItem::get( dir1, aItem );
1928     print_error( rtl::OString( "Get DirectoryItem" ), rc );
1929
1930     if ( rc==FileBase::E_None )
1931     {
1932         pStatus=new FileStatus( FileStatusMask_All );
1933         rc=aItem.getFileStatus( *pStatus );
1934
1935         FileStatusTest( pStatus );
1936
1937         delete pStatus;
1938     }
1939
1940     printf( "\n" );
1941
1942     PressKey();
1943     return;
1944 }
1945
1946 //--------------------------------------------------
1947 // FileFileStatusTest
1948 //--------------------------------------------------
1949
1950 void FileFileStatusTest( void )
1951 {
1952     FileBase::RC    rc;
1953     DirectoryItem   aItem;
1954     FileStatus      *pStatus;
1955
1956     printf( "--------------------------------------------\n" );
1957     printf( "File-FileStatus-Test\n" );
1958     printf( "--------------------------------------------\n\n" );
1959
1960     printf( "FileStatus of the file: ");
1961     printFileName( file1 );
1962     printf( "\n" );
1963
1964     aItem=DirectoryItem();
1965
1966     rc=DirectoryItem::get( file1 , aItem );
1967     print_error( rtl::OString( "Get DirectoryItem" ), rc );
1968
1969     if ( rc==FileBase::E_None )
1970     {
1971         pStatus=new FileStatus( FileStatusMask_All );
1972         rc=aItem.getFileStatus( *pStatus );
1973
1974         FileStatusTest( pStatus );
1975
1976         delete pStatus;
1977     }
1978
1979     printf( "\n" );
1980
1981     PressKey();
1982     return;
1983 }
1984
1985 //--------------------------------------------------
1986 // VolumeFileStatusTest
1987 //--------------------------------------------------
1988
1989 void VolumeFileStatusTest( void )
1990 {
1991     FileBase::RC    rc;
1992     DirectoryItem   aItem;
1993     FileStatus      *pStatus;
1994
1995     printf( "--------------------------------------------\n" );
1996     printf( "Volume-FileStatus-Test\n" );
1997     printf( "--------------------------------------------\n\n" );
1998
1999     printf( "FileStatus of the Volume: ");
2000     printFileName( root );
2001     printf( "\n" );
2002
2003     aItem=DirectoryItem();
2004
2005     rc=DirectoryItem::get( root , aItem );
2006     print_error( rtl::OString( "Get DirectoryItem" ), rc );
2007
2008     if ( rc==FileBase::E_None )
2009     {
2010         pStatus=new FileStatus( FileStatusMask_All) ;
2011         rc=aItem.getFileStatus( *pStatus );
2012
2013         FileStatusTest( pStatus );
2014
2015         delete pStatus;
2016     }
2017
2018     printf( "\n" );
2019
2020     PressKey();
2021     return;
2022 }
2023
2024
2025 //--------------------------------------------------
2026 // VolumeInfoTest
2027 //--------------------------------------------------
2028
2029 void VolumeInfoTest( void )
2030 {
2031     FileBase::RC    rc;
2032
2033     printf( "--------------------------------------------\n" );
2034     printf( "Volume-Info-Test\n" );
2035     printf( "--------------------------------------------\n\n" );
2036
2037     printf( "VolumeInfo of the volume ");
2038     printFileName( root );
2039
2040     printf( "\n" );
2041
2042     VolumeInfo rInfo( VolumeInfoMask_FreeSpace );
2043     rc=Directory::getVolumeInfo( root , rInfo );
2044     print_error( rtl::OString( "GetVolumeInfo" ),rc );
2045
2046     printf( "\n" );
2047
2048     //--------------------------------------------------
2049     // getRemoteFlag
2050     //--------------------------------------------------
2051
2052     if ( rInfo.getRemoteFlag() )
2053         printf( "RemoteFlag: Yes\n" );
2054     else
2055         printf( "RemoteFlag: No\n" );
2056
2057     //--------------------------------------------------
2058     // getRemoveableFlag
2059     //--------------------------------------------------
2060
2061     if ( rInfo.getRemoveableFlag() )
2062         printf( "RemoveableFlag: Yes\n" );
2063     else
2064         printf( "RemoveableFlag: No\n" );
2065
2066     //--------------------------------------------------
2067     // getTotalSpace
2068     //--------------------------------------------------
2069
2070     sal_uInt64  TotalSpace;
2071     TotalSpace=rInfo.getTotalSpace();
2072     printf( "Total Space: %i\n",TotalSpace );
2073
2074     //--------------------------------------------------
2075     // getFreeSpace
2076     //--------------------------------------------------
2077
2078     sal_uInt64  FreeSpace;
2079     FreeSpace=rInfo.getFreeSpace();
2080     printf( "Free Space: %i\n",FreeSpace );
2081
2082     //--------------------------------------------------
2083     // getUsedSpace
2084     //--------------------------------------------------
2085
2086     sal_uInt64  UsedSpace;
2087     UsedSpace=rInfo.getUsedSpace();
2088     printf( "Used Space: %i\n",UsedSpace );
2089
2090     //--------------------------------------------------
2091     // getMaxNameLength
2092     //--------------------------------------------------
2093
2094     sal_uInt32  MaxNameLength;
2095     MaxNameLength=rInfo.getMaxNameLength();
2096     printf( "MaxNameLength: %i\n",MaxNameLength );
2097
2098     //--------------------------------------------------
2099     // getMaxPathLength
2100     //--------------------------------------------------
2101
2102     sal_uInt32  MaxPathLength;
2103     MaxPathLength=rInfo.getMaxPathLength();
2104     printf( "MaxPathLength: %i\n",MaxPathLength );
2105
2106     //--------------------------------------------------
2107     // getFileSystemName
2108     //--------------------------------------------------
2109
2110     rtl::OUString   FileSystemName;
2111     FileSystemName=rInfo.getFileSystemName();
2112     printf( "File-System-Name: ");
2113     printFileName( FileSystemName );
2114     printf( "\n" );
2115
2116     PressKey();
2117     return;
2118 }
2119
2120 //--------------------------------------------------
2121 // FileBaseTest
2122 //--------------------------------------------------
2123
2124 void ConvertPathTest(rtl::OUString& strPath)
2125 {
2126     FileBase::RC    rc;
2127
2128     rtl::OUString       strNormPath;
2129     rtl::OUString       strFileURL;
2130     rtl::OUString       strNormPathFromFileURL;
2131     rtl::OUString       strSystemPath;
2132
2133     //--------------------------------------------------
2134     // normalizePath
2135     //--------------------------------------------------
2136
2137     rc=FileBase::getFileURLFromSystemPath( strPath, strNormPath );
2138
2139     if ( rc == FileBase::E_None )
2140     {
2141         printf( "Normalized Path: \t\t");
2142         printFileName( strNormPath );
2143         printf( "\n" );
2144     }
2145     else
2146         printf( "normalizePath: Error \n" );
2147
2148     //--------------------------------------------------
2149     // getFileURLFromSystemPath
2150     //--------------------------------------------------
2151
2152     if ( strNormPath.getLength() != 0 )
2153     {
2154         rc=FileBase::getFileURLFromSystemPath( strNormPath, strFileURL );
2155
2156         if ( rc == FileBase::E_None )
2157         {
2158             printf( "File-URL: \t\t\t");
2159             printFileName( strFileURL );
2160             printf( "\n" );
2161         }
2162         else
2163             printf( "getFileURLFromSystemPath: Error \n" );
2164     }
2165     else
2166         printf( "getFileURLFromSystemPath: not tested \n" );
2167
2168     //--------------------------------------------------
2169     // getNormalizedPathFromFileURL
2170     //--------------------------------------------------
2171
2172     if ( strFileURL.getLength() != 0 )
2173     {
2174         rc=FileBase::getSystemPathFromFileURL( strFileURL, strNormPathFromFileURL );
2175
2176         if ( rc == FileBase::E_None )
2177         {
2178             printf( "Normalized Path from File-URL: \t");
2179             printFileName( strNormPathFromFileURL );
2180             printf( "\n" );
2181         }
2182         else
2183             printf( "getNormalizedPathFromFileURL: Error \n" );
2184     }
2185     else
2186         printf( "getNormalizedPathFromFileURL: not tested \n" );
2187
2188
2189     //--------------------------------------------------
2190     // getSystemPathFromFileURL
2191     //--------------------------------------------------
2192
2193     if ( strNormPath.getLength() != 0 )
2194     {
2195         rc=FileBase::getSystemPathFromFileURL( strNormPath, strSystemPath );
2196
2197         if ( rc == FileBase::E_None )
2198         {
2199             printf( "System-Path: \t\t\t");
2200             printFileName( strSystemPath );
2201             printf( "\n");
2202         }
2203         else
2204             printf( "getSystemPathFromFileURL: Error \n" );
2205     }
2206     else
2207         printf( "getSystemPathFromFileURL: not tested \n" );
2208
2209     //--------------------------------------------------
2210     // Verify
2211     //--------------------------------------------------
2212
2213     if ( strNormPathFromFileURL == strNormPath )
2214         printf( "\nVerify: OK ! ( Normalized-Path == Normalized-Path-From-File-URL )\n" );
2215     else
2216         printf( "\nVerify: Error ! ( Normalized-Path != Normalized-Path-From-File-URL )\n" );
2217
2218     return;
2219 }
2220
2221 void FileBaseTest()
2222 {
2223     printf( "--------------------------------------------\n" );
2224     printf( "FileBase-Test\n" );
2225     printf( "--------------------------------------------\n\n" );
2226
2227     //--------------------------------------------------
2228     // ConvertPath-Test (Local File)
2229     //--------------------------------------------------
2230
2231     printf( "- Local File: ");
2232     printFileName( file1 );
2233     printf( "\n\n" );
2234
2235     ConvertPathTest(file1);
2236
2237     //--------------------------------------------------
2238     // ConvertPath-Test (File on a server)
2239     //--------------------------------------------------
2240
2241     printf( "\n- File on server: ");
2242     printFileName( file_on_server );
2243     printf( "\n\n" );
2244     ConvertPathTest(file_on_server);
2245
2246     PressKey();
2247
2248     return;
2249 }
2250
2251
2252 //--------------------------------------------------
2253 // AbsolutePathTest
2254 //--------------------------------------------------
2255 void DoAbsolutePathTest(rtl::OUString strDirBase, rtl::OUString strRelative)
2256 {
2257     FileBase::RC    rc;
2258
2259     rtl::OUString       strAbsolute;
2260
2261     printf( "Base-Directory: \t");
2262     printFileName( strDirBase );
2263     printf( "\n" );
2264     printf( "Relative-Path: \t\t");
2265     printFileName ( strRelative );
2266     printf( "\n" );
2267
2268     rc=FileBase::getAbsoluteFileURL( strDirBase, strRelative, strAbsolute );
2269
2270     if ( rc == FileBase::E_None )
2271     {
2272         printf( "Absolute-Path: \t\t");
2273         printFileName ( strAbsolute );
2274         printf( "\n" );
2275     }
2276     else
2277         printf( "Absolute-Path: Error \n" );
2278
2279     printf( "\n" );
2280     return;
2281 }
2282
2283 void AbsolutePathTest(void)
2284 {
2285     printf( "--------------------------------------------\n" );
2286     printf( "AbsolutePath-Test\n" );
2287     printf( "--------------------------------------------\n\n" );
2288
2289     DoAbsolutePathTest(dir1, rtl::OUString::createFromAscii("."));
2290     DoAbsolutePathTest(dir1, rtl::OUString::createFromAscii(".."));
2291     DoAbsolutePathTest(dir1, rtl::OUString::createFromAscii("../.."));
2292     DoAbsolutePathTest(dir1, rtl::OUString::createFromAscii("../HUHU"));
2293
2294     DoAbsolutePathTest(dir_on_server, rtl::OUString::createFromAscii("."));
2295     DoAbsolutePathTest(dir_on_server, rtl::OUString::createFromAscii(".."));
2296     DoAbsolutePathTest(dir_on_server, rtl::OUString::createFromAscii("../.."));
2297     DoAbsolutePathTest(dir_on_server, rtl::OUString::createFromAscii("../HUHU"));
2298
2299     PressKey();
2300     return;
2301 }
2302
2303
2304 //--------------------------------------------------
2305 // searchPathTest
2306 //--------------------------------------------------
2307
2308 void SearchPathTest(void)
2309 {
2310     FileBase::RC    rc;
2311
2312     rtl::OUString       strNormPath(file1);
2313     rtl::OUString       strFileURL;
2314     rtl::OUString       strSystemPath;
2315     rtl::OUString       strResultPath;
2316
2317     printf( "--------------------------------------------\n" );
2318     printf( "SearchPath-Test\n" );
2319     printf( "--------------------------------------------\n\n" );
2320
2321
2322     rc=FileBase::getFileURLFromSystemPath( strNormPath, strFileURL );
2323     print_error( rtl::OString( "getFileURLFromSystemPath" ), rc );
2324     rc=FileBase::getSystemPathFromFileURL( strNormPath, strSystemPath );
2325     print_error( rtl::OString( "getSystemPathFromFileURL" ), rc );
2326
2327     //--------------------------------------------------
2328     // searchFileURL (with a normalized path)
2329     //--------------------------------------------------
2330
2331     if ( strNormPath.getLength() != 0 )
2332     {
2333         printf( "\nSearch-Normalized-Path (with a normalized path) : ");
2334         printFileName ( strNormPath );
2335         printf( "\n" );
2336
2337         rc=FileBase::searchFileURL( strNormPath , rtl::OUString() , strResultPath );
2338
2339         if ( rc == FileBase::E_None )
2340         {
2341             printf( "Result: \t\t\t");
2342             printFileName ( strResultPath );
2343             printf( "\n" );
2344         }
2345         else
2346             printf( "searchFileURL (with a normalized path): Error\n" );
2347     }
2348     else
2349         printf( "searchFileURL (with a normalized path): not tested\n" );
2350
2351     //--------------------------------------------------
2352     // searchFileURL (with a File-URL)
2353     //--------------------------------------------------
2354
2355     if ( strFileURL.getLength() != 0 )
2356     {
2357         printf( "\nSearch-Normalized-Path (with a FileURL) : ");
2358         printFileName( strFileURL );
2359         printf( "\n" );
2360
2361         rc=FileBase::searchFileURL( strFileURL , rtl::OUString() , strResultPath );
2362
2363         if ( rc == FileBase::E_None )
2364         {
2365             printf( "Result: \t\t\t");
2366             printFileName ( strResultPath );
2367             printf( "\n" );
2368         }
2369         else
2370             printf( "searchFileURL (with a FileURL path): Error\n" );
2371     }
2372     else
2373         printf( "searchFileURL (with a FileURL path): not tested\n" );
2374
2375     //--------------------------------------------------
2376     // searchFileURL (with a systempath)
2377     //--------------------------------------------------
2378
2379     if ( strSystemPath.getLength() != 0 )
2380     {
2381         printf( "\nSearch-Normalized-Path (with a SystemPath) : ");
2382         printFileName( strSystemPath );
2383         printf( "\n" );
2384
2385         rc=FileBase::searchFileURL( strSystemPath , rtl::OUString() , strResultPath );
2386
2387         if ( rc == FileBase::E_None )
2388         {
2389             printf( "Result: \t\t\t");
2390             printFileName( strResultPath );
2391             printf( "\n" );
2392         }
2393         else
2394             printf( "searchFileURL (with a systempath): Error\n" );
2395     }
2396     else
2397         printf( "searchFileURL (with a systempath): not tested\n" );
2398
2399     //--------------------------------------------------
2400     // searchFileURL (File and no searchpath)
2401     //--------------------------------------------------
2402
2403     printf( "\nsearchFileURL:  File (no searchpath) : ");
2404     printFileName( file3 );
2405     printf( "\n" );
2406
2407     rc=FileBase::searchFileURL( file3 , rtl::OUString::createFromAscii("") , strResultPath );
2408
2409     if ( rc == FileBase::E_None )
2410     {
2411         printf( "Result: \t\t\t");
2412         printFileName( strResultPath );
2413         printf( "\n" );
2414     }
2415     else
2416         printf( "searchFileURL:  File not found: OK ! \n" );
2417
2418     //--------------------------------------------------
2419     // searchFileURL (File and Path)
2420     //--------------------------------------------------
2421
2422     printf( "\nsearchFileURL:  File : ");
2423     printFileName( file3 );
2424     printf( "\tSearchPath ");
2425     printFileName( dir1 );
2426     printf( "\n");
2427
2428     rc=FileBase::searchFileURL( file3 , dir1 , strResultPath );
2429
2430     if ( rc == FileBase::E_None )
2431     {
2432         printf( "Result: \t\t\t");
2433         printFileName( strResultPath );
2434         printf( "\n");
2435     }
2436     else
2437         printf( "searchFileURL:  File not found: Error\n" );
2438
2439     //------------------------------------------------------------
2440     // searchFileURL (File and searchpath with two entries)
2441     //------------------------------------------------------------
2442
2443     rtl::OUString       strSearchPath( dir_not_exist );
2444     strSearchPath+=rtl::OUString::createFromAscii(";");
2445     strSearchPath+=dir_on_server;
2446
2447     printf( "\nsearchFileURL:  File : ");
2448     printFileName( file3 );
2449     printf( "SearchPath ");
2450     printFileName( strSearchPath );
2451     printf( "\n");
2452
2453     rc=FileBase::searchFileURL( file3 , strSearchPath , strResultPath );
2454
2455     if ( rc == FileBase::E_None )
2456     {
2457         printf( "Result: \t\t\t");
2458         printFileName( strResultPath );
2459         printf( "\n" );
2460     }
2461     else
2462         printf( "searchFileURL:  File not found: Error\n" );
2463
2464     //-------------------------------------------------------------------
2465     // searchFileURL (File and searchpath (with a wrong semantic))
2466     //-------------------------------------------------------------------
2467
2468     strSearchPath=rtl::OUString( dir_wrong_semantic );
2469
2470     printf( "\nsearchFileURL:  File : ");
2471     printFileName( file3 );
2472     printf( "SearchPath ");
2473     printFileName( strSearchPath );
2474     printf( "\n");
2475
2476     rc=FileBase::searchFileURL( file3 , strSearchPath , strResultPath );
2477
2478     if ( rc == FileBase::E_None )
2479         printf( "Error: Wrong Semantich but no error occurs !\n" );
2480     else
2481         printf( "searchFileURL:  File not found: OK !\n" );
2482
2483     return;
2484 }
2485
2486 //--------------------------------------------------
2487 // CanonicalNameTest
2488 //--------------------------------------------------
2489
2490 void getCanonicalNameTest(rtl::OUString strPath)
2491 {
2492     FileBase::RC    rc;
2493
2494     rtl::OUString   strValid;
2495
2496     printf( "Original-Name: \t\t");
2497     printFileName( strPath );
2498     printf( "\n" );
2499
2500     rc=FileBase::getCanonicalName( strPath, strValid );
2501
2502     if ( rc == FileBase::E_None)
2503     {
2504         printf( "Canonical-Name: \t");
2505         printFileName( strValid );
2506         printf( "\n");
2507
2508     }
2509     else
2510         printf( "Canonical-Name: Error \n" );
2511
2512     printf( "\n" );
2513     return;
2514 }
2515
2516 void CanonicalNameTest(void)
2517 {
2518     printf( "--------------------------------------------\n" );
2519     printf( "CanonicalName-Test\n" );
2520     printf( "--------------------------------------------\n\n" );
2521
2522     getCanonicalNameTest( dir1 );
2523     getCanonicalNameTest( dir_on_server );
2524     getCanonicalNameTest( file1 );
2525     getCanonicalNameTest( file_on_server );
2526
2527     PressKey();
2528     return;
2529 }
2530
2531 //--------------------------------------------------
2532 // print_error
2533 //--------------------------------------------------
2534
2535 void print_error( ::rtl::OString& str, FileBase::RC rc )
2536 {
2537
2538     printf( "%s : ",str.getStr() );
2539     switch(rc)
2540     {
2541     case FileBase::E_None:
2542         printf("OK !\n");
2543         break;
2544     case FileBase::E_PERM:
2545         printf("E_PERM\n");
2546         break;
2547     case FileBase::E_NOENT:
2548         printf("E_NOENT\n");
2549         break;
2550     case FileBase::E_SRCH:
2551         printf("E_SRCH\n");
2552         break;
2553     case FileBase::E_INTR:
2554         printf("E_INTR\n");
2555         break;
2556     case FileBase::E_IO:
2557         printf("E_IO\n");
2558         break;
2559     case FileBase::E_NXIO:
2560         printf("E_NXIO\n");
2561         break;
2562     case FileBase::E_2BIG:
2563         printf("E_2BIG\n");
2564         break;
2565     case FileBase::E_NOEXEC:
2566         printf("E_NOEXEC\n");
2567         break;
2568     case FileBase::E_BADF:
2569         printf("E_BADF\n");
2570         break;
2571     case FileBase::E_CHILD:
2572         printf("E_CHILD\n");
2573         break;
2574     case FileBase::E_AGAIN:
2575         printf("E_AGAIN\n");
2576         break;
2577     case FileBase::E_NOMEM:
2578         printf("E_NOMEM\n");
2579         break;
2580     case FileBase::E_ACCES:
2581         printf("E_ACCES\n");
2582         break;
2583     case FileBase::E_FAULT:
2584         printf("E_FAULT\n");
2585         break;
2586     case FileBase::E_BUSY:
2587         printf("E_BUSY\n");
2588         break;
2589     case FileBase::E_EXIST:
2590         printf("E_EXIST\n");
2591         break;
2592     case FileBase::E_XDEV:
2593         printf("E_XDEV\n");
2594         break;
2595     case FileBase::E_NODEV:
2596         printf("E_NODEV\n");
2597         break;
2598     case FileBase::E_NOTDIR:
2599         printf("E_NOTDIR\n");
2600         break;
2601     case FileBase::E_ISDIR:
2602         printf("E_ISDIR\n");
2603         break;
2604     case FileBase::E_INVAL:
2605         printf("E_INVAL\n");
2606         break;
2607     case FileBase::E_NFILE:
2608         printf("E_NFILE\n");
2609         break;
2610     case FileBase::E_MFILE:
2611         printf("E_MFILE\n");
2612         break;
2613     case FileBase::E_NOTTY:
2614         printf("E_NOTTY\n");
2615         break;
2616     case FileBase::E_FBIG:
2617         printf("E_FBIG\n");
2618         break;
2619     case FileBase::E_NOSPC:
2620         printf("E_NOSPC\n");
2621         break;
2622     case FileBase::E_SPIPE:
2623         printf("E_SPIPE\n");
2624         break;
2625     case FileBase::E_ROFS:
2626         printf("E_ROFS\n");
2627         break;
2628     case FileBase::E_MLINK:
2629         printf("E_MLINK\n");
2630         break;
2631     case FileBase::E_PIPE:
2632         printf("E_PIPE\n");
2633         break;
2634     case FileBase::E_DOM:
2635         printf("E_DOM\n");
2636         break;
2637     case FileBase::E_RANGE:
2638         printf("E_RANGE\n");
2639         break;
2640     case FileBase::E_DEADLK:
2641         printf("E_DEADLK\n");
2642         break;
2643     case FileBase::E_NAMETOOLONG:
2644         printf("E_NAMETOOLONG\n");
2645         break;
2646     case FileBase::E_NOLCK:
2647         printf("E_NOLCK\n");
2648         break;
2649     case FileBase::E_NOSYS:
2650         printf("E_NOSYS\n");
2651         break;
2652     case FileBase::E_NOTEMPTY:
2653         printf("E_NOTEMPTY\n");
2654         break;
2655     case FileBase::E_LOOP:
2656         printf("E_LOOP\n");
2657         break;
2658     case FileBase::E_ILSEQ:
2659         printf("E_ILSEQ\n");
2660         break;
2661     case FileBase::E_NOLINK:
2662         printf("E_NOLINK\n");
2663         break;
2664     case FileBase::E_MULTIHOP:
2665         printf("E_MULTIHOP\n");
2666         break;
2667     case FileBase::E_USERS:
2668         printf("E_USERS\n");
2669         break;
2670     case FileBase::E_OVERFLOW:
2671         printf("E_OVERFLOW\n");
2672         break;
2673     default:
2674         printf("E_Unknown\n");
2675         break;
2676     }
2677     return;
2678 }
2679
2680 //--------------------------------------------------
2681 // main
2682 //--------------------------------------------------
2683 #if defined WNT
2684         #define MAIN _cdecl main
2685 #else
2686         #define MAIN main
2687 #endif
2688
2689 int MAIN( int argc, char* argv[] )
2690 {
2691     sal_Bool fSuccess=sal_False;
2692
2693     //Initialization
2694     fSuccess=Initialize();
2695     if ( !fSuccess )
2696     {
2697         printf("Error during Initialization");
2698         return -1;
2699     }
2700
2701
2702     if (argc==1)
2703     {
2704         DirectoryOpenAndCloseTest();
2705         DirectoryCreateAndRemoveTest();
2706
2707         FileOpenAndCloseTest();
2708         FileCreateAndRemoveTest();
2709         FileWriteAndReadTest();
2710         FileCopyAndMoveTest();
2711         FileSizeTest();
2712         FilePointerTest();
2713         FileAttributesTest();
2714         FileTimeTest();
2715         DirectoryItemTest();
2716         DirectoryFileStatusTest();
2717         VolumeFileStatusTest();
2718         FileFileStatusTest();
2719         VolumeInfoTest();
2720         FileBaseTest();
2721         SearchPathTest();
2722         AbsolutePathTest();
2723         CanonicalNameTest();
2724     }
2725     // command line arguments ?
2726     else
2727     {
2728         int i=1;
2729
2730         while (i<argc)
2731         {
2732             if (strcmp(argv[i], "doc")==0)
2733                 DirectoryOpenAndCloseTest();
2734             else if (strcmp(argv[i], "dcr")==0)
2735                 DirectoryCreateAndRemoveTest();
2736             else if (strcmp(argv[i], "foc")==0)
2737                 FileOpenAndCloseTest();
2738             else if (strcmp(argv[i], "fcr")==0)
2739                 FileCreateAndRemoveTest();
2740             else if (strcmp(argv[i], "fwr")==0)
2741                 FileWriteAndReadTest();
2742             else if (strcmp(argv[i], "fcm")==0)
2743                 FileCopyAndMoveTest();
2744             else if (strcmp(argv[i], "fs")==0)
2745                 FileSizeTest();
2746             else if (strcmp(argv[i], "fp")==0)
2747                 FilePointerTest();
2748             else if (strcmp(argv[i], "fa")==0)
2749                 FileAttributesTest();
2750             else if (strcmp(argv[i], "ft")==0)
2751                 FileTimeTest();
2752             else if (strcmp(argv[i], "di")==0)
2753                 DirectoryItemTest();
2754             else if (strcmp(argv[i], "dfs")==0)
2755                 DirectoryFileStatusTest();
2756             else if (strcmp(argv[i], "vfs")==0)
2757                 VolumeFileStatusTest();
2758             else if (strcmp(argv[i], "ffs")==0)
2759                 FileFileStatusTest();
2760             else if (strcmp(argv[i], "vi")==0)
2761                 VolumeInfoTest();
2762             else if (strcmp(argv[i], "fb")==0)
2763                 FileBaseTest();
2764             else if (strcmp(argv[i], "sp")==0)
2765                 SearchPathTest();
2766             else if (strcmp(argv[i], "ap")==0)
2767                 AbsolutePathTest();
2768             else if (strcmp(argv[i], "cn")==0)
2769                 CanonicalNameTest();
2770
2771             i++;
2772         }
2773     }
2774
2775     // Shutdown
2776     fSuccess=Shutdown();
2777     if ( !fSuccess )
2778     {
2779         printf("Error during Shutdown");
2780         return -1;
2781     }
2782
2783     return 0;
2784 }
2785
2786