From 03fd37cdf403e35aaaab874be9bad033d250e39d Mon Sep 17 00:00:00 2001 From: David Faure Date: Sat, 22 Oct 2011 11:35:37 +0200 Subject: Add the missing unittest Change-Id: I2384d9de7b9ef409db521087670070bd5afc85ff Reviewed-by: Thiago Macieira (Intel) --- .../corelib/io/qstandardpaths/qstandardpaths.pro | 12 + .../io/qstandardpaths/tst_qstandardpaths.cpp | 282 +++++++++++++++++++++ 2 files changed, 294 insertions(+) create mode 100644 tests/auto/corelib/io/qstandardpaths/qstandardpaths.pro create mode 100644 tests/auto/corelib/io/qstandardpaths/tst_qstandardpaths.cpp (limited to 'tests/auto/corelib/io') diff --git a/tests/auto/corelib/io/qstandardpaths/qstandardpaths.pro b/tests/auto/corelib/io/qstandardpaths/qstandardpaths.pro new file mode 100644 index 0000000000..983f87ac6f --- /dev/null +++ b/tests/auto/corelib/io/qstandardpaths/qstandardpaths.pro @@ -0,0 +1,12 @@ +TARGET = tst_qstandardpaths +CONFIG += testcase +SOURCES += tst_qstandardpaths.cpp +QT = core testlib +CONFIG += parallel_test + +wince* { + DEFINES += SRCDIR=\\\"\\\" +} else { + DEFINES += SRCDIR=\\\"$$PWD/\\\" +} + diff --git a/tests/auto/corelib/io/qstandardpaths/tst_qstandardpaths.cpp b/tests/auto/corelib/io/qstandardpaths/tst_qstandardpaths.cpp new file mode 100644 index 0000000000..00f52fb8d1 --- /dev/null +++ b/tests/auto/corelib/io/qstandardpaths/tst_qstandardpaths.cpp @@ -0,0 +1,282 @@ +/**************************************************************************** +** +** Copyright (C) 2011 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$ +** GNU Lesser General Public License Usage +** 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. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU General +** Public License version 3.0 as published by the Free Software Foundation +** and appearing in the file LICENSE.GPL included in the packaging of this +** file. Please review the following information to ensure the GNU General +** Public License version 3.0 requirements will be met: +** http://www.gnu.org/copyleft/gpl.html. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + +#include +#include +#include +#include + +#ifdef Q_OS_UNIX +#include +#include +#endif + +//TESTED_CLASS=QStandardPaths +//TESTED_FILES=qstandardpaths.cpp + +class tst_qstandardpaths : public QObject { + Q_OBJECT + +public: + tst_qstandardpaths() { + } + virtual ~tst_qstandardpaths() { + } + +private slots: + void testDefaultLocations(); + void testCustomLocations(); + void testLocateAll(); + void testDataLocation(); + void testFindExecutable(); + void testRuntimeDirectory(); + void testCustomRuntimeDirectory(); + void testAllWritableLocations_data(); + void testAllWritableLocations(); + +private: + void setCustomLocations() { + m_thisDir = QFile::decodeName(SRCDIR); + //qDebug() << m_thisDir; + m_thisDir.chop(1); // remove trailing slash! + + qputenv("XDG_CONFIG_HOME", QFile::encodeName(m_thisDir)); + QDir parent(m_thisDir); + parent.cdUp(); + m_globalDir = parent.path(); // gives us a trailing slash + qputenv("XDG_CONFIG_DIRS", QFile::encodeName(m_globalDir)); + } + QString m_thisDir; + QString m_globalDir; +}; + +void tst_qstandardpaths::testDefaultLocations() +{ +#ifndef Q_OS_WIN + qputenv("XDG_CONFIG_HOME", QByteArray()); + qputenv("XDG_CONFIG_DIRS", QByteArray()); + const QString expectedConfHome = QDir::homePath() + QString::fromLatin1("/.config"); + QCOMPARE(QStandardPaths::writableLocation(QStandardPaths::ConfigLocation), expectedConfHome); + const QStringList confDirs = QStandardPaths::standardLocations(QStandardPaths::ConfigLocation); + QCOMPARE(confDirs.count(), 2); + QVERIFY(confDirs.contains(expectedConfHome)); + + qputenv("XDG_DATA_HOME", QByteArray()); + qputenv("XDG_DATA_DIRS", QByteArray()); + const QStringList genericDataDirs = QStandardPaths::standardLocations(QStandardPaths::GenericDataLocation); + QCOMPARE(genericDataDirs.count(), 3); + const QString expectedDataHome = QDir::homePath() + QString::fromLatin1("/.local/share"); + QCOMPARE(genericDataDirs.at(0), expectedDataHome); + QCOMPARE(genericDataDirs.at(1), QString::fromLatin1("/usr/local/share")); + QCOMPARE(genericDataDirs.at(2), QString::fromLatin1("/usr/share")); +#endif +} + +void tst_qstandardpaths::testCustomLocations() +{ +#ifndef Q_OS_WIN + setCustomLocations(); + + // test writableLocation() + QCOMPARE(QStandardPaths::writableLocation(QStandardPaths::ConfigLocation), m_thisDir); + + // test locate() + const QString thisFileName = QString::fromLatin1("tst_qstandardpaths.cpp"); + QVERIFY(QFile::exists(m_thisDir + '/' + thisFileName)); + const QString thisFile = QStandardPaths::locate(QStandardPaths::ConfigLocation, thisFileName); + QVERIFY(!thisFile.isEmpty()); + QVERIFY(thisFile.endsWith(thisFileName)); + + const QString dir = QStandardPaths::locate(QStandardPaths::ConfigLocation, QString::fromLatin1("../qstandardpaths"), QStandardPaths::LocateDirectory); + QVERIFY(!dir.isEmpty()); + const QString thisDirAsFile = QStandardPaths::locate(QStandardPaths::ConfigLocation, QString::fromLatin1("../qstandardpaths")); + QVERIFY(thisDirAsFile.isEmpty()); // not a file + + const QStringList dirs = QStandardPaths::standardLocations(QStandardPaths::ConfigLocation); + QCOMPARE(dirs, QStringList() << m_thisDir << m_globalDir); +#endif +} + +// We really need QTemporaryDir for this test... + +void tst_qstandardpaths::testLocateAll() +{ +#ifndef Q_OS_WIN + const QStringList appsDirs = QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, "applications", QStandardPaths::LocateDirectory); + //qDebug() << appsDirs; + foreach (const QString &dir, appsDirs) + QVERIFY2(dir.endsWith(QLatin1String("/share/applications")), qPrintable(dir)); + + setCustomLocations(); + const QStringList allFiles = QStandardPaths::locateAll(QStandardPaths::ConfigLocation, "qstandardpaths.pro"); + QCOMPARE(allFiles.first(), QString(m_thisDir + QString::fromLatin1("/qstandardpaths.pro"))); +#endif +} + +void tst_qstandardpaths::testDataLocation() +{ + // On all platforms, DataLocation should be GenericDataLocation / organization name / app name + // This allows one app to access the data of another app. + { + const QString base = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation); + const QString app = QStandardPaths::writableLocation(QStandardPaths::DataLocation); + QCOMPARE(base, app); + } + QCoreApplication::instance()->setOrganizationName("Qt"); + QCoreApplication::instance()->setApplicationName("QtTest"); + { + const QString base = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation); + const QString app = QStandardPaths::writableLocation(QStandardPaths::DataLocation); + QCOMPARE(app, base + "/Qt/QtTest"); + } +} + +void tst_qstandardpaths::testFindExecutable() +{ + // Search for 'sh' on unix and 'cmd.exe' on Windows +#ifdef Q_OS_WIN + const QString exeName = "cmd.exe"; +#else + const QString exeName = "sh"; +#endif + + const QString result = QStandardPaths::findExecutable(exeName); + QVERIFY(!result.isEmpty()); +#ifdef Q_OS_WIN + QVERIFY(result.endsWith("/cmd.exe")); +#else + QVERIFY(result.endsWith("/bin/sh")); +#endif + + // full path as argument + QCOMPARE(QStandardPaths::findExecutable(result), result); + + // exe no found + QVERIFY(QStandardPaths::findExecutable("idontexist").isEmpty()); + QVERIFY(QStandardPaths::findExecutable("").isEmpty()); + + // link to directory + const QString target = QDir::tempPath() + QDir::separator() + QLatin1String("link.lnk"); + QFile::remove(target); + QFile appFile(QCoreApplication::applicationDirPath()); + QVERIFY(appFile.link(target)); + QVERIFY(QStandardPaths::findExecutable(target).isEmpty()); + QFile::remove(target); + + // findExecutable with a relative path +#ifdef Q_OS_UNIX + const QString pwd = QDir::currentPath(); + QDir::setCurrent("/bin"); + QStringList possibleResults; + possibleResults << QString::fromLatin1("/bin/sh") << QString::fromLatin1("/usr/bin/sh"); + const QString sh = QStandardPaths::findExecutable("./sh"); + QVERIFY2(possibleResults.contains(sh), qPrintable(sh)); + QDir::setCurrent(pwd); +#endif +} + +void tst_qstandardpaths::testRuntimeDirectory() +{ + const QString runtimeDir = QStandardPaths::writableLocation(QStandardPaths::RuntimeLocation); + QVERIFY(!runtimeDir.isEmpty()); + + // Check that it can automatically fix permissions +#ifdef Q_OS_UNIX + QFile file(runtimeDir); + const QFile::Permissions wantedPerms = QFile::ReadUser | QFile::WriteUser | QFile::ExeUser; + const QFile::Permissions additionalPerms = QFile::ReadOwner | QFile::WriteOwner | QFile::ExeOwner; + QCOMPARE(file.permissions(), wantedPerms | additionalPerms); + QVERIFY(file.setPermissions(wantedPerms | QFile::ExeGroup)); + const QString runtimeDirAgain = QStandardPaths::writableLocation(QStandardPaths::RuntimeLocation); + QCOMPARE(runtimeDirAgain, runtimeDir); + QCOMPARE(QFile(runtimeDirAgain).permissions(), wantedPerms | additionalPerms); +#endif +} + +void tst_qstandardpaths::testCustomRuntimeDirectory() +{ +#ifdef Q_OS_UNIX + qputenv("XDG_RUNTIME_DIR", QFile::encodeName("/tmp")); + // It's very unlikely that /tmp is 0600 or that we can chmod it + // The call below outputs + // "QStandardPaths: wrong ownership on runtime directory /tmp, 0 instead of $UID" + // but we can't reliably expect that it's owned by uid 0, I think. + const uid_t uid = geteuid(); + QTest::ignoreMessage(QtWarningMsg, + qPrintable(QString::fromLatin1("QStandardPaths: wrong ownership on runtime directory /tmp, 0 instead of %1").arg(uid))); + const QString runtimeDir = QStandardPaths::writableLocation(QStandardPaths::RuntimeLocation); + QVERIFY2(runtimeDir.isEmpty(), qPrintable(runtimeDir)); +#endif +} + +Q_DECLARE_METATYPE(QStandardPaths::StandardLocation) +void tst_qstandardpaths::testAllWritableLocations_data() +{ + QTest::addColumn("location"); + QTest::newRow("DesktopLocation") << QStandardPaths::DesktopLocation; + QTest::newRow("DocumentsLocation") << QStandardPaths::DocumentsLocation; + QTest::newRow("FontsLocation") << QStandardPaths::FontsLocation; + QTest::newRow("ApplicationsLocation") << QStandardPaths::ApplicationsLocation; + QTest::newRow("MusicLocation") << QStandardPaths::MusicLocation; + QTest::newRow("MoviesLocation") << QStandardPaths::MoviesLocation; + QTest::newRow("PicturesLocation") << QStandardPaths::PicturesLocation; + QTest::newRow("TempLocation") << QStandardPaths::TempLocation; + QTest::newRow("HomeLocation") << QStandardPaths::HomeLocation; + QTest::newRow("DataLocation") << QStandardPaths::DataLocation; +} + +void tst_qstandardpaths::testAllWritableLocations() +{ + QFETCH(QStandardPaths::StandardLocation, location); + QStandardPaths::writableLocation(location); + QStandardPaths::displayName(location); + + // Currently all desktop locations return their writable location + // with "Unix-style" paths (i.e. they use a slash, not backslash). + QString loc = QStandardPaths::writableLocation(location); + if (loc.size() > 1) // workaround for unlikely case of locations that return '/' + QCOMPARE(loc.endsWith(QLatin1Char('/')), false); +} + +QTEST_MAIN(tst_qstandardpaths) + +#include "tst_qstandardpaths.moc" -- cgit v1.2.3