| blob | 2a6fbeacc4d7245bbb51ed05b61ad2eb180ee09f |
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: osl_File.cxx,v $
10 * $Revision: 1.14 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
31 // MARKER(update_precomp.py): autogen include statement, do not remove
34 //------------------------------------------------------------------------
35 // include files
36 //------------------------------------------------------------------------
37 #include <sal/types.h>
38 #include <rtl/ustring.hxx>
39 #include <rtl/ustrbuf.hxx>
44 #include <osl/file.hxx>
45 #include <osl_File_Const.h>
47 #include <cppunit/simpleheader.hxx>
49 // #ifdef WNT
50 // # define UNICODE
51 // # define WIN32_LEAN_AND_MEAN
52 // # include <windows.h>
53 // # include <tchar.h>
54 // #endif
60 //------------------------------------------------------------------------
61 // helper functions
62 //------------------------------------------------------------------------
64 /** detailed wrong message.
65 */
67 {
103 }
105 }
108 {
114 }
116 /** print a file type name.
117 */
119 {
146 }
147 }
149 /** print a file attributes.
150 */
152 {
179 }
181 /** print a UNI_CODE file name.
182 */
184 {
190 }
192 /** print a ASCII_CODE file name.
193 */
195 {
198 }
200 /** print an output wrong message.
201 */
203 {
206 }
208 /** print an signed Integer Number.
209 */
211 {
214 }
216 /** print an unsigned Integer Number.
217 */
219 {
222 }
224 /** print Boolean value.
225 */
227 {
230 }
232 /** print struct TimeValue in local time format.
233 */
235 {
241 CPPUNIT_ASSERT_MESSAGE( "Error in printTime() function,osl_getLocalTimeFromSystemTime ",sal_True == osl_getLocalTimeFromSystemTime( tv, pLocalTV ) );
242 CPPUNIT_ASSERT_MESSAGE( "Error in printTime() function,osl_gepDateTimeFromTimeValue ",sal_True == osl_getDateTimeFromTimeValue( pLocalTV, pDateTime ) );
247 {
255 }
256 t_print( " %d:%d:%d %d nsecs\n", pDateTime->Hours, pDateTime->Minutes, pDateTime->Seconds, pDateTime->NanoSeconds);
260 }
262 /** compare two TimeValue, unit is "ms", since Windows time precision is better than UNX.
263 */
267 #else
269 #endif
272 {
273 // std::abs() seems to have some ambiguity problems (so-texas)
274 // return abs(_nValue);
276 // CPPUNIT_ASSERT(_nValue < 2147483647);
279 {
281 }
283 }
285 inline sal_Bool t_compareTime( TimeValue *m_aEndTime, TimeValue *m_aStartTime, sal_Int32 nDelta)
286 {
287 // sal_uInt64 uTimeValue;
288 // sal_Int64 iTimeValue;
289 //
290 // iTimeValue = t_abs64(( tv1->Seconds - tv2->Seconds) * 1000000000 + tv1->Nanosec - tv2->Nanosec);
291 // uTimeValue = ( iTimeValue / 1000000 );
296 {
298 nDeltaSeconds--;
299 }
303 }
305 /** compare two OUString file name.
306 */
308 {
309 sal_Bool bOk;
310 //on Windows, the seperatar is '\', so here change to '/', then compare
311 #if defined (WNT )
317 else
321 else
324 #else
326 #endif
328 }
330 /** compare a OUString and an ASCII file name.
331 */
333 {
339 }
341 /** simple version to judge if a file name or directory name is a URL or a system path, just to see if it
342 is start with "file:///";.
343 */
345 {
347 }
349 /** simple version to judge if a file name or directory name is a URL or a system path, just to see if it
350 is start with "file:///";.
351 */
353 {
355 }
357 /** concat two part to form a URL or system path, add PATH_SEPERATOR between them if necessary, add "file:///" to begining if necessary.
358 */
360 {
361 //check if pathname1 is full qualified URL;
363 {
365 ::osl::FileBase::getFileURLFromSystemPath( pathname1, aPathName ); //convert if not full qualified URL
367 }
370 //check if '/' is in the end of pathname1 or at the begin of pathname2;
375 }
377 /** create a temp test file using OUString name of full qualified URL or system path.
378 */
380 {
385 ::osl::FileBase::getFileURLFromSystemPath( filename, aPathURL ); //convert if not full qualified URL
387 //::std::auto_ptr<File> pFile( new File( aPathURL ) );
389 //nError = pFile->open( OpenFlag_Read | OpenFlag_Write | OpenFlag_Create );
391 //CPPUNIT_ASSERT_MESSAGE( "In createTestFile Function: creation ", ( ::osl::FileBase::E_None == nError ) || ( nError == ::osl::FileBase::E_EXIST ) );
393 {
395 }
398 }
400 /** create a temp test file using OUString name of full qualified URL or system path in a base directory.
401 */
403 {
408 }
410 /** detete a temp test file using OUString name.
411 */
413 {
414 // LLA: t_print("deleteTestFile\n");
419 ::osl::FileBase::getFileURLFromSystemPath( filename, aPathURL ); //convert if not full qualified URL
421 nError = ::osl::File::setAttributes( aPathURL, Attribute_GrpWrite| Attribute_OwnWrite| Attribute_OthWrite ); // if readonly, make writtenable.
422 CPPUNIT_ASSERT_MESSAGE( "In deleteTestFile Function: set writtenable ", ( ::osl::FileBase::E_None == nError ) || ( ::osl::FileBase::E_NOENT == nError ) );
425 CPPUNIT_ASSERT_MESSAGE( "In deleteTestFile Function: remove ", ( ::osl::FileBase::E_None == nError ) || ( nError == ::osl::FileBase::E_NOENT ) );
426 }
428 /** delete a temp test file using OUString name of full qualified URL or system path in a base directory.
429 */
431 {
436 }
438 /** create a temp test directory using OUString name of full qualified URL or system path.
439 */
441 {
446 ::osl::FileBase::getFileURLFromSystemPath( dirname, aPathURL ); //convert if not full qualified URL
448 //CPPUNIT_ASSERT_MESSAGE( "In createTestDirectory Function: creation: ", ( ::osl::FileBase::E_None == nError ) || ( nError == ::osl::FileBase::E_EXIST ) );
451 }
453 /** create a temp test directory using OUString name of full qualified URL or system path in a base directory.
454 */
455 inline void createTestDirectory( const ::rtl::OUString basename, const ::rtl::OUString dirname )
456 {
462 }
464 /** delete a temp test directory using OUString name of full qualified URL or system path.
465 */
467 {
468 // LLA: t_print("deleteTestDirectory\n");
471 // LLA: printFileName(aPathURL);
473 ::osl::FileBase::getFileURLFromSystemPath( dirname, aPathURL ); //convert if not full qualified URL
477 {
478 // LLA: t_print("#close Dir\n");
480 }
483 // LLA: printError(nError);
484 // LLA: if (( ::osl::FileBase::E_None == nError ))
485 // LLA: {
486 // LLA: t_print("nError == E_None\n");
487 // LLA: }
488 // LLA: else if ( ( nError == ::osl::FileBase::E_NOENT ))
489 // LLA: {
490 // LLA: t_print("nError == E_NOENT\n");
491 // LLA: }
492 // LLA: else
493 // LLA: {
494 // LLA: // t_print("nError == %d\n", nError);
495 // LLA: }
496 rtl::OUString strError = rtl::OUString::createFromAscii( "In deleteTestDirectory function: remove Directory ");
498 CPPUNIT_ASSERT_MESSAGE( strError, ( ::osl::FileBase::E_None == nError ) || ( nError == ::osl::FileBase::E_NOENT ) );
499 // LLA: if (! ( ::osl::FileBase::E_None == nError ) || ( nError == ::osl::FileBase::E_NOENT ))
500 // LLA: {
501 // LLA: t_print("In deleteTestDirectory function: remove\n");
502 // LLA: }
503 }
505 /** delete a temp test directory using OUString name of full qualified URL or system path in a base directory.
506 */
507 inline void deleteTestDirectory( const ::rtl::OUString basename, const ::rtl::OUString dirname )
508 {
513 }
516 /** Check for the file and directory access right.
517 */
519 osl_Check_Mode_Exist,
520 osl_Check_Mode_OpenAccess,
521 osl_Check_Mode_ReadAccess,
522 osl_Check_Mode_WriteAccess
525 // not used here
527 {
530 sal_Bool bCheckResult;
538 /// check if the file is exist.
543 /// check if the file is openable.
548 /// check the file name and whether it can be write.
549 /// write chars into the file.
550 //testFile.close( );
551 //testFile.open( OpenFlag_Write );
552 sal_uInt64 nCount_write;
565 }
568 }
570 //check if the file exist
572 {
575 /*#ifdef WNT
576 ::rtl::OUString aUStr = str.copy( 0 );
577 if ( isURL( str ) )
578 ::osl::FileBase::getSystemPathFromFileURL( str, aUStr );
580 ::rtl::OString aString = ::rtl::OUStringToOString( aUStr, RTL_TEXTENCODING_ASCII_US );
581 const char *path = aString.getStr( );
582 if (( _access( path, 0 ) ) != -1 )
583 bCheckResult = sal_True;
584 #else*/
586 // const char *path = aString.getStr( );
589 //if (bCheckResult)
590 //t_print("%s exist!\n", path);
591 //else
592 //t_print("%s not exist!\n", path);
593 //#endif
596 }
598 //check if the file can be writen
600 {
602 //on Windows, the file has no write right, but can be written
603 #ifdef WNT
612 //on UNX, just test if open success with OpenFlag_Write
613 #else
616 #endif
618 }
621 {
623 DirectoryItem rItem;
627 //::std::auto_ptr<Directory> pDir( new Directory( str ) );
643 //rc = pDir->getNextItem( rItem, 0 );
647 else
652 //if ( ( rc = pDir->create( aUString ) ) == ::osl::FileBase::E_None )
654 {
656 //rc = pDir->remove( aUString );
659 }
660 else
674 }
676 /** construct error message
677 */
678 inline ::rtl::OUString outputError( const ::rtl::OUString & returnVal, const ::rtl::OUString & rightVal, const sal_Char * msg = "")
679 {
690 }
692 /** Change file mode, two version in UNIX and Windows;.
693 */
696 {
704 }
707 {
711 }
712 #endif
718 //------------------------------------------------------------------------
719 // Beginning of the test cases for FileBase class
720 //------------------------------------------------------------------------
721 namespace osl_FileBase
722 {
725 //---------------------------------------------------------------------
726 // testing the method
727 // static inline RC getCanonicalName( const ::rtl::OUString& ustrRequestedURL, ::rtl::OUString& ustrValidURL )
728 //
729 // The illegal characters are ;+=[]',\"*\\<>/?:|.
730 // because getCanonicalName method is not implemented yet and will be deprecated in the future, this test is not necessary.
731 //---------------------------------------------------------------------
734 {
740 {
746 }
749 {
756 CPPUNIT_ASSERT_MESSAGE( " test for getCanonicalName function: an existed file name, should different from the request, it did not passed(W32)(UNX)",
758 }
761 {
765 CPPUNIT_ASSERT_MESSAGE( " test for getCanonicalName function: invalid file name, should different from the request, it did not passed(W32)(UNX)",
767 }
775 #endif
777 //---------------------------------------------------------------------
778 // testing the method
779 // static inline RC getAbsoluteFileURL( const ::rtl::OUString& ustrBaseDirectoryURL,
780 // const ::rtl::OUString& ustrRelativeFileURL,
781 // ::rtl::OUString& ustrAbsoluteFileURL )
782 //---------------------------------------------------------------------
785 {
786 //::osl::FileBase aFileBase;
788 // ::osl::FileBase::RC nError;
789 sal_Bool bOk;
793 void check_getAbsoluteFileURL( rtl::OUString const& _suBaseURL, rtl::OString const& _sRelativeURL, ::osl::FileBase::RC _nAssumeError, rtl::OUString const& _suAssumeResultStr );
823 /* use coding format as same as getSystemPathFromFileURL
824 // initialization
825 void setUp( )
826 {
827 sal_Char pResultURL1[] = "/relative/file1";
828 sal_Char pResultURL2[] = "/relative/file2";
829 sal_Char pResultURL3[] = "/file3";
830 sal_Char pResultURL4[] = "/file4";
831 sal_Char pResultURL5[] = "/canonical.name";
832 sal_Char pResultURL6[] = "/relative/";
833 aResultURL1 = aUserDirectoryURL.concat( rtl::OUString::createFromAscii( pResultURL1 ) );
834 aResultURL2 = aUserDirectoryURL.concat( rtl::OUString::createFromAscii( pResultURL2 ) );
835 aResultURL3 = aUserDirectoryURL.concat( rtl::OUString::createFromAscii( pResultURL3 ) );
836 aResultURL4 = aUserDirectoryURL.concat( rtl::OUString::createFromAscii( pResultURL4 ) );
837 aResultURL5 = aUserDirectoryURL.concat( rtl::OUString::createFromAscii( pResultURL5 ) );
838 aResultURL6 = aUserDirectoryURL.concat( rtl::OUString::createFromAscii( pResultURL6 ) );
839 }
841 void tearDown( )
842 {
843 }
845 // test code
846 void getAbsoluteFileURL_001( )
847 {
848 ::rtl::OUString aUStr_AbsURL;
850 ::osl::FileBase::RC nError11 = aFileBase.getAbsoluteFileURL( aUserDirectoryURL, aRelURL1, aUStr_AbsURL );
851 ::rtl::OUString suError = ::rtl::OUString::createFromAscii("test for getAbsoluteFileURL(' ");
852 suError += aUserDirectoryURL;
853 suError += ::rtl::OUString::createFromAscii("', '");
854 suError += aRelURL1;
855 suError += ::rtl::OUString::createFromAscii("', '");
856 suError += aUStr_AbsURL;
857 suError += outputError( aUStr_AbsURL, aResultURL1, "' ),");
859 sal_Bool nError12 = aUStr_AbsURL.equals( aResultURL1 );
860 ::osl::FileBase::RC nError21 = aFileBase.getAbsoluteFileURL( aUserDirectoryURL, aRelURL2, aUStr_AbsURL );
861 sal_Bool nError22 = aUStr_AbsURL.equals( aResultURL2 );
862 ::osl::FileBase::RC nError31 = aFileBase.getAbsoluteFileURL( aUserDirectoryURL, aRelURL3, aUStr_AbsURL );
863 sal_Bool nError32 = aUStr_AbsURL.equals( aResultURL3 );
864 ::osl::FileBase::RC nError41 = aFileBase.getAbsoluteFileURL( aUserDirectoryURL, aRelURL4, aUStr_AbsURL );
865 sal_Bool nError42 = aUStr_AbsURL.equals( aResultURL4 );
866 ::osl::FileBase::RC nError61 = aFileBase.getAbsoluteFileURL( aUserDirectoryURL, aRelURL6, aUStr_AbsURL );
867 sal_Bool nError62 = aUStr_AbsURL.equals( aResultURL6 );
868 printFileName( aUStr_AbsURL );
869 printFileName( aResultURL6 );
871 CPPUNIT_ASSERT_MESSAGE("test for getAbsoluteFileURL function: valid file name with valid directory",
872 ( ::osl::FileBase::E_None == nError11 ) && ( sal_True == nError12 ) &&
873 ( ::osl::FileBase::E_None == nError21 ) && ( sal_True == nError22 ) &&
874 ( ::osl::FileBase::E_None == nError31 ) && ( sal_True == nError32 ) &&
875 ( ::osl::FileBase::E_None == nError41 ) && ( sal_True == nError42 ) &&
876 ( ::osl::FileBase::E_None == nError61 ) && ( sal_True == nError62 ) );
877 }
880 #if ( defined UNX ) || ( defined OS2 ) //Link is not defined in Windows
881 void getAbsoluteFileURL_002( )
882 {
883 ::rtl::OUString aUStr_AbsURL, aUStr_LnkFileSys( aTempDirectorySys ), aUStr_SrcFileSys( aTempDirectorySys );
884 ( ( aUStr_LnkFileSys += aSlashURL ) += getCurrentPID( ) ) += ::rtl::OUString::createFromAscii("/link.file");
885 ( ( aUStr_SrcFileSys += aSlashURL ) += getCurrentPID( ) ) += ::rtl::OUString::createFromAscii("/canonical.name");
887 rtl::OString strLinkFileName, strSrcFileName;
888 strLinkFileName = OUStringToOString( aUStr_LnkFileSys, RTL_TEXTENCODING_ASCII_US );
889 strSrcFileName = OUStringToOString( aUStr_SrcFileSys, RTL_TEXTENCODING_ASCII_US );
891 createTestFile( aCanURL1 );
892 sal_Int32 fd = symlink( strSrcFileName.getStr(), strLinkFileName.getStr() );
893 CPPUNIT_ASSERT( fd == 0 );
895 nError = aFileBase.getAbsoluteFileURL( aUserDirectoryURL, aLnkURL1, aUStr_AbsURL );
896 bOk = aUStr_AbsURL.equals( aResultURL5 );
898 ::rtl::OUString suError = ::rtl::OUString::createFromAscii("test for getAbsoluteFileURL(' ");
899 suError += aUserDirectoryURL;
900 suError += ::rtl::OUString::createFromAscii("', '");
901 suError += aLnkURL1;
902 suError += ::rtl::OUString::createFromAscii("', '");
903 suError += aUStr_AbsURL;
904 suError += outputError( aUStr_AbsURL, aResultURL5, "' ),");
905 //printFileName(suError);
907 deleteTestFile( aCanURL1 );
908 fd = remove( strLinkFileName.getStr() );
909 CPPUNIT_ASSERT( fd == 0 );
911 CPPUNIT_ASSERT_MESSAGE("test for getAbsoluteFileURL function: URL contain link( Solaris version )",
912 ( ::osl::FileBase::E_None == nError ) && ( sal_True == bOk ) );
913 }
914 #else //Windows version
915 void getAbsoluteFileURL_002( )
916 {
917 CPPUNIT_ASSERT_MESSAGE("test for getAbsoluteFileURL function: URL contain link( Windows version )",
918 1 );
919 }
920 #endif
922 void getAbsoluteFileURL_003( )
923 {
924 // LLA: may be a wrong test, aTmpName1 not a real URL
925 #if 0
926 ::rtl::OUString aUStr_AbsURL;
928 nError = aFileBase.getAbsoluteFileURL( aTmpName1, aRelURL1, aUStr_AbsURL ); //base dir invalid error
929 ::rtl::OUString suError = ::rtl::OUString::createFromAscii("test for getAbsoluteFileURL('");
930 suError += aTmpName1;
931 suError += ::rtl::OUString::createFromAscii("', '");
932 suError += aRelURL1;
933 suError += ::rtl::OUString::createFromAscii("', '");
934 suError += aUStr_AbsURL;
935 suError += ::rtl::OUString::createFromAscii("' ),Parameter is invalid. it ignore the invalid base in Windows, did not pass in (W32), the reason maybe caused by the similar bug with getSystemPathFromFileURL() ");
937 CPPUNIT_ASSERT_MESSAGE( suError, ( ::osl::FileBase::E_INVAL == nError ) );
938 #endif
939 }
941 //use ".." in relartive path, the BasePath must exist on the file system
942 void getAbsoluteFileURL_004( )
943 {
944 //create two level directories under $Temp/PID/
945 ::rtl::OUString aUStrUpBase = aUserDirectoryURL + ::rtl::OUString::createFromAscii("/test1");
946 createTestDirectory( aUStrUpBase );
947 ::rtl::OUString aUStrBase = aUserDirectoryURL + ::rtl::OUString::createFromAscii("/test1/dir1");
948 createTestDirectory( aUStrBase );
950 ::rtl::OUString aUStrRelar = ::rtl::OUString::createFromAscii("../../mytestfile");
951 ::rtl::OUString aUStr_AbsURL;
952 ::rtl::OUString aResultURL6 = aUserDirectoryURL + ::rtl::OUString::createFromAscii("/mytestfile");
954 nError = aFileBase.getAbsoluteFileURL( aUStrBase, aUStrRelar, aUStr_AbsURL );
955 bOk = aUStr_AbsURL.equals( aResultURL6 );
956 ::rtl::OUString suError = ::rtl::OUString::createFromAscii("test for getAbsoluteFileURL('");
957 suError += aUStrBase;
958 suError += ::rtl::OUString::createFromAscii("', '");
959 suError += aUStrRelar;
960 suError += ::rtl::OUString::createFromAscii("', '");
961 suError += aUStr_AbsURL;
962 suError += outputError( aUStr_AbsURL, aResultURL6, "' ), did not pass on Win32 ");
964 deleteTestDirectory( aUStrBase );
965 deleteTestDirectory( aUStrUpBase );
967 CPPUNIT_ASSERT_MESSAGE( suError, ( ::osl::FileBase::E_None == nError ) && ( sal_True == bOk ) );
968 }
970 CPPUNIT_TEST_SUITE( getAbsoluteFileURL );
971 CPPUNIT_TEST( getAbsoluteFileURL_001 );
972 CPPUNIT_TEST( getAbsoluteFileURL_002 );
973 CPPUNIT_TEST( getAbsoluteFileURL_003 );
974 CPPUNIT_TEST( getAbsoluteFileURL_004 );
975 CPPUNIT_TEST_SUITE_END( );
976 };// class getAbsoluteFileURL*/
978 void getAbsoluteFileURL::check_getAbsoluteFileURL( rtl::OUString const& _suBaseURL, rtl::OString const& _sRelativeURL, ::osl::FileBase::RC _nAssumeError, rtl::OUString const& _suAssumeResultStr )
979 {
983 osl::FileBase::RC nError = FileBase::getAbsoluteFileURL( _suBaseURL, suRelativeURL, suResultURL );
986 t_print("getAbsoluteFileURL('%s','%s') deliver absolute URL: '%s', error '%s'\n", sBaseURL.getStr(), _sRelativeURL.getStr(),sResultURL.getStr(), sError.getStr() );
987 CPPUNIT_ASSERT_MESSAGE( "Assumption is wrong: error number is wrong", nError == _nAssumeError );
989 {
991 CPPUNIT_ASSERT_MESSAGE( "Assumption is wrong: ResultURL is not equal to expected URL ", bStrAreEqual == sal_True );
992 }
993 }
996 {
997 rtl::OUString suAssume = aUserDirectoryURL.concat( rtl::OUString::createFromAscii("/relative/file1") );
998 check_getAbsoluteFileURL( aUserDirectoryURL, "relative/file1",::osl::FileBase::E_None, suAssume );
999 }
1001 {
1002 rtl::OUString suAssume = aUserDirectoryURL.concat( rtl::OUString::createFromAscii("/relative/file2") );
1003 check_getAbsoluteFileURL( aUserDirectoryURL, "relative/./file2",::osl::FileBase::E_None, suAssume );
1004 }
1006 {
1008 check_getAbsoluteFileURL( aUserDirectoryURL, "relative/../file3",::osl::FileBase::E_None, suAssume );
1009 }
1011 {
1013 check_getAbsoluteFileURL( aUserDirectoryURL, "././relative/../file4",::osl::FileBase::E_None, suAssume );
1014 }
1016 {
1018 #if ( defined UNX )
1020 #else
1022 #endif
1023 check_getAbsoluteFileURL( aUserDirectoryURL, "././relative/.",::osl::FileBase::E_None, suAssume );
1024 }
1026 {
1027 rtl::OUString suAssume = aUserDirectoryURL.concat( rtl::OUString::createFromAscii("/.relative") );
1028 check_getAbsoluteFileURL( aUserDirectoryURL, "./.relative",::osl::FileBase::E_None, suAssume );
1029 }
1031 {
1033 #if (defined UNX )
1037 #endif
1038 check_getAbsoluteFileURL( aUserDirectoryURL, "./.a/mydir/..",::osl::FileBase::E_None, suAssume );
1039 }
1041 {
1042 rtl::OUString suAssume = aUserDirectoryURL.concat( rtl::OUString::createFromAscii("/tmp/ok") );
1043 #if ( defined UNX ) || ( defined OS2 )
1045 #else
1047 #endif
1048 }
1050 {
1052 ::rtl::OUString aUStr_AbsURL, aUStr_LnkFileSys( aTempDirectorySys ), aUStr_SrcFileSys( aTempDirectorySys );
1053 ( ( aUStr_LnkFileSys += aSlashURL ) += getCurrentPID( ) ) += ::rtl::OUString::createFromAscii("/link.file");
1054 ( ( aUStr_SrcFileSys += aSlashURL ) += getCurrentPID( ) ) += ::rtl::OUString::createFromAscii("/canonical.name");
1064 rtl::OUString suAssume = aUserDirectoryURL.concat( rtl::OUString::createFromAscii("/canonical.name") );
1069 #endif
1070 }
1071 //please see line# 930
1073 {
1074 }
1076 {
1077 //create two level directories under $Temp/PID/
1080 ::rtl::OUString aUStrBase = aUserDirectoryURL + ::rtl::OUString::createFromAscii("/test1/dir1");
1083 ::rtl::OUString suAssume = aUserDirectoryURL.concat( ::rtl::OUString::createFromAscii("/mytestfile") );
1087 }
1088 //---------------------------------------------------------------------
1089 // testing two methods:
1090 // static inline RC getSystemPathFromFileURL( const ::rtl::OUString& ustrFileURL,
1091 // ::rtl::OUString& ustrSystemPath )
1092 // static RC getFileURLFromSystemPath( const ::rtl::OUString & ustrSystemPath,
1093 // ::rtl::OUString & ustrFileURL );
1094 //---------------------------------------------------------------------
1096 {
1097 //::osl::FileBase aFileBase;
1098 // ::rtl::OUString aUStr;
1099 // ::osl::FileBase::RC nError;
1101 //void check_getSystemPathFromFileURL(rtl::OString const& _sURL, ::osl::FileBase::RC _nAssumeError, rtl::OString const& _sAssumeResultStr);
1102 void check_SystemPath_FileURL(rtl::OString const& _sSource, ::osl::FileBase::RC _nAssumeError, rtl::OString const& _sAssumeResultStr, sal_Bool bDirection = sal_True );
1103 void checkWNTBehaviour_getSystemPathFromFileURL(rtl::OString const& _sURL, ::osl::FileBase::RC _nAssumeError, rtl::OString const& _sWNTAssumeResultString );
1104 void checkUNXBehaviour_getSystemPathFromFileURL(rtl::OString const& _sURL, ::osl::FileBase::RC _nAssumeError, rtl::OString const& _sUnixAssumeResultString );
1105 void checkWNTBehaviour_getFileURLFromSystemPath(rtl::OString const& _sSysPath, ::osl::FileBase::RC _nAssumeError, rtl::OString const& _sWNTAssumeResultString);
1106 void checkUNXBehaviour_getFileURLFromSystemPath(rtl::OString const& _sSysPath, ::osl::FileBase::RC _nAssumeError, rtl::OString const& _sUnixAssumeResultString);
1109 // test code.
1134 //test case fot getFileURLFromSystemPath
1174 // test code.
1176 /* void getSystemPathFromFileURL::check_getSystemPathFromFileURL(rtl::OString const& _sURL, ::osl::FileBase::RC _nAssumeError, rtl::OString const& _sAssumeResultStr)
1177 {
1178 // PRE: URL as String
1179 rtl::OUString suURL;
1180 rtl::OUString suStr;
1181 suURL = rtl::OStringToOUString(_sURL, RTL_TEXTENCODING_UTF8);
1182 ::osl::FileBase::RC nError = osl::FileBase::getSystemPathFromFileURL( suURL, suStr ); // start with /
1184 // if the given string is gt length 0,
1185 // we check also this string
1186 rtl::OString sStr = rtl::OUStringToOString(suStr, RTL_TEXTENCODING_UTF8);
1187 rtl::OString sError = errorToString(nError);
1188 t_print("getSystemPathFromFileURL('%s') deliver system path: '%s', error '%s'\n", _sURL.getStr(), sStr.getStr(), sError.getStr() );
1190 // rtl::OUString suStrEncode = rtl::Uri::encode(suStr, rtl_UriCharClassUnoParamValue, rtl_UriEncodeKeepEscapes, RTL_TEXTENCODING_UTF8);
1191 // sStr = rtl::OUStringToOString(suStr, RTL_TEXTENCODING_UTF8);
1192 // t_print("UTF8: %s\n", sStr.getStr() );
1194 if (_sAssumeResultStr.getLength() > 0)
1195 {
1196 sal_Bool bStrAreEqual = _sAssumeResultStr.equals(sStr);
1197 CPPUNIT_ASSERT_MESSAGE( "Assumption is wrong",
1198 nError == _nAssumeError && bStrAreEqual == sal_True );
1199 }
1200 else
1201 {
1202 CPPUNIT_ASSERT_MESSAGE( "Assumption is wrong", nError == _nAssumeError );
1203 }
1204 }*/
1206 // if bDirection==sal_True, check getSystemPathFromFileURL
1207 // if bDirection==sal_False, check getFileURLFromSystemPath
1208 void SystemPath_FileURL::check_SystemPath_FileURL(rtl::OString const& _sSource, ::osl::FileBase::RC _nAssumeError, rtl::OString const& _sAssumeResultStr, sal_Bool bDirection)
1209 {
1210 // PRE: URL as String
1217 else
1220 // if the given string is gt length 0,
1221 // we check also this string
1225 t_print("getSystemPathFromFileURL('%s') deliver system path: '%s', error '%s'\n", _sSource.getStr(), sStr.getStr(), sError.getStr() );
1226 else
1227 t_print("getFileURLFromSystemPath('%s') deliver File URL: '%s', error '%s'\n", _sSource.getStr(), sStr.getStr(), sError.getStr() );
1229 // rtl::OUString suStrEncode = rtl::Uri::encode(suStr, rtl_UriCharClassUnoParamValue, rtl_UriEncodeKeepEscapes, RTL_TEXTENCODING_UTF8);
1230 // sStr = rtl::OUStringToOString(suStr, RTL_TEXTENCODING_UTF8);
1231 // t_print("UTF8: %s\n", sStr.getStr() );
1234 {
1238 }
1239 else
1240 {
1242 }
1243 }
1244 void SystemPath_FileURL::checkWNTBehaviour_getSystemPathFromFileURL(rtl::OString const& _sURL, ::osl::FileBase::RC _nAssumeError, rtl::OString const& _sWNTAssumeResultString)
1245 {
1246 #if ( defined WNT )
1248 #else
1252 #endif
1253 }
1255 void SystemPath_FileURL::checkUNXBehaviour_getSystemPathFromFileURL(rtl::OString const& _sURL, ::osl::FileBase::RC _nAssumeError, rtl::OString const& _sUnixAssumeResultString)
1256 {
1257 #if ( defined UNX )
1259 #else
1263 #endif
1264 }
1266 void SystemPath_FileURL::checkWNTBehaviour_getFileURLFromSystemPath(rtl::OString const& _sSysPath, ::osl::FileBase::RC _nAssumeError, rtl::OString const& _sWNTAssumeResultString)
1267 {
1268 #if ( defined WNT )
1270 #else
1274 #endif
1275 }
1277 void SystemPath_FileURL::checkUNXBehaviour_getFileURLFromSystemPath(rtl::OString const& _sSysPath, ::osl::FileBase::RC _nAssumeError, rtl::OString const& _sUnixAssumeResultString)
1278 {
1279 #if ( defined UNX )
1281 #else
1285 #endif
1286 }
1288 /** LLA: Test for getSystemPathFromFileURL()
1289 this test is splitted into 2 different OS tests,
1290 the first function checkUNXBehaviour... runs only on Unix based Systems,
1291 the second only on windows based systems
1292 the first parameter are a file URL where we want to get the system path of,
1293 the second parameter is the assumed error of the osl_getSystemPathFromFileURL() function,
1294 the thrid parameter is the assumed result string, the string will only test, if it's length is greater 0
1295 */
1298 {
1302 }
1305 {
1309 }
1311 {
1312 // rtl::OString sURL("%2f");
1314 checkUNXBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, "/"); // LLA: this is may be a BUG
1316 }
1318 {
1322 }
1324 {
1328 }
1330 {
1334 }
1336 {
1340 }
1342 {
1346 }
1348 {
1352 }
1354 {
1356 checkUNXBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, "c:/tmp"); // LLA: this is may be a BUG
1358 }
1360 {
1364 }
1366 {
1367 // LLA: is this a legal file path?
1371 }
1373 {
1377 }
1379 {
1383 }
1385 {
1387 checkUNXBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, "/tmp/../second"); // LLA: may be a BUG
1389 }
1391 {
1394 checkWNTBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, "c:\\tmp\\..\\second");
1395 }
1397 {
1401 }
1403 {
1410 // checkWNTBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, "\\tmp");
1411 }
1413 {
1417 }
1419 {
1421 checkUNXBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, "/c:/tmp/first second");
1422 checkWNTBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, "c:\\tmp\\first second");
1423 }
1426 {
1430 }
1432 #if 0
1434 {
1435 // LLA: ???
1436 //!! seams to be, that the directories do not pass together
1444 ::rtl::OUString suError = ::rtl::OUString::createFromAscii("test for getSystemPathFromFileURL(");
1446 suError += ::rtl::OUString::createFromAscii(") function:use a relative file URL, did not pass in(W32), it did not specified in method declaration of relative path issue, ");
1449 }
1450 #endif
1452 //normal legal case
1454 {
1462 ::rtl::OUString suError = ::rtl::OUString::createFromAscii("test for getSystemPathFromFileURL(' ");
1469 }
1471 //CJK charactors case
1473 {
1483 ::rtl::OUString suError = ::rtl::OUString::createFromAscii("test for getSystemPathFromFileURL(' ");
1490 }
1492 {
1500 }
1502 {
1506 }
1508 {
1512 }
1514 {
1516 checkUNXBehaviour_getFileURLFromSystemPath(sSysPath, osl::FileBase::E_None, "file:///tmp/first%20start");
1518 }
1520 {
1524 }
1525 // start with "~user", not impletment
1526 // void SystemPath_FileURL::getFileURLFromSystemPath_006()
1531 //---------------------------------------------------------------------
1532 // testing the method
1533 // static inline RC searchFileURL( const ::rtl::OUString& ustrFileName,
1534 // const ::rtl::OUString& ustrSearchPath,
1535 // ::rtl::OUString& ustrFileURL )
1536 //---------------------------------------------------------------------
1538 {
1539 //::osl::FileBase aFileBase;
1545 // test code.
1547 {
1548 /* search file is passed by system filename */
1550 /* search file is passed by full qualified file URL */
1552 /* search file is passed by relative file path */
1555 CPPUNIT_ASSERT_MESSAGE( "test for searchFileURL function: system filename/URL filename/relative path, system directory, searched files that is not exist, but it reply invalid error, did not pass in (W32) ",
1559 }
1562 {
1563 /* search file is passed by system filename */
1566 /* search file is passed by full qualified file URL */
1569 /* search file is passed by relative file path */
1572 /* search file is passed by an exist file */
1578 CPPUNIT_ASSERT_MESSAGE( "test for searchFileURL function: system filename/URL filename/relative path, system directory, searched file already exist.",
1587 }
1591 {
1592 OSLTEST_DECLARE( SystemPathList, TEST_PLATFORM_ROOT":"TEST_PLATFORM_ROOT TEST_PLATFORM_TEMP":"TEST_PLATFORM_ROOT"system/path" );
1595 CPPUNIT_ASSERT_MESSAGE( "test for searchFileURL function: search directory is a list of system paths",
1598 }
1601 {
1602 OSLTEST_DECLARE( SystemPathList, TEST_PLATFORM_ROOT PATH_LIST_DELIMITER TEST_PLATFORM_ROOT TEST_PLATFORM_TEMP PATH_LIST_DELIMITER TEST_PLATFORM_ROOT "system/path/../name" );
1605 CPPUNIT_ASSERT_MESSAGE( "test for searchFileURL function: search directory is a list of system paths",
1608 }
1611 {
1617 }
1629 //---------------------------------------------------------------------
1630 // testing the method
1631 // static inline RC getTempDirURL( ::rtl::OUString& ustrTempDirURL )
1632 //---------------------------------------------------------------------
1634 {
1635 //::osl::FileBase aFileBase;
1640 // initialization
1642 {
1644 }
1647 {
1648 }
1650 // test code.
1652 {
1656 }
1659 {
1660 CPPUNIT_ASSERT_MESSAGE( "test for getTempDirURL function: test for open and write access rights",
1664 }
1673 //---------------------------------------------------------------------
1674 // testing the method
1675 // static inline RC createTempFile( ::rtl::OUString* pustrDirectoryURL,
1676 // oslFileHandle* pHandle,
1677 // ::rtl::OUString* pustrTempFileURL)
1678 //---------------------------------------------------------------------
1680 {
1681 //::osl::FileBase aFileBase;
1683 sal_Bool bOK;
1691 // initialization
1693 {
1697 //*pUStr_DirURL = aUserDirectoryURL; /// create temp file in /tmp/PID or c:\temp\PID.*/
1698 }
1701 {
1705 }
1707 // test code.
1709 {
1712 //printFileName(*pUStr_FileURL);
1717 }
1719 CPPUNIT_ASSERT_MESSAGE( "test for createTempFile function: create temp file and test the existence",
1720 ( osl::FileBase::E_None == nError1 ) && ( pHandle != NULL ) && ( osl::FileBase::E_EXIST== nError2 ) );
1721 }
1724 {
1734 //check file if have the write permission
1739 }
1741 CPPUNIT_ASSERT_MESSAGE( "test for open and write access rights, in (W32), it did not have write access right, but it should be writtenable.",
1743 }
1746 {
1748 //the temp file will be removed when return from createTempFile
1753 CPPUNIT_ASSERT_MESSAGE( "test for createTempFile function: set pUStrFileURL to 0 to let it remove the file after call.",
1755 }
1757 {
1764 ( osl::FileBase::E_None == nError1 ) && ( osl::FileBase::E_EXIST == nError2 ) &&( sal_True == bOK ) );
1766 }
1776 // -----------------------------------------------------------------------------
1779 #endif
1782 // CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( osl_FileBase::getFileURLFromSystemPath, "osl_FileBase" );
1789 //------------------------------------------------------------------------
1790 // Beginning of the test cases for VolumeDevice class
1791 //------------------------------------------------------------------------
1794 namespace osl_VolumeDevice
1795 {
1797 //---------------------------------------------------------------------
1798 // testing the method
1799 // VolumeDevice() : _aHandle( NULL )
1800 //---------------------------------------------------------------------
1802 {
1808 // initialization
1810 {
1811 }
1814 {
1815 }
1817 // test code.
1819 {
1826 }
1829 {
1836 CPPUNIT_ASSERT_MESSAGE( "test for ctors function: Copy constructor for VolumeDevice, the copied VolumeDevice should have a mount path file:///, but it returned an empty OUString, it also may be the error from getDeviceHandle(), it did not pass in (UNX), (W32).",
1838 }
1841 {
1848 CPPUNIT_ASSERT_MESSAGE( "test for ctors function: Assigned operator for VolumeDevice, the assigned VolumeDevice should have a mount path file:///, but it returned an empty OUString, it also may be the error from getDeviceHandle(),it did not pass in (UNX), (W32).",
1850 }
1860 //---------------------------------------------------------------------
1861 // testing the method
1862 // inline RC automount()
1863 //---------------------------------------------------------------------
1865 {
1871 // initialization
1873 {
1874 }
1877 {
1879 }
1881 // test code.
1883 {
1889 }
1892 {
1900 CPPUNIT_ASSERT_MESSAGE( "test for automount function: this test is not implemented yet, it did not pass in (UNX), (W32).",
1902 }
1911 // -----------------------------------------------------------------------------
1915 #endif
1918 //------------------------------------------------------------------------
1919 // Beginning of the test cases for VolumeInfo class
1920 //------------------------------------------------------------------------
1921 namespace osl_VolumeInfo
1922 {
1924 //---------------------------------------------------------------------
1925 // testing the method
1926 // VolumeInfo( sal_uInt32 nMask ): _nMask( nMask )
1927 //---------------------------------------------------------------------
1929 {
1936 // initialization
1938 {
1939 }
1942 {
1943 }
1945 // test code.
1947 {
1959 }
1961 #if ( defined UNX ) || ( defined OS2 )
1963 {
1965 VolumeInfoMask_UsedSpace |
1966 VolumeInfoMask_FileSystemName );
1969 //CPPUNIT_ASSERT( aVolumeInfo.isValid( mask ) );
1974 CPPUNIT_ASSERT_MESSAGE( "test for ctors function: mask is specified as certain valid fields, and get the masked fields",
1978 }
1979 #else /// Windows version,here we can not determine whichvolume in Windows is serve as an nfs volume.
1981 {
1982 CPPUNIT_ASSERT_MESSAGE( "test for ctors function: mask is specified as certain valid fields, and get the masked fields( Windows version )",
1984 }
1985 #endif
1988 {
2007 CPPUNIT_ASSERT_MESSAGE( "test for ctors function: mask is specified as certain valid fields, but get unmasked fields, use mask to FreeSpace, but I can get TotalSpace, did not pass in (UNX)(W32)",
2010 }
2020 //---------------------------------------------------------------------
2021 // testing the method
2022 // inline sal_Bool isValid( sal_uInt32 nMask ) const
2023 //---------------------------------------------------------------------
2025 {
2031 // initialization
2033 {
2034 }
2037 {
2039 }
2041 // test code.
2043 {
2051 }
2053 #if ( defined UNX ) || ( defined OS2 )
2055 {
2056 sal_Int32 mask = VolumeInfoMask_Attributes | VolumeInfoMask_TotalSpace | osl_VolumeInfo_Mask_UsedSpace |
2063 CPPUNIT_ASSERT_MESSAGE( "test for isValid function: all valid fields specified for a nfs volume.",
2065 }
2066 #else /// Windows version,here we can not determine whichvolume in Windows is serve as an nfs volume.
2068 {
2069 CPPUNIT_ASSERT_MESSAGE( "test for isValid function: all valid fields specified for a nfs volume.( Windows version )",
2071 }
2072 #endif
2075 {
2087 CPPUNIT_ASSERT_MESSAGE( "test for isValid function: VolumeInfoMask_Attributes, it should be valid for some volume such as /, floppy, cdrom, etc. but it did not pass",
2089 }
2098 //---------------------------------------------------------------------
2099 // testing the method
2100 // inline sal_Bool getRemoteFlag() const
2101 //---------------------------------------------------------------------
2103 {
2109 // test code.
2111 {
2118 CPPUNIT_ASSERT_MESSAGE( "test for getRemoteFlag function: get a volume device which is not remote.",
2120 }
2124 {
2131 CPPUNIT_ASSERT_MESSAGE( "test for getRemoteFlag function: get a volume device which is remote( Solaris version ).",
2133 }
2136 {
2137 CPPUNIT_ASSERT_MESSAGE( "test for getRemoteFlag function: get a volume device which is remote( Windows version )",
2139 }
2140 #endif
2148 //---------------------------------------------------------------------
2149 // testing the method
2150 // inline sal_Bool getRemoveableFlag() const
2151 //---------------------------------------------------------------------
2153 {
2157 // test code.
2159 {
2166 CPPUNIT_ASSERT_MESSAGE( "test for getRemoveableFlag function: get a volume device which is not removable.",
2168 }
2171 {
2178 CPPUNIT_ASSERT_MESSAGE( "test for getRemoveableFlag function: get a volume device which is removable, not sure, here we use floppy disk, but it did not pass.",
2180 }
2188 //---------------------------------------------------------------------
2189 // testing the method
2190 // inline sal_Bool getCompactDiscFlag() const
2191 //---------------------------------------------------------------------
2193 {
2197 // test code.
2199 {
2206 CPPUNIT_ASSERT_MESSAGE( "test for getCompactDiscFlag function: get a volume device which is not a cdrom.",
2208 }
2211 {
2218 CPPUNIT_ASSERT_MESSAGE( "test for getCompactDiscFlag function: get a cdrom volume device flag, it did not pass.",
2220 }
2228 //---------------------------------------------------------------------
2229 // testing the method
2230 // inline sal_Bool getFloppyDiskFlag() const
2231 //---------------------------------------------------------------------
2233 {
2237 // test code.
2239 {
2246 CPPUNIT_ASSERT_MESSAGE( "test for getFloppyDiskFlag function: get a volume device which is not a floppy disk.",
2248 }
2251 {
2258 CPPUNIT_ASSERT_MESSAGE( "test for getFloppyDiskFlag function: get a floppy volume device flag, it did not pass.",
2260 }
2268 //---------------------------------------------------------------------
2269 // testing the method
2270 // inline sal_Bool getFixedDiskFlag() const
2271 //---------------------------------------------------------------------
2273 {
2277 // test code.
2279 {
2286 CPPUNIT_ASSERT_MESSAGE( "test for getFixedDiskFlag function: get a volume device which is not a fixed disk.",
2288 }
2291 {
2298 CPPUNIT_ASSERT_MESSAGE( "test for getFixedDiskFlag function: get a fixed disk volume device flag, it did not pass.",
2300 }
2307 //---------------------------------------------------------------------
2308 // testing the method
2309 // inline sal_Bool getRAMDiskFlag() const
2310 //---------------------------------------------------------------------
2312 {
2316 // test code.
2318 {
2325 CPPUNIT_ASSERT_MESSAGE( "test for getRAMDiskFlag function: get a volume device which is not a RAM disk.",
2327 }
2330 {
2337 CPPUNIT_ASSERT_MESSAGE( "test for getRAMDiskFlag function: FIX ME, don't know how to get a RAM disk flag, perhaps Windows 98 boot disk can create a RAM disk, it did not pass in (UNX)(W32).",
2339 }
2347 //---------------------------------------------------------------------
2348 // testing the method
2349 // inline sal_uInt64 getTotalSpace() const
2350 //---------------------------------------------------------------------
2352 {
2356 // test code.
2358 {
2366 CPPUNIT_ASSERT_MESSAGE( "test for getTotalSpace function: get total space of Fixed disk volume mounted on /, it should not be 0",
2368 }
2370 #if defined( UNX )
2372 {
2380 CPPUNIT_ASSERT_MESSAGE( "test for getTotalSpace function: get total space of /proc, it should be 0",
2382 }
2385 {
2386 CPPUNIT_ASSERT_MESSAGE( "test for getTotalSpace function:not applicable for /proc( Windows version )",
2388 }
2389 #endif
2393 #if defined(SOLARIS)
2395 {
2410 CPPUNIT_ASSERT_MESSAGE( "test for getTotalSpace function: get total space by hand, then compare with getTotalSpace, it did not pass",
2412 }
2415 {
2416 CPPUNIT_ASSERT_MESSAGE( "test for getTotalSpace function:not implemented yet( Windows version )",
2418 }
2419 #endif
2428 //---------------------------------------------------------------------
2429 // testing the method
2430 // inline sal_uInt64 getFreeSpace() const
2431 //---------------------------------------------------------------------
2433 {
2437 // test code.
2439 {
2447 CPPUNIT_ASSERT_MESSAGE( "test for getFreeSpace function: get free space of Fixed disk volume mounted on /, it should not be 0, suggestion: returned value, -1 is better, since some times the free space may be 0",
2449 }
2451 #if defined( UNX )
2453 {
2461 CPPUNIT_ASSERT_MESSAGE( "test for getFreeSpace function: get free space of /proc, it should be 0",
2463 }
2466 {
2467 CPPUNIT_ASSERT_MESSAGE( "test for getFreeSpace function: not applicable for /proc( Windows version )",
2469 }
2470 #endif
2473 #if defined(SOLARIS)
2475 {
2490 CPPUNIT_ASSERT_MESSAGE( "test for getFreeSpace function: get free space by hand, then compare with getFreeSpace, it did not pass",
2492 }
2495 {
2496 CPPUNIT_ASSERT_MESSAGE( "test for getFreeSpace function: not implemented yet( Windows version )",
2498 }
2499 #endif
2509 //---------------------------------------------------------------------
2510 // testing the method
2511 // inline sal_uInt64 getUsedSpace() const
2512 //---------------------------------------------------------------------
2514 {
2518 // test code.
2520 {
2528 CPPUNIT_ASSERT_MESSAGE( "test for getUsedSpace function: get used space of Fixed disk volume mounted on /, it should not be 0, suggestion: returned value, -1 is better, since some times the used space may be 0",
2530 }
2532 #if defined( UNX )
2534 {
2542 CPPUNIT_ASSERT_MESSAGE( "test for getUsedSpace function: get used space of /proc, it should be 0",
2544 }
2547 {
2548 CPPUNIT_ASSERT_MESSAGE( "test for getUsedSpace function: not applicable for /proc( Windows version )",
2550 }
2551 #endif
2554 #if defined(SOLARIS)
2556 {
2572 CPPUNIT_ASSERT_MESSAGE( "test for getUsedSpace function: get used space by hand, then compare with getUsedSpace, it did not pass",
2574 }
2577 {
2578 CPPUNIT_ASSERT_MESSAGE( "test for getUsedSpace function: not implemented yet( Windows version )",
2580 }
2581 #endif
2592 //---------------------------------------------------------------------
2593 // testing the method
2594 // inline sal_uInt32 getMaxNameLength() const
2595 //---------------------------------------------------------------------
2597 {
2601 // test code.
2603 {
2611 CPPUNIT_ASSERT_MESSAGE( "test for getMaxNameLength function: get max name length of Fixed disk volume mounted on /, it should not be 0",
2613 }
2616 #if ( defined UNX ) || ( defined OS2 )
2618 {
2633 CPPUNIT_ASSERT_MESSAGE( "test for getMaxNameLength function: get max name length by hand, then compare with getMaxNameLength",
2635 }
2638 {
2639 CPPUNIT_ASSERT_MESSAGE( "test for getMaxNameLength function: not implemented yet( Windows version )",
2641 }
2642 #endif
2651 //---------------------------------------------------------------------
2652 // testing the method
2653 // inline sal_uInt32 getMaxPathLength() const
2654 //---------------------------------------------------------------------
2656 {
2660 // test code.
2662 {
2670 CPPUNIT_ASSERT_MESSAGE( "test for getMaxPathLength function: get max path length of Fixed disk volume mounted on /, it should not be 0",
2672 }
2675 #if ( defined UNX ) || ( defined OS2 )
2677 {
2685 CPPUNIT_ASSERT_MESSAGE( "test for getMaxPathLength function: get max path length by hand, then compare with getMaxPathLength",
2687 }
2690 {
2691 CPPUNIT_ASSERT_MESSAGE( "test for getMaxPathLength function: not implemented yet( Windows version )",
2693 }
2694 #endif
2704 //---------------------------------------------------------------------
2705 // testing the method
2706 // inline ::rtl::OUString getFileSystemName() const
2707 //---------------------------------------------------------------------
2709 {
2714 // test code.
2716 {
2724 CPPUNIT_ASSERT_MESSAGE( "test for getFileSystemName function: get file system name of Fixed disk volume mounted on /, it should not be empty string",
2726 }
2729 #if defined(SOLARIS)
2731 {
2746 CPPUNIT_ASSERT_MESSAGE( "test for getFileSystemName function: get file system name by hand, then compare with getFileSystemName",
2748 }
2751 {
2752 CPPUNIT_ASSERT_MESSAGE( "test for getFileSystemName function: not implemented yet( Windows version )",
2754 }
2755 #endif
2764 //---------------------------------------------------------------------
2765 // testing the method
2766 // inline VolumeDevice getDeviceHandle() const
2767 //---------------------------------------------------------------------
2769 {
2774 // test code.
2776 {
2784 CPPUNIT_ASSERT_MESSAGE( "test for getDeviceHandle function: get device handle of Fixed disk volume mounted on /, it should not be NULL, it did not pass in (W32) (UNX).",
2786 }
2794 // -----------------------------------------------------------------------------
2795 /*CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( osl_VolumeInfo::ctors, "osl_VolumeInfo" );
2796 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( osl_VolumeInfo::isValid, "osl_VolumeInfo" );
2797 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( osl_VolumeInfo::getRemoteFlag, "osl_VolumeInfo" );
2798 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( osl_VolumeInfo::getRemoveableFlag, "osl_VolumeInfo" );
2799 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( osl_VolumeInfo::getCompactDiscFlag, "osl_VolumeInfo" );
2800 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( osl_VolumeInfo::getFloppyDiskFlag, "osl_VolumeInfo" );
2801 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( osl_VolumeInfo::getFixedDiskFlag, "osl_VolumeInfo" );
2802 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( osl_VolumeInfo::getRAMDiskFlag, "osl_VolumeInfo" );
2803 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( osl_VolumeInfo::getTotalSpace, "osl_VolumeInfo" );
2804 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( osl_VolumeInfo::getFreeSpace, "osl_VolumeInfo" );
2805 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( osl_VolumeInfo::getUsedSpace, "osl_VolumeInfo" );
2806 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( osl_VolumeInfo::getMaxNameLength, "osl_VolumeInfo" );
2807 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( osl_VolumeInfo::getMaxPathLength, "osl_VolumeInfo" );
2808 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( osl_VolumeInfo::getFileSystemName, "osl_VolumeInfo" );
2809 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( osl_VolumeInfo::getDeviceHandle, "osl_VolumeInfo" );*/
2814 //------------------------------------------------------------------------
2815 // Beginning of the test cases for VolumeDevice class
2816 //------------------------------------------------------------------------
2817 namespace osl_FileStatus
2818 {
2820 //---------------------------------------------------------------------
2821 // testing the method
2822 // FileStatus( sal_uInt32 nMask ): _nMask( nMask )
2823 //---------------------------------------------------------------------
2825 {
2831 // initialization
2833 {
2834 // create a tempfile in $TEMP/tmpdir/tmpname.
2844 /*
2845 Directory aDir( aTmpName3 );
2846 nError1 = aDir.open();
2847 CPPUNIT_ASSERT( ::osl::FileBase::E_None == nError1 );
2848 nError1 = aDir.getNextItem( rItem, 0 );
2849 CPPUNIT_ASSERT( ::osl::FileBase::E_None == nError1 );
2850 aDir.close();
2851 */
2852 }
2855 {
2856 // remove the tempfile in $TEMP/tmpdir/tmpname.
2859 }
2861 // test code.
2863 {
2871 }
2874 {
2882 }
2891 //---------------------------------------------------------------------
2892 // testing the method
2893 // inline sal_Bool isValid( sal_uInt32 nMask ) const
2894 //---------------------------------------------------------------------
2896 {
2902 // initialization
2904 {
2905 // create a tempfile in $TEMP/tmpdir/tmpname.
2910 //::std::auto_ptr<Directory> pDir( new Directory( aTmpName3 ) );
2915 }
2918 {
2923 // remove the tempfile in $TEMP/tmpdir/tmpname.
2926 }
2928 // test code.
2930 {
2939 }
2942 {
2945 {
2947 }
2949 {
2951 }
2953 {
2955 }
2957 {
2959 }
2961 {
2963 }
2965 {
2967 }
2969 {
2971 }
2973 {
2975 }
2977 }
2980 {
2992 // LLA: this is wrong, we never should try to check on all masks
2993 // only on one.
2994 // Second, it's not a bug, if a value is not valid, it's an unhandled feature.
2996 // sal_Bool bOk = rFileStatus.isValid( mask_file );
3001 // CPPUNIT_ASSERT_MESSAGE( "test for isValid function: regular file mask fields test, #FileStatusMask_CreationTime# should be valid field for regular file, but feedback is invalid",
3002 // ( sal_True == bOk ) );
3003 }
3005 //Link is not defined in Windows, and on Linux, we can not get the directory item of the link file
3006 // LLA: we have to differ to filesystems, normal filesystems support links (EXT2, ...)
3007 // castrated filesystems don't (FAT, FAT32)
3008 // Windows NT NTFS support links, but the windows api don't :-(
3011 {
3012 #if defined ( UNX )
3013 // ::osl::FileBase::RC nError;
3014 sal_Int32 fd;
3017 ( ( aUStr_LnkFileSys += aSlashURL ) += getCurrentPID( ) ) += ::rtl::OUString::createFromAscii("/tmpdir/link.file");
3018 ( ( aUStr_SrcFileSys += aSlashURL ) += getCurrentPID( ) ) += ::rtl::OUString::createFromAscii("/tmpdir/tmpname");
3025 //create a link file and link it to file "/tmp/PID/tmpdir/tmpname"
3029 // testDirectory is "/tmp/PID/tmpdir/"
3040 //printFileName( rFileStatus.getFileName( ) );
3042 {
3043 //t_print("find the link file");
3045 {
3048 }
3049 }
3050 }
3051 else
3053 };
3060 #endif
3061 }
3064 {
3071 // LLA: this is wrong
3072 // sal_Bool bOk1 = rFileStatus_all.isValid( mask_file_all );
3078 // sal_Bool bOk2 = rFileStatus_val.isValid( mask_file_val );
3081 // CPPUNIT_ASSERT_MESSAGE( "test for isValid function: check for Mask_All and Validate, really not sure what validate used for and how to use it, help me. did not pass (W32)(UNX).",
3082 // ( sal_False == bOk1 ) && ( sal_True == bOk2 ) );
3083 }
3095 //---------------------------------------------------------------------
3096 // testing the method
3097 // inline Type getFileType() const
3098 //---------------------------------------------------------------------
3100 {
3108 // initialization
3110 {
3111 // create a tempfile: $TEMP/tmpdir/tmpname.
3112 // a tempdirectory: $TEMP/tmpdir/tmpdir.
3113 // use $ROOT/staroffice as volume ---> use dev/fd as volume.
3114 // and get their directory item.
3116 //printFileName( aTmpName2);
3123 //getNextItem can not assure which item retrieved
3130 //mindy: failed on my RH9,so removed temporaly
3131 //nError1 = ::osl::DirectoryItem::get( aVolURL2, m_aVolumeItem );
3132 //CPPUNIT_ASSERT_MESSAGE("get volume item failed!", ::osl::FileBase::E_None == nError1 );
3134 }
3137 {
3138 // remove all in $TEMP/tmpdir.
3142 }
3144 // test code.
3146 {
3152 }
3155 {
3158 {
3162 {
3166 {
3167 // regular
3169 }
3171 {
3172 // directory
3174 }
3178 }
3179 }
3180 // LLA: it's not a bug, if a FileStatus not exist, so no else
3181 }
3184 {
3190 }
3193 {
3194 #if 0
3195 // LLA: this have to be discussed.
3201 {
3204 CPPUNIT_ASSERT_MESSAGE( "test for getFileType function: Volume, it seems the volume part of the field is not implemented, it did not pass in (W32)(UNX).",
3206 }
3207 #endif
3208 }
3212 {
3215 //create a fifo in $ROOT/tmp/tmpdir, get its DirectoryItem.
3227 //check for File type
3232 //delete fifo
3237 {
3242 }
3243 #endif
3244 }
3246 /*
3247 * LLA: removed, m_aSocketItem is wrong initialised.
3248 */
3250 // LLA: void getFileType_005( )
3251 // LLA: {
3252 // LLA: #if defined ( SOLARIS ) //Socket file may differ in Windows
3253 // LLA: // nError1 = ::osl::DirectoryItem::get( aTypeURL1, m_aSocketItem );
3254 // LLA: nError1 = ::osl::DirectoryItem::get( rtl::OUString::createFromAscii("/dev/null"), m_aSocketItem );
3255 // LLA: printError(nError1);
3256 // LLA: CPPUNIT_ASSERT_MESSAGE("get Socket type file failed", ::osl::FileBase::E_None == nError1 );
3257 // LLA:
3258 // LLA: //check for File type
3259 // LLA: ::osl::FileStatus rFileStatus( FileStatusMask_Type );
3260 // LLA:
3261 // LLA: nError1 = m_aSocketItem.getFileStatus( rFileStatus );
3262 // LLA: CPPUNIT_ASSERT_MESSAGE("getFileStatus failed", ::osl::FileBase::E_None == nError1 );
3263 // LLA:
3264 // LLA: if (rFileStatus.isValid( FileStatusMask_Type ))
3265 // LLA: {
3266 // LLA: osl::FileStatus::Type eType = rFileStatus.getFileType( );
3267 // LLA: printFileType(eType);
3268 // LLA: CPPUNIT_ASSERT_MESSAGE( "test for getFileType function: Socket, Solaris version ",
3269 // LLA: ( eType == ::osl::FileStatus::Socket ) );
3270 // LLA: }
3271 // LLA: #endif
3272 // LLA: }
3275 // deprecated since there is a same case Directory::getNextItem_004
3276 /*#if defined 0 //( UNX ) //( SOLARIS ) //Link file is not defined in Windows
3277 void getFileType_006( )
3278 {
3279 nError1 = ::osl::DirectoryItem::get( aTypeURL3, m_aLinkItem );
3280 CPPUNIT_ASSERT( ::osl::FileBase::E_None == nError1 );
3282 //check for File type
3283 ::osl::FileStatus rFileStatus( FileStatusMask_Type );
3284 nError1 = m_aLinkItem.getFileStatus( rFileStatus );
3285 CPPUNIT_ASSERT( ::osl::FileBase::E_None == nError1 );
3287 CPPUNIT_ASSERT_MESSAGE( "test for getFileType function: Link, UNX version ",
3288 ( ::osl::FileStatus::Link == rFileStatus.getFileType( ) ) );
3289 }
3290 #endif */
3293 {
3298 //check for File type
3304 {
3310 }
3311 #endif
3312 }
3319 // LLA: CPPUNIT_TEST( getFileType_005 );
3320 //CPPUNIT_TEST( getFileType_006 );
3325 //---------------------------------------------------------------------
3326 // testing the method
3327 // inline sal_uInt64 getAttributes() const
3328 //---------------------------------------------------------------------
3330 {
3336 // initialization
3338 {
3350 }
3353 {
3356 }
3358 // test code.
3359 #if ( defined UNX ) || ( defined OS2 )
3360 //windows only 3 file attributes: normal, readonly, hidden
3362 {
3369 CPPUNIT_ASSERT_MESSAGE( "test for getAttributes function: ReadOnly, GrpRead, OwnRead, OthRead( UNX version ) ",
3372 }
3375 {
3376 CPPUNIT_ASSERT_MESSAGE( "test for getAttributes function: ReadOnly, GrpRead, OwnRead, OthRead( Windows version )",
3378 }
3379 #endif
3383 {
3384 #if ( defined UNX ) || ( defined OS2 )
3391 CPPUNIT_ASSERT_MESSAGE( "test for getAttributes function: Executable, GrpExe, OwnExe, OthExe, the result is Readonly, Executable, GrpExe, OwnExe, OthExe, it partly not pass( Solaris version )",
3392 ( Attribute_ReadOnly | Attribute_Executable | Attribute_GrpExe | Attribute_OwnExe | Attribute_OthExe ) ==
3394 #endif
3395 }
3398 #if ( defined UNX ) || ( defined OS2 )
3400 {
3407 CPPUNIT_ASSERT_MESSAGE( "test for getAttributes function: GrpWrite, OwnWrite, OthWrite( Solaris version )",
3410 }
3413 {
3414 CPPUNIT_ASSERT_MESSAGE( "test for getAttributes function: GrpWrite, OwnWrite, OthWrite( Windows version )",
3416 }
3417 #endif
3421 {
3430 }
3433 {
3434 ::rtl::OUString aUserHiddenFileURL = ::rtl::OUString::createFromAscii("file:///c:/AUTOEXEC.BAT");
3436 //printFileName( aUserHiddenFileURL );
3442 CPPUNIT_ASSERT_MESSAGE( "Hidden files(Windows version), please check if hidden file c:/AUTOEXEC.BAT exists ",
3444 }
3445 #endif
3455 //---------------------------------------------------------------------
3456 // testing the method
3457 // inline TimeValue getAccessTime() const
3458 //---------------------------------------------------------------------
3460 {
3466 // initialization
3468 {
3475 }
3478 {
3480 }
3482 // test code.
3484 {
3501 CPPUNIT_ASSERT_MESSAGE( "test for getAccessTime function: This test turns out that UNX pricision is no more than 1 sec, don't know how to test this function, in Windows test, it lost hour min sec, only have date time. ",
3503 }
3510 //---------------------------------------------------------------------
3511 // testing the method
3512 // inline TimeValue getModifyTime() const
3513 //---------------------------------------------------------------------
3515 {
3522 // test code.
3524 {
3528 //create file
3533 //get current time
3537 //get instance item and filestatus
3544 //get modify time
3550 //delete file
3554 CPPUNIT_ASSERT_MESSAGE( "test for getModifyTime function: This test turns out that UNX pricision is no more than 1 sec, don't know how to improve this function. ",
3556 }
3564 //---------------------------------------------------------------------
3565 // testing the method
3566 // inline sal_uInt64 getFileSize() const
3567 //---------------------------------------------------------------------
3569 {
3575 // initialization
3577 {
3583 }
3586 {
3588 }
3590 // test code.
3592 {
3601 }
3604 {
3618 CPPUNIT_ASSERT_MESSAGE( "test for getFileSize function: file with size of TEST_FILE_SIZE, did not pass in (W32). ",
3620 }
3627 //---------------------------------------------------------------------
3628 // testing the method
3629 // inline ::rtl::OUString getFileName() const
3630 //---------------------------------------------------------------------
3632 {
3638 // initialization
3640 {
3646 }
3649 {
3651 }
3653 // test code.
3655 {
3664 }
3671 //---------------------------------------------------------------------
3672 // testing the method
3673 // inline ::rtl::OUString getFileURL() const
3674 //---------------------------------------------------------------------
3676 {
3682 // initialization
3684 {
3688 }
3691 {
3693 }
3695 // test code.
3697 {
3706 }
3713 //---------------------------------------------------------------------
3714 // testing the method
3715 // inline ::rtl::OUString getLinkTargetURL() const
3716 //---------------------------------------------------------------------
3718 {
3724 // test code.
3725 // initialization
3727 {
3731 }
3734 {
3736 }
3740 {
3741 //create a link file;
3743 ( ( aUStr_LnkFileSys += aSlashURL ) += getCurrentPID( ) ) += ::rtl::OUString::createFromAscii("/link.file");
3744 ( ( aUStr_SrcFileSys += aSlashURL ) += getCurrentPID( ) ) += ::rtl::OUString::createFromAscii("/tmpname");
3750 sal_Int32 fd;
3754 //get linkTarget URL
3763 //remove link file
3767 CPPUNIT_ASSERT_MESSAGE( "test for getLinkTargetURL function: Solaris version, creat a file, and a link file link to it, get its LinkTargetURL and compare",
3769 }
3770 #else
3772 {
3775 }
3776 #endif
3783 // -----------------------------------------------------------------------------
3798 //------------------------------------------------------------------------
3799 // Beginning of the test cases for File class
3800 //------------------------------------------------------------------------
3801 namespace osl_File
3802 {
3803 //---------------------------------------------------------------------
3804 // testing the method
3805 // File( const ::rtl::OUString& ustrFileURL )
3806 //---------------------------------------------------------------------
3808 {
3809 // ::osl::FileBase::RC nError1;
3812 // initialization
3814 {
3815 // create a tempfile in $TEMP/tmpdir/tmpname.
3818 }
3821 {
3822 // remove the tempfile in $TEMP/tmpdir/tmpname.
3825 }
3827 // test code.
3829 {
3834 CPPUNIT_ASSERT_MESSAGE( "test for ctors function: initialize a File and test its open and close",
3836 }
3839 {
3842 sal_uInt64 nCount;
3848 CPPUNIT_ASSERT_MESSAGE( "test for ctors function: test relative file URL, this test show that relative file URL is also acceptable",
3850 }
3858 //---------------------------------------------------------------------
3859 // testing the method
3860 // inline RC open( sal_uInt32 uFlags )
3861 //---------------------------------------------------------------------
3863 {
3867 // initialization
3869 {
3870 // create a tempfile in $TEMP/tmpdir/tmpname.
3873 }
3876 {
3877 // remove the tempfile in $TEMP/tmpdir/tmpname.
3880 }
3882 // test code.
3884 {
3893 }
3896 {
3903 }
3906 {
3913 }
3916 {
3923 #if defined (WNT )
3927 #endif
3931 }
3934 {
3941 }
3944 {
3961 CPPUNIT_ASSERT_MESSAGE( "test for open function: test for OpenFlag_Read,OpenFlag_Write and OpenFlag_Create",
3967 }
3979 //---------------------------------------------------------------------
3980 // testing the method
3981 // inline RC close()
3982 //---------------------------------------------------------------------
3984 {
3988 // initialization
3990 {
3991 // create a tempfile in $TEMP/tmpdir/tmpname.
3994 }
3997 {
3998 // remove the tempfile in $TEMP/tmpdir/tmpname.
4001 }
4003 // test code.
4005 {
4015 }
4018 {
4031 }
4040 //---------------------------------------------------------------------
4041 // testing the method
4042 // inline RC setPos( sal_uInt32 uHow, sal_Int64 uPos )
4043 //---------------------------------------------------------------------
4045 {
4050 // initialization
4052 {
4053 // create a tempfile in $TEMP/tmpdir/tmpname.
4057 //write chars into the file.
4066 }
4069 {
4070 // remove the tempfile in $TEMP/tmpdir/tmpname.
4073 }
4075 // test code.
4077 {
4090 CPPUNIT_ASSERT_MESSAGE( "test for setPos function: test for Pos_Absolut, set the position to 26, test if the 26th char in file is correct",
4092 }
4095 {
4110 CPPUNIT_ASSERT_MESSAGE( "test for setPos function: test for Pos_Current, set the position to end, test if the ( end -1 ) char in file is correct",
4112 }
4115 {
4121 //the file size is smaller than 100
4132 CPPUNIT_ASSERT_MESSAGE( "test for setPos function: test for Pos_End, set the position to end, test if the first char in file is correct",
4134 }
4143 //---------------------------------------------------------------------
4144 // testing the method
4145 // inline RC getPos( sal_uInt64& uPos )
4146 //---------------------------------------------------------------------
4148 {
4153 // initialization
4155 {
4156 // create a tempfile in $TEMP/tmpdir/tmpname.
4160 //write chars into the file.
4169 }
4172 {
4173 // remove the tempfile in $TEMP/tmpdir/tmpname.
4176 }
4178 // test code.
4180 {
4182 sal_uInt64 nFilePointer;
4198 CPPUNIT_ASSERT_MESSAGE( "test for getPos function: set the position to 26, get position and check if it is right",
4200 }
4208 //---------------------------------------------------------------------
4209 // testing the method
4210 // inline RC isEndOfFile( sal_Bool *pIsEOF )
4211 //---------------------------------------------------------------------
4213 {
4218 // initialization
4220 {
4221 // create a tempfile in $TEMP/tmpdir/tmpname.
4225 //write chars into the file.
4234 }
4237 {
4238 // remove the tempfile in $TEMP/tmpdir/tmpname.
4241 }
4243 // test code.
4245 {
4262 CPPUNIT_ASSERT_MESSAGE( "test for isEndOfFile function: set the position to end, check if reach end",
4264 }
4267 {
4280 {
4285 }
4292 CPPUNIT_ASSERT_MESSAGE( "test for isEndOfFile function: use isEndOfFile to move pointer step by step",
4294 }
4302 //---------------------------------------------------------------------
4303 // testing the method
4304 // inline RC setSize( sal_uInt64 uSize )
4305 //---------------------------------------------------------------------
4307 {
4312 // initialization
4314 {
4315 // create a tempfile in $TEMP/tmpdir/tmpname.
4319 //write chars into the file.
4328 }
4331 {
4332 // remove the tempfile in $TEMP/tmpdir/tmpname.
4335 }
4337 // test code.
4339 {
4341 // sal_Bool bEOF = sal_False;
4342 // sal_Bool *pEOF = &bEOF;
4343 sal_uInt64 nFilePointer;
4349 //enlarge the file to size of 100;
4353 //get the file size;
4364 }
4367 {
4369 // sal_Bool bEOF = sal_False;
4370 // sal_Bool *pEOF = &bEOF;
4371 sal_uInt64 nFilePointer;
4377 //enlarge the file to size of 100;
4381 //get the file size;
4392 }
4393 /* void setSize_003( )
4394 {
4395 ::osl::File testFile( aTmpName4 );
4396 // sal_Bool bEOF = sal_False;
4397 // sal_Bool *pEOF = &bEOF;
4398 sal_uInt64 nFilePointer;
4401 nError1 = testFile.open( OpenFlag_Read | OpenFlag_Write );
4402 CPPUNIT_ASSERT( ::osl::FileBase::E_None == nError1 );
4404 //enlarge the file to size of 100;
4405 nError1 = testFile.setSize( 10 );
4406 CPPUNIT_ASSERT( ::osl::FileBase::E_None == nError1 );
4408 //get the file size;
4409 nError1 = testFile.setPos( Pos_End, 0 );
4410 CPPUNIT_ASSERT( ::osl::FileBase::E_None == nError1 );
4411 nError1 = testFile.getPos( nFilePointer );
4412 CPPUNIT_ASSERT( ::osl::FileBase::E_None == nError1 );
4414 nError1 = testFile.close( );
4415 CPPUNIT_ASSERT( ::osl::FileBase::E_None == nError1 );
4417 CPPUNIT_ASSERT_MESSAGE( "test for setSize function: truncate the file ",
4418 10 == nFilePointer );
4419 }
4420 */
4429 //---------------------------------------------------------------------
4430 // testing the method
4431 // inline RC read( void *pBuffer, sal_uInt64 uBytesRequested, sal_uInt64& rBytesRead )
4432 //---------------------------------------------------------------------
4434 {
4439 // initialization
4441 {
4442 // create a tempfile in $TEMP/tmpdir/tmpname.
4446 //write chars into the file.
4455 }
4458 {
4459 // remove the tempfile in $TEMP/tmpdir/tmpname.
4462 }
4464 // test code.
4466 {
4468 sal_uInt64 nFilePointer;
4485 }
4488 {
4490 sal_uInt64 nFilePointer;
4508 ( 52 == nFilePointer ) && ( 26 == nCount_read ) && ( 0 == strncmp( buffer_read, &pBuffer_Char[26], 26 ) ) );
4509 }
4517 //---------------------------------------------------------------------
4518 // testing the method
4519 // inline RC write(const void *pBuffer, sal_uInt64 uBytesToWrite, sal_uInt64& rBytesWritten)
4520 //---------------------------------------------------------------------
4522 {
4527 // initialization
4529 {
4530 // create a tempfile in $TEMP/tmpname.
4532 }
4535 {
4536 // remove the tempfile in $TEMP/tmpname.
4538 }
4540 // test code.
4542 {
4544 sal_uInt64 nFilePointer;
4550 //write chars into the file.
4553 //get the current pointer;
4556 //reset pointer to the begining;
4565 CPPUNIT_ASSERT_MESSAGE( "test for write function: read whole content in the file to a buffer. Note, buffer size can not smaller than the read size",
4569 }
4576 //---------------------------------------------------------------------
4577 // testing the method
4578 // inline RC readLine( ::rtl::ByteSequence& aSeq )
4579 //---------------------------------------------------------------------
4581 {
4587 // initialization
4589 {
4590 // create a tempfile in $TEMP/tmpname.
4593 //write some strings into the file.
4597 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
4598 };
4604 {
4607 }
4611 }
4614 {
4615 // remove the tempfile in $TEMP/tmpname.
4617 }
4619 // test code.
4621 {
4632 }
4635 {
4643 {
4646 }
4650 CPPUNIT_ASSERT_MESSAGE( "test for readLine function: read three lines of the file and check the file pointer moving.",
4653 }
4660 //---------------------------------------------------------------------
4661 // testing the method
4662 // inline static RC copy( const ::rtl::OUString& ustrSourceFileURL, const ::rtl::OUString& ustrDestFileURL )
4663 //---------------------------------------------------------------------
4665 {
4670 // initialization
4672 {
4673 // create a tempfile in $TEMP/tmpdir/tmpname.
4677 //write chars into the file.
4686 }
4689 {
4690 // remove the tempfile in $TEMP/tmpdir/tmpname.
4693 }
4695 // test code.
4697 {
4700 //copy $TEMP/tmpdir/tmpname to $TEMP/tmpname.
4703 //check
4709 }
4712 {
4713 //copy $TEMP/tmpdir/tmpname to $TEMP/tmpdir.
4718 }
4721 {
4722 //copy $TEMP/tmpdir/tmpname to $ROOT/tmpname.
4724 #if defined (WNT )
4727 #endif
4730 }
4733 {
4734 //copy $TEMP/tmpname to $TEMP/tmpdir/tmpname.
4739 }
4742 {
4743 //copy $TEMP/tmpname to $TEMP/system.path using system path.
4748 }
4750 {
4757 //copy to new path
4761 //check if is the new file
4765 // CPPUNIT_ASSERT( ::osl::FileBase::E_None == nError1 );
4766 sal_uInt64 nFilePointer;
4773 }
4774 //copyLink has not been impletmented yet
4776 {
4777 #if ( defined UNX )
4781 #endif
4782 }
4794 //---------------------------------------------------------------------
4795 // testing the method
4796 // inline static RC move( const ::rtl::OUString& ustrSourceFileURL, const ::rtl::OUString& ustrDestFileURL )
4797 //---------------------------------------------------------------------
4799 {
4804 // initialization
4806 {
4807 // create a tempfile in $TEMP/tmpdir/tmpname.
4811 //write chars into the file.
4820 }
4823 {
4824 // remove the tempfile in $TEMP/tmpdir/tmpname.
4827 }
4829 // test code.
4831 {
4832 //rename $TEMP/tmpdir/tmpname to $TEMP/canonical.name.
4835 //check
4842 }
4845 {
4846 //move $TEMP/tmpdir/tmpname to $TEMP/tmpdir.
4848 //returned ::osl::FileBase::E_ACCES on WNT
4850 ( ::osl::FileBase::E_ACCES == nError1 || ::osl::FileBase::E_ISDIR == nError1 ) ||( ::osl::FileBase::E_EXIST == nError1 ) );
4851 }
4854 {
4855 //move $TEMP/tmpdir/tmpname to $ROOT/tmpname.
4857 #if defined (WNT )
4860 #endif
4864 }
4867 {
4868 //move $TEMP/tmpname to $TEMP/tmpdir/tmpname.
4873 }
4876 {
4877 //move $TEMP/tmpname to $TEMP/system.path using system path.
4882 }
4885 {
4886 //move directory $TEMP/tmpname to $TEMP/tmpdir/tmpname.
4889 //move file $TEMP/tmpdir/tmpname to $TEMP/tmpname
4892 #if defined ( WNT )
4893 deleteTestDirectory( aTmpName4 );// in Windows, it can be moved!!!!! this is only for not influence the following test.
4897 #endif
4898 CPPUNIT_ASSERT_MESSAGE( "test for move function: move a directory to an exist file with same name, did not pass in (W32)",
4900 }
4903 {
4904 //create directory $TEMP/tmpname.
4906 //move directory $TEMP/tmpdir to $TEMP/tmpname/tmpdir
4908 //check
4913 CPPUNIT_ASSERT_MESSAGE( "test for move function: move a directory to an exist file with same name",
4916 }
4917 // oldpath and newpath are not on the same filesystem.EXDEV,no such error no on Solaris, only on linux
4919 {
4920 CPPUNIT_ASSERT_MESSAGE( "oldpath and newpath are not on the same filesystem, should error returns",
4922 }
4923 //bugid# 115420, after the bug fix, add the case
4925 {
4926 //create directory $TEMP/tmpname.
4928 //create directory $TEMP/tmpname/tmpdir
4930 //move directory $TEMP/tmpname to $TEMP/tmpname/tmpdir/tmpname
4932 //printFileName( newName );
4934 //deleteTestDirectory( newName + OUString::createFromAscii("/tmpname") );
4935 //deleteTestDirectory( newName );
4940 }
4950 // CPPUNIT_TEST( move_008 );
4951 //CPPUNIT_TEST( move_009 );
4956 //---------------------------------------------------------------------
4957 // testing the method
4958 // inline static RC remove( const ::rtl::OUString& ustrFileURL )
4959 //---------------------------------------------------------------------
4961 {
4966 // initialization
4968 {
4969 // create a tempfile in $TEMP/tmpdir/tmpname.
4973 //write chars into the file.
4982 }
4985 {
4986 // remove the tempfile in $TEMP/tmpdir/tmpname.
4989 }
4991 // test code.
4993 {
4994 //remove $TEMP/tmpdir/tmpname.
4996 //check
5003 }
5006 {
5007 //remove $TEMP/tmpname.
5012 }
5015 {
5016 //remove $TEMP/system/path.
5019 CPPUNIT_ASSERT_MESSAGE( "test for remove function: removing a file not using full qualified URL",
5021 }
5024 {
5025 //remove $TEMP/tmpdir.
5030 }
5041 //---------------------------------------------------------------------
5042 // testing the method
5043 // inline static RC setAttributes( const ::rtl::OUString& ustrFileURL, sal_uInt64 uAttributes )
5044 //---------------------------------------------------------------------
5046 {
5051 // initialization
5053 {
5054 // create a tempfile in $TEMP/tmpdir/tmpname.
5056 }
5059 {
5060 // remove the tempfile in $TEMP/tmpdir/tmpname.
5062 }
5064 // test code.
5066 {
5067 //on windows, only can set 2 attributes: Attribute_ReadOnly, Attribute_HIDDEN
5068 #ifdef UNX
5069 //set the file to readonly
5070 nError2 = ::osl::File::setAttributes( aTmpName6, Attribute_ReadOnly | Attribute_GrpRead | Attribute_OwnRead | Attribute_OthRead );
5074 //get the file attributes
5079 CPPUNIT_ASSERT_MESSAGE( "test for setAttributes function: set file attributes and get it to verify.",
5082 #else
5083 //please see GetFileAttributes
5088 //get the file attributes
5092 //here the file has 2 Attributes: FILE_ATTRIBUTE_READONLY and FILE_ATTRIBUTE_NORMAL,
5093 // but FILE_ATTRIBUTE_NORMAL is valid only if used alone, so this is maybe a bug
5094 /*::rtl::OString aString = ::rtl::OUStringToOString( aTmpName6, RTL_TEXTENCODING_ASCII_US );
5095 DWORD dwFileAttributes = GetFileAttributes( aString.getStr( ) );
5096 if (dwFileAttributes & FILE_ATTRIBUTE_NORMAL)
5097 t_print("has normal attribute");
5098 if (dwFileAttributes & FILE_ATTRIBUTE_READONLY)
5099 t_print("has readonly attribute");
5100 */
5101 CPPUNIT_ASSERT_MESSAGE( "test for setAttributes function: set file attributes READONLY and get it to verify.",
5103 #endif
5104 }
5106 {
5107 //on UNX, can not set hidden attribute to file, rename file can set the attribute
5108 #ifdef WNT
5109 //set the file to hidden
5115 //get the file attributes
5120 CPPUNIT_ASSERT_MESSAGE( "test for setAttributes function: set file attributes and get it to verify.",
5122 #endif
5123 }
5132 //---------------------------------------------------------------------
5133 // testing the method
5134 // inline static RC setTime(
5135 // const ::rtl::OUString& ustrFileURL,
5136 // const TimeValue& rCreationTime,
5137 // const TimeValue& rLastAccessTime,
5138 // const TimeValue& rLastWriteTime )
5139 //---------------------------------------------------------------------
5141 {
5146 // initialization
5148 {
5149 // create a tempfile in $TEMP/tmpdir/tmpname.
5151 }
5154 {
5155 // remove the tempfile in $TEMP/tmpdir/tmpname.
5157 }
5159 // test code.
5161 {
5171 //get current time
5175 //set the file time
5179 //get the file access time, creation time, modify time
5198 CPPUNIT_ASSERT_MESSAGE( "test for setTime function: set access time then get it. time precision is still a problem for it cut off the nanosec.",
5200 #if defined ( WNT )
5201 //Unfortunately there is no way to get the creation time of a file under Unix (its a Windows only feature).
5202 //That means the flag osl_FileStatus_Mask_CreationTime should be deprecated under Unix.
5205 #endif
5212 }
5219 //---------------------------------------------------------------------
5220 // testing the method
5221 // inline static RC sync()
5222 //---------------------------------------------------------------------
5224 {
5229 // initialization
5231 {
5232 // create a tempfile in $TEMP/tmpdir/tmpname.
5235 }
5238 {
5239 // remove the tempfile in $TEMP/tmpdir/tmpname.
5241 }
5243 // test case: if The file is located on a read only file system.
5245 {
5246 #ifdef UNX
5260 //set the file to readonly
5261 nError2 = ::osl::File::setAttributes( aTmpName6, Attribute_ReadOnly | Attribute_GrpRead | Attribute_OwnRead | Attribute_OthRead );
5269 #endif
5270 }
5271 //test case:no enough space, how to create such case???see test_cpy_wrt_file.cxx::test_osl_writeFile
5280 // -----------------------------------------------------------------------------
5301 //------------------------------------------------------------------------
5302 // Beginning of the test cases for DirectoryItem class
5303 //------------------------------------------------------------------------
5304 namespace osl_DirectoryItem
5305 {
5306 //---------------------------------------------------------------------
5307 // testing the method
5308 // DirectoryItem(): _pData( NULL )
5309 //---------------------------------------------------------------------
5311 {
5315 // initialization
5317 {
5318 // create a tempfile in $TEMP/tmpname.
5320 }
5323 {
5324 // remove the tempfile in $TEMP/tmpname.
5326 }
5328 // test code.
5330 {
5334 //get the DirectoryItem.
5338 CPPUNIT_ASSERT_MESSAGE( "test for ctors function: initialize a new instance of DirectoryItem and get an item to check.",
5340 }
5347 //---------------------------------------------------------------------
5348 // testing the method
5349 // DirectoryItem( const DirectoryItem& rItem ): _pData( rItem._pData)
5350 //---------------------------------------------------------------------
5352 {
5356 // initialization
5358 {
5359 // create a tempfile in $TEMP/tmpname.
5361 }
5364 {
5365 // remove the tempfile in $TEMP/tmpname.
5367 }
5369 // test code.
5371 {
5373 //get the DirectoryItem.
5382 CPPUNIT_ASSERT_MESSAGE( "test for copy_assin_Ctors function: use copy constructor to get an item and check filename.",
5384 }
5387 {
5389 //get the DirectoryItem.
5399 CPPUNIT_ASSERT_MESSAGE( "test for copy_assin_Ctors function: test assinment operator here since it is same as copy constructor in test way.",
5401 }
5409 //---------------------------------------------------------------------
5410 // testing the method
5411 // inline sal_Bool is()
5412 //---------------------------------------------------------------------
5414 {
5418 // initialization
5420 {
5421 // create a tempfile in $TEMP/tmpname.
5423 }
5426 {
5427 // remove the tempfile in $TEMP/tmpname.
5429 }
5431 // test code.
5433 {
5438 }
5441 {
5443 //get the DirectoryItem.
5449 }
5457 //---------------------------------------------------------------------
5458 // testing the method
5459 // static inline RC get( const ::rtl::OUString& ustrFileURL, DirectoryItem& rItem )
5460 //---------------------------------------------------------------------
5462 {
5466 // initialization
5468 {
5469 // create a tempfile in $TEMP/tmpname.
5471 }
5474 {
5475 // remove the tempfile in $TEMP/tmpname.
5477 }
5479 // test code.
5481 {
5483 //get the DirectoryItem.
5486 //check the file name
5491 CPPUNIT_ASSERT_MESSAGE( "test for get function: use copy constructor to get an item and check filename.",
5494 }
5497 {
5499 //get the DirectoryItem.
5504 }
5507 {
5509 //get the DirectoryItem.
5514 }
5523 //---------------------------------------------------------------------
5524 // testing the method
5525 // inline RC getFileStatus( FileStatus& rStatus )
5526 //---------------------------------------------------------------------
5528 {
5532 // initialization
5534 {
5535 // create a tempfile in $TEMP/tmpdir/tmpname.
5538 }
5541 {
5542 // remove the tempfile in $TEMP/tmpdir/tmpname.
5545 }
5547 // test code.
5549 {
5551 //get the DirectoryItem.
5555 //check the file name
5562 }
5565 {
5567 //get the DirectoryItem.
5570 //check the file name
5576 }
5579 {
5581 //get the DirectoryItem.
5585 //check the file name
5592 }
5605 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( osl_DirectoryItem::copy_assin_Ctors, "osl_DirectoryItem" );
5608 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( osl_DirectoryItem::getFileStatus, "osl_DirectoryItem" );
5612 //------------------------------------------------------------------------
5613 // Beginning of the test cases for Directory class
5614 //------------------------------------------------------------------------
5615 namespace osl_Directory
5616 {
5617 //---------------------------------------------------------------------
5618 // testing the method
5619 // Directory( const ::rtl::OUString& strPath ): _pData( 0 ), _aPath( strPath )
5620 //---------------------------------------------------------------------
5622 {
5626 // initialization
5628 {
5629 // create a tempfile in $TEMP/tmpdir/tmpname.
5632 }
5635 {
5636 // remove the tempfile in $TEMP/tmpdir/tmpname.
5639 // LLA: t_print("tearDown done.\n");
5640 }
5642 // test code.
5644 {
5647 //open a directory
5650 //close a directory
5654 CPPUNIT_ASSERT_MESSAGE( "test for ctors function: create an instance and check open and close",
5657 }
5660 {
5663 //open a directory
5666 //close a directory
5673 }
5681 //---------------------------------------------------------------------
5682 // testing the method
5683 // inline RC open()
5684 //---------------------------------------------------------------------
5686 {
5690 // initialization
5692 {
5693 // create a tempfile in $TEMP/tmpdir/tmpname.
5696 }
5699 {
5700 // remove the tempfile in $TEMP/tmpdir/tmpname.
5703 }
5705 // test code.
5707 {
5710 //open a directory
5712 //check if directory is opened.
5714 //close a directory
5721 }
5724 {
5727 //open a directory
5730 {
5733 }
5737 }
5740 {
5743 //open a directory
5746 {
5749 }
5753 }
5756 {
5759 //open a directory
5762 {
5765 }
5769 }
5779 //---------------------------------------------------------------------
5780 // testing the method
5781 // inline sal_Bool isOpen() { return _pData != NULL; };
5782 //---------------------------------------------------------------------
5784 {
5788 // initialization
5790 {
5791 // create a tempfile in $TEMP/tmpdir/tmpname.
5794 }
5797 {
5798 // remove the tempfile in $TEMP/tmpdir/tmpname.
5801 }
5803 // test code.
5805 {
5808 //open a directory
5810 //check if directory is opened.
5812 //close a directory
5817 }
5820 {
5823 //check if directory is opened.
5826 CPPUNIT_ASSERT_MESSAGE( "test for isOpen function: do not open a directory and check for open",
5828 }
5836 //---------------------------------------------------------------------
5837 // testing the method
5838 // inline RC close()
5839 //---------------------------------------------------------------------
5841 {
5845 // initialization
5847 {
5848 // create a tempdirectory : $TEMP/tmpdir.
5850 }
5853 {
5854 // remove a tempdirectory : $TEMP/tmpdir.
5856 }
5858 // test code.
5860 {
5863 //open a directory
5865 //close a directory
5867 //check if directory is opened.
5872 }
5875 {
5878 //close a directory
5883 }
5892 //---------------------------------------------------------------------
5893 // testing the method
5894 // inline RC reset()
5895 //---------------------------------------------------------------------
5897 {
5902 // initialization
5904 {
5905 // create a tempdirectory : $TEMP/tmpdir.
5907 // create three files : $TEMP/tmpdir/tmpname, $TEMP/tmpdir/tmpdir, $TEMP/tmpdir/hiddenfile,
5911 }
5914 {
5915 // remove three files : $TEMP/tmpdir/tmpname, $TEMP/tmpdir/tmpdir, $TEMP/tmpdir/hiddenfile,
5919 // remove a tempdirectory : $TEMP/tmpdir.
5921 }
5923 // test code.
5925 {
5928 //open a directory
5931 //get first Item
5934 //get second Item
5935 //mindy: nError1 = testDirectory.getNextItem( rItem, 0 );
5936 //mindy: CPPUNIT_ASSERT( ::osl::FileBase::E_None == nError1 );
5938 //reset enumeration
5940 //get reseted Item, if reset does not work, getNextItem() should return the second Item (aTmpName1)
5944 //check the file name
5947 //close a directory
5955 CPPUNIT_ASSERT_MESSAGE( "test for reset function: get two directory item, reset it, then get again, check the filename",
5958 }
5961 {
5964 //close a directory
5969 }
5973 {
5976 //close a directory
5981 }
5984 {
5987 //close a directory
5992 }
6002 //---------------------------------------------------------------------
6003 // testing the method
6004 // inline RC getNextItem( DirectoryItem& rItem, sal_uInt32 nHint = 0 )
6005 //---------------------------------------------------------------------
6007 {
6012 // initialization
6014 {
6015 // create a tempdirectory : $TEMP/tmpdir.
6017 // create three files : $TEMP/tmpdir/tmpname, $TEMP/tmpdir/tmpdir, $TEMP/tmpdir/hiddenfile,
6022 }
6025 {
6026 // remove three files : $TEMP/tmpdir/tmpname, $TEMP/tmpdir/tmpdir, $TEMP/tmpdir/hiddenfile,
6030 // remove a tempdirectory : $TEMP/tmpdir.
6032 }
6034 // test code.
6036 {
6039 //open a directory
6043 //check the file name
6050 {
6051 //get three Items
6057 {
6058 case 0: bOk1 = compareFileName( rFileStatus.getFileName( ), aTmpName2 ) || compareFileName( rFileStatus.getFileName( ), aHidURL1);
6062 case 2: bOk3 = compareFileName( rFileStatus.getFileName( ), aHidURL1) || compareFileName( rFileStatus.getFileName( ), aTmpName2 );
6063 }
6064 }
6066 //close a directory
6070 CPPUNIT_ASSERT_MESSAGE( "test for getNextItem function: retrive three items and check their names.",
6072 }
6075 {
6079 CPPUNIT_ASSERT_MESSAGE( "test for getNextItem function: retrive an item in a directory which is not opened, also test for nHint's default value.",
6081 }
6084 {
6087 //open a directory
6092 {
6094 }
6096 //close a directory
6100 CPPUNIT_ASSERT_MESSAGE( "test for getNextItem function: retrive 4 times in a directory which contain only 3 files.",
6102 }
6105 {
6106 //create a link file(can not on Windows), then check if getNextItem can get it.
6107 #ifdef UNX
6110 ( ( aUStr_LnkFileSys += aSlashURL ) += getCurrentPID( ) ) += ::rtl::OUString::createFromAscii("/tmpdir/link.file");
6111 ( ( aUStr_SrcFileSys += aSlashURL ) += getCurrentPID( ) ) += ::rtl::OUString::createFromAscii("/tmpdir/tmpname");
6116 //create a link file and link it to file "/tmp/PID/tmpdir/tmpname"
6121 //open a directory
6131 {
6133 {
6136 }
6137 }
6138 }
6139 else
6141 };
6144 CPPUNIT_ASSERT_MESSAGE( "test for getNextItem function: check if can retrieve the link file name",
6146 #endif
6147 }
6157 //---------------------------------------------------------------------
6158 // testing the method
6159 // inline static RC getVolumeInfo( const ::rtl::OUString& ustrDirectoryURL, VolumeInfo& rInfo )
6160 //---------------------------------------------------------------------
6162 {
6167 // test code.
6169 {
6171 {
6172 //get file system name
6180 }
6182 {
6199 }
6201 {
6202 // within Linux, df / * 1024 bytes is the result
6205 }
6207 {
6210 }
6212 {
6215 }
6217 {
6220 }
6222 {
6225 }
6227 {
6230 }
6231 }
6234 {
6236 //call getVolumeInfo here
6238 // LLA: IMHO it's not a bug, if VolumeInfo is not valid, it's a feature
6239 // LLA: CPPUNIT_ASSERT_MESSAGE("mask is not valid", sal_True == aVolumeInfo.isValid( _nMask ) );
6241 {
6243 }
6244 }
6248 {
6251 }
6253 {
6256 }
6258 {
6261 }
6263 {
6266 }
6268 {
6271 }
6273 {
6276 }
6278 {
6281 }
6283 {
6286 }
6289 {
6292 //call getVolumeInfo here
6294 // LLA: rtl::OUString aRootSysURL;
6295 // LLA: nError1 = osl::File::getFileURLFromSystemPath(aRootSys, aRootSysURL);
6296 // LLA:
6297 // LLA: CPPUNIT_ASSERT_MESSAGE( "can't convert root path to file url",
6298 // LLA: ( osl::FileBase::E_NONE == nError1 ) );
6304 }
6307 {
6310 //call getVolumeInfo here
6313 // LLA: in Windows, it reply no error, it did not pass in (W32).
6314 #ifdef UNX
6317 #endif
6318 }
6335 //---------------------------------------------------------------------
6336 // testing the method
6337 // inline static RC create( const ::rtl::OUString& ustrDirectoryURL )
6338 //---------------------------------------------------------------------
6340 {
6345 // test code.
6347 {
6348 //create directory in $TEMP/tmpdir
6350 //check for existence
6352 //remove it
6355 CPPUNIT_ASSERT_MESSAGE( "test for create function: create a directory and check its existence.",
6358 }
6361 {
6362 //create directory in /tmpname
6364 #if defined (WNT )
6367 #endif
6369 CPPUNIT_ASSERT_MESSAGE( "test for create function: create a directory in root for access test.",
6371 }
6374 {
6375 //create directory in /tmpname
6380 }
6389 //---------------------------------------------------------------------
6390 // testing the method
6391 // inline static RC remove( const ::rtl::OUString& ustrDirectoryURL )
6392 //---------------------------------------------------------------------
6394 {
6399 // test code.
6401 {
6402 //create directory in $TEMP/tmpdir
6405 //remove it
6407 //check for existence
6411 CPPUNIT_ASSERT_MESSAGE( "test for remove function: remove a directory and check its existence.",
6414 }
6417 {
6418 //create directory in $TEMP/tmpdir
6421 //try to remove it by system path
6423 //check for existence
6429 CPPUNIT_ASSERT_MESSAGE( "test for remove function: remove a directory by its system path, and check its existence.",
6431 }
6434 {
6435 //try to remove a non-existed directory
6440 }
6443 {
6446 //try to remove file.
6451 bExist == sal_True &&(( osl::FileBase::E_NOTDIR == nError1 ) || ( osl::FileBase::E_NOENT == nError1 )) );
6452 }
6455 {
6461 ::rtl::OUString suError = ::rtl::OUString::createFromAscii("test for remove function: try to remove a directory that is not empty.") + errorToStr( nError1 );
6462 #if defined ( SOLARIS )
6463 //on UNX, the implementation uses rmdir(), which EEXIST is thrown on Solaris when the directory is not empty, refer to: 'man -s 2 rmdir', while on linux, ENOTEMPTY is thrown.
6464 //EEXIST The directory contains entries other than those for "." and "..".
6467 #else
6469 #endif
6470 }
6481 //########################################
6482 // TEST Directory::createPath
6483 //########################################
6485 #ifdef WNT
6486 # define PATH_BUFFER_SIZE MAX_PATH
6487 #else
6488 # define PATH_BUFFER_SIZE PATH_MAX
6489 #endif
6493 //########################################
6495 {
6496 OUString tmp;
6499 CPPUNIT_ASSERT_MESSAGE
6500 (
6503 );
6512 }
6514 //########################################
6516 {
6529 }
6531 //########################################
6533 {
6536 {
6537 }
6540 {
6541 i++;
6542 };
6545 {
6547 }
6551 };
6554 //########################################
6556 {
6558 //##########################################
6560 {}
6562 //##########################################
6564 {
6568 CPPUNIT_ASSERT_MESSAGE
6569 (
6572 );
6573 }
6575 //##########################################
6577 {
6584 CPPUNIT_ASSERT_MESSAGE
6585 (
6588 );
6589 }
6591 //##########################################
6593 {
6602 CPPUNIT_ASSERT_MESSAGE
6603 (
6606 );
6608 }
6610 #ifdef WNT
6612 //##########################################
6614 {
6628 }
6630 //##########################################
6632 {
6642 OUString tp_url;
6647 CPPUNIT_ASSERT_MESSAGE
6648 (
6651 );
6652 }
6654 //##########################################
6656 {
6659 OUString tp_url;
6664 CPPUNIT_ASSERT_MESSAGE
6665 (
6668 );
6669 }
6677 #ifdef WNT
6680 // adapt the UNC path in method createDirectoryPath_with_UNC_path
6681 // in order to run this test successfully
6682 //CPPUNIT_TEST(with_UNC_path);
6683 #endif
6688 // -----------------------------------------------------------------------------
6702 // -----------------------------------------------------------------------------
6703 // this macro creates an empty function, which will called by the RegisterAllFunctions()
6704 // to let the user the possibility to also register some functions by hand.
6705 // -----------------------------------------------------------------------------
6707 /// NOADDITIONAL;
6711 /** get Current PID.
6712 */
6714 {
6715 //~ Get current PID and turn it into OUString;
6717 #ifdef WNT
6719 #else
6721 #endif
6723 }
6726 /** Insert Current PID to the URL to avoid access violation between multiuser execution.
6727 */
6729 {
6730 //~ check if the path contain the temp directory, do nothing changes if not;
6734 //~ format pathname to TEMP/USERPID/URL style;
6736 {
6742 }
6743 else
6744 {
6750 }
6753 }
6755 /** to do some initialized work, we replace the NOADDITIONAL macro with the initialize work which
6756 will check the file and directory existence. and set some variables for test use.
6757 to simplify the initialize work, we seperate it into UNIX section and Windows section, the main task
6758 of initialization is adapt all URL defined in osl_File_Const.h to TEMP/USERPID/URL style format,
6759 since there may be an instance that multiuser execute test at the same time, and the temp file
6760 may not be clean up in this case due to access right problem.
6761 */
6763 {
6767 //~ make sure the c:\temp exist, if not, create it.
6768 #if ( defined WNT )
6772 };
6773 #endif
6775 //~ make sure the c:\temp\PID or /tmp/PID exist, if not, create it. initialize the user directory.
6781 }
6783 //~ adapt all URL to the TEMP/USERPID/URL format;
6800 }
6803 //~ do some clean up work after all test completed.
6804 class GlobalObject
6805 {
6808 {
6809 try
6810 {
6811 //~ make sure the c:\temp\PID or /tmp/PID exist, if yes, delete it.
6815 }
6817 // LLA: t_print("after deleteTestDirectory\n");
6818 //~ special clean up task in Windows and Unix seperately;
6819 #if ( defined UNX ) || ( defined OS2 )
6820 //~ some clean up task for UNIX OS
6821 ;
6822 #else
6823 //~ some clean up task for Windows OS
6824 //~ check if some files are in the way, remove them if necessary.
6845 #endif
6847 }
6849 {
6850 t_print("Exception caught in GlobalObject dtor(). Exception message: '%s'. Source line: %d\n", e.what(), e.sourceLine().lineNumber());
6851 }
6853 {
6855 }
6856 }
6857 };
6859 GlobalObject theGlobalObject;