X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/c7099635d100da76c381a5f1ef9bdbb975be32dc..de830910772f149c6b6cc0878b239dd19df3d309:/tests/filename/filenametest.cpp

diff --git a/tests/filename/filenametest.cpp b/tests/filename/filenametest.cpp
index d51c40dbef..711233d85d 100644
--- a/tests/filename/filenametest.cpp
+++ b/tests/filename/filenametest.cpp
@@ -24,6 +24,10 @@
 #include "wx/filename.h"
 #include "wx/filefn.h"
 
+#ifdef __WXMSW__
+    #include "wx/msw/registry.h"
+#endif // __WXMSW__
+
 // ----------------------------------------------------------------------------
 // local functions
 // ----------------------------------------------------------------------------
@@ -38,7 +42,7 @@ inline std::ostream& operator<<(std::ostream& o, const wxFileName& fn)
 // test data
 // ----------------------------------------------------------------------------
 
-static struct FileNameInfo
+static struct TestFileNameInfo
 {
     const wxChar *fullname;
     const wxChar *volume;
@@ -72,11 +76,13 @@ static struct FileNameInfo
     { _T("c:\\foo.bar"), _T("c"), _T("\\"), _T("foo"), _T("bar"), true, wxPATH_DOS },
     { _T("c:\\Windows\\command.com"), _T("c"), _T("\\Windows"), _T("command"), _T("com"), true, wxPATH_DOS },
 
+#if 0
     // NB: when using the wxFileName::GetLongPath() function on these two
     //     strings, the program will hang for several seconds blocking inside
     //     Win32 GetLongPathName() function
     { _T("\\\\server\\foo.bar"), _T("server"), _T("\\"), _T("foo"), _T("bar"), true, wxPATH_DOS },
     { _T("\\\\server\\dir\\foo.bar"), _T("server"), _T("\\dir"), _T("foo"), _T("bar"), true, wxPATH_DOS },
+#endif
 
     // consecutive [back]slashes should be treated as single occurrences of
     // them and not interpreted as share names if there is a volume name
@@ -94,10 +100,12 @@ static struct FileNameInfo
     { _T("File.Ext"), _T(""), _T(""), _T("File"), _T(".Ext"), false, wxPATH_MAC },
 #endif // 0
 
+#if 0
     // VMS file names
     // NB: on Windows they have the same effect of the \\server\\ strings
     //     (see the note above)
     { _T("device:[dir1.dir2.dir3]file.txt"), _T("device"), _T("dir1.dir2.dir3"), _T("file"), _T("txt"), true, wxPATH_VMS },
+#endif
     { _T("file.txt"), _T(""), _T(""), _T("file"), _T("txt"), false, wxPATH_VMS },
 };
 
@@ -118,6 +126,7 @@ private:
         CPPUNIT_TEST( TestSetPath );
         CPPUNIT_TEST( TestStrip );
         CPPUNIT_TEST( TestNormalize );
+        CPPUNIT_TEST( TestReplace );
 #ifdef __WINDOWS__
         CPPUNIT_TEST( TestShortLongPath );
 #endif // __WINDOWS__
@@ -129,6 +138,7 @@ private:
     void TestSetPath();
     void TestStrip();
     void TestNormalize();
+    void TestReplace();
 #ifdef __WINDOWS__
     void TestShortLongPath();
 #endif // __WINDOWS__
@@ -146,7 +156,7 @@ void FileNameTestCase::TestConstruction()
 {
     for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
     {
-        const FileNameInfo& fni = filenames[n];
+        const TestFileNameInfo& fni = filenames[n];
 
         wxFileName fn(fni.fullname, fni.format);
 
@@ -238,7 +248,7 @@ void FileNameTestCase::TestSplit()
 {
     for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
     {
-        const FileNameInfo& fni = filenames[n];
+        const TestFileNameInfo& fni = filenames[n];
         wxString volume, path, name, ext;
         wxFileName::SplitPath(fni.fullname,
                               &volume, &path, &name, &ext, fni.format);
@@ -288,9 +298,9 @@ void FileNameTestCase::TestNormalize()
 
     static const struct FileNameTest
     {
-        wxString original;
+        const char *original;
         int flags;
-        wxString expected;
+        const char *expected;
         wxPathFormat fmt;
     } tests[] =
     {
@@ -307,8 +317,8 @@ void FileNameTestCase::TestNormalize()
         // test wxPATH_NORM_TILDE
         // NB: do the tilde expansion also under Windows to test if it works there too
         { "/a/b/~", wxPATH_NORM_TILDE, "/a/b/~", wxPATH_UNIX },
-        { "/~/a/b", wxPATH_NORM_TILDE, home + "a/b", wxPATH_UNIX },
-        { "~/a/b", wxPATH_NORM_TILDE, home + "a/b", wxPATH_UNIX },
+        { "/~/a/b", wxPATH_NORM_TILDE, "HOME/a/b", wxPATH_UNIX },
+        { "~/a/b", wxPATH_NORM_TILDE, "HOME/a/b", wxPATH_UNIX },
 
         // test wxPATH_NORM_CASE
         { "Foo", wxPATH_NORM_CASE, "Foo", wxPATH_UNIX },
@@ -317,16 +327,28 @@ void FileNameTestCase::TestNormalize()
           "c:\\program files\\wx", wxPATH_DOS },
         { "C:/Program Files/wx", wxPATH_NORM_ALL | wxPATH_NORM_CASE,
           "c:\\program files\\wx", wxPATH_DOS },
+        { "C:\\Users\\zeitlin", wxPATH_NORM_ALL | wxPATH_NORM_CASE,
+          "c:\\users\\zeitlin", wxPATH_DOS },
 
         // test wxPATH_NORM_ABSOLUTE
-        { "a/b/", wxPATH_NORM_ABSOLUTE, cwd + "a/b/", wxPATH_UNIX },
-        { "a/b/c.ext", wxPATH_NORM_ABSOLUTE, cwd + "a/b/c.ext", wxPATH_UNIX },
+        { "a/b/", wxPATH_NORM_ABSOLUTE, "CWD/a/b/", wxPATH_UNIX },
+        { "a/b/c.ext", wxPATH_NORM_ABSOLUTE, "CWD/a/b/c.ext", wxPATH_UNIX },
         { "/a", wxPATH_NORM_ABSOLUTE, "/a", wxPATH_UNIX },
 
         // test giving no flags at all to Normalize()
         { "a/b/", 0, "a/b/", wxPATH_UNIX },
         { "a/b/c.ext", 0, "a/b/c.ext", wxPATH_UNIX },
-        { "/a", 0, "/a", wxPATH_UNIX }
+        { "/a", 0, "/a", wxPATH_UNIX },
+
+        // test handling dots without wxPATH_NORM_DOTS and wxPATH_NORM_ABSOLUTE
+        // for both existing and non-existent files (this is important under
+        // MSW where GetLongPathName() works only for the former)
+        { "./foo", wxPATH_NORM_LONG, "./foo", wxPATH_UNIX },
+        { "../foo", wxPATH_NORM_LONG, "../foo", wxPATH_UNIX },
+        { ".\\test.bkl", wxPATH_NORM_LONG, ".\\test.bkl", wxPATH_DOS },
+        { ".\\foo", wxPATH_NORM_LONG, ".\\foo", wxPATH_DOS },
+        { "..\\Makefile.in", wxPATH_NORM_LONG, "..\\Makefile.in", wxPATH_DOS },
+        { "..\\foo", wxPATH_NORM_LONG, "..\\foo", wxPATH_DOS },
     };
 
     // set the env var ABCDEF
@@ -338,33 +360,128 @@ void FileNameTestCase::TestNormalize()
         wxFileName fn(fnt.original, fnt.fmt);
 
         // be sure this normalization does not fail
-        CPPUNIT_ASSERT_MESSAGE
+        WX_ASSERT_MESSAGE
         (
-            (const char *)wxString::Format(_T("Normalize(%s) failed"), fnt.original).mb_str(),
+            ("#%d: Normalize(%s) failed", (int)i, fnt.original),
             fn.Normalize(fnt.flags, cwd, fnt.fmt)
         );
 
         // compare result with expected string
-        WX_ASSERT_STR_EQUAL( fnt.expected, fn.GetFullPath(fnt.fmt) );
+        wxString expected(tests[i].expected);
+        expected.Replace(_T("HOME/"), home);
+        expected.Replace(_T("CWD/"), cwd);
+        WX_ASSERT_EQUAL_MESSAGE
+        (
+            ("array element #%d", (int)i),
+            expected, fn.GetFullPath(fnt.fmt)
+        );
     }
+
+    // MSW-only test for wxPATH_NORM_LONG: notice that we only run it if short
+    // names generation is not disabled for this system as otherwise the file
+    // MKINST~1 doesn't exist at all and normalizing it fails (it's possible
+    // that we're on a FAT partition in which case the test would still succeed
+    // and also that the registry key was changed recently and didn't take
+    // effect yet but these are marginal cases which we consciously choose to
+    // ignore for now)
+#ifdef __WXMSW__
+    long shortNamesDisabled;
+    if ( wxRegKey
+         (
+            wxRegKey::HKLM,
+            "SYSTEM\\CurrentControlSet\\Control\\FileSystem"
+         ).QueryValue("NtfsDisable8dot3NameCreation", &shortNamesDisabled) &&
+            !shortNamesDisabled )
+    {
+        wxFileName fn("..\\MKINST~1");
+        CPPUNIT_ASSERT( fn.Normalize(wxPATH_NORM_LONG, cwd) );
+        CPPUNIT_ASSERT_EQUAL( "..\\mkinstalldirs", fn.GetFullPath() );
+    }
+    //else: when in doubt, don't run the test
+#endif // __WXMSW__
 }
 
-wxString wxTestStripExtension(wxString szFile)
+void FileNameTestCase::TestReplace()
 {
-    wxStripExtension(szFile);
-    return szFile;
+    static const struct FileNameTest
+    {
+        const char *original;
+        const char *env_contents;
+        const char *replace_fmtstring;
+        const char *expected;
+        wxPathFormat fmt;
+    } tests[] =
+    {
+        { "/usr/a/strange path/lib/someFile.ext", "/usr/a/strange path", "$%s", "$TEST_VAR/lib/someFile.ext", wxPATH_UNIX },
+        { "/usr/a/path/lib/someFile.ext", "/usr/a/path", "$%s", "$TEST_VAR/lib/someFile.ext", wxPATH_UNIX },
+        { "/usr/a/path/lib/someFile", "/usr/a/path/", "$%s", "$TEST_VARlib/someFile", wxPATH_UNIX },
+        { "/usr/a/path/lib/", "/usr/a/path/", "$(%s)", "$(TEST_VAR)lib/", wxPATH_UNIX },
+        { "/usr/a/path/lib/", "/usr/a/path/", "${{%s}}", "${{TEST_VAR}}lib/", wxPATH_UNIX },
+        { "/usr/a/path/lib/", "/usr/a/path/", "%s", "TEST_VARlib/", wxPATH_UNIX },
+        { "/usr/a/path/lib/", "/usr/a/path/", "%s//", "TEST_VAR/lib/", wxPATH_UNIX },
+            // note: empty directory components are automatically removed by wxFileName thus
+            //       using // in the replace format string has no effect
+
+        { "/usr/../a/path/lib/", "/usr/a/path/", "%s", "/usr/../a/path/lib/", wxPATH_UNIX },
+        { "/usr/a/path/usr/usr", "/usr", "%s", "TEST_VAR/a/pathTEST_VAR/usr", wxPATH_UNIX },
+        { "/usr/a/path/usr/usr", "/usr", "$%s", "$TEST_VAR/a/path$TEST_VAR/usr", wxPATH_UNIX },
+        { "/a/b/c/d", "a/", "%s", "/TEST_VARb/c/d", wxPATH_UNIX },
+
+        { "C:\\A\\Strange Path\\lib\\someFile", "C:\\A\\Strange Path", "%%%s%%", "%TEST_VAR%\\lib\\someFile", wxPATH_WIN },
+        { "C:\\A\\Path\\lib\\someFile", "C:\\A\\Path", "%%%s%%", "%TEST_VAR%\\lib\\someFile", wxPATH_WIN },
+        { "C:\\A\\Path\\lib\\someFile", "C:\\A\\Path", "$(%s)", "$(TEST_VAR)\\lib\\someFile", wxPATH_WIN }
+    };
+
+    for ( size_t i = 0; i < WXSIZEOF(tests); i++ )
+    {
+        const FileNameTest& fnt = tests[i];
+        wxFileName fn(fnt.original, fnt.fmt);
+
+        // set the environment variable
+        wxSetEnv(_T("TEST_VAR"), fnt.env_contents);
+
+        // be sure this ReplaceEnvVariable does not fail
+        WX_ASSERT_MESSAGE
+        (
+            ("#%d: ReplaceEnvVariable(%s) failed", (int)i, fnt.replace_fmtstring),
+            fn.ReplaceEnvVariable("TEST_VAR", fnt.replace_fmtstring, fnt.fmt)
+        );
+
+        // compare result with expected string
+        wxString expected(fnt.expected);
+        WX_ASSERT_EQUAL_MESSAGE
+        (
+            ("array element #%d", (int)i),
+            expected, fn.GetFullPath(fnt.fmt)
+        );
+    }
+
+    // now test ReplaceHomeDir
+
+    wxFileName fn = wxFileName::DirName(wxGetHomeDir());
+    fn.AppendDir("test1");
+    fn.AppendDir("test2");
+    fn.AppendDir("test3");
+    fn.SetName("some file");
+
+    WX_ASSERT_MESSAGE
+    (
+        ("ReplaceHomeDir(%s) failed", fn.GetFullPath()),
+        fn.ReplaceHomeDir()
+    );
+
+    CPPUNIT_ASSERT_EQUAL( wxString(_T("~/test1/test2/test3/some file")),
+                          fn.GetFullPath(wxPATH_UNIX) );
 }
 
 void FileNameTestCase::TestStrip()
 {
-    //test a crash
-    CPPUNIT_ASSERT_EQUAL( wxString(_T("")), wxTestStripExtension(_T("")) );
-
-    //others
-    CPPUNIT_ASSERT_EQUAL( wxString(_T("")), wxTestStripExtension(_T(".")) );
-    CPPUNIT_ASSERT_EQUAL( wxString(_T("")), wxTestStripExtension(_T(".wav")) );
-    CPPUNIT_ASSERT_EQUAL( wxString(_T("good")), wxTestStripExtension(_T("good.wav")) );
-    CPPUNIT_ASSERT_EQUAL( wxString(_T("good.wav")), wxTestStripExtension(_T("good.wav.wav")) );
+    CPPUNIT_ASSERT_EQUAL( "", wxFileName::StripExtension(_T("")) );
+    CPPUNIT_ASSERT_EQUAL( ".", wxFileName::StripExtension(_T(".")) );
+    CPPUNIT_ASSERT_EQUAL( ".vimrc", wxFileName::StripExtension(_T(".vimrc")) );
+    CPPUNIT_ASSERT_EQUAL( "bad", wxFileName::StripExtension(_T("bad")) );
+    CPPUNIT_ASSERT_EQUAL( "good", wxFileName::StripExtension(_T("good.wav")) );
+    CPPUNIT_ASSERT_EQUAL( "good.wav", wxFileName::StripExtension(_T("good.wav.wav")) );
 }
 
 #ifdef __WINDOWS__