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