]> git.saurik.com Git - wxWidgets.git/blobdiff - tests/filename/filenametest.cpp
extact common GAddress declarations to the common header instead of duplicating them...
[wxWidgets.git] / tests / filename / filenametest.cpp
index f91ab53ee4414cdbc56cce2944bc86d35a70887c..770ca8ac69af748637fabc45edc6d80e412e4e95 100644 (file)
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 
-#include "wx/wxprec.h"
+#include "testprec.h"
 
 #ifdef __BORLANDC__
     #pragma hdrstop
 #endif
 
 #ifndef WX_PRECOMP
 
 #ifdef __BORLANDC__
     #pragma hdrstop
 #endif
 
 #ifndef WX_PRECOMP
+    #include "wx/utils.h"
 #endif // WX_PRECOMP
 
 #include "wx/filename.h"
 #endif // WX_PRECOMP
 
 #include "wx/filename.h"
+#include "wx/filefn.h"
 
 
-#include "wx/cppunit.h"
+// ----------------------------------------------------------------------------
+// local functions
+// ----------------------------------------------------------------------------
+
+// define stream inserter for wxFileName to use it in CPPUNIT_ASSERT_EQUAL()
+inline std::ostream& operator<<(std::ostream& o, const wxFileName& fn)
+{
+    return o << fn.GetFullPath();
+}
 
 // ----------------------------------------------------------------------------
 // test data
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 // test data
 // ----------------------------------------------------------------------------
 
-static struct FileNameInfo
+static struct TestFileNameInfo
 {
     const wxChar *fullname;
     const wxChar *volume;
 {
     const wxChar *fullname;
     const wxChar *volume;
@@ -39,6 +49,11 @@ static struct FileNameInfo
     wxPathFormat format;
 } filenames[] =
 {
     wxPathFormat format;
 } filenames[] =
 {
+    // the empty string
+    { _T(""), _T(""), _T(""), _T(""), _T(""), false, wxPATH_UNIX },
+    { _T(""), _T(""), _T(""), _T(""), _T(""), false, wxPATH_DOS },
+    { _T(""), _T(""), _T(""), _T(""), _T(""), false, wxPATH_VMS },
+
     // Unix file names
     { _T("/usr/bin/ls"), _T(""), _T("/usr/bin"), _T("ls"), _T(""), true, wxPATH_UNIX },
     { _T("/usr/bin/"), _T(""), _T("/usr/bin"), _T(""), _T(""), true, wxPATH_UNIX },
     // Unix file names
     { _T("/usr/bin/ls"), _T(""), _T("/usr/bin"), _T("ls"), _T(""), true, wxPATH_UNIX },
     { _T("/usr/bin/"), _T(""), _T("/usr/bin"), _T(""), _T(""), true, wxPATH_UNIX },
@@ -56,9 +71,18 @@ static struct FileNameInfo
     { _T("c:foo.bar"), _T("c"), _T(""), _T("foo"), _T("bar"), false, wxPATH_DOS },
     { _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 },
     { _T("c:foo.bar"), _T("c"), _T(""), _T("foo"), _T("bar"), false, wxPATH_DOS },
     { _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 },
+
+    // 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 },
 
     { _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 },
 
+    // consecutive [back]slashes should be treated as single occurrences of
+    // them and not interpreted as share names if there is a volume name
+    { _T("c:\\aaa\\bbb\\ccc"), _T("c"), _T("\\aaa\\bbb"), _T("ccc"), _T(""), true, wxPATH_DOS },
+    { _T("c:\\\\aaa\\bbb\\ccc"), _T("c"), _T("\\\\aaa\\bbb"), _T("ccc"), _T(""), true, wxPATH_DOS },
+
     // wxFileName support for Mac file names is broken currently
 #if 0
     // Mac file names
     // wxFileName support for Mac file names is broken currently
 #if 0
     // Mac file names
@@ -71,6 +95,8 @@ static struct FileNameInfo
 #endif // 0
 
     // VMS file names
 #endif // 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 },
     { _T("file.txt"), _T(""), _T(""), _T("file"), _T("txt"), false, wxPATH_VMS },
 };
     { _T("device:[dir1.dir2.dir3]file.txt"), _T("device"), _T("dir1.dir2.dir3"), _T("file"), _T("txt"), true, wxPATH_VMS },
     { _T("file.txt"), _T(""), _T(""), _T("file"), _T("txt"), false, wxPATH_VMS },
 };
@@ -87,13 +113,25 @@ public:
 private:
     CPPUNIT_TEST_SUITE( FileNameTestCase );
         CPPUNIT_TEST( TestConstruction );
 private:
     CPPUNIT_TEST_SUITE( FileNameTestCase );
         CPPUNIT_TEST( TestConstruction );
+        CPPUNIT_TEST( TestComparison );
         CPPUNIT_TEST( TestSplit );
         CPPUNIT_TEST( TestSetPath );
         CPPUNIT_TEST( TestSplit );
         CPPUNIT_TEST( TestSetPath );
+        CPPUNIT_TEST( TestStrip );
+        CPPUNIT_TEST( TestNormalize );
+#ifdef __WINDOWS__
+        CPPUNIT_TEST( TestShortLongPath );
+#endif // __WINDOWS__
     CPPUNIT_TEST_SUITE_END();
 
     void TestConstruction();
     CPPUNIT_TEST_SUITE_END();
 
     void TestConstruction();
+    void TestComparison();
     void TestSplit();
     void TestSetPath();
     void TestSplit();
     void TestSetPath();
+    void TestStrip();
+    void TestNormalize();
+#ifdef __WINDOWS__
+    void TestShortLongPath();
+#endif // __WINDOWS__
 
     DECLARE_NO_COPY_CLASS(FileNameTestCase)
 };
 
     DECLARE_NO_COPY_CLASS(FileNameTestCase)
 };
@@ -108,31 +146,112 @@ void FileNameTestCase::TestConstruction()
 {
     for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
     {
 {
     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);
 
 
         wxFileName fn(fni.fullname, fni.format);
 
+        // the original full name could contain consecutive [back]slashes,
+        // squeeze them except for the double backslash in the beginning in
+        // Windows filenames where it has special meaning
+        wxString fullnameOrig;
+        if ( fni.format == wxPATH_DOS )
+        {
+            // copy the backslashes at beginning unchanged
+            const wxChar *p = fni.fullname;
+            while ( *p == _T('\\') )
+                fullnameOrig += *p++;
+
+            // replace consecutive slashes with single ones in the rest
+            for ( wxChar chPrev = _T('\0'); *p; p++ )
+            {
+                if ( *p == _T('\\') && chPrev == _T('\\') )
+                    continue;
+
+                chPrev = *p;
+                fullnameOrig += chPrev;
+            }
+        }
+        else // !wxPATH_DOS
+        {
+            fullnameOrig = fni.fullname;
+        }
+
+        fullnameOrig.Replace(_T("//"), _T("/"));
+
+
         wxString fullname = fn.GetFullPath(fni.format);
         wxString fullname = fn.GetFullPath(fni.format);
-        CPPUNIT_ASSERT( fullname == fni.fullname );
+        CPPUNIT_ASSERT_EQUAL( fullnameOrig, fullname );
+
+        // notice that we use a dummy working directory to ensure that paths
+        // with "../.." in them could be normalized, otherwise this would fail
+        // if the test is run from root directory or its direct subdirectory
+        CPPUNIT_ASSERT_MESSAGE
+        (
+            (const char *)wxString::Format(_T("Normalize(%s) failed"), fni.fullname).mb_str(),
+            fn.Normalize(wxPATH_NORM_ALL, _T("/foo/bar/baz"), fni.format)
+        );
+
+        if ( *fni.volume && *fni.path )
+        {
+            // check that specifying the volume separately or as part of the
+            // path doesn't make any difference
+            wxString pathWithVolume = fni.volume;
+            pathWithVolume += wxFileName::GetVolumeSeparator(fni.format);
+            pathWithVolume += fni.path;
 
 
-        CPPUNIT_ASSERT( fn.Normalize(wxPATH_NORM_ALL, _T(""), fni.format) );
+            CPPUNIT_ASSERT_EQUAL( wxFileName(pathWithVolume,
+                                             fni.name,
+                                             fni.ext,
+                                             fni.format), fn );
+        }
     }
     }
+
+    wxFileName fn;
+
+    // empty strings
+    fn.AssignDir(wxEmptyString);
+    CPPUNIT_ASSERT( !fn.IsOk() );
+
+    fn.Assign(wxEmptyString);
+    CPPUNIT_ASSERT( !fn.IsOk() );
+
+    fn.Assign(wxEmptyString, wxEmptyString);
+    CPPUNIT_ASSERT( !fn.IsOk() );
+
+    fn.Assign(wxEmptyString, wxEmptyString, wxEmptyString);
+    CPPUNIT_ASSERT( !fn.IsOk() );
+
+    fn.Assign(wxEmptyString, wxEmptyString, wxEmptyString, wxEmptyString);
+    CPPUNIT_ASSERT( !fn.IsOk() );
+}
+
+void FileNameTestCase::TestComparison()
+{
+    wxFileName fn1(wxT("/tmp/file1"));
+    wxFileName fn2(wxT("/tmp/dir2/../file2"));
+    fn1.Normalize();
+    fn2.Normalize();
+    CPPUNIT_ASSERT_EQUAL(fn1.GetPath(), fn2.GetPath());
 }
 
 void FileNameTestCase::TestSplit()
 {
     for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
     {
 }
 
 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);
 
         wxString volume, path, name, ext;
         wxFileName::SplitPath(fni.fullname,
                               &volume, &path, &name, &ext, fni.format);
 
-        CPPUNIT_ASSERT( volume == fni.volume );
-        CPPUNIT_ASSERT( path == fni.path );
-        CPPUNIT_ASSERT( name == fni.name );
-        CPPUNIT_ASSERT( ext == fni.ext );
+        CPPUNIT_ASSERT_EQUAL( wxString(fni.volume), volume );
+        CPPUNIT_ASSERT_EQUAL( wxString(fni.path), path );
+        CPPUNIT_ASSERT_EQUAL( wxString(fni.name), name );
+        CPPUNIT_ASSERT_EQUAL( wxString(fni.ext), ext );
     }
     }
+
+    // special case of empty extension
+    wxFileName fn(_T("foo."));
+    CPPUNIT_ASSERT_EQUAL( wxString(_T("foo.")), fn.GetFullPath() );
 }
 
 void FileNameTestCase::TestSetPath()
 }
 
 void FileNameTestCase::TestSetPath()
@@ -146,3 +265,120 @@ void FileNameTestCase::TestSetPath()
     CPPUNIT_ASSERT( fn.SameAs(wxFileName(_T("/usr/local/bin/ls"), wxPATH_UNIX)) );
 }
 
     CPPUNIT_ASSERT( fn.SameAs(wxFileName(_T("/usr/local/bin/ls"), wxPATH_UNIX)) );
 }
 
+void FileNameTestCase::TestNormalize()
+{
+    // prepare some data to be used later
+    wxString sep = wxFileName::GetPathSeparator();
+    wxString cwd = wxGetCwd();
+    wxString home = wxGetUserHome();
+
+    cwd.Replace(sep, wxT("/"));
+    if (cwd.Last() != wxT('/'))
+        cwd += wxT('/');
+    home.Replace(sep, wxT("/"));
+    if (home.Last() != wxT('/'))
+        home += wxT('/');
+
+    // since we will always be testing paths using the wxPATH_UNIX
+    // format, we need to remove the volume, if present
+    if (home.Contains(wxT(':')))
+        home = home.AfterFirst(wxT(':'));
+    if (cwd.Contains(wxT(':')))
+        cwd = cwd.AfterFirst(wxT(':'));
+
+    static const struct FileNameTest
+    {
+        wxString original;
+        int flags;
+        wxString expected;
+        wxPathFormat fmt;
+    } tests[] =
+    {
+        // test wxPATH_NORM_ENV_VARS
+#ifdef __WXMSW__
+        { "%ABCDEF%/g/h/i", wxPATH_NORM_ENV_VARS, "abcdef/g/h/i", wxPATH_UNIX },
+#else
+        { "$(ABCDEF)/g/h/i", wxPATH_NORM_ENV_VARS, "abcdef/g/h/i", wxPATH_UNIX },
+#endif
+
+        // test wxPATH_NORM_DOTS
+        { "a/.././b/c/../../", wxPATH_NORM_DOTS, "", wxPATH_UNIX },
+
+        // 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 },
+
+        // test wxPATH_NORM_CASE
+        { "Foo", wxPATH_NORM_CASE, "Foo", wxPATH_UNIX },
+        { "Foo", wxPATH_NORM_CASE, "foo", wxPATH_DOS },
+        { "C:\\Program Files\\wx", wxPATH_NORM_CASE,
+          "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", 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 }
+    };
+
+    // set the env var ABCDEF
+    wxSetEnv(_T("ABCDEF"), _T("abcdef"));
+
+    for ( size_t i = 0; i < WXSIZEOF(tests); i++ )
+    {
+        const FileNameTest& fnt = tests[i];
+        wxFileName fn(fnt.original, fnt.fmt);
+
+        // be sure this normalization does not fail
+        CPPUNIT_ASSERT_MESSAGE
+        (
+            (const char *)wxString::Format(_T("Normalize(%s) failed"), fnt.original).mb_str(),
+            fn.Normalize(fnt.flags, cwd, fnt.fmt)
+        );
+
+        // compare result with expected string
+        CPPUNIT_ASSERT_EQUAL( fnt.expected, fn.GetFullPath(fnt.fmt) );
+    }
+}
+
+wxString wxTestStripExtension(wxString szFile)
+{
+    wxStripExtension(szFile);
+    return szFile;
+}
+
+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")) );
+}
+
+#ifdef __WINDOWS__
+
+void FileNameTestCase::TestShortLongPath()
+{
+    wxFileName fn(_T("C:\\Program Files\\Windows NT\\Accessories\\wordpad.exe"));
+
+    // incredibly enough, GetLongPath() used to return different results during
+    // the first and subsequent runs, test for this
+    CPPUNIT_ASSERT_EQUAL( fn.GetLongPath(), fn.GetLongPath() );
+    CPPUNIT_ASSERT_EQUAL( fn.GetShortPath(), fn.GetShortPath() );
+}
+
+#endif // __WINDOWS__