[wxWidgets.git] / tests / filename / filenametest.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        tests/filename/filename.cpp
// Purpose:     wxFileName unit test
// Author:      Vadim Zeitlin
// Created:     2004-07-25
// RCS-ID:      $Id$
// Copyright:   (c) 2004 Vadim Zeitlin
///////////////////////////////////////////////////////////////////////////////

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

#include "testprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#ifndef WX_PRECOMP
    #include "wx/utils.h"
#endif // WX_PRECOMP

#include "wx/filename.h"
#include "wx/filefn.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
// ----------------------------------------------------------------------------

static struct TestFileNameInfo
{
    const wxChar *fullname;
    const wxChar *volume;
    const wxChar *path;
    const wxChar *name;
    const wxChar *ext;
    bool isAbsolute;
    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 },
    { _T("~/.zshrc"), _T(""), _T("~"), _T(".zshrc"), _T(""), true, wxPATH_UNIX },
    { _T("../../foo"), _T(""), _T("../.."), _T("foo"), _T(""), false, wxPATH_UNIX },
    { _T("foo.bar"), _T(""), _T(""), _T("foo"), _T("bar"), false, wxPATH_UNIX },
    { _T("~/foo.bar"), _T(""), _T("~"), _T("foo"), _T("bar"), true, wxPATH_UNIX },
    { _T("/foo"), _T(""), _T("/"), _T("foo"), _T(""), true, wxPATH_UNIX },
    { _T("Mahogany-0.60/foo.bar"), _T(""), _T("Mahogany-0.60"), _T("foo"), _T("bar"), false, wxPATH_UNIX },
    { _T("/tmp/wxwin.tar.bz"), _T(""), _T("/tmp"), _T("wxwin.tar"), _T("bz"), true, wxPATH_UNIX },

    // Windows file names
    { _T("foo.bar"), _T(""), _T(""), _T("foo"), _T("bar"), false, wxPATH_DOS },
    { _T("\\foo.bar"), _T(""), _T("\\"), _T("foo"), _T("bar"), false, 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 },

    // 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
    { _T("Volume:Dir:File"), _T("Volume"), _T("Dir"), _T("File"), _T(""), true, wxPATH_MAC },
    { _T("Volume:Dir:Subdir:File"), _T("Volume"), _T("Dir:Subdir"), _T("File"), _T(""), true, wxPATH_MAC },
    { _T("Volume:"), _T("Volume"), _T(""), _T(""), _T(""), true, wxPATH_MAC },
    { _T(":Dir:File"), _T(""), _T("Dir"), _T("File"), _T(""), false, wxPATH_MAC },
    { _T(":File.Ext"), _T(""), _T(""), _T("File"), _T(".Ext"), false, wxPATH_MAC },
    { _T("File.Ext"), _T(""), _T(""), _T("File"), _T(".Ext"), false, wxPATH_MAC },
#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 },
};

// ----------------------------------------------------------------------------
// test class
// ----------------------------------------------------------------------------

class FileNameTestCase : public CppUnit::TestCase
{
public:
    FileNameTestCase() { }

private:
    CPPUNIT_TEST_SUITE( FileNameTestCase );
        CPPUNIT_TEST( TestConstruction );
        CPPUNIT_TEST( TestComparison );
        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();
    void TestComparison();
    void TestSplit();
    void TestSetPath();
    void TestStrip();
    void TestNormalize();
#ifdef __WINDOWS__
    void TestShortLongPath();
#endif // __WINDOWS__

    DECLARE_NO_COPY_CLASS(FileNameTestCase)
};

// register in the unnamed registry so that these tests are run by default
CPPUNIT_TEST_SUITE_REGISTRATION( FileNameTestCase );

// also include in it's own registry so that these tests can be run alone
CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( FileNameTestCase, "FileNameTestCase" );

void FileNameTestCase::TestConstruction()
{
    for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
    {
        const TestFileNameInfo& fni = filenames[n];

        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);
        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_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++ )
    {
        const TestFileNameInfo& fni = filenames[n];
        wxString volume, path, name, ext;
        wxFileName::SplitPath(fni.fullname,
                              &volume, &path, &name, &ext, fni.format);

        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()
{
    wxFileName fn(_T("d:\\test\\foo.bar"), wxPATH_DOS);
    fn.SetPath(_T("c:\\temp"), wxPATH_DOS);
    CPPUNIT_ASSERT( fn.SameAs(wxFileName(_T("c:\\temp\\foo.bar"), wxPATH_DOS)) );

    fn = wxFileName(_T("/usr/bin/ls"), wxPATH_UNIX);
    fn.SetPath(_T("/usr/local/bin"), 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__
Commit	Line	Data
f095b1fc VZ	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
8899b155	14	#include "testprec.h"
f095b1fc VZ	15
	16	#ifdef __BORLANDC__
	17	#pragma hdrstop
	18	#endif
	19
	20	#ifndef WX_PRECOMP
f7c69b90	21	#include "wx/utils.h"
f095b1fc VZ	22	#endif // WX_PRECOMP
	23
	24	#include "wx/filename.h"
c08dd08b	25	#include "wx/filefn.h"
f095b1fc	26
2264775b VZ	27	// ----------------------------------------------------------------------------
	28	// local functions
	29	// ----------------------------------------------------------------------------
	30
	31	// define stream inserter for wxFileName to use it in CPPUNIT_ASSERT_EQUAL()
	32	inline std::ostream& operator<<(std::ostream& o, const wxFileName& fn)
	33	{
	34	return o << fn.GetFullPath();
	35	}
	36
f095b1fc VZ	37	// ----------------------------------------------------------------------------
	38	// test data
	39	// ----------------------------------------------------------------------------
	40
5fed01a9	41	static struct TestFileNameInfo
f095b1fc VZ	42	{
	43	const wxChar *fullname;
	44	const wxChar *volume;
	45	const wxChar *path;
	46	const wxChar *name;
	47	const wxChar *ext;
	48	bool isAbsolute;
	49	wxPathFormat format;
	50	} filenames[] =
	51	{
69858116	52	// the empty string
e7b54c07 VS	53	{ _T(""), _T(""), _T(""), _T(""), _T(""), false, wxPATH_UNIX },
	54	{ _T(""), _T(""), _T(""), _T(""), _T(""), false, wxPATH_DOS },
	55	{ _T(""), _T(""), _T(""), _T(""), _T(""), false, wxPATH_VMS },
69858116	56
f095b1fc VZ	57	// Unix file names
	58	{ _T("/usr/bin/ls"), _T(""), _T("/usr/bin"), _T("ls"), _T(""), true, wxPATH_UNIX },
	59	{ _T("/usr/bin/"), _T(""), _T("/usr/bin"), _T(""), _T(""), true, wxPATH_UNIX },
	60	{ _T("~/.zshrc"), _T(""), _T("~"), _T(".zshrc"), _T(""), true, wxPATH_UNIX },
	61	{ _T("../../foo"), _T(""), _T("../.."), _T("foo"), _T(""), false, wxPATH_UNIX },
	62	{ _T("foo.bar"), _T(""), _T(""), _T("foo"), _T("bar"), false, wxPATH_UNIX },
	63	{ _T("~/foo.bar"), _T(""), _T("~"), _T("foo"), _T("bar"), true, wxPATH_UNIX },
	64	{ _T("/foo"), _T(""), _T("/"), _T("foo"), _T(""), true, wxPATH_UNIX },
	65	{ _T("Mahogany-0.60/foo.bar"), _T(""), _T("Mahogany-0.60"), _T("foo"), _T("bar"), false, wxPATH_UNIX },
	66	{ _T("/tmp/wxwin.tar.bz"), _T(""), _T("/tmp"), _T("wxwin.tar"), _T("bz"), true, wxPATH_UNIX },
	67
	68	// Windows file names
	69	{ _T("foo.bar"), _T(""), _T(""), _T("foo"), _T("bar"), false, wxPATH_DOS },
	70	{ _T("\\foo.bar"), _T(""), _T("\\"), _T("foo"), _T("bar"), false, wxPATH_DOS },
	71	{ _T("c:foo.bar"), _T("c"), _T(""), _T("foo"), _T("bar"), false, wxPATH_DOS },
	72	{ _T("c:\\foo.bar"), _T("c"), _T("\\"), _T("foo"), _T("bar"), true, wxPATH_DOS },
	73	{ _T("c:\\Windows\\command.com"), _T("c"), _T("\\Windows"), _T("command"), _T("com"), true, wxPATH_DOS },
bf7f7793	74
c7099635 VZ	75	// NB: when using the wxFileName::GetLongPath() function on these two
	76	// strings, the program will hang for several seconds blocking inside
	77	// Win32 GetLongPathName() function
f095b1fc VZ	78	{ _T("\\\\server\\foo.bar"), _T("server"), _T("\\"), _T("foo"), _T("bar"), true, wxPATH_DOS },
	79	{ _T("\\\\server\\dir\\foo.bar"), _T("server"), _T("\\dir"), _T("foo"), _T("bar"), true, wxPATH_DOS },
	80
34841b21 VZ	81	// consecutive [back]slashes should be treated as single occurrences of
	82	// them and not interpreted as share names if there is a volume name
	83	{ _T("c:\\aaa\\bbb\\ccc"), _T("c"), _T("\\aaa\\bbb"), _T("ccc"), _T(""), true, wxPATH_DOS },
9b9596de	84	{ _T("c:\\\\aaa\\bbb\\ccc"), _T("c"), _T("\\\\aaa\\bbb"), _T("ccc"), _T(""), true, wxPATH_DOS },
bf7f7793	85
f095b1fc VZ	86	// wxFileName support for Mac file names is broken currently
	87	#if 0
	88	// Mac file names
	89	{ _T("Volume:Dir:File"), _T("Volume"), _T("Dir"), _T("File"), _T(""), true, wxPATH_MAC },
	90	{ _T("Volume:Dir:Subdir:File"), _T("Volume"), _T("Dir:Subdir"), _T("File"), _T(""), true, wxPATH_MAC },
	91	{ _T("Volume:"), _T("Volume"), _T(""), _T(""), _T(""), true, wxPATH_MAC },
	92	{ _T(":Dir:File"), _T(""), _T("Dir"), _T("File"), _T(""), false, wxPATH_MAC },
	93	{ _T(":File.Ext"), _T(""), _T(""), _T("File"), _T(".Ext"), false, wxPATH_MAC },
	94	{ _T("File.Ext"), _T(""), _T(""), _T("File"), _T(".Ext"), false, wxPATH_MAC },
	95	#endif // 0
	96
	97	// VMS file names
bf7f7793 RR	98	// NB: on Windows they have the same effect of the \\server\\ strings
bf7f7793 RR	99	// (see the note above)
f095b1fc VZ	100	{ _T("device:[dir1.dir2.dir3]file.txt"), _T("device"), _T("dir1.dir2.dir3"), _T("file"), _T("txt"), true, wxPATH_VMS },
	101	{ _T("file.txt"), _T(""), _T(""), _T("file"), _T("txt"), false, wxPATH_VMS },
	102	};
	103
	104	// ----------------------------------------------------------------------------
	105	// test class
	106	// ----------------------------------------------------------------------------
	107
	108	class FileNameTestCase : public CppUnit::TestCase
	109	{
	110	public:
	111	FileNameTestCase() { }
	112
	113	private:
	114	CPPUNIT_TEST_SUITE( FileNameTestCase );
	115	CPPUNIT_TEST( TestConstruction );
33366127	116	CPPUNIT_TEST( TestComparison );
f095b1fc	117	CPPUNIT_TEST( TestSplit );
4524a24b	118	CPPUNIT_TEST( TestSetPath );
c08dd08b	119	CPPUNIT_TEST( TestStrip );
bf7f7793	120	CPPUNIT_TEST( TestNormalize );
60c0dfe5 VZ	121	#ifdef __WINDOWS__
	122	CPPUNIT_TEST( TestShortLongPath );
	123	#endif // __WINDOWS__
f095b1fc VZ	124	CPPUNIT_TEST_SUITE_END();
	125
	126	void TestConstruction();
33366127	127	void TestComparison();
f095b1fc VZ	128	void TestSplit();
f095b1fc VZ	129	void TestSetPath();
c08dd08b	130	void TestStrip();
bf7f7793	131	void TestNormalize();
60c0dfe5 VZ	132	#ifdef __WINDOWS__
	133	void TestShortLongPath();
	134	#endif // __WINDOWS__
f095b1fc VZ	135
	136	DECLARE_NO_COPY_CLASS(FileNameTestCase)
	137	};
	138
	139	// register in the unnamed registry so that these tests are run by default
	140	CPPUNIT_TEST_SUITE_REGISTRATION( FileNameTestCase );
	141
	142	// also include in it's own registry so that these tests can be run alone
	143	CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( FileNameTestCase, "FileNameTestCase" );
	144
	145	void FileNameTestCase::TestConstruction()
	146	{
	147	for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
	148	{
5fed01a9	149	const TestFileNameInfo& fni = filenames[n];
f095b1fc VZ	150
	151	wxFileName fn(fni.fullname, fni.format);
	152
9b9596de VZ	153	// the original full name could contain consecutive [back]slashes,
	154	// squeeze them except for the double backslash in the beginning in
	155	// Windows filenames where it has special meaning
	156	wxString fullnameOrig;
	157	if ( fni.format == wxPATH_DOS )
	158	{
	159	// copy the backslashes at beginning unchanged
	160	const wxChar *p = fni.fullname;
	161	while ( *p == _T('\\') )
	162	fullnameOrig += *p++;
	163
	164	// replace consecutive slashes with single ones in the rest
	165	for ( wxChar chPrev = _T('\0'); *p; p++ )
	166	{
	167	if ( *p == _T('\\') && chPrev == _T('\\') )
	168	continue;
	169
	170	chPrev = *p;
	171	fullnameOrig += chPrev;
	172	}
	173	}
	174	else // !wxPATH_DOS
	175	{
	176	fullnameOrig = fni.fullname;
	177	}
	178
	179	fullnameOrig.Replace(_T("//"), _T("/"));
	180
	181
f095b1fc	182	wxString fullname = fn.GetFullPath(fni.format);
9b9596de	183	CPPUNIT_ASSERT_EQUAL( fullnameOrig, fullname );
f095b1fc	184
ab8576b4 VZ	185	// notice that we use a dummy working directory to ensure that paths
	186	// with "../.." in them could be normalized, otherwise this would fail
	187	// if the test is run from root directory or its direct subdirectory
2264775b VZ	188	CPPUNIT_ASSERT_MESSAGE
2264775b VZ	189	(
b51abd73	190	(const char *)wxString::Format(_T("Normalize(%s) failed"), fni.fullname).mb_str(),
c2173965	191	fn.Normalize(wxPATH_NORM_ALL, _T("/foo/bar/baz"), fni.format)
2264775b	192	);
4c2deb19 VZ	193
	194	if ( fni.volume && fni.path )
	195	{
	196	// check that specifying the volume separately or as part of the
	197	// path doesn't make any difference
	198	wxString pathWithVolume = fni.volume;
	199	pathWithVolume += wxFileName::GetVolumeSeparator(fni.format);
	200	pathWithVolume += fni.path;
	201
2264775b	202	CPPUNIT_ASSERT_EQUAL( wxFileName(pathWithVolume,
4c2deb19 VZ	203	fni.name,
4c2deb19 VZ	204	fni.ext,
2264775b	205	fni.format), fn );
4c2deb19	206	}
f095b1fc	207	}
69858116 VZ	208
	209	wxFileName fn;
	210
	211	// empty strings
	212	fn.AssignDir(wxEmptyString);
	213	CPPUNIT_ASSERT( !fn.IsOk() );
	214
	215	fn.Assign(wxEmptyString);
	216	CPPUNIT_ASSERT( !fn.IsOk() );
	217
	218	fn.Assign(wxEmptyString, wxEmptyString);
	219	CPPUNIT_ASSERT( !fn.IsOk() );
	220
	221	fn.Assign(wxEmptyString, wxEmptyString, wxEmptyString);
	222	CPPUNIT_ASSERT( !fn.IsOk() );
	223
	224	fn.Assign(wxEmptyString, wxEmptyString, wxEmptyString, wxEmptyString);
	225	CPPUNIT_ASSERT( !fn.IsOk() );
f095b1fc VZ	226	}
f095b1fc VZ	227
33366127 VZ	228	void FileNameTestCase::TestComparison()
33366127 VZ	229	{
523cd68a VZ	230	wxFileName fn1(wxT("/tmp/file1"));
	231	wxFileName fn2(wxT("/tmp/dir2/../file2"));
	232	fn1.Normalize();
	233	fn2.Normalize();
2264775b	234	CPPUNIT_ASSERT_EQUAL(fn1.GetPath(), fn2.GetPath());
33366127 VZ	235	}
33366127 VZ	236
f095b1fc VZ	237	void FileNameTestCase::TestSplit()
	238	{
	239	for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
	240	{
5fed01a9	241	const TestFileNameInfo& fni = filenames[n];
f095b1fc VZ	242	wxString volume, path, name, ext;
	243	wxFileName::SplitPath(fni.fullname,
	244	&volume, &path, &name, &ext, fni.format);
	245
2264775b VZ	246	CPPUNIT_ASSERT_EQUAL( wxString(fni.volume), volume );
	247	CPPUNIT_ASSERT_EQUAL( wxString(fni.path), path );
	248	CPPUNIT_ASSERT_EQUAL( wxString(fni.name), name );
	249	CPPUNIT_ASSERT_EQUAL( wxString(fni.ext), ext );
f095b1fc	250	}
dfecbee5 VZ	251
	252	// special case of empty extension
	253	wxFileName fn(_T("foo."));
2264775b	254	CPPUNIT_ASSERT_EQUAL( wxString(_T("foo.")), fn.GetFullPath() );
f095b1fc VZ	255	}
f095b1fc VZ	256
4524a24b VZ	257	void FileNameTestCase::TestSetPath()
	258	{
	259	wxFileName fn(_T("d:\\test\\foo.bar"), wxPATH_DOS);
67050b6d VS	260	fn.SetPath(_T("c:\\temp"), wxPATH_DOS);
67050b6d VS	261	CPPUNIT_ASSERT( fn.SameAs(wxFileName(_T("c:\\temp\\foo.bar"), wxPATH_DOS)) );
4524a24b	262
67050b6d VS	263	fn = wxFileName(_T("/usr/bin/ls"), wxPATH_UNIX);
	264	fn.SetPath(_T("/usr/local/bin"), wxPATH_UNIX);
	265	CPPUNIT_ASSERT( fn.SameAs(wxFileName(_T("/usr/local/bin/ls"), wxPATH_UNIX)) );
4524a24b VZ	266	}
4524a24b VZ	267
bf7f7793 RR	268	void FileNameTestCase::TestNormalize()
	269	{
	270	// prepare some data to be used later
	271	wxString sep = wxFileName::GetPathSeparator();
	272	wxString cwd = wxGetCwd();
	273	wxString home = wxGetUserHome();
	274
	275	cwd.Replace(sep, wxT("/"));
	276	if (cwd.Last() != wxT('/'))
	277	cwd += wxT('/');
	278	home.Replace(sep, wxT("/"));
	279	if (home.Last() != wxT('/'))
	280	home += wxT('/');
	281
	282	// since we will always be testing paths using the wxPATH_UNIX
	283	// format, we need to remove the volume, if present
	284	if (home.Contains(wxT(':')))
	285	home = home.AfterFirst(wxT(':'));
	286	if (cwd.Contains(wxT(':')))
	287	cwd = cwd.AfterFirst(wxT(':'));
	288
8e083702	289	static const struct FileNameTest
bf7f7793	290	{
8e083702	291	wxString original;
bf7f7793	292	int flags;
8e083702	293	wxString expected;
c7099635	294	wxPathFormat fmt;
bf7f7793 RR	295	} tests[] =
	296	{
	297	// test wxPATH_NORM_ENV_VARS
	298	#ifdef __WXMSW__
c7099635	299	{ "%ABCDEF%/g/h/i", wxPATH_NORM_ENV_VARS, "abcdef/g/h/i", wxPATH_UNIX },
bf7f7793	300	#else
c7099635	301	{ "$(ABCDEF)/g/h/i", wxPATH_NORM_ENV_VARS, "abcdef/g/h/i", wxPATH_UNIX },
bf7f7793 RR	302	#endif
	303
	304	// test wxPATH_NORM_DOTS
c7099635	305	{ "a/.././b/c/../../", wxPATH_NORM_DOTS, "", wxPATH_UNIX },
bf7f7793 RR	306
	307	// test wxPATH_NORM_TILDE
	308	// NB: do the tilde expansion also under Windows to test if it works there too
c7099635 VZ	309	{ "/a/b/~", wxPATH_NORM_TILDE, "/a/b/~", wxPATH_UNIX },
	310	{ "/~/a/b", wxPATH_NORM_TILDE, home + "a/b", wxPATH_UNIX },
	311	{ "~/a/b", wxPATH_NORM_TILDE, home + "a/b", wxPATH_UNIX },
	312
	313	// test wxPATH_NORM_CASE
	314	{ "Foo", wxPATH_NORM_CASE, "Foo", wxPATH_UNIX },
	315	{ "Foo", wxPATH_NORM_CASE, "foo", wxPATH_DOS },
	316	{ "C:\\Program Files\\wx", wxPATH_NORM_CASE,
	317	"c:\\program files\\wx", wxPATH_DOS },
	318	{ "C:/Program Files/wx", wxPATH_NORM_ALL \| wxPATH_NORM_CASE,
	319	"c:\\program files\\wx", wxPATH_DOS },
9a0c5c01 VZ	320	{ "C:\\Users\\zeitlin", wxPATH_NORM_ALL \| wxPATH_NORM_CASE,
9a0c5c01 VZ	321	"c:\\users\\zeitlin", wxPATH_DOS },
bf7f7793 RR	322
bf7f7793 RR	323	// test wxPATH_NORM_ABSOLUTE
c7099635 VZ	324	{ "a/b/", wxPATH_NORM_ABSOLUTE, cwd + "a/b/", wxPATH_UNIX },
	325	{ "a/b/c.ext", wxPATH_NORM_ABSOLUTE, cwd + "a/b/c.ext", wxPATH_UNIX },
	326	{ "/a", wxPATH_NORM_ABSOLUTE, "/a", wxPATH_UNIX },
bf7f7793 RR	327
bf7f7793 RR	328	// test giving no flags at all to Normalize()
c7099635 VZ	329	{ "a/b/", 0, "a/b/", wxPATH_UNIX },
	330	{ "a/b/c.ext", 0, "a/b/c.ext", wxPATH_UNIX },
	331	{ "/a", 0, "/a", wxPATH_UNIX }
bf7f7793 RR	332	};
	333
	334	// set the env var ABCDEF
	335	wxSetEnv(_T("ABCDEF"), _T("abcdef"));
	336
2264775b	337	for ( size_t i = 0; i < WXSIZEOF(tests); i++ )
bf7f7793	338	{
c7099635 VZ	339	const FileNameTest& fnt = tests[i];
c7099635 VZ	340	wxFileName fn(fnt.original, fnt.fmt);
bf7f7793 RR	341
bf7f7793 RR	342	// be sure this normalization does not fail
2264775b VZ	343	CPPUNIT_ASSERT_MESSAGE
2264775b VZ	344	(
c7099635 VZ	345	(const char *)wxString::Format(_T("Normalize(%s) failed"), fnt.original).mb_str(),
c7099635 VZ	346	fn.Normalize(fnt.flags, cwd, fnt.fmt)
2264775b	347	);
bf7f7793 RR	348
bf7f7793 RR	349	// compare result with expected string
1de532f5	350	CPPUNIT_ASSERT_EQUAL( fnt.expected, fn.GetFullPath(fnt.fmt) );
bf7f7793 RR	351	}
	352	}
	353
ff3d9a35	354	wxString wxTestStripExtension(wxString szFile)
c08dd08b RN	355	{
	356	wxStripExtension(szFile);
	357	return szFile;
	358	}
	359
	360	void FileNameTestCase::TestStrip()
	361	{
	362	//test a crash
2264775b	363	CPPUNIT_ASSERT_EQUAL( wxString(_T("")), wxTestStripExtension(_T("")) );
c08dd08b RN	364
c08dd08b RN	365	//others
2264775b VZ	366	CPPUNIT_ASSERT_EQUAL( wxString(_T("")), wxTestStripExtension(_T(".")) );
	367	CPPUNIT_ASSERT_EQUAL( wxString(_T("")), wxTestStripExtension(_T(".wav")) );
	368	CPPUNIT_ASSERT_EQUAL( wxString(_T("good")), wxTestStripExtension(_T("good.wav")) );
	369	CPPUNIT_ASSERT_EQUAL( wxString(_T("good.wav")), wxTestStripExtension(_T("good.wav.wav")) );
ff3d9a35	370	}
60c0dfe5 VZ	371
	372	#ifdef __WINDOWS__
	373
	374	void FileNameTestCase::TestShortLongPath()
	375	{
3f302e75	376	wxFileName fn(_T("C:\\Program Files\\Windows NT\\Accessories\\wordpad.exe"));
60c0dfe5 VZ	377
	378	// incredibly enough, GetLongPath() used to return different results during
	379	// the first and subsequent runs, test for this
	380	CPPUNIT_ASSERT_EQUAL( fn.GetLongPath(), fn.GetLongPath() );
	381	CPPUNIT_ASSERT_EQUAL( fn.GetShortPath(), fn.GetShortPath() );
	382	}
	383
	384	#endif // __WINDOWS__