diff -r 000000000000 -r 1918ee327afb tests/auto/qfileinfo/tst_qfileinfo.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tests/auto/qfileinfo/tst_qfileinfo.cpp Mon Jan 11 14:00:40 2010 +0000 @@ -0,0 +1,1383 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the test suite of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + +#include + + +#include +#include +#include +#include +#include +#include +#ifdef Q_OS_UNIX +#include +#include +#include +#endif +#ifdef Q_OS_WIN +#include +#endif +#include +#include +#ifdef Q_OS_SYMBIAN +#include +#include +#endif +#include "../network-settings.h" +#include + +#if defined(Q_OS_SYMBIAN) +# define SRCDIR "" +#endif + +//TESTED_CLASS= +//TESTED_FILES= + +class tst_QFileInfo : public QObject +{ +Q_OBJECT + +public: + tst_QFileInfo(); + ~tst_QFileInfo(); + +private slots: + void getSetCheck(); + + void copy(); + + void isFile_data(); + void isFile(); + + void isDir_data(); + void isDir(); + + void isRoot_data(); + void isRoot(); + + void exists_data(); + void exists(); + + void absolutePath_data(); + void absolutePath(); + + void absFilePath_data(); + void absFilePath(); + + void canonicalPath(); + void canonicalFilePath(); + + void fileName_data(); + void fileName(); + + void bundleName_data(); + void bundleName(); + + void dir_data(); + void dir(); + + void suffix_data(); + void suffix(); + + void completeSuffix_data(); + void completeSuffix(); + + void baseName_data(); + void baseName(); + + void completeBaseName_data(); + void completeBaseName(); + + void permission_data(); + void permission(); + + void size_data(); + void size(); + + void systemFiles(); + + void compare_data(); + void compare(); + + void consistent_data(); + void consistent(); + + void fileTimes_data(); + void fileTimes(); + void fileTimes_oldFile(); + + void isSymLink_data(); + void isSymLink(); + + void isHidden_data(); + void isHidden(); + + void isBundle_data(); + void isBundle(); + + void isLocalFs_data(); + void isLocalFs(); + + void refresh(); + +#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE) + void brokenShortcut(); +#endif + + void isWritable(); + void isExecutable(); + void testDecomposedUnicodeNames_data(); + void testDecomposedUnicodeNames(); + + void equalOperator() const; + void equalOperatorWithDifferentSlashes() const; + void notEqualOperator() const; +}; + +tst_QFileInfo::tst_QFileInfo() +{ +} + +tst_QFileInfo::~tst_QFileInfo() +{ + QFile::remove("brokenlink.lnk"); + QFile::remove("link.lnk"); + QFile::remove("file1"); + QFile::remove("dummyfile"); +#ifdef Q_OS_SYMBIAN + QFile::remove("hidden.txt"); + QFile::remove("nothidden.txt"); +#else + QFile::remove("tempfile.txt"); +#endif + +#if defined(Q_OS_UNIX) && !defined(Q_OS_SYMBIAN) + QDir().rmdir("./.hidden-directory"); +#endif +} + +// Testing get/set functions +void tst_QFileInfo::getSetCheck() +{ + QFileInfo obj1; + // bool QFileInfo::caching() + // void QFileInfo::setCaching(bool) + obj1.setCaching(false); + QCOMPARE(false, obj1.caching()); + obj1.setCaching(true); + QCOMPARE(true, obj1.caching()); +} + +static QFileInfoPrivate* getPrivate(QFileInfo &info) +{ + return (*reinterpret_cast(&info)); +} + +void tst_QFileInfo::copy() +{ + QTemporaryFile *t; + t = new QTemporaryFile; + t->open(); + QFileInfo info(t->fileName()); + QVERIFY(info.exists()); + + //copy constructor + QFileInfo info2(info); + QFileInfoPrivate *privateInfo = getPrivate(info); + QFileInfoPrivate *privateInfo2 = getPrivate(info2); + QCOMPARE(privateInfo->data, privateInfo2->data); + + //operator = + QFileInfo info3 = info; + QFileInfoPrivate *privateInfo3 = getPrivate(info3); + QCOMPARE(privateInfo->data, privateInfo3->data); + QCOMPARE(privateInfo2->data, privateInfo3->data); + + //refreshing info3 will detach it + QFile file(info.absoluteFilePath()); + QVERIFY(file.open(QFile::WriteOnly)); + QCOMPARE(file.write("JAJAJAA"), qint64(7)); + file.flush(); + + QTest::qWait(250); +#if defined(Q_OS_WIN) || defined(Q_OS_WINCE) + if (QSysInfo::windowsVersion() & QSysInfo::WV_VISTA || + QSysInfo::windowsVersion() & QSysInfo::WV_CE_based) + file.close(); +#endif +#if defined(Q_OS_WINCE) + // On Windows CE we need to close the file. + // Otherwise the content will be cached and not + // flushed to the storage, although we flushed it + // manually!!! CE has interim cache, we cannot influence. + QTest::qWait(5000); +#endif + info3.refresh(); + QVERIFY(privateInfo->data != privateInfo3->data); + QVERIFY(privateInfo2->data != privateInfo3->data); + QCOMPARE(privateInfo->data, privateInfo2->data); +} + +void tst_QFileInfo::isFile_data() +{ + QTest::addColumn("path"); + QTest::addColumn("expected"); + + QTest::newRow("data0") << QDir::currentPath() << false; + QTest::newRow("data1") << SRCDIR "tst_qfileinfo.cpp" << true; + QTest::newRow("data2") << ":/tst_qfileinfo/resources/" << false; + QTest::newRow("data3") << ":/tst_qfileinfo/resources/file1" << true; + QTest::newRow("data4") << ":/tst_qfileinfo/resources/afilethatshouldnotexist" << false; +} + +void tst_QFileInfo::isFile() +{ + QFETCH(QString, path); + QFETCH(bool, expected); + + QFileInfo fi(path); + QCOMPARE(fi.isFile(), expected); +} + + +void tst_QFileInfo::isDir_data() +{ + // create a broken symlink + QFile::remove("brokenlink.lnk"); + QFile::remove("dummyfile"); + QFile file3("dummyfile"); + file3.open(QIODevice::WriteOnly); + if (file3.link("brokenlink.lnk")) { + file3.remove(); + QFileInfo info3("brokenlink.lnk"); + QVERIFY( info3.isSymLink() ); + } + + QTest::addColumn("path"); + QTest::addColumn("expected"); + + QTest::newRow("data0") << QDir::currentPath() << true; + QTest::newRow("data1") << SRCDIR "tst_qfileinfo.cpp" << false; + QTest::newRow("data2") << ":/tst_qfileinfo/resources/" << true; + QTest::newRow("data3") << ":/tst_qfileinfo/resources/file1" << false; + QTest::newRow("data4") << ":/tst_qfileinfo/resources/afilethatshouldnotexist" << false; + + QTest::newRow("simple dir") << SRCDIR "resources" << true; + QTest::newRow("simple dir with slash") << SRCDIR "resources/" << true; + + QTest::newRow("broken link") << "brokenlink.lnk" << false; + +#if (defined(Q_OS_WIN) && !defined(Q_OS_WINCE)) || defined(Q_OS_SYMBIAN) + QTest::newRow("drive 1") << "c:" << true; + QTest::newRow("drive 2") << "c:/" << true; + //QTest::newRow("drive 2") << "t:s" << false; +#endif +#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE) + QTest::newRow("unc 1") << "//" + QtNetworkSettings::winServerName() << true; + QTest::newRow("unc 2") << "//" + QtNetworkSettings::winServerName() + "/" << true; + QTest::newRow("unc 3") << "//" + QtNetworkSettings::winServerName() + "/testshare" << true; + QTest::newRow("unc 4") << "//" + QtNetworkSettings::winServerName() + "/testshare/" << true; + QTest::newRow("unc 5") << "//" + QtNetworkSettings::winServerName() + "/testshare/tmp" << true; + QTest::newRow("unc 6") << "//" + QtNetworkSettings::winServerName() + "/testshare/tmp/" << true; + QTest::newRow("unc 7") << "//" + QtNetworkSettings::winServerName() + "/testshare/adirthatshouldnotexist" << false; +#endif +} + +void tst_QFileInfo::isDir() +{ + QFETCH(QString, path); + QFETCH(bool, expected); + + QFileInfo fi(path); + QCOMPARE(fi.isDir(), expected); +} + +void tst_QFileInfo::isRoot_data() +{ + QTest::addColumn("path"); + QTest::addColumn("expected"); + QTest::newRow("data0") << QDir::currentPath() << false; + QTest::newRow("data1") << "/" << true; + QTest::newRow("data2") << "*" << false; + QTest::newRow("data3") << "/*" << false; + QTest::newRow("data4") << ":/tst_qfileinfo/resources/" << false; + QTest::newRow("data5") << ":/" << true; + + QTest::newRow("simple dir") << SRCDIR "resources" << false; + QTest::newRow("simple dir with slash") << SRCDIR "resources/" << false; +#if (defined(Q_OS_WIN) && !defined(Q_OS_WINCE)) || defined(Q_OS_SYMBIAN) + QTest::newRow("drive 1") << "c:" << false; + QTest::newRow("drive 2") << "c:/" << true; + QTest::newRow("drive 3") << "p:/" << false; +#endif + +#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE) + QTest::newRow("unc 1") << "//" + QtNetworkSettings::winServerName() << true; + QTest::newRow("unc 2") << "//" + QtNetworkSettings::winServerName() + "/" << true; + QTest::newRow("unc 3") << "//" + QtNetworkSettings::winServerName() + "/testshare" << false; + QTest::newRow("unc 4") << "//" + QtNetworkSettings::winServerName() + "/testshare/" << false; + QTest::newRow("unc 7") << "//ahostthatshouldnotexist" << false; +#endif +} + +void tst_QFileInfo::isRoot() +{ + QFETCH(QString, path); + QFETCH(bool, expected); + + QFileInfo fi(path); + QCOMPARE(fi.isRoot(), expected); +} + +void tst_QFileInfo::exists_data() +{ + QTest::addColumn("path"); + QTest::addColumn("expected"); + + QTest::newRow("data0") << QDir::currentPath() << true; + QTest::newRow("data1") << SRCDIR "tst_qfileinfo.cpp" << true; + QTest::newRow("data2") << "/I/do_not_expect_this_path_to_exist/" << false; + QTest::newRow("data3") << ":/tst_qfileinfo/resources/" << true; + QTest::newRow("data4") << ":/tst_qfileinfo/resources/file1" << true; + QTest::newRow("data5") << ":/I/do_not_expect_this_path_to_exist/" << false; + QTest::newRow("data6") << SRCDIR "resources/*" << false; + QTest::newRow("data7") << SRCDIR "resources/*.foo" << false; + QTest::newRow("data8") << SRCDIR "resources/*.ext1" << false; + QTest::newRow("data9") << SRCDIR "resources/file?.ext1" << false; + QTest::newRow("data10") << "." << true; + QTest::newRow("data11") << ". " << false; + + QTest::newRow("simple dir") << SRCDIR "resources" << true; + QTest::newRow("simple dir with slash") << SRCDIR "resources/" << true; + +#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE) + QTest::newRow("unc 1") << "//" + QtNetworkSettings::winServerName() << true; + QTest::newRow("unc 2") << "//" + QtNetworkSettings::winServerName() + "/" << true; + QTest::newRow("unc 3") << "//" + QtNetworkSettings::winServerName() + "/testshare" << true; + QTest::newRow("unc 4") << "//" + QtNetworkSettings::winServerName() + "/testshare/" << true; + QTest::newRow("unc 5") << "//" + QtNetworkSettings::winServerName() + "/testshare/tmp" << true; + QTest::newRow("unc 6") << "//" + QtNetworkSettings::winServerName() + "/testshare/tmp/" << true; + QTest::newRow("unc 7") << "//" + QtNetworkSettings::winServerName() + "/testshare/adirthatshouldnotexist" << false; + QTest::newRow("unc 8") << "//" + QtNetworkSettings::winServerName() + "/asharethatshouldnotexist" << false; + QTest::newRow("unc 9") << "//ahostthatshouldnotexist" << false; +#endif +} + +void tst_QFileInfo::exists() +{ + QFETCH(QString, path); + QFETCH(bool, expected); + + QFileInfo fi(path); + QCOMPARE(fi.exists(), expected); +} + +void tst_QFileInfo::absolutePath_data() +{ + QTest::addColumn("file"); + QTest::addColumn("path"); + QTest::addColumn("filename"); + + QString drivePrefix; +#if (defined(Q_OS_WIN) && !defined(Q_OS_WINCE)) || defined(Q_OS_SYMBIAN) + drivePrefix = QDir::currentPath().left(2); + QString nonCurrentDrivePrefix = + drivePrefix.left(1).compare("X", Qt::CaseInsensitive) == 0 ? QString("Y:") : QString("X:"); + + // Make sure drive-relative paths return correct absolute paths (task 255326) + QTest::newRow(":my.dll") << drivePrefix + "my.dll" << QDir::currentPath() << "my.dll"; + QTest::newRow(":my.dll") << nonCurrentDrivePrefix + "my.dll" + << nonCurrentDrivePrefix + "/" + << "my.dll"; +#endif + QTest::newRow("0") << "/machine/share/dir1/" << drivePrefix + "/machine/share/dir1" << ""; + QTest::newRow("1") << "/machine/share/dir1" << drivePrefix + "/machine/share" << "dir1"; + QTest::newRow("2") << "/usr/local/bin" << drivePrefix + "/usr/local" << "bin"; + QTest::newRow("3") << "/usr/local/bin/" << drivePrefix + "/usr/local/bin" << ""; + QTest::newRow("/test") << "/test" << drivePrefix + "/" << "test"; + +#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE) + // see task 102898 + QTest::newRow("c:\\autoexec.bat") << "c:\\autoexec.bat" << "C:/" + << "autoexec.bat"; +#endif +} + +void tst_QFileInfo::absolutePath() +{ + QFETCH(QString, file); + QFETCH(QString, path); + QFETCH(QString, filename); + + QFileInfo fi(file); + + QCOMPARE(fi.absolutePath(), path); + QCOMPARE(fi.fileName(), filename); +} + +void tst_QFileInfo::absFilePath_data() +{ + QTest::addColumn("file"); + QTest::addColumn("expected"); + + QTest::newRow("relativeFile") << "tmp.txt" << QDir::currentPath() + "/tmp.txt"; + QTest::newRow("relativeFileInSubDir") << "temp/tmp.txt" << QDir::currentPath() + "/" + "temp/tmp.txt"; +#if (defined(Q_OS_WIN) && !defined(Q_OS_WINCE)) || defined(Q_OS_SYMBIAN) + QString curr = QDir::currentPath(); + + curr.remove(0, 2); // Make it a absolute path with no drive specifier: \depot\qt-4.2\tests\auto\qfileinfo + QTest::newRow(".") << curr << QDir::currentPath(); + QTest::newRow("absFilePath") << "c:\\home\\andy\\tmp.txt" << "C:/home/andy/tmp.txt"; + + // Make sure drive-relative paths return correct absolute paths (task 255326) + QString drivePrefix = QDir::currentPath().left(2); + QString nonCurrentDrivePrefix = + drivePrefix.left(1).compare("X", Qt::CaseInsensitive) == 0 ? QString("Y:") : QString("X:"); + + QTest::newRow(":my.dll") << drivePrefix + "temp/my.dll" << QDir::currentPath() + "/temp/my.dll"; + QTest::newRow(":my.dll") << nonCurrentDrivePrefix + "temp/my.dll" + << nonCurrentDrivePrefix + "/temp/my.dll"; +#else + QTest::newRow("absFilePath") << "/home/andy/tmp.txt" << "/home/andy/tmp.txt"; +#endif +} + +void tst_QFileInfo::absFilePath() +{ + QFETCH(QString, file); + QFETCH(QString, expected); + + QFileInfo fi(file); + QCOMPARE(fi.absoluteFilePath(), expected); +} + +void tst_QFileInfo::canonicalPath() +{ + QTemporaryFile tempFile; + tempFile.setAutoRemove(true); + tempFile.open(); + QFileInfo fi(tempFile.fileName()); + QCOMPARE(fi.canonicalPath(), QFileInfo(QDir::tempPath()).canonicalFilePath()); +} + +void tst_QFileInfo::canonicalFilePath() +{ + const QString fileName("tmp.canon"); + QFile tempFile(fileName); + QVERIFY(tempFile.open(QFile::WriteOnly)); + QFileInfo fi(tempFile.fileName()); + QCOMPARE(fi.canonicalFilePath(), QDir::currentPath() + "/" + fileName); + tempFile.remove(); + + // This used to crash on Mac, verify that it doesn't anymore. + QFileInfo info("/tmp/../../../../../../../../../../../../../../../../../"); + info.canonicalFilePath(); + +#ifndef Q_OS_WIN + // test symlinks + QFile::remove("link.lnk"); + { + QFile file(SRCDIR "tst_qfileinfo.cpp"); + if (file.link("link.lnk")) { + QFileInfo info1(file); + QFileInfo info2("link.lnk"); + QCOMPARE(info1.canonicalFilePath(), info2.canonicalFilePath()); + } + } +# if !defined(Q_OS_SYMBIAN) + // Symbian doesn't support links to directories + { + const QString link(QDir::tempPath() + QDir::separator() + "tst_qfileinfo"); + QFile::remove(link); + QFile file(QDir::currentPath()); + if (file.link(link)) { + QFile tempfile("tempfile.txt"); + tempfile.open(QIODevice::ReadWrite); + tempfile.write("This file is generated by the QFileInfo autotest."); + QVERIFY(tempfile.flush()); + tempfile.close(); + + QFileInfo info1("tempfile.txt"); + QFileInfo info2(link + QDir::separator() + "tempfile.txt"); + + QVERIFY(info1.exists()); + QVERIFY(info2.exists()); + QCOMPARE(info1.canonicalFilePath(), info2.canonicalFilePath()); + + QFileInfo info3(link + QDir::separator() + "link.lnk"); + QFileInfo info4(SRCDIR "tst_qfileinfo.cpp"); + QVERIFY(!info3.canonicalFilePath().isEmpty()); + QCOMPARE(info4.canonicalFilePath(), info3.canonicalFilePath()); + + tempfile.remove(); + } + } + { + QString link(QDir::tempPath() + QDir::separator() + "tst_qfileinfo" + + QDir::separator() + "link_to_tst_qfileinfo"); + QFile::remove(link); + + QFile file(QDir::tempPath() + QDir::separator() + "tst_qfileinfo" + + QDir::separator() + "tst_qfileinfo.cpp"); + if (file.link(link)) + { + QFileInfo info1("tst_qfileinfo.cpp"); + QFileInfo info2(link); + QCOMPARE(info1.canonicalFilePath(), info2.canonicalFilePath()); + } + } +# endif +#endif +} + +void tst_QFileInfo::fileName_data() +{ + QTest::addColumn("file"); + QTest::addColumn("expected"); + + QTest::newRow("relativeFile") << "tmp.txt" << "tmp.txt"; + QTest::newRow("relativeFileInSubDir") << "temp/tmp.txt" << "tmp.txt"; +#if (defined(Q_OS_WIN) && !defined(Q_OS_WINCE)) || defined(Q_OS_SYMBIAN) + QTest::newRow("absFilePath") << "c:\\home\\andy\\tmp.txt" << "tmp.txt"; +#else + QTest::newRow("absFilePath") << "/home/andy/tmp.txt" << "tmp.txt"; +#endif + QTest::newRow("resource1") << ":/tst_qfileinfo/resources/file1.ext1" << "file1.ext1"; + QTest::newRow("resource2") << ":/tst_qfileinfo/resources/file1.ext1.ext2" << "file1.ext1.ext2"; + + QTest::newRow("ending slash [small]") << QString::fromLatin1("/a/") << QString::fromLatin1(""); + QTest::newRow("no ending slash [small]") << QString::fromLatin1("/a") << QString::fromLatin1("a"); + + QTest::newRow("ending slash") << QString::fromLatin1("/somedir/") << QString::fromLatin1(""); + QTest::newRow("no ending slash") << QString::fromLatin1("/somedir") << QString::fromLatin1("somedir"); +} + +void tst_QFileInfo::fileName() +{ + QFETCH(QString, file); + QFETCH(QString, expected); + + QFileInfo fi(file); + QCOMPARE(fi.fileName(), expected); +} + +void tst_QFileInfo::bundleName_data() +{ + QTest::addColumn("file"); + QTest::addColumn("expected"); + + QTest::newRow("root") << "/" << ""; + QTest::newRow("etc") << "/etc" << ""; +#ifdef Q_OS_MAC + QTest::newRow("safari") << "/Applications/Safari.app" << "Safari"; +#endif +} + +void tst_QFileInfo::bundleName() +{ + QFETCH(QString, file); + QFETCH(QString, expected); + + QFileInfo fi(file); + QCOMPARE(fi.bundleName(), expected); +} + +void tst_QFileInfo::dir_data() +{ + QTest::addColumn("file"); + QTest::addColumn("absPath"); + QTest::addColumn("expected"); + + QTest::newRow("relativeFile") << "tmp.txt" << false << "."; + QTest::newRow("relativeFileAbsPath") << "tmp.txt" << true << QDir::currentPath(); + QTest::newRow("relativeFileInSubDir") << "temp/tmp.txt" << false << "temp"; + QTest::newRow("relativeFileInSubDirAbsPath") << "temp/tmp.txt" << true << QDir::currentPath() + "/temp"; + QTest::newRow("absFilePath") << QDir::currentPath() + "/tmp.txt" << false << QDir::currentPath(); + QTest::newRow("absFilePathAbsPath") << QDir::currentPath() + "/tmp.txt" << true << QDir::currentPath(); + QTest::newRow("resource1") << ":/tst_qfileinfo/resources/file1.ext1" << true << ":/tst_qfileinfo/resources"; +} + +void tst_QFileInfo::dir() +{ + QFETCH(QString, file); + QFETCH(bool, absPath); + QFETCH(QString, expected); + + QFileInfo fi(file); + if (absPath) + QCOMPARE(fi.absolutePath(), expected); + else + QCOMPARE(fi.path(), expected); +} + + +void tst_QFileInfo::suffix_data() +{ + QTest::addColumn("file"); + QTest::addColumn("expected"); + + QTest::newRow("noextension0") << "file" << ""; + QTest::newRow("noextension1") << "/path/to/file" << ""; + QTest::newRow("data0") << "file.tar" << "tar"; + QTest::newRow("data1") << "file.tar.gz" << "gz"; + QTest::newRow("data2") << "/path/file/file.tar.gz" << "gz"; + QTest::newRow("data3") << "/path/file.tar" << "tar"; + QTest::newRow("resource1") << ":/tst_qfileinfo/resources/file1.ext1" << "ext1"; + QTest::newRow("resource2") << ":/tst_qfileinfo/resources/file1.ext1.ext2" << "ext2"; + QTest::newRow("hidden1") << ".ext1" << "ext1"; + QTest::newRow("hidden1") << ".ext" << "ext"; + QTest::newRow("hidden1") << ".ex" << "ex"; + QTest::newRow("hidden1") << ".e" << "e"; + QTest::newRow("hidden2") << ".ext1.ext2" << "ext2"; + QTest::newRow("hidden2") << ".ext.ext2" << "ext2"; + QTest::newRow("hidden2") << ".ex.ext2" << "ext2"; + QTest::newRow("hidden2") << ".e.ext2" << "ext2"; + QTest::newRow("hidden2") << "..ext2" << "ext2"; +} + +void tst_QFileInfo::suffix() +{ + QFETCH(QString, file); + QFETCH(QString, expected); + + QFileInfo fi(file); + QCOMPARE(fi.suffix(), expected); +} + + +void tst_QFileInfo::completeSuffix_data() +{ + QTest::addColumn("file"); + QTest::addColumn("expected"); + + QTest::newRow("noextension0") << "file" << ""; + QTest::newRow("noextension1") << "/path/to/file" << ""; + QTest::newRow("data0") << "file.tar" << "tar"; + QTest::newRow("data1") << "file.tar.gz" << "tar.gz"; + QTest::newRow("data2") << "/path/file/file.tar.gz" << "tar.gz"; + QTest::newRow("data3") << "/path/file.tar" << "tar"; + QTest::newRow("resource1") << ":/tst_qfileinfo/resources/file1.ext1" << "ext1"; + QTest::newRow("resource2") << ":/tst_qfileinfo/resources/file1.ext1.ext2" << "ext1.ext2"; +} + +void tst_QFileInfo::completeSuffix() +{ + QFETCH(QString, file); + QFETCH(QString, expected); + + QFileInfo fi(file); + QCOMPARE(fi.completeSuffix(), expected); +} + +void tst_QFileInfo::baseName_data() +{ + QTest::addColumn("file"); + QTest::addColumn("expected"); + + QTest::newRow("data0") << "file.tar" << "file"; + QTest::newRow("data1") << "file.tar.gz" << "file"; + QTest::newRow("data2") << "/path/file/file.tar.gz" << "file"; + QTest::newRow("data3") << "/path/file.tar" << "file"; + QTest::newRow("data4") << "/path/file" << "file"; + QTest::newRow("resource1") << ":/tst_qfileinfo/resources/file1.ext1" << "file1"; + QTest::newRow("resource2") << ":/tst_qfileinfo/resources/file1.ext1.ext2" << "file1"; +} + +void tst_QFileInfo::baseName() +{ + QFETCH(QString, file); + QFETCH(QString, expected); + + QFileInfo fi(file); + QCOMPARE(fi.baseName(), expected); +} + +void tst_QFileInfo::completeBaseName_data() +{ + QTest::addColumn("file"); + QTest::addColumn("expected"); + + QTest::newRow("data0") << "file.tar" << "file"; + QTest::newRow("data1") << "file.tar.gz" << "file.tar"; + QTest::newRow("data2") << "/path/file/file.tar.gz" << "file.tar"; + QTest::newRow("data3") << "/path/file.tar" << "file"; + QTest::newRow("data4") << "/path/file" << "file"; + QTest::newRow("resource1") << ":/tst_qfileinfo/resources/file1.ext1" << "file1"; + QTest::newRow("resource2") << ":/tst_qfileinfo/resources/file1.ext1.ext2" << "file1.ext1"; +} + +void tst_QFileInfo::completeBaseName() +{ + QFETCH(QString, file); + QFETCH(QString, expected); + + QFileInfo fi(file); + QCOMPARE(fi.completeBaseName(), expected); +} + +void tst_QFileInfo::permission_data() +{ + QTest::addColumn("file"); + QTest::addColumn("perms"); + QTest::addColumn("expected"); + + QTest::newRow("data0") << QCoreApplication::instance()->applicationFilePath() << int(QFile::ExeUser) << true; + QTest::newRow("data1") << SRCDIR "tst_qfileinfo.cpp" << int(QFile::ReadUser) << true; +// QTest::newRow("data2") << "tst_qfileinfo.cpp" << int(QFile::WriteUser) << false; + QTest::newRow("resource1") << ":/tst_qfileinfo/resources/file1.ext1" << int(QFile::ReadUser) << true; + QTest::newRow("resource2") << ":/tst_qfileinfo/resources/file1.ext1" << int(QFile::WriteUser) << false; + QTest::newRow("resource3") << ":/tst_qfileinfo/resources/file1.ext1" << int(QFile::ExeUser) << false; +} + +void tst_QFileInfo::permission() +{ + QFETCH(QString, file); + QFETCH(int, perms); + QFETCH(bool, expected); +#ifdef Q_OS_SYMBIAN + QSKIP("No user based rights in Symbian OS - SOS needs platform security tests instead", SkipAll); +#endif + QFileInfo fi(file); + QCOMPARE(fi.permission(QFile::Permissions(perms)), expected); +} + +void tst_QFileInfo::size_data() +{ + QTest::addColumn("file"); + QTest::addColumn("size"); + + QTest::newRow("resource1") << ":/tst_qfileinfo/resources/file1.ext1" << 0; + QFile::remove("file1"); + QFile file("file1"); + QVERIFY(file.open(QFile::WriteOnly)); + QCOMPARE(file.write("JAJAJAA"), qint64(7)); + QTest::newRow("created-file") << "file1" << 7; + + QTest::newRow("resource2") << ":/tst_qfileinfo/resources/file1.ext1.ext2" << 0; +} + +void tst_QFileInfo::size() +{ + QFETCH(QString, file); + + QFileInfo fi(file); + (void)fi.permissions(); // see task 104198 + QTEST(int(fi.size()), "size"); +} + +void tst_QFileInfo::systemFiles() +{ +#if !defined(Q_OS_WIN) || defined(Q_OS_WINCE) + QSKIP("This is a Windows only test", SkipAll); +#endif + QFileInfo fi("c:\\pagefile.sys"); + QVERIFY(fi.exists()); // task 167099 + QVERIFY(fi.size() > 0); // task 189202 + QVERIFY(fi.lastModified().isValid()); +} + +void tst_QFileInfo::compare_data() +{ + QTest::addColumn("file1"); + QTest::addColumn("file2"); + QTest::addColumn("same"); + + QTest::newRow("data0") + << QString::fromLatin1(SRCDIR "tst_qfileinfo.cpp") + << QString::fromLatin1(SRCDIR "tst_qfileinfo.cpp") + << true; + QTest::newRow("data1") + << QString::fromLatin1(SRCDIR "tst_qfileinfo.cpp") + << QString::fromLatin1("/tst_qfileinfo.cpp") + << false; + QTest::newRow("data2") + << QString::fromLatin1("tst_qfileinfo.cpp") + << QDir::currentPath() + QString::fromLatin1("/tst_qfileinfo.cpp") + << true; + QTest::newRow("casesense1") + << QString::fromLatin1(SRCDIR "tst_qfileInfo.cpp") + << QString::fromLatin1(SRCDIR "tst_qfileinfo.cpp") +#if defined(Q_OS_WIN) || defined(Q_OS_SYMBIAN) + << true; +#else + << false; +#endif +} + +void tst_QFileInfo::compare() +{ + QFETCH(QString, file1); + QFETCH(QString, file2); + QFETCH(bool, same); + QFileInfo fi1(file1), fi2(file2); + QCOMPARE(same, fi1 == fi2); +} + +void tst_QFileInfo::consistent_data() +{ + QTest::addColumn("file"); + QTest::addColumn("expected"); + +#if defined(Q_OS_WIN) || defined(Q_OS_SYMBIAN) + QTest::newRow("slashes") << QString::fromLatin1("\\a\\a\\a\\a") << QString::fromLatin1("/a/a/a/a"); +#endif + QTest::newRow("ending slash") << QString::fromLatin1("/a/somedir/") << QString::fromLatin1("/a/somedir/"); + QTest::newRow("no ending slash") << QString::fromLatin1("/a/somedir") << QString::fromLatin1("/a/somedir"); +} + +void tst_QFileInfo::consistent() +{ + QFETCH(QString, file); + QFETCH(QString, expected); + + QFileInfo fi(file); + QCOMPARE(fi.filePath(), expected); + QCOMPARE(fi.dir().path() + "/" + fi.fileName(), expected); +} + + +void tst_QFileInfo::fileTimes_data() +{ + QTest::addColumn("fileName"); + QTest::newRow("simple") << QString::fromLatin1("simplefile.txt"); + QTest::newRow( "longfile" ) << QString::fromLatin1("longFileNamelongFileNamelongFileNamelongFileName" + "longFileNamelongFileNamelongFileNamelongFileName" + "longFileNamelongFileNamelongFileNamelongFileName" + "longFileNamelongFileNamelongFileNamelongFileName" + "longFileNamelongFileNamelongFileNamelongFileName.txt"); + QTest::newRow( "longfile absolutepath" ) << QFileInfo(QString::fromLatin1("longFileNamelongFileNamelongFileNamelongFileName" + "longFileNamelongFileNamelongFileNamelongFileName" + "longFileNamelongFileNamelongFileNamelongFileName" + "longFileNamelongFileNamelongFileNamelongFileName" + "longFileNamelongFileNamelongFileNamelongFileName.txt")).absoluteFilePath(); +} + +void tst_QFileInfo::fileTimes() +{ +#if defined(Q_OS_WINCE) + int sleepTime = 3000; +#else + int sleepTime = 2000; +#endif + QFETCH(QString, fileName); + if (QFile::exists(fileName)) { + QVERIFY(QFile::remove(fileName)); + } + QTest::qSleep(sleepTime); + { + QFile file(fileName); +#if defined(Q_OS_WINCE) + QEXPECT_FAIL("longfile", "No long filenames on WinCE", Abort); + QEXPECT_FAIL("longfile absolutepath", "No long filenames on WinCE", Abort); +#elif defined(Q_OS_SYMBIAN) + QEXPECT_FAIL("longfile", "Maximum total filepath cannot exceed 256 characters in Symbian", Abort); + QEXPECT_FAIL("longfile absolutepath", "Maximum total filepath cannot exceed 256 characters in Symbian", Abort); +#endif + QVERIFY(file.open(QFile::WriteOnly | QFile::Text)); + QTextStream ts(&file); + ts << fileName << endl; + } + QTest::qSleep(sleepTime); + QDateTime beforeWrite = QDateTime::currentDateTime(); + QTest::qSleep(sleepTime); + { + QFileInfo fileInfo(fileName); + QVERIFY(fileInfo.created() < beforeWrite); + QFile file(fileName); + QVERIFY(file.open(QFile::ReadWrite | QFile::Text)); + QTextStream ts(&file); + ts << fileName << endl; + } + QTest::qSleep(sleepTime); + QDateTime beforeRead = QDateTime::currentDateTime(); + QTest::qSleep(sleepTime); + { + QFileInfo fileInfo(fileName); +// On unix created() returns the same as lastModified(). +#if !defined(Q_OS_UNIX) && !defined(Q_OS_WINCE) + QVERIFY(fileInfo.created() < beforeWrite); +#endif + QVERIFY(fileInfo.lastModified() > beforeWrite); + QFile file(fileName); + QVERIFY(file.open(QFile::ReadOnly | QFile::Text)); + QTextStream ts(&file); + QString line = ts.readLine(); + QCOMPARE(line, fileName); + } + + QFileInfo fileInfo(fileName); +#if !defined(Q_OS_UNIX) && !defined(Q_OS_WINCE) + QVERIFY(fileInfo.created() < beforeWrite); +#endif + //In Vista the last-access timestamp is not updated when the file is accessed/touched (by default). + //To enable this the HKLM\SYSTEM\CurrentControlSet\Control\FileSystem\NtfsDisableLastAccessUpdate + //is set to 0, in the test machine. +#ifdef Q_OS_WINCE + QEXPECT_FAIL("simple", "WinCE only stores date of access data, not the time", Continue); +#endif +#ifdef Q_OS_SYMBIAN + QEXPECT_FAIL("simple", "Symbian implementation of stat doesn't return read time right", Abort); +#endif + QVERIFY(fileInfo.lastRead() > beforeRead); + QVERIFY(fileInfo.lastModified() > beforeWrite); + QVERIFY(fileInfo.lastModified() < beforeRead); +} + +void tst_QFileInfo::fileTimes_oldFile() +{ + // This is not supported on WinCE +#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE) + // All files are opened in share mode (both read and write). + DWORD shareMode = FILE_SHARE_READ | FILE_SHARE_WRITE; + + // All files on Windows can be read; there's no such thing as an + // unreadable file. Add GENERIC_WRITE if WriteOnly is passed. + int accessRights = GENERIC_READ | GENERIC_WRITE; + + SECURITY_ATTRIBUTES securityAtts = { sizeof(SECURITY_ATTRIBUTES), NULL, TRUE }; + + // Regular file mode. In Unbuffered mode, pass the no-buffering flag. + DWORD flagsAndAtts = FILE_ATTRIBUTE_NORMAL; + + // WriteOnly can create files, ReadOnly cannot. + DWORD creationDisp = OPEN_ALWAYS; + + // Create the file handle. + HANDLE fileHandle = CreateFile(L"oldfile.txt", + accessRights, + shareMode, + &securityAtts, + creationDisp, + flagsAndAtts, + NULL); + + // Set file times back to 1601. + SYSTEMTIME stime; + stime.wYear = 1601; + stime.wMonth = 1; + stime.wDayOfWeek = 1; + stime.wDay = 1; + stime.wHour = 1; + stime.wMinute = 0; + stime.wSecond = 0; + stime.wMilliseconds = 0; + + FILETIME ctime; + QVERIFY(SystemTimeToFileTime(&stime, &ctime)); + FILETIME atime = ctime; + FILETIME mtime = atime; + QVERIFY(fileHandle); + QVERIFY(SetFileTime(fileHandle, &ctime, &atime, &mtime) != 0); + + CloseHandle(fileHandle); + + QFileInfo info("oldfile.txt"); + QCOMPARE(info.lastModified(), QDateTime(QDate(1601, 1, 1), QTime(1, 0), Qt::UTC).toLocalTime()); +#endif +} + +void tst_QFileInfo::isSymLink_data() +{ + QFile::remove("link.lnk"); + QFile::remove("brokenlink.lnk"); + QFile::remove("dummyfile"); + + QFile file1(SRCDIR "tst_qfileinfo.cpp"); + QVERIFY(file1.link("link.lnk")); + + QFile file2("dummyfile"); + file2.open(QIODevice::WriteOnly); + QVERIFY(file2.link("brokenlink.lnk")); + file2.remove(); + + QTest::addColumn("path"); + QTest::addColumn("isSymLink"); + QTest::addColumn("linkTarget"); + + QTest::newRow("existent file") << SRCDIR "tst_qfileinfo.cpp" << false << ""; + QTest::newRow("link") << "link.lnk" << true << QFileInfo(SRCDIR "tst_qfileinfo.cpp").absoluteFilePath(); + QTest::newRow("broken link") << "brokenlink.lnk" << true << QFileInfo("dummyfile").absoluteFilePath(); + +#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE) + if (QSysInfo::WindowsVersion & QSysInfo::WV_VISTA) { + QTest::newRow("Documents and Settings") << "C:/Documents and Settings" << true << "C:/Users"; + QTest::newRow("All Users") << "C:/Users/All Users" << true << "C:/ProgramData"; + QTest::newRow("Default User") << "C:/Users/Default User" << true << "C:/Users/Default"; + } +#endif +} + +void tst_QFileInfo::isSymLink() +{ + QFETCH(QString, path); + QFETCH(bool, isSymLink); + QFETCH(QString, linkTarget); + + QFileInfo fi(path); + QCOMPARE(fi.isSymLink(), isSymLink); + QCOMPARE(fi.symLinkTarget(), linkTarget); +} + +void tst_QFileInfo::isHidden_data() +{ + QTest::addColumn("path"); + QTest::addColumn("isHidden"); + foreach (const QFileInfo& info, QDir::drives()) { + QTest::newRow(qPrintable("drive." + info.path())) << info.path() << false; + } + +#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE) + QTest::newRow("C:/RECYCLER") << QString::fromLatin1("C:/RECYCLER") << true; + QTest::newRow("C:/RECYCLER/.") << QString::fromLatin1("C:/RECYCLER/.") << false; + QTest::newRow("C:/RECYCLER/..") << QString::fromLatin1("C:/RECYCLER/..") << false; +#endif +#if defined(Q_OS_UNIX) && !defined(Q_OS_SYMBIAN) + + if (!QDir("./.hidden-directory").exists() + && !QDir().mkdir("./.hidden-directory")) + qWarning("Unable to create directory './.hidden-directory'. Some tests will fail."); + + QTest::newRow("./.hidden-directory") << QString("./.hidden-directory") << true; + QTest::newRow("./.hidden-directory/.") << QString("./.hidden-directory/.") << false; + QTest::newRow("./.hidden-directory/..") << QString("./.hidden-directory/..") << false; + + QTest::newRow("/path/to/.hidden-directory") << QDir::currentPath() + QString("/.hidden-directory") << true; + QTest::newRow("/path/to/.hidden-directory/.") << QDir::currentPath() + QString("/.hidden-directory/.") << false; + QTest::newRow("/path/to/.hidden-directory/..") << QDir::currentPath() + QString("/.hidden-directory/..") << false; +#endif + +#if defined(Q_OS_MAC) + // /bin has the hidden attribute on Mac OS X + QTest::newRow("/bin/") << QString::fromLatin1("/bin/") << true; +#elif !defined(Q_OS_WIN) && !defined(Q_OS_SYMBIAN) + QTest::newRow("/bin/") << QString::fromLatin1("/bin/") << false; +#endif + +#ifdef Q_OS_MAC + QTest::newRow("mac_etc") << QString::fromLatin1("/etc") << true; + QTest::newRow("mac_private_etc") << QString::fromLatin1("/private/etc") << false; + QTest::newRow("mac_Applications") << QString::fromLatin1("/Applications") << false; +#endif + +#ifdef Q_OS_SYMBIAN + // No guaranteed hidden file knows to exist in Symbian filesystem, so make one. + QString hiddenFileName("hidden.txt"); + QString notHiddenFileName("nothidden.txt"); + QTest::newRow("hidden file") << hiddenFileName << true; + QTest::newRow("non-hidden file") << notHiddenFileName << false; + + { + QFile file(hiddenFileName); + if (file.open(QIODevice::WriteOnly)) { + QTextStream t(&file); + t << "foobar"; + } else { + qWarning("Failed to create hidden file"); + } + QFile file2(notHiddenFileName); + if (file2.open(QIODevice::WriteOnly)) { + QTextStream t(&file); + t << "foobar"; + } else { + qWarning("Failed to create non-hidden file"); + } + } + + RFs rfs; + TInt err = rfs.Connect(); + if (err == KErrNone) { + HBufC* symFile = qt_QString2HBufC(hiddenFileName); + err = rfs.SetAtt(*symFile, KEntryAttHidden, 0); + rfs.Close(); + delete symFile; + if (err != KErrNone) { + qWarning("Failed to set hidden attribute for test file"); + } + } else { + qWarning("Failed to open RFs session"); + } +#endif +} + +void tst_QFileInfo::isHidden() +{ + QFETCH(QString, path); + QFETCH(bool, isHidden); + QFileInfo fi(path); + + QCOMPARE(fi.isHidden(), isHidden); +} + +void tst_QFileInfo::isBundle_data() +{ + QTest::addColumn("path"); + QTest::addColumn("isBundle"); + QTest::newRow("root") << QString::fromLatin1("/") << false; +#ifdef Q_OS_MAC + QTest::newRow("mac_Applications") << QString::fromLatin1("/Applications") << false; + QTest::newRow("mac_Applications") << QString::fromLatin1("/Applications/Safari.app") << true; +#endif +} + +void tst_QFileInfo::isBundle() +{ + QFETCH(QString, path); + QFETCH(bool, isBundle); + QFileInfo fi(path); + QCOMPARE(fi.isBundle(), isBundle); +} + +void tst_QFileInfo::isLocalFs_data() +{ + QTest::addColumn("path"); + QTest::addColumn("isLocalFs"); + + QTest::newRow("local root") << QString::fromLatin1("/") << true; + QTest::newRow("local non-existent file") << QString::fromLatin1("/abrakadabra.boo") << true; + + QTest::newRow("qresource root") << QString::fromLatin1(":/") << false; +} + +void tst_QFileInfo::isLocalFs() +{ + QFETCH(QString, path); + QFETCH(bool, isLocalFs); + + QFileInfo info(path); + QFileInfoPrivate *privateInfo = getPrivate(info); + QVERIFY(privateInfo->data->fileEngine); + QCOMPARE(bool(privateInfo->data->fileEngine->fileFlags(QAbstractFileEngine::LocalDiskFlag) + & QAbstractFileEngine::LocalDiskFlag), isLocalFs); +} + +void tst_QFileInfo::refresh() +{ +#if defined(Q_OS_WINCE) + int sleepTime = 3000; +#else + int sleepTime = 2000; +#endif + + QFile::remove("file1"); + QFile file("file1"); + QVERIFY(file.open(QFile::WriteOnly)); + QCOMPARE(file.write("JAJAJAA"), qint64(7)); + file.flush(); + + QFileInfo info(file); + QDateTime lastModified = info.lastModified(); + QCOMPARE(info.size(), qint64(7)); + + QTest::qSleep(sleepTime); + + QCOMPARE(file.write("JOJOJO"), qint64(6)); + file.flush(); + QVERIFY(info.lastModified() == lastModified); + + QCOMPARE(info.size(), qint64(7)); +#if defined(Q_OS_WIN) || defined(Q_OS_WINCE) + if (QSysInfo::windowsVersion() & QSysInfo::WV_VISTA || + QSysInfo::windowsVersion() & QSysInfo::WV_CE_based) + file.close(); +#endif +#if defined(Q_OS_WINCE) + // On Windows CE we need to close the file. + // Otherwise the content will be cached and not + // flushed to the storage, although we flushed it + // manually!!! CE has interim cache, we cannot influence. + QTest::qWait(5000); +#endif + info.refresh(); + QCOMPARE(info.size(), qint64(13)); + QVERIFY(info.lastModified() > lastModified); + + QFileInfo info2 = info; + QCOMPARE(info2.size(), info.size()); + + info2.refresh(); + QCOMPARE(info2.size(), info.size()); +} + +#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE) +void tst_QFileInfo::brokenShortcut() +{ + QString linkName("borkenlink.lnk"); + QFile::remove(linkName); + QFile file(linkName); + file.open(QFile::WriteOnly); + file.write("b0rk"); + file.close(); + + QFileInfo info(linkName); + QVERIFY(info.isSymLink()); + QVERIFY(!info.exists()); + QFile::remove(linkName); +} +#endif + +void tst_QFileInfo::isWritable() +{ +#ifdef Q_OS_SYMBIAN + QSKIP("Currently skipped on Symbian OS, but surely there is a writeable file somewhere???", SkipAll); +#endif + + QFile tempfile("tempfile.txt"); + tempfile.open(QIODevice::WriteOnly); + tempfile.write("This file is generated by the QFileInfo autotest."); + tempfile.close(); + + QVERIFY(QFileInfo("tempfile.txt").isWritable()); + tempfile.remove(); + +#ifdef Q_OS_WIN +#ifdef Q_OS_WINCE + QFileInfo fi("\\Windows\\wince.nls"); +#else + QFileInfo fi("c:\\pagefile.sys"); +#endif + QVERIFY(fi.exists()); + QVERIFY(!fi.isWritable()); +#endif +#ifdef Q_OS_UNIX + if (::getuid() == 0) + QVERIFY(QFileInfo("/etc/passwd").isWritable()); + else + QVERIFY(!QFileInfo("/etc/passwd").isWritable()); +#endif +} + +void tst_QFileInfo::isExecutable() +{ +#ifdef Q_OS_SYMBIAN +# if defined(Q_CC_NOKIAX86) + QSKIP("Impossible to implement reading/touching of application binaries in Symbian emulator", SkipAll); +# endif + QString appPath = "c:/sys/bin/tst_qfileinfo.exe"; +#else + QString appPath = QCoreApplication::applicationDirPath(); + appPath += "/tst_qfileinfo"; +# if defined(Q_OS_WIN) + appPath += ".exe"; +# endif +#endif + QFileInfo fi(appPath); + QCOMPARE(fi.isExecutable(), true); + + QCOMPARE(QFileInfo("qfileinfo.pro").isExecutable(), false); +} + + +void tst_QFileInfo::testDecomposedUnicodeNames_data() +{ + QTest::addColumn("filePath"); + QTest::addColumn("fileName"); + QTest::addColumn("exists"); + QString currPath = QDir::currentPath(); + QTest::newRow("latin-only") << currPath + "/4.pdf" << "4.pdf" << true; + QTest::newRow("one-decomposed uni") << currPath + QString::fromUtf8("/4 ä.pdf") << QString::fromUtf8("4 ä.pdf") << true; + QTest::newRow("many-decomposed uni") << currPath + QString::fromUtf8("/4 äääcopy.pdf") << QString::fromUtf8("4 äääcopy.pdf") << true; + QTest::newRow("no decomposed") << currPath + QString::fromUtf8("/4 øøøcopy.pdf") << QString::fromUtf8("4 øøøcopy.pdf") << true; +} + +static void createFileNative(const QString &filePath) +{ +#ifdef Q_OS_UNIX + int fd = open(filePath.normalized(QString::NormalizationForm_D).toUtf8().constData(), O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR); + if (fd < 0) { + QFAIL("couldn't create file"); + } else { + close(fd); + } +#else + Q_UNUSED(filePath); +#endif +} + +static void removeFileNative(const QString &filePath) +{ +#ifdef Q_OS_UNIX + unlink(filePath.normalized(QString::NormalizationForm_D).toUtf8().constData()); +#else + Q_UNUSED(filePath); +#endif +} + +void tst_QFileInfo::testDecomposedUnicodeNames() +{ +#ifndef Q_OS_MAC + QSKIP("This is a OS X only test (unless you know more about filesystems, then maybe you should try it ;)", SkipAll); +#endif + QFETCH(QString, filePath); + createFileNative(filePath); + + QFileInfo file(filePath); + QTEST(file.fileName(), "fileName"); + QTEST(file.exists(), "exists"); + removeFileNative(filePath); +} + +void tst_QFileInfo::equalOperator() const +{ + /* Compare two default constructed values. Yes, to me it seems it should be the opposite too, but + * this is how the code was written. */ + QVERIFY(!(QFileInfo() == QFileInfo())); +} + + +void tst_QFileInfo::equalOperatorWithDifferentSlashes() const +{ + const QFileInfo fi1("/usr"); + const QFileInfo fi2("/usr/"); + + QCOMPARE(fi1, fi2); +} + +void tst_QFileInfo::notEqualOperator() const +{ + /* Compare two default constructed values. Yes, to me it seems it should be the opposite too, but + * this is how the code was written. */ + QVERIFY(QFileInfo() != QFileInfo()); +} + +QTEST_MAIN(tst_QFileInfo) +#include "tst_qfileinfo.moc"