1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sal.hxx"
26
27 //------------------------------------------------------------------------
28 // include files
29 //------------------------------------------------------------------------
30 #include <sal/types.h>
31 #include <rtl/ustring.hxx>
32 #include <rtl/ustrbuf.hxx>
33
34 #include "osl/thread.h"
35
36 #include "rtl/ustrbuf.hxx"
37 #include <osl/file.hxx>
38 #include <osl_File_Const.h>
39
40 #include "gtest/gtest.h"
41
42 // #ifdef WNT
43 // # define UNICODE
44 // # define WIN32_LEAN_AND_MEAN
45 // # include <windows.h>
46 // # include <tchar.h>
47 // #endif
48
49
50 using namespace osl;
51 using namespace rtl;
52
53 //------------------------------------------------------------------------
54 // helper functions
55 //------------------------------------------------------------------------
56
57 /** detailed wrong message.
58 */
errorToString(const::osl::FileBase::RC _nError)59 inline ::rtl::OString errorToString( const ::osl::FileBase::RC _nError )
60 {
61 ::rtl::OString sResult;
62 switch ( _nError ) {
63 case ::osl::FileBase::E_None:
64 sResult = "Success";
65 break;
66 case ::osl::FileBase::E_PERM:
67 sResult = "Operation not permitted";
68 break;
69 case ::osl::FileBase::E_NOENT:
70 sResult = "No such file or directory";
71 break;
72 case ::osl::FileBase::E_EXIST:
73 sResult = "Already Exist";
74 break;
75 case ::osl::FileBase::E_ACCES:
76 sResult = "Permission denied";
77 break;
78 case ::osl::FileBase::E_INVAL:
79 sResult = "The format of the parameters was not valid";
80 break;
81 case ::osl::FileBase::E_NOTDIR:
82 sResult = "Not a directory";
83 break;
84 case ::osl::FileBase::E_ISDIR:
85 sResult = "Is a directory";
86 break;
87 case ::osl::FileBase::E_BADF:
88 sResult = "Bad file";
89 break;
90 case ::osl::FileBase::E_NOTEMPTY:
91 sResult = "The directory is not empty";
92 break;
93 default:
94 sResult = "Unknown Error";
95 break;
96 }
97 return sResult;
98 }
99
errorToStr(::osl::FileBase::RC const & nError)100 rtl::OUString errorToStr( ::osl::FileBase::RC const& nError)
101 {
102 rtl::OUStringBuffer suBuf;
103 suBuf.append( rtl::OUString::createFromAscii("The returned error is: ") );
104 suBuf.append( rtl::OStringToOUString(errorToString(nError), RTL_TEXTENCODING_ASCII_US) );
105 suBuf.append( rtl::OUString::createFromAscii("!\n") );
106 return suBuf.makeStringAndClear();
107 }
108
109 /** print a file type name.
110 */
printFileType(const::osl::FileStatus::Type nType)111 inline void printFileType( const ::osl::FileStatus::Type nType )
112 {
113 printf( "#printFileType# " );
114 switch ( nType ) {
115 case ::osl::FileStatus::Directory:
116 printf( "This file is a: Directory.\n" );
117 break;
118 case ::osl::FileStatus::Volume:
119 printf( "This file is a: volume device.\n" );
120 break;
121 case ::osl::FileStatus::Regular:
122 printf( "This file is a: regular file.\n" );
123 break;
124 case ::osl::FileStatus::Fifo:
125 printf( "This file is a: fifo.\n" );
126 break;
127 case ::osl::FileStatus::Socket:
128 printf( "This file is a: socket.\n" );
129 break;
130 case ::osl::FileStatus::Link:
131 printf( "This file is a: link file.\n" );
132 break;
133 case ::osl::FileStatus::Special:
134 printf( "This file is a: special.\n" );
135 break;
136 case ::osl::FileStatus::Unknown:
137 printf( "The file type is unknown %d \n", nType );
138 break;
139 }
140 }
141
142 /** print a file attributes.
143 */
printFileAttributes(const sal_Int64 nAttributes)144 inline void printFileAttributes( const sal_Int64 nAttributes )
145 {
146 printf( "#printFileAttributes# This file is a: (" );
147 if ( ( nAttributes | Attribute_ReadOnly ) == nAttributes )
148 printf( " ReadOnly " );
149 if ( ( nAttributes | Attribute_Hidden ) == nAttributes )
150 printf( " Hidden " );
151 if ( ( nAttributes | Attribute_Executable ) == nAttributes )
152 printf( " Executable " );
153 if ( ( nAttributes | Attribute_GrpWrite ) == nAttributes )
154 printf( " GrpWrite " );
155 if ( ( nAttributes | Attribute_GrpRead ) == nAttributes )
156 printf( " GrpRead " );
157 if ( ( nAttributes | Attribute_GrpExe ) == nAttributes )
158 printf( " GrpExe " );
159 if ( ( nAttributes | Attribute_OwnWrite ) == nAttributes )
160 printf( " OwnWrite " );
161 if ( ( nAttributes | Attribute_OwnRead ) == nAttributes )
162 printf( " OwnRead " );
163 if ( ( nAttributes | Attribute_OwnExe ) == nAttributes )
164 printf( " OwnExe " );
165 if ( ( nAttributes | Attribute_OthWrite ) == nAttributes )
166 printf( " OthWrite " );
167 if ( ( nAttributes | Attribute_OthRead ) == nAttributes )
168 printf( " OthRead " );
169 if ( ( nAttributes | Attribute_OthExe ) == nAttributes )
170 printf( " OthExe " );
171 printf( ") file!\n" );
172 }
173
174 /** print a UNI_CODE file name.
175 */
printFileName(const::rtl::OUString & str)176 inline void printFileName( const ::rtl::OUString & str )
177 {
178 rtl::OString aString;
179
180 printf( "#printFileName_u# " );
181 aString = ::rtl::OUStringToOString( str, RTL_TEXTENCODING_ASCII_US );
182 printf( "%s\n", aString.getStr( ) );
183 }
184
185 /** print a ASCII_CODE file name.
186 */
printFileName(const sal_Char * str)187 inline void printFileName( const sal_Char * str )
188 {
189 printf( "#printFileName_a# " );
190 printf( "%s\n", str );
191 }
192
193 /** print an output wrong message.
194 */
printError(const::osl::FileBase::RC nError)195 inline void printError( const ::osl::FileBase::RC nError )
196 {
197 printf( "#printError# " );
198 printFileName( errorToStr(nError) );
199 }
200
201 /** print an signed Integer Number.
202 */
printInt(sal_Int64 i)203 inline void printInt( sal_Int64 i )
204 {
205 printf( "#printInt_i64# " );
206 printf( "The Integer64 is %lld\n", i);
207 }
208
209 /** print an unsigned Integer Number.
210 */
printInt(sal_uInt64 i)211 inline void printInt( sal_uInt64 i )
212 {
213 printf( "#printInt_u64# " );
214 printf( "The unsigned Integer64 is %llu\n", i);
215 }
216
217 /** print Boolean value.
218 */
printBool(sal_Bool bOk)219 inline void printBool( sal_Bool bOk )
220 {
221 printf( "#printBool# " );
222 ( sal_True == bOk ) ? printf( "YES!\n" ): printf( "NO!\n" );
223 }
224
225 /** print struct TimeValue in local time format.
226 */
printTime(TimeValue * tv)227 inline void printTime( TimeValue *tv )
228 {
229 oslDateTime *pDateTime = ( oslDateTime* )malloc( sizeof( oslDateTime ) ) ;
230 ASSERT_TRUE(pDateTime != NULL) << "Error in printTime() function,malloc ";
231 TimeValue *pLocalTV = ( TimeValue* )malloc( sizeof( TimeValue ) );
232 ASSERT_TRUE(pLocalTV != NULL) << "Error in printTime() function,malloc ";
233
234 ASSERT_TRUE(sal_True == osl_getLocalTimeFromSystemTime( tv, pLocalTV )) << "Error in printTime() function,osl_getLocalTimeFromSystemTime ";
235 ASSERT_TRUE(sal_True == osl_getDateTimeFromTimeValue( pLocalTV, pDateTime )) << "Error in printTime() function,osl_gepDateTimeFromTimeValue ";
236
237 printf( "#printTime# " );
238 printf( " Time is: %d/%d/%d ", pDateTime->Month, pDateTime->Day, pDateTime->Year);
239 switch ( pDateTime->DayOfWeek )
240 {
241 case 0: printf("Sun. "); break;
242 case 1: printf("Mon. "); break;
243 case 2: printf("Tue. "); break;
244 case 3: printf("Thr. "); break;
245 case 4: printf("Wen. "); break;
246 case 5: printf("Fri. "); break;
247 case 6: printf("Sat. "); break;
248 }
249 printf( " %d:%d:%d %d nsecs\n", pDateTime->Hours, pDateTime->Minutes, pDateTime->Seconds, pDateTime->NanoSeconds);
250
251 free( pDateTime );
252 free( pLocalTV );
253 }
254
255 /** compare two TimeValue, unit is "ms", since Windows time precision is better than UNX.
256 */
257
258 #if ( defined UNX ) || ( defined OS2 ) //precision of time in Windows is better than UNX
259 # define delta 2000 //time precision, 2000ms
260 #else
261 # define delta 1800 //time precision, 1.8s
262 #endif
263
t_abs64(sal_Int64 _nValue)264 inline sal_Int64 t_abs64(sal_Int64 _nValue)
265 {
266 // std::abs() seems to have some ambiguity problems (so-texas)
267 // return abs(_nValue);
268 printf("t_abs64(%ld)\n", _nValue);
269 // ASSERT_TRUE(_nValue < 2147483647);
270
271 if (_nValue < 0)
272 {
273 _nValue = -_nValue;
274 }
275 return _nValue;
276 }
277
t_compareTime(TimeValue * m_aEndTime,TimeValue * m_aStartTime,sal_Int32 nDelta)278 inline sal_Bool t_compareTime( TimeValue *m_aEndTime, TimeValue *m_aStartTime, sal_Int32 nDelta)
279 {
280 // sal_uInt64 uTimeValue;
281 // sal_Int64 iTimeValue;
282 //
283 // iTimeValue = t_abs64(( tv1->Seconds - tv2->Seconds) * 1000000000 + tv1->Nanosec - tv2->Nanosec);
284 // uTimeValue = ( iTimeValue / 1000000 );
285
286 sal_Int32 nDeltaSeconds = m_aEndTime->Seconds - m_aStartTime->Seconds;
287 sal_Int32 nDeltaNanoSec = sal_Int32(m_aEndTime->Nanosec) - sal_Int32(m_aStartTime->Nanosec);
288 if (nDeltaNanoSec < 0)
289 {
290 nDeltaNanoSec = 1000000000 + nDeltaNanoSec;
291 nDeltaSeconds--;
292 }
293
294 sal_Int32 nDeltaMilliSec = (nDeltaSeconds * 1000) + (nDeltaNanoSec / 1000000);
295 return ( nDeltaMilliSec < nDelta );
296 }
297
298 /** compare two OUString file name.
299 */
compareFileName(const::rtl::OUString & ustr1,const::rtl::OUString & ustr2)300 inline sal_Bool compareFileName( const ::rtl::OUString & ustr1, const ::rtl::OUString & ustr2 )
301 {
302 sal_Bool bOk;
303 //on Windows, the seperatar is '\', so here change to '/', then compare
304 #if defined (WNT )
305 ::rtl::OUString ustr1new,ustr2new;
306 sal_Unicode reverseSlash = (sal_Unicode)'\\';
307
308 if (ustr1.lastIndexOf(reverseSlash) != -1)
309 ustr1new = ustr1.replace(reverseSlash,(sal_Unicode)'/');
310 else
311 ustr1new = ustr1;
312 if (ustr2.lastIndexOf(reverseSlash) != -1)
313 ustr2new = ustr2.replace(reverseSlash,(sal_Unicode)'/');
314 else
315 ustr2new = ustr2;
316 bOk = ustr1new.equalsIgnoreAsciiCase( ustr2new ) ;
317 #else
318 bOk = ustr1.equalsIgnoreAsciiCase( ustr2 );
319 #endif
320 return bOk;
321 }
322
323 /** compare a OUString and an ASCII file name.
324 */
compareFileName(const::rtl::OUString & ustr,const sal_Char * astr)325 inline sal_Bool compareFileName( const ::rtl::OUString & ustr, const sal_Char *astr )
326 {
327 (void)ustr;
328 ::rtl::OUString ustr1 = rtl::OUString::createFromAscii( astr );
329 sal_Bool bOk = ustr1.equalsIgnoreAsciiCase( ustr1 );
330
331 return bOk;
332 }
333
334 /** simple version to judge if a file name or directory name is a URL or a system path, just to see if it
335 is start with "file:///";.
336 */
isURL(const sal_Char * pathname)337 inline sal_Bool isURL( const sal_Char *pathname )
338 {
339 return ( 0 == strncmp( pathname, FILE_PREFIX, sizeof( FILE_PREFIX ) - 1 ) );
340 }
341
342 /** simple version to judge if a file name or directory name is a URL or a system path, just to see if it
343 is start with "file:///";.
344 */
isURL(const::rtl::OUString pathname)345 inline sal_Bool isURL( const ::rtl::OUString pathname )
346 {
347 return ( ( pathname.indexOf( aPreURL ) == 0 ) ? sal_True : sal_False );
348 }
349
350 /** concat two part to form a URL or system path, add PATH_SEPERATOR between them if necessary, add "file:///" to beginning if necessary.
351 */
concatURL(::rtl::OUString & pathname1,const::rtl::OUString & pathname2)352 inline void concatURL( ::rtl::OUString & pathname1, const ::rtl::OUString & pathname2 )
353 {
354 //check if pathname1 is full qualified URL;
355 if ( !isURL( pathname1 ) )
356 {
357 ::rtl::OUString aPathName = pathname1.copy( 0 );
358 ::osl::FileBase::getFileURLFromSystemPath( pathname1, aPathName ); //convert if not full qualified URL
359 pathname1 = aPathName.copy( 0 );
360 }
361
362 sal_Int32 index = 0;
363 //check if '/' is in the end of pathname1 or at the begin of pathname2;
364 if ( ( ( index = pathname1.lastIndexOf( aSlashURL ) ) != ( pathname1.getLength( ) - 1 ) ) &&
365 ( ( index = pathname2.indexOf( aSlashURL ) ) != 0 ) )
366 pathname1 += aSlashURL;
367 pathname1 += pathname2;
368 }
369
370 /** create a temp test file using OUString name of full qualified URL or system path.
371 */
createTestFile(const::rtl::OUString filename)372 inline void createTestFile( const ::rtl::OUString filename )
373 {
374 ::rtl::OUString aPathURL = filename.copy( 0 );
375 ::osl::FileBase::RC nError;
376
377 if ( !isURL( filename ) )
378 ::osl::FileBase::getFileURLFromSystemPath( filename, aPathURL ); //convert if not full qualified URL
379
380 //::std::auto_ptr<File> pFile( new File( aPathURL ) );
381 File aFile(aPathURL);
382 //nError = pFile->open( OpenFlag_Read | OpenFlag_Write | OpenFlag_Create );
383 nError = aFile.open( OpenFlag_Read | OpenFlag_Write | OpenFlag_Create );
384 //ASSERT_TRUE(( ::osl::FileBase::E_None == nError ) || ( nError == ::osl::FileBase::E_EXIST )) << "In createTestFile Function: creation ";
385 if ( ( ::osl::FileBase::E_None != nError ) && ( nError != ::osl::FileBase::E_EXIST ))
386 {
387 printf("createTestFile failed!\n");
388 }
389 aFile.close();
390
391 }
392
393 /** create a temp test file using OUString name of full qualified URL or system path in a base directory.
394 */
createTestFile(const::rtl::OUString basename,const::rtl::OUString filename)395 inline void createTestFile( const ::rtl::OUString basename, const ::rtl::OUString filename )
396 {
397 ::rtl::OUString aBaseURL = basename.copy( 0 );
398
399 concatURL( aBaseURL, filename );
400 createTestFile( aBaseURL );
401 }
402
403 /** detete a temp test file using OUString name.
404 */
deleteTestFile(const::rtl::OUString filename)405 inline void deleteTestFile( const ::rtl::OUString filename )
406 {
407 // LLA: printf("deleteTestFile\n");
408 ::rtl::OUString aPathURL = filename.copy( 0 );
409 ::osl::FileBase::RC nError;
410
411 if ( !isURL( filename ) )
412 ::osl::FileBase::getFileURLFromSystemPath( filename, aPathURL ); //convert if not full qualified URL
413
414 nError = ::osl::File::setAttributes( aPathURL, Attribute_GrpWrite| Attribute_OwnWrite| Attribute_OthWrite ); // if readonly, make writtenable.
415 ASSERT_TRUE(( ::osl::FileBase::E_None == nError ) || ( ::osl::FileBase::E_NOENT == nError )) << "In deleteTestFile Function: set writtenable ";
416
417 nError = ::osl::File::remove( aPathURL );
418 ASSERT_TRUE(( ::osl::FileBase::E_None == nError ) || ( nError == ::osl::FileBase::E_NOENT )) << "In deleteTestFile Function: remove ";
419 }
420
421 /** delete a temp test file using OUString name of full qualified URL or system path in a base directory.
422 */
deleteTestFile(const::rtl::OUString basename,const::rtl::OUString filename)423 inline void deleteTestFile( const ::rtl::OUString basename, const ::rtl::OUString filename )
424 {
425 ::rtl::OUString aBaseURL = basename.copy( 0 );
426
427 concatURL( aBaseURL, filename );
428 deleteTestFile( aBaseURL );
429 }
430
431 /** create a temp test directory using OUString name of full qualified URL or system path.
432 */
createTestDirectory(const::rtl::OUString dirname)433 inline void createTestDirectory( const ::rtl::OUString dirname )
434 {
435 ::rtl::OUString aPathURL = dirname.copy( 0 );
436 ::osl::FileBase::RC nError;
437
438 if ( !isURL( dirname ) )
439 ::osl::FileBase::getFileURLFromSystemPath( dirname, aPathURL ); //convert if not full qualified URL
440 nError = ::osl::Directory::create( aPathURL );
441 //ASSERT_TRUE(( ::osl::FileBase::E_None == nError ) || ( nError == ::osl::FileBase::E_EXIST )) << "In createTestDirectory Function: creation: ";
442 if ( ( ::osl::FileBase::E_None != nError ) && ( nError != ::osl::FileBase::E_EXIST ))
443 printf("createTestDirectory failed!\n");
444 }
445
446 /** create a temp test directory using OUString name of full qualified URL or system path in a base directory.
447 */
createTestDirectory(const::rtl::OUString basename,const::rtl::OUString dirname)448 inline void createTestDirectory( const ::rtl::OUString basename, const ::rtl::OUString dirname )
449 {
450 ::rtl::OUString aBaseURL = basename.copy( 0 );
451 ::rtl::OString aString;
452
453 concatURL( aBaseURL, dirname );
454 createTestDirectory( aBaseURL );
455 }
456
457 /** delete a temp test directory using OUString name of full qualified URL or system path.
458 */
deleteTestDirectory(const::rtl::OUString dirname)459 inline void deleteTestDirectory( const ::rtl::OUString dirname )
460 {
461 // LLA: printf("deleteTestDirectory\n");
462 ::rtl::OUString aPathURL = dirname.copy( 0 );
463 ::osl::FileBase::RC nError;
464 // LLA: printFileName(aPathURL);
465 if ( !isURL( dirname ) )
466 ::osl::FileBase::getFileURLFromSystemPath( dirname, aPathURL ); //convert if not full qualified URL
467
468 ::osl::Directory testDir( aPathURL );
469 if ( testDir.isOpen( ) == sal_True )
470 {
471 // LLA: printf("#close Dir\n");
472 testDir.close( ); //close if still open.
473 }
474
475 nError = ::osl::Directory::remove( aPathURL );
476 // LLA: printError(nError);
477 // LLA: if (( ::osl::FileBase::E_None == nError ))
478 // LLA: {
479 // LLA: printf("nError == E_None\n");
480 // LLA: }
481 // LLA: else if ( ( nError == ::osl::FileBase::E_NOENT ))
482 // LLA: {
483 // LLA: printf("nError == E_NOENT\n");
484 // LLA: }
485 // LLA: else
486 // LLA: {
487 // LLA: // printf("nError == %d\n", nError);
488 // LLA: }
489 rtl::OUString strError = rtl::OUString::createFromAscii( "In deleteTestDirectory function: remove Directory ");
490 strError += aPathURL;
491 EXPECT_TRUE(( ::osl::FileBase::E_None == nError ) || ( nError == ::osl::FileBase::E_NOENT )) << strError.pData;
492 // LLA: if (! ( ::osl::FileBase::E_None == nError ) || ( nError == ::osl::FileBase::E_NOENT ))
493 // LLA: {
494 // LLA: printf("In deleteTestDirectory function: remove\n");
495 // LLA: }
496 }
497
498 /** delete a temp test directory using OUString name of full qualified URL or system path in a base directory.
499 */
deleteTestDirectory(const::rtl::OUString basename,const::rtl::OUString dirname)500 inline void deleteTestDirectory( const ::rtl::OUString basename, const ::rtl::OUString dirname )
501 {
502 ::rtl::OUString aBaseURL = basename.copy( 0 );
503
504 concatURL( aBaseURL, dirname );
505 deleteTestDirectory( aBaseURL );
506 }
507
508
509 /** Check for the file and directory access right.
510 */
511 typedef enum {
512 osl_Check_Mode_Exist,
513 osl_Check_Mode_OpenAccess,
514 osl_Check_Mode_ReadAccess,
515 osl_Check_Mode_WriteAccess
516 } oslCheckMode;
517
518 // not used here
checkFile(const::rtl::OUString & str,oslCheckMode nCheckMode)519 inline sal_Bool checkFile( const ::rtl::OUString & str, oslCheckMode nCheckMode )
520 {
521 ::osl::FileBase::RC nError1, nError2;
522 ::osl::File testFile( str );
523 sal_Bool bCheckResult;
524
525 bCheckResult = sal_False;
526 nError1 = testFile.open ( OpenFlag_Read );
527 if ( ( ::osl::FileBase::E_NOENT != nError1 ) && ( ::osl::FileBase::E_ACCES != nError1 ) ){
528
529 switch ( nCheckMode ) {
530 case osl_Check_Mode_Exist:
531 /// check if the file is exist.
532 if ( ::osl::FileBase::E_None == nError1 )
533 bCheckResult = sal_True;
534 break;
535 case osl_Check_Mode_OpenAccess:
536 /// check if the file is openable.
537 if ( ::osl::FileBase::E_None == nError1 )
538 bCheckResult = sal_True;
539 break;
540 case osl_Check_Mode_WriteAccess:
541 /// check the file name and whether it can be write.
542 /// write chars into the file.
543 //testFile.close( );
544 //testFile.open( OpenFlag_Write );
545 sal_uInt64 nCount_write;
546 nError2 = testFile.write( pBuffer_Char, 10, nCount_write );
547 if ( ::osl::FileBase::E_None == nError2 )
548 bCheckResult = sal_True;
549 break;
550
551 default:
552 bCheckResult = sal_False;
553 }/// swith
554
555 nError2 = testFile.close( );
556 EXPECT_TRUE(nError2 == FileBase::E_None) << " in CheckFile() function, close file ";
557
558 }
559
560 return bCheckResult;
561 }
562
563 //check if the file exist
ifFileExist(const::rtl::OUString & str)564 inline sal_Bool ifFileExist( const ::rtl::OUString & str )
565 {
566 sal_Bool bCheckResult = sal_False;
567
568 /*#ifdef WNT
569 ::rtl::OUString aUStr = str.copy( 0 );
570 if ( isURL( str ) )
571 ::osl::FileBase::getSystemPathFromFileURL( str, aUStr );
572
573 ::rtl::OString aString = ::rtl::OUStringToOString( aUStr, RTL_TEXTENCODING_ASCII_US );
574 const char *path = aString.getStr( );
575 if (( _access( path, 0 ) ) != -1 )
576 bCheckResult = sal_True;
577 #else*/
578 ::rtl::OString aString = ::rtl::OUStringToOString( str, RTL_TEXTENCODING_ASCII_US );
579 // const char *path = aString.getStr( );
580 ::osl::File testFile( str );
581 bCheckResult = ( osl::FileBase::E_None == testFile.open( OpenFlag_Read ) );
582 //if (bCheckResult)
583 //printf("%s exist!\n", path);
584 //else
585 //printf("%s not exist!\n", path);
586 //#endif
587 return bCheckResult;
588
589 }
590
591 //check if the file can be written
ifFileCanWrite(const::rtl::OUString & str)592 inline sal_Bool ifFileCanWrite( const ::rtl::OUString & str )
593 {
594 sal_Bool bCheckResult = sal_False;
595 //on Windows, the file has no write right, but can be written
596 #ifdef WNT
597 ::rtl::OUString aUStr = str.copy( 0 );
598 if ( isURL( str ) )
599 ::osl::FileBase::getSystemPathFromFileURL( str, aUStr );
600
601 ::rtl::OString aString = ::rtl::OUStringToOString( aUStr, RTL_TEXTENCODING_ASCII_US );
602 const char *path = aString.getStr( );
603 if (( _access( path, 2 ) ) != -1 )
604 bCheckResult = sal_True;
605 //on UNX, just test if open success with OpenFlag_Write
606 #else
607 ::osl::File testFile( str );
608 bCheckResult = (osl::FileBase::E_None == testFile.open( OpenFlag_Write ));
609 #endif
610 return bCheckResult;
611 }
612
checkDirectory(const::rtl::OUString & str,oslCheckMode nCheckMode)613 inline sal_Bool checkDirectory( const ::rtl::OUString & str, oslCheckMode nCheckMode )
614 {
615 rtl::OUString aUString;
616 DirectoryItem rItem;
617 FileBase::RC rc;
618 sal_Bool bCheckResult= sal_False;
619
620 //::std::auto_ptr<Directory> pDir( new Directory( str ) );
621 Directory aDir( str );
622 rc = aDir.open( );
623
624 if ( ( ::osl::FileBase::E_NOENT != rc ) && ( ::osl::FileBase::E_ACCES != rc ) ){
625
626 switch ( nCheckMode ) {
627 case osl_Check_Mode_Exist:
628 if ( rc == ::osl::FileBase::E_None )
629 bCheckResult = sal_True;
630 break;
631 case osl_Check_Mode_OpenAccess:
632 if ( rc == ::osl::FileBase::E_None )
633 bCheckResult = sal_True;
634 break;
635 case osl_Check_Mode_ReadAccess:
636 //rc = pDir->getNextItem( rItem, 0 );
637 rc = aDir.getNextItem( rItem, 0 );
638 if ( ( rc == ::osl::FileBase::E_None ) || ( rc == ::osl::FileBase::E_NOENT ) )
639 bCheckResult = sal_True;
640 else
641 bCheckResult = sal_False;
642 break;
643 case osl_Check_Mode_WriteAccess:
644 ( ( aUString += str ) += aSlashURL ) += aTmpName2;
645 //if ( ( rc = pDir->create( aUString ) ) == ::osl::FileBase::E_None )
646 if ( ( rc = Directory::create( aUString ) ) == ::osl::FileBase::E_None )
647 {
648 bCheckResult = sal_True;
649 //rc = pDir->remove( aUString );
650 rc = Directory::remove( aUString );
651 EXPECT_TRUE( rc == ::osl::FileBase::E_None );
652 }
653 else
654 bCheckResult = sal_False;
655 break;
656
657 default:
658 bCheckResult = sal_False;
659 }// switch
660
661 rc = aDir.close( );
662 EXPECT_TRUE( rc == FileBase::E_None );
663
664 }//if
665
666 return bCheckResult;
667 }
668
669 /** construct error message
670 */
outputError(const::rtl::OUString & returnVal,const::rtl::OUString & rightVal,const sal_Char * msg="")671 inline ::rtl::OUString outputError( const ::rtl::OUString & returnVal, const ::rtl::OUString & rightVal, const sal_Char * msg = "")
672 {
673 ::rtl::OUString aUString;
674 if ( returnVal.equals( rightVal ) )
675 return aUString;
676 aUString += ::rtl::OUString::createFromAscii(msg);
677 aUString += ::rtl::OUString::createFromAscii(": the returned value is '");
678 aUString += returnVal;
679 aUString += ::rtl::OUString::createFromAscii("', but the value should be '");
680 aUString += rightVal;
681 aUString += ::rtl::OUString::createFromAscii("'.");
682 return aUString;
683 }
684
685 /** Change file mode, two version in UNIX and Windows;.
686 */
687 #if ( defined UNX ) || ( defined OS2 ) //chmod() method is differ in Windows
changeFileMode(::rtl::OUString & filepath,sal_Int32 mode)688 inline void changeFileMode( ::rtl::OUString & filepath, sal_Int32 mode )
689 {
690 rtl::OString aString;
691 rtl::OUString aUStr = filepath.copy( 0 );
692
693 if ( isURL( filepath ) )
694 ::osl::FileBase::getSystemPathFromFileURL( filepath, aUStr );
695 aString = ::rtl::OUStringToOString( aUStr, RTL_TEXTENCODING_ASCII_US );
696 chmod( aString.getStr( ), mode );
697 }
698 #else //Windows version
changeFileMode(::rtl::OUString & filepath,sal_Int32 mode)699 inline void changeFileMode( ::rtl::OUString & filepath, sal_Int32 mode )
700 {
701 (void)filepath;
702 (void)mode;
703 printf("this method is not implemented yet");
704 }
705 #endif
706
707 inline ::rtl::OUString getCurrentPID( void );
708
709
710
711 //------------------------------------------------------------------------
712 // Beginning of the test cases for FileBase class
713 //------------------------------------------------------------------------
714 namespace osl_FileBase
715 {
716
717 #if 0 //~ this function has been deprecated
718 //---------------------------------------------------------------------
719 // testing the method
720 // static inline RC getCanonicalName( const ::rtl::OUString& ustrRequestedURL, ::rtl::OUString& ustrValidURL )
721 //
722 // The illegal characters are ;+=[]',\"*\\<>/?:|.
723 // because getCanonicalName method is not implemented yet and will be deprecated in the future, this test is not necessary.
724 //---------------------------------------------------------------------
725
726 class getCanonicalName:public ::testing::Test
727 {
728
729 public:
730 ::osl::FileBase::RC nError;
731 };// class getCanonicalName
732
733 TEST_F(getCanonicalName, getCanonicalName_001 )
734 {
735 ::rtl::OUString aUStr_ValidURL;
736 nError = ::osl::FileBase::getCanonicalName( aCanURL1, aUStr_ValidURL );
737
738 ASSERT_TRUE(( osl::FileBase::E_None == nError ) && aUStr_ValidURL.equalsIgnoreAsciiCase( aCanURL1 )) << "test for getCanonicalName function: check valid and unused file name";
739 }
740
741 TEST_F(getCanonicalName, getCanonicalName_002 )
742 {
743 ::rtl::OUString aUStr_ValidURL;
744
745 createTestFile( aCanURL1 );
746 nError = ::osl::FileBase::getCanonicalName( aCanURL1, aUStr_ValidURL );
747 deleteTestFile( aCanURL1 );
748
749 ASSERT_TRUE(( osl::FileBase::E_None == nError ) && aUStr_ValidURL.equalsIgnoreAsciiCase( aCanURL1 )) << " test for getCanonicalName function: an existed file name, should different from the request, it did not passed(W32)(UNX)";
750 }
751
752 TEST_F(getCanonicalName, getCanonicalName_003 )
753 {
754 ::rtl::OUString aUStr_ValidURL;
755 nError = ::osl::FileBase::getCanonicalName ( aCanURL2, aUStr_ValidURL );
756
757 ASSERT_TRUE(( osl::FileBase::E_None == nError ) && aUStr_ValidURL.equalsIgnoreAsciiCase( aCanURL2 )) << " test for getCanonicalName function: invalid file name, should different from the request, it did not passed(W32)(UNX)";
758 }
759 #endif
760
761 //---------------------------------------------------------------------
762 // testing the method
763 // static inline RC getAbsoluteFileURL( const ::rtl::OUString& ustrBaseDirectoryURL,
764 // const ::rtl::OUString& ustrRelativeFileURL,
765 // ::rtl::OUString& ustrAbsoluteFileURL )
766 //---------------------------------------------------------------------
767
768 class getAbsoluteFileURL:public ::testing::Test
769 {
770 protected:
771 ::osl::FileBase aFileBase;
772 ::rtl::OUString aResultURL1, aResultURL2, aResultURL3, aResultURL4, aResultURL5, aResultURL6;
773 ::osl::FileBase::RC nError;
774 sal_Bool bOk;
775
776 public:
777 void SetUp();
778 void TearDown();
779 void check_getAbsoluteFileURL( rtl::OUString const& _suBaseURL, rtl::OString const& _sRelativeURL, ::osl::FileBase::RC _nAssumeError, rtl::OUString const& _suAssumeResultStr );
780 }; //class getAbsoluteFileURL
781
782 /* use coding format as same as getSystemPathFromFileURL*/
783 // initialization
SetUp()784 void getAbsoluteFileURL::SetUp( )
785 {
786 sal_Char pResultURL1[] = "/relative/file1";
787 sal_Char pResultURL2[] = "/relative/file2";
788 sal_Char pResultURL3[] = "/file3";
789 sal_Char pResultURL4[] = "/file4";
790 sal_Char pResultURL5[] = "/canonical.name";
791 sal_Char pResultURL6[] = "/relative/";
792 aResultURL1 = aUserDirectoryURL.concat( rtl::OUString::createFromAscii( pResultURL1 ) );
793 aResultURL2 = aUserDirectoryURL.concat( rtl::OUString::createFromAscii( pResultURL2 ) );
794 aResultURL3 = aUserDirectoryURL.concat( rtl::OUString::createFromAscii( pResultURL3 ) );
795 aResultURL4 = aUserDirectoryURL.concat( rtl::OUString::createFromAscii( pResultURL4 ) );
796 aResultURL5 = aUserDirectoryURL.concat( rtl::OUString::createFromAscii( pResultURL5 ) );
797 aResultURL6 = aUserDirectoryURL.concat( rtl::OUString::createFromAscii( pResultURL6 ) );
798 }
799
TearDown()800 void getAbsoluteFileURL::TearDown( )
801 {
802 }
803
804 // test code
TEST_F(getAbsoluteFileURL,getAbsoluteFileURL_001)805 TEST_F(getAbsoluteFileURL, getAbsoluteFileURL_001)
806 {
807 ::rtl::OUString aUStr_AbsURL;
808
809 ::osl::FileBase::RC nError11 = aFileBase.getAbsoluteFileURL( aUserDirectoryURL, aRelURL1, aUStr_AbsURL );
810 ::rtl::OUString suError = ::rtl::OUString::createFromAscii("test for getAbsoluteFileURL(' ");
811 suError += aUserDirectoryURL;
812 suError += ::rtl::OUString::createFromAscii("', '");
813 suError += aRelURL1;
814 suError += ::rtl::OUString::createFromAscii("', '");
815 suError += aUStr_AbsURL;
816 suError += outputError( aUStr_AbsURL, aResultURL1, "' ),");
817
818 sal_Bool nError12 = aUStr_AbsURL.equals( aResultURL1 );
819 ::osl::FileBase::RC nError21 = aFileBase.getAbsoluteFileURL( aUserDirectoryURL, aRelURL2, aUStr_AbsURL );
820 sal_Bool nError22 = aUStr_AbsURL.equals( aResultURL2 );
821 ::osl::FileBase::RC nError31 = aFileBase.getAbsoluteFileURL( aUserDirectoryURL, aRelURL3, aUStr_AbsURL );
822 sal_Bool nError32 = aUStr_AbsURL.equals( aResultURL3 );
823 ::osl::FileBase::RC nError41 = aFileBase.getAbsoluteFileURL( aUserDirectoryURL, aRelURL4, aUStr_AbsURL );
824 sal_Bool nError42 = aUStr_AbsURL.equals( aResultURL4 );
825 printFileName( aUStr_AbsURL );
826 printFileName( aResultURL6 );
827
828 ASSERT_TRUE(( ::osl::FileBase::E_None == nError11 ) && ( sal_True == nError12 ) &&
829 ( ::osl::FileBase::E_None == nError21 ) && ( sal_True == nError22 ) &&
830 ( ::osl::FileBase::E_None == nError31 ) && ( sal_True == nError32 ) &&
831 ( ::osl::FileBase::E_None == nError41 ) && ( sal_True == nError42 )) << "test for getAbsoluteFileURL function: valid file name with valid directory";
832 }
833
834
835 #if ( defined UNX ) || ( defined OS2 ) //Link is not defined in Windows
TEST_F(getAbsoluteFileURL,getAbsoluteFileURL_002_1)836 TEST_F(getAbsoluteFileURL, getAbsoluteFileURL_002_1)
837 {
838 ::rtl::OUString aUStr_AbsURL, aUStr_LnkFileSys( aTempDirectorySys ), aUStr_SrcFileSys( aTempDirectorySys );
839 ( ( aUStr_LnkFileSys += aSlashURL ) += getCurrentPID( ) ) += ::rtl::OUString::createFromAscii("/link.file");
840 ( ( aUStr_SrcFileSys += aSlashURL ) += getCurrentPID( ) ) += ::rtl::OUString::createFromAscii("/canonical.name");
841
842 rtl::OString strLinkFileName, strSrcFileName;
843 strLinkFileName = OUStringToOString( aUStr_LnkFileSys, RTL_TEXTENCODING_ASCII_US );
844 strSrcFileName = OUStringToOString( aUStr_SrcFileSys, RTL_TEXTENCODING_ASCII_US );
845
846 createTestFile( aCanURL1 );
847 sal_Int32 fd = symlink( strSrcFileName.getStr(), strLinkFileName.getStr() );
848 ASSERT_TRUE( fd == 0 );
849
850 nError = aFileBase.getAbsoluteFileURL( aUserDirectoryURL, aLnkURL1, aUStr_AbsURL );
851 bOk = aUStr_AbsURL.equals( aResultURL5 );
852
853 ::rtl::OUString suError = ::rtl::OUString::createFromAscii("test for getAbsoluteFileURL(' ");
854 suError += aUserDirectoryURL;
855 suError += ::rtl::OUString::createFromAscii("', '");
856 suError += aLnkURL1;
857 suError += ::rtl::OUString::createFromAscii("', '");
858 suError += aUStr_AbsURL;
859 suError += outputError( aUStr_AbsURL, aResultURL5, "' ),");
860 //printFileName(suError);
861
862 deleteTestFile( aCanURL1 );
863 fd = remove( strLinkFileName.getStr() );
864 ASSERT_TRUE( fd == 0 );
865
866 ASSERT_TRUE(( ::osl::FileBase::E_None == nError ) && ( sal_True == bOk )) << "test for getAbsoluteFileURL function: URL contain link( Solaris version )";
867 }
868 #else //Windows version
TEST_F(getAbsoluteFileURL,getAbsoluteFileURL_002_1)869 TEST_F(getAbsoluteFileURL, getAbsoluteFileURL_002_1)
870 {
871 ASSERT_TRUE(1) << "test for getAbsoluteFileURL function: URL contain link( Windows version )";
872 }
873 #endif
874
TEST_F(getAbsoluteFileURL,getAbsoluteFileURL_003_1)875 TEST_F(getAbsoluteFileURL, getAbsoluteFileURL_003_1)
876 {
877 // LLA: may be a wrong test, aTmpName1 not a real URL
878 #if 0
879 ::rtl::OUString aUStr_AbsURL;
880
881 nError = aFileBase.getAbsoluteFileURL( aTmpName1, aRelURL1, aUStr_AbsURL ); //base dir invalid error
882 ::rtl::OUString suError = ::rtl::OUString::createFromAscii("test for getAbsoluteFileURL('");
883 suError += aTmpName1;
884 suError += ::rtl::OUString::createFromAscii("', '");
885 suError += aRelURL1;
886 suError += ::rtl::OUString::createFromAscii("', '");
887 suError += aUStr_AbsURL;
888 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() ");
889
890 ASSERT_TRUE(( ::osl::FileBase::E_INVAL == nError )) << suError;
891 #endif
892 }
893
894 //use ".." in relartive path, the BasePath must exist on the file system
TEST_F(getAbsoluteFileURL,getAbsoluteFileURL_004_1)895 TEST_F(getAbsoluteFileURL, getAbsoluteFileURL_004_1)
896 {
897 //create two level directories under $Temp/PID/
898 ::rtl::OUString aUStrUpBase = aUserDirectoryURL + ::rtl::OUString::createFromAscii("/test1");
899 createTestDirectory( aUStrUpBase );
900 ::rtl::OUString aUStrBase = aUserDirectoryURL + ::rtl::OUString::createFromAscii("/test1/dir1");
901 createTestDirectory( aUStrBase );
902
903 ::rtl::OUString aUStrRelar = ::rtl::OUString::createFromAscii("../../mytestfile");
904 ::rtl::OUString aUStr_AbsURL;
905 ::rtl::OUString aResultURL6 = aUserDirectoryURL + ::rtl::OUString::createFromAscii("/mytestfile");
906
907 nError = aFileBase.getAbsoluteFileURL( aUStrBase, aUStrRelar, aUStr_AbsURL );
908 bOk = aUStr_AbsURL.equals( aResultURL6 );
909 ::rtl::OUString suError = ::rtl::OUString::createFromAscii("test for getAbsoluteFileURL('");
910 suError += aUStrBase;
911 suError += ::rtl::OUString::createFromAscii("', '");
912 suError += aUStrRelar;
913 suError += ::rtl::OUString::createFromAscii("', '");
914 suError += aUStr_AbsURL;
915 suError += outputError( aUStr_AbsURL, aResultURL6, "' ), did not pass on Win32 ");
916
917 deleteTestDirectory( aUStrBase );
918 deleteTestDirectory( aUStrUpBase );
919
920 ASSERT_TRUE(( ::osl::FileBase::E_None == nError ) && ( sal_True == bOk )) << suError.pData;
921 }
922
check_getAbsoluteFileURL(rtl::OUString const & _suBaseURL,rtl::OString const & _sRelativeURL,::osl::FileBase::RC _nAssumeError,rtl::OUString const & _suAssumeResultStr)923 void getAbsoluteFileURL::check_getAbsoluteFileURL( rtl::OUString const& _suBaseURL, rtl::OString const& _sRelativeURL, ::osl::FileBase::RC _nAssumeError, rtl::OUString const& _suAssumeResultStr )
924 {
925 rtl::OUString suRelativeURL = rtl::OStringToOUString(_sRelativeURL, RTL_TEXTENCODING_UTF8);
926 rtl::OString sBaseURL = rtl::OUStringToOString(_suBaseURL, RTL_TEXTENCODING_UTF8);
927 rtl::OUString suResultURL;
928 osl::FileBase::RC nError = FileBase::getAbsoluteFileURL( _suBaseURL, suRelativeURL, suResultURL );
929 rtl::OString sResultURL = rtl::OUStringToOString( suResultURL, RTL_TEXTENCODING_UTF8);
930 rtl::OString sError = errorToString(nError);
931 printf("getAbsoluteFileURL('%s','%s') deliver absolute URL: '%s', error '%s'\n", sBaseURL.getStr(), _sRelativeURL.getStr(),sResultURL.getStr(), sError.getStr() );
932 ASSERT_TRUE(nError == _nAssumeError) << "Assumption is wrong: error number is wrong";
933 if ( nError == ::osl::FileBase::E_None )
934 {
935 sal_Bool bStrAreEqual = _suAssumeResultStr.equals( suResultURL );
936 ASSERT_TRUE(bStrAreEqual == sal_True) << "Assumption is wrong: ResultURL is not equal to expected URL ";
937 }
938 }
939
TEST_F(getAbsoluteFileURL,getAbsoluteFileURL_001_1)940 TEST_F(getAbsoluteFileURL, getAbsoluteFileURL_001_1)
941 {
942 rtl::OUString suAssume = aUserDirectoryURL.concat( rtl::OUString::createFromAscii("/relative/file1") );
943 check_getAbsoluteFileURL( aUserDirectoryURL, "relative/file1",::osl::FileBase::E_None, suAssume );
944 }
TEST_F(getAbsoluteFileURL,getAbsoluteFileURL_001_2)945 TEST_F(getAbsoluteFileURL, getAbsoluteFileURL_001_2)
946 {
947 rtl::OUString suAssume = aUserDirectoryURL.concat( rtl::OUString::createFromAscii("/relative/file2") );
948 check_getAbsoluteFileURL( aUserDirectoryURL, "relative/./file2",::osl::FileBase::E_None, suAssume );
949 }
TEST_F(getAbsoluteFileURL,getAbsoluteFileURL_001_3)950 TEST_F(getAbsoluteFileURL, getAbsoluteFileURL_001_3)
951 {
952 rtl::OUString suAssume = aUserDirectoryURL.concat( rtl::OUString::createFromAscii("/file3") );
953 check_getAbsoluteFileURL( aUserDirectoryURL, "relative/../file3",::osl::FileBase::E_None, suAssume );
954 }
TEST_F(getAbsoluteFileURL,getAbsoluteFileURL_001_4)955 TEST_F(getAbsoluteFileURL, getAbsoluteFileURL_001_4)
956 {
957 rtl::OUString suAssume = aUserDirectoryURL.concat( rtl::OUString::createFromAscii("/file4") );
958 check_getAbsoluteFileURL( aUserDirectoryURL, "././relative/../file4",::osl::FileBase::E_None, suAssume );
959 }
TEST_F(getAbsoluteFileURL,getAbsoluteFileURL_001_5)960 TEST_F(getAbsoluteFileURL, getAbsoluteFileURL_001_5)
961 {
962 rtl::OUString suAssume;
963 #if ( defined UNX )
964 suAssume = aUserDirectoryURL.concat( rtl::OUString::createFromAscii("/relative/") );
965 #else
966 suAssume = aUserDirectoryURL.concat( rtl::OUString::createFromAscii("/relative") );
967 #endif
968 check_getAbsoluteFileURL( aUserDirectoryURL, "././relative/.",::osl::FileBase::E_None, suAssume );
969 }
TEST_F(getAbsoluteFileURL,getAbsoluteFileURL_001_6)970 TEST_F(getAbsoluteFileURL, getAbsoluteFileURL_001_6)
971 {
972 rtl::OUString suAssume = aUserDirectoryURL.concat( rtl::OUString::createFromAscii("/.relative") );
973 check_getAbsoluteFileURL( aUserDirectoryURL, "./.relative",::osl::FileBase::E_None, suAssume );
974 }
TEST_F(getAbsoluteFileURL,getAbsoluteFileURL_001_7)975 TEST_F(getAbsoluteFileURL, getAbsoluteFileURL_001_7)
976 {
977 rtl::OUString suAssume;
978 #if (defined UNX )
979 suAssume = aUserDirectoryURL.concat( rtl::OUString::createFromAscii("/.a/") );
980 #else //windows
981 suAssume = aUserDirectoryURL.concat( rtl::OUString::createFromAscii("/.a") );
982 #endif
983 check_getAbsoluteFileURL( aUserDirectoryURL, "./.a/mydir/..",::osl::FileBase::E_None, suAssume );
984 }
TEST_F(getAbsoluteFileURL,getAbsoluteFileURL_001_8)985 TEST_F(getAbsoluteFileURL, getAbsoluteFileURL_001_8)
986 {
987 rtl::OUString suAssume = aUserDirectoryURL.concat( rtl::OUString::createFromAscii("/tmp/ok") );
988 #if ( defined UNX ) || ( defined OS2 )
989 check_getAbsoluteFileURL( aUserDirectoryURL, "tmp//ok",::osl::FileBase::E_None, suAssume );
990 #else
991 check_getAbsoluteFileURL( aUserDirectoryURL, "tmp//ok",::osl::FileBase::E_INVAL, suAssume );
992 #endif
993 }
TEST_F(getAbsoluteFileURL,getAbsoluteFileURL_002)994 TEST_F(getAbsoluteFileURL, getAbsoluteFileURL_002)
995 {
996 #if ( defined UNX ) || ( defined OS2 ) //Link is not defined in Windows
997 ::rtl::OUString aUStr_AbsURL, aUStr_LnkFileSys( aTempDirectorySys ), aUStr_SrcFileSys( aTempDirectorySys );
998 ( ( aUStr_LnkFileSys += aSlashURL ) += getCurrentPID( ) ) += ::rtl::OUString::createFromAscii("/link.file");
999 ( ( aUStr_SrcFileSys += aSlashURL ) += getCurrentPID( ) ) += ::rtl::OUString::createFromAscii("/canonical.name");
1000
1001 rtl::OString strLinkFileName, strSrcFileName;
1002 strLinkFileName = OUStringToOString( aUStr_LnkFileSys, RTL_TEXTENCODING_ASCII_US );
1003 strSrcFileName = OUStringToOString( aUStr_SrcFileSys, RTL_TEXTENCODING_ASCII_US );
1004
1005 createTestFile( aCanURL1 );
1006 sal_Int32 fd = symlink( strSrcFileName.getStr(), strLinkFileName.getStr() );
1007 ASSERT_TRUE( fd == 0 );
1008 rtl::OString sLnkURL = OUStringToOString( aLnkURL1, RTL_TEXTENCODING_ASCII_US );
1009 rtl::OUString suAssume = aUserDirectoryURL.concat( rtl::OUString::createFromAscii("/canonical.name") );
1010 check_getAbsoluteFileURL( aUserDirectoryURL, sLnkURL, ::osl::FileBase::E_None, suAssume );
1011 deleteTestFile( aCanURL1 );
1012 fd = remove( strLinkFileName.getStr() );
1013 ASSERT_TRUE( fd == 0 );
1014 #endif
1015 }
1016 //please see line# 930
TEST_F(getAbsoluteFileURL,getAbsoluteFileURL_003)1017 TEST_F(getAbsoluteFileURL, getAbsoluteFileURL_003)
1018 {
1019 }
TEST_F(getAbsoluteFileURL,getAbsoluteFileURL_004)1020 TEST_F(getAbsoluteFileURL, getAbsoluteFileURL_004)
1021 {
1022 //create two level directories under $Temp/PID/
1023 ::rtl::OUString aUStrUpBase = aUserDirectoryURL + ::rtl::OUString::createFromAscii("/test1");
1024 createTestDirectory( aUStrUpBase );
1025 ::rtl::OUString aUStrBase = aUserDirectoryURL + ::rtl::OUString::createFromAscii("/test1/dir1");
1026 createTestDirectory( aUStrBase );
1027
1028 ::rtl::OUString suAssume = aUserDirectoryURL.concat( ::rtl::OUString::createFromAscii("/mytestfile") );
1029 check_getAbsoluteFileURL( aUStrBase, "../../mytestfile" , ::osl::FileBase::E_None, suAssume );
1030 deleteTestDirectory( aUStrBase );
1031 deleteTestDirectory( aUStrUpBase );
1032 }
1033 //---------------------------------------------------------------------
1034 // testing two methods:
1035 // static inline RC getSystemPathFromFileURL( const ::rtl::OUString& ustrFileURL,
1036 // ::rtl::OUString& ustrSystemPath )
1037 // static RC getFileURLFromSystemPath( const ::rtl::OUString & ustrSystemPath,
1038 // ::rtl::OUString & ustrFileURL );
1039 //---------------------------------------------------------------------
1040 class SystemPath_FileURL:public ::testing::Test
1041 {
1042 protected:
1043 //::osl::FileBase aFileBase;
1044 // ::rtl::OUString aUStr;
1045 // ::osl::FileBase::RC nError;
1046
1047 //void check_getSystemPathFromFileURL(rtl::OString const& _sURL, ::osl::FileBase::RC _nAssumeError, rtl::OString const& _sAssumeResultStr);
1048 void check_SystemPath_FileURL(rtl::OString const& _sSource, ::osl::FileBase::RC _nAssumeError, rtl::OString const& _sAssumeResultStr, sal_Bool bDirection = sal_True );
1049 void checkWNTBehaviour_getSystemPathFromFileURL(rtl::OString const& _sURL, ::osl::FileBase::RC _nAssumeError, rtl::OString const& _sWNTAssumeResultString );
1050 void checkUNXBehaviour_getSystemPathFromFileURL(rtl::OString const& _sURL, ::osl::FileBase::RC _nAssumeError, rtl::OString const& _sUnixAssumeResultString );
1051 void checkWNTBehaviour_getFileURLFromSystemPath(rtl::OString const& _sSysPath, ::osl::FileBase::RC _nAssumeError, rtl::OString const& _sWNTAssumeResultString);
1052 void checkUNXBehaviour_getFileURLFromSystemPath(rtl::OString const& _sSysPath, ::osl::FileBase::RC _nAssumeError, rtl::OString const& _sUnixAssumeResultString);
1053
1054 };// class SystemPath_FileURL
1055
1056
1057 // test code.
1058
1059 /* void getSystemPathFromFileURL::check_getSystemPathFromFileURL(rtl::OString const& _sURL, ::osl::FileBase::RC _nAssumeError, rtl::OString const& _sAssumeResultStr)
1060 {
1061 // PRE: URL as String
1062 rtl::OUString suURL;
1063 rtl::OUString suStr;
1064 suURL = rtl::OStringToOUString(_sURL, RTL_TEXTENCODING_UTF8);
1065 ::osl::FileBase::RC nError = osl::FileBase::getSystemPathFromFileURL( suURL, suStr ); // start with /
1066
1067 // if the given string is gt length 0,
1068 // we check also this string
1069 rtl::OString sStr = rtl::OUStringToOString(suStr, RTL_TEXTENCODING_UTF8);
1070 rtl::OString sError = errorToString(nError);
1071 printf("getSystemPathFromFileURL('%s') deliver system path: '%s', error '%s'\n", _sURL.getStr(), sStr.getStr(), sError.getStr() );
1072
1073 // rtl::OUString suStrEncode = rtl::Uri::encode(suStr, rtl_UriCharClassUnoParamValue, rtl_UriEncodeKeepEscapes, RTL_TEXTENCODING_UTF8);
1074 // sStr = rtl::OUStringToOString(suStr, RTL_TEXTENCODING_UTF8);
1075 // printf("UTF8: %s\n", sStr.getStr() );
1076
1077 if (_sAssumeResultStr.getLength() > 0)
1078 {
1079 sal_Bool bStrAreEqual = _sAssumeResultStr.equals(sStr);
1080 ASSERT_TRUE(nError == _nAssumeError && bStrAreEqual == sal_True) << "Assumption is wrong";
1081 }
1082 else
1083 {
1084 ASSERT_TRUE(nError == _nAssumeError) << "Assumption is wrong";
1085 }
1086 }*/
1087
1088 // if bDirection==sal_True, check getSystemPathFromFileURL
1089 // if bDirection==sal_False, check getFileURLFromSystemPath
check_SystemPath_FileURL(rtl::OString const & _sSource,::osl::FileBase::RC _nAssumeError,rtl::OString const & _sAssumeResultStr,sal_Bool bDirection)1090 void SystemPath_FileURL::check_SystemPath_FileURL(rtl::OString const& _sSource, ::osl::FileBase::RC _nAssumeError, rtl::OString const& _sAssumeResultStr, sal_Bool bDirection)
1091 {
1092 // PRE: URL as String
1093 rtl::OUString suSource;
1094 rtl::OUString suStr;
1095 suSource = rtl::OStringToOUString(_sSource, RTL_TEXTENCODING_UTF8);
1096 ::osl::FileBase::RC nError;
1097 if ( bDirection == sal_True )
1098 nError = osl::FileBase::getSystemPathFromFileURL( suSource, suStr );
1099 else
1100 nError = osl::FileBase::getFileURLFromSystemPath( suSource, suStr );
1101
1102 // if the given string is gt length 0,
1103 // we check also this string
1104 rtl::OString sStr = rtl::OUStringToOString(suStr, RTL_TEXTENCODING_UTF8);
1105 rtl::OString sError = errorToString(nError);
1106 if ( bDirection == sal_True )
1107 printf("getSystemPathFromFileURL('%s') deliver system path: '%s', error '%s'\n", _sSource.getStr(), sStr.getStr(), sError.getStr() );
1108 else
1109 printf("getFileURLFromSystemPath('%s') deliver File URL: '%s', error '%s'\n", _sSource.getStr(), sStr.getStr(), sError.getStr() );
1110
1111 // rtl::OUString suStrEncode = rtl::Uri::encode(suStr, rtl_UriCharClassUnoParamValue, rtl_UriEncodeKeepEscapes, RTL_TEXTENCODING_UTF8);
1112 // sStr = rtl::OUStringToOString(suStr, RTL_TEXTENCODING_UTF8);
1113 // printf("UTF8: %s\n", sStr.getStr() );
1114
1115 if (_sAssumeResultStr.getLength() > 0)
1116 {
1117 sal_Bool bStrAreEqual = _sAssumeResultStr.equals(sStr);
1118 ASSERT_TRUE(nError == _nAssumeError && bStrAreEqual == sal_True) << "Assumption is wrong";
1119 }
1120 else
1121 {
1122 ASSERT_TRUE(nError == _nAssumeError) << "Assumption is wrong";
1123 }
1124 }
checkWNTBehaviour_getSystemPathFromFileURL(rtl::OString const & _sURL,::osl::FileBase::RC _nAssumeError,rtl::OString const & _sWNTAssumeResultString)1125 void SystemPath_FileURL::checkWNTBehaviour_getSystemPathFromFileURL(rtl::OString const& _sURL, ::osl::FileBase::RC _nAssumeError, rtl::OString const& _sWNTAssumeResultString)
1126 {
1127 #if ( defined WNT )
1128 check_SystemPath_FileURL(_sURL, _nAssumeError, _sWNTAssumeResultString);
1129 #else
1130 (void)_sURL;
1131 (void)_nAssumeError;
1132 (void)_sWNTAssumeResultString;
1133 #endif
1134 }
1135
checkUNXBehaviour_getSystemPathFromFileURL(rtl::OString const & _sURL,::osl::FileBase::RC _nAssumeError,rtl::OString const & _sUnixAssumeResultString)1136 void SystemPath_FileURL::checkUNXBehaviour_getSystemPathFromFileURL(rtl::OString const& _sURL, ::osl::FileBase::RC _nAssumeError, rtl::OString const& _sUnixAssumeResultString)
1137 {
1138 #if ( defined UNX )
1139 check_SystemPath_FileURL(_sURL, _nAssumeError, _sUnixAssumeResultString);
1140 #else
1141 (void)_sURL;
1142 (void)_nAssumeError;
1143 (void)_sUnixAssumeResultString;
1144 #endif
1145 }
1146
checkWNTBehaviour_getFileURLFromSystemPath(rtl::OString const & _sSysPath,::osl::FileBase::RC _nAssumeError,rtl::OString const & _sWNTAssumeResultString)1147 void SystemPath_FileURL::checkWNTBehaviour_getFileURLFromSystemPath(rtl::OString const& _sSysPath, ::osl::FileBase::RC _nAssumeError, rtl::OString const& _sWNTAssumeResultString)
1148 {
1149 #if ( defined WNT )
1150 check_SystemPath_FileURL(_sSysPath, _nAssumeError, _sWNTAssumeResultString, sal_False );
1151 #else
1152 (void)_sSysPath;
1153 (void)_nAssumeError;
1154 (void)_sWNTAssumeResultString;
1155 #endif
1156 }
1157
checkUNXBehaviour_getFileURLFromSystemPath(rtl::OString const & _sSysPath,::osl::FileBase::RC _nAssumeError,rtl::OString const & _sUnixAssumeResultString)1158 void SystemPath_FileURL::checkUNXBehaviour_getFileURLFromSystemPath(rtl::OString const& _sSysPath, ::osl::FileBase::RC _nAssumeError, rtl::OString const& _sUnixAssumeResultString)
1159 {
1160 #if ( defined UNX )
1161 check_SystemPath_FileURL(_sSysPath, _nAssumeError, _sUnixAssumeResultString, sal_False );
1162 #else
1163 (void)_sSysPath;
1164 (void)_nAssumeError;
1165 (void)_sUnixAssumeResultString;
1166 #endif
1167 }
1168
1169 /** LLA: Test for getSystemPathFromFileURL()
1170 this test is splitted into 2 different OS tests,
1171 the first function checkUNXBehaviour... runs only on Unix based Systems,
1172 the second only on windows based systems
1173 the first parameter are a file URL where we want to get the system path of,
1174 the second parameter is the assumed error of the osl_getSystemPathFromFileURL() function,
1175 the third parameter is the assumed result string, the string will only test, if it's length is greater 0
1176 */
1177
TEST_F(SystemPath_FileURL,getSystemPathFromFileURL_001_1)1178 TEST_F(SystemPath_FileURL, getSystemPathFromFileURL_001_1)
1179 {
1180 rtl::OString sURL("");
1181 checkUNXBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_INVAL, "");
1182 checkWNTBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_INVAL, "");
1183 }
1184
TEST_F(SystemPath_FileURL,getSystemPathFromFileURL_001_2)1185 TEST_F(SystemPath_FileURL, getSystemPathFromFileURL_001_2)
1186 {
1187 rtl::OString sURL("/");
1188 checkUNXBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_INVAL, "");
1189 checkWNTBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, "\\");
1190 }
TEST_F(SystemPath_FileURL,getSystemPathFromFileURL_001_21)1191 TEST_F(SystemPath_FileURL, getSystemPathFromFileURL_001_21)
1192 {
1193 // rtl::OString sURL("%2f");
1194 rtl::OString sURL("%2F");
1195 checkUNXBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, "/"); // LLA: this is may be a BUG
1196 checkWNTBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_INVAL, "");
1197 }
TEST_F(SystemPath_FileURL,getSystemPathFromFileURL_001_22)1198 TEST_F(SystemPath_FileURL, getSystemPathFromFileURL_001_22)
1199 {
1200 rtl::OString sURL("file:///tmp%2Fmydir");
1201 checkUNXBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_INVAL, "");
1202 checkWNTBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_INVAL, "");
1203 }
TEST_F(SystemPath_FileURL,getSystemPathFromFileURL_001_3)1204 TEST_F(SystemPath_FileURL, getSystemPathFromFileURL_001_3)
1205 {
1206 rtl::OString sURL("a");
1207 checkUNXBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, "a");
1208 checkWNTBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, "a");
1209 }
TEST_F(SystemPath_FileURL,getSystemPathFromFileURL_001_31)1210 TEST_F(SystemPath_FileURL, getSystemPathFromFileURL_001_31)
1211 {
1212 rtl::OString sURL("tmpname");
1213 checkUNXBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, "tmpname");
1214 checkWNTBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, "tmpname");
1215 }
TEST_F(SystemPath_FileURL,getSystemPathFromFileURL_001_4)1216 TEST_F(SystemPath_FileURL, getSystemPathFromFileURL_001_4)
1217 {
1218 rtl::OString sURL("file://");
1219 checkUNXBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, "");
1220 checkWNTBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_INVAL, "");
1221 }
TEST_F(SystemPath_FileURL,getSystemPathFromFileURL_001_41)1222 TEST_F(SystemPath_FileURL, getSystemPathFromFileURL_001_41)
1223 {
1224 rtl::OString sURL("file://localhost/tmp");
1225 checkUNXBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, "");
1226 checkWNTBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_INVAL, "");
1227 }
TEST_F(SystemPath_FileURL,getSystemPathFromFileURL_001_5)1228 TEST_F(SystemPath_FileURL, getSystemPathFromFileURL_001_5)
1229 {
1230 rtl::OString sURL("file:///tmp");
1231 checkUNXBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, "/tmp");
1232 checkWNTBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_INVAL, "");
1233 }
TEST_F(SystemPath_FileURL,getSystemPathFromFileURL_001_51)1234 TEST_F(SystemPath_FileURL, getSystemPathFromFileURL_001_51)
1235 {
1236 rtl::OString sURL("file://c:/tmp");
1237 checkUNXBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, "c:/tmp"); // LLA: this is may be a BUG
1238 checkWNTBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_INVAL, "");
1239 }
TEST_F(SystemPath_FileURL,getSystemPathFromFileURL_001_52)1240 TEST_F(SystemPath_FileURL, getSystemPathFromFileURL_001_52)
1241 {
1242 rtl::OString sURL("file:///c:/tmp");
1243 checkUNXBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, "/c:/tmp");
1244 checkWNTBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, "c:\\tmp");
1245 }
TEST_F(SystemPath_FileURL,getSystemPathFromFileURL_001_53)1246 TEST_F(SystemPath_FileURL, getSystemPathFromFileURL_001_53)
1247 {
1248 // LLA: is this a legal file path?
1249 rtl::OString sURL("file:///c|/tmp");
1250 checkUNXBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, "/c|/tmp");
1251 checkWNTBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, "c:\\tmp");
1252 }
TEST_F(SystemPath_FileURL,getSystemPathFromFileURL_001_6)1253 TEST_F(SystemPath_FileURL, getSystemPathFromFileURL_001_6)
1254 {
1255 rtl::OString sURL("file:///tmp/first");
1256 checkUNXBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, "/tmp/first");
1257 checkWNTBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_INVAL, "");
1258 }
TEST_F(SystemPath_FileURL,getSystemPathFromFileURL_001_61)1259 TEST_F(SystemPath_FileURL, getSystemPathFromFileURL_001_61)
1260 {
1261 rtl::OString sURL("file:///c:/tmp/first");
1262 checkUNXBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, "/c:/tmp/first");
1263 checkWNTBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, "c:\\tmp\\first");
1264 }
TEST_F(SystemPath_FileURL,getSystemPathFromFileURL_001_7)1265 TEST_F(SystemPath_FileURL, getSystemPathFromFileURL_001_7)
1266 {
1267 rtl::OString sURL("file:///tmp/../second");
1268 checkUNXBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, "/tmp/../second"); // LLA: may be a BUG
1269 checkWNTBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_INVAL, "");
1270 }
TEST_F(SystemPath_FileURL,getSystemPathFromFileURL_001_71)1271 TEST_F(SystemPath_FileURL, getSystemPathFromFileURL_001_71)
1272 {
1273 rtl::OString sURL("file:///c:/tmp/../second");
1274 checkUNXBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, "/c:/tmp/../second");
1275 checkWNTBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, "c:\\tmp\\..\\second");
1276 }
TEST_F(SystemPath_FileURL,getSystemPathFromFileURL_001_8)1277 TEST_F(SystemPath_FileURL, getSystemPathFromFileURL_001_8)
1278 {
1279 rtl::OString sURL("../tmp");
1280 checkUNXBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, "../tmp");
1281 checkWNTBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, "..\\tmp");
1282 }
TEST_F(SystemPath_FileURL,getSystemPathFromFileURL_001_81)1283 TEST_F(SystemPath_FileURL, getSystemPathFromFileURL_001_81)
1284 {
1285 rtl::OString sURL("file://~/tmp");
1286 char* home_path;
1287 home_path = getenv("HOME");
1288 rtl::OString expResult(home_path);
1289 expResult += "/tmp";
1290 checkUNXBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, expResult );
1291 // checkWNTBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, "\\tmp");
1292 }
TEST_F(SystemPath_FileURL,getSystemPathFromFileURL_001_9)1293 TEST_F(SystemPath_FileURL, getSystemPathFromFileURL_001_9)
1294 {
1295 rtl::OString sURL("file:///tmp/first%20second");
1296 checkUNXBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, "/tmp/first second");
1297 checkWNTBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_INVAL, "");
1298 }
TEST_F(SystemPath_FileURL,getSystemPathFromFileURL_001_91)1299 TEST_F(SystemPath_FileURL, getSystemPathFromFileURL_001_91)
1300 {
1301 rtl::OString sURL("file:///c:/tmp/first%20second");
1302 checkUNXBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, "/c:/tmp/first second");
1303 checkWNTBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, "c:\\tmp\\first second");
1304 }
1305
TEST_F(SystemPath_FileURL,getSystemPathFromFileURL_001_92)1306 TEST_F(SystemPath_FileURL, getSystemPathFromFileURL_001_92)
1307 {
1308 rtl::OString sURL("ca@#;+.,$///78no%01ni..name");
1309 checkUNXBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_None, "");
1310 checkWNTBehaviour_getSystemPathFromFileURL(sURL, osl::FileBase::E_INVAL, "");
1311 }
1312
1313 #if 0
1314 TEST_F(SystemPath_FileURL, getSystemPathFromFileURL_003)
1315 {
1316 // LLA: ???
1317 //!! seems to be, that the directories do not pass together
1318 ::rtl::OUString aUStr;
1319 ::rtl::OUString aRelativeURL = ::rtl::OUString::createFromAscii("../../relartive/file3");
1320 ::rtl::OUString aResultURL ( aSysPath4 );
1321 ::osl::FileBase::RC nError = osl::FileBase::getSystemPathFromFileURL( aRelativeURL, aUStr );
1322
1323 sal_Bool bOk = compareFileName( aUStr, aResultURL );
1324
1325 ::rtl::OUString suError = ::rtl::OUString::createFromAscii("test for getSystemPathFromFileURL(");
1326 suError += aRelativeURL;
1327 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, ");
1328 suError += outputError(aUStr, aResultURL);
1329 ASSERT_TRUE(( osl::FileBase::E_None == nError ) && ( sal_True == bOk )) << suError;
1330 }
1331 #endif
1332
1333 //normal legal case
TEST_F(SystemPath_FileURL,getSystemPathFromFileURL_004)1334 TEST_F(SystemPath_FileURL, getSystemPathFromFileURL_004)
1335 {
1336 ::rtl::OUString aUStr;
1337 ::rtl::OUString aNormalURL( aTmpName6 );
1338 ::rtl::OUString aResultURL ( aSysPath4 );
1339 ::osl::FileBase::RC nError = osl::FileBase::getSystemPathFromFileURL( aNormalURL, aUStr );
1340
1341 sal_Bool bOk = compareFileName( aUStr, aResultURL );
1342
1343 ::rtl::OUString suError = ::rtl::OUString::createFromAscii("test for getSystemPathFromFileURL(' ");
1344 suError += aNormalURL;
1345 suError += ::rtl::OUString::createFromAscii(" ') function:use an absolute file URL, ");
1346 suError += outputError(aUStr, aResultURL);
1347
1348 ASSERT_TRUE(( osl::FileBase::E_None == nError ) && ( sal_True == bOk )) << suError.pData;
1349
1350 }
1351
1352 //CJK characters case
TEST_F(SystemPath_FileURL,getSystemPathFromFileURL_005)1353 TEST_F(SystemPath_FileURL, getSystemPathFromFileURL_005)
1354 {
1355 ::rtl::OUString aUStr;
1356 createTestDirectory( aTmpName10 );
1357 ::rtl::OUString aNormalURL( aTmpName10 );
1358 ::rtl::OUString aResultURL ( aSysPath5 );
1359
1360 ::osl::FileBase::RC nError = osl::FileBase::getSystemPathFromFileURL( aNormalURL, aUStr );
1361
1362 sal_Bool bOk = compareFileName( aUStr, aResultURL );
1363
1364 ::rtl::OUString suError = ::rtl::OUString::createFromAscii("test for getSystemPathFromFileURL(' ");
1365 suError += aNormalURL;
1366 suError += ::rtl::OUString::createFromAscii(" ') function:use a CJK coded absolute URL, ");
1367 suError += outputError(aUStr, aResultURL);
1368 deleteTestDirectory( aTmpName10 );
1369
1370 ASSERT_TRUE(( osl::FileBase::E_None == nError ) && ( sal_True == bOk )) << suError.pData;
1371 }
TEST_F(SystemPath_FileURL,getFileURLFromSystemPath_001)1372 TEST_F(SystemPath_FileURL, getFileURLFromSystemPath_001)
1373 {
1374 rtl::OString sSysPath("~/tmp");
1375 char* home_path;
1376 home_path = getenv("HOME");
1377 rtl::OString expResult(home_path);
1378 expResult = "file://"+ expResult + "/tmp";
1379 checkUNXBehaviour_getFileURLFromSystemPath(sSysPath, osl::FileBase::E_None, expResult );
1380 checkWNTBehaviour_getFileURLFromSystemPath(sSysPath, osl::FileBase::E_None, "~/tmp");
1381 }
TEST_F(SystemPath_FileURL,getFileURLFromSystemPath_002)1382 TEST_F(SystemPath_FileURL, getFileURLFromSystemPath_002)
1383 {
1384 rtl::OString sSysPath("c:/tmp");
1385 checkUNXBehaviour_getFileURLFromSystemPath(sSysPath, osl::FileBase::E_None, "c:/tmp");
1386 checkWNTBehaviour_getFileURLFromSystemPath(sSysPath, osl::FileBase::E_None, "file:///c:/tmp");
1387 }
TEST_F(SystemPath_FileURL,getFileURLFromSystemPath_003)1388 TEST_F(SystemPath_FileURL, getFileURLFromSystemPath_003)
1389 {
1390 rtl::OString sSysPath("file:///temp");
1391 checkUNXBehaviour_getFileURLFromSystemPath(sSysPath, osl::FileBase::E_INVAL, "");
1392 checkWNTBehaviour_getFileURLFromSystemPath(sSysPath, osl::FileBase::E_INVAL, "");
1393 }
TEST_F(SystemPath_FileURL,getFileURLFromSystemPath_004)1394 TEST_F(SystemPath_FileURL, getFileURLFromSystemPath_004)
1395 {
1396 rtl::OString sSysPath("//tmp//first start");
1397 checkUNXBehaviour_getFileURLFromSystemPath(sSysPath, osl::FileBase::E_None, "file:///tmp/first%20start");
1398 checkWNTBehaviour_getFileURLFromSystemPath(sSysPath, osl::FileBase::E_INVAL, "");
1399 }
TEST_F(SystemPath_FileURL,getFileURLFromSystemPath_005)1400 TEST_F(SystemPath_FileURL, getFileURLFromSystemPath_005)
1401 {
1402 rtl::OString sSysPath("");
1403 checkUNXBehaviour_getFileURLFromSystemPath(sSysPath, osl::FileBase::E_INVAL, "");
1404 checkWNTBehaviour_getFileURLFromSystemPath(sSysPath, osl::FileBase::E_INVAL, "");
1405 }
1406 // start with "~user", not impletment
1407 // void SystemPath_FileURL::getFileURLFromSystemPath_006()
1408
1409
1410
1411
1412 //---------------------------------------------------------------------
1413 // testing the method
1414 // static inline RC searchFileURL( const ::rtl::OUString& ustrFileName,
1415 // const ::rtl::OUString& ustrSearchPath,
1416 // ::rtl::OUString& ustrFileURL )
1417 //---------------------------------------------------------------------
1418 class searchFileURL:public ::testing::Test
1419 {
1420 protected:
1421 //::osl::FileBase aFileBase;
1422 ::rtl::OUString aUStr;
1423 ::osl::FileBase::RC nError1, nError2, nError3,nError4;
1424
1425 public:
1426 };// class searchFileURL
1427
1428 // test code.
TEST_F(searchFileURL,searchFileURL_001)1429 TEST_F(searchFileURL, searchFileURL_001 )
1430 {
1431 /* search file is passed by system filename */
1432 nError1 = ::osl::FileBase::searchFileURL( aTmpName1, aUserDirectorySys, aUStr );
1433 /* search file is passed by full qualified file URL */
1434 nError2 = ::osl::FileBase::searchFileURL( aCanURL1, aUserDirectorySys, aUStr );
1435 /* search file is passed by relative file path */
1436 nError3 = ::osl::FileBase::searchFileURL( aRelURL4, aUserDirectorySys, aUStr );
1437
1438 ASSERT_TRUE(( osl::FileBase::E_NOENT == nError1 ) &&
1439 ( osl::FileBase::E_NOENT == nError2 ) &&
1440 ( osl::FileBase::E_NOENT == nError3 )) << "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) ";
1441 }
1442
TEST_F(searchFileURL,searchFileURL_002)1443 TEST_F(searchFileURL, searchFileURL_002 )
1444 {
1445 /* search file is passed by system filename */
1446 nError1 = ::osl::FileBase::searchFileURL( aTempDirectorySys, aRootSys, aUStr );
1447 sal_Bool bOk1 = compareFileName( aUStr, aTempDirectoryURL );
1448 /* search file is passed by full qualified file URL */
1449 nError2 = ::osl::FileBase::searchFileURL( aTempDirectoryURL, aRootSys, aUStr );
1450 sal_Bool bOk2 = compareFileName( aUStr, aTempDirectoryURL );
1451 /* search file is passed by relative file path */
1452 nError3 = ::osl::FileBase::searchFileURL( aRelURL5, aRootSys, aUStr );
1453 sal_Bool bOk3 = compareFileName( aUStr, aTempDirectoryURL );
1454 /* search file is passed by an exist file */
1455 createTestFile( aCanURL1 );
1456 nError4 = ::osl::FileBase::searchFileURL( aCanURL4, aUserDirectorySys, aUStr );
1457 sal_Bool bOk4 = compareFileName( aUStr, aCanURL1 );
1458 deleteTestFile( aCanURL1 );
1459
1460 ASSERT_TRUE(( osl::FileBase::E_None == nError1 ) &&
1461 ( osl::FileBase::E_None == nError2 ) &&
1462 ( osl::FileBase::E_None == nError3 ) &&
1463 ( osl::FileBase::E_None == nError4 ) &&
1464 ( sal_True == bOk1 ) &&
1465 ( sal_True == bOk2 ) &&
1466 ( sal_True == bOk3 ) &&
1467 ( sal_True == bOk4 )) << "test for searchFileURL function: system filename/URL filename/relative path, system directory, searched file already exist.";
1468 }
1469
1470
TEST_F(searchFileURL,searchFileURL_003)1471 TEST_F(searchFileURL, searchFileURL_003 )
1472 {
1473 OSLTEST_DECLARE( SystemPathList, TEST_PLATFORM_ROOT":"TEST_PLATFORM_ROOT TEST_PLATFORM_TEMP":"TEST_PLATFORM_ROOT"system/path" );
1474 nError1 = ::osl::FileBase::searchFileURL( aUserDirectoryURL, aSystemPathList, aUStr );
1475 sal_Bool bOk = compareFileName( aUStr, aUserDirectoryURL );
1476 ASSERT_TRUE(( osl::FileBase::E_None == nError1 ) &&
1477 ( sal_True == bOk )) << "test for searchFileURL function: search directory is a list of system paths";
1478 }
1479
TEST_F(searchFileURL,searchFileURL_004)1480 TEST_F(searchFileURL, searchFileURL_004 )
1481 {
1482 OSLTEST_DECLARE( SystemPathList, TEST_PLATFORM_ROOT PATH_LIST_DELIMITER TEST_PLATFORM_ROOT TEST_PLATFORM_TEMP PATH_LIST_DELIMITER TEST_PLATFORM_ROOT "system/path/../name" );
1483 nError1 = ::osl::FileBase::searchFileURL( aUserDirectoryURL, aSystemPathList, aUStr );
1484 sal_Bool bOk = compareFileName( aUStr, aUserDirectoryURL );
1485 ASSERT_TRUE(( osl::FileBase::E_None == nError1 ) &&
1486 ( sal_True == bOk )) << "test for searchFileURL function: search directory is a list of system paths";
1487 }
1488
TEST_F(searchFileURL,searchFileURL_005)1489 TEST_F(searchFileURL, searchFileURL_005 )
1490 {
1491 nError1 = ::osl::FileBase::searchFileURL( aUserDirectoryURL, aNullURL, aUStr );
1492 sal_Bool bOk = compareFileName( aUStr, aUserDirectoryURL );
1493 ASSERT_TRUE(( osl::FileBase::E_None == nError1 ) &&
1494 ( sal_True == bOk )) << "test for searchFileURL function: search directory is NULL";
1495 }
1496
1497 //---------------------------------------------------------------------
1498 // testing the method
1499 // static inline RC getTempDirURL( ::rtl::OUString& ustrTempDirURL )
1500 //---------------------------------------------------------------------
1501 class getTempDirURL:public ::testing::Test
1502 {
1503 protected:
1504 //::osl::FileBase aFileBase;
1505 ::rtl::OUString aUStr;
1506 ::osl::FileBase::RC nError;
1507
1508 public:
1509 // initialization
SetUp()1510 void SetUp( )
1511 {
1512 nError = FileBase::getTempDirURL( aUStr );
1513 }
1514
TearDown()1515 void TearDown( )
1516 {
1517 }
1518 };// class getTempDirURL
1519
TEST_F(getTempDirURL,getTempDirURL_001)1520 TEST_F(getTempDirURL, getTempDirURL_001 )
1521 {
1522
1523 ASSERT_TRUE(( osl::FileBase::E_None == nError )) << "test for getTempDirURL function: excution";
1524 }
1525
TEST_F(getTempDirURL,getTempDirURL_002)1526 TEST_F(getTempDirURL, getTempDirURL_002 )
1527 {
1528 ASSERT_TRUE(checkDirectory( aUStr, osl_Check_Mode_OpenAccess ) &&
1529 checkDirectory( aUStr, osl_Check_Mode_ReadAccess ) &&
1530 checkDirectory( aUStr,osl_Check_Mode_WriteAccess )) << "test for getTempDirURL function: test for open and write access rights";
1531 }
1532
1533 //---------------------------------------------------------------------
1534 // testing the method
1535 // static inline RC createTempFile( ::rtl::OUString* pustrDirectoryURL,
1536 // oslFileHandle* pHandle,
1537 // ::rtl::OUString* pustrTempFileURL)
1538 //---------------------------------------------------------------------
1539 class createTempFile:public ::testing::Test
1540 {
1541 protected:
1542 //::osl::FileBase aFileBase;
1543 ::osl::FileBase::RC nError1, nError2;
1544 sal_Bool bOK;
1545
1546 oslFileHandle *pHandle;
1547 ::rtl::OUString *pUStr_DirURL;
1548 ::rtl::OUString *pUStr_FileURL;
1549
1550 public:
1551
1552 // initialization
SetUp()1553 void SetUp( )
1554 {
1555 pHandle = new oslFileHandle();
1556 pUStr_DirURL = new ::rtl::OUString( aUserDirectoryURL );
1557 pUStr_FileURL = new ::rtl::OUString();
1558 //*pUStr_DirURL = aUserDirectoryURL; /// create temp file in /tmp/PID or c:\temp\PID.*/
1559 }
1560
TearDown()1561 void TearDown( )
1562 {
1563 delete pUStr_DirURL;
1564 delete pUStr_FileURL;
1565 delete pHandle;
1566 }
1567 };// class createTempFile
1568
TEST_F(createTempFile,createTempFile_001)1569 TEST_F(createTempFile, createTempFile_001 )
1570 {
1571 nError1 = FileBase::createTempFile( pUStr_DirURL, pHandle, pUStr_FileURL );
1572 ::osl::File testFile( *pUStr_FileURL );
1573 //printFileName(*pUStr_FileURL);
1574 nError2 = testFile.open( OpenFlag_Create );
1575 if ( osl::FileBase::E_EXIST == nError2 ) {
1576 osl_closeFile( *pHandle );
1577 deleteTestFile( *pUStr_FileURL );
1578 }
1579
1580 ASSERT_TRUE(( osl::FileBase::E_None == nError1 ) && ( pHandle != NULL ) && ( osl::FileBase::E_EXIST== nError2 )) << "test for createTempFile function: create temp file and test the existence";
1581 }
1582
TEST_F(createTempFile,createTempFile_002)1583 TEST_F(createTempFile, createTempFile_002 )
1584 {
1585 bOK = sal_False;
1586 nError1 = FileBase::createTempFile( pUStr_DirURL, pHandle, pUStr_FileURL );
1587 ::osl::File testFile( *pUStr_FileURL );
1588 nError2 = testFile.open( OpenFlag_Create );
1589
1590 ASSERT_TRUE(( osl::FileBase::E_None == nError1 ) && ( pHandle != NULL ) &&
1591 ( osl::FileBase::E_EXIST == nError2 )) << "createTempFile function: create a temp file, but it does not exist";
1592
1593 //check file if have the write permission
1594 if ( osl::FileBase::E_EXIST == nError2 ) {
1595 bOK = ifFileCanWrite( *pUStr_FileURL );
1596 osl_closeFile( *pHandle );
1597 deleteTestFile( *pUStr_FileURL );
1598 }
1599
1600 ASSERT_TRUE(( sal_True == bOK )) << "test for open and write access rights, in (W32), it did not have write access right, but it should be writtenable.";
1601 }
1602
TEST_F(createTempFile,createTempFile_003)1603 TEST_F(createTempFile, createTempFile_003 )
1604 {
1605 nError1 = FileBase::createTempFile( pUStr_DirURL, pHandle, 0 );
1606 //the temp file will be removed when return from createTempFile
1607 bOK = ( pHandle != NULL && pHandle != 0);
1608 if ( sal_True == bOK )
1609 osl_closeFile( *pHandle );
1610
1611 ASSERT_TRUE(( ::osl::FileBase::E_None == nError1 ) &&( sal_True == bOK )) << "test for createTempFile function: set pUStrFileURL to 0 to let it remove the file after call.";
1612 }
TEST_F(createTempFile,createTempFile_004)1613 TEST_F(createTempFile, createTempFile_004 )
1614 {
1615 nError1 = FileBase::createTempFile( pUStr_DirURL, 0, pUStr_FileURL );
1616 bOK = ( pUStr_FileURL != 0);
1617 ::osl::File testFile( *pUStr_FileURL );
1618 nError2 = testFile.open( OpenFlag_Create );
1619 deleteTestFile( *pUStr_FileURL );
1620 ASSERT_TRUE(( osl::FileBase::E_None == nError1 ) && ( osl::FileBase::E_EXIST == nError2 ) &&( sal_True == bOK )) << "createTempFile function: create a temp file, but it does not exist";
1621
1622 }
1623
1624 }// namespace osl_FileBase
1625
1626
1627 //------------------------------------------------------------------------
1628 // Beginning of the test cases for VolumeDevice class
1629 //------------------------------------------------------------------------
1630
1631 #if 0 //~ this Class has been deprecated
1632 namespace osl_VolumeDevice
1633 {
1634
1635 //---------------------------------------------------------------------
1636 // testing the method
1637 // VolumeDevice() : _aHandle( NULL )
1638 //---------------------------------------------------------------------
1639 class VolumeDeviceCtors : public ::testing::Test
1640 {
1641 protected:
1642 ::osl::VolumeDevice aVolumeDevice;
1643 ::rtl::OUString aUStr;
1644 ::osl::FileBase::RC nError1, nError2;
1645
1646 public:
1647 // initialization
1648 void SetUp( )
1649 {
1650 }
1651
1652 void TearDown( )
1653 {
1654 }
1655 };// class ctors
1656
1657 TEST_F(VolumeDeviceCtors, ctors_001 )
1658 {
1659 ::osl::VolumeDevice aVolumeDevice1;
1660
1661 ASSERT_TRUE(( osl::FileBase::E_None != aVolumeDevice1.automount( ) ) &&
1662 ( osl::FileBase::E_None != aVolumeDevice1.unmount( ) ) &&
1663 ( aNullURL.equals( aVolumeDevice1.getMountPath( ) ) )) << "test for ctors function: Constructor for VolumeDevice with no args.";
1664 }
1665
1666 TEST_F(VolumeDeviceCtors, ctors_002 )
1667 {
1668 ::osl::VolumeInfo aVolumeInfo( VolumeInfoMask_Attributes );
1669 nError1 = ::osl::Directory::getVolumeInfo( aRootURL, aVolumeInfo );
1670 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
1671
1672 ::osl::VolumeDevice aVolumeDevice1( aVolumeInfo.getDeviceHandle( ) );
1673 sal_Bool bOk = compareFileName( aNullURL, aVolumeDevice1.getMountPath( ) );
1674 ASSERT_TRUE(sal_False == bOk) << "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).";
1675 }
1676
1677 TEST_F(VolumeDeviceCtors, ctors_003 )
1678 {
1679 ::osl::VolumeInfo aVolumeInfo( VolumeInfoMask_Attributes );
1680 nError1 = ::osl::Directory::getVolumeInfo( aRootURL, aVolumeInfo );
1681 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
1682
1683 ::osl::VolumeDevice aVolumeDevice1 = aVolumeInfo.getDeviceHandle( );
1684 sal_Bool bOk = compareFileName( aNullURL, aVolumeDevice1.getMountPath( ) );
1685 ASSERT_TRUE(sal_False == bOk) << "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).";
1686 }
1687
1688 //---------------------------------------------------------------------
1689 // testing the method
1690 // inline RC automount()
1691 //---------------------------------------------------------------------
1692 class automount : public ::testing::Test
1693 {
1694 protected:
1695 ::osl::VolumeDevice aVolumeDevice;
1696 ::rtl::OUString aUStr;
1697 ::osl::FileBase::RC nError1, nError2;
1698
1699 public:
1700 // initialization
1701 void SetUp( )
1702 {
1703 }
1704
1705 void TearDown( )
1706 {
1707
1708 }
1709 };// class automount
1710
1711 TEST_F(automount, automount_001 )
1712 {
1713 ::osl::VolumeDevice aVolumeDevice1;
1714 nError1 = aVolumeDevice1.automount( );
1715
1716 ASSERT_TRUE(( osl::FileBase::E_INVAL == nError1 )) << "test for automount function: invalid parameter.";
1717 }
1718
1719 TEST_F(automount, automount_002 )
1720 {
1721 ::osl::VolumeInfo aVolumeInfo( VolumeInfoMask_Attributes );
1722 nError1 = ::osl::Directory::getVolumeInfo( aVolURL2, aVolumeInfo );
1723 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
1724
1725 ::osl::VolumeDevice aVolumeDevice1( aVolumeInfo.getDeviceHandle( ) );
1726 nError1 = aVolumeDevice1.unmount( );
1727 nError1 = aVolumeDevice1.automount( );
1728 ASSERT_TRUE(( osl::FileBase::E_None == nError1 )) << "test for automount function: this test is not implemented yet, it did not pass in (UNX), (W32).";
1729 }
1730
1731 }// namespace osl_VolumeDevice
1732 #endif
1733
1734
1735 //------------------------------------------------------------------------
1736 // Beginning of the test cases for VolumeInfo class
1737 //------------------------------------------------------------------------
1738 namespace osl_VolumeInfo
1739 {
1740
1741 //---------------------------------------------------------------------
1742 // testing the method
1743 // VolumeInfo( sal_uInt32 nMask ): _nMask( nMask )
1744 //---------------------------------------------------------------------
1745 class VolumeInfoCtors : public ::testing::Test
1746 {
1747 protected:
1748 ::rtl::OUString aUStr;
1749 ::osl::FileBase::RC nError1, nError2;
1750
1751 ::osl::VolumeDevice aVolumeDevice1;
1752
1753 public:
1754 // initialization
SetUp()1755 void SetUp( )
1756 {
1757 }
1758
tearDown()1759 void tearDown( )
1760 {
1761 }
1762 };// class ctors
1763
TEST_F(VolumeInfoCtors,ctors_001)1764 TEST_F(VolumeInfoCtors, ctors_001 )
1765 {
1766 ::osl::VolumeInfo aVolumeInfo( 0 );
1767 nError1 = ::osl::Directory::getVolumeInfo( aRootURL, aVolumeInfo );
1768 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
1769 sal_uInt64 uiTotalSpace = aVolumeInfo.getTotalSpace( );
1770 sal_uInt32 uiMaxPathLength = aVolumeInfo.getMaxPathLength( );
1771 aUStr = aVolumeInfo.getFileSystemName( );
1772
1773 ASSERT_TRUE(( 0 == uiTotalSpace ) &&
1774 ( 0 == uiMaxPathLength ) &&
1775 sal_True == compareFileName( aUStr, aNullURL )) << "test for ctors function: mask is empty";
1776 }
1777
1778 #if ( defined UNX ) || ( defined OS2 )
TEST_F(VolumeInfoCtors,ctors_002)1779 TEST_F(VolumeInfoCtors, ctors_002 )
1780 {
1781 ::osl::VolumeInfo aVolumeInfo( VolumeInfoMask_TotalSpace |
1782 VolumeInfoMask_UsedSpace |
1783 VolumeInfoMask_FileSystemName );
1784 nError1 = ::osl::Directory::getVolumeInfo( aVolURL4, aVolumeInfo );
1785 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
1786 //ASSERT_TRUE( aVolumeInfo.isValid( mask ) );
1787 sal_uInt64 uiTotalSpace = aVolumeInfo.getTotalSpace( );
1788 sal_uInt64 uiUsedSpace = aVolumeInfo.getUsedSpace( );
1789 aUStr = aVolumeInfo.getFileSystemName( );
1790
1791 ASSERT_TRUE(( 0 != uiTotalSpace ) &&
1792 ( 0 != uiUsedSpace ) &&
1793 sal_True == compareFileName( aUStr, "nfs" )) << "test for ctors function: mask is specified as certain valid fields, and get the masked fields";
1794 }
1795 #else /// Windows version,here we can not determine whichvolume in Windows is serve as an nfs volume.
TEST_F(VolumeInfoCtors,ctors_002)1796 TEST_F(VolumeInfoCtors, ctors_002 )
1797 {
1798 ASSERT_TRUE(1 == 1) << "test for ctors function: mask is specified as certain valid fields, and get the masked fields( Windows version )";
1799 }
1800 #endif
1801
TEST_F(VolumeInfoCtors,ctors_003)1802 TEST_F(VolumeInfoCtors, ctors_003 )
1803 {
1804
1805 sal_Int32 mask1 = VolumeInfoMask_FreeSpace;
1806 ::osl::VolumeInfo aVolumeInfo1( mask1 );
1807 nError1 = ::osl::Directory::getVolumeInfo( aRootURL, aVolumeInfo1 );
1808 ASSERT_TRUE( sal_True == aVolumeInfo1.isValid( mask1 ) );
1809 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
1810
1811 sal_uInt64 uiTotalSpace1 = aVolumeInfo1.getTotalSpace( );
1812 aUStr = aVolumeInfo1.getFileSystemName( );
1813
1814 sal_Int32 mask2 = VolumeInfoMask_TotalSpace;
1815 ::osl::VolumeInfo aVolumeInfo2( mask2 );
1816 nError2 = ::osl::Directory::getVolumeInfo( aRootURL, aVolumeInfo2 );
1817 ASSERT_TRUE( sal_True == aVolumeInfo2.isValid( mask2 ) );
1818 ASSERT_TRUE( osl::FileBase::E_None == nError2 );
1819
1820 sal_uInt64 uiTotalSpace2 = aVolumeInfo2.getTotalSpace( );
1821
1822 ASSERT_TRUE(( 0 == uiTotalSpace1 ) && ( 0 != uiTotalSpace2 ) &&
1823 sal_True == compareFileName( aUStr, aNullURL )) << "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)";
1824 }
1825
1826 //---------------------------------------------------------------------
1827 // testing the method
1828 // inline sal_Bool isValid( sal_uInt32 nMask ) const
1829 //---------------------------------------------------------------------
1830 class VolumeInfoIsValid : public ::testing::Test
1831 {
1832 protected:
1833 ::osl::VolumeDevice aVolumeDevice;
1834 ::rtl::OUString aUStr;
1835 ::osl::FileBase::RC nError1, nError2;
1836
1837 public:
1838 // initialization
SetUp()1839 void SetUp( )
1840 {
1841 }
1842
TearDown()1843 void TearDown( )
1844 {
1845
1846 }
1847 };// class isValid
1848
TEST_F(VolumeInfoIsValid,isValid_001)1849 TEST_F(VolumeInfoIsValid, isValid_001 )
1850 {
1851 sal_Int32 mask = 0;
1852 ::osl::VolumeInfo aVolumeInfo( mask );
1853 nError1 = ::osl::Directory::getVolumeInfo( aVolURL4, aVolumeInfo );
1854 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
1855
1856 ASSERT_TRUE(sal_True == aVolumeInfo.isValid( mask )) << "test for isValid function: no fields specified.";
1857 }
1858
1859 #if ( defined UNX ) || ( defined OS2 )
TEST_F(VolumeInfoIsValid,isValid_002)1860 TEST_F(VolumeInfoIsValid, isValid_002 )
1861 {
1862 sal_Int32 mask = VolumeInfoMask_Attributes | VolumeInfoMask_TotalSpace | osl_VolumeInfo_Mask_UsedSpace |
1863 osl_VolumeInfo_Mask_FreeSpace | osl_VolumeInfo_Mask_MaxNameLength |
1864 osl_VolumeInfo_Mask_MaxPathLength | osl_VolumeInfo_Mask_FileSystemName;
1865 ::osl::VolumeInfo aVolumeInfo( mask );
1866 nError1 = ::osl::Directory::getVolumeInfo( aVolURL4, aVolumeInfo );
1867 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
1868
1869 ASSERT_TRUE(sal_True == aVolumeInfo.isValid( mask )) << "test for isValid function: all valid fields specified for a nfs volume.";
1870 }
1871 #else /// Windows version,here we can not determine whichvolume in Windows is serve as an nfs volume.
TEST_F(VolumeInfoIsValid,isValid_002)1872 TEST_F(VolumeInfoIsValid, isValid_002 )
1873 {
1874 ASSERT_TRUE(1 == 1) << "test for isValid function: all valid fields specified for a nfs volume.( Windows version )";
1875 }
1876 #endif
1877
TEST_F(VolumeInfoIsValid,isValid_003)1878 TEST_F(VolumeInfoIsValid, isValid_003 )
1879 {
1880 ::osl::VolumeDevice aVolumeDevice1;
1881 sal_Int32 mask = VolumeInfoMask_Attributes;
1882 ::osl::VolumeInfo aVolumeInfo( mask );
1883 nError1 = ::osl::Directory::getVolumeInfo( aVolURL1, aVolumeInfo );
1884 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
1885 sal_Bool bOk1 = aVolumeInfo.isValid( mask );
1886
1887 nError1 = ::osl::Directory::getVolumeInfo( aVolURL2, aVolumeInfo );
1888 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
1889 sal_Bool bOk2 = aVolumeInfo.isValid( mask );
1890
1891 ASSERT_TRUE(( sal_True == bOk1 ) && ( sal_True == bOk2 )) << "test for isValid function: VolumeInfoMask_Attributes, it should be valid for some volume such as /, floppy, cdrom, etc. but it did not pass";
1892 }
1893
1894 //---------------------------------------------------------------------
1895 // testing the method
1896 // inline sal_Bool getRemoteFlag() const
1897 //---------------------------------------------------------------------
1898 class getRemoteFlag : public ::testing::Test
1899 {
1900 protected:
1901 ::osl::VolumeDevice aVolumeDevice;
1902 ::rtl::OUString aUStr;
1903 ::osl::FileBase::RC nError1, nError2;
1904 };// class getRemoteFlag
1905
TEST_F(getRemoteFlag,getRemoteFlag_001)1906 TEST_F(getRemoteFlag, getRemoteFlag_001 )
1907 {
1908 sal_Int32 mask = VolumeInfoMask_Attributes;
1909 ::osl::VolumeInfo aVolumeInfo( mask );
1910 nError1 = ::osl::Directory::getVolumeInfo( aVolURL1, aVolumeInfo );
1911 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
1912 sal_Bool bOk = aVolumeInfo.getRemoteFlag( );
1913
1914 ASSERT_TRUE(( sal_False == bOk )) << "test for getRemoteFlag function: get a volume device which is not remote.";
1915 }
1916
1917 #if ( defined UNX ) || ( defined OS2 ) //remote Volume is different in Solaris and Windows
TEST_F(getRemoteFlag,getRemoteFlag_002)1918 TEST_F(getRemoteFlag, getRemoteFlag_002 )
1919 {
1920 sal_Int32 mask = VolumeInfoMask_Attributes;
1921 ::osl::VolumeInfo aVolumeInfo( mask );
1922 nError1 = ::osl::Directory::getVolumeInfo( aVolURL4, aVolumeInfo );
1923 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
1924 sal_Bool bOk = aVolumeInfo.getRemoteFlag( );
1925
1926 ASSERT_TRUE(( sal_True == bOk )) << "test for getRemoteFlag function: get a volume device which is remote( Solaris version ).";
1927 }
1928 #else //Windows version
TEST_F(getRemoteFlag,getRemoteFlag_002)1929 TEST_F(getRemoteFlag, getRemoteFlag_002 )
1930 {
1931 ASSERT_TRUE(1 == 1) << "test for getRemoteFlag function: get a volume device which is remote( Windows version )";
1932 }
1933 #endif
1934
1935 //---------------------------------------------------------------------
1936 // testing the method
1937 // inline sal_Bool getRemoveableFlag() const
1938 //---------------------------------------------------------------------
1939 class getRemoveableFlag : public ::testing::Test
1940 {
1941 protected:
1942 ::osl::FileBase::RC nError1, nError2;
1943 };// class getRemoveableFlag
1944
TEST_F(getRemoveableFlag,getRemoveableFlag_001)1945 TEST_F(getRemoveableFlag, getRemoveableFlag_001 )
1946 {
1947 sal_Int32 mask = VolumeInfoMask_Attributes;
1948 ::osl::VolumeInfo aVolumeInfo( mask );
1949 nError1 = ::osl::Directory::getVolumeInfo( aVolURL1, aVolumeInfo );
1950 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
1951 sal_Bool bOk = aVolumeInfo.getRemoveableFlag( );
1952
1953 ASSERT_TRUE(sal_False == bOk) << "test for getRemoveableFlag function: get a volume device which is not removable.";
1954 }
1955
TEST_F(getRemoveableFlag,getRemoveableFlag_002)1956 TEST_F(getRemoveableFlag, getRemoveableFlag_002 )
1957 {
1958 sal_Int32 mask = VolumeInfoMask_Attributes;
1959 ::osl::VolumeInfo aVolumeInfo( mask );
1960 nError1 = ::osl::Directory::getVolumeInfo( aVolURL2, aVolumeInfo );
1961 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
1962 sal_Bool bOk = aVolumeInfo.getRemoveableFlag( );
1963
1964 ASSERT_TRUE(sal_True == bOk) << "test for getRemoveableFlag function: get a volume device which is removable, not sure, here we use floppy disk, but it did not pass.";
1965 }
1966
1967 //---------------------------------------------------------------------
1968 // testing the method
1969 // inline sal_Bool getCompactDiscFlag() const
1970 //---------------------------------------------------------------------
1971 class getCompactDiscFlag : public ::testing::Test
1972 {
1973 protected:
1974 ::osl::FileBase::RC nError1;
1975 };// class getCompactDiscFlag
1976
TEST_F(getCompactDiscFlag,getCompactDiscFlag_001)1977 TEST_F(getCompactDiscFlag, getCompactDiscFlag_001 )
1978 {
1979 sal_Int32 mask = VolumeInfoMask_Attributes;
1980 ::osl::VolumeInfo aVolumeInfo( mask );
1981 nError1 = ::osl::Directory::getVolumeInfo( aVolURL1, aVolumeInfo );
1982 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
1983 sal_Bool bOk = aVolumeInfo.getCompactDiscFlag( );
1984
1985 ASSERT_TRUE(( sal_False == bOk )) << "test for getCompactDiscFlag function: get a volume device which is not a cdrom.";
1986 }
1987
TEST_F(getCompactDiscFlag,getCompactDiscFlag_002)1988 TEST_F(getCompactDiscFlag, getCompactDiscFlag_002 )
1989 {
1990 sal_Int32 mask = VolumeInfoMask_Attributes;
1991 ::osl::VolumeInfo aVolumeInfo( mask );
1992 nError1 = ::osl::Directory::getVolumeInfo( aVolURL6, aVolumeInfo );
1993 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
1994 sal_Bool bOk = aVolumeInfo.getCompactDiscFlag( );
1995
1996 ASSERT_TRUE(( sal_True == bOk )) << "test for getCompactDiscFlag function: get a cdrom volume device flag, it did not pass.";
1997 }
1998
1999 //---------------------------------------------------------------------
2000 // testing the method
2001 // inline sal_Bool getFloppyDiskFlag() const
2002 //---------------------------------------------------------------------
2003 class getFloppyDiskFlag : public ::testing::Test
2004 {
2005 protected:
2006 ::osl::FileBase::RC nError1;
2007 };// class getFloppyDiskFlag
2008
TEST_F(getFloppyDiskFlag,getFloppyDiskFlag_001)2009 TEST_F(getFloppyDiskFlag, getFloppyDiskFlag_001 )
2010 {
2011 sal_Int32 mask = VolumeInfoMask_Attributes;
2012 ::osl::VolumeInfo aVolumeInfo( mask );
2013 nError1 = ::osl::Directory::getVolumeInfo( aVolURL1, aVolumeInfo );
2014 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
2015 sal_Bool bOk = aVolumeInfo.getFloppyDiskFlag( );
2016
2017 ASSERT_TRUE(( sal_False == bOk )) << "test for getFloppyDiskFlag function: get a volume device which is not a floppy disk.";
2018 }
2019
TEST_F(getFloppyDiskFlag,getFloppyDiskFlag_002)2020 TEST_F(getFloppyDiskFlag, getFloppyDiskFlag_002 )
2021 {
2022 sal_Int32 mask = VolumeInfoMask_Attributes;
2023 ::osl::VolumeInfo aVolumeInfo( mask );
2024 nError1 = ::osl::Directory::getVolumeInfo( aVolURL2, aVolumeInfo );
2025 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
2026 sal_Bool bOk = aVolumeInfo.getFloppyDiskFlag( );
2027
2028 ASSERT_TRUE(( sal_True == bOk )) << "test for getFloppyDiskFlag function: get a floppy volume device flag, it did not pass.";
2029 }
2030
2031 //---------------------------------------------------------------------
2032 // testing the method
2033 // inline sal_Bool getFixedDiskFlag() const
2034 //---------------------------------------------------------------------
2035 class getFixedDiskFlag : public ::testing::Test
2036 {
2037 protected:
2038 ::osl::FileBase::RC nError1;
2039 };// class getFixedDiskFlag
2040
TEST_F(getFixedDiskFlag,getFixedDiskFlag_001)2041 TEST_F(getFixedDiskFlag, getFixedDiskFlag_001 )
2042 {
2043 sal_Int32 mask = VolumeInfoMask_Attributes;
2044 ::osl::VolumeInfo aVolumeInfo( mask );
2045 nError1 = ::osl::Directory::getVolumeInfo( aVolURL2, aVolumeInfo );
2046 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
2047 sal_Bool bOk = aVolumeInfo.getFixedDiskFlag( );
2048
2049 ASSERT_TRUE(( sal_False == bOk )) << "test for getFixedDiskFlag function: get a volume device which is not a fixed disk.";
2050 }
2051
TEST_F(getFixedDiskFlag,getFixedDiskFlag_002)2052 TEST_F(getFixedDiskFlag, getFixedDiskFlag_002 )
2053 {
2054 sal_Int32 mask = VolumeInfoMask_Attributes;
2055 ::osl::VolumeInfo aVolumeInfo( mask );
2056 nError1 = ::osl::Directory::getVolumeInfo( aVolURL1, aVolumeInfo );
2057 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
2058 sal_Bool bOk = aVolumeInfo.getFixedDiskFlag( );
2059
2060 ASSERT_TRUE(( sal_True == bOk )) << "test for getFixedDiskFlag function: get a fixed disk volume device flag, it did not pass.";
2061 }
2062
2063 //---------------------------------------------------------------------
2064 // testing the method
2065 // inline sal_Bool getRAMDiskFlag() const
2066 //---------------------------------------------------------------------
2067 class getRAMDiskFlag : public ::testing::Test
2068 {
2069 protected:
2070 ::osl::FileBase::RC nError1;
2071 };// class getRAMDiskFlag
2072
TEST_F(getRAMDiskFlag,getRAMDiskFlag_001)2073 TEST_F(getRAMDiskFlag, getRAMDiskFlag_001 )
2074 {
2075 sal_Int32 mask = VolumeInfoMask_Attributes;
2076 ::osl::VolumeInfo aVolumeInfo( mask );
2077 nError1 = ::osl::Directory::getVolumeInfo( aVolURL1, aVolumeInfo );
2078 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
2079 sal_Bool bOk = aVolumeInfo.getRAMDiskFlag( );
2080
2081 ASSERT_TRUE(( sal_False == bOk )) << "test for getRAMDiskFlag function: get a volume device which is not a RAM disk.";
2082 }
2083
TEST_F(getRAMDiskFlag,getRAMDiskFlag_002)2084 TEST_F(getRAMDiskFlag, getRAMDiskFlag_002 )
2085 {
2086 sal_Int32 mask = VolumeInfoMask_Attributes;
2087 ::osl::VolumeInfo aVolumeInfo( mask );
2088 nError1 = ::osl::Directory::getVolumeInfo( aVolURL1, aVolumeInfo );
2089 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
2090 sal_Bool bOk = aVolumeInfo.getRAMDiskFlag( );
2091
2092 ASSERT_TRUE(( sal_True == bOk )) << "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).";
2093 }
2094
2095 //---------------------------------------------------------------------
2096 // testing the method
2097 // inline sal_uInt64 getTotalSpace() const
2098 //---------------------------------------------------------------------
2099 class getTotalSpace : public ::testing::Test
2100 {
2101 protected:
2102 ::osl::FileBase::RC nError1;
2103 };// class getTotalSpace
2104
TEST_F(getTotalSpace,getTotalSpace_001)2105 TEST_F(getTotalSpace, getTotalSpace_001 )
2106 {
2107 sal_Int32 mask = VolumeInfoMask_TotalSpace;
2108 ::osl::VolumeInfo aVolumeInfo( mask );
2109 nError1 = ::osl::Directory::getVolumeInfo( aVolURL1, aVolumeInfo );
2110 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
2111 ASSERT_TRUE( sal_True == aVolumeInfo.isValid( mask ) );
2112 sal_uInt64 uiTotalSpace = aVolumeInfo.getTotalSpace( );
2113
2114 ASSERT_TRUE(0 != uiTotalSpace) << "test for getTotalSpace function: get total space of Fixed disk volume mounted on /, it should not be 0";
2115 }
2116
2117 #if defined( UNX )
TEST_F(getTotalSpace,getTotalSpace_002)2118 TEST_F(getTotalSpace, getTotalSpace_002 )
2119 {
2120 sal_Int32 mask = VolumeInfoMask_TotalSpace;
2121 ::osl::VolumeInfo aVolumeInfo( mask );
2122 nError1 = ::osl::Directory::getVolumeInfo( aVolURL3, aVolumeInfo );
2123 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
2124 ASSERT_TRUE( sal_True == aVolumeInfo.isValid( mask ) );
2125 sal_uInt64 uiTotalSpace = aVolumeInfo.getTotalSpace( );
2126
2127 ASSERT_TRUE(0 == uiTotalSpace) << "test for getTotalSpace function: get total space of /proc, it should be 0";
2128 }
2129 #else /// Windows version, in Windows, there is no /proc directory
TEST_F(getTotalSpace,getTotalSpace_002)2130 TEST_F(getTotalSpace, getTotalSpace_002 )
2131 {
2132 ASSERT_TRUE(1 == 1) << "test for getTotalSpace function:not applicable for /proc( Windows version )";
2133 }
2134 #endif
2135
2136
2137
2138 #if defined(SOLARIS)
TEST_F(getTotalSpace,getTotalSpace_003)2139 TEST_F(getTotalSpace, getTotalSpace_003 )
2140 {
2141 struct statvfs aStatFS;
2142 static const sal_Char name[] = "/";
2143
2144 memset (&aStatFS, 0, sizeof(aStatFS));
2145 statvfs( name, &aStatFS);
2146 sal_uInt64 TotalSpace = aStatFS.f_frsize * aStatFS.f_blocks ;
2147
2148 sal_Int32 mask = VolumeInfoMask_TotalSpace;
2149 ::osl::VolumeInfo aVolumeInfo( mask );
2150 nError1 = ::osl::Directory::getVolumeInfo( aVolURL1, aVolumeInfo );
2151 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
2152 ASSERT_TRUE( sal_True == aVolumeInfo.isValid( mask ) );
2153 sal_uInt64 uiTotalSpace = aVolumeInfo.getTotalSpace( );
2154
2155 ASSERT_TRUE(uiTotalSpace == TotalSpace) << "test for getTotalSpace function: get total space by hand, then compare with getTotalSpace, it did not pass";
2156 }
2157 #else /// Windows version
TEST_F(getTotalSpace,getTotalSpace_003)2158 TEST_F(getTotalSpace, getTotalSpace_003 )
2159 {
2160 ASSERT_TRUE(1 == 1) << "test for getTotalSpace function:not implemented yet( Windows version )";
2161 }
2162 #endif
2163
2164 //---------------------------------------------------------------------
2165 // testing the method
2166 // inline sal_uInt64 getFreeSpace() const
2167 //---------------------------------------------------------------------
2168 class getFreeSpace : public ::testing::Test
2169 {
2170 protected:
2171 ::osl::FileBase::RC nError1;
2172 };// class getFreeSpace
2173
TEST_F(getFreeSpace,getFreeSpace_001)2174 TEST_F(getFreeSpace, getFreeSpace_001 )
2175 {
2176 sal_Int32 mask = VolumeInfoMask_FreeSpace;
2177 ::osl::VolumeInfo aVolumeInfo( mask );
2178 nError1 = ::osl::Directory::getVolumeInfo( aVolURL1, aVolumeInfo );
2179 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
2180 ASSERT_TRUE( sal_True == aVolumeInfo.isValid( mask ) );
2181 sal_uInt64 uiFreeSpace = aVolumeInfo.getFreeSpace( );
2182
2183 ASSERT_TRUE(0 != uiFreeSpace) << "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";
2184 }
2185
2186 #if defined( UNX )
TEST_F(getFreeSpace,getFreeSpace_002)2187 TEST_F(getFreeSpace, getFreeSpace_002 )
2188 {
2189 sal_Int32 mask = VolumeInfoMask_FreeSpace;
2190 ::osl::VolumeInfo aVolumeInfo( mask );
2191 nError1 = ::osl::Directory::getVolumeInfo( aVolURL3, aVolumeInfo );
2192 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
2193 ASSERT_TRUE( sal_True == aVolumeInfo.isValid( mask ) );
2194 sal_uInt64 uiFreeSpace = aVolumeInfo.getFreeSpace( );
2195
2196 ASSERT_TRUE(0 == uiFreeSpace) << "test for getFreeSpace function: get free space of /proc, it should be 0";
2197 }
2198 #else /// Windows version, in Windows, there is no /proc directory
TEST_F(getFreeSpace,getFreeSpace_002)2199 TEST_F(getFreeSpace, getFreeSpace_002 )
2200 {
2201 ASSERT_TRUE(1 == 1) << "test for getFreeSpace function: not applicable for /proc( Windows version )";
2202 }
2203 #endif
2204
2205
2206 #if defined(SOLARIS)
TEST_F(getFreeSpace,getFreeSpace_003)2207 TEST_F(getFreeSpace, getFreeSpace_003 )
2208 {
2209 struct statvfs aStatFS;
2210 static const sal_Char name[] = "/";
2211
2212 memset (&aStatFS, 0, sizeof(aStatFS));
2213 statvfs( name, &aStatFS);
2214 sal_uInt64 FreeSpace = aStatFS.f_bfree * aStatFS.f_frsize ;
2215
2216 sal_Int32 mask = VolumeInfoMask_FreeSpace;
2217 ::osl::VolumeInfo aVolumeInfo( mask );
2218 nError1 = ::osl::Directory::getVolumeInfo( aVolURL1, aVolumeInfo );
2219 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
2220 ASSERT_TRUE( sal_True == aVolumeInfo.isValid( mask ) );
2221 sal_uInt64 uiFreeSpace = aVolumeInfo.getFreeSpace( );
2222
2223 ASSERT_TRUE(uiFreeSpace == FreeSpace) << "test for getFreeSpace function: get free space by hand, then compare with getFreeSpace, it did not pass";
2224 }
2225 #else //Windows version
TEST_F(getFreeSpace,getFreeSpace_003)2226 TEST_F(getFreeSpace, getFreeSpace_003 )
2227 {
2228 ASSERT_TRUE(1 == 1) << "test for getFreeSpace function: not implemented yet( Windows version )";
2229 }
2230 #endif
2231
2232 //---------------------------------------------------------------------
2233 // testing the method
2234 // inline sal_uInt64 getUsedSpace() const
2235 //---------------------------------------------------------------------
2236 class getUsedSpace : public ::testing::Test
2237 {
2238 protected:
2239 ::osl::FileBase::RC nError1;
2240 };// class getUsedSpace
2241
TEST_F(getUsedSpace,getUsedSpace_001)2242 TEST_F(getUsedSpace, getUsedSpace_001 )
2243 {
2244 sal_Int32 mask = VolumeInfoMask_UsedSpace;
2245 ::osl::VolumeInfo aVolumeInfo( mask );
2246 nError1 = ::osl::Directory::getVolumeInfo( aVolURL1, aVolumeInfo );
2247 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
2248 ASSERT_TRUE( sal_True == aVolumeInfo.isValid( mask ) );
2249 sal_uInt64 uiUsedSpace = aVolumeInfo.getUsedSpace( );
2250
2251 ASSERT_TRUE(0 != uiUsedSpace) << "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";
2252 }
2253
2254 #if defined( UNX )
TEST_F(getUsedSpace,getUsedSpace_002)2255 TEST_F(getUsedSpace, getUsedSpace_002 )
2256 {
2257 sal_Int32 mask = VolumeInfoMask_UsedSpace;
2258 ::osl::VolumeInfo aVolumeInfo( mask );
2259 nError1 = ::osl::Directory::getVolumeInfo( aVolURL3, aVolumeInfo );
2260 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
2261 ASSERT_TRUE( sal_True == aVolumeInfo.isValid( mask ) );
2262 sal_uInt64 uiUsedSpace = aVolumeInfo.getUsedSpace( );
2263
2264 ASSERT_TRUE(0 == uiUsedSpace) << "test for getUsedSpace function: get used space of /proc, it should be 0";
2265 }
2266 #else /// Windows version, in Windows, there is no /proc directory
TEST_F(getUsedSpace,getUsedSpace_002)2267 TEST_F(getUsedSpace, getUsedSpace_002 )
2268 {
2269 ASSERT_TRUE(1 == 1) << "test for getUsedSpace function: not applicable for /proc( Windows version )";
2270 }
2271 #endif
2272
2273
2274 #if defined(SOLARIS)
TEST_F(getUsedSpace,getUsedSpace_003)2275 TEST_F(getUsedSpace, getUsedSpace_003 )
2276 {
2277 struct statvfs aStatFS;
2278 static const sal_Char name[] = "/";
2279
2280 memset (&aStatFS, 0, sizeof(aStatFS));
2281 statvfs( name, &aStatFS);
2282 sal_uInt64 UsedSpace = ( aStatFS.f_blocks - aStatFS.f_bavail ) * aStatFS.f_frsize;
2283
2284
2285 sal_Int32 mask = VolumeInfoMask_UsedSpace;
2286 ::osl::VolumeInfo aVolumeInfo( mask );
2287 nError1 = ::osl::Directory::getVolumeInfo( aVolURL1, aVolumeInfo );
2288 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
2289 ASSERT_TRUE( sal_True == aVolumeInfo.isValid( mask ) );
2290 sal_uInt64 uiUsedSpace = aVolumeInfo.getUsedSpace( );
2291
2292 ASSERT_TRUE(uiUsedSpace == UsedSpace) << "test for getUsedSpace function: get used space by hand, then compare with getUsedSpace, it did not pass";
2293 }
2294 #else //Windows version
TEST_F(getUsedSpace,getUsedSpace_003)2295 TEST_F(getUsedSpace, getUsedSpace_003 )
2296 {
2297 ASSERT_TRUE(1 == 1) << "test for getUsedSpace function: not implemented yet( Windows version )";
2298 }
2299 #endif
2300
2301 //---------------------------------------------------------------------
2302 // testing the method
2303 // inline sal_uInt32 getMaxNameLength() const
2304 //---------------------------------------------------------------------
2305 class getMaxNameLength : public ::testing::Test
2306 {
2307 protected:
2308 ::osl::FileBase::RC nError1;
2309 };// class getMaxNameLength
2310
TEST_F(getMaxNameLength,getMaxNameLength_001)2311 TEST_F(getMaxNameLength, getMaxNameLength_001 )
2312 {
2313 sal_Int32 mask = VolumeInfoMask_MaxNameLength;
2314 ::osl::VolumeInfo aVolumeInfo( mask );
2315 nError1 = ::osl::Directory::getVolumeInfo( aVolURL1, aVolumeInfo );
2316 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
2317 ASSERT_TRUE( sal_True == aVolumeInfo.isValid( mask ) );
2318 sal_uInt32 uiMaxNameLength = aVolumeInfo.getMaxNameLength( );
2319
2320 ASSERT_TRUE(0 != uiMaxNameLength) << "test for getMaxNameLength function: get max name length of Fixed disk volume mounted on /, it should not be 0";
2321 }
2322
2323
2324 #if ( defined UNX ) || ( defined OS2 )
TEST_F(getMaxNameLength,getMaxNameLength_002)2325 TEST_F(getMaxNameLength, getMaxNameLength_002 )
2326 {
2327 struct statvfs aStatFS;
2328 static const sal_Char name[] = "/";
2329
2330 memset (&aStatFS, 0, sizeof(aStatFS));
2331 statvfs( name, &aStatFS);
2332 sal_uInt64 MaxNameLength = aStatFS.f_namemax;
2333
2334 sal_Int32 mask = VolumeInfoMask_MaxNameLength;
2335 ::osl::VolumeInfo aVolumeInfo( mask );
2336 nError1 = ::osl::Directory::getVolumeInfo( aVolURL1, aVolumeInfo );
2337 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
2338 ASSERT_TRUE( sal_True == aVolumeInfo.isValid( mask ) );
2339 sal_uInt64 uiMaxNameLength = aVolumeInfo.getMaxNameLength( );
2340
2341 ASSERT_TRUE(uiMaxNameLength == MaxNameLength) << "test for getMaxNameLength function: get max name length by hand, then compare with getMaxNameLength";
2342 }
2343 #else //Windows version
TEST_F(getMaxNameLength,getMaxNameLength_002)2344 TEST_F(getMaxNameLength, getMaxNameLength_002 )
2345 {
2346 ASSERT_TRUE(1 == 1) << "test for getMaxNameLength function: not implemented yet( Windows version )";
2347 }
2348 #endif
2349
2350 //---------------------------------------------------------------------
2351 // testing the method
2352 // inline sal_uInt32 getMaxPathLength() const
2353 //---------------------------------------------------------------------
2354 class getMaxPathLength : public ::testing::Test
2355 {
2356 protected:
2357 ::osl::FileBase::RC nError1;
2358 };// class getMaxPathLength
2359
TEST_F(getMaxPathLength,getMaxPathLength_001)2360 TEST_F(getMaxPathLength, getMaxPathLength_001 )
2361 {
2362 sal_Int32 mask = VolumeInfoMask_MaxPathLength;
2363 ::osl::VolumeInfo aVolumeInfo( mask );
2364 nError1 = ::osl::Directory::getVolumeInfo( aVolURL1, aVolumeInfo );
2365 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
2366 ASSERT_TRUE( sal_True == aVolumeInfo.isValid( mask ) );
2367 sal_uInt32 uiMaxPathLength = aVolumeInfo.getMaxPathLength( );
2368
2369 ASSERT_TRUE(0 != uiMaxPathLength) << "test for getMaxPathLength function: get max path length of Fixed disk volume mounted on /, it should not be 0";
2370 }
2371
2372
2373 #if ( defined UNX ) || ( defined OS2 )
TEST_F(getMaxPathLength,getMaxPathLength_002)2374 TEST_F(getMaxPathLength, getMaxPathLength_002 )
2375 {
2376 sal_Int32 mask = VolumeInfoMask_MaxPathLength;
2377 ::osl::VolumeInfo aVolumeInfo( mask );
2378 nError1 = ::osl::Directory::getVolumeInfo( aVolURL1, aVolumeInfo );
2379 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
2380 ASSERT_TRUE( sal_True == aVolumeInfo.isValid( mask ) );
2381 sal_uInt64 uiMaxPathLength = aVolumeInfo.getMaxPathLength( );
2382
2383 ASSERT_TRUE(uiMaxPathLength == PATH_MAX) << "test for getMaxPathLength function: get max path length by hand, then compare with getMaxPathLength";
2384 }
2385 #else //Windows version
TEST_F(getMaxPathLength,getMaxPathLength_002)2386 TEST_F(getMaxPathLength, getMaxPathLength_002 )
2387 {
2388 ASSERT_TRUE(1 == 1) << "test for getMaxPathLength function: not implemented yet( Windows version )";
2389 }
2390 #endif
2391
2392 //---------------------------------------------------------------------
2393 // testing the method
2394 // inline ::rtl::OUString getFileSystemName() const
2395 //---------------------------------------------------------------------
2396 class getFileSystemName : public ::testing::Test
2397 {
2398 protected:
2399 ::rtl::OUString aUStr;
2400 ::osl::FileBase::RC nError1;
2401 };// class getFileSystemName
2402
TEST_F(getFileSystemName,getFileSystemName_001)2403 TEST_F(getFileSystemName, getFileSystemName_001 )
2404 {
2405 sal_Int32 mask = VolumeInfoMask_FileSystemName;
2406 ::osl::VolumeInfo aVolumeInfo( mask );
2407 nError1 = ::osl::Directory::getVolumeInfo( aVolURL1, aVolumeInfo );
2408 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
2409 ASSERT_TRUE( sal_True == aVolumeInfo.isValid( mask ) );
2410 aUStr = aVolumeInfo.getFileSystemName( );
2411
2412 ASSERT_TRUE(sal_False == compareFileName( aNullURL, aUStr )) << "test for getFileSystemName function: get file system name of Fixed disk volume mounted on /, it should not be empty string";
2413 }
2414
2415
2416 #if defined(SOLARIS)
TEST_F(getFileSystemName,getFileSystemName_002)2417 TEST_F(getFileSystemName, getFileSystemName_002 )
2418 {
2419 struct statvfs aStatFS;
2420 static const sal_Char name[] = "/";
2421
2422 memset (&aStatFS, 0, sizeof(aStatFS));
2423 statvfs( name, &aStatFS);
2424 sal_Char * astrFileSystemName = aStatFS.f_basetype;
2425
2426 sal_Int32 mask = VolumeInfoMask_FileSystemName;
2427 ::osl::VolumeInfo aVolumeInfo( mask );
2428 nError1 = ::osl::Directory::getVolumeInfo( aVolURL1, aVolumeInfo );
2429 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
2430 ASSERT_TRUE( sal_True == aVolumeInfo.isValid( mask ) );
2431 aUStr = aVolumeInfo.getFileSystemName( );
2432
2433 ASSERT_TRUE(sal_True == compareFileName( aUStr, astrFileSystemName )) << "test for getFileSystemName function: get file system name by hand, then compare with getFileSystemName";
2434 }
2435 #else //Windows version
TEST_F(getFileSystemName,getFileSystemName_002)2436 TEST_F(getFileSystemName, getFileSystemName_002 )
2437 {
2438 ASSERT_TRUE(1 == 1) << "test for getFileSystemName function: not implemented yet( Windows version )";
2439 }
2440 #endif
2441
2442 //---------------------------------------------------------------------
2443 // testing the method
2444 // inline VolumeDevice getDeviceHandle() const
2445 //---------------------------------------------------------------------
2446 class getDeviceHandle : public ::testing::Test
2447 {
2448 protected:
2449 ::rtl::OUString aUStr;
2450 ::osl::FileBase::RC nError1;
2451 };// class getDeviceHandle
2452
TEST_F(getDeviceHandle,getDeviceHandle_001)2453 TEST_F(getDeviceHandle, getDeviceHandle_001 )
2454 {
2455 ::osl::VolumeInfo aVolumeInfo( VolumeInfoMask_Attributes );
2456 nError1 = ::osl::Directory::getVolumeInfo( aVolURL1, aVolumeInfo );
2457 ASSERT_TRUE( osl::FileBase::E_None == nError1 );
2458
2459 ::osl::VolumeDevice aVolumeDevice1( aVolumeInfo.getDeviceHandle( ) );
2460 sal_Bool bOk = compareFileName( aNullURL, aVolumeDevice1.getMountPath( ) );
2461
2462 ASSERT_TRUE(( sal_False == bOk )) << "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).";
2463 }
2464
2465 }// namespace osl_VolumeInfo
2466
2467
2468
2469 //------------------------------------------------------------------------
2470 // Beginning of the test cases for VolumeDevice class
2471 //------------------------------------------------------------------------
2472 namespace osl_FileStatus
2473 {
2474
2475 //---------------------------------------------------------------------
2476 // testing the method
2477 // FileStatus( sal_uInt32 nMask ): _nMask( nMask )
2478 //---------------------------------------------------------------------
2479 class FileStatusCtors : public ::testing::Test
2480 {
2481 protected:
2482 ::rtl::OUString aUStr;
2483 ::osl::FileBase::RC nError1, nError2;
2484 ::osl::DirectoryItem rItem;
2485
2486 public:
2487 // initialization
SetUp()2488 void SetUp( )
2489 {
2490 // create a tempfile in $TEMP/tmpdir/tmpname.
2491 createTestDirectory( aTmpName3 );
2492 createTestFile( aTmpName4 );
2493
2494 ::std::auto_ptr<Directory> pDir( new Directory( aTmpName3 ) );
2495 nError1 = pDir->open( );
2496 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
2497 nError1 = pDir->getNextItem( rItem, 0 );
2498 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
2499 pDir->close();
2500 /*
2501 Directory aDir( aTmpName3 );
2502 nError1 = aDir.open();
2503 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
2504 nError1 = aDir.getNextItem( rItem, 0 );
2505 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
2506 aDir.close();
2507 */
2508 }
2509
TearDown()2510 void TearDown( )
2511 {
2512 // remove the tempfile in $TEMP/tmpdir/tmpname.
2513 deleteTestFile( aTmpName4 );
2514 deleteTestDirectory( aTmpName3 );
2515 }
2516 };// class ctors
2517
TEST_F(FileStatusCtors,ctors_001)2518 TEST_F(FileStatusCtors, ctors_001 )
2519 {
2520 ::osl::FileStatus rFileStatus( FileStatusMask_All );
2521 nError1 = rItem.getFileStatus( rFileStatus );
2522 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
2523 aUStr = rFileStatus.getFileName( );
2524
2525 ASSERT_TRUE(sal_True == compareFileName( aUStr, aTmpName2)) << "test for ctors function: mask all and see the file name";
2526 }
2527
TEST_F(FileStatusCtors,ctors_002)2528 TEST_F(FileStatusCtors, ctors_002 )
2529 {
2530 ::osl::FileStatus rFileStatus( 0 );
2531 nError1 = rItem.getFileStatus( rFileStatus );
2532 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
2533 aUStr = rFileStatus.getFileName( );
2534
2535 ASSERT_TRUE(sal_True == compareFileName( aUStr, aNullURL)) << "test for ctors function: mask is empty";
2536 }
2537
2538 //---------------------------------------------------------------------
2539 // testing the method
2540 // inline sal_Bool isValid( sal_uInt32 nMask ) const
2541 //---------------------------------------------------------------------
2542 class FileStatusIsValid : public ::testing::Test
2543 {
2544 protected:
2545 ::rtl::OUString aUStr;
2546 ::osl::Directory *pDir;
2547 ::osl::DirectoryItem rItem_file, rItem_link;
2548
2549 public:
2550 // initialization
SetUp()2551 void SetUp( )
2552 {
2553 // create a tempfile in $TEMP/tmpdir/tmpname.
2554 createTestDirectory( aTmpName3 );
2555 createTestFile( aTmpName4 );
2556
2557 pDir = new Directory( aTmpName3 );
2558 //::std::auto_ptr<Directory> pDir( new Directory( aTmpName3 ) );
2559 ::osl::FileBase::RC nError1 = pDir->open( );
2560 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
2561 nError1 = pDir->getNextItem( rItem_file, 1 );
2562 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
2563 }
2564
TearDown()2565 void TearDown( )
2566 {
2567 ::osl::FileBase::RC nError1 = pDir->close( );
2568 delete pDir;
2569 ASSERT_TRUE(::osl::FileBase::E_None == nError1) << errorToStr(nError1).pData;
2570
2571 // remove the tempfile in $TEMP/tmpdir/tmpname.
2572 deleteTestFile( aTmpName4 );
2573 deleteTestDirectory( aTmpName3 );
2574 }
2575
check_FileStatus(::osl::FileStatus const & _aStatus)2576 void check_FileStatus(::osl::FileStatus const& _aStatus)
2577 {
2578 rtl::OString sStat;
2579 if (_aStatus.isValid(FileStatusMask_Type))
2580 {
2581 sStat += "type ";
2582 }
2583 if (_aStatus.isValid(FileStatusMask_Attributes))
2584 {
2585 sStat += "attributes ";
2586 }
2587 if (_aStatus.isValid(FileStatusMask_CreationTime))
2588 {
2589 sStat += "ctime ";
2590 }
2591 if (_aStatus.isValid(FileStatusMask_AccessTime))
2592 {
2593 sStat += "atime ";
2594 }
2595 if (_aStatus.isValid(FileStatusMask_ModifyTime))
2596 {
2597 sStat += "mtime ";
2598 }
2599 if (_aStatus.isValid(FileStatusMask_FileSize))
2600 {
2601 sStat += "filesize ";
2602 }
2603 if (_aStatus.isValid(FileStatusMask_FileName))
2604 {
2605 sStat += "filename ";
2606 }
2607 if (_aStatus.isValid(FileStatusMask_FileURL))
2608 {
2609 sStat += "fileurl ";
2610 }
2611 printf("mask: %s\n", sStat.getStr());
2612 }
2613 };// class ctors
2614
TEST_F(FileStatusIsValid,isValid_001)2615 TEST_F(FileStatusIsValid, isValid_001 )
2616 {
2617 sal_uInt32 mask = 0;
2618 ::osl::FileStatus rFileStatus( mask );
2619 ::osl::FileBase::RC nError1 = rItem_file.getFileStatus( rFileStatus );
2620 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
2621 sal_Bool bOk = rFileStatus.isValid( mask );
2622
2623 ASSERT_TRUE(( sal_True == bOk )) << "test for isValid function: no fields specified";
2624 }
2625
TEST_F(FileStatusIsValid,isValid_002)2626 TEST_F(FileStatusIsValid, isValid_002 )
2627 {
2628 createTestFile( aTmpName6 );
2629 sal_uInt32 mask_file = ( FileStatusMask_Type | FileStatusMask_Attributes |
2630 FileStatusMask_CreationTime | FileStatusMask_AccessTime |
2631 FileStatusMask_ModifyTime | FileStatusMask_FileSize |
2632 FileStatusMask_FileName | FileStatusMask_FileURL) ;
2633 ::osl::FileStatus rFileStatus( mask_file );
2634 ::osl::FileBase::RC nError1 = ::osl::DirectoryItem::get( aTmpName6, rItem_file );
2635 nError1 = rItem_file.getFileStatus( rFileStatus );
2636
2637 ASSERT_TRUE(::osl::FileBase::E_None == nError1) << errorToStr(nError1).pData;
2638
2639 // LLA: this is wrong, we never should try to check on all masks
2640 // only on one.
2641 // Second, it's not a bug, if a value is not valid, it's an unhandled feature.
2642
2643 // sal_Bool bOk = rFileStatus.isValid( mask_file );
2644
2645 check_FileStatus(rFileStatus);
2646 deleteTestFile( aTmpName6 );
2647
2648 // ASSERT_TRUE(// ( sal_True == bOk )) << "test for isValid function: regular file mask fields test, #FileStatusMask_CreationTime# should be valid field for regular file, but feedback is invalid";
2649 }
2650
2651 //Link is not defined in Windows, and on Linux, we can not get the directory item of the link file
2652 // LLA: we have to differ to filesystems, normal filesystems support links (EXT2, ...)
2653 // castrated filesystems don't (FAT, FAT32)
2654 // Windows NT NTFS support links, but the windows api don't :-(
2655
TEST_F(FileStatusIsValid,isValid_003)2656 TEST_F(FileStatusIsValid, isValid_003 )
2657 {
2658 #if defined ( UNX )
2659 // ::osl::FileBase::RC nError;
2660 sal_Int32 fd;
2661
2662 ::rtl::OUString aUStr_LnkFileSys( aTempDirectorySys ), aUStr_SrcFileSys( aTempDirectorySys );
2663 ( ( aUStr_LnkFileSys += aSlashURL ) += getCurrentPID( ) ) += ::rtl::OUString::createFromAscii("/tmpdir/link.file");
2664 ( ( aUStr_SrcFileSys += aSlashURL ) += getCurrentPID( ) ) += ::rtl::OUString::createFromAscii("/tmpdir/tmpname");
2665
2666 rtl::OString strLinkFileName;
2667 rtl::OString strSrcFileName;
2668 strLinkFileName = OUStringToOString( aUStr_LnkFileSys, RTL_TEXTENCODING_ASCII_US );
2669 strSrcFileName = OUStringToOString( aUStr_SrcFileSys, RTL_TEXTENCODING_ASCII_US );
2670
2671 //create a link file and link it to file "/tmp/PID/tmpdir/tmpname"
2672 fd = symlink( strSrcFileName.getStr(), strLinkFileName.getStr() );
2673 ASSERT_TRUE( fd == 0 );
2674
2675 // testDirectory is "/tmp/PID/tmpdir/"
2676 ::osl::Directory testDirectory( aTmpName3 );
2677 ::osl::FileBase::RC nError1 = testDirectory.open( );
2678 ::rtl::OUString aFileName = ::rtl::OUString::createFromAscii("link.file");
2679 sal_Bool bOk = sal_False;
2680 while (1) {
2681 nError1 = testDirectory.getNextItem( rItem_link, 4 );
2682 if (::osl::FileBase::E_None == nError1) {
2683 sal_uInt32 mask_link = FileStatusMask_FileName | FileStatusMask_LinkTargetURL;
2684 ::osl::FileStatus rFileStatus( mask_link );
2685 rItem_link.getFileStatus( rFileStatus );
2686 //printFileName( rFileStatus.getFileName( ) );
2687 if ( compareFileName( rFileStatus.getFileName( ), aFileName) == sal_True )
2688 {
2689 //printf("find the link file");
2690 if ( sal_True == rFileStatus.isValid( FileStatusMask_LinkTargetURL ) )
2691 {
2692 bOk = sal_True;
2693 break;
2694 }
2695 }
2696 }
2697 else
2698 break;
2699 };
2700
2701 fd = remove( strLinkFileName );
2702 ASSERT_TRUE( fd == 0 );
2703
2704 ASSERT_TRUE(( sal_True == bOk )) << "test for isValid function: link file, check for LinkTargetURL";
2705 #endif
2706 }
2707
TEST_F(FileStatusIsValid,isValid_004)2708 TEST_F(FileStatusIsValid, isValid_004 )
2709 {
2710 sal_uInt32 mask_file_all = FileStatusMask_All;
2711 ::osl::FileStatus rFileStatus_all( mask_file_all );
2712 ::osl::FileBase::RC nError1 = rItem_file.getFileStatus( rFileStatus_all );
2713 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
2714
2715 check_FileStatus(rFileStatus_all);
2716 // LLA: this is wrong
2717 // sal_Bool bOk1 = rFileStatus_all.isValid( mask_file_all );
2718
2719 sal_uInt32 mask_file_val = FileStatusMask_Validate;
2720 ::osl::FileStatus rFileStatus_val( mask_file_val );
2721 nError1 = rItem_file.getFileStatus( rFileStatus_val );
2722 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
2723 // sal_Bool bOk2 = rFileStatus_val.isValid( mask_file_val );
2724
2725 check_FileStatus(rFileStatus_val);
2726 // ASSERT_TRUE(// ( sal_False == bOk1 ) && ( sal_True == bOk2 )) << "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).";
2727 }
2728
2729 //---------------------------------------------------------------------
2730 // testing the method
2731 // inline Type getFileType() const
2732 //---------------------------------------------------------------------
2733 class getFileType : public ::testing::Test
2734 {
2735 protected:
2736 ::rtl::OUString aUStr;
2737 ::osl::FileBase::RC nError1, nError2;
2738
2739 ::osl::DirectoryItem m_aItem_1, m_aItem_2, m_aVolumeItem, m_aFifoItem;
2740 ::osl::DirectoryItem m_aLinkItem, m_aSocketItem, m_aSpecialItem;
2741
2742 public:
2743 // initialization
SetUp()2744 void SetUp( )
2745 {
2746 // create a tempfile: $TEMP/tmpdir/tmpname.
2747 // a tempdirectory: $TEMP/tmpdir/tmpdir.
2748 // use $ROOT/staroffice as volume ---> use dev/fd as volume.
2749 // and get their directory item.
2750 createTestDirectory( aTmpName3 );
2751 //printFileName( aTmpName2);
2752 createTestFile( aTmpName3, aTmpName2 );
2753 createTestDirectory( aTmpName3, aTmpName1 );
2754
2755 ::std::auto_ptr<Directory> pDir( new Directory( aTmpName3 ) );
2756 nError1 = pDir->open( );
2757 ASSERT_TRUE(::osl::FileBase::E_None == nError1) << "open aTmpName3 failed!";
2758 //getNextItem can not assure which item retrieved
2759 nError1 = pDir->getNextItem( m_aItem_1, 1 );
2760 ASSERT_TRUE(::osl::FileBase::E_None == nError1) << "get first item failed!";
2761
2762 nError1 = pDir->getNextItem( m_aItem_2 );
2763 ASSERT_TRUE(::osl::FileBase::E_None == nError1) << "get second item failed!";
2764 pDir->close();
2765 //mindy: failed on my RH9,so removed temporaly
2766 //nError1 = ::osl::DirectoryItem::get( aVolURL2, m_aVolumeItem );
2767 //ASSERT_TRUE(::osl::FileBase::E_None == nError1) << "get volume item failed!";
2768
2769 }
2770
TearDown()2771 void TearDown( )
2772 {
2773 // remove all in $TEMP/tmpdir.
2774 deleteTestDirectory( aTmpName3, aTmpName1 );
2775 deleteTestFile( aTmpName3, aTmpName2 );
2776 deleteTestDirectory( aTmpName3 );
2777 }
2778
check_FileType(osl::FileStatus const & _rFileStatus)2779 void check_FileType(osl::FileStatus const& _rFileStatus )
2780 {
2781 sal_Bool bOK = sal_False;
2782 if ( _rFileStatus.isValid(FileStatusMask_FileName))
2783 {
2784 rtl::OUString suFilename = _rFileStatus.getFileName();
2785
2786 if ( _rFileStatus.isValid(FileStatusMask_Type))
2787 {
2788 osl::FileStatus::Type eType = _rFileStatus.getFileType( );
2789
2790 if ( compareFileName( suFilename, aTmpName2) == sal_True )
2791 {
2792 // regular
2793 bOK = ( eType == osl::FileStatus::Regular );
2794 }
2795 if ( compareFileName( suFilename, aTmpName1) == sal_True )
2796 {
2797 // directory
2798 bOK = ( eType == ::osl::FileStatus::Directory );
2799 }
2800
2801 ASSERT_TRUE(( bOK == sal_True )) << "test for getFileType function: ";
2802 }
2803 }
2804 // LLA: it's not a bug, if a FileStatus not exist, so no else
2805 }
2806 };// class getFileType
2807
TEST_F(getFileType,getFileType_001)2808 TEST_F(getFileType, getFileType_001 )
2809 {
2810 ::osl::FileStatus rFileStatus( FileStatusMask_Type | FileStatusMask_FileName );
2811 nError1 = m_aItem_1.getFileStatus( rFileStatus );
2812 ASSERT_TRUE(::osl::FileBase::E_None == nError1) << "getFileStatus failed";
2813
2814 check_FileType(rFileStatus);
2815 }
2816
TEST_F(getFileType,getFileType_002)2817 TEST_F(getFileType, getFileType_002 )
2818 {
2819 ::osl::FileStatus rFileStatus( FileStatusMask_Type | FileStatusMask_FileName );
2820 nError1 = m_aItem_2.getFileStatus( rFileStatus );
2821
2822 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
2823 check_FileType(rFileStatus);
2824 }
2825
TEST_F(getFileType,getFileType_003)2826 TEST_F(getFileType, getFileType_003 )
2827 {
2828 #if 0
2829 // LLA: this have to be discussed.
2830 ::osl::FileStatus rFileStatus( FileStatusMask_Type );
2831 nError1 = m_aVolumeItem.getFileStatus( rFileStatus );
2832 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
2833
2834 if (rFileStatus.isValid(FileStatusMask_Type))
2835 {
2836 osl::FileStatus::Type eType = rFileStatus.getFileType( );
2837
2838 ASSERT_TRUE(( eType == ::osl::FileStatus::Volume )) << "test for getFileType function: Volume, it seems the volume part of the field is not implemented, it did not pass in (W32)(UNX).";
2839 }
2840 #endif
2841 }
2842
2843
TEST_F(getFileType,getFileType_004)2844 TEST_F(getFileType, getFileType_004 )
2845 {
2846 #if ( defined UNX ) || ( defined OS2 ) //Fifo creation is differ in Windows
2847
2848 //create a fifo in $ROOT/tmp/tmpdir, get its DirectoryItem.
2849 rtl::OString strFifoSys;
2850 strFifoSys = OUStringToOString( aFifoSys, RTL_TEXTENCODING_ASCII_US );
2851 ::rtl::OUString aFifoURL;
2852
2853 int fd = mkfifo( strFifoSys.getStr(), O_RDWR | O_CREAT );
2854 ASSERT_TRUE(fd == 0) << "mkfifo failed!";
2855 ::osl::FileBase::getFileURLFromSystemPath( aFifoSys, aFifoURL );
2856
2857 nError1 = ::osl::DirectoryItem::get( aFifoURL, m_aFifoItem );
2858 ASSERT_TRUE(::osl::FileBase::E_None == nError1) << "get item failed!";
2859
2860 //check for File type
2861 ::osl::FileStatus rFileStatus( FileStatusMask_Type );
2862 nError1 = m_aFifoItem.getFileStatus( rFileStatus );
2863 ASSERT_TRUE(::osl::FileBase::E_None == nError1) << "get Status failed!";
2864
2865 //delete fifo
2866 nError1 = ::osl::File::remove( aFifoURL );
2867 ASSERT_TRUE(::osl::FileBase::E_None == nError1) << "remove file failed!";
2868
2869 if (rFileStatus.isValid(FileStatusMask_Type))
2870 {
2871 osl::FileStatus::Type eType = rFileStatus.getFileType( );
2872
2873 ASSERT_TRUE(( eType == ::osl::FileStatus::Fifo )) << "test for getFileType function: Fifo, Solaris version ";
2874 }
2875 #endif
2876 }
2877
2878 /*
2879 * LLA: removed, m_aSocketItem is wrong initialised.
2880 */
2881
2882 // LLA: TEST_F(getFileType, getFileType_005 )
2883 // LLA: {
2884 // LLA: #if defined ( SOLARIS ) //Socket file may differ in Windows
2885 // LLA: // nError1 = ::osl::DirectoryItem::get( aTypeURL1, m_aSocketItem );
2886 // LLA: nError1 = ::osl::DirectoryItem::get( rtl::OUString::createFromAscii("/dev/null"), m_aSocketItem );
2887 // LLA: printError(nError1);
2888 // LLA: ASSERT_TRUE(::osl::FileBase::E_None == nError1) << "get Socket type file failed";
2889 // LLA:
2890 // LLA: //check for File type
2891 // LLA: ::osl::FileStatus rFileStatus( FileStatusMask_Type );
2892 // LLA:
2893 // LLA: nError1 = m_aSocketItem.getFileStatus( rFileStatus );
2894 // LLA: ASSERT_TRUE(::osl::FileBase::E_None == nError1) << "getFileStatus failed";
2895 // LLA:
2896 // LLA: if (rFileStatus.isValid( FileStatusMask_Type ))
2897 // LLA: {
2898 // LLA: osl::FileStatus::Type eType = rFileStatus.getFileType( );
2899 // LLA: printFileType(eType);
2900 // LLA: ASSERT_TRUE(// LLA: ( eType == ::osl::FileStatus::Socket )) << "test for getFileType function: Socket, Solaris version ";
2901 // LLA: }
2902 // LLA: #endif
2903 // LLA: }
2904
2905
2906 // deprecated since there is a same case Directory::getNextItem_004
2907 /*#if defined 0 //( UNX ) //( SOLARIS ) //Link file is not defined in Windows
2908 TEST_F(getFileType, getFileType_006 )
2909 {
2910 nError1 = ::osl::DirectoryItem::get( aTypeURL3, m_aLinkItem );
2911 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
2912
2913 //check for File type
2914 ::osl::FileStatus rFileStatus( FileStatusMask_Type );
2915 nError1 = m_aLinkItem.getFileStatus( rFileStatus );
2916 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
2917
2918 ASSERT_TRUE(( ::osl::FileStatus::Link == rFileStatus.getFileType( ) )) << "test for getFileType function: Link, UNX version ";
2919 }
2920 #endif */
2921
TEST_F(getFileType,getFileType_007)2922 TEST_F(getFileType, getFileType_007 )
2923 {
2924 #if defined ( SOLARIS ) //Special file is differ in Windows
2925 nError1 = ::osl::DirectoryItem::get( aTypeURL2, m_aSpecialItem );
2926 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
2927
2928 //check for File type
2929 ::osl::FileStatus rFileStatus( FileStatusMask_Type );
2930 nError1 = m_aSpecialItem.getFileStatus( rFileStatus );
2931 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
2932
2933 if (rFileStatus.isValid(FileStatusMask_Type))
2934 {
2935 osl::FileStatus::Type eType = rFileStatus.getFileType( );
2936
2937
2938 ASSERT_TRUE(( eType == ::osl::FileStatus::Special )) << "test for getFileType function: Special, Solaris version ";
2939 }
2940 #endif
2941 }
2942
2943 //---------------------------------------------------------------------
2944 // testing the method
2945 // inline sal_uInt64 getAttributes() const
2946 //---------------------------------------------------------------------
2947 class getAttributes : public ::testing::Test
2948 {
2949 protected:
2950 ::rtl::OUString aTypeURL, aTypeURL_Hid;
2951 ::osl::FileBase::RC nError;
2952 ::osl::DirectoryItem rItem, rItem_hidden;
2953
2954 public:
2955 // initialization
SetUp()2956 void SetUp( )
2957 {
2958 aTypeURL = aUserDirectoryURL.copy( 0 );
2959 concatURL( aTypeURL, aTmpName2 );
2960 createTestFile( aTypeURL );
2961 nError = ::osl::DirectoryItem::get( aTypeURL, rItem );
2962 ASSERT_TRUE( nError == FileBase::E_None );
2963
2964 aTypeURL_Hid = aUserDirectoryURL.copy( 0 );
2965 concatURL( aTypeURL_Hid, aHidURL1 );
2966 createTestFile( aTypeURL_Hid );
2967 nError = ::osl::DirectoryItem::get( aTypeURL_Hid, rItem_hidden );
2968 ASSERT_TRUE( nError == FileBase::E_None );
2969 }
2970
TearDown()2971 void TearDown( )
2972 {
2973 deleteTestFile( aTypeURL );
2974 deleteTestFile( aTypeURL_Hid );
2975 }
2976 };// class getAttributes
2977
2978 #if ( defined UNX ) || ( defined OS2 )
2979 //windows only 3 file attributes: normal, readonly, hidden
TEST_F(getAttributes,getAttributes_001)2980 TEST_F(getAttributes, getAttributes_001 )
2981 {
2982 changeFileMode( aTypeURL, S_IRUSR | S_IRGRP | S_IROTH );
2983
2984 ::osl::FileStatus rFileStatus( FileStatusMask_Attributes );
2985 nError = rItem.getFileStatus( rFileStatus );
2986 ASSERT_TRUE( nError == FileBase::E_None );
2987
2988 ASSERT_TRUE(( Attribute_ReadOnly | Attribute_GrpRead | Attribute_OwnRead | Attribute_OthRead ) ==
2989 rFileStatus.getAttributes( )) << "test for getAttributes function: ReadOnly, GrpRead, OwnRead, OthRead( UNX version ) ";
2990 }
2991 #else //Windows version
TEST_F(getAttributes,getAttributes_001)2992 TEST_F(getAttributes, getAttributes_001 )
2993 {
2994 ASSERT_TRUE(1 == 1) << "test for getAttributes function: ReadOnly, GrpRead, OwnRead, OthRead( Windows version )";
2995 }
2996 #endif
2997
2998
TEST_F(getAttributes,getAttributes_002)2999 TEST_F(getAttributes, getAttributes_002 )
3000 {
3001 #if ( defined UNX ) || ( defined OS2 )
3002 changeFileMode( aTypeURL, S_IXUSR | S_IXGRP | S_IXOTH );
3003
3004 ::osl::FileStatus rFileStatus( FileStatusMask_Attributes );
3005 nError = rItem.getFileStatus( rFileStatus );
3006 ASSERT_TRUE( nError == FileBase::E_None );
3007
3008 ASSERT_TRUE(( Attribute_ReadOnly | Attribute_Executable | Attribute_GrpExe | Attribute_OwnExe | Attribute_OthExe ) ==
3009 rFileStatus.getAttributes( )) << "test for getAttributes function: Executable, GrpExe, OwnExe, OthExe, the result is Readonly, Executable, GrpExe, OwnExe, OthExe, it partly not pass( Solaris version )";
3010 #endif
3011 }
3012
3013
3014 #if ( defined UNX ) || ( defined OS2 )
TEST_F(getAttributes,getAttributes_003)3015 TEST_F(getAttributes, getAttributes_003 )
3016 {
3017 changeFileMode( aTypeURL, S_IWUSR | S_IWGRP | S_IWOTH );
3018
3019 ::osl::FileStatus rFileStatus( FileStatusMask_Attributes );
3020 nError = rItem.getFileStatus( rFileStatus );
3021 ASSERT_TRUE( nError == FileBase::E_None );
3022
3023 ASSERT_TRUE(( Attribute_GrpWrite | Attribute_OwnWrite | Attribute_OthWrite ) ==
3024 rFileStatus.getAttributes( )) << "test for getAttributes function: GrpWrite, OwnWrite, OthWrite( Solaris version )";
3025 }
3026 #else //Windows version
TEST_F(getAttributes,getAttributes_003)3027 TEST_F(getAttributes, getAttributes_003 )
3028 {
3029 ASSERT_TRUE(1 == 1) << "test for getAttributes function: GrpWrite, OwnWrite, OthWrite( Windows version )";
3030 }
3031 #endif
3032
3033 #if ( defined UNX ) || ( defined OS2 ) //hidden file definition may different in Windows
TEST_F(getAttributes,getAttributes_004)3034 TEST_F(getAttributes, getAttributes_004 )
3035 {
3036 sal_Int32 test_Attributes = Attribute_Hidden;
3037 ::osl::FileStatus rFileStatus( FileStatusMask_Attributes );
3038 nError = rItem_hidden.getFileStatus( rFileStatus );
3039 ASSERT_TRUE( nError == FileBase::E_None );
3040 test_Attributes &= rFileStatus.getAttributes( );
3041
3042 ASSERT_TRUE(test_Attributes == Attribute_Hidden) << "test for getAttributes function: Hidden files( Solaris version )";
3043 }
3044 #else //Windows version
TEST_F(getAttributes,getAttributes_004)3045 TEST_F(getAttributes, getAttributes_004 )
3046 {
3047 ::rtl::OUString aUserHiddenFileURL = ::rtl::OUString::createFromAscii("file:///c:/AUTOEXEC.BAT");
3048 nError = ::osl::DirectoryItem::get( aUserHiddenFileURL, rItem_hidden );
3049 //printFileName( aUserHiddenFileURL );
3050 ASSERT_TRUE(nError == FileBase::E_None) << "get item fail";
3051 ::osl::FileStatus rFileStatus( FileStatusMask_Attributes );
3052 nError = rItem_hidden.getFileStatus( rFileStatus );
3053 ASSERT_TRUE( nError == FileBase::E_None );
3054
3055 ASSERT_TRUE((rFileStatus.getAttributes( ) & Attribute_Hidden)!= 0) << "Hidden files(Windows version), please check if hidden file c:/AUTOEXEC.BAT exists ";
3056 }
3057 #endif
3058
3059 //---------------------------------------------------------------------
3060 // testing the method
3061 // inline TimeValue getAccessTime() const
3062 //---------------------------------------------------------------------
3063 class getAccessTime : public ::testing::Test
3064 {
3065 protected:
3066 ::rtl::OUString aTypeURL;
3067 ::osl::FileBase::RC nError;
3068 ::osl::DirectoryItem rItem;
3069
3070 public:
3071 // initialization
SetUp()3072 void SetUp( )
3073 {
3074 aTypeURL = aUserDirectoryURL.copy( 0 );
3075 concatURL( aTypeURL, aTmpName2 );
3076 createTestFile( aTypeURL );
3077 nError = ::osl::DirectoryItem::get( aTypeURL, rItem );
3078 ASSERT_TRUE( nError == FileBase::E_None );
3079
3080 }
3081
TearDown()3082 void TearDown( )
3083 {
3084 deleteTestFile( aTypeURL );
3085 }
3086 };// class getAccessTime
3087
TEST_F(getAccessTime,getAccessTime_001)3088 TEST_F(getAccessTime, getAccessTime_001)
3089 {
3090 TimeValue *pTV_current = NULL;
3091 ASSERT_TRUE( ( pTV_current = ( TimeValue* )malloc( sizeof( TimeValue ) ) ) != NULL );
3092 TimeValue *pTV_access = NULL;
3093 ASSERT_TRUE( ( pTV_access = ( TimeValue* )malloc( sizeof( TimeValue ) ) ) != NULL );
3094
3095 ::osl::FileStatus rFileStatus( FileStatusMask_AccessTime );
3096 nError = rItem.getFileStatus( rFileStatus );
3097 sal_Bool bOk = osl_getSystemTime( pTV_current );
3098 ASSERT_TRUE( sal_True == bOk && nError == FileBase::E_None );
3099
3100 *pTV_access = rFileStatus.getAccessTime( );
3101
3102 sal_Bool bOK = t_compareTime( pTV_access, pTV_current, delta );
3103 free( pTV_current );
3104 free( pTV_access );
3105
3106 ASSERT_TRUE(sal_True == bOK) << "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. ";
3107 }
3108
3109 //---------------------------------------------------------------------
3110 // testing the method
3111 // inline TimeValue getModifyTime() const
3112 //---------------------------------------------------------------------
3113 class getModifyTime : public ::testing::Test
3114 {
3115 protected:
3116 ::rtl::OUString aTypeURL;
3117 ::osl::FileBase::RC nError;
3118 ::osl::DirectoryItem rItem;
3119 };// class getModifyTime
3120
TEST_F(getModifyTime,getModifyTime_001)3121 TEST_F(getModifyTime, getModifyTime_001)
3122 {
3123 TimeValue *pTV_current = NULL;
3124 ASSERT_TRUE( ( pTV_current = ( TimeValue* )malloc( sizeof( TimeValue ) ) ) != NULL );
3125
3126 //create file
3127 aTypeURL = aUserDirectoryURL.copy( 0 );
3128 concatURL( aTypeURL, aTmpName2 );
3129 createTestFile( aTypeURL );
3130
3131 //get current time
3132 sal_Bool bOk = osl_getSystemTime( pTV_current );
3133 ASSERT_TRUE( sal_True == bOk );
3134
3135 //get instance item and filestatus
3136 nError = ::osl::DirectoryItem::get( aTypeURL, rItem );
3137 ASSERT_TRUE( nError == FileBase::E_None );
3138 ::osl::FileStatus rFileStatus( FileStatusMask_ModifyTime );
3139 nError = rItem.getFileStatus( rFileStatus );
3140 ASSERT_TRUE( nError == FileBase::E_None );
3141
3142 //get modify time
3143 TimeValue *pTV_modify = NULL;
3144 ASSERT_TRUE( ( pTV_modify = ( TimeValue* )malloc( sizeof( TimeValue ) ) ) != NULL );
3145 *pTV_modify = rFileStatus.getModifyTime( );
3146
3147 sal_Bool bOK = t_compareTime( pTV_modify, pTV_current, delta );
3148 //delete file
3149 deleteTestFile( aTypeURL );
3150 free( pTV_current );
3151
3152 ASSERT_TRUE(sal_True == bOK) << "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. ";
3153 }
3154
3155
3156 //---------------------------------------------------------------------
3157 // testing the method
3158 // inline sal_uInt64 getFileSize() const
3159 //---------------------------------------------------------------------
3160 class getFileSize : public ::testing::Test
3161 {
3162 protected:
3163 ::rtl::OUString aTypeURL;
3164 ::osl::FileBase::RC nError;
3165 ::osl::DirectoryItem rItem;
3166
3167 public:
3168 // initialization
SetUp()3169 void SetUp( )
3170 {
3171 aTypeURL = aUserDirectoryURL.copy( 0 );
3172 concatURL( aTypeURL, aTmpName2 );
3173 createTestFile( aTypeURL );
3174 nError = ::osl::DirectoryItem::get( aTypeURL, rItem );
3175 ASSERT_TRUE( nError == FileBase::E_None );
3176 }
3177
TearDown()3178 void TearDown( )
3179 {
3180 deleteTestFile( aTypeURL );
3181 }
3182 };// class getFileSize
3183
TEST_F(getFileSize,getFileSize_001)3184 TEST_F(getFileSize, getFileSize_001 )
3185 {
3186 ::osl::FileStatus rFileStatus( FileStatusMask_FileSize );
3187 nError = rItem.getFileStatus( rFileStatus );
3188 ASSERT_TRUE( nError == FileBase::E_None );
3189
3190 sal_uInt64 uFileSize = rFileStatus.getFileSize( );
3191
3192 ASSERT_TRUE(0 == uFileSize) << "test for getFileSize function: empty file ";
3193 }
3194
TEST_F(getFileSize,getFileSize_002)3195 TEST_F(getFileSize, getFileSize_002 )
3196 {
3197 ::osl::File testfile( aTypeURL );
3198 nError = testfile.open( OpenFlag_Write | OpenFlag_Read );
3199 ASSERT_TRUE( ::osl::FileBase::E_None == nError );
3200 nError = testfile.setSize( TEST_FILE_SIZE );
3201 ASSERT_TRUE( ::osl::FileBase::E_None == nError );
3202
3203 nError = ::osl::DirectoryItem::get( aTypeURL, rItem );
3204 ASSERT_TRUE( nError == FileBase::E_None );
3205 ::osl::FileStatus rFileStatus( FileStatusMask_FileSize );
3206 nError = rItem.getFileStatus( rFileStatus );
3207 ASSERT_TRUE( nError == FileBase::E_None );
3208 sal_uInt64 uFileSize = rFileStatus.getFileSize( );
3209
3210 ASSERT_TRUE(TEST_FILE_SIZE == uFileSize) << "test for getFileSize function: file with size of TEST_FILE_SIZE, did not pass in (W32). ";
3211 }
3212
3213 //---------------------------------------------------------------------
3214 // testing the method
3215 // inline ::rtl::OUString getFileName() const
3216 //---------------------------------------------------------------------
3217 class getFileName : public ::testing::Test
3218 {
3219 protected:
3220 ::rtl::OUString aTypeURL;
3221 ::osl::FileBase::RC nError;
3222 ::osl::DirectoryItem rItem;
3223
3224 public:
3225 // initialization
SetUp()3226 void SetUp( )
3227 {
3228 aTypeURL = aUserDirectoryURL.copy( 0 );
3229 concatURL( aTypeURL, aTmpName2 );
3230 createTestFile( aTypeURL );
3231 nError = ::osl::DirectoryItem::get( aTypeURL, rItem );
3232 ASSERT_TRUE( nError == FileBase::E_None );
3233 }
3234
TearDown()3235 void TearDown( )
3236 {
3237 deleteTestFile( aTypeURL );
3238 }
3239 };// class getFileName
3240
TEST_F(getFileName,getFileName_001)3241 TEST_F(getFileName, getFileName_001 )
3242 {
3243 ::osl::FileStatus rFileStatus( FileStatusMask_FileName );
3244 nError = rItem.getFileStatus( rFileStatus );
3245 ASSERT_TRUE( nError == FileBase::E_None );
3246
3247 ::rtl::OUString aFileName = rFileStatus.getFileName( );
3248
3249 ASSERT_TRUE(sal_True == compareFileName( aFileName, aTmpName2 )) << "test for getFileName function: name compare with specify";
3250 }
3251
3252 //---------------------------------------------------------------------
3253 // testing the method
3254 // inline ::rtl::OUString getFileURL() const
3255 //---------------------------------------------------------------------
3256 class getFileURL : public ::testing::Test
3257 {
3258 protected:
3259 ::rtl::OUString aTypeURL;
3260 ::osl::FileBase::RC nError;
3261 ::osl::DirectoryItem rItem;
3262
3263 public:
3264 // initialization
SetUp()3265 void SetUp( )
3266 {
3267 createTestFile( aTmpName6 );
3268 nError = ::osl::DirectoryItem::get( aTmpName6, rItem );
3269 ASSERT_TRUE( nError == FileBase::E_None );
3270 }
3271
TearDown()3272 void TearDown( )
3273 {
3274 deleteTestFile( aTmpName6 );
3275 }
3276 };// class getFileURL
3277
TEST_F(getFileURL,getFileURL_001)3278 TEST_F(getFileURL, getFileURL_001 )
3279 {
3280 ::osl::FileStatus rFileStatus( FileStatusMask_FileURL );
3281 nError = rItem.getFileStatus( rFileStatus );
3282 ASSERT_TRUE( nError == FileBase::E_None );
3283
3284 ::rtl::OUString aFileURL = rFileStatus.getFileURL( );
3285
3286 ASSERT_TRUE(sal_True == compareFileName( aFileURL, aTmpName6 )) << "test for getFileURL function: ";
3287 }
3288
3289 //---------------------------------------------------------------------
3290 // testing the method
3291 // inline ::rtl::OUString getLinkTargetURL() const
3292 //---------------------------------------------------------------------
3293 class getLinkTargetURL : public ::testing::Test
3294 {
3295 protected:
3296 ::rtl::OUString aTypeURL;
3297 ::osl::FileBase::RC nError;
3298 ::osl::DirectoryItem rItem;
3299
3300 public:
3301 // test code.
3302 // initialization
SetUp()3303 void SetUp( )
3304 {
3305 aTypeURL = aUserDirectoryURL.copy( 0 );
3306 concatURL( aTypeURL, aTmpName2 );
3307 createTestFile( aTypeURL );
3308 }
3309
TearDown()3310 void TearDown( )
3311 {
3312 deleteTestFile( aTypeURL );
3313 }
3314 };// class getLinkTargetURL
3315
3316 #if ( defined UNX ) || ( defined OS2 ) //Link file is not define in Windows
TEST_F(getLinkTargetURL,getLinkTargetURL_001)3317 TEST_F(getLinkTargetURL, getLinkTargetURL_001 )
3318 {
3319 //create a link file;
3320 ::rtl::OUString aUStr_LnkFileSys( aTempDirectorySys ), aUStr_SrcFileSys( aTempDirectorySys );
3321 ( ( aUStr_LnkFileSys += aSlashURL ) += getCurrentPID( ) ) += ::rtl::OUString::createFromAscii("/link.file");
3322 ( ( aUStr_SrcFileSys += aSlashURL ) += getCurrentPID( ) ) += ::rtl::OUString::createFromAscii("/tmpname");
3323
3324 rtl::OString strLinkFileName, strSrcFileName;
3325 strLinkFileName = OUStringToOString( aUStr_LnkFileSys, RTL_TEXTENCODING_ASCII_US );
3326 strSrcFileName = OUStringToOString( aUStr_SrcFileSys, RTL_TEXTENCODING_ASCII_US );
3327
3328 sal_Int32 fd;
3329 fd = symlink( strSrcFileName.getStr(), strLinkFileName.getStr() );
3330 ASSERT_TRUE(fd == 0) << "in creating link file";
3331
3332 //get linkTarget URL
3333 nError = ::osl::DirectoryItem::get( aLnkURL1, rItem );
3334 ASSERT_TRUE(nError == FileBase::E_None) << "in getting link file item";
3335
3336 ::osl::FileStatus rFileStatus( FileStatusMask_LinkTargetURL );
3337 nError = rItem.getFileStatus( rFileStatus );
3338 ASSERT_TRUE(nError == FileBase::E_None) << "in getting link file status";
3339 ::rtl::OUString aFileURL = rFileStatus.getLinkTargetURL( );
3340
3341 //remove link file
3342 fd = remove( strLinkFileName.getStr() );
3343 ASSERT_TRUE(fd == 0) << "in deleting link file";
3344
3345 ASSERT_TRUE(sal_True == compareFileName( aFileURL, aTypeURL )) << "test for getLinkTargetURL function: Solaris version, creat a file, and a link file link to it, get its LinkTargetURL and compare";
3346 }
3347 #else
TEST_F(getLinkTargetURL,getLinkTargetURL_001)3348 TEST_F(getLinkTargetURL, getLinkTargetURL_001 )
3349 {
3350 ASSERT_TRUE(1) << "test for getLinkTargetURL function: Windows version, not tested";
3351 }
3352 #endif
3353
3354 }// namespace osl_FileStatus
3355
3356
3357
3358 //------------------------------------------------------------------------
3359 // Beginning of the test cases for File class
3360 //------------------------------------------------------------------------
3361 namespace osl_File
3362 {
3363 //---------------------------------------------------------------------
3364 // testing the method
3365 // File( const ::rtl::OUString& ustrFileURL )
3366 //---------------------------------------------------------------------
3367 class FileCtors : public ::testing::Test
3368 {
3369 protected:
3370 // ::osl::FileBase::RC nError1;
3371
3372 public:
3373 // initialization
SetUp()3374 void SetUp( )
3375 {
3376 // create a tempfile in $TEMP/tmpdir/tmpname.
3377 createTestDirectory( aTmpName3 );
3378 createTestFile( aTmpName4 );
3379 }
3380
TearDown()3381 void TearDown( )
3382 {
3383 // remove the tempfile in $TEMP/tmpdir/tmpname.
3384 deleteTestFile( aTmpName4 );
3385 deleteTestDirectory( aTmpName3 );
3386 }
3387 };// class ctors
3388
TEST_F(FileCtors,ctors_001)3389 TEST_F(FileCtors, ctors_001 )
3390 {
3391 ::osl::File testFile( aTmpName4 );
3392
3393 ::osl::FileBase::RC nError1 = testFile.open( OpenFlag_Read | OpenFlag_Write );
3394 ::osl::FileBase::RC nError2 = testFile.close( );
3395 ASSERT_TRUE(( ::osl::FileBase::E_None == nError1 ) && ( ::osl::FileBase::E_None == nError2 )) << "test for ctors function: initialize a File and test its open and close";
3396 }
3397
TEST_F(FileCtors,ctors_002)3398 TEST_F(FileCtors, ctors_002 )
3399 {
3400 ::osl::File testFile( aTmpName5 );
3401 sal_Char buffer[30] = "Test for File constructor";
3402 sal_uInt64 nCount;
3403
3404 ::osl::FileBase::RC nError1 = testFile.open( OpenFlag_Read | OpenFlag_Write );
3405 ::osl::FileBase::RC nError2 = testFile.write( buffer, 30, nCount );
3406 testFile.close( );
3407
3408 ASSERT_TRUE(( ::osl::FileBase::E_None == nError1 ) && ( ::osl::FileBase::E_None == nError2 )) << "test for ctors function: test relative file URL, this test show that relative file URL is also acceptable";
3409 }
3410
3411 //---------------------------------------------------------------------
3412 // testing the method
3413 // inline RC open( sal_uInt32 uFlags )
3414 //---------------------------------------------------------------------
3415 class FileOpen : public ::testing::Test
3416 {
3417 protected:
3418 ::osl::FileBase::RC nError1, nError2, nError3;
3419
3420 public:
3421 // initialization
SetUp()3422 void SetUp( )
3423 {
3424 // create a tempfile in $TEMP/tmpdir/tmpname.
3425 createTestDirectory( aTmpName3 );
3426 createTestFile( aTmpName4 );
3427 }
3428
TearDown()3429 void TearDown( )
3430 {
3431 // remove the tempfile in $TEMP/tmpdir/tmpname.
3432 deleteTestFile( aTmpName4 );
3433 deleteTestDirectory( aTmpName3 );
3434 }
3435 };// class open
3436
3437 // test code.
TEST_F(FileOpen,open_001)3438 TEST_F(FileOpen, open_001 )
3439 {
3440 ::osl::File testFile( aTmpName4 );
3441
3442 nError1 = testFile.open( OpenFlag_Read | OpenFlag_Write );
3443 nError2 = testFile.close( );
3444 ASSERT_TRUE(::osl::FileBase::E_None == nError2) << "close error";
3445
3446 ASSERT_TRUE(::osl::FileBase::E_None == nError1) << "test for open function: open a regular file";
3447 }
3448
TEST_F(FileOpen,open_002)3449 TEST_F(FileOpen, open_002 )
3450 {
3451 ::osl::File testFile( aTmpName3 );
3452
3453 nError1 = testFile.open( OpenFlag_Read );
3454
3455 ASSERT_TRUE(( File::E_INVAL == nError1 ) || ( File::E_ACCES == nError1 )) << "test for open function: open a directory";
3456 }
3457
TEST_F(FileOpen,open_003)3458 TEST_F(FileOpen, open_003 )
3459 {
3460 ::osl::File testFile( aCanURL1 );
3461
3462 nError1 = testFile.open( OpenFlag_Read | OpenFlag_Write );
3463
3464 ASSERT_TRUE(File::E_NOENT == nError1) << "test for open function: open a non-exist file";
3465 }
3466
TEST_F(FileOpen,open_004)3467 TEST_F(FileOpen, open_004 )
3468 {
3469 ::rtl::OUString aTestFile( aRootURL );
3470 concatURL( aTestFile, aTmpName2 );
3471 ::osl::File testFile( aTestFile );
3472
3473 nError1 = testFile.open( OpenFlag_Create );
3474 sal_Bool bOK = ( File::E_ACCES == nError1 );
3475 #if defined (WNT )
3476 bOK = sal_True; /// in Windows, you can create file in c:/ any way.
3477 testFile.close( );
3478 deleteTestFile( aTestFile);
3479 #endif
3480
3481 ASSERT_TRUE(bOK == sal_True) << "test for open function: create an illegal file";
3482 }
3483
TEST_F(FileOpen,open_005)3484 TEST_F(FileOpen, open_005 )
3485 {
3486 ::osl::File testFile( aTmpName4 );
3487
3488 nError1 = testFile.open( OpenFlag_Create );
3489
3490 ASSERT_TRUE(File::E_EXIST == nError1) << "test for open function: create an exist file";
3491 }
3492
TEST_F(FileOpen,open_006)3493 TEST_F(FileOpen, open_006 )
3494 {
3495 ::osl::File testFile( aCanURL1 );
3496 sal_Char buffer_write[30] = "Test for File open";
3497 sal_Char buffer_read[30];
3498 sal_uInt64 nCount_write, nCount_read;
3499
3500 nError1 = testFile.open( OpenFlag_Read | OpenFlag_Write | OpenFlag_Create );
3501 nError2 = testFile.write( buffer_write, 30, nCount_write );
3502 ::osl::FileBase::RC nError4 = testFile.setPos( Pos_Absolut, 0 );
3503 ASSERT_TRUE( ::osl::FileBase::E_None == nError4 );
3504 nError3 = testFile.read( buffer_read, 10, nCount_read );
3505
3506 ::osl::FileBase::RC nError5 = testFile.close( );
3507 ASSERT_TRUE( ::osl::FileBase::E_None == nError5 );
3508 ::osl::FileBase::RC nError6 = testFile.remove( aCanURL1 );
3509 ASSERT_TRUE( ::osl::FileBase::E_None == nError6 );
3510
3511 ASSERT_TRUE(( ::osl::FileBase::E_None == nError1 ) &&
3512 ( ::osl::FileBase::E_None == nError2 ) &&
3513 ( ::osl::FileBase::E_None == nError3 ) &&
3514 ( 30 == nCount_write ) &&
3515 ( 10 == nCount_read )) << "test for open function: test for OpenFlag_Read,OpenFlag_Write and OpenFlag_Create";
3516 }
3517
3518 //---------------------------------------------------------------------
3519 // testing the method
3520 // inline RC close()
3521 //---------------------------------------------------------------------
3522 class FileClose : public ::testing::Test
3523 {
3524 protected:
3525 ::osl::FileBase::RC nError1, nError2, nError3;
3526
3527 public:
3528 // initialization
SetUp()3529 void SetUp( )
3530 {
3531 // create a tempfile in $TEMP/tmpdir/tmpname.
3532 createTestDirectory( aTmpName3 );
3533 createTestFile( aTmpName4 );
3534 }
3535
TearDown()3536 void TearDown( )
3537 {
3538 // remove the tempfile in $TEMP/tmpdir/tmpname.
3539 deleteTestFile( aTmpName4 );
3540 deleteTestDirectory( aTmpName3 );
3541 }
3542 };// class close
3543
TEST_F(FileClose,close_001)3544 TEST_F(FileClose, close_001 )
3545 {
3546 ::osl::File testFile( aTmpName4 );
3547
3548 nError1 = testFile.open( OpenFlag_Read | OpenFlag_Write );
3549 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3550
3551 nError2 = testFile.close( );
3552
3553 ASSERT_TRUE(::osl::FileBase::E_None == nError2) << "test for close function: close a regular file";
3554 }
3555
TEST_F(FileClose,close_002)3556 TEST_F(FileClose, close_002 )
3557 {
3558 ::osl::File testFile( aTmpName4 );
3559
3560 nError1 = testFile.open( OpenFlag_Read | OpenFlag_Write );
3561 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3562
3563 nError2 = testFile.close( );
3564
3565 nError3 = testFile.setPos( Pos_Absolut, 0 );
3566
3567 ASSERT_TRUE(( ::osl::FileBase::E_None == nError2 ) &&
3568 ( ::osl::FileBase::E_None != nError3 )) << "test for close function: manipulate a file after it has been closed";
3569 }
3570
3571 //---------------------------------------------------------------------
3572 // testing the method
3573 // inline RC setPos( sal_uInt32 uHow, sal_Int64 uPos )
3574 //---------------------------------------------------------------------
3575 class setPos : public ::testing::Test
3576 {
3577 protected:
3578 ::osl::FileBase::RC nError1;
3579 sal_uInt64 nCount_write, nCount_read;
3580
3581 public:
3582 // initialization
SetUp()3583 void SetUp( )
3584 {
3585 // create a tempfile in $TEMP/tmpdir/tmpname.
3586 createTestDirectory( aTmpName3 );
3587 createTestFile( aTmpName4 );
3588
3589 //write chars into the file.
3590 ::osl::File testFile( aTmpName4 );
3591
3592 nError1 = testFile.open( OpenFlag_Write );
3593 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3594 nError1 = testFile.write( pBuffer_Char, sizeof( pBuffer_Char ), nCount_write );
3595 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3596 nError1 = testFile.close( );
3597 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3598 }
3599
TearDown()3600 void TearDown( )
3601 {
3602 // remove the tempfile in $TEMP/tmpdir/tmpname.
3603 deleteTestFile( aTmpName4 );
3604 deleteTestDirectory( aTmpName3 );
3605 }
3606 };// class setPos
3607
TEST_F(setPos,setPos_001)3608 TEST_F(setPos, setPos_001 )
3609 {
3610 ::osl::File testFile( aTmpName4 );
3611 sal_Char buffer_read[2];
3612
3613 nError1 = testFile.open( OpenFlag_Read | OpenFlag_Write );
3614 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3615 nError1 = testFile.setPos( Pos_Absolut, 26 );
3616 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3617 nError1 = testFile.read( buffer_read, 1, nCount_read );
3618 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3619 nError1 = testFile.close( );
3620 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3621
3622 ASSERT_TRUE(buffer_read[0] == pBuffer_Char[26]) << "test for setPos function: test for Pos_Absolut, set the position to 26, test if the 26th char in file is correct";
3623 }
3624
TEST_F(setPos,setPos_002)3625 TEST_F(setPos, setPos_002 )
3626 {
3627 ::osl::File testFile( aTmpName4 );
3628 sal_Char buffer_read[2];
3629
3630 nError1 = testFile.open( OpenFlag_Read | OpenFlag_Write );
3631 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3632 nError1 = testFile.setPos( Pos_Absolut, sizeof( pBuffer_Char ) - 2 );
3633 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3634 nError1 = testFile.setPos( Pos_Current, 0);
3635 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3636 nError1 = testFile.read( buffer_read, 1, nCount_read );
3637 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3638 nError1 = testFile.close( );
3639 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3640
3641 ASSERT_TRUE(buffer_read[0] == pBuffer_Char[sizeof( pBuffer_Char ) - 2]) << "test for setPos function: test for Pos_Current, set the position to end, test if the ( end -1 ) char in file is correct";
3642 }
3643
TEST_F(setPos,setPos_003)3644 TEST_F(setPos, setPos_003 )
3645 {
3646 ::osl::File testFile( aTmpName4 );
3647 sal_Char buffer_read[2];
3648
3649 nError1 = testFile.open( OpenFlag_Read | OpenFlag_Write );
3650 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3651 //the file size is smaller than 100
3652 nError1 = testFile.setPos( Pos_End, -100 );
3653 ASSERT_TRUE(::osl::FileBase::E_INVAL == nError1) << "should return error";
3654
3655 nError1 = testFile.setPos( Pos_End, -53 );
3656 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3657 nError1 = testFile.read( buffer_read, 1, nCount_read );
3658 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3659 nError1 = testFile.close( );
3660 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3661
3662 ASSERT_TRUE(buffer_read[0] == pBuffer_Char[0]) << "test for setPos function: test for Pos_End, set the position to end, test if the first char in file is correct";
3663 }
3664
3665 //---------------------------------------------------------------------
3666 // testing the method
3667 // inline RC getPos( sal_uInt64& uPos )
3668 //---------------------------------------------------------------------
3669 class getPos : public ::testing::Test
3670 {
3671 protected:
3672 ::osl::FileBase::RC nError1;
3673 sal_uInt64 nCount_write, nCount_read;
3674
3675 public:
3676 // initialization
SetUp()3677 void SetUp( )
3678 {
3679 // create a tempfile in $TEMP/tmpdir/tmpname.
3680 createTestDirectory( aTmpName3 );
3681 createTestFile( aTmpName4 );
3682
3683 //write chars into the file.
3684 ::osl::File testFile( aTmpName4 );
3685
3686 nError1 = testFile.open( OpenFlag_Write );
3687 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3688 nError1 = testFile.write( pBuffer_Char, sizeof( pBuffer_Char ), nCount_write );
3689 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3690 nError1 = testFile.close( );
3691 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3692 }
3693
TearDown()3694 void TearDown( )
3695 {
3696 // remove the tempfile in $TEMP/tmpdir/tmpname.
3697 deleteTestFile( aTmpName4 );
3698 deleteTestDirectory( aTmpName3 );
3699 }
3700 };// class getPos
3701
TEST_F(getPos,getPos_001)3702 TEST_F(getPos, getPos_001 )
3703 {
3704 ::osl::File testFile( aTmpName4 );
3705 sal_uInt64 nFilePointer;
3706
3707 nError1 = testFile.getPos( nFilePointer );
3708 ASSERT_TRUE( ::osl::FileBase::E_INVAL == nError1 );
3709
3710 nError1 = testFile.open( OpenFlag_Read | OpenFlag_Write );
3711 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3712
3713 nError1 = testFile.setPos( Pos_Absolut, 26 );
3714 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3715 nError1 = testFile.getPos( nFilePointer );
3716 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3717
3718 nError1 = testFile.close( );
3719 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3720
3721 ASSERT_TRUE(26 == nFilePointer) << "test for getPos function: set the position to 26, get position and check if it is right";
3722 }
3723
3724 //---------------------------------------------------------------------
3725 // testing the method
3726 // inline RC isEndOfFile( sal_Bool *pIsEOF )
3727 //---------------------------------------------------------------------
3728 class isEndOfFile : public ::testing::Test
3729 {
3730 protected:
3731 ::osl::FileBase::RC nError1;
3732 sal_uInt64 nCount_write, nCount_read;
3733
3734 public:
3735 // initialization
SetUp()3736 void SetUp( )
3737 {
3738 // create a tempfile in $TEMP/tmpdir/tmpname.
3739 createTestDirectory( aTmpName3 );
3740 createTestFile( aTmpName4 );
3741
3742 //write chars into the file.
3743 ::osl::File testFile( aTmpName4 );
3744
3745 nError1 = testFile.open( OpenFlag_Write );
3746 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3747 nError1 = testFile.write( pBuffer_Char, sizeof( pBuffer_Char ), nCount_write );
3748 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3749 nError1 = testFile.close( );
3750 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3751 }
3752
TearDown()3753 void TearDown( )
3754 {
3755 // remove the tempfile in $TEMP/tmpdir/tmpname.
3756 deleteTestFile( aTmpName4 );
3757 deleteTestDirectory( aTmpName3 );
3758 }
3759 };// class isEndOfFile
3760
TEST_F(isEndOfFile,isEndOfFile_001)3761 TEST_F(isEndOfFile, isEndOfFile_001 )
3762 {
3763 ::osl::File testFile( aTmpName4 );
3764 sal_Bool bEOF = sal_False;
3765 sal_Bool *pEOF = &bEOF;
3766
3767
3768 nError1 = testFile.open( OpenFlag_Read | OpenFlag_Write );
3769 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3770
3771 nError1 = testFile.setPos( Pos_End, 0 );
3772 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3773 nError1 = testFile.isEndOfFile( pEOF );
3774 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3775
3776 nError1 = testFile.close( );
3777 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3778
3779 ASSERT_TRUE(sal_True == *pEOF) << "test for isEndOfFile function: set the position to end, check if reach end";
3780 }
3781
TEST_F(isEndOfFile,isEndOfFile_002)3782 TEST_F(isEndOfFile, isEndOfFile_002 )
3783 {
3784 ::osl::File testFile( aTmpName4 );
3785 sal_Bool bEOF = sal_False;
3786 sal_Bool *pEOF = &bEOF;
3787 sal_uInt64 nFilePointer = 0;
3788
3789 nError1 = testFile.open( OpenFlag_Read | OpenFlag_Write );
3790 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3791
3792 nError1 = testFile.setPos( Pos_Absolut, 0 );
3793 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3794 *pEOF = sal_False;
3795 while ( !( *pEOF ) )
3796 {
3797 nError1 = testFile.isEndOfFile( pEOF );
3798 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3799 nError1 = testFile.setPos( Pos_Current, 1 );
3800 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3801 }
3802 nError1 = testFile.getPos( nFilePointer );
3803 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3804
3805 nError1 = testFile.close( );
3806 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3807
3808 ASSERT_TRUE(sizeof( pBuffer_Char ) + 1 == nFilePointer) << "test for isEndOfFile function: use isEndOfFile to move pointer step by step";
3809 }
3810
3811 //---------------------------------------------------------------------
3812 // testing the method
3813 // inline RC setSize( sal_uInt64 uSize )
3814 //---------------------------------------------------------------------
3815 class setSize : public ::testing::Test
3816 {
3817 protected:
3818 ::osl::FileBase::RC nError1;
3819 sal_uInt64 nCount_write, nCount_read;
3820
3821 public:
3822 // initialization
SetUp()3823 void SetUp( )
3824 {
3825 // create a tempfile in $TEMP/tmpdir/tmpname.
3826 createTestDirectory( aTmpName3 );
3827 createTestFile( aTmpName4 );
3828
3829 //write chars into the file.
3830 ::osl::File testFile( aTmpName4 );
3831
3832 nError1 = testFile.open( OpenFlag_Write );
3833 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3834 nError1 = testFile.write( pBuffer_Char, sizeof( pBuffer_Char ), nCount_write );
3835 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3836 nError1 = testFile.close( );
3837 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3838 }
3839
TearDown()3840 void TearDown( )
3841 {
3842 // remove the tempfile in $TEMP/tmpdir/tmpname.
3843 deleteTestFile( aTmpName4 );
3844 deleteTestDirectory( aTmpName3 );
3845 }
3846 };// class setSize
3847
TEST_F(setSize,setSize_001)3848 TEST_F(setSize, setSize_001 )
3849 {
3850 ::osl::File testFile( aTmpName4 );
3851 // sal_Bool bEOF = sal_False;
3852 // sal_Bool *pEOF = &bEOF;
3853 sal_uInt64 nFilePointer;
3854
3855
3856 nError1 = testFile.open( OpenFlag_Read | OpenFlag_Write );
3857 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3858
3859 //enlarge the file to size of 100;
3860 nError1 = testFile.setSize( 100 );
3861 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3862
3863 //get the file size;
3864 nError1 = testFile.setPos( Pos_End, 0 );
3865 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3866 nError1 = testFile.getPos( nFilePointer );
3867 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3868
3869 nError1 = testFile.close( );
3870 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3871
3872 ASSERT_TRUE(100 == nFilePointer) << "test for setSize function: enlarge the file ";
3873 }
3874
TEST_F(setSize,setSize_002)3875 TEST_F(setSize, setSize_002 )
3876 {
3877 ::osl::File testFile( aTmpName4 );
3878 // sal_Bool bEOF = sal_False;
3879 // sal_Bool *pEOF = &bEOF;
3880 sal_uInt64 nFilePointer;
3881
3882
3883 nError1 = testFile.open( OpenFlag_Read | OpenFlag_Write );
3884 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3885
3886 //enlarge the file to size of 100;
3887 nError1 = testFile.setSize( 10 );
3888 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3889
3890 //get the file size;
3891 nError1 = testFile.setPos( Pos_End, 0 );
3892 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3893 nError1 = testFile.getPos( nFilePointer );
3894 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3895
3896 nError1 = testFile.close( );
3897 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3898
3899 ASSERT_TRUE(10 == nFilePointer) << "test for setSize function: truncate the file ";
3900 }
3901 /* TEST_F(setSize, setSize_003 )
3902 {
3903 ::osl::File testFile( aTmpName4 );
3904 // sal_Bool bEOF = sal_False;
3905 // sal_Bool *pEOF = &bEOF;
3906 sal_uInt64 nFilePointer;
3907
3908
3909 nError1 = testFile.open( OpenFlag_Read | OpenFlag_Write );
3910 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3911
3912 //enlarge the file to size of 100;
3913 nError1 = testFile.setSize( 10 );
3914 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3915
3916 //get the file size;
3917 nError1 = testFile.setPos( Pos_End, 0 );
3918 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3919 nError1 = testFile.getPos( nFilePointer );
3920 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3921
3922 nError1 = testFile.close( );
3923 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3924
3925 ASSERT_TRUE(10 == nFilePointer) << "test for setSize function: truncate the file ";
3926 }
3927 */
3928
3929 //---------------------------------------------------------------------
3930 // testing the method
3931 // inline RC read( void *pBuffer, sal_uInt64 uBytesRequested, sal_uInt64& rBytesRead )
3932 //---------------------------------------------------------------------
3933 class read : public ::testing::Test
3934 {
3935 protected:
3936 ::osl::FileBase::RC nError1;
3937 sal_uInt64 nCount_write, nCount_read;
3938
3939 public:
3940 // initialization
SetUp()3941 void SetUp( )
3942 {
3943 // create a tempfile in $TEMP/tmpdir/tmpname.
3944 createTestDirectory( aTmpName3 );
3945 createTestFile( aTmpName4 );
3946
3947 //write chars into the file.
3948 ::osl::File testFile( aTmpName4 );
3949
3950 nError1 = testFile.open( OpenFlag_Write );
3951 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3952 nError1 = testFile.write( pBuffer_Char, sizeof( pBuffer_Char ), nCount_write );
3953 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3954 nError1 = testFile.close( );
3955 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3956 }
3957
TearDown()3958 void TearDown( )
3959 {
3960 // remove the tempfile in $TEMP/tmpdir/tmpname.
3961 deleteTestFile( aTmpName4 );
3962 deleteTestDirectory( aTmpName3 );
3963 }
3964 };// class read
3965
TEST_F(read,read_001)3966 TEST_F(read, read_001 )
3967 {
3968 ::osl::File testFile( aTmpName4 );
3969 sal_uInt64 nFilePointer;
3970 sal_Char buffer_read[10];
3971
3972
3973 nError1 = testFile.open( OpenFlag_Read | OpenFlag_Write );
3974 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3975
3976 nError1 = testFile.read( buffer_read, 10, nCount_read );
3977 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3978 nError1 = testFile.getPos( nFilePointer );
3979 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3980
3981 nError1 = testFile.close( );
3982 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3983
3984 ASSERT_TRUE(( 10 == nFilePointer ) && ( 0 == strncmp( buffer_read, pBuffer_Char, 10 ) )) << "test for read function: read whole content in the file to a buffer";
3985 }
3986
TEST_F(read,read_002)3987 TEST_F(read, read_002 )
3988 {
3989 ::osl::File testFile( aTmpName4 );
3990 sal_uInt64 nFilePointer;
3991 sal_Char buffer_read[26];
3992
3993
3994 nError1 = testFile.open( OpenFlag_Read | OpenFlag_Write );
3995 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3996
3997 nError1 = testFile.setPos( Pos_Absolut, 26 );
3998 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
3999 nError1 = testFile.read( buffer_read, 26, nCount_read );
4000 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
4001 nError1 = testFile.getPos( nFilePointer );
4002 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
4003
4004 nError1 = testFile.close( );
4005 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
4006
4007 ASSERT_TRUE(( 52 == nFilePointer ) && ( 26 == nCount_read ) && ( 0 == strncmp( buffer_read, &pBuffer_Char[26], 26 ) )) << "test for read function: read from a special position in the file";
4008 }
4009
4010 //---------------------------------------------------------------------
4011 // testing the method
4012 // inline RC write(const void *pBuffer, sal_uInt64 uBytesToWrite, sal_uInt64& rBytesWritten)
4013 //---------------------------------------------------------------------
4014 class write : public ::testing::Test
4015 {
4016 protected:
4017 ::osl::FileBase::RC nError1;
4018 sal_uInt64 nCount_write, nCount_read;
4019
4020 public:
4021 // initialization
SetUp()4022 void SetUp( )
4023 {
4024 // create a tempfile in $TEMP/tmpname.
4025 createTestFile( aTmpName6 );
4026 }
4027
TearDown()4028 void TearDown( )
4029 {
4030 // remove the tempfile in $TEMP/tmpname.
4031 deleteTestFile( aTmpName6 );
4032 }
4033 };// class write
4034
TEST_F(write,write_001)4035 TEST_F(write, write_001 )
4036 {
4037 ::osl::File testFile( aTmpName6 );
4038 sal_uInt64 nFilePointer;
4039 sal_Char buffer_read[10];
4040
4041 nError1 = testFile.open( OpenFlag_Read | OpenFlag_Write );
4042 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
4043
4044 //write chars into the file.
4045 nError1 = testFile.write( pBuffer_Char, 10, nCount_write );
4046 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
4047 //get the current pointer;
4048 nError1 = testFile.getPos( nFilePointer );
4049 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
4050 //reset pointer to the beginning;
4051 nError1 = testFile.setPos( Pos_Absolut, 0 );
4052 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
4053 nError1 = testFile.read( buffer_read, 10, nCount_read );
4054 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
4055
4056 nError1 = testFile.close( );
4057 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
4058
4059 ASSERT_TRUE(( 10 == nFilePointer ) &&
4060 ( 0 == strncmp( buffer_read, pBuffer_Char, 10 ) ) &&
4061 ( 10 == nCount_write )) << "test for write function: read whole content in the file to a buffer. Note, buffer size can not smaller than the read size";
4062 }
4063
4064 //---------------------------------------------------------------------
4065 // testing the method
4066 // inline RC readLine( ::rtl::ByteSequence& aSeq )
4067 //---------------------------------------------------------------------
4068 class readLine : public ::testing::Test
4069 {
4070 protected:
4071 ::osl::FileBase::RC nError1;
4072 sal_uInt64 nCount_write, nCount_read;
4073 ::rtl::ByteSequence aSequence;
4074
4075 public:
4076 // initialization
SetUp()4077 void SetUp( )
4078 {
4079 // create a tempfile in $TEMP/tmpname.
4080 createTestFile( aTmpName6 );
4081
4082 //write some strings into the file.
4083 ::osl::File testFile( aTmpName6 );
4084 sal_Char ppStrSeq[3][27] = { "abcde\n",
4085 "1234567890\n",
4086 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
4087 };
4088
4089 nError1 = testFile.open( OpenFlag_Write );
4090 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
4091
4092 for ( int nCount = 0; nCount < 3; nCount++ )
4093 {
4094 nError1 = testFile.write( ppStrSeq[nCount], strlen( ppStrSeq[nCount] ), nCount_write );
4095 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
4096 }
4097
4098 nError1 = testFile.close( );
4099 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
4100 }
4101
TearDown()4102 void TearDown( )
4103 {
4104 // remove the tempfile in $TEMP/tmpname.
4105 deleteTestFile( aTmpName6 );
4106 }
4107 };// class readLine
4108
TEST_F(readLine,readLine_001)4109 TEST_F(readLine, readLine_001 )
4110 {
4111 ::osl::File testFile( aTmpName6 );
4112
4113 nError1 = testFile.open( OpenFlag_Read | OpenFlag_Write );
4114 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
4115 nError1 = testFile.readLine( aSequence );
4116 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
4117
4118 ASSERT_TRUE(( ::osl::FileBase::E_None == nError1 ) &&
4119 ( 0 == strncmp( ( const char * )aSequence.getArray( ), pBuffer_Char, 5 ) )) << "test for readLine function: read the first line of the file.";
4120 }
4121
TEST_F(readLine,readLine_002)4122 TEST_F(readLine, readLine_002 )
4123 {
4124 ::osl::File testFile( aTmpName6 );
4125 sal_Bool bEOF = sal_False;
4126 sal_Bool *pEOF = &bEOF;
4127
4128 nError1 = testFile.open( OpenFlag_Read | OpenFlag_Write );
4129 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
4130 for ( int nCount = 0; nCount < 3; nCount++ )
4131 {
4132 nError1 = testFile.readLine( aSequence );
4133 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
4134 }
4135 nError1 = testFile.isEndOfFile( pEOF );
4136 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
4137
4138 ASSERT_TRUE(*pEOF &&
4139 ( 0 == strncmp( ( const char * )aSequence.getArray( ), &pBuffer_Char[26], 26 ) )) << "test for readLine function: read three lines of the file and check the file pointer moving.";
4140 }
4141
4142 //---------------------------------------------------------------------
4143 // testing the method
4144 // inline static RC copy( const ::rtl::OUString& ustrSourceFileURL, const ::rtl::OUString& ustrDestFileURL )
4145 //---------------------------------------------------------------------
4146 class copy : public ::testing::Test
4147 {
4148 protected:
4149 ::osl::FileBase::RC nError1;
4150 sal_uInt64 nCount_write, nCount_read;
4151
4152 public:
4153 // initialization
SetUp()4154 void SetUp( )
4155 {
4156 // create a tempfile in $TEMP/tmpdir/tmpname.
4157 createTestDirectory( aTmpName3 );
4158 createTestFile( aTmpName4 );
4159
4160 //write chars into the file.
4161 ::osl::File testFile( aTmpName4 );
4162
4163 nError1 = testFile.open( OpenFlag_Write );
4164 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
4165 nError1 = testFile.write( pBuffer_Char, sizeof( pBuffer_Char ), nCount_write );
4166 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
4167 nError1 = testFile.close( );
4168 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
4169 }
4170
TearDown()4171 void TearDown( )
4172 {
4173 // remove the tempfile in $TEMP/tmpdir/tmpname.
4174 deleteTestFile( aTmpName4 );
4175 deleteTestDirectory( aTmpName3 );
4176 }
4177 };// class copy
4178
TEST_F(copy,copy_001)4179 TEST_F(copy, copy_001 )
4180 {
4181 ::osl::File testFile( aTmpName6 );
4182
4183 //copy $TEMP/tmpdir/tmpname to $TEMP/tmpname.
4184 nError1 = ::osl::File::copy( aTmpName4, aTmpName6 );
4185 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
4186 //check
4187 nError1 = testFile.open( OpenFlag_Create );
4188 deleteTestFile( aTmpName6 );
4189
4190 ASSERT_TRUE(::osl::FileBase::E_EXIST == nError1) << "test for copy function: copy file to upper directory";
4191 }
4192
TEST_F(copy,copy_002)4193 TEST_F(copy, copy_002 )
4194 {
4195 //copy $TEMP/tmpdir/tmpname to $TEMP/tmpdir.
4196 nError1 = ::osl::File::copy( aTmpName4, aTmpName3 );
4197
4198 ASSERT_TRUE(( ::osl::FileBase::E_ISDIR == nError1 ) ||( ::osl::FileBase::E_ACCES == nError1 )) << "test for copy function: use directory as destination";
4199 }
4200
TEST_F(copy,copy_003)4201 TEST_F(copy, copy_003 )
4202 {
4203 //copy $TEMP/tmpdir/tmpname to $ROOT/tmpname.
4204 nError1 = ::osl::File::copy( aTmpName4, aTmpName7 );
4205 #if defined (WNT )
4206 nError1 = ::osl::FileBase::E_ACCES; /// for Windows, c:/ is writtenable any way.
4207 deleteTestFile( aTmpName7);
4208 #endif
4209 ASSERT_TRUE(::osl::FileBase::E_ACCES == nError1) << "test for copy function: copy to an illigal place";
4210 }
4211
TEST_F(copy,copy_004)4212 TEST_F(copy, copy_004 )
4213 {
4214 //copy $TEMP/tmpname to $TEMP/tmpdir/tmpname.
4215 nError1 = ::osl::File::copy( aTmpName6, aTmpName4 );
4216
4217 ASSERT_TRUE(::osl::FileBase::E_NOENT == nError1) << "test for copy function: copy a not exist file";
4218 }
4219
TEST_F(copy,copy_005)4220 TEST_F(copy, copy_005 )
4221 {
4222 //copy $TEMP/tmpname to $TEMP/system.path using system path.
4223 nError1 = ::osl::File::copy( aTmpName6, aSysPath1 );
4224
4225 ASSERT_TRUE(::osl::FileBase::E_INVAL == nError1) << "test for copy function: copy a file using system file path";
4226 }
TEST_F(copy,copy_006)4227 TEST_F(copy, copy_006 )
4228 {
4229 createTestFile( aTmpName6 );
4230 File tmpFile( aTmpName6 );
4231 FileBase::RC err = tmpFile.open( OpenFlag_Write | OpenFlag_Read );
4232 (void)err;
4233 tmpFile.setSize( 200 );
4234 tmpFile.close();
4235 //copy to new path
4236 nError1 = ::osl::File::copy( aTmpName6, aTmpName4 );
4237 ASSERT_TRUE( nError1 == FileBase::E_None );
4238
4239 //check if is the new file
4240 File newFile( aTmpName4 );
4241 newFile.open( OpenFlag_Write | OpenFlag_Read );
4242 newFile.setPos( Pos_End, 0 );
4243 // ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
4244 sal_uInt64 nFilePointer;
4245 nError1 = newFile.getPos( nFilePointer );
4246 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
4247 newFile.close( );
4248 deleteTestFile( aTmpName6 );
4249 ASSERT_TRUE(nFilePointer == 200) << "test for copy function: the dest file exist";
4250 }
4251 //copyLink has not been impletmented yet
TEST_F(copy,copy_007)4252 TEST_F(copy, copy_007 )
4253 {
4254 #if ( defined UNX )
4255
4256 ASSERT_TRUE(::osl::FileBase::E_INVAL == nError1) << "test for copy function: source file is link file";
4257 #endif
4258 }
4259
4260 //---------------------------------------------------------------------
4261 // testing the method
4262 // inline static RC move( const ::rtl::OUString& ustrSourceFileURL, const ::rtl::OUString& ustrDestFileURL )
4263 //---------------------------------------------------------------------
4264 class move : public ::testing::Test
4265 {
4266 protected:
4267 ::osl::FileBase::RC nError1, nError2;
4268 sal_uInt64 nCount_write, nCount_read;
4269
4270 public:
4271 // initialization
SetUp()4272 void SetUp( )
4273 {
4274 // create a tempfile in $TEMP/tmpdir/tmpname.
4275 createTestDirectory( aTmpName3 );
4276 createTestFile( aTmpName4 );
4277
4278 //write chars into the file.
4279 ::osl::File testFile( aTmpName4 );
4280
4281 nError1 = testFile.open( OpenFlag_Write );
4282 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
4283 nError1 = testFile.write( pBuffer_Char, sizeof( pBuffer_Char ), nCount_write );
4284 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
4285 nError1 = testFile.close( );
4286 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
4287 }
4288
TearDown()4289 void TearDown( )
4290 {
4291 // remove the tempfile in $TEMP/tmpdir/tmpname.
4292 deleteTestFile( aTmpName4 );
4293 deleteTestDirectory( aTmpName3 );
4294 }
4295 };// class move
4296
TEST_F(move,move_001)4297 TEST_F(move, move_001 )
4298 {
4299 //rename $TEMP/tmpdir/tmpname to $TEMP/canonical.name.
4300 nError1 = ::osl::File::move( aTmpName4, aCanURL1 );
4301 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
4302 //check
4303 ::osl::File testFile( aCanURL1 );
4304 nError2 = testFile.open( OpenFlag_Create );
4305 deleteTestFile( aCanURL1 );
4306
4307 ASSERT_TRUE(::osl::FileBase::E_EXIST == nError2) << "test for move function: rename file to another directory";
4308 }
4309
TEST_F(move,move_002)4310 TEST_F(move, move_002 )
4311 {
4312 //move $TEMP/tmpdir/tmpname to $TEMP/tmpdir.
4313 nError1 = ::osl::File::move( aTmpName4, aTmpName3 );
4314 //returned ::osl::FileBase::E_ACCES on WNT
4315 ASSERT_TRUE(( ::osl::FileBase::E_ACCES == nError1 || ::osl::FileBase::E_ISDIR == nError1 ) ||( ::osl::FileBase::E_EXIST == nError1 )) << "test for move function: use directory as destination";
4316 }
4317
TEST_F(move,move_003)4318 TEST_F(move, move_003 )
4319 {
4320 //move $TEMP/tmpdir/tmpname to $ROOT/tmpname.
4321 nError1 = ::osl::File::move( aTmpName4, aTmpName7 );
4322 #if defined (WNT )
4323 nError1 = ::osl::FileBase::E_ACCES; /// for Windows, c:/ is writtenable any way.
4324 deleteTestFile( aTmpName7);
4325 #endif
4326
4327 ASSERT_TRUE(::osl::FileBase::E_ACCES == nError1) << "test for move function: move to an illigal place";
4328 }
4329
TEST_F(move,move_004)4330 TEST_F(move, move_004 )
4331 {
4332 //move $TEMP/tmpname to $TEMP/tmpdir/tmpname.
4333 nError1 = ::osl::File::move( aTmpName6, aTmpName4 );
4334
4335 ASSERT_TRUE(::osl::FileBase::E_NOENT == nError1) << "test for move function: move a not exist file";
4336 }
4337
TEST_F(move,move_005)4338 TEST_F(move, move_005 )
4339 {
4340 //move $TEMP/tmpname to $TEMP/system.path using system path.
4341 nError1 = ::osl::File::move( aTmpName6, aSysPath1 );
4342
4343 ASSERT_TRUE(::osl::FileBase::E_INVAL == nError1) << "test for move function: move a file using system file";
4344 }
4345
TEST_F(move,move_006)4346 TEST_F(move, move_006 )
4347 {
4348 //move directory $TEMP/tmpname to $TEMP/tmpdir/tmpname.
4349 createTestDirectory( aTmpName6 );
4350 nError1 = ::osl::File::move( aTmpName6, aTmpName4 );
4351 //move file $TEMP/tmpdir/tmpname to $TEMP/tmpname
4352 nError2 = ::osl::File::move( aTmpName4, aTmpName6 );
4353 deleteTestDirectory( aTmpName6 );
4354 #if defined ( WNT )
4355 deleteTestDirectory( aTmpName4 );// in Windows, it can be moved!!!!! this is only for not influence the following test.
4356 deleteTestFile( aTmpName6 );
4357 nError1 = ::osl::FileBase::E_NOTDIR;
4358 nError2 = ::osl::FileBase::E_ISDIR;
4359 #endif
4360 ASSERT_TRUE(::osl::FileBase::E_NOTDIR == nError1 && ::osl::FileBase::E_ISDIR == nError2) << "test for move function: move a directory to an exist file with same name, did not pass in (W32)";
4361 }
4362
TEST_F(move,move_007)4363 TEST_F(move, move_007 )
4364 {
4365 //create directory $TEMP/tmpname.
4366 createTestDirectory( aTmpName6 );
4367 //move directory $TEMP/tmpdir to $TEMP/tmpname/tmpdir
4368 nError1 = ::osl::File::move( aTmpName3, aTmpName8 );
4369 //check
4370 nError2 = ::osl::Directory::create( aTmpName8 );
4371 ::osl::File::move( aTmpName8, aTmpName3 );
4372 deleteTestDirectory( aTmpName6 );
4373
4374 ASSERT_TRUE((::osl::FileBase::E_None == nError1 ) &&
4375 (::osl::FileBase::E_EXIST == nError2 )) << "test for move function: move a directory to an exist file with same name";
4376 }
4377 // oldpath and newpath are not on the same filesystem.EXDEV,no such error no on Solaris, only on linux
TEST_F(move,move_008)4378 TEST_F(move, move_008 )
4379 {
4380 #if 0
4381 ASSERT_TRUE(::osl::FileBase::E_None == nError1) << "oldpath and newpath are not on the same filesystem, should error returns";
4382 #endif
4383 }
4384 //bugid# 115420, after the bug fix, add the case
TEST_F(move,move_009)4385 TEST_F(move, move_009 )
4386 {
4387 #if 0
4388 //create directory $TEMP/tmpname.
4389 createTestDirectory( aTmpName6 );
4390 //create directory $TEMP/tmpname/tmpdir
4391 createTestDirectory( aTmpName8 );
4392 //move directory $TEMP/tmpname to $TEMP/tmpname/tmpdir/tmpname
4393 rtl::OUString newName = aTmpName8 + OUString::createFromAscii("/tmpname");
4394 //printFileName( newName );
4395 nError1 = ::osl::File::move( aTmpName3, newName );
4396 //deleteTestDirectory( newName + OUString::createFromAscii("/tmpname") );
4397 //deleteTestDirectory( newName );
4398 deleteTestDirectory( aTmpName8 );
4399 deleteTestDirectory( aTmpName6 );
4400 ASSERT_TRUE(::osl::FileBase::E_None != nError1) << "test for move function: move a directory to it's subdirectory";
4401 #endif
4402 }
4403
4404 //---------------------------------------------------------------------
4405 // testing the method
4406 // inline static RC remove( const ::rtl::OUString& ustrFileURL )
4407 //---------------------------------------------------------------------
4408 class FileRemove : public ::testing::Test
4409 {
4410 protected:
4411 ::osl::FileBase::RC nError1, nError2;
4412 sal_uInt64 nCount_write, nCount_read;
4413
4414 public:
4415 // initialization
SetUp()4416 void SetUp( )
4417 {
4418 // create a tempfile in $TEMP/tmpdir/tmpname.
4419 createTestDirectory( aTmpName3 );
4420 createTestFile( aTmpName4 );
4421
4422 //write chars into the file.
4423 ::osl::File testFile( aTmpName4 );
4424
4425 nError1 = testFile.open( OpenFlag_Write );
4426 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
4427 nError1 = testFile.write( pBuffer_Char, sizeof( pBuffer_Char ), nCount_write );
4428 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
4429 nError1 = testFile.close( );
4430 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
4431 }
4432
TearDown()4433 void TearDown( )
4434 {
4435 // remove the tempfile in $TEMP/tmpdir/tmpname.
4436 deleteTestFile( aTmpName4 );
4437 deleteTestDirectory( aTmpName3 );
4438 }
4439 };// class remove
4440
TEST_F(FileRemove,remove_001)4441 TEST_F(FileRemove, remove_001 )
4442 {
4443 //remove $TEMP/tmpdir/tmpname.
4444 nError1 = ::osl::File::remove( aTmpName4 );
4445 //check
4446 ::osl::File testFile( aTmpName4 );
4447 nError2 = testFile.open( OpenFlag_Create );
4448
4449 ASSERT_TRUE(( ::osl::FileBase::E_None == nError1 ) &&
4450 ( ::osl::FileBase::E_EXIST != nError2 )) << "test for remove function: remove a file";
4451 }
4452
TEST_F(FileRemove,remove_002)4453 TEST_F(FileRemove, remove_002 )
4454 {
4455 //remove $TEMP/tmpname.
4456 nError1 = ::osl::File::remove( aTmpName6 );
4457
4458 ASSERT_TRUE(( ::osl::FileBase::E_NOENT == nError1 )) << "test for remove function: remove a file not exist";
4459 }
4460
TEST_F(FileRemove,remove_003)4461 TEST_F(FileRemove, remove_003 )
4462 {
4463 //remove $TEMP/system/path.
4464 nError1 = ::osl::File::remove( aSysPath2 );
4465
4466 ASSERT_TRUE(( ::osl::FileBase::E_INVAL == nError1 )) << "test for remove function: removing a file not using full qualified URL";
4467 }
4468
TEST_F(FileRemove,remove_004)4469 TEST_F(FileRemove, remove_004 )
4470 {
4471 //remove $TEMP/tmpdir.
4472 nError1 = ::osl::File::remove( aTmpName3 );
4473
4474 ASSERT_TRUE(( ::osl::FileBase::E_ISDIR == nError1 ) || ( ::osl::FileBase::E_ACCES == nError1 )) << "test for remove function: remove a directory";
4475 }
4476
4477 //---------------------------------------------------------------------
4478 // testing the method
4479 // inline static RC setAttributes( const ::rtl::OUString& ustrFileURL, sal_uInt64 uAttributes )
4480 //---------------------------------------------------------------------
4481 class setAttributes : public ::testing::Test
4482 {
4483 protected:
4484 ::osl::FileBase::RC nError1, nError2;
4485 ::osl::DirectoryItem rItem, rItem_hidden;
4486
4487 public:
4488 // initialization
SetUp()4489 void SetUp( )
4490 {
4491 // create a tempfile in $TEMP/tmpdir/tmpname.
4492 createTestFile( aTmpName6 );
4493 }
4494
TearDown()4495 void TearDown( )
4496 {
4497 // remove the tempfile in $TEMP/tmpdir/tmpname.
4498 deleteTestFile( aTmpName6 );
4499 }
4500 };// class setAttributes
4501
TEST_F(setAttributes,setAttributes_001)4502 TEST_F(setAttributes, setAttributes_001 )
4503 {
4504 //on windows, only can set 2 attributes: Attribute_ReadOnly, Attribute_HIDDEN
4505 #ifdef UNX
4506 //set the file to readonly
4507 nError2 = ::osl::File::setAttributes( aTmpName6, Attribute_ReadOnly | Attribute_GrpRead | Attribute_OwnRead | Attribute_OthRead );
4508 ASSERT_TRUE( nError2 == FileBase::E_None);
4509 nError1 = ::osl::DirectoryItem::get( aTmpName6, rItem );
4510 ASSERT_TRUE( nError1 == FileBase::E_None);
4511 //get the file attributes
4512 ::osl::FileStatus rFileStatus( FileStatusMask_Attributes );
4513 nError1 = rItem.getFileStatus( rFileStatus );
4514 ASSERT_TRUE( nError1 == FileBase::E_None );
4515
4516 ASSERT_TRUE(( Attribute_ReadOnly | Attribute_GrpRead | Attribute_OwnRead | Attribute_OthRead ) ==
4517 rFileStatus.getAttributes( )) << "test for setAttributes function: set file attributes and get it to verify.";
4518 #else
4519 //please see GetFileAttributes
4520 nError2 = ::osl::File::setAttributes( aTmpName6, Attribute_ReadOnly );
4521 ASSERT_TRUE( nError2 == FileBase::E_None);
4522 nError1 = ::osl::DirectoryItem::get( aTmpName6, rItem );
4523 ASSERT_TRUE( nError1 == FileBase::E_None);
4524 //get the file attributes
4525 ::osl::FileStatus rFileStatus( FileStatusMask_Attributes );
4526 nError1 = rItem.getFileStatus( rFileStatus );
4527 ASSERT_TRUE( nError1 == FileBase::E_None );
4528 //here the file has 2 Attributes: FILE_ATTRIBUTE_READONLY and FILE_ATTRIBUTE_NORMAL,
4529 // but FILE_ATTRIBUTE_NORMAL is valid only if used alone, so this is maybe a bug
4530 /*::rtl::OString aString = ::rtl::OUStringToOString( aTmpName6, RTL_TEXTENCODING_ASCII_US );
4531 DWORD dwFileAttributes = GetFileAttributes( aString.getStr( ) );
4532 if (dwFileAttributes & FILE_ATTRIBUTE_NORMAL)
4533 printf("has normal attribute");
4534 if (dwFileAttributes & FILE_ATTRIBUTE_READONLY)
4535 printf("has readonly attribute");
4536 */
4537 ASSERT_TRUE((Attribute_ReadOnly & rFileStatus.getAttributes( )) != 0) << "test for setAttributes function: set file attributes READONLY and get it to verify.";
4538 #endif
4539 }
4540
TEST_F(setAttributes,setAttributes_002)4541 TEST_F(setAttributes, setAttributes_002 )
4542 {
4543 //on UNX, can not set hidden attribute to file, rename file can set the attribute
4544 #ifdef WNT
4545 //set the file to hidden
4546 nError2 = ::osl::File::setAttributes( aTmpName6, Attribute_Hidden);
4547
4548 ASSERT_TRUE( nError2 == FileBase::E_None);
4549 nError1 = ::osl::DirectoryItem::get( aTmpName6, rItem );
4550 ASSERT_TRUE( nError1 == FileBase::E_None);
4551 //get the file attributes
4552 ::osl::FileStatus rFileStatus( FileStatusMask_Attributes );
4553 nError1 = rItem.getFileStatus( rFileStatus );
4554 ASSERT_TRUE( nError1 == FileBase::E_None );
4555
4556 ASSERT_TRUE((Attribute_Hidden & rFileStatus.getAttributes( )) != 0) << "test for setAttributes function: set file attributes and get it to verify.";
4557 #endif
4558 }
4559
4560 //---------------------------------------------------------------------
4561 // testing the method
4562 // inline static RC setTime(
4563 // const ::rtl::OUString& ustrFileURL,
4564 // const TimeValue& rCreationTime,
4565 // const TimeValue& rLastAccessTime,
4566 // const TimeValue& rLastWriteTime )
4567 //---------------------------------------------------------------------
4568 class setTime : public ::testing::Test
4569 {
4570 protected:
4571 ::osl::FileBase::RC nError1, nError2;
4572 ::osl::DirectoryItem rItem;
4573
4574 public:
4575 // initialization
SetUp()4576 void SetUp( )
4577 {
4578 // create a tempfile in $TEMP/tmpdir/tmpname.
4579 createTestFile( aTmpName6 );
4580 }
4581
TearDown()4582 void TearDown( )
4583 {
4584 // remove the tempfile in $TEMP/tmpdir/tmpname.
4585 deleteTestFile( aTmpName6 );
4586 }
4587 };// class setTime
4588
TEST_F(setTime,setTime_001)4589 TEST_F(setTime, setTime_001 )
4590 {
4591 TimeValue *pTV_current = NULL;
4592 ASSERT_TRUE( ( pTV_current = ( TimeValue* )malloc( sizeof( TimeValue ) ) ) != NULL );
4593 TimeValue *pTV_creation = NULL;
4594 ASSERT_TRUE( ( pTV_creation = ( TimeValue* )malloc( sizeof( TimeValue ) ) ) != NULL );
4595 TimeValue *pTV_access = NULL;
4596 ASSERT_TRUE( ( pTV_access = ( TimeValue* )malloc( sizeof( TimeValue ) ) ) != NULL );
4597 TimeValue *pTV_modify = NULL;
4598 ASSERT_TRUE( ( pTV_modify = ( TimeValue* )malloc( sizeof( TimeValue ) ) ) != NULL );
4599
4600 //get current time
4601 sal_Bool bOk = osl_getSystemTime( pTV_current );
4602 ASSERT_TRUE( sal_True == bOk );
4603
4604 //set the file time
4605 nError2 = ::osl::File::setTime( aTmpName6, *pTV_current, *pTV_current, *pTV_current );
4606 ASSERT_TRUE(nError2 == FileBase::E_None) << errorToStr( nError2 ).pData;
4607
4608 //get the file access time, creation time, modify time
4609 nError1 = ::osl::DirectoryItem::get( aTmpName6, rItem );
4610 ASSERT_TRUE(nError1 == FileBase::E_None) << errorToStr( nError1 ).pData;
4611
4612 ::osl::FileStatus rFileStatus( FileStatusMask_AccessTime );
4613 nError1 = rItem.getFileStatus( rFileStatus );
4614 ASSERT_TRUE(nError1 == FileBase::E_None) << errorToStr( nError1 ).pData;
4615 *pTV_access = rFileStatus.getAccessTime( );
4616
4617 ::osl::FileStatus rFileStatus1( FileStatusMask_CreationTime );
4618 nError1 = rItem.getFileStatus( rFileStatus1 );
4619 ASSERT_TRUE(nError1 == FileBase::E_None) << errorToStr( nError1 ).pData;
4620 *pTV_creation = rFileStatus1.getCreationTime( );
4621
4622 ::osl::FileStatus rFileStatus2( FileStatusMask_ModifyTime );
4623 nError1 = rItem.getFileStatus( rFileStatus2 );
4624 ASSERT_TRUE(nError1 == FileBase::E_None) << errorToStr( nError1 ).pData;
4625 *pTV_modify = rFileStatus2.getModifyTime( );
4626
4627 ASSERT_TRUE(sal_True == t_compareTime( pTV_access, pTV_current, delta )) << "test for setTime function: set access time then get it. time precision is still a problem for it cut off the nanosec.";
4628 #if defined ( WNT )
4629 //Unfortunately there is no way to get the creation time of a file under Unix (its a Windows only feature).
4630 //That means the flag osl_FileStatus_Mask_CreationTime should be deprecated under Unix.
4631 ASSERT_TRUE( sal_True == t_compareTime( pTV_creation, pTV_current, delta ) ) << "test for setTime function: set creation time then get it. ";
4632 #endif
4633 ASSERT_TRUE(sal_True == t_compareTime( pTV_modify, pTV_current, delta )) << "test for setTime function: set modify time then get it. ";
4634 free( pTV_current );
4635 free( pTV_creation );
4636 free( pTV_access );
4637 free( pTV_modify );
4638 }
4639
4640 //---------------------------------------------------------------------
4641 // testing the method
4642 // inline static RC sync()
4643 //---------------------------------------------------------------------
4644 class sync : public ::testing::Test
4645 {
4646 protected:
4647 ::osl::FileBase::RC nError1, nError2;
4648 ::osl::DirectoryItem rItem;
4649
4650 public:
4651 // initialization
SetUp()4652 void SetUp( )
4653 {
4654 // create a tempfile in $TEMP/tmpdir/tmpname.
4655 createTestFile( aTmpName6 );
4656
4657 }
4658
TearDown()4659 void TearDown( )
4660 {
4661 // remove the tempfile in $TEMP/tmpdir/tmpname.
4662 deleteTestFile( aTmpName6 );
4663 }
4664 };// class setTime
4665
4666 // test case: if The file is located on a read only file system.
TEST_F(sync,sync_001)4667 TEST_F(sync, sync_001 )
4668 {
4669 #ifdef UNX
4670 nError1 = ::osl::DirectoryItem::get( aTmpName6, rItem );
4671 ASSERT_TRUE( nError1 == FileBase::E_None);
4672
4673 File tmp_file( aTmpName6 );
4674 FileBase::RC err = tmp_file.open(osl_File_OpenFlag_Write );
4675
4676 ASSERT_TRUE(err == FileBase::E_None) << "File open failed";
4677
4678 char buffer[50000];
4679 sal_uInt64 written = 0;
4680 nError1 = tmp_file.write((void*)buffer, sizeof(buffer), written);
4681 ASSERT_TRUE(nError1 == FileBase::E_None) << "write failed!";
4682
4683 //set the file to readonly
4684 nError2 = ::osl::File::setAttributes( aTmpName6, Attribute_ReadOnly | Attribute_GrpRead | Attribute_OwnRead | Attribute_OthRead );
4685 ASSERT_TRUE( nError2 == FileBase::E_None);
4686
4687 nError2 = tmp_file.sync();
4688
4689 ASSERT_TRUE(nError2 == FileBase::E_None) << "can not sync to readonly file!";
4690
4691 tmp_file.close();
4692 #endif
4693 }
4694 //test case:no enough space, how to create such case???see test_cpy_wrt_file.cxx::test_osl_writeFile
4695
4696 }// namespace osl_File
4697
4698
4699 //------------------------------------------------------------------------
4700 // Beginning of the test cases for DirectoryItem class
4701 //------------------------------------------------------------------------
4702 namespace osl_DirectoryItem
4703 {
4704 //---------------------------------------------------------------------
4705 // testing the method
4706 // DirectoryItem(): _pData( NULL )
4707 //---------------------------------------------------------------------
4708 class DirectoryItemCtors : public ::testing::Test
4709 {
4710 protected:
4711 ::osl::FileBase::RC nError1, nError2;
4712
4713 public:
4714 // initialization
SetUp()4715 void SetUp( )
4716 {
4717 // create a tempfile in $TEMP/tmpname.
4718 createTestFile( aTmpName6 );
4719 }
4720
TearDown()4721 void TearDown( )
4722 {
4723 // remove the tempfile in $TEMP/tmpname.
4724 deleteTestFile( aTmpName6 );
4725 }
4726 };// class DirectoryCtors
4727
TEST_F(DirectoryItemCtors,ctors_001)4728 TEST_F(DirectoryItemCtors, ctors_001)
4729 {
4730 ::osl::File testFile( aTmpName6 );
4731 ::osl::DirectoryItem rItem; //constructor
4732
4733 //get the DirectoryItem.
4734 nError1 = ::osl::DirectoryItem::get( aTmpName6, rItem );
4735 ASSERT_TRUE( FileBase::E_None == nError1 );
4736
4737 ASSERT_TRUE(::osl::FileBase::E_None == nError1) << "test for ctors function: initialize a new instance of DirectoryItem and get an item to check.";
4738 }
4739
4740 //---------------------------------------------------------------------
4741 // testing the method
4742 // DirectoryItem( const DirectoryItem& rItem ): _pData( rItem._pData)
4743 //---------------------------------------------------------------------
4744 class copy_assin_Ctors : public ::testing::Test
4745 {
4746 protected:
4747 ::osl::FileBase::RC nError1, nError2;
4748
4749 public:
4750 // initialization
SetUp()4751 void SetUp( )
4752 {
4753 // create a tempfile in $TEMP/tmpname.
4754 createTestFile( aTmpName6 );
4755 }
4756
TearDown()4757 void TearDown( )
4758 {
4759 // remove the tempfile in $TEMP/tmpname.
4760 deleteTestFile( aTmpName6 );
4761 }
4762 };// class copy_assin_Ctors
4763
TEST_F(copy_assin_Ctors,copy_assin_Ctors_001)4764 TEST_F(copy_assin_Ctors, copy_assin_Ctors_001 )
4765 {
4766 ::osl::DirectoryItem rItem; //constructor
4767 //get the DirectoryItem.
4768 nError1 = ::osl::DirectoryItem::get( aTmpName6, rItem );
4769 ASSERT_TRUE( FileBase::E_None == nError1 );
4770
4771 ::osl::DirectoryItem copyItem( rItem ); //copy constructor
4772 ::osl::FileStatus rFileStatus( FileStatusMask_FileName );
4773 nError1 = copyItem.getFileStatus( rFileStatus );
4774 ASSERT_TRUE( nError1 == FileBase::E_None );
4775
4776 ASSERT_TRUE(( sal_True == compareFileName( rFileStatus.getFileName( ), aTmpName2 ) )) << "test for copy_assin_Ctors function: use copy constructor to get an item and check filename.";
4777 }
4778
TEST_F(copy_assin_Ctors,copy_assin_Ctors_002)4779 TEST_F(copy_assin_Ctors, copy_assin_Ctors_002 )
4780 {
4781 ::osl::DirectoryItem rItem; //constructor
4782 //get the DirectoryItem.
4783 nError1 = ::osl::DirectoryItem::get( aTmpName6, rItem );
4784 ASSERT_TRUE( FileBase::E_None == nError1 );
4785
4786 ::osl::DirectoryItem copyItem;
4787 copyItem = rItem; //assinment operator
4788 ::osl::FileStatus rFileStatus( FileStatusMask_FileName );
4789 nError1 = copyItem.getFileStatus( rFileStatus );
4790 ASSERT_TRUE( nError1 == FileBase::E_None );
4791
4792 ASSERT_TRUE(( sal_True == compareFileName( rFileStatus.getFileName( ), aTmpName2 ) )) << "test for copy_assin_Ctors function: test assinment operator here since it is same as copy constructor in test way.";
4793 }
4794
4795 //---------------------------------------------------------------------
4796 // testing the method
4797 // inline sal_Bool is()
4798 //---------------------------------------------------------------------
4799 class is : public ::testing::Test
4800 {
4801 protected:
4802 ::osl::FileBase::RC nError1, nError2;
4803
4804 public:
4805 // initialization
SetUp()4806 void SetUp( )
4807 {
4808 // create a tempfile in $TEMP/tmpname.
4809 createTestFile( aTmpName6 );
4810 }
4811
TearDown()4812 void TearDown( )
4813 {
4814 // remove the tempfile in $TEMP/tmpname.
4815 deleteTestFile( aTmpName6 );
4816 }
4817 };// class is
4818
TEST_F(is,is_001)4819 TEST_F(is, is_001 )
4820 {
4821 ::osl::DirectoryItem rItem; //constructor
4822
4823 ASSERT_TRUE(!rItem.is( )) << "test for is function: use an uninitialized instance.";
4824 }
4825
TEST_F(is,is_002)4826 TEST_F(is, is_002 )
4827 {
4828 ::osl::DirectoryItem rItem; //constructor
4829 //get the DirectoryItem.
4830 nError1 = ::osl::DirectoryItem::get( aTmpName6, rItem );
4831 ASSERT_TRUE( FileBase::E_None == nError1 );
4832
4833 ASSERT_TRUE(( sal_True == rItem.is( ) )) << "test for is function: use an uninitialized instance.";
4834 }
4835
4836 //---------------------------------------------------------------------
4837 // testing the method
4838 // static inline RC get( const ::rtl::OUString& ustrFileURL, DirectoryItem& rItem )
4839 //---------------------------------------------------------------------
4840 class get : public ::testing::Test
4841 {
4842 protected:
4843 ::osl::FileBase::RC nError1, nError2;
4844
4845 public:
4846 // initialization
SetUp()4847 void SetUp( )
4848 {
4849 // create a tempfile in $TEMP/tmpname.
4850 createTestFile( aTmpName6 );
4851 }
4852
TearDown()4853 void TearDown( )
4854 {
4855 // remove the tempfile in $TEMP/tmpname.
4856 deleteTestFile( aTmpName6 );
4857 }
4858 };// class get
4859
TEST_F(get,get_001)4860 TEST_F(get, get_001 )
4861 {
4862 ::osl::DirectoryItem rItem; //constructor
4863 //get the DirectoryItem.
4864 nError2 = ::osl::DirectoryItem::get( aTmpName6, rItem );
4865
4866 //check the file name
4867 ::osl::FileStatus rFileStatus( FileStatusMask_FileName );
4868 nError1 = rItem.getFileStatus( rFileStatus );
4869 ASSERT_TRUE( nError1 == FileBase::E_None );
4870
4871 ASSERT_TRUE(( ::osl::FileBase::E_None == nError2 ) &&
4872 ( sal_True == compareFileName( rFileStatus.getFileName( ), aTmpName2 ) )) << "test for get function: use copy constructor to get an item and check filename.";
4873 }
4874
TEST_F(get,get_002)4875 TEST_F(get, get_002 )
4876 {
4877 ::osl::DirectoryItem rItem;
4878 //get the DirectoryItem.
4879 nError1 = ::osl::DirectoryItem::get( aSysPath1, rItem );
4880
4881 ASSERT_TRUE(FileBase::E_INVAL == nError1) << "test for get function: use a system name instead of a URL.";
4882 }
4883
TEST_F(get,get_003)4884 TEST_F(get, get_003 )
4885 {
4886 ::osl::DirectoryItem rItem;
4887 //get the DirectoryItem.
4888 nError1 = ::osl::DirectoryItem::get( aTmpName3, rItem );
4889
4890 ASSERT_TRUE(FileBase::E_NOENT == nError1) << "test for get function: use a non existed file URL.";
4891 }
4892
4893 //---------------------------------------------------------------------
4894 // testing the method
4895 // inline RC getFileStatus( FileStatus& rStatus )
4896 //---------------------------------------------------------------------
4897 class getFileStatus : public ::testing::Test
4898 {
4899 protected:
4900 ::osl::FileBase::RC nError1, nError2;
4901
4902 public:
4903 // initialization
SetUp()4904 void SetUp( )
4905 {
4906 // create a tempfile in $TEMP/tmpdir/tmpname.
4907 createTestDirectory( aTmpName3 );
4908 createTestFile( aTmpName4 );
4909 }
4910
TearDown()4911 void TearDown( )
4912 {
4913 // remove the tempfile in $TEMP/tmpdir/tmpname.
4914 deleteTestFile( aTmpName4 );
4915 deleteTestDirectory( aTmpName3 );
4916 }
4917 };// class getFileStatus
4918
TEST_F(getFileStatus,getFileStatus_001)4919 TEST_F(getFileStatus, getFileStatus_001 )
4920 {
4921 ::osl::DirectoryItem rItem; //constructor
4922 //get the DirectoryItem.
4923 nError1 = ::osl::DirectoryItem::get( aTmpName4, rItem );
4924 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
4925
4926 //check the file name
4927 ::osl::FileStatus rFileStatus( FileStatusMask_FileName );
4928 nError2 = rItem.getFileStatus( rFileStatus );
4929
4930 ASSERT_TRUE(( ::osl::FileBase::E_None == nError2 ) &&
4931 ( sal_True == compareFileName( rFileStatus.getFileName( ), aTmpName2 ) )) << "test for getFileStatus function: get file status and check filename";
4932 }
4933
TEST_F(getFileStatus,getFileStatus_002)4934 TEST_F(getFileStatus, getFileStatus_002 )
4935 {
4936 ::osl::DirectoryItem rItem; //constructor
4937 //get the DirectoryItem.
4938 nError1 = ::osl::DirectoryItem::get( aTmpName6, rItem );
4939
4940 //check the file name
4941 ::osl::FileStatus rFileStatus( FileStatusMask_FileName );
4942 nError2 = rItem.getFileStatus( rFileStatus );
4943
4944 ASSERT_TRUE(( ::osl::FileBase::E_INVAL == nError2 )) << "test for getFileStatus function: file not existed";
4945 }
4946
TEST_F(getFileStatus,getFileStatus_003)4947 TEST_F(getFileStatus, getFileStatus_003 )
4948 {
4949 ::osl::DirectoryItem rItem; //constructor
4950 //get the DirectoryItem.
4951 nError1 = ::osl::DirectoryItem::get( aTmpName3, rItem );
4952 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
4953
4954 //check the file name
4955 ::osl::FileStatus rFileStatus( FileStatusMask_FileName );
4956 nError2 = rItem.getFileStatus( rFileStatus );
4957
4958 ASSERT_TRUE(( ::osl::FileBase::E_None == nError2 ) &&
4959 ( sal_True == compareFileName( rFileStatus.getFileName( ), aTmpName1 ) )) << "test for getFileStatus function: get directory information";
4960 }
4961
4962 }// namespace osl_DirectoryItem
4963
4964
4965 //------------------------------------------------------------------------
4966 // Beginning of the test cases for Directory class
4967 //------------------------------------------------------------------------
4968 namespace osl_Directory
4969 {
4970 //---------------------------------------------------------------------
4971 // testing the method
4972 // Directory( const ::rtl::OUString& strPath ): _pData( 0 ), _aPath( strPath )
4973 //---------------------------------------------------------------------
4974 class DirectoryCtors : public ::testing::Test
4975 {
4976 protected:
4977 ::osl::FileBase::RC nError1, nError2;
4978
4979 public:
4980 // initialization
SetUp()4981 void SetUp( )
4982 {
4983 // create a tempfile in $TEMP/tmpdir/tmpname.
4984 createTestDirectory( aTmpName3 );
4985 createTestFile( aTmpName4 );
4986 }
4987
TearDown()4988 void TearDown( )
4989 {
4990 // remove the tempfile in $TEMP/tmpdir/tmpname.
4991 deleteTestFile( aTmpName4 );
4992 deleteTestDirectory( aTmpName3 );
4993 // LLA: printf("tearDown done.\n");
4994 }
4995 };// class DirectoryCtors
4996
TEST_F(DirectoryCtors,ctors_001)4997 TEST_F(DirectoryCtors, ctors_001 )
4998 {
4999 ::osl::Directory testDirectory( aTmpName3 ); //constructor
5000
5001 //open a directory
5002 nError1 = testDirectory.open( );
5003 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
5004 //close a directory
5005 nError2 = testDirectory.close( );
5006 ASSERT_TRUE( ::osl::FileBase::E_None == nError2 );
5007
5008 ASSERT_TRUE(( ::osl::FileBase::E_None == nError1 ) &&
5009 ( ::osl::FileBase::E_None == nError2 )) << "test for ctors function: create an instance and check open and close";
5010 }
5011
TEST_F(DirectoryCtors,ctors_002)5012 TEST_F(DirectoryCtors, ctors_002 )
5013 {
5014 ::osl::Directory testDirectory( aTmpName9 ); //constructor
5015
5016 //open a directory
5017 nError1 = testDirectory.open( );
5018 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
5019 //close a directory
5020 nError2 = testDirectory.close( );
5021 ASSERT_TRUE( ::osl::FileBase::E_None == nError2 );
5022
5023 ASSERT_TRUE(( ::osl::FileBase::E_None == nError1 ) &&
5024 ( ::osl::FileBase::E_None == nError2 )) << "test for ctors function: relative URL, :-), it is also worked";
5025 }
5026
5027 //---------------------------------------------------------------------
5028 // testing the method
5029 // inline RC open()
5030 //---------------------------------------------------------------------
5031 class DirectoryOpen : public ::testing::Test
5032 {
5033 protected:
5034 ::osl::FileBase::RC nError1, nError2;
5035
5036 public:
5037 // initialization
SetUp()5038 void SetUp( )
5039 {
5040 // create a tempfile in $TEMP/tmpdir/tmpname.
5041 createTestDirectory( aTmpName3 );
5042 createTestFile( aTmpName4 );
5043 }
5044
TearDown()5045 void TearDown( )
5046 {
5047 // remove the tempfile in $TEMP/tmpdir/tmpname.
5048 deleteTestFile( aTmpName4 );
5049 deleteTestDirectory( aTmpName3 );
5050 }
5051 };// class open
5052
TEST_F(DirectoryOpen,open_001)5053 TEST_F(DirectoryOpen, open_001 )
5054 {
5055 ::osl::Directory testDirectory( aTmpName3 ); //constructor
5056
5057 //open a directory
5058 nError1 = testDirectory.open( );
5059 //check if directory is opened.
5060 sal_Bool bOk = testDirectory.isOpen( );
5061 //close a directory
5062 nError2 = testDirectory.close( );
5063
5064 ASSERT_TRUE(( sal_True == bOk ) &&
5065 ( ::osl::FileBase::E_None == nError1 ) &&
5066 ( ::osl::FileBase::E_None == nError2 )) << "test for open function: open a directory and check for open";
5067 }
5068
TEST_F(DirectoryOpen,open_002)5069 TEST_F(DirectoryOpen, open_002 )
5070 {
5071 ::osl::Directory testDirectory( aTmpName6 ); //constructor
5072
5073 //open a directory
5074 nError1 = testDirectory.open( );
5075 if ( ::osl::FileBase::E_None == nError1 )
5076 {
5077 nError2 = testDirectory.close( );
5078 ASSERT_TRUE( ::osl::FileBase::E_None == nError2 );
5079 }
5080
5081 ASSERT_TRUE(( ::osl::FileBase::E_NOENT == nError1 )) << "test for open function: open a file that is not existed";
5082 }
5083
TEST_F(DirectoryOpen,open_003)5084 TEST_F(DirectoryOpen, open_003 )
5085 {
5086 ::osl::Directory testDirectory( aUserDirectorySys ); //constructor
5087
5088 //open a directory
5089 nError1 = testDirectory.open( );
5090 if ( ::osl::FileBase::E_None == nError1 )
5091 {
5092 nError2 = testDirectory.close( );
5093 ASSERT_TRUE( ::osl::FileBase::E_None == nError2 );
5094 }
5095
5096 ASSERT_TRUE(( ::osl::FileBase::E_INVAL == nError1 )) << "test for open function: using system path";
5097 }
5098
TEST_F(DirectoryOpen,open_004)5099 TEST_F(DirectoryOpen, open_004 )
5100 {
5101 ::osl::Directory testDirectory( aTmpName4 ); //constructor
5102
5103 //open a directory
5104 nError1 = testDirectory.open( );
5105 if ( ::osl::FileBase::E_None == nError1 )
5106 {
5107 nError2 = testDirectory.close( );
5108 ASSERT_TRUE( ::osl::FileBase::E_None == nError2 );
5109 }
5110
5111 ASSERT_TRUE(( ::osl::FileBase::E_NOTDIR == nError1 ) || ( ::osl::FileBase::E_ACCES )) << "test for open function: open a file instead of a directory";
5112 }
5113
5114 //---------------------------------------------------------------------
5115 // testing the method
5116 // inline sal_Bool isOpen() { return _pData != NULL; };
5117 //---------------------------------------------------------------------
5118 class isOpen : public ::testing::Test
5119 {
5120 protected:
5121 ::osl::FileBase::RC nError1, nError2;
5122
5123 public:
5124 // initialization
SetUp()5125 void SetUp( )
5126 {
5127 // create a tempfile in $TEMP/tmpdir/tmpname.
5128 createTestDirectory( aTmpName3 );
5129 createTestFile( aTmpName4 );
5130 }
5131
TearDown()5132 void TearDown( )
5133 {
5134 // remove the tempfile in $TEMP/tmpdir/tmpname.
5135 deleteTestFile( aTmpName4 );
5136 deleteTestDirectory( aTmpName3 );
5137 }
5138 };// class isOpen
5139
TEST_F(isOpen,isOpen_001)5140 TEST_F(isOpen, isOpen_001 )
5141 {
5142 ::osl::Directory testDirectory( aTmpName3 ); //constructor
5143
5144 //open a directory
5145 nError1 = testDirectory.open( );
5146 //check if directory is opened.
5147 sal_Bool bOk = testDirectory.isOpen( );
5148 //close a directory
5149 nError2 = testDirectory.close( );
5150
5151 ASSERT_TRUE(( sal_True == bOk )) << "test for isOpen function: open a directory and check for open";
5152 }
5153
TEST_F(isOpen,isOpen_002)5154 TEST_F(isOpen, isOpen_002 )
5155 {
5156 ::osl::Directory testDirectory( aTmpName3 ); //constructor
5157
5158 //check if directory is opened.
5159 sal_Bool bOk = testDirectory.isOpen( );
5160
5161 ASSERT_TRUE(!( sal_True == bOk )) << "test for isOpen function: do not open a directory and check for open";
5162 }
5163
5164 //---------------------------------------------------------------------
5165 // testing the method
5166 // inline RC close()
5167 //---------------------------------------------------------------------
5168 class DirectoryClose : public ::testing::Test
5169 {
5170 protected:
5171 ::osl::FileBase::RC nError1, nError2;
5172
5173 public:
5174 // initialization
SetUp()5175 void SetUp( )
5176 {
5177 // create a tempdirectory : $TEMP/tmpdir.
5178 createTestDirectory( aTmpName3 );
5179 }
5180
TearDown()5181 void TearDown( )
5182 {
5183 // remove a tempdirectory : $TEMP/tmpdir.
5184 deleteTestDirectory( aTmpName3 );
5185 }
5186 };// class close
5187
TEST_F(DirectoryClose,close_001)5188 TEST_F(DirectoryClose, close_001 )
5189 {
5190 ::osl::Directory testDirectory( aTmpName3 ); //constructor
5191
5192 //open a directory
5193 nError1 = testDirectory.open( );
5194 //close a directory
5195 nError2 = testDirectory.close( );
5196 //check if directory is opened.
5197 sal_Bool bOk = testDirectory.isOpen( );
5198
5199 ASSERT_TRUE(!( sal_True == bOk )) << "test for isOpen function: close a directory and check for open";
5200 }
5201
TEST_F(DirectoryClose,close_002)5202 TEST_F(DirectoryClose, close_002 )
5203 {
5204 ::osl::Directory testDirectory( aTmpName3 ); //constructor
5205
5206 //close a directory
5207 nError1 = testDirectory.close( );
5208
5209 ASSERT_TRUE(( ::osl::FileBase::E_BADF == nError1 )) << "test for isOpen function: close a not opened directory";
5210 }
5211
5212 //---------------------------------------------------------------------
5213 // testing the method
5214 // inline RC reset()
5215 //---------------------------------------------------------------------
5216 class reset : public ::testing::Test
5217 {
5218 protected:
5219 ::osl::FileBase::RC nError1, nError2;
5220 ::osl::DirectoryItem rItem;
5221
5222 public:
5223 // initialization
SetUp()5224 void SetUp( )
5225 {
5226 // create a tempdirectory : $TEMP/tmpdir.
5227 createTestDirectory( aTmpName3 );
5228 // create three files : $TEMP/tmpdir/tmpname, $TEMP/tmpdir/tmpdir, $TEMP/tmpdir/hiddenfile,
5229 createTestFile( aTmpName3, aTmpName2);
5230 createTestFile( aTmpName3, aTmpName1);
5231 createTestFile( aTmpName3, aHidURL1);
5232 }
5233
TearDown()5234 void TearDown( )
5235 {
5236 // remove three files : $TEMP/tmpdir/tmpname, $TEMP/tmpdir/tmpdir, $TEMP/tmpdir/hiddenfile,
5237 deleteTestFile( aTmpName3, aHidURL1);
5238 deleteTestFile( aTmpName3, aTmpName1);
5239 deleteTestFile( aTmpName3, aTmpName2);
5240 // remove a tempdirectory : $TEMP/tmpdir.
5241 deleteTestDirectory( aTmpName3 );
5242 }
5243 };// class reset
5244
TEST_F(reset,reset_001)5245 TEST_F(reset, reset_001 )
5246 {
5247 ::osl::Directory testDirectory( aTmpName3 ); //constructor
5248
5249 //open a directory
5250 nError1 = testDirectory.open( );
5251 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
5252 //get first Item
5253 nError1 = testDirectory.getNextItem( rItem, 1 );
5254 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
5255 //get second Item
5256 //mindy: nError1 = testDirectory.getNextItem( rItem, 0 );
5257 //mindy: ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
5258
5259 //reset enumeration
5260 nError2 = testDirectory.reset( );
5261 //get reseted Item, if reset does not work, getNextItem() should return the second Item (aTmpName1)
5262 nError1 = testDirectory.getNextItem( rItem, 0 );
5263 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
5264
5265 //check the file name
5266 ::osl::FileStatus rFileStatus( FileStatusMask_FileName );
5267 nError1 = rItem.getFileStatus( rFileStatus );
5268 //close a directory
5269 nError1 = testDirectory.close( );
5270 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
5271
5272 sal_Bool bOK1,bOK2;
5273 bOK1 = compareFileName( rFileStatus.getFileName( ), aTmpName2 );
5274 bOK2 = compareFileName( rFileStatus.getFileName( ), aHidURL1 );
5275
5276 ASSERT_TRUE(( ::osl::FileBase::E_None == nError2 ) &&
5277 ( sal_True == bOK1 || bOK2 )) << "test for reset function: get two directory item, reset it, then get again, check the filename";
5278 }
5279
TEST_F(reset,reset_002)5280 TEST_F(reset, reset_002 )
5281 {
5282 ::osl::Directory testDirectory( aTmpName6 ); //constructor
5283
5284 //close a directory
5285 nError1 = testDirectory.reset( );
5286
5287 ASSERT_TRUE(( ::osl::FileBase::E_NOENT == nError1 )) << "test for reset function: reset a non existed directory";
5288 }
5289
5290
TEST_F(reset,reset_003)5291 TEST_F(reset, reset_003 )
5292 {
5293 ::osl::Directory testDirectory( aTmpName4 ); //constructor
5294
5295 //close a directory
5296 nError1 = testDirectory.reset( );
5297
5298 ASSERT_TRUE(( ::osl::FileBase::E_NOTDIR == nError1 ) || ( ::osl::FileBase::E_NOENT == nError1 )) << "test for reset function: reset a file instead of a directory";
5299 }
5300
TEST_F(reset,reset_004)5301 TEST_F(reset, reset_004 )
5302 {
5303 ::osl::Directory testDirectory( aUserDirectorySys ); //constructor
5304
5305 //close a directory
5306 nError1 = testDirectory.reset( );
5307
5308 ASSERT_TRUE(( ::osl::FileBase::E_INVAL == nError1 )) << "test for reset function: use a system path";
5309 }
5310
5311 //---------------------------------------------------------------------
5312 // testing the method
5313 // inline RC getNextItem( DirectoryItem& rItem, sal_uInt32 nHint = 0 )
5314 //---------------------------------------------------------------------
5315 class getNextItem : public ::testing::Test
5316 {
5317 protected:
5318 ::osl::FileBase::RC nError1, nError2;
5319 ::osl::DirectoryItem rItem;
5320
5321 public:
5322 // initialization
SetUp()5323 void SetUp( )
5324 {
5325 // create a tempdirectory : $TEMP/tmpdir.
5326 createTestDirectory( aTmpName3 );
5327 // create three files : $TEMP/tmpdir/tmpname, $TEMP/tmpdir/tmpdir, $TEMP/tmpdir/hiddenfile,
5328 createTestFile( aTmpName3, aTmpName2 );
5329 createTestFile( aTmpName3, aTmpName1 );
5330 createTestFile( aTmpName3, aHidURL1 );
5331
5332 }
5333
TearDown()5334 void TearDown( )
5335 {
5336 // remove three files : $TEMP/tmpdir/tmpname, $TEMP/tmpdir/tmpdir, $TEMP/tmpdir/hiddenfile,
5337 deleteTestFile( aTmpName3, aHidURL1 );
5338 deleteTestFile( aTmpName3, aTmpName1 );
5339 deleteTestFile( aTmpName3, aTmpName2 );
5340 // remove a tempdirectory : $TEMP/tmpdir.
5341 deleteTestDirectory( aTmpName3 );
5342 }
5343 };// class getNextItem
5344
TEST_F(getNextItem,getNextItem_001)5345 TEST_F(getNextItem, getNextItem_001 )
5346 {
5347 ::osl::Directory testDirectory( aTmpName3 ); //constructor
5348
5349 //open a directory
5350 nError1 = testDirectory.open( );
5351 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
5352
5353 //check the file name
5354 ::rtl::OUString strFilename;
5355 sal_Bool bOk1 = sal_False;
5356 sal_Bool bOk2 = sal_False;
5357 sal_Bool bOk3 = sal_False;
5358 ::osl::FileStatus rFileStatus( FileStatusMask_FileName );
5359 for ( int nCount = 0; nCount < 3; nCount++ )
5360 {
5361 //get three Items
5362 nError1 = testDirectory.getNextItem( rItem, 2 );
5363 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
5364 nError1 = rItem.getFileStatus( rFileStatus );
5365 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
5366 switch ( nCount )
5367 {
5368 case 0: bOk1 = compareFileName( rFileStatus.getFileName( ), aTmpName2 ) || compareFileName( rFileStatus.getFileName( ), aHidURL1);
5369 break;
5370 case 1: bOk2 = compareFileName( rFileStatus.getFileName( ), aTmpName1 );
5371 break;
5372 case 2: bOk3 = compareFileName( rFileStatus.getFileName( ), aHidURL1) || compareFileName( rFileStatus.getFileName( ), aTmpName2 );
5373 }
5374 }
5375
5376 //close a directory
5377 nError1 = testDirectory.close( );
5378 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
5379
5380 ASSERT_TRUE(( sal_True == bOk1 ) && ( sal_True == bOk2 ) && ( sal_True == bOk3 )) << "test for getNextItem function: retrieve three items and check their names.";
5381 }
5382
TEST_F(getNextItem,getNextItem_002)5383 TEST_F(getNextItem, getNextItem_002 )
5384 {
5385 ::osl::Directory testDirectory( aTmpName3 ); //constructor
5386 nError1 = testDirectory.getNextItem( rItem );
5387
5388 ASSERT_TRUE(( ::osl::FileBase::E_INVAL == nError1 )) << "test for getNextItem function: retrieve an item in a directory which is not opened, also test for nHint's default value.";
5389 }
5390
TEST_F(getNextItem,getNextItem_003)5391 TEST_F(getNextItem, getNextItem_003 )
5392 {
5393 ::osl::Directory testDirectory( aTmpName3 ); //constructor
5394
5395 //open a directory
5396 nError1 = testDirectory.open( );
5397 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
5398
5399 for ( int nCount = 0; nCount < 4; nCount++ )
5400 {
5401 nError2 = testDirectory.getNextItem( rItem, 3 );
5402 }
5403
5404 //close a directory
5405 nError1 = testDirectory.close( );
5406 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
5407
5408 ASSERT_TRUE(( ::osl::FileBase::E_NOENT == nError2 )) << "test for getNextItem function: retrieve 4 times in a directory which contain only 3 files.";
5409 }
5410
TEST_F(getNextItem,getNextItem_004)5411 TEST_F(getNextItem, getNextItem_004 )
5412 {
5413 //create a link file(can not on Windows), then check if getNextItem can get it.
5414 #ifdef UNX
5415 sal_Bool bOK = sal_False;
5416 ::rtl::OUString aUStr_LnkFileSys( aTempDirectorySys ), aUStr_SrcFileSys( aTempDirectorySys );
5417 ( ( aUStr_LnkFileSys += aSlashURL ) += getCurrentPID( ) ) += ::rtl::OUString::createFromAscii("/tmpdir/link.file");
5418 ( ( aUStr_SrcFileSys += aSlashURL ) += getCurrentPID( ) ) += ::rtl::OUString::createFromAscii("/tmpdir/tmpname");
5419 rtl::OString strLinkFileName, strSrcFileName;
5420 strLinkFileName = OUStringToOString( aUStr_LnkFileSys, RTL_TEXTENCODING_ASCII_US );
5421 strSrcFileName = OUStringToOString( aUStr_SrcFileSys, RTL_TEXTENCODING_ASCII_US );
5422
5423 //create a link file and link it to file "/tmp/PID/tmpdir/tmpname"
5424 sal_Int32 fd = symlink( strSrcFileName.getStr(), strLinkFileName.getStr() );
5425 ASSERT_TRUE( fd == 0 );
5426 ::osl::Directory testDirectory( aTmpName3 );
5427
5428 //open a directory
5429 nError1 = testDirectory.open( );
5430 ::rtl::OUString aFileName = ::rtl::OUString::createFromAscii("link.file");
5431
5432 while (1) {
5433 nError1 = testDirectory.getNextItem( rItem, 4 );
5434 if (::osl::FileBase::E_None == nError1) {
5435 ::osl::FileStatus rFileStatus( FileStatusMask_FileName | FileStatusMask_Type );
5436 rItem.getFileStatus( rFileStatus );
5437 if ( compareFileName( rFileStatus.getFileName( ), aFileName) == sal_True )
5438 {
5439 if ( FileStatus::Link == rFileStatus.getFileType( ))
5440 {
5441 bOK = sal_True;
5442 break;
5443 }
5444 }
5445 }
5446 else
5447 break;
5448 };
5449 fd = std::remove( strLinkFileName.getStr() );
5450 ASSERT_TRUE(fd == 0) << "remove link file failed";
5451 ASSERT_TRUE(( bOK == sal_True )) << "test for getNextItem function: check if can retrieve the link file name";
5452 #endif
5453 }
5454
5455 //---------------------------------------------------------------------
5456 // testing the method
5457 // inline static RC getVolumeInfo( const ::rtl::OUString& ustrDirectoryURL, VolumeInfo& rInfo )
5458 //---------------------------------------------------------------------
5459 class getVolumeInfo : public ::testing::Test
5460 {
5461 protected:
5462 ::osl::FileBase::RC nError1, nError2;
5463
5464 public:
5465
5466 // test code.
checkValidMask(osl::VolumeInfo const & _aVolumeInfo,sal_Int32 _nMask)5467 void checkValidMask(osl::VolumeInfo const& _aVolumeInfo, sal_Int32 _nMask)
5468 {
5469 if (_nMask == VolumeInfoMask_FileSystemName)
5470 {
5471 //get file system name
5472 ::rtl::OUString aFileSysName( aNullURL );
5473 aFileSysName = _aVolumeInfo.getFileSystemName( );
5474
5475 sal_Bool bRes2 = compareFileName( aFileSysName, aNullURL );
5476 ASSERT_TRUE(( osl::FileBase::E_None == nError1 ) &&
5477 ( sal_False == bRes2 )) << "test for getVolumeInfo function: getVolumeInfo of root directory.";
5478 }
5479 if (_nMask == VolumeInfoMask_Attributes)
5480 {
5481 sal_Bool b1 = _aVolumeInfo.getRemoteFlag();
5482 sal_Bool b2 = _aVolumeInfo.getRemoveableFlag();
5483 sal_Bool b3 = _aVolumeInfo.getCompactDiscFlag();
5484 sal_Bool b4 = _aVolumeInfo.getFloppyDiskFlag();
5485 sal_Bool b5 = _aVolumeInfo.getFixedDiskFlag();
5486 sal_Bool b6 = _aVolumeInfo.getRAMDiskFlag();
5487
5488 rtl::OString sAttr;
5489 if (b1) sAttr = "Remote";
5490 if (b2) sAttr += " Removeable";
5491 if (b3) sAttr += " CDROM";
5492 if (b4) sAttr += " Floppy";
5493 if (b5) sAttr += " FixedDisk";
5494 if (b6) sAttr += " RAMDisk";
5495
5496 printf("Attributes: %s\n", sAttr.getStr() );
5497 }
5498 if (_nMask == VolumeInfoMask_TotalSpace)
5499 {
5500 // within Linux, df / * 1024 bytes is the result
5501 sal_uInt64 nSize = _aVolumeInfo.getTotalSpace();
5502 printf("Total space: %lld\n", nSize);
5503 }
5504 if (_nMask == VolumeInfoMask_UsedSpace)
5505 {
5506 sal_uInt64 nSize = _aVolumeInfo.getUsedSpace();
5507 printf(" Used space: %lld\n", nSize);
5508 }
5509 if (_nMask == VolumeInfoMask_FreeSpace)
5510 {
5511 sal_uInt64 nSize = _aVolumeInfo.getFreeSpace();
5512 printf(" Free space: %lld\n", nSize);
5513 }
5514 if (_nMask == VolumeInfoMask_MaxNameLength)
5515 {
5516 sal_uInt32 nLength = _aVolumeInfo.getMaxNameLength();
5517 printf("max name length: %ld\n", nLength);
5518 }
5519 if (_nMask == VolumeInfoMask_MaxPathLength)
5520 {
5521 sal_uInt32 nLength = _aVolumeInfo.getMaxPathLength();
5522 printf("max path length: %ld\n", nLength);
5523 }
5524 if (_nMask == VolumeInfoMask_FileSystemCaseHandling)
5525 {
5526 bool bIsCase = _aVolumeInfo.isCaseSensitiveFileSystem();
5527 printf("filesystem case sensitive: %s\n", bIsCase ? "yes" : "no");
5528 }
5529 }
5530
checkVolumeInfo(sal_Int32 _nMask)5531 void checkVolumeInfo(sal_Int32 _nMask)
5532 {
5533 ::osl::VolumeInfo aVolumeInfo( _nMask );
5534 //call getVolumeInfo here
5535 nError1 = ::osl::Directory::getVolumeInfo( aVolURL1, aVolumeInfo );
5536 // LLA: IMHO it's not a bug, if VolumeInfo is not valid, it's a feature
5537 // LLA: ASSERT_TRUE(sal_True == aVolumeInfo.isValid( _nMask )) << "mask is not valid";
5538 if (aVolumeInfo.isValid( _nMask))
5539 {
5540 checkValidMask(aVolumeInfo, _nMask);
5541 }
5542 }
5543 };// class getVolumeInfo
5544
TEST_F(getVolumeInfo,getVolumeInfo_001_1)5545 TEST_F(getVolumeInfo, getVolumeInfo_001_1 )
5546 {
5547 sal_Int32 mask = VolumeInfoMask_FileSystemName;
5548 checkVolumeInfo(mask);
5549 }
TEST_F(getVolumeInfo,getVolumeInfo_001_2)5550 TEST_F(getVolumeInfo, getVolumeInfo_001_2 )
5551 {
5552 sal_Int32 mask = VolumeInfoMask_Attributes;
5553 checkVolumeInfo(mask);
5554 }
TEST_F(getVolumeInfo,getVolumeInfo_001_3)5555 TEST_F(getVolumeInfo, getVolumeInfo_001_3 )
5556 {
5557 sal_Int32 mask = VolumeInfoMask_TotalSpace;
5558 checkVolumeInfo(mask);
5559 }
TEST_F(getVolumeInfo,getVolumeInfo_001_4)5560 TEST_F(getVolumeInfo, getVolumeInfo_001_4 )
5561 {
5562 sal_Int32 mask = VolumeInfoMask_UsedSpace;
5563 checkVolumeInfo(mask);
5564 }
TEST_F(getVolumeInfo,getVolumeInfo_001_5)5565 TEST_F(getVolumeInfo, getVolumeInfo_001_5 )
5566 {
5567 sal_Int32 mask = VolumeInfoMask_FreeSpace;
5568 checkVolumeInfo(mask);
5569 }
TEST_F(getVolumeInfo,getVolumeInfo_001_6)5570 TEST_F(getVolumeInfo, getVolumeInfo_001_6 )
5571 {
5572 sal_Int32 mask = VolumeInfoMask_MaxNameLength;
5573 checkVolumeInfo(mask);
5574 }
TEST_F(getVolumeInfo,getVolumeInfo_001_7)5575 TEST_F(getVolumeInfo, getVolumeInfo_001_7 )
5576 {
5577 sal_Int32 mask = VolumeInfoMask_MaxPathLength;
5578 checkVolumeInfo(mask);
5579 }
TEST_F(getVolumeInfo,getVolumeInfo_001_8)5580 TEST_F(getVolumeInfo, getVolumeInfo_001_8 )
5581 {
5582 sal_Int32 mask = VolumeInfoMask_FileSystemCaseHandling;
5583 checkVolumeInfo(mask);
5584 }
5585
TEST_F(getVolumeInfo,getVolumeInfo_002)5586 TEST_F(getVolumeInfo, getVolumeInfo_002 )
5587 {
5588 sal_Int32 mask = VolumeInfoMask_FileSystemName;
5589 ::osl::VolumeInfo aVolumeInfo( mask );
5590 //call getVolumeInfo here
5591
5592 // LLA: rtl::OUString aRootSysURL;
5593 // LLA: nError1 = osl::File::getFileURLFromSystemPath(aRootSys, aRootSysURL);
5594 // LLA:
5595 // LLA: ASSERT_TRUE(// LLA: ( osl::FileBase::E_NONE == nError1 )) << "can't convert root path to file url";
5596
5597 nError1 = ::osl::Directory::getVolumeInfo( aRootSys, aVolumeInfo );
5598
5599 ASSERT_TRUE(( osl::FileBase::E_INVAL == nError1 )) << "test for getVolumeInfo function: use system path as parameter.";
5600 }
5601
TEST_F(getVolumeInfo,getVolumeInfo_003)5602 TEST_F(getVolumeInfo, getVolumeInfo_003 )
5603 {
5604 sal_Int32 mask = VolumeInfoMask_FileSystemName;
5605 ::osl::VolumeInfo aVolumeInfo( mask );
5606 //call getVolumeInfo here
5607 nError1 = ::osl::Directory::getVolumeInfo( aTmpName3, aVolumeInfo );
5608
5609 // LLA: in Windows, it reply no error, it did not pass in (W32).
5610 #ifdef UNX
5611 ASSERT_TRUE(( osl::FileBase::E_NOENT == nError1 )) << "test for getVolumeInfo function: non-existence test. ";
5612 #endif
5613 }
5614
5615 //---------------------------------------------------------------------
5616 // testing the method
5617 // inline static RC create( const ::rtl::OUString& ustrDirectoryURL )
5618 //---------------------------------------------------------------------
5619 class create : public ::testing::Test
5620 {
5621 protected:
5622 ::osl::FileBase::RC nError1, nError2;
5623 };// class create
5624
TEST_F(create,create_001)5625 TEST_F(create, create_001 )
5626 {
5627 //create directory in $TEMP/tmpdir
5628 nError1 = ::osl::Directory::create( aTmpName3 );
5629 //check for existence
5630 nError2 = ::osl::Directory::create( aTmpName3 );
5631 //remove it
5632 deleteTestDirectory( aTmpName3 );
5633
5634 ASSERT_TRUE(( osl::FileBase::E_None == nError1 ) &&
5635 ( osl::FileBase::E_EXIST== nError2 )) << "test for create function: create a directory and check its existence.";
5636 }
5637
TEST_F(create,create_002)5638 TEST_F(create, create_002 )
5639 {
5640 //create directory in /tmpname
5641 nError1 = ::osl::Directory::create( aTmpName7 );
5642 #if defined (WNT )
5643 nError1 = osl::FileBase::E_ACCES; /// in Windows, you can create directory in c:/ any way.
5644 deleteTestDirectory( aTmpName7 );
5645 #endif
5646
5647 ASSERT_TRUE(( osl::FileBase::E_ACCES == nError1 )) << "test for create function: create a directory in root for access test.";
5648 }
5649
TEST_F(create,create_003)5650 TEST_F(create, create_003 )
5651 {
5652 //create directory in /tmpname
5653 nError1 = ::osl::Directory::create( aSysPath1 );
5654
5655 ASSERT_TRUE(( osl::FileBase::E_INVAL == nError1 )) << "test for create function: create a directory using system path.";
5656 }
5657
5658 //---------------------------------------------------------------------
5659 // testing the method
5660 // inline static RC remove( const ::rtl::OUString& ustrDirectoryURL )
5661 //---------------------------------------------------------------------
5662 class DirectoryRemove : public ::testing::Test
5663 {
5664 protected:
5665 ::osl::FileBase::RC nError1, nError2;
5666 };// class remove
5667
TEST_F(DirectoryRemove,remove_001)5668 TEST_F(DirectoryRemove, remove_001 )
5669 {
5670 //create directory in $TEMP/tmpdir
5671 nError1 = ::osl::Directory::create( aTmpName3 );
5672 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
5673 //remove it
5674 nError1 = ::osl::Directory::remove( aTmpName3 );
5675 //check for existence
5676 ::osl::Directory rDirectory( aTmpName3 );
5677 nError2 = rDirectory.open( );
5678
5679 ASSERT_TRUE(( osl::FileBase::E_None == nError1 ) &&
5680 ( osl::FileBase::E_NOENT == nError2 )) << "test for remove function: remove a directory and check its existence.";
5681 }
5682
TEST_F(DirectoryRemove,remove_002)5683 TEST_F(DirectoryRemove, remove_002 )
5684 {
5685 //create directory in $TEMP/tmpdir
5686 nError1 = ::osl::Directory::create( aTmpName3 );
5687 ASSERT_TRUE( ::osl::FileBase::E_None == nError1 );
5688 //try to remove it by system path
5689 nError1 = ::osl::Directory::remove( aSysPath3 );
5690 //check for existence
5691 ::osl::Directory rDirectory( aTmpName3 );
5692 nError2 = rDirectory.open( );
5693 if ( osl::FileBase::E_NOENT != nError2 )
5694 ::osl::Directory::remove( aTmpName3 );
5695
5696 ASSERT_TRUE(( osl::FileBase::E_INVAL == nError1 )) << "test for remove function: remove a directory by its system path, and check its existence.";
5697 }
5698
TEST_F(DirectoryRemove,remove_003)5699 TEST_F(DirectoryRemove, remove_003 )
5700 {
5701 //try to remove a non-existed directory
5702 nError1 = ::osl::Directory::remove( aTmpName6 );
5703
5704 ASSERT_TRUE(( osl::FileBase::E_NOENT == nError1 )) << "test for remove function: try to remove a non-existed directory.";
5705 }
5706
TEST_F(DirectoryRemove,remove_004)5707 TEST_F(DirectoryRemove, remove_004 )
5708 {
5709 createTestFile( aTmpName6 );
5710 sal_Bool bExist = ifFileExist( aTmpName6 );
5711 //try to remove file.
5712 nError1 = ::osl::Directory::remove( aTmpName6 );
5713 deleteTestFile( aTmpName6 );
5714
5715 ASSERT_TRUE(bExist == sal_True &&(( osl::FileBase::E_NOTDIR == nError1 ) || ( osl::FileBase::E_NOENT == nError1 ))) << "test for remove function: try to remove a file but not directory.";
5716 }
5717
TEST_F(DirectoryRemove,remove_005)5718 TEST_F(DirectoryRemove, remove_005 )
5719 {
5720 createTestDirectory( aTmpName3 );
5721 createTestFile( aTmpName4 );
5722 nError1 = ::osl::Directory::remove( aTmpName3 );
5723 deleteTestFile( aTmpName4 );
5724 deleteTestDirectory( aTmpName3 );
5725 ::rtl::OUString suError = ::rtl::OUString::createFromAscii("test for remove function: try to remove a directory that is not empty.") + errorToStr( nError1 );
5726 #if defined ( SOLARIS )
5727 //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.
5728 //EEXIST The directory contains entries other than those for "." and "..".
5729 printf("#Solaris test\n");
5730 ASSERT_TRUE(( osl::FileBase::E_EXIST == nError1 )) << suError.pData;
5731 #else
5732 ASSERT_TRUE(( osl::FileBase::E_NOTEMPTY == nError1 )) << suError.pData;
5733 #endif
5734 }
5735
5736 //########################################
5737 // TEST Directory::createPath
5738 //########################################
5739
5740 #ifdef WNT
5741 # define PATH_BUFFER_SIZE MAX_PATH
5742 #else
5743 # define PATH_BUFFER_SIZE PATH_MAX
5744 #endif
5745
5746 char TEST_PATH_POSTFIX[] = "hello/world";
5747
5748 //########################################
get_test_path()5749 OUString get_test_path()
5750 {
5751 OUString tmp;
5752 FileBase::RC rc = FileBase::getTempDirURL(tmp);
5753
5754 EXPECT_TRUE(rc == FileBase::E_None) << "Test path creation failed";
5755
5756 OUStringBuffer b(tmp);
5757 if (tmp.lastIndexOf('/') != (tmp.getLength() - 1))
5758 b.appendAscii("/");
5759
5760 b.appendAscii(TEST_PATH_POSTFIX);
5761
5762 return b.makeStringAndClear();
5763 }
5764
5765 //########################################
rm_test_path(const OUString & path)5766 void rm_test_path(const OUString& path)
5767 {
5768 sal_Unicode buffer[PATH_BUFFER_SIZE];
5769 rtl_copyMemory(buffer, path.getStr(), (path.getLength() + 1) * sizeof(sal_Unicode));
5770
5771 sal_Int32 i = rtl_ustr_lastIndexOfChar(buffer, '/');
5772 if (i == path.getLength())
5773 buffer[i] = 0;
5774
5775 Directory::remove(buffer);
5776
5777 i = rtl_ustr_lastIndexOfChar(buffer, '/');
5778 buffer[i] = 0;
5779 Directory::remove(buffer);
5780 }
5781
5782 //########################################
5783 class DirCreatedObserver : public DirectoryCreationObserver
5784 {
5785 public:
DirCreatedObserver()5786 DirCreatedObserver() : i(0)
5787 {
5788 }
5789
DirectoryCreated(const rtl::OUString &)5790 virtual void DirectoryCreated(const rtl::OUString& /*aDirectoryUrl*/)
5791 {
5792 i++;
5793 };
5794
number_of_dirs_created() const5795 int number_of_dirs_created() const
5796 {
5797 return i;
5798 }
5799
5800 private:
5801 int i;
5802 };
5803
5804
5805 //########################################
5806 class createPath : public ::testing::Test
5807 {
5808 public:
5809 //##########################################
createPath()5810 createPath()
5811 {}
5812
5813 #ifdef WNT
5814
5815 //##########################################
get_unused_drive_letter()5816 char* get_unused_drive_letter()
5817 {
5818 static char m_aBuff[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
5819
5820 DWORD ld = GetLogicalDrives();
5821 DWORD i = 4;
5822 DWORD j = 2;
5823
5824 while ((ld & i) && (i > 1))
5825 { i = i << 1; j++; }
5826
5827 if (i > 2)
5828 return m_aBuff + j;
5829
5830 return NULL;
5831 }
5832
5833
5834 #endif /* WNT */
5835 }; // class createPath
5836
5837 #ifdef WNT
5838 //##########################################
TEST_F(createPath,at_invalid_logical_drive)5839 TEST_F(createPath, at_invalid_logical_drive)
5840 {
5841 char* drv = get_unused_drive_letter();
5842 char buff[PATH_BUFFER_SIZE];
5843 rtl_zeroMemory(buff, sizeof(buff));
5844
5845 strncpy(buff, drv, 1);
5846 strcat(buff, ":\\");
5847 strcat(buff, TEST_PATH_POSTFIX);
5848
5849 OUString path = OUString::createFromAscii(buff);
5850 OUString tp_url;
5851 FileBase::getFileURLFromSystemPath(path, tp_url);
5852
5853 FileBase::RC rc = Directory::createPath(tp_url);
5854
5855 ASSERT_TRUE(rc != FileBase::E_None) << "osl_createDirectoryPath doesn't fail on unused logical drive letters";
5856 }
5857
5858 //##########################################
5859 // adapt the UNC path in method createDirectoryPath_with_UNC_path
5860 // in order to run this test successfully
5861 #if 0
5862 TEST_F(createPath, with_UNC_path)
5863 {
5864
5865 OUString tp_unc = OUString::createFromAscii("\\\\Tra-1\\TRA_D\\hello\\world\\");
5866 OUString tp_url;
5867 FileBase::getFileURLFromSystemPath(tp_unc, tp_url);
5868
5869 FileBase::RC rc = Directory::createPath(tp_url);
5870
5871 ASSERT_TRUE(rc == FileBase::E_None) << "osl_createDirectoryPath fails with UNC path";
5872 }
5873 #endif
5874 #endif
5875
5876 //##########################################
TEST_F(createPath,with_relative_path)5877 TEST_F(createPath, with_relative_path)
5878 {
5879 FileBase::RC rc = Directory::createPath(
5880 OUString::createFromAscii(TEST_PATH_POSTFIX));
5881
5882 ASSERT_TRUE(rc == FileBase::E_INVAL) << "osl_createDirectoryPath contract broken";
5883 }
5884
5885 //##########################################
TEST_F(createPath,without_callback)5886 TEST_F(createPath, without_callback)
5887 {
5888 OUString tp_url = get_test_path();
5889
5890 rm_test_path(tp_url);
5891
5892 FileBase::RC rc = Directory::createPath(tp_url);
5893
5894 ASSERT_TRUE(rc == FileBase::E_None) << "osl_createDirectoryPath failed";
5895 }
5896
5897 //##########################################
TEST_F(createPath,with_callback)5898 TEST_F(createPath, with_callback)
5899 {
5900 OUString tp_url = get_test_path();
5901
5902 rm_test_path(tp_url);
5903
5904 DirCreatedObserver* observer = new DirCreatedObserver;
5905 FileBase::RC rc = Directory::createPath(tp_url, observer);
5906 int nDirs = observer->number_of_dirs_created();
5907 delete observer;
5908 ASSERT_TRUE((rc == FileBase::E_None) && (nDirs > 0)) << "osl_createDirectoryPath failed";
5909
5910 }
5911
5912 }// namespace osl_Directory
5913
5914
5915 // -----------------------------------------------------------------------------
5916 // this macro creates an empty function, which will called by the RegisterAllFunctions()
5917 // to let the user the possibility to also register some functions by hand.
5918 // -----------------------------------------------------------------------------
5919
5920 /// NOADDITIONAL;
5921
5922
5923
5924 /** get Current PID.
5925 */
getCurrentPID()5926 inline ::rtl::OUString getCurrentPID( )
5927 {
5928 //~ Get current PID and turn it into OUString;
5929 int nPID = 0;
5930 #ifdef WNT
5931 nPID = GetCurrentProcessId();
5932 #else
5933 nPID = getpid();
5934 #endif
5935 return ( ::rtl::OUString::valueOf( ( long )nPID ) );
5936 }
5937
5938
5939 /** Insert Current PID to the URL to avoid access violation between multiuser execution.
5940 */
insertPID(::rtl::OUString & pathname)5941 inline void insertPID( ::rtl::OUString & pathname )
5942 {
5943 //~ check if the path contain the temp directory, do nothing changes if not;
5944 if ( pathname.indexOf( aTempDirectoryURL ) && pathname.indexOf( aTempDirectorySys ) )
5945 return;
5946
5947 //~ format pathname to TEMP/USERPID/URL style;
5948 if ( !pathname.indexOf( aTempDirectoryURL ) )
5949 {
5950 ::rtl::OUString strPID( getCurrentPID( ) );
5951 ::rtl::OUString pathLeft = aTempDirectoryURL.copy( 0 );
5952 ::rtl::OUString pathRight = pathname.copy( aTempDirectoryURL.getLength( ) );
5953 pathname = pathLeft.copy( 0 );
5954 ( ( pathname += aSlashURL ) += strPID ) += pathRight;
5955 }
5956 else
5957 {
5958 ::rtl::OUString strPID( getCurrentPID( ) );
5959 ::rtl::OUString pathLeft = aTempDirectorySys.copy( 0 );
5960 ::rtl::OUString pathRight = pathname.copy( aTempDirectorySys.getLength( ) );
5961 pathname = pathLeft.copy( 0 );
5962 ( ( pathname += aSlashURL ) += strPID ) += pathRight;
5963 }
5964
5965
5966 }
5967
main(int argc,char ** argv)5968 int main(int argc, char **argv)
5969 {
5970 printf( "Initializing..." );
5971
5972 //~ make sure the c:\temp exist, if not, create it.
5973 #if ( defined WNT )
5974 if ( checkDirectory( aTempDirectoryURL, osl_Check_Mode_Exist ) != sal_True ) {
5975 printf( "\n#C:\\temp is not exist, now creating\n" );
5976 createTestDirectory( aTempDirectoryURL );
5977 };
5978 #endif
5979
5980 //~ make sure the c:\temp\PID or /tmp/PID exist, if not, create it. initialize the user directory.
5981 ( aUserDirectoryURL += aSlashURL ) += getCurrentPID( );
5982 ( aUserDirectorySys += aSlashURL ) += getCurrentPID( );
5983
5984 if ( checkDirectory( aUserDirectoryURL, osl_Check_Mode_Exist ) != sal_True ) {
5985 createTestDirectory( aUserDirectoryURL );
5986 }
5987
5988 //~ adapt all URL to the TEMP/USERPID/URL format;
5989 insertPID( aCanURL1 );
5990 insertPID( aTmpName3 );
5991 insertPID( aTmpName4 );
5992 insertPID( aTmpName5 );
5993 insertPID( aTmpName6 );
5994 insertPID( aTmpName8 );
5995 insertPID( aTmpName9 );
5996 insertPID( aLnkURL1 );
5997 insertPID( aFifoSys );
5998 insertPID( aSysPath1 );
5999 insertPID( aSysPath2 );
6000 insertPID( aSysPath3 );
6001 insertPID( aSysPath4 );
6002
6003 printf( "Done.\n" );
6004
6005 ::testing::InitGoogleTest(&argc, argv);
6006 return RUN_ALL_TESTS();
6007 }
6008
6009
6010 //~ do some clean up work after all test completed.
6011 class GlobalObject
6012 {
6013 public:
~GlobalObject()6014 ~GlobalObject()
6015 {
6016 try
6017 {
6018 //~ make sure the c:\temp\PID or /tmp/PID exist, if yes, delete it.
6019 printf( "\n#Do some clean-ups ...\n" );
6020 if ( checkDirectory( aUserDirectoryURL, osl_Check_Mode_Exist ) == sal_True ) {
6021 deleteTestDirectory( aUserDirectoryURL );
6022 }
6023
6024 // LLA: printf("after deleteTestDirectory\n");
6025 //~ special clean up task in Windows and Unix separately;
6026 #if ( defined UNX ) || ( defined OS2 )
6027 //~ some clean up task for UNIX OS
6028 ;
6029 #else
6030 //~ some clean up task for Windows OS
6031 //~ check if some files are in the way, remove them if necessary.
6032 if ( ifFileExist( aTmpName6 ) == sal_True )
6033 deleteTestFile( aTmpName6 );
6034 if ( ifFileExist( aTmpName4 ) == sal_True )
6035 deleteTestFile( aTmpName4 );
6036 if ( checkDirectory( aTmpName4, osl_Check_Mode_Exist ) == sal_True )
6037 deleteTestDirectory( aTmpName4 );
6038 if ( ifFileExist( aTmpName3 ) == sal_True )
6039 deleteTestFile( aTmpName3 );
6040 if ( checkDirectory( aTmpName3, osl_Check_Mode_Exist ) == sal_True )
6041 deleteTestDirectory( aTmpName3 );
6042
6043 ::rtl::OUString aUStr( aUserDirectoryURL );
6044 concatURL( aUStr, aHidURL1 );
6045 if ( ifFileExist( aUStr ) == sal_True )
6046 deleteTestFile( aUStr );
6047
6048 ::rtl::OUString aUStr1( aRootURL );
6049 concatURL( aUStr1, aTmpName2 );
6050 if ( ifFileExist( aUStr1 ) == sal_True )
6051 deleteTestFile( aUStr1 );
6052 #endif
6053
6054 }
6055 catch (...)
6056 {
6057 printf("Exception caught (...) in GlobalObject dtor()\n");
6058 }
6059 }
6060 };
6061
6062 GlobalObject theGlobalObject;
6063