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