sal/workben/testfile.cxx

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