[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 FileNameInfo
{
    const wxChar *fullname;
    const wxChar *volume;
    const wxChar *path;
    const wxChar *name;
    const wxChar *ext;
    bool isAbsolute;
    wxPathFormat format;
} filenames[] =
{
    // 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 various seconds. All those time is taken by the
    //     call to the win32 API GetLongPathName()...
    { _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 },


    // 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 FileNameInfo& fni = filenames[n];

        wxFileName fn(fni.fullname, fni.format);

        wxString fullname = fn.GetFullPath(fni.format);
        CPPUNIT_ASSERT_EQUAL( wxString(fni.fullname), 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
        (
            wxString::Format("Normalize(%s) failed", fni.fullname).c_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 );
        }
    }
}

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 FileNameInfo& 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 struct FileNameTest
    {
        const wxChar *original;
        int flags;
        wxString expected;
    } tests[] =
    {
        // test wxPATH_NORM_ENV_VARS
#ifdef __WXMSW__
        { wxT("%ABCDEF%/g/h/i"), wxPATH_NORM_ENV_VARS, wxT("abcdef/g/h/i") },
#else
        { wxT("$(ABCDEF)/g/h/i"), wxPATH_NORM_ENV_VARS, wxT("abcdef/g/h/i") },
#endif

        // test wxPATH_NORM_DOTS
        { wxT("a/.././b/c/../../"), wxPATH_NORM_DOTS, wxT("") },

        // test wxPATH_NORM_TILDE
        // NB: do the tilde expansion also under Windows to test if it works there too
        { wxT("/a/b/~"), wxPATH_NORM_TILDE, wxT("/a/b/~") },
        { wxT("/~/a/b"), wxPATH_NORM_TILDE, home + wxT("a/b") },
        { wxT("~/a/b"), wxPATH_NORM_TILDE, home + wxT("a/b") },

        // test wxPATH_NORM_ABSOLUTE
        { wxT("a/b/"), wxPATH_NORM_ABSOLUTE, cwd + wxT("a/b/") },
        { wxT("a/b/c.ext"), wxPATH_NORM_ABSOLUTE, cwd + wxT("a/b/c.ext") },
        { wxT("/a"), wxPATH_NORM_ABSOLUTE, wxT("/a") },

        // test giving no flags at all to Normalize()
        { wxT("a/b/"), 0, wxT("a/b/") },
        { wxT("a/b/c.ext"), 0, wxT("a/b/c.ext") },
        { wxT("/a"), 0, wxT("/a") }
    };

    // set the env var ABCDEF
    wxSetEnv(_T("ABCDEF"), _T("abcdef"));

    for ( size_t i = 0; i < WXSIZEOF(tests); i++ )
    {
        wxFileName fn(tests[i].original, wxPATH_UNIX);

        // be sure this normalization does not fail
        CPPUNIT_ASSERT_MESSAGE
        (
            wxString::Format("Normalize(%s) failed", tests[i].original).c_str(),
            fn.Normalize(tests[i].flags, cwd, wxPATH_UNIX)
        );

        // compare result with expected string
        CPPUNIT_ASSERT_EQUAL( tests[i].expected, fn.GetFullPath(wxPATH_UNIX) );
    }
}

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
	41	static struct FileNameInfo
	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	{
	52	// Unix file names
	53	{ _T("/usr/bin/ls"), _T(""), _T("/usr/bin"), _T("ls"), _T(""), true, wxPATH_UNIX },
	54	{ _T("/usr/bin/"), _T(""), _T("/usr/bin"), _T(""), _T(""), true, wxPATH_UNIX },
	55	{ _T("~/.zshrc"), _T(""), _T("~"), _T(".zshrc"), _T(""), true, wxPATH_UNIX },
	56	{ _T("../../foo"), _T(""), _T("../.."), _T("foo"), _T(""), false, wxPATH_UNIX },
	57	{ _T("foo.bar"), _T(""), _T(""), _T("foo"), _T("bar"), false, wxPATH_UNIX },
	58	{ _T("~/foo.bar"), _T(""), _T("~"), _T("foo"), _T("bar"), true, wxPATH_UNIX },
	59	{ _T("/foo"), _T(""), _T("/"), _T("foo"), _T(""), true, wxPATH_UNIX },
	60	{ _T("Mahogany-0.60/foo.bar"), _T(""), _T("Mahogany-0.60"), _T("foo"), _T("bar"), false, wxPATH_UNIX },
	61	{ _T("/tmp/wxwin.tar.bz"), _T(""), _T("/tmp"), _T("wxwin.tar"), _T("bz"), true, wxPATH_UNIX },
	62
	63	// Windows file names
	64	{ _T("foo.bar"), _T(""), _T(""), _T("foo"), _T("bar"), false, wxPATH_DOS },
	65	{ _T("\\foo.bar"), _T(""), _T("\\"), _T("foo"), _T("bar"), false, wxPATH_DOS },
	66	{ _T("c:foo.bar"), _T("c"), _T(""), _T("foo"), _T("bar"), false, wxPATH_DOS },
	67	{ _T("c:\\foo.bar"), _T("c"), _T("\\"), _T("foo"), _T("bar"), true, wxPATH_DOS },
	68	{ _T("c:\\Windows\\command.com"), _T("c"), _T("\\Windows"), _T("command"), _T("com"), true, wxPATH_DOS },
bf7f7793 RR	69
	70	// NB: when using the wxFileName::GetLongPath() function on these two strings,
	71	// the program will hang various seconds. All those time is taken by the
	72	// call to the win32 API GetLongPathName()...
f095b1fc VZ	73	{ _T("\\\\server\\foo.bar"), _T("server"), _T("\\"), _T("foo"), _T("bar"), true, wxPATH_DOS },
	74	{ _T("\\\\server\\dir\\foo.bar"), _T("server"), _T("\\dir"), _T("foo"), _T("bar"), true, wxPATH_DOS },
	75
bf7f7793	76
f095b1fc VZ	77	// wxFileName support for Mac file names is broken currently
	78	#if 0
	79	// Mac file names
	80	{ _T("Volume:Dir:File"), _T("Volume"), _T("Dir"), _T("File"), _T(""), true, wxPATH_MAC },
	81	{ _T("Volume:Dir:Subdir:File"), _T("Volume"), _T("Dir:Subdir"), _T("File"), _T(""), true, wxPATH_MAC },
	82	{ _T("Volume:"), _T("Volume"), _T(""), _T(""), _T(""), true, wxPATH_MAC },
	83	{ _T(":Dir:File"), _T(""), _T("Dir"), _T("File"), _T(""), false, wxPATH_MAC },
	84	{ _T(":File.Ext"), _T(""), _T(""), _T("File"), _T(".Ext"), false, wxPATH_MAC },
	85	{ _T("File.Ext"), _T(""), _T(""), _T("File"), _T(".Ext"), false, wxPATH_MAC },
	86	#endif // 0
	87
	88	// VMS file names
bf7f7793 RR	89	// NB: on Windows they have the same effect of the \\server\\ strings
bf7f7793 RR	90	// (see the note above)
f095b1fc VZ	91	{ _T("device:[dir1.dir2.dir3]file.txt"), _T("device"), _T("dir1.dir2.dir3"), _T("file"), _T("txt"), true, wxPATH_VMS },
	92	{ _T("file.txt"), _T(""), _T(""), _T("file"), _T("txt"), false, wxPATH_VMS },
	93	};
	94
	95	// ----------------------------------------------------------------------------
	96	// test class
	97	// ----------------------------------------------------------------------------
	98
	99	class FileNameTestCase : public CppUnit::TestCase
	100	{
	101	public:
	102	FileNameTestCase() { }
	103
	104	private:
	105	CPPUNIT_TEST_SUITE( FileNameTestCase );
	106	CPPUNIT_TEST( TestConstruction );
33366127	107	CPPUNIT_TEST( TestComparison );
f095b1fc	108	CPPUNIT_TEST( TestSplit );
4524a24b	109	CPPUNIT_TEST( TestSetPath );
c08dd08b	110	CPPUNIT_TEST( TestStrip );
bf7f7793	111	CPPUNIT_TEST( TestNormalize );
60c0dfe5 VZ	112	#ifdef __WINDOWS__
	113	CPPUNIT_TEST( TestShortLongPath );
	114	#endif // __WINDOWS__
f095b1fc VZ	115	CPPUNIT_TEST_SUITE_END();
	116
	117	void TestConstruction();
33366127	118	void TestComparison();
f095b1fc VZ	119	void TestSplit();
f095b1fc VZ	120	void TestSetPath();
c08dd08b	121	void TestStrip();
bf7f7793	122	void TestNormalize();
60c0dfe5 VZ	123	#ifdef __WINDOWS__
	124	void TestShortLongPath();
	125	#endif // __WINDOWS__
f095b1fc VZ	126
	127	DECLARE_NO_COPY_CLASS(FileNameTestCase)
	128	};
	129
	130	// register in the unnamed registry so that these tests are run by default
	131	CPPUNIT_TEST_SUITE_REGISTRATION( FileNameTestCase );
	132
	133	// also include in it's own registry so that these tests can be run alone
	134	CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( FileNameTestCase, "FileNameTestCase" );
	135
	136	void FileNameTestCase::TestConstruction()
	137	{
	138	for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
	139	{
	140	const FileNameInfo& fni = filenames[n];
	141
	142	wxFileName fn(fni.fullname, fni.format);
	143
	144	wxString fullname = fn.GetFullPath(fni.format);
2264775b	145	CPPUNIT_ASSERT_EQUAL( wxString(fni.fullname), fullname );
f095b1fc	146
ab8576b4 VZ	147	// notice that we use a dummy working directory to ensure that paths
	148	// with "../.." in them could be normalized, otherwise this would fail
	149	// if the test is run from root directory or its direct subdirectory
2264775b VZ	150	CPPUNIT_ASSERT_MESSAGE
	151	(
	152	wxString::Format("Normalize(%s) failed", fni.fullname).c_str(),
c2173965	153	fn.Normalize(wxPATH_NORM_ALL, _T("/foo/bar/baz"), fni.format)
2264775b	154	);
4c2deb19 VZ	155
	156	if ( fni.volume && fni.path )
	157	{
	158	// check that specifying the volume separately or as part of the
	159	// path doesn't make any difference
	160	wxString pathWithVolume = fni.volume;
	161	pathWithVolume += wxFileName::GetVolumeSeparator(fni.format);
	162	pathWithVolume += fni.path;
	163
2264775b	164	CPPUNIT_ASSERT_EQUAL( wxFileName(pathWithVolume,
4c2deb19 VZ	165	fni.name,
4c2deb19 VZ	166	fni.ext,
2264775b	167	fni.format), fn );
4c2deb19	168	}
f095b1fc VZ	169	}
	170	}
	171
33366127 VZ	172	void FileNameTestCase::TestComparison()
33366127 VZ	173	{
523cd68a VZ	174	wxFileName fn1(wxT("/tmp/file1"));
	175	wxFileName fn2(wxT("/tmp/dir2/../file2"));
	176	fn1.Normalize();
	177	fn2.Normalize();
2264775b	178	CPPUNIT_ASSERT_EQUAL(fn1.GetPath(), fn2.GetPath());
33366127 VZ	179	}
33366127 VZ	180
f095b1fc VZ	181	void FileNameTestCase::TestSplit()
	182	{
	183	for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
	184	{
	185	const FileNameInfo& fni = filenames[n];
	186	wxString volume, path, name, ext;
	187	wxFileName::SplitPath(fni.fullname,
	188	&volume, &path, &name, &ext, fni.format);
	189
2264775b VZ	190	CPPUNIT_ASSERT_EQUAL( wxString(fni.volume), volume );
	191	CPPUNIT_ASSERT_EQUAL( wxString(fni.path), path );
	192	CPPUNIT_ASSERT_EQUAL( wxString(fni.name), name );
	193	CPPUNIT_ASSERT_EQUAL( wxString(fni.ext), ext );
f095b1fc	194	}
dfecbee5 VZ	195
	196	// special case of empty extension
	197	wxFileName fn(_T("foo."));
2264775b	198	CPPUNIT_ASSERT_EQUAL( wxString(_T("foo.")), fn.GetFullPath() );
f095b1fc VZ	199	}
f095b1fc VZ	200
4524a24b VZ	201	void FileNameTestCase::TestSetPath()
	202	{
	203	wxFileName fn(_T("d:\\test\\foo.bar"), wxPATH_DOS);
67050b6d VS	204	fn.SetPath(_T("c:\\temp"), wxPATH_DOS);
67050b6d VS	205	CPPUNIT_ASSERT( fn.SameAs(wxFileName(_T("c:\\temp\\foo.bar"), wxPATH_DOS)) );
4524a24b	206
67050b6d VS	207	fn = wxFileName(_T("/usr/bin/ls"), wxPATH_UNIX);
	208	fn.SetPath(_T("/usr/local/bin"), wxPATH_UNIX);
	209	CPPUNIT_ASSERT( fn.SameAs(wxFileName(_T("/usr/local/bin/ls"), wxPATH_UNIX)) );
4524a24b VZ	210	}
4524a24b VZ	211
bf7f7793 RR	212	void FileNameTestCase::TestNormalize()
	213	{
	214	// prepare some data to be used later
	215	wxString sep = wxFileName::GetPathSeparator();
	216	wxString cwd = wxGetCwd();
	217	wxString home = wxGetUserHome();
	218
	219	cwd.Replace(sep, wxT("/"));
	220	if (cwd.Last() != wxT('/'))
	221	cwd += wxT('/');
	222	home.Replace(sep, wxT("/"));
	223	if (home.Last() != wxT('/'))
	224	home += wxT('/');
	225
	226	// since we will always be testing paths using the wxPATH_UNIX
	227	// format, we need to remove the volume, if present
	228	if (home.Contains(wxT(':')))
	229	home = home.AfterFirst(wxT(':'));
	230	if (cwd.Contains(wxT(':')))
	231	cwd = cwd.AfterFirst(wxT(':'));
	232
	233	static struct FileNameTest
	234	{
2264775b	235	const wxChar *original;
bf7f7793 RR	236	int flags;
	237	wxString expected;
	238	} tests[] =
	239	{
	240	// test wxPATH_NORM_ENV_VARS
	241	#ifdef __WXMSW__
	242	{ wxT("%ABCDEF%/g/h/i"), wxPATH_NORM_ENV_VARS, wxT("abcdef/g/h/i") },
	243	#else
	244	{ wxT("$(ABCDEF)/g/h/i"), wxPATH_NORM_ENV_VARS, wxT("abcdef/g/h/i") },
	245	#endif
	246
	247	// test wxPATH_NORM_DOTS
	248	{ wxT("a/.././b/c/../../"), wxPATH_NORM_DOTS, wxT("") },
	249
	250	// test wxPATH_NORM_TILDE
	251	// NB: do the tilde expansion also under Windows to test if it works there too
	252	{ wxT("/a/b/~"), wxPATH_NORM_TILDE, wxT("/a/b/~") },
	253	{ wxT("/~/a/b"), wxPATH_NORM_TILDE, home + wxT("a/b") },
	254	{ wxT("~/a/b"), wxPATH_NORM_TILDE, home + wxT("a/b") },
	255
	256	// test wxPATH_NORM_ABSOLUTE
	257	{ wxT("a/b/"), wxPATH_NORM_ABSOLUTE, cwd + wxT("a/b/") },
	258	{ wxT("a/b/c.ext"), wxPATH_NORM_ABSOLUTE, cwd + wxT("a/b/c.ext") },
	259	{ wxT("/a"), wxPATH_NORM_ABSOLUTE, wxT("/a") },
	260
	261	// test giving no flags at all to Normalize()
	262	{ wxT("a/b/"), 0, wxT("a/b/") },
	263	{ wxT("a/b/c.ext"), 0, wxT("a/b/c.ext") },
	264	{ wxT("/a"), 0, wxT("/a") }
	265	};
	266
	267	// set the env var ABCDEF
	268	wxSetEnv(_T("ABCDEF"), _T("abcdef"));
	269
2264775b	270	for ( size_t i = 0; i < WXSIZEOF(tests); i++ )
bf7f7793 RR	271	{
	272	wxFileName fn(tests[i].original, wxPATH_UNIX);
	273
	274	// be sure this normalization does not fail
2264775b VZ	275	CPPUNIT_ASSERT_MESSAGE
	276	(
	277	wxString::Format("Normalize(%s) failed", tests[i].original).c_str(),
	278	fn.Normalize(tests[i].flags, cwd, wxPATH_UNIX)
	279	);
bf7f7793 RR	280
	281	// compare result with expected string
	282	CPPUNIT_ASSERT_EQUAL( tests[i].expected, fn.GetFullPath(wxPATH_UNIX) );
	283	}
	284	}
	285
ff3d9a35	286	wxString wxTestStripExtension(wxString szFile)
c08dd08b RN	287	{
	288	wxStripExtension(szFile);
	289	return szFile;
	290	}
	291
	292	void FileNameTestCase::TestStrip()
	293	{
	294	//test a crash
2264775b	295	CPPUNIT_ASSERT_EQUAL( wxString(_T("")), wxTestStripExtension(_T("")) );
c08dd08b RN	296
c08dd08b RN	297	//others
2264775b VZ	298	CPPUNIT_ASSERT_EQUAL( wxString(_T("")), wxTestStripExtension(_T(".")) );
	299	CPPUNIT_ASSERT_EQUAL( wxString(_T("")), wxTestStripExtension(_T(".wav")) );
	300	CPPUNIT_ASSERT_EQUAL( wxString(_T("good")), wxTestStripExtension(_T("good.wav")) );
	301	CPPUNIT_ASSERT_EQUAL( wxString(_T("good.wav")), wxTestStripExtension(_T("good.wav.wav")) );
ff3d9a35	302	}
60c0dfe5 VZ	303
	304	#ifdef __WINDOWS__
	305
	306	void FileNameTestCase::TestShortLongPath()
	307	{
3f302e75	308	wxFileName fn(_T("C:\\Program Files\\Windows NT\\Accessories\\wordpad.exe"));
60c0dfe5 VZ	309
	310	// incredibly enough, GetLongPath() used to return different results during
	311	// the first and subsequent runs, test for this
	312	CPPUNIT_ASSERT_EQUAL( fn.GetLongPath(), fn.GetLongPath() );
	313	CPPUNIT_ASSERT_EQUAL( fn.GetShortPath(), fn.GetShortPath() );
	314	}
	315
	316	#endif // __WINDOWS__