tests/filename/filenametest.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        tests/filename/filename.cpp
   3 // Purpose:     wxFileName unit test
   4 // Author:      Vadim Zeitlin
   5 // Created:     2004-07-25
   6 // RCS-ID:      $Id$
   7 // Copyright:   (c) 2004 Vadim Zeitlin
   8 ///////////////////////////////////////////////////////////////////////////////
   9
  10 // ----------------------------------------------------------------------------
  11 // headers
  12 // ----------------------------------------------------------------------------
  13
  14 #include "testprec.h"
  15
  16 #ifdef __BORLANDC__
  17     #pragma hdrstop
  18 #endif
  19
  20 #ifndef WX_PRECOMP
  21     #include "wx/utils.h"
  22 #endif // WX_PRECOMP
  23
  24 #include "wx/filename.h"
  25 #include "wx/filefn.h"
  26 #include "wx/stdpaths.h"
  27 #include "wx/scopeguard.h"
  28
  29 #ifdef __WINDOWS__
  30     #include "wx/msw/registry.h"
  31 #endif // __WINDOWS__
  32
  33 #ifdef __UNIX__
  34     #include <unistd.h>
  35 #endif // __UNIX__
  36
  37 #include "testfile.h"
  38
  39 // ----------------------------------------------------------------------------
  40 // test data
  41 // ----------------------------------------------------------------------------
  42
  43 static struct TestFileNameInfo
  44 {
  45     const char *fullname;
  46     const char *volume;
  47     const char *path;
  48     const char *name;
  49     const char *ext;
  50     bool isAbsolute;
  51     wxPathFormat format;
  52 } filenames[] =
  53 {
  54     // the empty string
  55     { "", "", "", "", "", false, wxPATH_UNIX },
  56     { "", "", "", "", "", false, wxPATH_DOS },
  57     { "", "", "", "", "", false, wxPATH_VMS },
  58
  59     // Unix file names
  60     { "/usr/bin/ls", "", "/usr/bin", "ls", "", true, wxPATH_UNIX },
  61     { "/usr/bin/", "", "/usr/bin", "", "", true, wxPATH_UNIX },
  62     { "~/.zshrc", "", "~", ".zshrc", "", true, wxPATH_UNIX },
  63     { "../../foo", "", "../..", "foo", "", false, wxPATH_UNIX },
  64     { "foo.bar", "", "", "foo", "bar", false, wxPATH_UNIX },
  65     { "~/foo.bar", "", "~", "foo", "bar", true, wxPATH_UNIX },
  66     { "~user/foo.bar", "", "~user", "foo", "bar", true, wxPATH_UNIX },
  67     { "~user/", "", "~user", "", "", true, wxPATH_UNIX },
  68     { "/foo", "", "/", "foo", "", true, wxPATH_UNIX },
  69     { "Mahogany-0.60/foo.bar", "", "Mahogany-0.60", "foo", "bar", false, wxPATH_UNIX },
  70     { "/tmp/wxwin.tar.bz", "", "/tmp", "wxwin.tar", "bz", true, wxPATH_UNIX },
  71
  72     // Windows file names
  73     { "foo.bar", "", "", "foo", "bar", false, wxPATH_DOS },
  74     { "\\foo.bar", "", "\\", "foo", "bar", false, wxPATH_DOS },
  75     { "c:foo.bar", "c", "", "foo", "bar", false, wxPATH_DOS },
  76     { "c:\\foo.bar", "c", "\\", "foo", "bar", true, wxPATH_DOS },
  77     { "c:\\Windows\\command.com", "c", "\\Windows", "command", "com", true, wxPATH_DOS },
  78     { "\\\\?\\Volume{8089d7d7-d0ac-11db-9dd0-806d6172696f}\\",
  79       "Volume{8089d7d7-d0ac-11db-9dd0-806d6172696f}", "\\", "", "", true, wxPATH_DOS },
  80     { "\\\\?\\Volume{8089d7d7-d0ac-11db-9dd0-806d6172696f}\\Program Files\\setup.exe",
  81       "Volume{8089d7d7-d0ac-11db-9dd0-806d6172696f}", "\\Program Files", "setup", "exe", true, wxPATH_DOS },
  82
  83 #if 0
  84     // NB: when using the wxFileName::GetLongPath() function on these two
  85     //     strings, the program will hang for several seconds blocking inside
  86     //     Win32 GetLongPathName() function
  87     { "\\\\server\\foo.bar", "server", "\\", "foo", "bar", true, wxPATH_DOS },
  88     { "\\\\server\\dir\\foo.bar", "server", "\\dir", "foo", "bar", true, wxPATH_DOS },
  89 #endif
  90
  91     // consecutive [back]slashes should be treated as single occurrences of
  92     // them and not interpreted as share names if there is a volume name
  93     { "c:\\aaa\\bbb\\ccc", "c", "\\aaa\\bbb", "ccc", "", true, wxPATH_DOS },
  94     { "c:\\\\aaa\\bbb\\ccc", "c", "\\\\aaa\\bbb", "ccc", "", true, wxPATH_DOS },
  95
  96     // wxFileName support for Mac file names is broken currently
  97 #if 0
  98     // Mac file names
  99     { "Volume:Dir:File", "Volume", "Dir", "File", "", true, wxPATH_MAC },
 100     { "Volume:Dir:Subdir:File", "Volume", "Dir:Subdir", "File", "", true, wxPATH_MAC },
 101     { "Volume:", "Volume", "", "", "", true, wxPATH_MAC },
 102     { ":Dir:File", "", "Dir", "File", "", false, wxPATH_MAC },
 103     { ":File.Ext", "", "", "File", ".Ext", false, wxPATH_MAC },
 104     { "File.Ext", "", "", "File", ".Ext", false, wxPATH_MAC },
 105 #endif // 0
 106
 107 #if 0
 108     // VMS file names
 109     // NB: on Windows they have the same effect of the \\server\\ strings
 110     //     (see the note above)
 111     { "device:[dir1.dir2.dir3]file.txt", "device", "dir1.dir2.dir3", "file", "txt", true, wxPATH_VMS },
 112 #endif
 113     { "file.txt", "", "", "file", "txt", false, wxPATH_VMS },
 114 };
 115
 116 // ----------------------------------------------------------------------------
 117 // test class
 118 // ----------------------------------------------------------------------------
 119
 120 class FileNameTestCase : public CppUnit::TestCase
 121 {
 122 public:
 123     FileNameTestCase() { }
 124
 125 private:
 126     CPPUNIT_TEST_SUITE( FileNameTestCase );
 127         CPPUNIT_TEST( TestConstruction );
 128         CPPUNIT_TEST( TestComparison );
 129         CPPUNIT_TEST( TestSplit );
 130         CPPUNIT_TEST( TestSetPath );
 131         CPPUNIT_TEST( TestStrip );
 132         CPPUNIT_TEST( TestNormalize );
 133         CPPUNIT_TEST( TestReplace );
 134         CPPUNIT_TEST( TestGetHumanReadable );
 135 #ifdef __WINDOWS__
 136         CPPUNIT_TEST( TestShortLongPath );
 137 #endif // __WINDOWS__
 138         CPPUNIT_TEST( TestUNC );
 139         CPPUNIT_TEST( TestVolumeUniqueName );
 140         CPPUNIT_TEST( TestCreateTempFileName );
 141         CPPUNIT_TEST( TestGetTimes );
 142         CPPUNIT_TEST( TestExists );
 143         CPPUNIT_TEST( TestIsSame );
 144 #if defined(__UNIX__)
 145         CPPUNIT_TEST( TestSymlinks );
 146 #endif // __UNIX__
 147     CPPUNIT_TEST_SUITE_END();
 148
 149     void TestConstruction();
 150     void TestComparison();
 151     void TestSplit();
 152     void TestSetPath();
 153     void TestStrip();
 154     void TestNormalize();
 155     void TestReplace();
 156     void TestGetHumanReadable();
 157 #ifdef __WINDOWS__
 158     void TestShortLongPath();
 159 #endif // __WINDOWS__
 160     void TestUNC();
 161     void TestVolumeUniqueName();
 162     void TestCreateTempFileName();
 163     void TestGetTimes();
 164     void TestExists();
 165     void TestIsSame();
 166 #if defined(__UNIX__)
 167     void TestSymlinks();
 168 #endif // __UNIX__
 169
 170     DECLARE_NO_COPY_CLASS(FileNameTestCase)
 171 };
 172
 173 // register in the unnamed registry so that these tests are run by default
 174 CPPUNIT_TEST_SUITE_REGISTRATION( FileNameTestCase );
 175
 176 // also include in its own registry so that these tests can be run alone
 177 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( FileNameTestCase, "FileNameTestCase" );
 178
 179 void FileNameTestCase::TestConstruction()
 180 {
 181     for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
 182     {
 183         const TestFileNameInfo& fni = filenames[n];
 184
 185         wxFileName fn(fni.fullname, fni.format);
 186
 187         // the original full name could contain consecutive [back]slashes,
 188         // squeeze them except for the double backslash in the beginning in
 189         // Windows filenames where it has special meaning
 190         wxString fullnameOrig;
 191         if ( fni.format == wxPATH_DOS )
 192         {
 193             // copy the backslashes at beginning unchanged
 194             const char *p = fni.fullname;
 195             while ( *p == '\\' )
 196                 fullnameOrig += *p++;
 197
 198             // replace consecutive slashes with single ones in the rest
 199             for ( char chPrev = '\0'; *p; p++ )
 200             {
 201                 if ( *p == '\\' && chPrev == '\\' )
 202                     continue;
 203
 204                 chPrev = *p;
 205                 fullnameOrig += chPrev;
 206             }
 207         }
 208         else // !wxPATH_DOS
 209         {
 210             fullnameOrig = fni.fullname;
 211         }
 212
 213         fullnameOrig.Replace("//", "/");
 214
 215
 216         wxString fullname = fn.GetFullPath(fni.format);
 217         CPPUNIT_ASSERT_EQUAL( fullnameOrig, fullname );
 218
 219         // notice that we use a dummy working directory to ensure that paths
 220         // with "../.." in them could be normalized, otherwise this would fail
 221         // if the test is run from root directory or its direct subdirectory
 222         CPPUNIT_ASSERT_MESSAGE
 223         (
 224             (const char *)wxString::Format("Normalize(%s) failed", fni.fullname).mb_str(),
 225             fn.Normalize(wxPATH_NORM_ALL, "/foo/bar/baz", fni.format)
 226         );
 227
 228         if ( *fni.volume && *fni.path )
 229         {
 230             // check that specifying the volume separately or as part of the
 231             // path doesn't make any difference
 232             wxString pathWithVolume = fni.volume;
 233             pathWithVolume += wxFileName::GetVolumeSeparator(fni.format);
 234             pathWithVolume += fni.path;
 235
 236             CPPUNIT_ASSERT_EQUAL( wxFileName(pathWithVolume,
 237                                              fni.name,
 238                                              fni.ext,
 239                                              fni.format), fn );
 240         }
 241     }
 242
 243     wxFileName fn;
 244
 245     // empty strings
 246     fn.AssignDir(wxEmptyString);
 247     CPPUNIT_ASSERT( !fn.IsOk() );
 248
 249     fn.Assign(wxEmptyString);
 250     CPPUNIT_ASSERT( !fn.IsOk() );
 251
 252     fn.Assign(wxEmptyString, wxEmptyString);
 253     CPPUNIT_ASSERT( !fn.IsOk() );
 254
 255     fn.Assign(wxEmptyString, wxEmptyString, wxEmptyString);
 256     CPPUNIT_ASSERT( !fn.IsOk() );
 257
 258     fn.Assign(wxEmptyString, wxEmptyString, wxEmptyString, wxEmptyString);
 259     CPPUNIT_ASSERT( !fn.IsOk() );
 260 }
 261
 262 void FileNameTestCase::TestComparison()
 263 {
 264     wxFileName fn1(wxT("/tmp/file1"));
 265     wxFileName fn2(wxT("/tmp/dir2/../file2"));
 266     fn1.Normalize();
 267     fn2.Normalize();
 268     CPPUNIT_ASSERT_EQUAL(fn1.GetPath(), fn2.GetPath());
 269 }
 270
 271 void FileNameTestCase::TestSplit()
 272 {
 273     for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
 274     {
 275         const TestFileNameInfo& fni = filenames[n];
 276         wxString volume, path, name, ext;
 277         wxFileName::SplitPath(fni.fullname,
 278                               &volume, &path, &name, &ext, fni.format);
 279
 280         CPPUNIT_ASSERT_EQUAL( wxString(fni.volume), volume );
 281         CPPUNIT_ASSERT_EQUAL( wxString(fni.path), path );
 282         CPPUNIT_ASSERT_EQUAL( wxString(fni.name), name );
 283         CPPUNIT_ASSERT_EQUAL( wxString(fni.ext), ext );
 284     }
 285
 286     // special case of empty extension
 287     wxFileName fn("foo.");
 288     CPPUNIT_ASSERT_EQUAL( wxString("foo."), fn.GetFullPath() );
 289 }
 290
 291 void FileNameTestCase::TestSetPath()
 292 {
 293     wxFileName fn("d:\\test\\foo.bar", wxPATH_DOS);
 294     fn.SetPath("c:\\temp", wxPATH_DOS);
 295     CPPUNIT_ASSERT( fn.SameAs(wxFileName("c:\\temp\\foo.bar", wxPATH_DOS)) );
 296
 297     fn = wxFileName("/usr/bin/ls", wxPATH_UNIX);
 298     fn.SetPath("/usr/local/bin", wxPATH_UNIX);
 299     CPPUNIT_ASSERT( fn.SameAs(wxFileName("/usr/local/bin/ls", wxPATH_UNIX)) );
 300 }
 301
 302 void FileNameTestCase::TestNormalize()
 303 {
 304     // prepare some data to be used later
 305     wxString sep = wxFileName::GetPathSeparator();
 306     wxString cwd = wxGetCwd();
 307     wxString home = wxGetUserHome();
 308
 309     cwd.Replace(sep, wxT("/"));
 310     if (cwd.Last() != wxT('/'))
 311         cwd += wxT('/');
 312     home.Replace(sep, wxT("/"));
 313     if (home.Last() != wxT('/'))
 314         home += wxT('/');
 315
 316     // since we will always be testing paths using the wxPATH_UNIX
 317     // format, we need to remove the volume, if present
 318     if (home.Contains(wxT(':')))
 319         home = home.AfterFirst(wxT(':'));
 320     if (cwd.Contains(wxT(':')))
 321         cwd = cwd.AfterFirst(wxT(':'));
 322
 323     static const struct FileNameTest
 324     {
 325         const char *original;
 326         int flags;
 327         const char *expected;
 328         wxPathFormat fmt;
 329     } tests[] =
 330     {
 331         // test wxPATH_NORM_ENV_VARS
 332 #ifdef __WINDOWS__
 333         { "%ABCDEF%/g/h/i", wxPATH_NORM_ENV_VARS, "abcdef/g/h/i", wxPATH_UNIX },
 334 #else
 335         { "$(ABCDEF)/g/h/i", wxPATH_NORM_ENV_VARS, "abcdef/g/h/i", wxPATH_UNIX },
 336 #endif
 337
 338         // test wxPATH_NORM_DOTS
 339         { "a/.././b/c/../../", wxPATH_NORM_DOTS, "", wxPATH_UNIX },
 340         { "", wxPATH_NORM_DOTS, "", wxPATH_UNIX },
 341         { "./foo", wxPATH_NORM_DOTS, "foo", wxPATH_UNIX },
 342         { "b/../bar", wxPATH_NORM_DOTS, "bar", wxPATH_UNIX },
 343         { "c/../../quux", wxPATH_NORM_DOTS, "../quux", wxPATH_UNIX },
 344         { "/c/../../quux", wxPATH_NORM_DOTS, "/quux", wxPATH_UNIX },
 345
 346         // test wxPATH_NORM_TILDE: notice that ~ is only interpreted specially
 347         // when it is the first character in the file name
 348         { "/a/b/~", wxPATH_NORM_TILDE, "/a/b/~", wxPATH_UNIX },
 349         { "/~/a/b", wxPATH_NORM_TILDE, "/~/a/b", wxPATH_UNIX },
 350         { "~/a/b", wxPATH_NORM_TILDE, "HOME/a/b", wxPATH_UNIX },
 351
 352         // test wxPATH_NORM_CASE
 353         { "Foo", wxPATH_NORM_CASE, "Foo", wxPATH_UNIX },
 354         { "Foo", wxPATH_NORM_CASE, "foo", wxPATH_DOS },
 355         { "C:\\Program Files\\wx", wxPATH_NORM_CASE,
 356           "c:\\program files\\wx", wxPATH_DOS },
 357         { "C:/Program Files/wx", wxPATH_NORM_ALL | wxPATH_NORM_CASE,
 358           "c:\\program files\\wx", wxPATH_DOS },
 359         { "C:\\Users\\zeitlin", wxPATH_NORM_ALL | wxPATH_NORM_CASE,
 360           "c:\\users\\zeitlin", wxPATH_DOS },
 361
 362         // test wxPATH_NORM_ABSOLUTE
 363         { "a/b/", wxPATH_NORM_ABSOLUTE, "CWD/a/b/", wxPATH_UNIX },
 364         { "a/b/c.ext", wxPATH_NORM_ABSOLUTE, "CWD/a/b/c.ext", wxPATH_UNIX },
 365         { "/a", wxPATH_NORM_ABSOLUTE, "/a", wxPATH_UNIX },
 366
 367         // test giving no flags at all to Normalize()
 368         { "a/b/", 0, "a/b/", wxPATH_UNIX },
 369         { "a/b/c.ext", 0, "a/b/c.ext", wxPATH_UNIX },
 370         { "/a", 0, "/a", wxPATH_UNIX },
 371
 372         // test handling dots without wxPATH_NORM_DOTS and wxPATH_NORM_ABSOLUTE
 373         // for both existing and non-existent files (this is important under
 374         // MSW where GetLongPathName() works only for the former)
 375         { "./foo", wxPATH_NORM_LONG, "./foo", wxPATH_UNIX },
 376         { "../foo", wxPATH_NORM_LONG, "../foo", wxPATH_UNIX },
 377         { ".\\test.bkl", wxPATH_NORM_LONG, ".\\test.bkl", wxPATH_DOS },
 378         { ".\\foo", wxPATH_NORM_LONG, ".\\foo", wxPATH_DOS },
 379         { "..\\Makefile.in", wxPATH_NORM_LONG, "..\\Makefile.in", wxPATH_DOS },
 380         { "..\\foo", wxPATH_NORM_LONG, "..\\foo", wxPATH_DOS },
 381     };
 382
 383     // set the env var ABCDEF
 384     wxSetEnv("ABCDEF", "abcdef");
 385
 386     for ( size_t i = 0; i < WXSIZEOF(tests); i++ )
 387     {
 388         const FileNameTest& fnt = tests[i];
 389         wxFileName fn(fnt.original, fnt.fmt);
 390
 391         // be sure this normalization does not fail
 392         WX_ASSERT_MESSAGE
 393         (
 394             ("#%d: Normalize(%s) failed", (int)i, fnt.original),
 395             fn.Normalize(fnt.flags, cwd, fnt.fmt)
 396         );
 397
 398         // compare result with expected string
 399         wxString expected(tests[i].expected);
 400         expected.Replace("HOME/", home);
 401         expected.Replace("CWD/", cwd);
 402         WX_ASSERT_EQUAL_MESSAGE
 403         (
 404             ("array element #%d", (int)i),
 405             expected, fn.GetFullPath(fnt.fmt)
 406         );
 407     }
 408
 409     // MSW-only test for wxPATH_NORM_LONG: notice that we only run it if short
 410     // names generation is not disabled for this system as otherwise the file
 411     // MKINST~1 doesn't exist at all and normalizing it fails (it's possible
 412     // that we're on a FAT partition in which case the test would still succeed
 413     // and also that the registry key was changed recently and didn't take
 414     // effect yet but these are marginal cases which we consciously choose to
 415     // ignore for now)
 416 #ifdef __WINDOWS__
 417     long shortNamesDisabled;
 418     if ( wxRegKey
 419          (
 420             wxRegKey::HKLM,
 421             "SYSTEM\\CurrentControlSet\\Control\\FileSystem"
 422          ).QueryValue("NtfsDisable8dot3NameCreation", &shortNamesDisabled) &&
 423             !shortNamesDisabled )
 424     {
 425         wxFileName fn("..\\MKINST~1");
 426         CPPUNIT_ASSERT( fn.Normalize(wxPATH_NORM_LONG, cwd) );
 427         CPPUNIT_ASSERT_EQUAL( "..\\mkinstalldirs", fn.GetFullPath() );
 428     }
 429     //else: when in doubt, don't run the test
 430 #endif // __WINDOWS__
 431 }
 432
 433 void FileNameTestCase::TestReplace()
 434 {
 435     static const struct FileNameTest
 436     {
 437         const char *original;
 438         const char *env_contents;
 439         const char *replace_fmtstring;
 440         const char *expected;
 441         wxPathFormat fmt;
 442     } tests[] =
 443     {
 444         { "/usr/a/strange path/lib/someFile.ext", "/usr/a/strange path", "$%s", "$TEST_VAR/lib/someFile.ext", wxPATH_UNIX },
 445         { "/usr/a/path/lib/someFile.ext", "/usr/a/path", "$%s", "$TEST_VAR/lib/someFile.ext", wxPATH_UNIX },
 446         { "/usr/a/path/lib/someFile", "/usr/a/path/", "$%s", "$TEST_VARlib/someFile", wxPATH_UNIX },
 447         { "/usr/a/path/lib/", "/usr/a/path/", "$(%s)", "$(TEST_VAR)lib/", wxPATH_UNIX },
 448         { "/usr/a/path/lib/", "/usr/a/path/", "${{%s}}", "${{TEST_VAR}}lib/", wxPATH_UNIX },
 449         { "/usr/a/path/lib/", "/usr/a/path/", "%s", "TEST_VARlib/", wxPATH_UNIX },
 450         { "/usr/a/path/lib/", "/usr/a/path/", "%s//", "TEST_VAR/lib/", wxPATH_UNIX },
 451             // note: empty directory components are automatically removed by wxFileName thus
 452             //       using // in the replace format string has no effect
 453
 454         { "/usr/../a/path/lib/", "/usr/a/path/", "%s", "/usr/../a/path/lib/", wxPATH_UNIX },
 455         { "/usr/a/path/usr/usr", "/usr", "%s", "TEST_VAR/a/pathTEST_VAR/usr", wxPATH_UNIX },
 456         { "/usr/a/path/usr/usr", "/usr", "$%s", "$TEST_VAR/a/path$TEST_VAR/usr", wxPATH_UNIX },
 457         { "/a/b/c/d", "a/", "%s", "/TEST_VARb/c/d", wxPATH_UNIX },
 458
 459         { "C:\\A\\Strange Path\\lib\\someFile", "C:\\A\\Strange Path", "%%%s%%", "%TEST_VAR%\\lib\\someFile", wxPATH_WIN },
 460         { "C:\\A\\Path\\lib\\someFile", "C:\\A\\Path", "%%%s%%", "%TEST_VAR%\\lib\\someFile", wxPATH_WIN },
 461         { "C:\\A\\Path\\lib\\someFile", "C:\\A\\Path", "$(%s)", "$(TEST_VAR)\\lib\\someFile", wxPATH_WIN }
 462     };
 463
 464     for ( size_t i = 0; i < WXSIZEOF(tests); i++ )
 465     {
 466         const FileNameTest& fnt = tests[i];
 467         wxFileName fn(fnt.original, fnt.fmt);
 468
 469         // set the environment variable
 470         wxSetEnv("TEST_VAR", fnt.env_contents);
 471
 472         // be sure this ReplaceEnvVariable does not fail
 473         WX_ASSERT_MESSAGE
 474         (
 475             ("#%d: ReplaceEnvVariable(%s) failed", (int)i, fnt.replace_fmtstring),
 476             fn.ReplaceEnvVariable("TEST_VAR", fnt.replace_fmtstring, fnt.fmt)
 477         );
 478
 479         // compare result with expected string
 480         wxString expected(fnt.expected);
 481         WX_ASSERT_EQUAL_MESSAGE
 482         (
 483             ("array element #%d", (int)i),
 484             expected, fn.GetFullPath(fnt.fmt)
 485         );
 486     }
 487
 488     // now test ReplaceHomeDir
 489
 490     wxFileName fn = wxFileName::DirName(wxGetHomeDir());
 491     fn.AppendDir("test1");
 492     fn.AppendDir("test2");
 493     fn.AppendDir("test3");
 494     fn.SetName("some file");
 495
 496     WX_ASSERT_MESSAGE
 497     (
 498         ("ReplaceHomeDir(%s) failed", fn.GetFullPath()),
 499         fn.ReplaceHomeDir()
 500     );
 501
 502     CPPUNIT_ASSERT_EQUAL( wxString("~/test1/test2/test3/some file"),
 503                           fn.GetFullPath(wxPATH_UNIX) );
 504 }
 505
 506 void FileNameTestCase::TestGetHumanReadable()
 507 {
 508     static const struct TestData
 509     {
 510         const char *result;
 511         int size;
 512         int prec;
 513         wxSizeConvention conv;
 514     } testData[] =
 515     {
 516         { "NA",             0, 1, wxSIZE_CONV_TRADITIONAL },
 517         { "2.0 KB",      2000, 1, wxSIZE_CONV_TRADITIONAL },
 518         { "1.953 KiB",   2000, 3, wxSIZE_CONV_IEC         },
 519         { "2.000 KB",    2000, 3, wxSIZE_CONV_SI          },
 520         { "297 KB",    304351, 0, wxSIZE_CONV_TRADITIONAL },
 521         { "304 KB",    304351, 0, wxSIZE_CONV_SI          },
 522     };
 523
 524     CLocaleSetter loc;      // we want to use "C" locale for LC_NUMERIC
 525                             // so that regardless of the system's locale
 526                             // the decimal point used by GetHumanReadableSize()
 527                             // is always '.'
 528     for ( unsigned n = 0; n < WXSIZEOF(testData); n++ )
 529     {
 530         const TestData& td = testData[n];
 531
 532         // take care of using the decimal point for the current locale before
 533         // the actual comparison
 534         CPPUNIT_ASSERT_EQUAL
 535         (
 536             td.result,
 537             wxFileName::GetHumanReadableSize(td.size, "NA", td.prec, td.conv)
 538         );
 539     }
 540
 541     // also test the default convention value
 542     CPPUNIT_ASSERT_EQUAL( "1.4 MB", wxFileName::GetHumanReadableSize(1512993, "") );
 543 }
 544
 545 void FileNameTestCase::TestStrip()
 546 {
 547     CPPUNIT_ASSERT_EQUAL( "", wxFileName::StripExtension("") );
 548     CPPUNIT_ASSERT_EQUAL( ".", wxFileName::StripExtension(".") );
 549     CPPUNIT_ASSERT_EQUAL( ".vimrc", wxFileName::StripExtension(".vimrc") );
 550     CPPUNIT_ASSERT_EQUAL( "bad", wxFileName::StripExtension("bad") );
 551     CPPUNIT_ASSERT_EQUAL( "good", wxFileName::StripExtension("good.wav") );
 552     CPPUNIT_ASSERT_EQUAL( "good.wav", wxFileName::StripExtension("good.wav.wav") );
 553 }
 554
 555 #ifdef __WINDOWS__
 556
 557 void FileNameTestCase::TestShortLongPath()
 558 {
 559     wxFileName fn("C:\\Program Files\\Windows NT\\Accessories\\wordpad.exe");
 560
 561     // incredibly enough, GetLongPath() used to return different results during
 562     // the first and subsequent runs, test for this
 563     CPPUNIT_ASSERT_EQUAL( fn.GetLongPath(), fn.GetLongPath() );
 564     CPPUNIT_ASSERT_EQUAL( fn.GetShortPath(), fn.GetShortPath() );
 565 }
 566
 567 #endif // __WINDOWS__
 568
 569 void FileNameTestCase::TestUNC()
 570 {
 571     wxFileName fn("//share/path/name.ext", wxPATH_DOS);
 572     CPPUNIT_ASSERT_EQUAL( "share", fn.GetVolume() );
 573     CPPUNIT_ASSERT_EQUAL( "\\path", fn.GetPath(wxPATH_NO_SEPARATOR, wxPATH_DOS) );
 574
 575     fn.Assign("\\\\share2\\path2\\name.ext", wxPATH_DOS);
 576     CPPUNIT_ASSERT_EQUAL( "share2", fn.GetVolume() );
 577     CPPUNIT_ASSERT_EQUAL( "\\path2", fn.GetPath(wxPATH_NO_SEPARATOR, wxPATH_DOS) );
 578 }
 579
 580 void FileNameTestCase::TestVolumeUniqueName()
 581 {
 582     wxFileName fn("\\\\?\\Volume{8089d7d7-d0ac-11db-9dd0-806d6172696f}\\",
 583                   wxPATH_DOS);
 584     CPPUNIT_ASSERT_EQUAL( "Volume{8089d7d7-d0ac-11db-9dd0-806d6172696f}",
 585                           fn.GetVolume() );
 586     CPPUNIT_ASSERT_EQUAL( "\\", fn.GetPath(wxPATH_NO_SEPARATOR, wxPATH_DOS) );
 587     CPPUNIT_ASSERT_EQUAL( "\\\\?\\Volume{8089d7d7-d0ac-11db-9dd0-806d6172696f}\\",
 588                           fn.GetFullPath(wxPATH_DOS) );
 589
 590     fn.Assign("\\\\?\\Volume{8089d7d7-d0ac-11db-9dd0-806d6172696f}\\"
 591               "Program Files\\setup.exe", wxPATH_DOS);
 592     CPPUNIT_ASSERT_EQUAL( "Volume{8089d7d7-d0ac-11db-9dd0-806d6172696f}",
 593                           fn.GetVolume() );
 594     CPPUNIT_ASSERT_EQUAL( "\\Program Files",
 595                           fn.GetPath(wxPATH_NO_SEPARATOR, wxPATH_DOS) );
 596     CPPUNIT_ASSERT_EQUAL( "\\\\?\\Volume{8089d7d7-d0ac-11db-9dd0-806d6172696f}\\"
 597                           "Program Files\\setup.exe",
 598                           fn.GetFullPath(wxPATH_DOS) );
 599 }
 600
 601 void FileNameTestCase::TestCreateTempFileName()
 602 {
 603     static const struct TestData
 604     {
 605         const char *prefix;
 606         const char *expectedFolder;
 607         bool shouldSucceed;
 608     } testData[] =
 609     {
 610         { "", "$SYSTEM_TEMP", true },
 611         { "foo", "$SYSTEM_TEMP", true },
 612         { "..", "$SYSTEM_TEMP", true },
 613         { "../bar", "..", true },
 614 #ifdef __WINDOWS__
 615         { "$USER_DOCS_DIR\\", "$USER_DOCS_DIR", true },
 616         { "c:\\a\\directory\\which\\does\\not\\exist", "", false },
 617 #elif defined( __UNIX__ )
 618         { "$USER_DOCS_DIR/", "$USER_DOCS_DIR", true },
 619         { "/tmp/foo", "/tmp", true },
 620         { "/tmp/a/directory/which/does/not/exist", "", false },
 621 #endif // __UNIX__
 622     };
 623
 624     for ( size_t n = 0; n < WXSIZEOF(testData); n++ )
 625     {
 626         wxString prefix = testData[n].prefix;
 627         prefix.Replace("$USER_DOCS_DIR", wxStandardPaths::Get().GetDocumentsDir());
 628
 629         std::string errDesc = wxString::Format("failed on prefix '%s'", prefix).ToStdString();
 630
 631         wxString path = wxFileName::CreateTempFileName(prefix);
 632         CPPUNIT_ASSERT_EQUAL_MESSAGE( errDesc, !testData[n].shouldSucceed, path.empty() );
 633
 634         if (testData[n].shouldSucceed)
 635         {
 636             errDesc += "; path is " + path.ToStdString();
 637
 638             // test the place where the temp file has been created
 639             wxString expected = testData[n].expectedFolder;
 640             expected.Replace("$SYSTEM_TEMP", wxStandardPaths::Get().GetTempDir());
 641             expected.Replace("$USER_DOCS_DIR", wxStandardPaths::Get().GetDocumentsDir());
 642             CPPUNIT_ASSERT_EQUAL_MESSAGE( errDesc, expected, wxFileName(path).GetPath() );
 643
 644             // the temporary file is created with full permissions for the current process
 645             // so we should always be able to remove it:
 646             CPPUNIT_ASSERT_MESSAGE( errDesc, wxRemoveFile(path) );
 647         }
 648     }
 649 }
 650
 651 void FileNameTestCase::TestGetTimes()
 652 {
 653     wxFileName fn(wxFileName::CreateTempFileName("filenametest"));
 654     CPPUNIT_ASSERT( fn.IsOk() );
 655     wxON_BLOCK_EXIT1( wxRemoveFile, fn.GetFullPath() );
 656
 657     wxDateTime dtAccess, dtMod, dtCreate;
 658     CPPUNIT_ASSERT( fn.GetTimes(&dtAccess, &dtMod, &dtCreate) );
 659
 660     // make sure all retrieved dates are equal to the current date&time
 661     // with an accuracy up to 1 minute
 662     CPPUNIT_ASSERT(dtCreate.IsEqualUpTo(wxDateTime::Now(), wxTimeSpan(0,1)));
 663     CPPUNIT_ASSERT(dtMod.IsEqualUpTo(wxDateTime::Now(), wxTimeSpan(0,1)));
 664     CPPUNIT_ASSERT(dtAccess.IsEqualUpTo(wxDateTime::Now(), wxTimeSpan(0,1)));
 665 }
 666
 667 void FileNameTestCase::TestExists()
 668 {
 669     wxFileName fn(wxFileName::CreateTempFileName("filenametest"));
 670     CPPUNIT_ASSERT( fn.IsOk() );
 671     wxON_BLOCK_EXIT1( wxRemoveFile, fn.GetFullPath() );
 672
 673     CPPUNIT_ASSERT( fn.FileExists() );
 674     CPPUNIT_ASSERT( !wxFileName::DirExists(fn.GetFullPath()) );
 675
 676     CPPUNIT_ASSERT( fn.Exists(wxFILE_EXISTS_REGULAR) );
 677     CPPUNIT_ASSERT( !fn.Exists(wxFILE_EXISTS_DIR) );
 678     CPPUNIT_ASSERT( fn.Exists() );
 679
 680     const wxString& tempdir = wxFileName::GetTempDir();
 681
 682     wxFileName fileInTempDir(tempdir, "bloordyblop");
 683     CPPUNIT_ASSERT( !fileInTempDir.Exists() );
 684     CPPUNIT_ASSERT( fileInTempDir.DirExists() );
 685
 686     wxFileName dirTemp(wxFileName::DirName(tempdir));
 687     CPPUNIT_ASSERT( !dirTemp.FileExists() );
 688     CPPUNIT_ASSERT( dirTemp.DirExists() );
 689
 690     CPPUNIT_ASSERT( dirTemp.Exists(wxFILE_EXISTS_DIR) );
 691     CPPUNIT_ASSERT( !dirTemp.Exists(wxFILE_EXISTS_REGULAR) );
 692     CPPUNIT_ASSERT( dirTemp.Exists() );
 693
 694 #ifdef __UNIX__
 695     CPPUNIT_ASSERT( !wxFileName::FileExists("/dev/null") );
 696     CPPUNIT_ASSERT( !wxFileName::DirExists("/dev/null") );
 697     CPPUNIT_ASSERT( wxFileName::Exists("/dev/null") );
 698     CPPUNIT_ASSERT( wxFileName::Exists("/dev/null", wxFILE_EXISTS_DEVICE) );
 699 #ifdef __LINUX__
 700     // These files are only guaranteed to exist under Linux.
 701     // No need for wxFILE_EXISTS_NO_FOLLOW here; wxFILE_EXISTS_SYMLINK implies it
 702     CPPUNIT_ASSERT( wxFileName::Exists("/dev/core", wxFILE_EXISTS_SYMLINK) );
 703     CPPUNIT_ASSERT( wxFileName::Exists("/dev/log", wxFILE_EXISTS_SOCKET) );
 704 #endif // __LINUX__
 705 #ifndef __VMS
 706     wxString fifo = dirTemp.GetPath() + "/fifo";
 707    if (mkfifo(fifo.c_str(), 0600) == 0)
 708     {
 709         wxON_BLOCK_EXIT1(wxRemoveFile, fifo);
 710
 711         CPPUNIT_ASSERT( wxFileName::Exists(fifo, wxFILE_EXISTS_FIFO) );
 712     }
 713 #endif
 714 #endif // __UNIX__
 715 }
 716
 717 void FileNameTestCase::TestIsSame()
 718 {
 719     wxFileName fn1( wxFileName::CreateTempFileName( "filenametest1" ) );
 720     CPPUNIT_ASSERT( fn1.IsOk() );
 721     wxON_BLOCK_EXIT1( wxRemoveFile, fn1.GetFullPath() );
 722
 723     wxFileName fn2( wxFileName::CreateTempFileName( "filenametest2" ) );
 724     CPPUNIT_ASSERT( fn2.IsOk() );
 725     wxON_BLOCK_EXIT1( wxRemoveFile, fn2.GetFullPath() );
 726
 727     CPPUNIT_ASSERT( fn1.SameAs( fn1 ) );
 728     CPPUNIT_ASSERT( !fn1.SameAs( fn2 ) );
 729
 730 #if defined(__UNIX__)
 731     // We need to create a temporary directory and a temporary link.
 732     // Unfortunately we can't use wxFileName::CreateTempFileName() for neither
 733     // as it creates plain files, so use tempnam() explicitly instead.
 734     char* tn = tempnam(NULL, "wxfn1");
 735     const wxString tempdir1 = wxString::From8BitData(tn);
 736     free(tn);
 737
 738     CPPUNIT_ASSERT( wxFileName::Mkdir(tempdir1) );
 739     // Unfortunately the casts are needed to select the overload we need here.
 740     wxON_BLOCK_EXIT2( static_cast<bool (*)(const wxString&, int)>(wxFileName::Rmdir),
 741                       tempdir1, static_cast<int>(wxPATH_RMDIR_RECURSIVE) );
 742
 743     tn = tempnam(NULL, "wxfn2");
 744     const wxString tempdir2 = wxString::From8BitData(tn);
 745     free(tn);
 746     CPPUNIT_ASSERT_EQUAL( 0, symlink(tempdir1.c_str(), tempdir2.c_str()) );
 747     wxON_BLOCK_EXIT1( wxRemoveFile, tempdir2 );
 748
 749
 750     wxFileName fn3(tempdir1, "foo");
 751     wxFileName fn4(tempdir2, "foo");
 752
 753     // These files have different paths, hence are different.
 754     CPPUNIT_ASSERT( !fn3.SameAs(fn4) );
 755
 756     // Create and close a file to trigger creating it.
 757     wxFile(fn3.GetFullPath(), wxFile::write);
 758
 759     // Now that both files do exist we should be able to detect that they are
 760     // actually the same file.
 761     CPPUNIT_ASSERT( fn3.SameAs(fn4) );
 762 #endif // __UNIX__
 763 }
 764
 765 #if defined(__UNIX__)
 766
 767 // Tests for functions that are changed by ShouldFollowLink()
 768 void FileNameTestCase::TestSymlinks()
 769 {
 770     const wxString tmpdir(wxStandardPaths::Get().GetTempDir());
 771
 772     wxFileName tmpfn(wxFileName::DirName(tmpdir));
 773
 774     wxDateTime dtAccessTmp, dtModTmp, dtCreateTmp;
 775     CPPUNIT_ASSERT(tmpfn.GetTimes(&dtAccessTmp, &dtModTmp, &dtCreateTmp));
 776
 777     // Create a temporary directory
 778 #ifdef __VMS
 779     wxString name = tmpdir + ".filenametestXXXXXX]";
 780     mkdir( name.char_str() , 0222 );
 781     wxString tempdir = name;
 782 #else
 783     wxString name = tmpdir + "/filenametestXXXXXX";
 784     wxString tempdir = wxString::From8BitData(mkdtemp(name.char_str()));
 785     tempdir << wxFileName::GetPathSeparator();
 786 #endif
 787     wxFileName tempdirfn(wxFileName::DirName(tempdir));
 788     CPPUNIT_ASSERT(tempdirfn.DirExists());
 789
 790     // Create a regular file in that dir, to act as a symlink target
 791     wxFileName targetfn(wxFileName::CreateTempFileName(tempdir));
 792     CPPUNIT_ASSERT(targetfn.FileExists());
 793
 794     // Create a symlink to that file
 795     wxFileName linktofile(tempdir, "linktofile");
 796     CPPUNIT_ASSERT_EQUAL(0, symlink(targetfn.GetFullPath().c_str(),
 797                                         linktofile.GetFullPath().c_str()));
 798
 799     // ... and another to the temporary directory
 800     const wxString linktodirName(tempdir + "/linktodir");
 801     wxFileName linktodir(wxFileName::DirName(linktodirName));
 802     CPPUNIT_ASSERT_EQUAL(0, symlink(tmpfn.GetFullPath().c_str(),
 803                                         linktodirName.c_str()));
 804
 805     // And symlinks to both of those symlinks
 806     wxFileName linktofilelnk(tempdir, "linktofilelnk");
 807     CPPUNIT_ASSERT_EQUAL(0, symlink(linktofile.GetFullPath().c_str(),
 808                                     linktofilelnk.GetFullPath().c_str()));
 809     wxFileName linktodirlnk(tempdir, "linktodirlnk");
 810     CPPUNIT_ASSERT_EQUAL(0, symlink(linktodir.GetFullPath().c_str(),
 811                                     linktodirlnk.GetFullPath().c_str()));
 812
 813     // Run the tests twice: once in the default symlink following mode and the
 814     // second time without following symlinks.
 815     bool deref = true;
 816     for ( int n = 0; n < 2; ++n, deref = !deref )
 817     {
 818         const std::string msg(deref ? " failed for the link target"
 819                                     : " failed for the path itself");
 820
 821         if ( !deref )
 822         {
 823             linktofile.DontFollowLink();
 824             linktodir.DontFollowLink();
 825             linktofilelnk.DontFollowLink();
 826             linktodirlnk.DontFollowLink();
 827         }
 828
 829         // Test SameAs()
 830         CPPUNIT_ASSERT_EQUAL_MESSAGE
 831         (
 832             "Comparison with file" + msg,
 833             deref, linktofile.SameAs(targetfn)
 834         );
 835
 836         CPPUNIT_ASSERT_EQUAL_MESSAGE
 837         (
 838             "Comparison with directory" + msg,
 839             deref, linktodir.SameAs(tmpfn)
 840         );
 841
 842         // A link-to-a-link should dereference through to the final target
 843         CPPUNIT_ASSERT_EQUAL_MESSAGE
 844         (
 845             "Comparison with link to a file" + msg,
 846             deref,
 847             linktofilelnk.SameAs(targetfn)
 848         );
 849         CPPUNIT_ASSERT_EQUAL_MESSAGE
 850         (
 851             "Comparison with link to a directory" + msg,
 852             deref,
 853             linktodirlnk.SameAs(tmpfn)
 854         );
 855
 856         // Test GetTimes()
 857         wxDateTime dtAccess, dtMod, dtCreate;
 858         CPPUNIT_ASSERT_MESSAGE
 859         (
 860             "Getting times of a directory" + msg,
 861             linktodir.GetTimes(&dtAccess, &dtMod, &dtCreate)
 862         );
 863
 864         // IsEqualTo() should be true only when dereferencing. Don't test each
 865         // individually: accessing to create the link will have updated some
 866         bool equal = dtCreate.IsEqualTo(dtCreateTmp) &&
 867                      dtMod.IsEqualTo(dtModTmp) &&
 868                      dtAccess.IsEqualTo(dtAccessTmp);
 869         CPPUNIT_ASSERT_EQUAL_MESSAGE
 870         (
 871             "Comparing directory times" + msg,
 872             deref,
 873             equal
 874         );
 875
 876         // Test (File|Dir)Exists()
 877         CPPUNIT_ASSERT_EQUAL_MESSAGE
 878         (
 879             "Testing file existence" + msg,
 880             deref,
 881             linktofile.FileExists()
 882         );
 883         CPPUNIT_ASSERT_EQUAL_MESSAGE
 884         (
 885             "Testing directory existence" + msg,
 886             deref,
 887             linktodir.DirExists()
 888         );
 889
 890         // Test wxFileName::Exists
 891         // The wxFILE_EXISTS_NO_FOLLOW flag should override DontFollowLink()
 892         CPPUNIT_ASSERT_EQUAL_MESSAGE
 893         (
 894             "Testing file existence" + msg,
 895             false,
 896             linktofile.Exists(wxFILE_EXISTS_REGULAR | wxFILE_EXISTS_NO_FOLLOW)
 897         );
 898         CPPUNIT_ASSERT_EQUAL_MESSAGE
 899         (
 900             "Testing directory existence" + msg,
 901             false,
 902             linktodir.Exists(wxFILE_EXISTS_DIR | wxFILE_EXISTS_NO_FOLLOW)
 903         );
 904         // and the static versions
 905         CPPUNIT_ASSERT_EQUAL_MESSAGE
 906         (
 907             "Testing file existence" + msg,
 908             false,
 909             wxFileName::Exists(linktofile.GetFullPath(), wxFILE_EXISTS_REGULAR | wxFILE_EXISTS_NO_FOLLOW)
 910         );
 911         CPPUNIT_ASSERT_EQUAL_MESSAGE
 912         (
 913             "Testing file existence" + msg,
 914             true,
 915             wxFileName::Exists(linktofile.GetFullPath(), wxFILE_EXISTS_REGULAR)
 916         );
 917         CPPUNIT_ASSERT_EQUAL_MESSAGE
 918         (
 919             "Testing directory existence" + msg,
 920             false,
 921             wxFileName::Exists(linktodir.GetFullPath(), wxFILE_EXISTS_DIR | wxFILE_EXISTS_NO_FOLLOW)
 922         );
 923         CPPUNIT_ASSERT_EQUAL_MESSAGE
 924         (
 925             "Testing directory existence" + msg,
 926             true,
 927             wxFileName::Exists(linktodir.GetFullPath(), wxFILE_EXISTS_DIR)
 928         );
 929     }
 930
 931     // Finally test Exists() after removing the file.
 932     CPPUNIT_ASSERT(wxRemoveFile(targetfn.GetFullPath()));
 933     // This should succeed, as the symlink still exists and
 934     // the default wxFILE_EXISTS_ANY implies wxFILE_EXISTS_NO_FOLLOW
 935     CPPUNIT_ASSERT(wxFileName(tempdir, "linktofile").Exists());
 936     // So should this one, as wxFILE_EXISTS_SYMLINK does too
 937     CPPUNIT_ASSERT(wxFileName(tempdir, "linktofile").
 938                                             Exists(wxFILE_EXISTS_SYMLINK));
 939     // but not this one, as the now broken symlink is followed
 940     CPPUNIT_ASSERT(!wxFileName(tempdir, "linktofile").
 941                                             Exists(wxFILE_EXISTS_REGULAR));
 942     CPPUNIT_ASSERT(linktofile.Exists());
 943
 944     // This is also a convenient place to test Rmdir() as we have things to
 945     // remove.
 946
 947     // First, check that removing a symlink to a directory fails.
 948     CPPUNIT_ASSERT( !wxFileName::Rmdir(linktodirName) );
 949
 950     // And recursively removing it only removes the symlink itself, not the
 951     // directory.
 952     CPPUNIT_ASSERT( wxFileName::Rmdir(linktodirName, wxPATH_RMDIR_RECURSIVE) );
 953     CPPUNIT_ASSERT( tmpfn.Exists() );
 954
 955     // Finally removing the directory itself does remove everything.
 956     CPPUNIT_ASSERT(tempdirfn.Rmdir(wxPATH_RMDIR_RECURSIVE));
 957     CPPUNIT_ASSERT( !tempdirfn.Exists() );
 958 }
 959
 960 #endif // __UNIX__