1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: tests/filename/filename.cpp
3 // Purpose: wxFileName unit test
4 // Author: Vadim Zeitlin
7 // Copyright: (c) 2004 Vadim Zeitlin
8 ///////////////////////////////////////////////////////////////////////////////
10 // ----------------------------------------------------------------------------
12 // ----------------------------------------------------------------------------
24 #include "wx/filename.h"
25 #include "wx/filefn.h"
26 #include "wx/stdpaths.h"
27 #include "wx/scopeguard.h"
30 #include "wx/msw/registry.h"
40 // ----------------------------------------------------------------------------
42 // ----------------------------------------------------------------------------
44 static struct TestFileNameInfo
56 { "", "", "", "", "", false, wxPATH_UNIX
},
57 { "", "", "", "", "", false, wxPATH_DOS
},
58 { "", "", "", "", "", false, wxPATH_VMS
},
61 { "/usr/bin/ls", "", "/usr/bin", "ls", "", true, wxPATH_UNIX
},
62 { "/usr/bin/", "", "/usr/bin", "", "", true, wxPATH_UNIX
},
63 { "~/.zshrc", "", "~", ".zshrc", "", true, wxPATH_UNIX
},
64 { "../../foo", "", "../..", "foo", "", false, wxPATH_UNIX
},
65 { "foo.bar", "", "", "foo", "bar", false, wxPATH_UNIX
},
66 { "~/foo.bar", "", "~", "foo", "bar", true, wxPATH_UNIX
},
67 { "~user/foo.bar", "", "~user", "foo", "bar", true, wxPATH_UNIX
},
68 { "~user/", "", "~user", "", "", true, wxPATH_UNIX
},
69 { "/foo", "", "/", "foo", "", true, wxPATH_UNIX
},
70 { "Mahogany-0.60/foo.bar", "", "Mahogany-0.60", "foo", "bar", false, wxPATH_UNIX
},
71 { "/tmp/wxwin.tar.bz", "", "/tmp", "wxwin.tar", "bz", true, wxPATH_UNIX
},
74 { "foo.bar", "", "", "foo", "bar", false, wxPATH_DOS
},
75 { "\\foo.bar", "", "\\", "foo", "bar", false, wxPATH_DOS
},
76 { "c:foo.bar", "c", "", "foo", "bar", false, wxPATH_DOS
},
77 { "c:\\foo.bar", "c", "\\", "foo", "bar", true, wxPATH_DOS
},
78 { "c:\\Windows\\command.com", "c", "\\Windows", "command", "com", true, wxPATH_DOS
},
79 { "\\\\?\\Volume{8089d7d7-d0ac-11db-9dd0-806d6172696f}\\",
80 "Volume{8089d7d7-d0ac-11db-9dd0-806d6172696f}", "\\", "", "", true, wxPATH_DOS
},
81 { "\\\\?\\Volume{8089d7d7-d0ac-11db-9dd0-806d6172696f}\\Program Files\\setup.exe",
82 "Volume{8089d7d7-d0ac-11db-9dd0-806d6172696f}", "\\Program Files", "setup", "exe", true, wxPATH_DOS
},
85 // NB: when using the wxFileName::GetLongPath() function on these two
86 // strings, the program will hang for several seconds blocking inside
87 // Win32 GetLongPathName() function
88 { "\\\\server\\foo.bar", "server", "\\", "foo", "bar", true, wxPATH_DOS
},
89 { "\\\\server\\dir\\foo.bar", "server", "\\dir", "foo", "bar", true, wxPATH_DOS
},
92 // consecutive [back]slashes should be treated as single occurrences of
93 // them and not interpreted as share names if there is a volume name
94 { "c:\\aaa\\bbb\\ccc", "c", "\\aaa\\bbb", "ccc", "", true, wxPATH_DOS
},
95 { "c:\\\\aaa\\bbb\\ccc", "c", "\\\\aaa\\bbb", "ccc", "", true, wxPATH_DOS
},
97 // wxFileName support for Mac file names is broken currently
100 { "Volume:Dir:File", "Volume", "Dir", "File", "", true, wxPATH_MAC
},
101 { "Volume:Dir:Subdir:File", "Volume", "Dir:Subdir", "File", "", true, wxPATH_MAC
},
102 { "Volume:", "Volume", "", "", "", true, wxPATH_MAC
},
103 { ":Dir:File", "", "Dir", "File", "", false, wxPATH_MAC
},
104 { ":File.Ext", "", "", "File", ".Ext", false, wxPATH_MAC
},
105 { "File.Ext", "", "", "File", ".Ext", false, wxPATH_MAC
},
110 // NB: on Windows they have the same effect of the \\server\\ strings
111 // (see the note above)
112 { "device:[dir1.dir2.dir3]file.txt", "device", "dir1.dir2.dir3", "file", "txt", true, wxPATH_VMS
},
114 { "file.txt", "", "", "file", "txt", false, wxPATH_VMS
},
117 // ----------------------------------------------------------------------------
119 // ----------------------------------------------------------------------------
121 class FileNameTestCase
: public CppUnit::TestCase
124 FileNameTestCase() { }
127 CPPUNIT_TEST_SUITE( FileNameTestCase
);
128 CPPUNIT_TEST( TestConstruction
);
129 CPPUNIT_TEST( TestComparison
);
130 CPPUNIT_TEST( TestSplit
);
131 CPPUNIT_TEST( TestSetPath
);
132 CPPUNIT_TEST( TestStrip
);
133 CPPUNIT_TEST( TestNormalize
);
134 CPPUNIT_TEST( TestReplace
);
135 CPPUNIT_TEST( TestGetHumanReadable
);
137 CPPUNIT_TEST( TestShortLongPath
);
138 #endif // __WINDOWS__
139 CPPUNIT_TEST( TestUNC
);
140 CPPUNIT_TEST( TestVolumeUniqueName
);
141 CPPUNIT_TEST( TestCreateTempFileName
);
142 CPPUNIT_TEST( TestGetTimes
);
143 CPPUNIT_TEST( TestSetTimes
);
144 CPPUNIT_TEST( TestExists
);
145 CPPUNIT_TEST( TestIsSame
);
146 #if defined(__UNIX__)
147 CPPUNIT_TEST( TestSymlinks
);
149 CPPUNIT_TEST_SUITE_END();
151 void TestConstruction();
152 void TestComparison();
156 void TestNormalize();
158 void TestGetHumanReadable();
160 void TestShortLongPath();
161 #endif // __WINDOWS__
163 void TestVolumeUniqueName();
164 void TestCreateTempFileName();
169 #if defined(__UNIX__)
173 DECLARE_NO_COPY_CLASS(FileNameTestCase
)
176 // register in the unnamed registry so that these tests are run by default
177 CPPUNIT_TEST_SUITE_REGISTRATION( FileNameTestCase
);
179 // also include in its own registry so that these tests can be run alone
180 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( FileNameTestCase
, "FileNameTestCase" );
182 void FileNameTestCase::TestConstruction()
184 for ( size_t n
= 0; n
< WXSIZEOF(filenames
); n
++ )
186 const TestFileNameInfo
& fni
= filenames
[n
];
188 wxFileName
fn(fni
.fullname
, fni
.format
);
190 // the original full name could contain consecutive [back]slashes,
191 // squeeze them except for the double backslash in the beginning in
192 // Windows filenames where it has special meaning
193 wxString fullnameOrig
;
194 if ( fni
.format
== wxPATH_DOS
)
196 // copy the backslashes at beginning unchanged
197 const char *p
= fni
.fullname
;
199 fullnameOrig
+= *p
++;
201 // replace consecutive slashes with single ones in the rest
202 for ( char chPrev
= '\0'; *p
; p
++ )
204 if ( *p
== '\\' && chPrev
== '\\' )
208 fullnameOrig
+= chPrev
;
213 fullnameOrig
= fni
.fullname
;
216 fullnameOrig
.Replace("//", "/");
219 wxString fullname
= fn
.GetFullPath(fni
.format
);
220 CPPUNIT_ASSERT_EQUAL( fullnameOrig
, fullname
);
222 // notice that we use a dummy working directory to ensure that paths
223 // with "../.." in them could be normalized, otherwise this would fail
224 // if the test is run from root directory or its direct subdirectory
225 CPPUNIT_ASSERT_MESSAGE
227 (const char *)wxString::Format("Normalize(%s) failed", fni
.fullname
).mb_str(),
228 fn
.Normalize(wxPATH_NORM_ALL
, "/foo/bar/baz", fni
.format
)
231 if ( *fni
.volume
&& *fni
.path
)
233 // check that specifying the volume separately or as part of the
234 // path doesn't make any difference
235 wxString pathWithVolume
= fni
.volume
;
236 pathWithVolume
+= wxFileName::GetVolumeSeparator(fni
.format
);
237 pathWithVolume
+= fni
.path
;
239 CPPUNIT_ASSERT_EQUAL( wxFileName(pathWithVolume
,
249 fn
.AssignDir(wxEmptyString
);
250 CPPUNIT_ASSERT( !fn
.IsOk() );
252 fn
.Assign(wxEmptyString
);
253 CPPUNIT_ASSERT( !fn
.IsOk() );
255 fn
.Assign(wxEmptyString
, wxEmptyString
);
256 CPPUNIT_ASSERT( !fn
.IsOk() );
258 fn
.Assign(wxEmptyString
, wxEmptyString
, wxEmptyString
);
259 CPPUNIT_ASSERT( !fn
.IsOk() );
261 fn
.Assign(wxEmptyString
, wxEmptyString
, wxEmptyString
, wxEmptyString
);
262 CPPUNIT_ASSERT( !fn
.IsOk() );
265 void FileNameTestCase::TestComparison()
267 wxFileName
fn1(wxT("/tmp/file1"));
268 wxFileName
fn2(wxT("/tmp/dir2/../file2"));
271 CPPUNIT_ASSERT_EQUAL(fn1
.GetPath(), fn2
.GetPath());
274 void FileNameTestCase::TestSplit()
276 for ( size_t n
= 0; n
< WXSIZEOF(filenames
); n
++ )
278 const TestFileNameInfo
& fni
= filenames
[n
];
279 wxString volume
, path
, name
, ext
;
280 wxFileName::SplitPath(fni
.fullname
,
281 &volume
, &path
, &name
, &ext
, fni
.format
);
283 CPPUNIT_ASSERT_EQUAL( wxString(fni
.volume
), volume
);
284 CPPUNIT_ASSERT_EQUAL( wxString(fni
.path
), path
);
285 CPPUNIT_ASSERT_EQUAL( wxString(fni
.name
), name
);
286 CPPUNIT_ASSERT_EQUAL( wxString(fni
.ext
), ext
);
289 // special case of empty extension
290 wxFileName
fn("foo.");
291 CPPUNIT_ASSERT_EQUAL( wxString("foo."), fn
.GetFullPath() );
294 void FileNameTestCase::TestSetPath()
296 wxFileName
fn("d:\\test\\foo.bar", wxPATH_DOS
);
297 fn
.SetPath("c:\\temp", wxPATH_DOS
);
298 CPPUNIT_ASSERT( fn
.SameAs(wxFileName("c:\\temp\\foo.bar", wxPATH_DOS
)) );
300 fn
= wxFileName("/usr/bin/ls", wxPATH_UNIX
);
301 fn
.SetPath("/usr/local/bin", wxPATH_UNIX
);
302 CPPUNIT_ASSERT( fn
.SameAs(wxFileName("/usr/local/bin/ls", wxPATH_UNIX
)) );
305 void FileNameTestCase::TestNormalize()
307 // prepare some data to be used later
308 wxString sep
= wxFileName::GetPathSeparator();
309 wxString cwd
= wxGetCwd();
310 wxString home
= wxGetUserHome();
312 cwd
.Replace(sep
, wxT("/"));
313 if (cwd
.Last() != wxT('/'))
315 home
.Replace(sep
, wxT("/"));
316 if (home
.Last() != wxT('/'))
319 // since we will always be testing paths using the wxPATH_UNIX
320 // format, we need to remove the volume, if present
321 if (home
.Contains(wxT(':')))
322 home
= home
.AfterFirst(wxT(':'));
323 if (cwd
.Contains(wxT(':')))
324 cwd
= cwd
.AfterFirst(wxT(':'));
326 static const struct FileNameTest
328 const char *original
;
330 const char *expected
;
334 // test wxPATH_NORM_ENV_VARS
336 { "%ABCDEF%/g/h/i", wxPATH_NORM_ENV_VARS
, "abcdef/g/h/i", wxPATH_UNIX
},
338 { "$(ABCDEF)/g/h/i", wxPATH_NORM_ENV_VARS
, "abcdef/g/h/i", wxPATH_UNIX
},
341 // test wxPATH_NORM_DOTS
342 { "a/.././b/c/../../", wxPATH_NORM_DOTS
, "", wxPATH_UNIX
},
343 { "", wxPATH_NORM_DOTS
, "", wxPATH_UNIX
},
344 { "./foo", wxPATH_NORM_DOTS
, "foo", wxPATH_UNIX
},
345 { "b/../bar", wxPATH_NORM_DOTS
, "bar", wxPATH_UNIX
},
346 { "c/../../quux", wxPATH_NORM_DOTS
, "../quux", wxPATH_UNIX
},
347 { "/c/../../quux", wxPATH_NORM_DOTS
, "/quux", wxPATH_UNIX
},
349 // test wxPATH_NORM_TILDE: notice that ~ is only interpreted specially
350 // when it is the first character in the file name
351 { "/a/b/~", wxPATH_NORM_TILDE
, "/a/b/~", wxPATH_UNIX
},
352 { "/~/a/b", wxPATH_NORM_TILDE
, "/~/a/b", wxPATH_UNIX
},
353 { "~/a/b", wxPATH_NORM_TILDE
, "HOME/a/b", wxPATH_UNIX
},
355 // test wxPATH_NORM_CASE
356 { "Foo", wxPATH_NORM_CASE
, "Foo", wxPATH_UNIX
},
357 { "Foo", wxPATH_NORM_CASE
, "foo", wxPATH_DOS
},
358 { "C:\\Program Files\\wx", wxPATH_NORM_CASE
,
359 "c:\\program files\\wx", wxPATH_DOS
},
360 { "C:/Program Files/wx", wxPATH_NORM_ALL
| wxPATH_NORM_CASE
,
361 "c:\\program files\\wx", wxPATH_DOS
},
362 { "C:\\Users\\zeitlin", wxPATH_NORM_ALL
| wxPATH_NORM_CASE
,
363 "c:\\users\\zeitlin", wxPATH_DOS
},
365 // test wxPATH_NORM_ABSOLUTE
366 { "a/b/", wxPATH_NORM_ABSOLUTE
, "CWD/a/b/", wxPATH_UNIX
},
367 { "a/b/c.ext", wxPATH_NORM_ABSOLUTE
, "CWD/a/b/c.ext", wxPATH_UNIX
},
368 { "/a", wxPATH_NORM_ABSOLUTE
, "/a", wxPATH_UNIX
},
370 // test giving no flags at all to Normalize()
371 { "a/b/", 0, "a/b/", wxPATH_UNIX
},
372 { "a/b/c.ext", 0, "a/b/c.ext", wxPATH_UNIX
},
373 { "/a", 0, "/a", wxPATH_UNIX
},
375 // test handling dots without wxPATH_NORM_DOTS and wxPATH_NORM_ABSOLUTE
376 // for both existing and non-existent files (this is important under
377 // MSW where GetLongPathName() works only for the former)
378 { "./foo", wxPATH_NORM_LONG
, "./foo", wxPATH_UNIX
},
379 { "../foo", wxPATH_NORM_LONG
, "../foo", wxPATH_UNIX
},
380 { ".\\test.bkl", wxPATH_NORM_LONG
, ".\\test.bkl", wxPATH_DOS
},
381 { ".\\foo", wxPATH_NORM_LONG
, ".\\foo", wxPATH_DOS
},
382 { "..\\Makefile.in", wxPATH_NORM_LONG
, "..\\Makefile.in", wxPATH_DOS
},
383 { "..\\foo", wxPATH_NORM_LONG
, "..\\foo", wxPATH_DOS
},
386 // set the env var ABCDEF
387 wxSetEnv("ABCDEF", "abcdef");
389 for ( size_t i
= 0; i
< WXSIZEOF(tests
); i
++ )
391 const FileNameTest
& fnt
= tests
[i
];
392 wxFileName
fn(fnt
.original
, fnt
.fmt
);
394 // be sure this normalization does not fail
397 ("#%d: Normalize(%s) failed", (int)i
, fnt
.original
),
398 fn
.Normalize(fnt
.flags
, cwd
, fnt
.fmt
)
401 // compare result with expected string
402 wxString
expected(tests
[i
].expected
);
403 expected
.Replace("HOME/", home
);
404 expected
.Replace("CWD/", cwd
);
405 WX_ASSERT_EQUAL_MESSAGE
407 ("array element #%d", (int)i
),
408 expected
, fn
.GetFullPath(fnt
.fmt
)
412 // MSW-only test for wxPATH_NORM_LONG: notice that we only run it if short
413 // names generation is not disabled for this system as otherwise the file
414 // MKINST~1 doesn't exist at all and normalizing it fails (it's possible
415 // that we're on a FAT partition in which case the test would still succeed
416 // and also that the registry key was changed recently and didn't take
417 // effect yet but these are marginal cases which we consciously choose to
420 long shortNamesDisabled
;
424 "SYSTEM\\CurrentControlSet\\Control\\FileSystem"
425 ).QueryValue("NtfsDisable8dot3NameCreation", &shortNamesDisabled
) &&
426 !shortNamesDisabled
)
428 wxFileName
fn("..\\MKINST~1");
429 CPPUNIT_ASSERT( fn
.Normalize(wxPATH_NORM_LONG
, cwd
) );
430 CPPUNIT_ASSERT_EQUAL( "..\\mkinstalldirs", fn
.GetFullPath() );
432 //else: when in doubt, don't run the test
433 #endif // __WINDOWS__
436 void FileNameTestCase::TestReplace()
438 static const struct FileNameTest
440 const char *original
;
441 const char *env_contents
;
442 const char *replace_fmtstring
;
443 const char *expected
;
447 { "/usr/a/strange path/lib/someFile.ext", "/usr/a/strange path", "$%s", "$TEST_VAR/lib/someFile.ext", wxPATH_UNIX
},
448 { "/usr/a/path/lib/someFile.ext", "/usr/a/path", "$%s", "$TEST_VAR/lib/someFile.ext", wxPATH_UNIX
},
449 { "/usr/a/path/lib/someFile", "/usr/a/path/", "$%s", "$TEST_VARlib/someFile", wxPATH_UNIX
},
450 { "/usr/a/path/lib/", "/usr/a/path/", "$(%s)", "$(TEST_VAR)lib/", wxPATH_UNIX
},
451 { "/usr/a/path/lib/", "/usr/a/path/", "${{%s}}", "${{TEST_VAR}}lib/", wxPATH_UNIX
},
452 { "/usr/a/path/lib/", "/usr/a/path/", "%s", "TEST_VARlib/", wxPATH_UNIX
},
453 { "/usr/a/path/lib/", "/usr/a/path/", "%s//", "TEST_VAR/lib/", wxPATH_UNIX
},
454 // note: empty directory components are automatically removed by wxFileName thus
455 // using // in the replace format string has no effect
457 { "/usr/../a/path/lib/", "/usr/a/path/", "%s", "/usr/../a/path/lib/", wxPATH_UNIX
},
458 { "/usr/a/path/usr/usr", "/usr", "%s", "TEST_VAR/a/pathTEST_VAR/usr", wxPATH_UNIX
},
459 { "/usr/a/path/usr/usr", "/usr", "$%s", "$TEST_VAR/a/path$TEST_VAR/usr", wxPATH_UNIX
},
460 { "/a/b/c/d", "a/", "%s", "/TEST_VARb/c/d", wxPATH_UNIX
},
462 { "C:\\A\\Strange Path\\lib\\someFile", "C:\\A\\Strange Path", "%%%s%%", "%TEST_VAR%\\lib\\someFile", wxPATH_WIN
},
463 { "C:\\A\\Path\\lib\\someFile", "C:\\A\\Path", "%%%s%%", "%TEST_VAR%\\lib\\someFile", wxPATH_WIN
},
464 { "C:\\A\\Path\\lib\\someFile", "C:\\A\\Path", "$(%s)", "$(TEST_VAR)\\lib\\someFile", wxPATH_WIN
}
467 for ( size_t i
= 0; i
< WXSIZEOF(tests
); i
++ )
469 const FileNameTest
& fnt
= tests
[i
];
470 wxFileName
fn(fnt
.original
, fnt
.fmt
);
472 // set the environment variable
473 wxSetEnv("TEST_VAR", fnt
.env_contents
);
475 // be sure this ReplaceEnvVariable does not fail
478 ("#%d: ReplaceEnvVariable(%s) failed", (int)i
, fnt
.replace_fmtstring
),
479 fn
.ReplaceEnvVariable("TEST_VAR", fnt
.replace_fmtstring
, fnt
.fmt
)
482 // compare result with expected string
483 wxString
expected(fnt
.expected
);
484 WX_ASSERT_EQUAL_MESSAGE
486 ("array element #%d", (int)i
),
487 expected
, fn
.GetFullPath(fnt
.fmt
)
491 // now test ReplaceHomeDir
493 wxFileName fn
= wxFileName::DirName(wxGetHomeDir());
494 fn
.AppendDir("test1");
495 fn
.AppendDir("test2");
496 fn
.AppendDir("test3");
497 fn
.SetName("some file");
501 ("ReplaceHomeDir(%s) failed", fn
.GetFullPath()),
505 CPPUNIT_ASSERT_EQUAL( wxString("~/test1/test2/test3/some file"),
506 fn
.GetFullPath(wxPATH_UNIX
) );
509 void FileNameTestCase::TestGetHumanReadable()
511 static const struct TestData
516 wxSizeConvention conv
;
519 { "NA", 0, 1, wxSIZE_CONV_TRADITIONAL
},
520 { "2.0 KB", 2000, 1, wxSIZE_CONV_TRADITIONAL
},
521 { "1.953 KiB", 2000, 3, wxSIZE_CONV_IEC
},
522 { "2.000 KB", 2000, 3, wxSIZE_CONV_SI
},
523 { "297 KB", 304351, 0, wxSIZE_CONV_TRADITIONAL
},
524 { "304 KB", 304351, 0, wxSIZE_CONV_SI
},
527 CLocaleSetter loc
; // we want to use "C" locale for LC_NUMERIC
528 // so that regardless of the system's locale
529 // the decimal point used by GetHumanReadableSize()
531 for ( unsigned n
= 0; n
< WXSIZEOF(testData
); n
++ )
533 const TestData
& td
= testData
[n
];
535 // take care of using the decimal point for the current locale before
536 // the actual comparison
540 wxFileName::GetHumanReadableSize(td
.size
, "NA", td
.prec
, td
.conv
)
544 // also test the default convention value
545 CPPUNIT_ASSERT_EQUAL( "1.4 MB", wxFileName::GetHumanReadableSize(1512993, "") );
548 void FileNameTestCase::TestStrip()
550 CPPUNIT_ASSERT_EQUAL( "", wxFileName::StripExtension("") );
551 CPPUNIT_ASSERT_EQUAL( ".", wxFileName::StripExtension(".") );
552 CPPUNIT_ASSERT_EQUAL( ".vimrc", wxFileName::StripExtension(".vimrc") );
553 CPPUNIT_ASSERT_EQUAL( "bad", wxFileName::StripExtension("bad") );
554 CPPUNIT_ASSERT_EQUAL( "good", wxFileName::StripExtension("good.wav") );
555 CPPUNIT_ASSERT_EQUAL( "good.wav", wxFileName::StripExtension("good.wav.wav") );
560 void FileNameTestCase::TestShortLongPath()
562 wxFileName
fn("C:\\Program Files\\Windows NT\\Accessories\\wordpad.exe");
564 // incredibly enough, GetLongPath() used to return different results during
565 // the first and subsequent runs, test for this
566 CPPUNIT_ASSERT_EQUAL( fn
.GetLongPath(), fn
.GetLongPath() );
567 CPPUNIT_ASSERT_EQUAL( fn
.GetShortPath(), fn
.GetShortPath() );
570 #endif // __WINDOWS__
572 void FileNameTestCase::TestUNC()
574 wxFileName
fn("//share/path/name.ext", wxPATH_DOS
);
575 CPPUNIT_ASSERT_EQUAL( "share", fn
.GetVolume() );
576 CPPUNIT_ASSERT_EQUAL( "\\path", fn
.GetPath(wxPATH_NO_SEPARATOR
, wxPATH_DOS
) );
578 fn
.Assign("\\\\share2\\path2\\name.ext", wxPATH_DOS
);
579 CPPUNIT_ASSERT_EQUAL( "share2", fn
.GetVolume() );
580 CPPUNIT_ASSERT_EQUAL( "\\path2", fn
.GetPath(wxPATH_NO_SEPARATOR
, wxPATH_DOS
) );
583 void FileNameTestCase::TestVolumeUniqueName()
585 wxFileName
fn("\\\\?\\Volume{8089d7d7-d0ac-11db-9dd0-806d6172696f}\\",
587 CPPUNIT_ASSERT_EQUAL( "Volume{8089d7d7-d0ac-11db-9dd0-806d6172696f}",
589 CPPUNIT_ASSERT_EQUAL( "\\", fn
.GetPath(wxPATH_NO_SEPARATOR
, wxPATH_DOS
) );
590 CPPUNIT_ASSERT_EQUAL( "\\\\?\\Volume{8089d7d7-d0ac-11db-9dd0-806d6172696f}\\",
591 fn
.GetFullPath(wxPATH_DOS
) );
593 fn
.Assign("\\\\?\\Volume{8089d7d7-d0ac-11db-9dd0-806d6172696f}\\"
594 "Program Files\\setup.exe", wxPATH_DOS
);
595 CPPUNIT_ASSERT_EQUAL( "Volume{8089d7d7-d0ac-11db-9dd0-806d6172696f}",
597 CPPUNIT_ASSERT_EQUAL( "\\Program Files",
598 fn
.GetPath(wxPATH_NO_SEPARATOR
, wxPATH_DOS
) );
599 CPPUNIT_ASSERT_EQUAL( "\\\\?\\Volume{8089d7d7-d0ac-11db-9dd0-806d6172696f}\\"
600 "Program Files\\setup.exe",
601 fn
.GetFullPath(wxPATH_DOS
) );
604 void FileNameTestCase::TestCreateTempFileName()
606 static const struct TestData
609 const char *expectedFolder
;
613 { "", "$SYSTEM_TEMP", true },
614 { "foo", "$SYSTEM_TEMP", true },
615 { "..", "$SYSTEM_TEMP", true },
616 { "../bar", "..", true },
618 { "$USER_DOCS_DIR\\", "$USER_DOCS_DIR", true },
619 { "c:\\a\\directory\\which\\does\\not\\exist", "", false },
620 #elif defined( __UNIX__ )
621 { "$USER_DOCS_DIR/", "$USER_DOCS_DIR", true },
622 { "/tmp/foo", "/tmp", true },
623 { "/tmp/a/directory/which/does/not/exist", "", false },
627 for ( size_t n
= 0; n
< WXSIZEOF(testData
); n
++ )
629 wxString prefix
= testData
[n
].prefix
;
630 prefix
.Replace("$USER_DOCS_DIR", wxStandardPaths::Get().GetDocumentsDir());
632 std::string errDesc
= wxString::Format("failed on prefix '%s'", prefix
).ToStdString();
634 wxString path
= wxFileName::CreateTempFileName(prefix
);
635 CPPUNIT_ASSERT_EQUAL_MESSAGE( errDesc
, !testData
[n
].shouldSucceed
, path
.empty() );
637 if (testData
[n
].shouldSucceed
)
639 errDesc
+= "; path is " + path
.ToStdString();
641 // test the place where the temp file has been created
642 wxString expected
= testData
[n
].expectedFolder
;
643 expected
.Replace("$SYSTEM_TEMP", wxStandardPaths::Get().GetTempDir());
644 expected
.Replace("$USER_DOCS_DIR", wxStandardPaths::Get().GetDocumentsDir());
645 CPPUNIT_ASSERT_EQUAL_MESSAGE( errDesc
, expected
, wxFileName(path
).GetPath() );
647 // the temporary file is created with full permissions for the current process
648 // so we should always be able to remove it:
649 CPPUNIT_ASSERT_MESSAGE( errDesc
, wxRemoveFile(path
) );
654 void FileNameTestCase::TestGetTimes()
656 wxFileName
fn(wxFileName::CreateTempFileName("filenametest"));
657 CPPUNIT_ASSERT( fn
.IsOk() );
658 wxON_BLOCK_EXIT1( wxRemoveFile
, fn
.GetFullPath() );
660 wxDateTime dtAccess
, dtMod
, dtCreate
;
661 CPPUNIT_ASSERT( fn
.GetTimes(&dtAccess
, &dtMod
, &dtCreate
) );
663 // make sure all retrieved dates are equal to the current date&time
664 // with an accuracy up to 1 minute
665 CPPUNIT_ASSERT(dtCreate
.IsEqualUpTo(wxDateTime::Now(), wxTimeSpan(0,1)));
666 CPPUNIT_ASSERT(dtMod
.IsEqualUpTo(wxDateTime::Now(), wxTimeSpan(0,1)));
667 CPPUNIT_ASSERT(dtAccess
.IsEqualUpTo(wxDateTime::Now(), wxTimeSpan(0,1)));
670 void FileNameTestCase::TestSetTimes()
672 wxFileName
fn(wxFileName::CreateTempFileName("filenametest"));
673 CPPUNIT_ASSERT( fn
.IsOk() );
674 wxON_BLOCK_EXIT1( wxRemoveFile
, fn
.GetFullPath() );
676 const wxDateTime
dtAccess(1, wxDateTime::Jan
, 2013);
677 const wxDateTime
dtModify(1, wxDateTime::Feb
, 2013);
678 const wxDateTime
dtCreate(1, wxDateTime::Mar
, 2013);
680 CPPUNIT_ASSERT( fn
.SetTimes(&dtAccess
, &dtModify
, &dtCreate
) );
682 wxDateTime dtAccess2
,
685 CPPUNIT_ASSERT( fn
.GetTimes(&dtAccess2
, &dtModify2
, &dtCreate2
) );
686 CPPUNIT_ASSERT_EQUAL( dtAccess
, dtAccess2
);
687 CPPUNIT_ASSERT_EQUAL( dtModify
, dtModify2
);
689 // Under Unix the creation time can't be set.
691 CPPUNIT_ASSERT_EQUAL( dtCreate
, dtCreate2
);
692 #endif // __WINDOWS__
695 void FileNameTestCase::TestExists()
697 wxFileName
fn(wxFileName::CreateTempFileName("filenametest"));
698 CPPUNIT_ASSERT( fn
.IsOk() );
699 wxON_BLOCK_EXIT1( wxRemoveFile
, fn
.GetFullPath() );
701 CPPUNIT_ASSERT( fn
.FileExists() );
702 CPPUNIT_ASSERT( !wxFileName::DirExists(fn
.GetFullPath()) );
704 // FIXME-VC6: This compiler crashes with
706 // fatal error C1001: INTERNAL COMPILER ERROR
707 // (compiler file 'msc1.cpp', line 1794)
709 // when compiling calls to Exists() with parameter for some reason, just
710 // disable these tests there.
712 CPPUNIT_ASSERT( fn
.Exists(wxFILE_EXISTS_REGULAR
) );
713 CPPUNIT_ASSERT( !fn
.Exists(wxFILE_EXISTS_DIR
) );
715 CPPUNIT_ASSERT( fn
.Exists() );
717 const wxString
& tempdir
= wxFileName::GetTempDir();
719 wxFileName
fileInTempDir(tempdir
, "bloordyblop");
720 CPPUNIT_ASSERT( !fileInTempDir
.Exists() );
721 CPPUNIT_ASSERT( fileInTempDir
.DirExists() );
723 wxFileName
dirTemp(wxFileName::DirName(tempdir
));
724 CPPUNIT_ASSERT( !dirTemp
.FileExists() );
725 CPPUNIT_ASSERT( dirTemp
.DirExists() );
728 CPPUNIT_ASSERT( dirTemp
.Exists(wxFILE_EXISTS_DIR
) );
729 CPPUNIT_ASSERT( !dirTemp
.Exists(wxFILE_EXISTS_REGULAR
) );
731 CPPUNIT_ASSERT( dirTemp
.Exists() );
734 CPPUNIT_ASSERT( !wxFileName::FileExists("/dev/null") );
735 CPPUNIT_ASSERT( !wxFileName::DirExists("/dev/null") );
736 CPPUNIT_ASSERT( wxFileName::Exists("/dev/null") );
737 CPPUNIT_ASSERT( wxFileName::Exists("/dev/null", wxFILE_EXISTS_DEVICE
) );
739 // These files are only guaranteed to exist under Linux.
740 // No need for wxFILE_EXISTS_NO_FOLLOW here; wxFILE_EXISTS_SYMLINK implies it
741 CPPUNIT_ASSERT( wxFileName::Exists("/dev/core", wxFILE_EXISTS_SYMLINK
) );
742 CPPUNIT_ASSERT( wxFileName::Exists("/dev/log", wxFILE_EXISTS_SOCKET
) );
745 wxString fifo
= dirTemp
.GetPath() + "/fifo";
746 if (mkfifo(fifo
.c_str(), 0600) == 0)
748 wxON_BLOCK_EXIT1(wxRemoveFile
, fifo
);
750 CPPUNIT_ASSERT( wxFileName::Exists(fifo
, wxFILE_EXISTS_FIFO
) );
756 void FileNameTestCase::TestIsSame()
758 wxFileName
fn1( wxFileName::CreateTempFileName( "filenametest1" ) );
759 CPPUNIT_ASSERT( fn1
.IsOk() );
760 wxON_BLOCK_EXIT1( wxRemoveFile
, fn1
.GetFullPath() );
762 wxFileName
fn2( wxFileName::CreateTempFileName( "filenametest2" ) );
763 CPPUNIT_ASSERT( fn2
.IsOk() );
764 wxON_BLOCK_EXIT1( wxRemoveFile
, fn2
.GetFullPath() );
766 CPPUNIT_ASSERT( fn1
.SameAs( fn1
) );
767 CPPUNIT_ASSERT( !fn1
.SameAs( fn2
) );
769 #if defined(__UNIX__)
770 // We need to create a temporary directory and a temporary link.
771 // Unfortunately we can't use wxFileName::CreateTempFileName() for neither
772 // as it creates plain files, so use tempnam() explicitly instead.
773 char* tn
= tempnam(NULL
, "wxfn1");
774 const wxString tempdir1
= wxString::From8BitData(tn
);
777 CPPUNIT_ASSERT( wxFileName::Mkdir(tempdir1
) );
778 // Unfortunately the casts are needed to select the overload we need here.
779 wxON_BLOCK_EXIT2( static_cast<bool (*)(const wxString
&, int)>(wxFileName::Rmdir
),
780 tempdir1
, static_cast<int>(wxPATH_RMDIR_RECURSIVE
) );
782 tn
= tempnam(NULL
, "wxfn2");
783 const wxString tempdir2
= wxString::From8BitData(tn
);
785 CPPUNIT_ASSERT_EQUAL( 0, symlink(tempdir1
.c_str(), tempdir2
.c_str()) );
786 wxON_BLOCK_EXIT1( wxRemoveFile
, tempdir2
);
789 wxFileName
fn3(tempdir1
, "foo");
790 wxFileName
fn4(tempdir2
, "foo");
792 // These files have different paths, hence are different.
793 CPPUNIT_ASSERT( !fn3
.SameAs(fn4
) );
795 // Create and close a file to trigger creating it.
796 wxFile(fn3
.GetFullPath(), wxFile::write
);
798 // Now that both files do exist we should be able to detect that they are
799 // actually the same file.
800 CPPUNIT_ASSERT( fn3
.SameAs(fn4
) );
804 #if defined(__UNIX__)
806 // Tests for functions that are changed by ShouldFollowLink()
807 void FileNameTestCase::TestSymlinks()
809 const wxString
tmpdir(wxStandardPaths::Get().GetTempDir());
811 wxFileName
tmpfn(wxFileName::DirName(tmpdir
));
813 wxDateTime dtAccessTmp
, dtModTmp
, dtCreateTmp
;
814 CPPUNIT_ASSERT(tmpfn
.GetTimes(&dtAccessTmp
, &dtModTmp
, &dtCreateTmp
));
816 // Create a temporary directory
818 wxString name
= tmpdir
+ ".filenametestXXXXXX]";
819 mkdir( name
.char_str() , 0222 );
820 wxString tempdir
= name
;
822 wxString name
= tmpdir
+ "/filenametestXXXXXX";
823 wxString tempdir
= wxString::From8BitData(mkdtemp(name
.char_str()));
824 tempdir
<< wxFileName::GetPathSeparator();
826 wxFileName
tempdirfn(wxFileName::DirName(tempdir
));
827 CPPUNIT_ASSERT(tempdirfn
.DirExists());
829 // Create a regular file in that dir, to act as a symlink target
830 wxFileName
targetfn(wxFileName::CreateTempFileName(tempdir
));
831 CPPUNIT_ASSERT(targetfn
.FileExists());
833 // Create a symlink to that file
834 wxFileName
linktofile(tempdir
, "linktofile");
835 CPPUNIT_ASSERT_EQUAL(0, symlink(targetfn
.GetFullPath().c_str(),
836 linktofile
.GetFullPath().c_str()));
838 // ... and another to the temporary directory
839 const wxString
linktodirName(tempdir
+ "/linktodir");
840 wxFileName
linktodir(wxFileName::DirName(linktodirName
));
841 CPPUNIT_ASSERT_EQUAL(0, symlink(tmpfn
.GetFullPath().c_str(),
842 linktodirName
.c_str()));
844 // And symlinks to both of those symlinks
845 wxFileName
linktofilelnk(tempdir
, "linktofilelnk");
846 CPPUNIT_ASSERT_EQUAL(0, symlink(linktofile
.GetFullPath().c_str(),
847 linktofilelnk
.GetFullPath().c_str()));
848 wxFileName
linktodirlnk(tempdir
, "linktodirlnk");
849 CPPUNIT_ASSERT_EQUAL(0, symlink(linktodir
.GetFullPath().c_str(),
850 linktodirlnk
.GetFullPath().c_str()));
852 // Run the tests twice: once in the default symlink following mode and the
853 // second time without following symlinks.
855 for ( int n
= 0; n
< 2; ++n
, deref
= !deref
)
857 const std::string
msg(deref
? " failed for the link target"
858 : " failed for the path itself");
862 linktofile
.DontFollowLink();
863 linktodir
.DontFollowLink();
864 linktofilelnk
.DontFollowLink();
865 linktodirlnk
.DontFollowLink();
869 CPPUNIT_ASSERT_EQUAL_MESSAGE
871 "Comparison with file" + msg
,
872 deref
, linktofile
.SameAs(targetfn
)
875 CPPUNIT_ASSERT_EQUAL_MESSAGE
877 "Comparison with directory" + msg
,
878 deref
, linktodir
.SameAs(tmpfn
)
881 // A link-to-a-link should dereference through to the final target
882 CPPUNIT_ASSERT_EQUAL_MESSAGE
884 "Comparison with link to a file" + msg
,
886 linktofilelnk
.SameAs(targetfn
)
888 CPPUNIT_ASSERT_EQUAL_MESSAGE
890 "Comparison with link to a directory" + msg
,
892 linktodirlnk
.SameAs(tmpfn
)
896 wxDateTime dtAccess
, dtMod
, dtCreate
;
897 CPPUNIT_ASSERT_MESSAGE
899 "Getting times of a directory" + msg
,
900 linktodir
.GetTimes(&dtAccess
, &dtMod
, &dtCreate
)
903 // IsEqualTo() should be true only when dereferencing. Don't test each
904 // individually: accessing to create the link will have updated some
905 bool equal
= dtCreate
.IsEqualTo(dtCreateTmp
) &&
906 dtMod
.IsEqualTo(dtModTmp
) &&
907 dtAccess
.IsEqualTo(dtAccessTmp
);
908 CPPUNIT_ASSERT_EQUAL_MESSAGE
910 "Comparing directory times" + msg
,
915 // Test (File|Dir)Exists()
916 CPPUNIT_ASSERT_EQUAL_MESSAGE
918 "Testing file existence" + msg
,
920 linktofile
.FileExists()
922 CPPUNIT_ASSERT_EQUAL_MESSAGE
924 "Testing directory existence" + msg
,
926 linktodir
.DirExists()
929 // Test wxFileName::Exists
930 // The wxFILE_EXISTS_NO_FOLLOW flag should override DontFollowLink()
931 CPPUNIT_ASSERT_EQUAL_MESSAGE
933 "Testing file existence" + msg
,
935 linktofile
.Exists(wxFILE_EXISTS_REGULAR
| wxFILE_EXISTS_NO_FOLLOW
)
937 CPPUNIT_ASSERT_EQUAL_MESSAGE
939 "Testing directory existence" + msg
,
941 linktodir
.Exists(wxFILE_EXISTS_DIR
| wxFILE_EXISTS_NO_FOLLOW
)
943 // and the static versions
944 CPPUNIT_ASSERT_EQUAL_MESSAGE
946 "Testing file existence" + msg
,
948 wxFileName::Exists(linktofile
.GetFullPath(), wxFILE_EXISTS_REGULAR
| wxFILE_EXISTS_NO_FOLLOW
)
950 CPPUNIT_ASSERT_EQUAL_MESSAGE
952 "Testing file existence" + msg
,
954 wxFileName::Exists(linktofile
.GetFullPath(), wxFILE_EXISTS_REGULAR
)
956 CPPUNIT_ASSERT_EQUAL_MESSAGE
958 "Testing directory existence" + msg
,
960 wxFileName::Exists(linktodir
.GetFullPath(), wxFILE_EXISTS_DIR
| wxFILE_EXISTS_NO_FOLLOW
)
962 CPPUNIT_ASSERT_EQUAL_MESSAGE
964 "Testing directory existence" + msg
,
966 wxFileName::Exists(linktodir
.GetFullPath(), wxFILE_EXISTS_DIR
)
970 // Finally test Exists() after removing the file.
971 CPPUNIT_ASSERT(wxRemoveFile(targetfn
.GetFullPath()));
972 // This should succeed, as the symlink still exists and
973 // the default wxFILE_EXISTS_ANY implies wxFILE_EXISTS_NO_FOLLOW
974 CPPUNIT_ASSERT(wxFileName(tempdir
, "linktofile").Exists());
975 // So should this one, as wxFILE_EXISTS_SYMLINK does too
976 CPPUNIT_ASSERT(wxFileName(tempdir
, "linktofile").
977 Exists(wxFILE_EXISTS_SYMLINK
));
978 // but not this one, as the now broken symlink is followed
979 CPPUNIT_ASSERT(!wxFileName(tempdir
, "linktofile").
980 Exists(wxFILE_EXISTS_REGULAR
));
981 CPPUNIT_ASSERT(linktofile
.Exists());
983 // This is also a convenient place to test Rmdir() as we have things to
986 // First, check that removing a symlink to a directory fails.
987 CPPUNIT_ASSERT( !wxFileName::Rmdir(linktodirName
) );
989 // And recursively removing it only removes the symlink itself, not the
991 CPPUNIT_ASSERT( wxFileName::Rmdir(linktodirName
, wxPATH_RMDIR_RECURSIVE
) );
992 CPPUNIT_ASSERT( tmpfn
.Exists() );
994 // Finally removing the directory itself does remove everything.
995 CPPUNIT_ASSERT(tempdirfn
.Rmdir(wxPATH_RMDIR_RECURSIVE
));
996 CPPUNIT_ASSERT( !tempdirfn
.Exists() );