cheng/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'file-tests'

Browse Source 
Clean up file tests and re-enable most of them in the CI workflow using
Wine.

See https://github.com/wxWidgets/wxWidgets/pull/2416
This commit is contained in:
Vadim Zeitlin 2021-07-04 18:23:03 +02:00
commit 02c90d126c
3 changed files with 353 additions and 538 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
.github/workflows/ci_msw_cross.yml vendored
View File

@ -60,6 +60,11 @@ jobs:
# Default to 64-bit build.
HOST_TRIPLET: ${{ matrix.triplet || 'x86_64-w64-mingw32' }}
# While our tests should run in any locale natively, it seems that Wine
# requires the locale encoding to be UTF-8 for Unicode file names to work
# correctly, so set the locale explicitly for it.
LC_ALL: C.UTF-8
# Run all commands as the normal user, created by the first step below.
#
# Note that the Bash options used here are the same as for the default
@ -200,11 +205,11 @@ jobs:
# to exclude the tests that are not run by default, so start with this.
excluded_tests=('~[.]')
# Only TestSetTimes fails, but only the full test can be excluded.
excluded_tests+=('~FileNameTestCase')
# There is 1 day difference in creation time under Wine somehow.
excluded_tests+=('~wxFileName::SetTimes')
# Only FileError fails, but the whole test has to be excluded.
excluded_tests+=('~FileFunctionsTestCase')
# Closing the file fails for unknown reason under Wine.
excluded_tests+=('~FileFunctions::Error')
# Sporadic failures due to extra events.
excluded_tests+=('~wxFileSystemWatcher::EventCreate')

364
tests/file/filefn.cpp
View File

@ -26,51 +26,11 @@
// test class
// ----------------------------------------------------------------------------
class FileFunctionsTestCase : public CppUnit::TestCase
class FileFunctionsTestCase
{
public:
FileFunctionsTestCase() { }
void setUp() wxOVERRIDE;
void tearDown() wxOVERRIDE;
private:
CPPUNIT_TEST_SUITE( FileFunctionsTestCase );
CPPUNIT_TEST( GetTempFolder );
CPPUNIT_TEST( CopyFile );
CPPUNIT_TEST( CreateFile );
CPPUNIT_TEST( FileExists );
CPPUNIT_TEST( FindFile );
CPPUNIT_TEST( FindFileNext );
CPPUNIT_TEST( RemoveFile );
CPPUNIT_TEST( RenameFile );
CPPUNIT_TEST( ConcatenateFiles );
CPPUNIT_TEST( GetCwd );
CPPUNIT_TEST( FileEof );
CPPUNIT_TEST( FileError );
CPPUNIT_TEST( DirExists );
CPPUNIT_TEST( IsAbsolutePath );
CPPUNIT_TEST( PathOnly );
CPPUNIT_TEST( Mkdir );
CPPUNIT_TEST( Rmdir );
CPPUNIT_TEST_SUITE_END();
void GetTempFolder();
void CopyFile();
void CreateFile();
void FileExists();
void FindFile();
void FindFileNext();
void RemoveFile();
void RenameFile();
void ConcatenateFiles();
void GetCwd();
void FileEof();
void FileError();
void DirExists();
void IsAbsolutePath();
void PathOnly();
void Mkdir();
void Rmdir();
protected:
FileFunctionsTestCase();
~FileFunctionsTestCase();
// Helper methods
void DoCreateFile(const wxString& filePath);
@ -95,17 +55,10 @@ private:
};
// ----------------------------------------------------------------------------
// CppUnit macros
// test fixture implementation
// ----------------------------------------------------------------------------
CPPUNIT_TEST_SUITE_REGISTRATION( FileFunctionsTestCase );
CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( FileFunctionsTestCase, "FileFunctionsTestCase" );
// ----------------------------------------------------------------------------
// tests implementation
// ----------------------------------------------------------------------------
void FileFunctionsTestCase::setUp()
FileFunctionsTestCase::FileFunctionsTestCase()
{
// Initialize local data
@ -123,7 +76,7 @@ void FileFunctionsTestCase::setUp()
m_fileNameWork = fn3.GetFullPath();
}
void FileFunctionsTestCase::tearDown()
FileFunctionsTestCase::~FileFunctionsTestCase()
{
// Remove all remaining temporary files
if ( wxFileExists(m_fileNameASCII) )
@ -142,43 +95,51 @@ void FileFunctionsTestCase::tearDown()
}
}
void FileFunctionsTestCase::GetTempFolder()
// ----------------------------------------------------------------------------
// tests themselves start here
// ----------------------------------------------------------------------------
TEST_CASE_METHOD(FileFunctionsTestCase,
"FileFunctions::GetTempFolder",
"[filefn]")
{
// Verify that obtained temporary folder is not empty.
wxString tmpDir = wxFileName::GetTempDir();
CPPUNIT_ASSERT( !tmpDir.IsEmpty() );
CHECK( !tmpDir.IsEmpty() );
}
void FileFunctionsTestCase::CopyFile()
TEST_CASE_METHOD(FileFunctionsTestCase,
"FileFunctions::CopyFile",
"[filefn]")
{
const wxString filename1(wxS("horse.xpm"));
const wxString& filename2 = m_fileNameWork;
const std::string msg =
wxString::Format("File 1: %s File 2:%s", filename1, filename2)
.ToStdString();
INFO("File 1: " << filename1 << " File 2: " << filename2);
CPPUNIT_ASSERT_MESSAGE( msg, wxCopyFile(filename1, filename2) );
REQUIRE( wxCopyFile(filename1, filename2) );
// verify that the two files have the same contents!
wxFFile f1(filename1, wxT("rb")),
f2(filename2, wxT("rb"));
CPPUNIT_ASSERT_MESSAGE( msg, f1.IsOpened() );
CPPUNIT_ASSERT_MESSAGE( msg, f2.IsOpened() );
REQUIRE( f1.IsOpened() );
REQUIRE( f2.IsOpened() );
wxString s1, s2;
CPPUNIT_ASSERT_MESSAGE( msg, f1.ReadAll(&s1) );
CPPUNIT_ASSERT_MESSAGE( msg, f2.ReadAll(&s2) );
CPPUNIT_ASSERT_MESSAGE( msg, s1 == s2 );
REQUIRE( f1.ReadAll(&s1) );
REQUIRE( f2.ReadAll(&s2) );
CHECK( s1 == s2 );
CPPUNIT_ASSERT_MESSAGE( msg, f1.Close() );
CPPUNIT_ASSERT_MESSAGE( msg, f2.Close() );
CPPUNIT_ASSERT_MESSAGE( msg, wxRemoveFile(filename2) );
CHECK( f1.Close() );
CHECK( f2.Close() );
CHECK( wxRemoveFile(filename2) );
}
void FileFunctionsTestCase::CreateFile()
TEST_CASE_METHOD(FileFunctionsTestCase,
"FileFunctions::CreateFile",
"[filefn]")
{
// Create file name containing ASCII characters only.
DoCreateFile(m_fileNameASCII);
@ -190,20 +151,22 @@ void FileFunctionsTestCase::CreateFile()
void FileFunctionsTestCase::DoCreateFile(const wxString& filePath)
{
const std::string msg = wxString::Format("File: %s", filePath).ToStdString();
INFO("File: " << filePath);
// Create temporary file.
wxTextFile file;
CPPUNIT_ASSERT_MESSAGE( msg, file.Create(filePath) );
CPPUNIT_ASSERT_MESSAGE( msg, file.Close() );
REQUIRE( file.Create(filePath) );
CHECK( file.Close() );
wxRemoveFile(filePath);
}
void FileFunctionsTestCase::FileExists()
TEST_CASE_METHOD(FileFunctionsTestCase,
"FileFunctions::FileExists",
"[filefn]")
{
CPPUNIT_ASSERT( wxFileExists(wxT("horse.png")) );
CPPUNIT_ASSERT( !wxFileExists(wxT("horse.___")) );
CHECK( wxFileExists(wxT("horse.png")) );
CHECK( !wxFileExists(wxT("horse.___")) );
// Check file name containing ASCII characters only.
DoFileExists(m_fileNameASCII);
@ -215,21 +178,23 @@ void FileFunctionsTestCase::FileExists()
void FileFunctionsTestCase::DoFileExists(const wxString& filePath)
{
const std::string msg = wxString::Format("File: %s", filePath).ToStdString();
INFO("File: " << filePath);
// Create temporary file.
wxTextFile file;
CPPUNIT_ASSERT_MESSAGE( msg, file.Create(filePath) );
CPPUNIT_ASSERT_MESSAGE( msg, file.Close() );
REQUIRE( file.Create(filePath) );
CHECK( file.Close() );
// Verify that file exists with 2 methods.
CPPUNIT_ASSERT_MESSAGE( msg, file.Exists() );
CPPUNIT_ASSERT_MESSAGE( msg, wxFileExists(filePath) );
CHECK( file.Exists() );
CHECK( wxFileExists(filePath) );
wxRemoveFile(filePath);
}
void FileFunctionsTestCase::FindFile()
TEST_CASE_METHOD(FileFunctionsTestCase,
"FileFunctions::FindFile",
"[filefn]")
{
// Find file name containing ASCII characters only.
DoFindFile(m_fileNameASCII);
@ -241,28 +206,30 @@ void FileFunctionsTestCase::FindFile()
void FileFunctionsTestCase::DoFindFile(const wxString& filePath)
{
const std::string msg = wxString::Format("File: %s", filePath).ToStdString();
INFO("File: " << filePath);
// Create temporary file.
wxTextFile file;
CPPUNIT_ASSERT_MESSAGE( msg, file.Create(filePath) );
CPPUNIT_ASSERT_MESSAGE( msg, file.Close() );
REQUIRE( file.Create(filePath) );
CHECK( file.Close() );
// Check if file can be found (method 1).
wxString foundFile = wxFindFirstFile(filePath, wxFILE);
CPPUNIT_ASSERT_MESSAGE( msg, foundFile == filePath );
CHECK( foundFile == filePath );
// Check if file can be found (method 2).
wxFileSystem fs;
wxString furl = fs.FindFirst(filePath, wxFILE);
wxFileName fname = wxFileName::URLToFileName(furl);
foundFile = fname.GetFullPath();
CPPUNIT_ASSERT_MESSAGE( msg, foundFile == filePath );
CHECK( foundFile == filePath );
wxRemoveFile(filePath);
}
void FileFunctionsTestCase::FindFileNext()
TEST_CASE_METHOD(FileFunctionsTestCase,
"FileFunctions::FindFileNext",
"[filefn]")
{
// Construct file name containing ASCII characters only.
const wxString fileMask(wxT("horse.*"));
@ -273,9 +240,9 @@ void FileFunctionsTestCase::FindFileNext()
wxFileName fn1(foundFile1);
wxFileName fn2(foundFile2);
// Full names must be different.
CPPUNIT_ASSERT( foundFile1 != foundFile2 );
CHECK( foundFile1 != foundFile2 );
// Base names must be the same.
CPPUNIT_ASSERT( fn1.GetName() == fn2.GetName() );
CHECK( fn1.GetName() == fn2.GetName() );
// Check using method 2.
wxFileSystem fs;
@ -286,12 +253,14 @@ void FileFunctionsTestCase::FindFileNext()
fn2 = wxFileName::URLToFileName(furl);
foundFile2 = fn2.GetFullPath();
// Full names must be different.
CPPUNIT_ASSERT( fn1.GetFullPath() != fn2.GetFullPath() );
CHECK( fn1.GetFullPath() != fn2.GetFullPath() );
// Base names must be the same.
CPPUNIT_ASSERT( fn1.GetName() == fn2.GetName() );
CHECK( fn1.GetName() == fn2.GetName() );
}
void FileFunctionsTestCase::RemoveFile()
TEST_CASE_METHOD(FileFunctionsTestCase,
"FileFunctions::RemoveFile",
"[filefn]")
{
// Create & remove file with name containing ASCII characters only.
DoRemoveFile(m_fileNameASCII);
@ -303,19 +272,21 @@ void FileFunctionsTestCase::RemoveFile()
void FileFunctionsTestCase::DoRemoveFile(const wxString& filePath)
{
const std::string msg = wxString::Format("File: %s", filePath).ToStdString();
INFO("File: " << filePath);
// Create temporary file.
wxTextFile file;
CPPUNIT_ASSERT_MESSAGE( msg, file.Create(filePath) );
CPPUNIT_ASSERT_MESSAGE( msg, file.Close() );
REQUIRE( file.Create(filePath) );
CHECK( file.Close() );
CPPUNIT_ASSERT_MESSAGE( msg, file.Exists() );
CPPUNIT_ASSERT_MESSAGE( msg, wxRemoveFile(filePath) );
CPPUNIT_ASSERT_MESSAGE( msg, !file.Exists() );
CHECK( file.Exists() );
CHECK( wxRemoveFile(filePath) );
CHECK( !file.Exists() );
}
void FileFunctionsTestCase::RenameFile()
TEST_CASE_METHOD(FileFunctionsTestCase,
"FileFunctions::RenameFile",
"[filefn]")
{
// Verify renaming file with/without overwriting
// when new file already exist/don't exist.
@ -337,23 +308,21 @@ FileFunctionsTestCase::DoRenameFile(const wxString& oldFilePath,
bool overwrite,
bool withNew)
{
const std::string msg =
wxString::Format(wxT("File 1: %s File 2:%s"), oldFilePath, newFilePath)
.ToStdString();
INFO("File 1:" << oldFilePath << " File 2: " << newFilePath);
// Create temporary source file.
wxTextFile file;
CPPUNIT_ASSERT_MESSAGE( msg, file.Create(oldFilePath) );
CPPUNIT_ASSERT_MESSAGE( msg, file.Close() );
REQUIRE( file.Create(oldFilePath) );
CHECK( file.Close() );
if ( withNew )
{
// Create destination file to test overwriting.
wxTextFile file2;
CPPUNIT_ASSERT_MESSAGE( msg, file2.Create(newFilePath) );
CPPUNIT_ASSERT_MESSAGE( msg, file2.Close() );
REQUIRE( file2.Create(newFilePath) );
CHECK( file2.Close() );
CPPUNIT_ASSERT_MESSAGE( msg, wxFileExists(newFilePath) );
CHECK( wxFileExists(newFilePath) );
}
else
{
@ -363,36 +332,38 @@ FileFunctionsTestCase::DoRenameFile(const wxString& oldFilePath,
wxRemoveFile(newFilePath);
}
CPPUNIT_ASSERT_MESSAGE( msg, !wxFileExists(newFilePath) );
CHECK( !wxFileExists(newFilePath) );
}
CPPUNIT_ASSERT_MESSAGE( msg, wxFileExists(oldFilePath) );
CPPUNIT_ASSERT_MESSAGE( msg, wxFileExists(oldFilePath) );
CPPUNIT_ASSERT_MESSAGE( msg, wxFileExists(oldFilePath) );
CHECK( wxFileExists(oldFilePath) );
CHECK( wxFileExists(oldFilePath) );
CHECK( wxFileExists(oldFilePath) );
bool shouldFail = !overwrite && withNew;
if ( shouldFail )
{
CPPUNIT_ASSERT_MESSAGE( msg, !wxRenameFile(oldFilePath, newFilePath, overwrite));
CHECK( !wxRenameFile(oldFilePath, newFilePath, overwrite));
// Verify that file has not been renamed.
CPPUNIT_ASSERT_MESSAGE( msg, wxFileExists(oldFilePath) );
CPPUNIT_ASSERT_MESSAGE( msg, wxFileExists(newFilePath) );
CHECK( wxFileExists(oldFilePath) );
CHECK( wxFileExists(newFilePath) );
// Cleanup.
wxRemoveFile(oldFilePath);
}
else
{
CPPUNIT_ASSERT_MESSAGE( msg, wxRenameFile(oldFilePath, newFilePath, overwrite) );
CHECK( wxRenameFile(oldFilePath, newFilePath, overwrite) );
// Verify that file has been renamed.
CPPUNIT_ASSERT_MESSAGE( msg, !wxFileExists(oldFilePath) );
CPPUNIT_ASSERT_MESSAGE( msg, wxFileExists(newFilePath) );
CHECK( !wxFileExists(oldFilePath) );
CHECK( wxFileExists(newFilePath) );
}
// Cleanup.
wxRemoveFile(newFilePath);
}
void FileFunctionsTestCase::ConcatenateFiles()
TEST_CASE_METHOD(FileFunctionsTestCase,
"FileFunctions::ConcatenateFiles",
"[filefn]")
{
#if wxUSE_UNICODE
DoConcatFile(m_fileNameASCII, m_fileNameNonASCII, m_fileNameWork);
@ -404,169 +375,166 @@ void FileFunctionsTestCase::DoConcatFile(const wxString& filePath1,
const wxString& filePath2,
const wxString& destFilePath)
{
const std::string msg =
wxString::Format("File 1: %s File 2:%s File 3: %s",
filePath1, filePath2, destFilePath)
.ToStdString();
INFO("File 1:" << filePath1
<< " File 2: " << filePath2
<< " File 3: " << destFilePath);
// Prepare source data
wxFFile f1(filePath1, wxT("wb")),
f2(filePath2, wxT("wb"));
CPPUNIT_ASSERT_MESSAGE( msg, f1.IsOpened() );
CPPUNIT_ASSERT_MESSAGE( msg, f2.IsOpened() );
REQUIRE( f1.IsOpened() );
REQUIRE( f2.IsOpened() );
wxString s1(wxT("1234567890"));
wxString s2(wxT("abcdefghij"));
CPPUNIT_ASSERT_MESSAGE( msg, f1.Write(s1) );
CPPUNIT_ASSERT_MESSAGE( msg, f2.Write(s2) );
CHECK( f1.Write(s1) );
CHECK( f2.Write(s2) );
CPPUNIT_ASSERT_MESSAGE( msg, f1.Close() );
CPPUNIT_ASSERT_MESSAGE( msg, f2.Close() );
CHECK( f1.Close() );
CHECK( f2.Close() );
// Concatenate source files
CPPUNIT_ASSERT_MESSAGE( msg, wxConcatFiles(filePath1, filePath2, destFilePath) );
CHECK( wxConcatFiles(filePath1, filePath2, destFilePath) );
// Verify content of destination file
CPPUNIT_ASSERT_MESSAGE( msg, wxFileExists(destFilePath) );
REQUIRE( wxFileExists(destFilePath) );
wxString sSrc = s1 + s2;
wxString s3;
wxFFile f3(destFilePath, wxT("rb"));
CPPUNIT_ASSERT_MESSAGE( msg, f3.ReadAll(&s3) );
CPPUNIT_ASSERT_MESSAGE( msg, sSrc.length() == s3.length() );
CPPUNIT_ASSERT_MESSAGE( msg, memcmp(sSrc.c_str(), s3.c_str(), sSrc.length()) == 0 );
CPPUNIT_ASSERT_MESSAGE( msg, f3.Close() );
CHECK( f3.ReadAll(&s3) );
CHECK( sSrc.length() == s3.length() );
CHECK( memcmp(sSrc.c_str(), s3.c_str(), sSrc.length()) == 0 );
CHECK( f3.Close() );
CPPUNIT_ASSERT_MESSAGE( msg, wxRemoveFile(filePath1) );
CPPUNIT_ASSERT_MESSAGE( msg, wxRemoveFile(filePath2) );
CPPUNIT_ASSERT_MESSAGE( msg, wxRemoveFile(destFilePath) );
CHECK( wxRemoveFile(filePath1) );
CHECK( wxRemoveFile(filePath2) );
CHECK( wxRemoveFile(destFilePath) );
}
void FileFunctionsTestCase::GetCwd()
TEST_CASE_METHOD(FileFunctionsTestCase,
"FileFunctions::GetCwd",
"[filefn]")
{
// Verify that obtained working directory is not empty.
wxString cwd = wxGetCwd();
CPPUNIT_ASSERT( !cwd.IsEmpty() );
CHECK( !cwd.IsEmpty() );
}
void FileFunctionsTestCase::FileEof()
TEST_CASE_METHOD(FileFunctionsTestCase,
"FileFunctions::Eof",
"[filefn]")
{
const wxString filename(wxT("horse.bmp"));
const std::string msg = wxString::Format("File: %s", filename).ToStdString();
INFO("File: " << filename);
wxFFile file(filename, wxT("r"));
// wxFFile::Eof must be false at start
CPPUNIT_ASSERT_MESSAGE( msg, !file.Eof() );
CPPUNIT_ASSERT_MESSAGE( msg, file.SeekEnd() );
CHECK( !file.Eof() );
CHECK( file.SeekEnd() );
// wxFFile::Eof returns true only after attempt to read last byte
char array[1];
CPPUNIT_ASSERT_MESSAGE( msg, file.Read(array, 1) == 0 );
CPPUNIT_ASSERT_MESSAGE( msg, file.Eof() );
CHECK( file.Read(array, 1) == 0 );
CHECK( file.Eof() );
CPPUNIT_ASSERT_MESSAGE( msg, file.Close() );
CHECK( file.Close() );
// wxFFile::Eof after close should not cause crash but fail instead
bool failed = true;
try
{
file.Eof();
failed = false;
}
catch (...)
{
}
CPPUNIT_ASSERT_MESSAGE( msg, failed );
WX_ASSERT_FAILS_WITH_ASSERT( file.Eof() );
}
void FileFunctionsTestCase::FileError()
TEST_CASE_METHOD(FileFunctionsTestCase,
"FileFunctions::Error",
"[filefn]")
{
const wxString filename(wxT("horse.bmp"));
const std::string msg = wxString::Format("File: %s", filename).ToStdString();
INFO("File: " << filename);
wxFFile file(filename, wxT("r"));
// wxFFile::Error must be false at start assuming file "horse.bmp" exists.
CPPUNIT_ASSERT_MESSAGE( msg, !file.Error() );
CHECK( !file.Error() );
// Attempt to write to file opened in readonly mode should cause error
CPPUNIT_ASSERT_MESSAGE( msg, !file.Write(filename) );
CPPUNIT_ASSERT_MESSAGE( msg, file.Error() );
CHECK( !file.Write(filename) );
CHECK( file.Error() );
CPPUNIT_ASSERT_MESSAGE( msg, file.Close() );
CHECK( file.Close() );
// wxFFile::Error after close should not cause crash but fail instead
bool failed = true;
try
{
file.Error();
failed = false;
}
catch (...)
{
}
CPPUNIT_ASSERT_MESSAGE( msg, failed );
WX_ASSERT_FAILS_WITH_ASSERT( file.Error() );
}
void FileFunctionsTestCase::DirExists()
TEST_CASE_METHOD(FileFunctionsTestCase,
"FileFunctions::DirExists",
"[filefn]")
{
wxString cwd = wxGetCwd();
const std::string msg = wxString::Format("CWD: %s", cwd).ToStdString();
INFO("CWD: " << cwd);
// Current working directory must exist
CPPUNIT_ASSERT_MESSAGE( msg, wxDirExists(cwd));
CHECK(wxDirExists(cwd));
}
void FileFunctionsTestCase::IsAbsolutePath()
TEST_CASE_METHOD(FileFunctionsTestCase,
"FileFunctions::IsAbsolutePath",
"[filefn]")
{
wxString name = wxT("horse.bmp");
const std::string msg = wxString::Format("File: %s", name).ToStdString();
INFO("File: " << name);
// File name is given as relative path
CPPUNIT_ASSERT_MESSAGE( msg, !wxIsAbsolutePath(name) );
CHECK( !wxIsAbsolutePath(name) );
wxFileName filename(name);
CPPUNIT_ASSERT( filename.MakeAbsolute() );
CHECK( filename.MakeAbsolute() );
// wxFileName::GetFullPath returns absolute path
CPPUNIT_ASSERT_MESSAGE( msg, wxIsAbsolutePath(filename.GetFullPath()));
CHECK( wxIsAbsolutePath(filename.GetFullPath()));
#ifdef __WINDOWS__
CPPUNIT_ASSERT( wxIsAbsolutePath("\\"));
CPPUNIT_ASSERT( wxIsAbsolutePath("c:"));
CPPUNIT_ASSERT( !wxIsAbsolutePath("c"));
CHECK( wxIsAbsolutePath("\\"));
CHECK( wxIsAbsolutePath("c:"));
CHECK( !wxIsAbsolutePath("c"));
#endif
}
void FileFunctionsTestCase::PathOnly()
TEST_CASE_METHOD(FileFunctionsTestCase,
"FileFunctions::PathOnly",
"[filefn]")
{
wxString name = wxT("horse.bmp");
// Get absolute path to horse.bmp
wxFileName filename(name);
CPPUNIT_ASSERT( filename.MakeAbsolute() );
CHECK( filename.MakeAbsolute() );
wxString pathOnly = wxPathOnly(filename.GetFullPath());
if ( !wxDirExists(pathOnly) )
CPPUNIT_ASSERT( pathOnly == wxString() );
CHECK( pathOnly == wxString() );
}
// Unit tests for Mkdir and Rmdir doesn't cover non-ASCII directory names.
// Rmdir fails on them on Linux. See ticket #17644.
void FileFunctionsTestCase::Mkdir()
TEST_CASE_METHOD(FileFunctionsTestCase,
"FileFunctions::Mkdir",
"[filefn]")
{
#if wxUSE_UNICODE
wxString dirname = wxString::FromUTF8("__wxMkdir_test_dir_with_\xc3\xb6");
const std::string msg = wxString::Format("Dir: %s", dirname).ToStdString();
CPPUNIT_ASSERT_MESSAGE( msg, wxMkdir(dirname) );
CPPUNIT_ASSERT_MESSAGE( msg, wxDirExists(dirname) );
CPPUNIT_ASSERT_MESSAGE( msg, wxRmdir(dirname) );
INFO("Dir: " << dirname);
CHECK( wxMkdir(dirname) );
CHECK( wxDirExists(dirname) );
CHECK( wxRmdir(dirname) );
#endif // wxUSE_UNICODE
}
void FileFunctionsTestCase::Rmdir()
TEST_CASE_METHOD(FileFunctionsTestCase,
"FileFunctions::Rmdir",
"[filefn]")
{
#if wxUSE_UNICODE
wxString dirname = wxString::FromUTF8("__wxRmdir_test_dir_with_\xc3\xb6");
const std::string msg = wxString::Format("Dir: %s", dirname).ToStdString();
INFO("Dir: " << dirname);
CPPUNIT_ASSERT_MESSAGE( msg, wxMkdir(dirname) );
CPPUNIT_ASSERT_MESSAGE( msg, wxRmdir(dirname) );
CPPUNIT_ASSERT_MESSAGE( msg, !wxDirExists(dirname) );
CHECK( wxMkdir(dirname) );
CHECK( wxRmdir(dirname) );
CHECK( !wxDirExists(dirname) );
#endif // wxUSE_UNICODE
}

514
tests/filename/filenametest.cpp
View File

@ -114,84 +114,17 @@ static struct TestFileNameInfo
};
// ----------------------------------------------------------------------------
// test class
// tests
// ----------------------------------------------------------------------------
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 );
CPPUNIT_TEST( TestRelative );
CPPUNIT_TEST( TestReplace );
CPPUNIT_TEST( TestGetHumanReadable );
#ifdef __WINDOWS__
CPPUNIT_TEST( TestShortLongPath );
#endif // __WINDOWS__
CPPUNIT_TEST( TestUNC );
CPPUNIT_TEST( TestVolumeUniqueName );
CPPUNIT_TEST( TestCreateTempFileName );
CPPUNIT_TEST( TestGetTimes );
CPPUNIT_TEST( TestSetTimes );
CPPUNIT_TEST( TestExists );
CPPUNIT_TEST( TestIsSame );
#if defined(__UNIX__)
CPPUNIT_TEST( TestSymlinks );
#endif // __UNIX__
#ifdef __WINDOWS__
CPPUNIT_TEST( TestShortcuts );
#endif // __WINDOWS__
CPPUNIT_TEST_SUITE_END();
void TestConstruction();
void TestComparison();
void TestSplit();
void TestSetPath();
void TestStrip();
void TestRelative();
void TestNormalize();
void TestReplace();
void TestGetHumanReadable();
#ifdef __WINDOWS__
void TestShortLongPath();
#endif // __WINDOWS__
void TestUNC();
void TestVolumeUniqueName();
void TestCreateTempFileName();
void TestGetTimes();
void TestSetTimes();
void TestExists();
void TestIsSame();
#if defined(__UNIX__)
void TestSymlinks();
#endif // __UNIX__
#ifdef __WINDOWS__
void TestShortcuts();
#endif // __WINDOWS__
wxDECLARE_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 its own registry so that these tests can be run alone
CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( FileNameTestCase, "FileNameTestCase" );
void FileNameTestCase::TestConstruction()
TEST_CASE("wxFileName::Construction", "[filename]")
{
for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
{
const TestFileNameInfo& fni = filenames[n];
INFO("Test #" << n << ": \"" << fni.fullname << "\"");
wxFileName fn(fni.fullname, fni.format);
// the original full name could contain consecutive [back]slashes,
@ -223,17 +156,12 @@ void FileNameTestCase::TestConstruction()
fullnameOrig.Replace("//", "/");
wxString fullname = fn.GetFullPath(fni.format);
CPPUNIT_ASSERT_EQUAL( fullnameOrig, fullname );
CHECK( fn.GetFullPath(fni.format) == fullnameOrig );
// 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("Normalize(%s) failed", fni.fullname).mb_str(),
fn.Normalize(wxPATH_NORM_ALL, "/foo/bar/baz", fni.format)
);
CHECK( fn.Normalize(wxPATH_NORM_ALL, "/foo/bar/baz", fni.format) );
if ( *fni.volume && *fni.path )
{
@ -243,10 +171,10 @@ void FileNameTestCase::TestConstruction()
pathWithVolume += wxFileName::GetVolumeSeparator(fni.format);
pathWithVolume += fni.path;
CPPUNIT_ASSERT_EQUAL( wxFileName(pathWithVolume,
fni.name,
fni.ext,
fni.format), fn );
CHECK( wxFileName(pathWithVolume,
fni.name,
fni.ext,
fni.format) == fn );
}
}
@ -254,31 +182,31 @@ void FileNameTestCase::TestConstruction()
// empty strings
fn.AssignDir(wxEmptyString);
CPPUNIT_ASSERT( !fn.IsOk() );
CHECK( !fn.IsOk() );
fn.Assign(wxEmptyString);
CPPUNIT_ASSERT( !fn.IsOk() );
CHECK( !fn.IsOk() );
fn.Assign(wxEmptyString, wxEmptyString);
CPPUNIT_ASSERT( !fn.IsOk() );
CHECK( !fn.IsOk() );
fn.Assign(wxEmptyString, wxEmptyString, wxEmptyString);
CPPUNIT_ASSERT( !fn.IsOk() );
CHECK( !fn.IsOk() );
fn.Assign(wxEmptyString, wxEmptyString, wxEmptyString, wxEmptyString);
CPPUNIT_ASSERT( !fn.IsOk() );
CHECK( !fn.IsOk() );
}
void FileNameTestCase::TestComparison()
TEST_CASE("wxFileName::Comparison", "[filename]")
{
wxFileName fn1(wxT("/tmp/file1"));
wxFileName fn2(wxT("/tmp/dir2/../file2"));
fn1.Normalize();
fn2.Normalize();
CPPUNIT_ASSERT_EQUAL(fn1.GetPath(), fn2.GetPath());
CHECK(fn1.GetPath() == fn2.GetPath());
}
void FileNameTestCase::TestSplit()
TEST_CASE("wxFileName::Split", "[filename]")
{
for ( size_t n = 0; n < WXSIZEOF(filenames); n++ )
{
@ -287,29 +215,29 @@ void FileNameTestCase::TestSplit()
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 );
CHECK( volume == fni.volume );
CHECK( path == fni.path );
CHECK( name == fni.name );
CHECK( ext == fni.ext );
}
// special case of empty extension
wxFileName fn("foo.");
CPPUNIT_ASSERT_EQUAL( wxString("foo."), fn.GetFullPath() );
CHECK( fn.GetFullPath() == "foo." );
}
void FileNameTestCase::TestSetPath()
TEST_CASE("wxFileName::SetPath", "[filename]")
{
wxFileName fn("d:\\test\\foo.bar", wxPATH_DOS);
fn.SetPath("c:\\temp", wxPATH_DOS);
CPPUNIT_ASSERT( fn.SameAs(wxFileName("c:\\temp\\foo.bar", wxPATH_DOS)) );
CHECK( fn.SameAs(wxFileName("c:\\temp\\foo.bar", wxPATH_DOS)) );
fn = wxFileName("/usr/bin/ls", wxPATH_UNIX);
fn.SetPath("/usr/local/bin", wxPATH_UNIX);
CPPUNIT_ASSERT( fn.SameAs(wxFileName("/usr/local/bin/ls", wxPATH_UNIX)) );
CHECK( fn.SameAs(wxFileName("/usr/local/bin/ls", wxPATH_UNIX)) );
}
void FileNameTestCase::TestNormalize()
TEST_CASE("wxFileName::Normalize", "[filename]")
{
// prepare some data to be used later
wxString sep = wxFileName::GetPathSeparator();
@ -434,32 +362,32 @@ void FileNameTestCase::TestNormalize()
!shortNamesDisabled )
{
wxFileName fn("..\\MKINST~1");
CPPUNIT_ASSERT( fn.Normalize(wxPATH_NORM_LONG, cwd) );
CPPUNIT_ASSERT_EQUAL( "..\\mkinstalldirs", fn.GetFullPath() );
CHECK( fn.Normalize(wxPATH_NORM_LONG, cwd) );
CHECK( fn.GetFullPath() == "..\\mkinstalldirs" );
}
//else: when in doubt, don't run the test
#endif // __WINDOWS__
}
void FileNameTestCase::TestRelative()
TEST_CASE("wxFileName::Relative", "[filename]")
{
const wxString pathSep = wxFileName::GetPathSeparator();
wxFileName fn("a" + pathSep + "b.cpp");
fn.MakeRelativeTo("a");
CPPUNIT_ASSERT_EQUAL( "b.cpp", fn.GetFullPath() );
CHECK( fn.GetFullPath() == "b.cpp" );
fn.AssignDir("a" + pathSep + "b");
fn.MakeRelativeTo("a");
CPPUNIT_ASSERT_EQUAL( "b" + pathSep, fn.GetFullPath() );
CHECK( fn.GetFullPath() == "b" + pathSep );
fn.AssignDir("a");
fn.MakeRelativeTo("a");
CPPUNIT_ASSERT_EQUAL( "." + pathSep, fn.GetFullPath() );
CHECK( fn.GetFullPath() == "." + pathSep );
}
void FileNameTestCase::TestReplace()
TEST_CASE("wxFileName::Replace", "[filename]")
{
static const struct FileNameTest
{
@ -528,11 +456,10 @@ void FileNameTestCase::TestReplace()
fn.ReplaceHomeDir()
);
CPPUNIT_ASSERT_EQUAL( wxString("~/test1/test2/test3/some file"),
fn.GetFullPath(wxPATH_UNIX) );
CHECK( fn.GetFullPath(wxPATH_UNIX) == "~/test1/test2/test3/some file" );
}
void FileNameTestCase::TestGetHumanReadable()
TEST_CASE("wxFileName::GetHumanReadable", "[filename]")
{
static const struct TestData
{
@ -560,74 +487,69 @@ void FileNameTestCase::TestGetHumanReadable()
// take care of using the decimal point for the current locale before
// the actual comparison
CPPUNIT_ASSERT_EQUAL
CHECK
(
td.result,
wxFileName::GetHumanReadableSize(td.size, "NA", td.prec, td.conv)
==
td.result
);
}
// also test the default convention value
CPPUNIT_ASSERT_EQUAL( "1.4 MB", wxFileName::GetHumanReadableSize(1512993, "") );
CHECK( wxFileName::GetHumanReadableSize(1512993, "") == "1.4 MB" );
}
void FileNameTestCase::TestStrip()
TEST_CASE("wxFileName::Strip", "[filename]")
{
CPPUNIT_ASSERT_EQUAL( "", wxFileName::StripExtension("") );
CPPUNIT_ASSERT_EQUAL( ".", wxFileName::StripExtension(".") );
CPPUNIT_ASSERT_EQUAL( ".vimrc", wxFileName::StripExtension(".vimrc") );
CPPUNIT_ASSERT_EQUAL( "bad", wxFileName::StripExtension("bad") );
CPPUNIT_ASSERT_EQUAL( "good", wxFileName::StripExtension("good.wav") );
CPPUNIT_ASSERT_EQUAL( "good.wav", wxFileName::StripExtension("good.wav.wav") );
CHECK( wxFileName::StripExtension("") == "" );
CHECK( wxFileName::StripExtension(".") == "." );
CHECK( wxFileName::StripExtension(".vimrc") == ".vimrc" );
CHECK( wxFileName::StripExtension("bad") == "bad" );
CHECK( wxFileName::StripExtension("good.wav") == "good" );
CHECK( wxFileName::StripExtension("good.wav.wav") == "good.wav" );
}
#ifdef __WINDOWS__
void FileNameTestCase::TestShortLongPath()
TEST_CASE("wxFileName::ShortLongPath", "[filename]")
{
wxFileName fn("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() );
CHECK( fn.GetLongPath() == fn.GetLongPath() );
CHECK( fn.GetShortPath() == fn.GetShortPath() );
}
#endif // __WINDOWS__
void FileNameTestCase::TestUNC()
TEST_CASE("wxFileName::UNC", "[filename]")
{
wxFileName fn("//share/path/name.ext", wxPATH_DOS);
CPPUNIT_ASSERT_EQUAL( "share", fn.GetVolume() );
CPPUNIT_ASSERT_EQUAL( "\\path", fn.GetPath(wxPATH_NO_SEPARATOR, wxPATH_DOS) );
CHECK( fn.GetVolume() == "share" );
CHECK( fn.GetPath(wxPATH_NO_SEPARATOR, wxPATH_DOS) == "\\path" );
fn.Assign("\\\\share2\\path2\\name.ext", wxPATH_DOS);
CPPUNIT_ASSERT_EQUAL( "share2", fn.GetVolume() );
CPPUNIT_ASSERT_EQUAL( "\\path2", fn.GetPath(wxPATH_NO_SEPARATOR, wxPATH_DOS) );
CHECK( fn.GetVolume() == "share2" );
CHECK( fn.GetPath(wxPATH_NO_SEPARATOR, wxPATH_DOS) == "\\path2" );
}
void FileNameTestCase::TestVolumeUniqueName()
TEST_CASE("wxFileName::VolumeUniqueName", "[filename]")
{
wxFileName fn("\\\\?\\Volume{8089d7d7-d0ac-11db-9dd0-806d6172696f}\\",
wxPATH_DOS);
CPPUNIT_ASSERT_EQUAL( "Volume{8089d7d7-d0ac-11db-9dd0-806d6172696f}",
fn.GetVolume() );
CPPUNIT_ASSERT_EQUAL( "\\", fn.GetPath(wxPATH_NO_SEPARATOR, wxPATH_DOS) );
CPPUNIT_ASSERT_EQUAL( "\\\\?\\Volume{8089d7d7-d0ac-11db-9dd0-806d6172696f}\\",
fn.GetFullPath(wxPATH_DOS) );
CHECK( fn.GetVolume() == "Volume{8089d7d7-d0ac-11db-9dd0-806d6172696f}" );
CHECK( fn.GetPath(wxPATH_NO_SEPARATOR, wxPATH_DOS) == "\\" );
CHECK( fn.GetFullPath(wxPATH_DOS) == "\\\\?\\Volume{8089d7d7-d0ac-11db-9dd0-806d6172696f}\\" );
fn.Assign("\\\\?\\Volume{8089d7d7-d0ac-11db-9dd0-806d6172696f}\\"
"Program Files\\setup.exe", wxPATH_DOS);
CPPUNIT_ASSERT_EQUAL( "Volume{8089d7d7-d0ac-11db-9dd0-806d6172696f}",
fn.GetVolume() );
CPPUNIT_ASSERT_EQUAL( "\\Program Files",
fn.GetPath(wxPATH_NO_SEPARATOR, wxPATH_DOS) );
CPPUNIT_ASSERT_EQUAL( "\\\\?\\Volume{8089d7d7-d0ac-11db-9dd0-806d6172696f}\\"
"Program Files\\setup.exe",
fn.GetFullPath(wxPATH_DOS) );
CHECK( fn.GetVolume() == "Volume{8089d7d7-d0ac-11db-9dd0-806d6172696f}" );
CHECK( fn.GetPath(wxPATH_NO_SEPARATOR, wxPATH_DOS) == "\\Program Files" );
CHECK( fn.GetFullPath(wxPATH_DOS) == "\\\\?\\Volume{8089d7d7-d0ac-11db-9dd0-806d6172696f}\\Program Files\\setup.exe" );
}
void FileNameTestCase::TestCreateTempFileName()
TEST_CASE("wxFileName::CreateTempFileName", "[filename]")
{
static const struct TestData
{
@ -655,106 +577,106 @@ void FileNameTestCase::TestCreateTempFileName()
wxString prefix = testData[n].prefix;
prefix.Replace("$USER_DOCS_DIR", wxStandardPaths::Get().GetDocumentsDir());
std::string errDesc = wxString::Format("failed on prefix '%s'", prefix).ToStdString();
INFO("Prefix: " << prefix);
wxString path = wxFileName::CreateTempFileName(prefix);
CPPUNIT_ASSERT_EQUAL_MESSAGE( errDesc, !testData[n].shouldSucceed, path.empty() );
CHECK( path.empty() == !testData[n].shouldSucceed );
if (testData[n].shouldSucceed)
{
errDesc += "; path is " + path.ToStdString();
INFO("Path: " << path);
// test the place where the temp file has been created
wxString expected = testData[n].expectedFolder;
expected.Replace("$SYSTEM_TEMP", wxStandardPaths::Get().GetTempDir());
expected.Replace("$USER_DOCS_DIR", wxStandardPaths::Get().GetDocumentsDir());
CPPUNIT_ASSERT_EQUAL_MESSAGE( errDesc, expected, wxFileName(path).GetPath() );
CHECK( wxFileName(path).GetPath() == expected );
// the temporary file is created with full permissions for the current process
// so we should always be able to remove it:
CPPUNIT_ASSERT_MESSAGE( errDesc, wxRemoveFile(path) );
CHECK( wxRemoveFile(path) );
}
}
}
void FileNameTestCase::TestGetTimes()
TEST_CASE("wxFileName::GetTimes", "[filename]")
{
wxFileName fn(wxFileName::CreateTempFileName("filenametest"));
CPPUNIT_ASSERT( fn.IsOk() );
REQUIRE( fn.IsOk() );
wxON_BLOCK_EXIT1( wxRemoveFile, fn.GetFullPath() );
wxDateTime dtAccess, dtMod, dtCreate;
CPPUNIT_ASSERT( fn.GetTimes(&dtAccess, &dtMod, &dtCreate) );
REQUIRE( fn.GetTimes(&dtAccess, &dtMod, &dtCreate) );
// make sure all retrieved dates are equal to the current date&time
// with an accuracy up to 1 minute
CPPUNIT_ASSERT(dtCreate.IsEqualUpTo(wxDateTime::Now(), wxTimeSpan(0,1)));
CPPUNIT_ASSERT(dtMod.IsEqualUpTo(wxDateTime::Now(), wxTimeSpan(0,1)));
CPPUNIT_ASSERT(dtAccess.IsEqualUpTo(wxDateTime::Now(), wxTimeSpan(0,1)));
CHECK(dtCreate.IsEqualUpTo(wxDateTime::Now(), wxTimeSpan(0,1)));
CHECK(dtMod.IsEqualUpTo(wxDateTime::Now(), wxTimeSpan(0,1)));
CHECK(dtAccess.IsEqualUpTo(wxDateTime::Now(), wxTimeSpan(0,1)));
}
void FileNameTestCase::TestSetTimes()
TEST_CASE("wxFileName::SetTimes", "[filename]")
{
wxFileName fn(wxFileName::CreateTempFileName("filenametest"));
CPPUNIT_ASSERT( fn.IsOk() );
REQUIRE( fn.IsOk() );
wxON_BLOCK_EXIT1( wxRemoveFile, fn.GetFullPath() );
const wxDateTime dtAccess(1, wxDateTime::Jan, 2013);
const wxDateTime dtModify(1, wxDateTime::Feb, 2013);
const wxDateTime dtCreate(1, wxDateTime::Mar, 2013);
CPPUNIT_ASSERT( fn.SetTimes(&dtAccess, &dtModify, &dtCreate) );
REQUIRE( fn.SetTimes(&dtAccess, &dtModify, &dtCreate) );
wxDateTime dtAccess2,
dtModify2,
dtCreate2;
CPPUNIT_ASSERT( fn.GetTimes(&dtAccess2, &dtModify2, &dtCreate2) );
CPPUNIT_ASSERT_EQUAL( dtAccess, dtAccess2 );
CPPUNIT_ASSERT_EQUAL( dtModify, dtModify2 );
REQUIRE( fn.GetTimes(&dtAccess2, &dtModify2, &dtCreate2) );
CHECK( dtAccess2 == dtAccess );
CHECK( dtModify2 == dtModify );
// Under Unix the creation time can't be set.
#ifdef __WINDOWS__
CPPUNIT_ASSERT_EQUAL( dtCreate, dtCreate2 );
CHECK( dtCreate2 == dtCreate );
#endif // __WINDOWS__
}
void FileNameTestCase::TestExists()
TEST_CASE("wxFileName::Exists", "[filename]")
{
wxFileName fn(wxFileName::CreateTempFileName("filenametest"));
CPPUNIT_ASSERT( fn.IsOk() );
REQUIRE( fn.IsOk() );
wxON_BLOCK_EXIT1( wxRemoveFile, fn.GetFullPath() );
CPPUNIT_ASSERT( fn.FileExists() );
CPPUNIT_ASSERT( !wxFileName::DirExists(fn.GetFullPath()) );
CHECK( fn.FileExists() );
CHECK( !wxFileName::DirExists(fn.GetFullPath()) );
CPPUNIT_ASSERT( fn.Exists(wxFILE_EXISTS_REGULAR) );
CPPUNIT_ASSERT( !fn.Exists(wxFILE_EXISTS_DIR) );
CPPUNIT_ASSERT( fn.Exists() );
CHECK( fn.Exists(wxFILE_EXISTS_REGULAR) );
CHECK( !fn.Exists(wxFILE_EXISTS_DIR) );
CHECK( fn.Exists() );
const wxString& tempdir = wxFileName::GetTempDir();
wxFileName fileInTempDir(tempdir, "bloordyblop");
CPPUNIT_ASSERT( !fileInTempDir.Exists() );
CPPUNIT_ASSERT( fileInTempDir.DirExists() );
CHECK( !fileInTempDir.Exists() );
CHECK( fileInTempDir.DirExists() );
wxFileName dirTemp(wxFileName::DirName(tempdir));
CPPUNIT_ASSERT( !dirTemp.FileExists() );
CPPUNIT_ASSERT( dirTemp.DirExists() );
CHECK( !dirTemp.FileExists() );
CHECK( dirTemp.DirExists() );
CPPUNIT_ASSERT( dirTemp.Exists(wxFILE_EXISTS_DIR) );
CPPUNIT_ASSERT( !dirTemp.Exists(wxFILE_EXISTS_REGULAR) );
CPPUNIT_ASSERT( dirTemp.Exists() );
CHECK( dirTemp.Exists(wxFILE_EXISTS_DIR) );
CHECK( !dirTemp.Exists(wxFILE_EXISTS_REGULAR) );
CHECK( dirTemp.Exists() );
#ifdef __UNIX__
CPPUNIT_ASSERT( !wxFileName::FileExists("/dev/null") );
CPPUNIT_ASSERT( !wxFileName::DirExists("/dev/null") );
CPPUNIT_ASSERT( wxFileName::Exists("/dev/null") );
CPPUNIT_ASSERT( wxFileName::Exists("/dev/null", wxFILE_EXISTS_DEVICE) );
CHECK( !wxFileName::FileExists("/dev/null") );
CHECK( !wxFileName::DirExists("/dev/null") );
CHECK( wxFileName::Exists("/dev/null") );
CHECK( wxFileName::Exists("/dev/null", wxFILE_EXISTS_DEVICE) );
#ifdef __LINUX__
// These files are only guaranteed to exist under Linux.
// No need for wxFILE_EXISTS_NO_FOLLOW here; wxFILE_EXISTS_SYMLINK implies it
CPPUNIT_ASSERT( wxFileName::Exists("/proc/self", wxFILE_EXISTS_SYMLINK) );
CPPUNIT_ASSERT( wxFileName::Exists("/dev/log", wxFILE_EXISTS_SOCKET) );
CHECK( wxFileName::Exists("/proc/self", wxFILE_EXISTS_SYMLINK) );
CHECK( wxFileName::Exists("/dev/log", wxFILE_EXISTS_SOCKET) );
#endif // __LINUX__
#ifndef __VMS
wxString fifo = dirTemp.GetPath() + "/fifo";
@ -762,24 +684,24 @@ void FileNameTestCase::TestExists()
{
wxON_BLOCK_EXIT1(wxRemoveFile, fifo);
CPPUNIT_ASSERT( wxFileName::Exists(fifo, wxFILE_EXISTS_FIFO) );
CHECK( wxFileName::Exists(fifo, wxFILE_EXISTS_FIFO) );
}
#endif
#endif // __UNIX__
}
void FileNameTestCase::TestIsSame()
TEST_CASE("wxFileName::SameAs", "[filename]")
{
wxFileName fn1( wxFileName::CreateTempFileName( "filenametest1" ) );
CPPUNIT_ASSERT( fn1.IsOk() );
REQUIRE( fn1.IsOk() );
wxON_BLOCK_EXIT1( wxRemoveFile, fn1.GetFullPath() );
wxFileName fn2( wxFileName::CreateTempFileName( "filenametest2" ) );
CPPUNIT_ASSERT( fn2.IsOk() );
REQUIRE( fn2.IsOk() );
wxON_BLOCK_EXIT1( wxRemoveFile, fn2.GetFullPath() );
CPPUNIT_ASSERT( fn1.SameAs( fn1 ) );
CPPUNIT_ASSERT( !fn1.SameAs( fn2 ) );
CHECK( fn1.SameAs( fn1 ) );
CHECK( !fn1.SameAs( fn2 ) );
#if defined(__UNIX__)
// We need to create a temporary directory and a temporary link.
@ -789,7 +711,7 @@ void FileNameTestCase::TestIsSame()
const wxString tempdir1 = wxString::From8BitData(tn);
free(tn);
CPPUNIT_ASSERT( wxFileName::Mkdir(tempdir1) );
REQUIRE( wxFileName::Mkdir(tempdir1) );
// Unfortunately the casts are needed to select the overload we need here.
wxON_BLOCK_EXIT2( static_cast<bool (*)(const wxString&, int)>(wxFileName::Rmdir),
tempdir1, static_cast<int>(wxPATH_RMDIR_RECURSIVE) );
@ -797,7 +719,7 @@ void FileNameTestCase::TestIsSame()
tn = tempnam(NULL, "wxfn2");
const wxString tempdir2 = wxString::From8BitData(tn);
free(tn);
CPPUNIT_ASSERT_EQUAL( 0, symlink(tempdir1.c_str(), tempdir2.c_str()) );
CHECK( symlink(tempdir1.c_str(), tempdir2.c_str()) == 0 );
wxON_BLOCK_EXIT1( wxRemoveFile, tempdir2 );
@ -805,21 +727,21 @@ void FileNameTestCase::TestIsSame()
wxFileName fn4(tempdir2, "foo");
// These files have different paths, hence are different.
CPPUNIT_ASSERT( !fn3.SameAs(fn4) );
CHECK( !fn3.SameAs(fn4) );
// Create and close a file to trigger creating it.
wxFile(fn3.GetFullPath(), wxFile::write);
// Now that both files do exist we should be able to detect that they are
// actually the same file.
CPPUNIT_ASSERT( fn3.SameAs(fn4) );
CHECK( fn3.SameAs(fn4) );
#endif // __UNIX__
}
#if defined(__UNIX__)
// Tests for functions that are changed by ShouldFollowLink()
void FileNameTestCase::TestSymlinks()
TEST_CASE("wxFileName::Symlinks", "[filename]")
{
const wxString tmpdir(wxStandardPaths::Get().GetTempDir());
@ -836,76 +758,49 @@ void FileNameTestCase::TestSymlinks()
tempdir << wxFileName::GetPathSeparator();
#endif
wxFileName tempdirfn(wxFileName::DirName(tempdir));
CPPUNIT_ASSERT(tempdirfn.DirExists());
CHECK(tempdirfn.DirExists());
// Create a regular file in that dir, to act as a symlink target
wxFileName targetfn(wxFileName::CreateTempFileName(tempdir));
CPPUNIT_ASSERT(targetfn.FileExists());
CHECK(targetfn.FileExists());
// Resolving a non-symlink will just return the same thing
CPPUNIT_ASSERT_EQUAL_MESSAGE
(
"Non-symlink didn't resolve to the same file",
targetfn, targetfn.ResolveLink()
);
INFO("Non-symlink didn't resolve to the same file");
CHECK( targetfn.ResolveLink() == targetfn );
// Create a symlink to that file
wxFileName linktofile(tempdir, "linktofile");
CPPUNIT_ASSERT_EQUAL(0, symlink(targetfn.GetFullPath().c_str(),
linktofile.GetFullPath().c_str()));
CHECK( symlink(targetfn.GetFullPath().c_str(), linktofile.GetFullPath().c_str()) == 0 );
// Test resolving the filename to the symlink
CPPUNIT_ASSERT_EQUAL_MESSAGE
(
"Failed to resolve symlink to file",
targetfn, linktofile.ResolveLink()
);
INFO("Failed to resolve symlink to file");
CHECK( linktofile.ResolveLink() == targetfn );
// Create a relative symlink to that file
wxFileName relativelinktofile(tempdir, "relativelinktofile");
wxString relativeFileName = "./" + targetfn.GetFullName();
CPPUNIT_ASSERT_EQUAL(0, symlink(relativeFileName.c_str(),
relativelinktofile.GetFullPath().c_str()));
CPPUNIT_ASSERT_EQUAL_MESSAGE
(
"Failed to resolve relative symlink to absolute file path",
targetfn, relativelinktofile.ResolveLink()
);
CHECK( symlink(relativeFileName.c_str(), relativelinktofile.GetFullPath().c_str()) == 0 );
INFO("Failed to resolve relative symlink to absolute file path");
CHECK( relativelinktofile.ResolveLink() == targetfn );
// ... and another to the temporary directory
const wxString linktodirName(tempdir + "/linktodir");
wxFileName linktodirfn(linktodirName);
wxFileName linktodir(wxFileName::DirName(linktodirName));
CPPUNIT_ASSERT_EQUAL(0, symlink(tmpfn.GetFullPath().c_str(),
linktodirName.c_str()));
CPPUNIT_ASSERT_EQUAL_MESSAGE
(
"Failed to resolve symlink to directory",
tmpfn, linktodirfn.ResolveLink()
);
CHECK( symlink(tmpfn.GetFullPath().c_str(), linktodirName.c_str()) == 0 );
INFO("Failed to resolve symlink to directory");
CHECK( linktodirfn.ResolveLink() == tmpfn );
// And symlinks to both of those symlinks
wxFileName linktofilelnk(tempdir, "linktofilelnk");
CPPUNIT_ASSERT_EQUAL(0, symlink(linktofile.GetFullPath().c_str(),
linktofilelnk.GetFullPath().c_str()));
CPPUNIT_ASSERT_EQUAL_MESSAGE
(
"Failed to resolve symlink to file symlink",
targetfn, linktofilelnk.ResolveLink()
);
CHECK( symlink(linktofile.GetFullPath().c_str(), linktofilelnk.GetFullPath().c_str()) == 0 );
INFO("Failed to resolve symlink to file symlink");
CHECK( linktofilelnk.ResolveLink() == targetfn );
wxFileName linktodirlnk(tempdir, "linktodirlnk");
CPPUNIT_ASSERT_EQUAL(0, symlink(linktodir.GetFullPath().c_str(),
linktodirlnk.GetFullPath().c_str()));
CPPUNIT_ASSERT_EQUAL_MESSAGE
(
"Failed to resolve symlink to directory symlink",
tmpfn, linktodirlnk.ResolveLink()
);
CHECK( symlink(linktodir.GetFullPath().c_str(), linktodirlnk.GetFullPath().c_str()) == 0 );
INFO("Failed to resolve symlink to directory symlink");
CHECK( linktodirlnk.ResolveLink() == tmpfn );
// Run the tests twice: once in the default symlink following mode and the
// second time without following symlinks.
@ -924,130 +819,77 @@ void FileNameTestCase::TestSymlinks()
}
// Test SameAs()
CPPUNIT_ASSERT_EQUAL_MESSAGE
(
"Comparison with file" + msg,
deref, linktofile.SameAs(targetfn)
);
INFO("Comparison with file" + msg);
CHECK( linktofile.SameAs(targetfn) == deref );
CPPUNIT_ASSERT_EQUAL_MESSAGE
(
"Comparison with directory" + msg,
deref, linktodir.SameAs(tmpfn)
);
INFO("Comparison with directory" + msg);
CHECK( linktodir.SameAs(tmpfn) == deref );
// A link-to-a-link should dereference through to the final target
CPPUNIT_ASSERT_EQUAL_MESSAGE
(
"Comparison with link to a file" + msg,
deref,
linktofilelnk.SameAs(targetfn)
);
CPPUNIT_ASSERT_EQUAL_MESSAGE
(
"Comparison with link to a directory" + msg,
deref,
linktodirlnk.SameAs(tmpfn)
);
INFO("Comparison with link to a file" + msg);
CHECK( linktofilelnk.SameAs(targetfn) == deref );
INFO("Comparison with link to a directory" + msg);
CHECK( linktodirlnk.SameAs(tmpfn) == deref );
// Test GetTimes()
INFO("Getting times of a directory" + msg);
wxDateTime dtAccess, dtMod, dtCreate;
CPPUNIT_ASSERT_MESSAGE
(
"Getting times of a directory" + msg,
linktodir.GetTimes(&dtAccess, &dtMod, &dtCreate)
);
CHECK( linktodir.GetTimes(&dtAccess, &dtMod, &dtCreate) );
// Test (File|Dir)Exists()
CPPUNIT_ASSERT_EQUAL_MESSAGE
(
"Testing file existence" + msg,
deref,
linktofile.FileExists()
);
CPPUNIT_ASSERT_EQUAL_MESSAGE
(
"Testing directory existence" + msg,
deref,
linktodir.DirExists()
);
INFO("Testing file existence" + msg);
CHECK( linktofile.FileExists() == deref );
INFO("Testing directory existence" + msg);
CHECK( linktodir.DirExists() == deref );
// Test wxFileName::Exists
// The wxFILE_EXISTS_NO_FOLLOW flag should override DontFollowLink()
CPPUNIT_ASSERT_EQUAL_MESSAGE
(
"Testing file existence" + msg,
false,
linktofile.Exists(wxFILE_EXISTS_REGULAR | wxFILE_EXISTS_NO_FOLLOW)
);
CPPUNIT_ASSERT_EQUAL_MESSAGE
(
"Testing directory existence" + msg,
false,
linktodir.Exists(wxFILE_EXISTS_DIR | wxFILE_EXISTS_NO_FOLLOW)
);
INFO("Testing file existence" + msg);
CHECK_FALSE( linktofile.Exists(wxFILE_EXISTS_REGULAR | wxFILE_EXISTS_NO_FOLLOW) );
INFO("Testing directory existence" + msg);
CHECK_FALSE( linktodir.Exists(wxFILE_EXISTS_DIR | wxFILE_EXISTS_NO_FOLLOW) );
// and the static versions
CPPUNIT_ASSERT_EQUAL_MESSAGE
(
"Testing file existence" + msg,
false,
wxFileName::Exists(linktofile.GetFullPath(), wxFILE_EXISTS_REGULAR | wxFILE_EXISTS_NO_FOLLOW)
);
CPPUNIT_ASSERT_EQUAL_MESSAGE
(
"Testing file existence" + msg,
true,
wxFileName::Exists(linktofile.GetFullPath(), wxFILE_EXISTS_REGULAR)
);
CPPUNIT_ASSERT_EQUAL_MESSAGE
(
"Testing directory existence" + msg,
false,
wxFileName::Exists(linktodir.GetFullPath(), wxFILE_EXISTS_DIR | wxFILE_EXISTS_NO_FOLLOW)
);
CPPUNIT_ASSERT_EQUAL_MESSAGE
(
"Testing directory existence" + msg,
true,
wxFileName::Exists(linktodir.GetFullPath(), wxFILE_EXISTS_DIR)
);
INFO("Testing file existence" + msg);
CHECK_FALSE( wxFileName::Exists(linktofile.GetFullPath(), wxFILE_EXISTS_REGULAR | wxFILE_EXISTS_NO_FOLLOW) );
CHECK( wxFileName::Exists(linktofile.GetFullPath(), wxFILE_EXISTS_REGULAR) );
INFO("Testing directory existence" + msg);
CHECK_FALSE( wxFileName::Exists(linktodir.GetFullPath(), wxFILE_EXISTS_DIR | wxFILE_EXISTS_NO_FOLLOW) );
CHECK( wxFileName::Exists(linktodir.GetFullPath(), wxFILE_EXISTS_DIR) );
}
// Finally test Exists() after removing the file.
CPPUNIT_ASSERT(wxRemoveFile(targetfn.GetFullPath()));
CHECK(wxRemoveFile(targetfn.GetFullPath()));
// Resolving a file that doesn't exist returns empty
CPPUNIT_ASSERT_EQUAL_MESSAGE
(
"Non-existent file didn't resolve correctly",
wxFileName(), targetfn.ResolveLink()
);
INFO("Non-existent file didn't resolve correctly");
CHECK( targetfn.ResolveLink() == wxFileName() );
// This should succeed, as the symlink still exists and
// the default wxFILE_EXISTS_ANY implies wxFILE_EXISTS_NO_FOLLOW
CPPUNIT_ASSERT(wxFileName(tempdir, "linktofile").Exists());
CHECK(wxFileName(tempdir, "linktofile").Exists());
// So should this one, as wxFILE_EXISTS_SYMLINK does too
CPPUNIT_ASSERT(wxFileName(tempdir, "linktofile").
Exists(wxFILE_EXISTS_SYMLINK));
CHECK(wxFileName(tempdir, "linktofile").Exists(wxFILE_EXISTS_SYMLINK));
// but not this one, as the now broken symlink is followed
CPPUNIT_ASSERT(!wxFileName(tempdir, "linktofile").
Exists(wxFILE_EXISTS_REGULAR));
CPPUNIT_ASSERT(linktofile.Exists());
CHECK(!wxFileName(tempdir, "linktofile").Exists(wxFILE_EXISTS_REGULAR));
CHECK(linktofile.Exists());
// This is also a convenient place to test Rmdir() as we have things to
// remove.
// First, check that removing a symlink to a directory fails.
CPPUNIT_ASSERT( !wxFileName::Rmdir(linktodirName) );
CHECK( !wxFileName::Rmdir(linktodirName) );
// And recursively removing it only removes the symlink itself, not the
// directory.
CPPUNIT_ASSERT( wxFileName::Rmdir(linktodirName, wxPATH_RMDIR_RECURSIVE) );
CPPUNIT_ASSERT( tmpfn.Exists() );
CHECK( wxFileName::Rmdir(linktodirName, wxPATH_RMDIR_RECURSIVE) );
CHECK( tmpfn.Exists() );
// Finally removing the directory itself does remove everything.
CPPUNIT_ASSERT(tempdirfn.Rmdir(wxPATH_RMDIR_RECURSIVE));
CPPUNIT_ASSERT( !tempdirfn.Exists() );
CHECK(tempdirfn.Rmdir(wxPATH_RMDIR_RECURSIVE));
CHECK( !tempdirfn.Exists() );
}
#endif // __UNIX__
@ -1066,29 +908,29 @@ void CreateShortcut(const wxString& pathFile, const wxString& pathLink)
wxCOMPtr<IShellLink> sl;
hr = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
IID_IShellLink, (void **)&sl);
CPPUNIT_ASSERT( SUCCEEDED(hr) );
REQUIRE( SUCCEEDED(hr) );
wxCOMPtr<IPersistFile> pf;
hr = sl->QueryInterface(IID_IPersistFile, (void **)&pf);
CPPUNIT_ASSERT( SUCCEEDED(hr) );
REQUIRE( SUCCEEDED(hr) );
hr = sl->SetPath(pathFile.t_str());
CPPUNIT_ASSERT( SUCCEEDED(hr) );
CHECK( SUCCEEDED(hr) );
hr = pf->Save(pathLink.wc_str(), TRUE);
CPPUNIT_ASSERT( SUCCEEDED(hr) );
CHECK( SUCCEEDED(hr) );
}
} // anonymous namespace
void FileNameTestCase::TestShortcuts()
TEST_CASE("wxFileName::Shortcuts", "[filename]")
{
wxFileName fn(wxFileName::CreateTempFileName("filenametest"));
CPPUNIT_ASSERT( fn.IsOk() );
REQUIRE( fn.IsOk() );
wxON_BLOCK_EXIT1( wxRemoveFile, fn.GetFullPath() );
wxFileName fnLink(fn.GetPath(), "sc_" + fn.GetName(), "lnk");
CPPUNIT_ASSERT( fnLink.IsOk() );
REQUIRE( fnLink.IsOk() );
wxON_BLOCK_EXIT1( wxRemoveFile, fnLink.GetFullPath() );
CreateShortcut(fn.GetFullPath(), fnLink.GetFullPath());
@ -1097,7 +939,7 @@ void FileNameTestCase::TestShortcuts()
// name.
wxFileName fnLinkRel(fnLink);
fnLink.MakeRelativeTo(".");
CPPUNIT_ASSERT_EQUAL(fnLink.GetFullName(), fnLinkRel.GetFullName());
CHECK( fnLinkRel.GetFullName() == fnLink.GetFullName() );
}
#endif // __WINDOWS__