plasma-framework/autotests/packagestructuretest.cpp

277 lines
9.2 KiB
C++
Raw Normal View History

/******************************************************************************
* Copyright 2007 by Aaron Seigo <aseigo@kde.org> *
* *
* This library is free software; you can redistribute it and/or *
* modify it under the terms of the GNU Library General Public *
* License as published by the Free Software Foundation; either *
* version 2 of the License, or (at your option) any later version. *
* *
* This library is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
* Library General Public License for more details. *
* *
* You should have received a copy of the GNU Library General Public License *
* along with this library; see the file COPYING.LIB. If not, write to *
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, *
* Boston, MA 02110-1301, USA. *
*******************************************************************************/
#include "packagestructuretest.h"
#include <kconfig.h>
#include <kconfiggroup.h>
2013-07-29 19:05:59 +02:00
#include <QDebug>
#include <klocalizedstring.h>
2011-07-21 14:48:12 +02:00
#include "applet.h"
2013-02-08 14:40:30 +01:00
#include "packagestructure.h"
2011-07-21 14:48:12 +02:00
#include "pluginloader.h"
2011-07-15 12:58:56 +02:00
class NoPrefixes : public Plasma::Package
{
public:
explicit NoPrefixes()
2013-02-08 14:40:30 +01:00
: Plasma::Package(new Plasma::PackageStructure)
{
setContentsPrefixPaths(QStringList());
addDirectoryDefinition("bin", QStringLiteral("bin"), QStringLiteral("bin"));
addFileDefinition("MultiplePaths", QStringLiteral("first"), QStringLiteral("Description proper"));
addFileDefinition("MultiplePaths", QStringLiteral("second"), QStringLiteral("Description proper"));
setPath(QStringLiteral("/"));
}
};
2013-02-15 15:16:54 +01:00
void PackageStructureTest::initTestCase()
{
m_packagePath = QFINDTESTDATA("data/testpackage");
ps = Plasma::PluginLoader::self()->loadPackage(QStringLiteral("Plasma/Generic"));
ps.setPath(m_packagePath);
}
void PackageStructureTest::validStructures()
{
QVERIFY(ps.hasValidStructure());
QVERIFY(!Plasma::Package().hasValidStructure());
QVERIFY(!Plasma::PluginLoader::self()->loadPackage(QStringLiteral("doesNotExist")).hasValidStructure());
}
void PackageStructureTest::validPackages()
{
QVERIFY(ps.isValid());
QVERIFY(!Plasma::Package().isValid());
QVERIFY(!Plasma::PluginLoader::self()->loadPackage(QStringLiteral("doesNotExist")).isValid());
QVERIFY(NoPrefixes().isValid());
Plasma::Package p = Plasma::PluginLoader::self()->loadPackage(QStringLiteral("Plasma/Generic"));
QVERIFY(!p.isValid());
p.setPath(QStringLiteral("/does/not/exist"));
QVERIFY(!p.isValid());
p.setPath(ps.path());
QVERIFY(p.isValid());
}
void PackageStructureTest::copyPerformance()
{
// seed the cache first
ps.filePath("mainscript");
QBENCHMARK {
Plasma::Package foo(ps);
const QString bar = foo.filePath("mainscript");
Q_UNUSED(bar);
}
}
void PackageStructureTest::mutateAfterCopy()
{
const bool mainscriptRequired = ps.isRequired("mainscript");
const QStringList imageMimeTypes = ps.mimeTypes("images");
2014-08-08 07:19:27 +02:00
const QStringList defaultMimeTypes = ps.mimeTypes("translations");
const QString packageRoot = ps.defaultPackageRoot();
const bool externalPaths = ps.allowExternalPaths();
const QString servicePrefix = ps.servicePrefix();
const QStringList contentsPrefixPaths = ps.contentsPrefixPaths();
const QList<const char *> files = ps.files();
const QList<const char *> dirs = ps.directories();
Plasma::Package copy(ps);
copy.setRequired("mainscript", !mainscriptRequired);
2014-08-08 07:19:27 +02:00
QCOMPARE(ps.isRequired("mainscript"), mainscriptRequired);
QCOMPARE(copy.isRequired("mainscript"), !mainscriptRequired);
copy = ps;
const QString copyPackageRoot = packageRoot + "more/";
copy.setDefaultPackageRoot(copyPackageRoot);
QCOMPARE(ps.defaultPackageRoot(), packageRoot);
QCOMPARE(copy.defaultPackageRoot(), copyPackageRoot);
copy = ps;
copy.setAllowExternalPaths(!externalPaths);
QCOMPARE(ps.allowExternalPaths(), externalPaths);
QCOMPARE(copy.allowExternalPaths(), !externalPaths);
copy = ps;
const QString copyServicePrefix = packageRoot + "more/";
copy.setServicePrefix(copyServicePrefix);
QCOMPARE(ps.servicePrefix(), servicePrefix);
QCOMPARE(copy.servicePrefix(), copyServicePrefix);
copy = ps;
QStringList copyContentsPrefixPaths = contentsPrefixPaths;
copyContentsPrefixPaths << QStringLiteral("more/");
2014-08-08 07:19:27 +02:00
copy.setContentsPrefixPaths(copyContentsPrefixPaths);
QCOMPARE(ps.contentsPrefixPaths(), contentsPrefixPaths);
QCOMPARE(copy.contentsPrefixPaths(), copyContentsPrefixPaths);
copy = ps;
copy.addFileDefinition("nonsense", QStringLiteral("foobar"), QString());
QCOMPARE(ps.files(), files);
QVERIFY(ps.files() != copy.files());
copy = ps;
copy.addDirectoryDefinition("nonsense", QStringLiteral("foobar"), QString());
QCOMPARE(ps.directories(), dirs);
QVERIFY(ps.directories() != copy.directories());
2014-08-08 07:24:00 +02:00
copy = ps;
copy.removeDefinition("mainscript");
QCOMPARE(ps.files(), files);
QVERIFY(ps.files() != copy.files());
#ifndef PLASMA_NO_PACKAGE_EXTRADATA
2014-08-08 07:19:27 +02:00
copy = ps;
QVERIFY(!imageMimeTypes.isEmpty());
QStringList copyMimeTypes;
copyMimeTypes << imageMimeTypes.first();
copy.setMimeTypes("images", copyMimeTypes);
QCOMPARE(ps.mimeTypes("images"), imageMimeTypes);
QCOMPARE(copy.mimeTypes("images"), copyMimeTypes);
2014-08-08 07:19:27 +02:00
copy = ps;
QStringList copyDefaultMimeTypes = defaultMimeTypes;
copyDefaultMimeTypes << QStringLiteral("rubbish");
2014-08-08 07:19:27 +02:00
copy.setDefaultMimeTypes(copyDefaultMimeTypes);
QCOMPARE(ps.mimeTypes("translations"), defaultMimeTypes);
QCOMPARE(copy.mimeTypes("translations"), copyDefaultMimeTypes);
#endif
}
void PackageStructureTest::emptyContentsPrefix()
{
2011-07-15 12:58:56 +02:00
NoPrefixes package;
QString path(package.filePath("bin", QStringLiteral("ls")));
//qDebug() << path;
QCOMPARE(path, QStringLiteral("/bin/ls"));
}
void PackageStructureTest::multiplePaths()
{
NoPrefixes package;
QCOMPARE(package.name("MultiplePaths"), QStringLiteral("Description proper"));
}
void PackageStructureTest::directories()
{
2014-04-26 01:45:47 +02:00
QList<const char *> dirs;
dirs << "config" << "data" << "images" << "theme" << "scripts" << "translations" << "ui";
2014-04-26 01:45:47 +02:00
QList<const char *> psDirs = ps.directories();
QCOMPARE(dirs.count(), psDirs.count());
foreach (const char *dir, psDirs) {
bool found = false;
foreach (const char *check, dirs) {
if (qstrcmp(dir, check)) {
found = true;
break;
}
}
QVERIFY(found);
}
foreach (const char *dir, dirs) {
bool found = false;
foreach (const char *check, psDirs) {
if (qstrcmp(dir, check)) {
found = true;
break;
}
}
QVERIFY(found);
}
}
void PackageStructureTest::requiredDirectories()
{
2014-04-26 01:45:47 +02:00
QList<const char *> dirs;
2011-07-15 12:58:56 +02:00
QCOMPARE(ps.requiredDirectories(), dirs);
}
void PackageStructureTest::files()
{
2014-04-26 01:45:47 +02:00
QList<const char *> files;
files << "mainconfigui" << "mainconfigxml" << "mainscript";
2014-04-26 01:45:47 +02:00
QList<const char *> psFiles = ps.files();
//for (int i = 0; i < psFiles.count(); ++i) {
// qDebug() << psFiles[i];
//}
foreach (const char *file, psFiles) {
bool found = false;
foreach (const char *check, files) {
if (qstrcmp(file, check)) {
found = true;
break;
}
}
QVERIFY(found);
}
}
void PackageStructureTest::requiredFiles()
{
2014-04-26 01:45:47 +02:00
QList<const char *> files;
files << "mainscript";
2014-04-26 01:45:47 +02:00
QList<const char *> psFiles = ps.requiredFiles();
QCOMPARE(files.count(), psFiles.count());
for (int i = 0; i < files.count(); ++i) {
QCOMPARE(files[i], psFiles[i]);
}
}
void PackageStructureTest::path()
{
QCOMPARE(ps.filePath("images"), QDir(m_packagePath + QStringLiteral("/contents/images")).canonicalPath());
QCOMPARE(ps.filePath("theme"), QDir(m_packagePath + QStringLiteral("/contents/theme")).canonicalPath());
QCOMPARE(ps.filePath("mainscript"), QFileInfo(m_packagePath + QStringLiteral("/contents/ui/main.qml")).canonicalFilePath());
}
void PackageStructureTest::name()
{
2011-07-15 12:58:56 +02:00
QCOMPARE(ps.name("config"), i18n("Configuration Definitions"));
QCOMPARE(ps.name("mainscript"), i18n("Main Script File"));
}
void PackageStructureTest::required()
{
2011-07-15 12:58:56 +02:00
QVERIFY(ps.isRequired("mainscript"));
}
2011-05-06 12:26:39 +02:00
void PackageStructureTest::mimeTypes()
{
2011-05-06 12:26:39 +02:00
QStringList mimeTypes;
mimeTypes << QStringLiteral("image/svg+xml") << QStringLiteral("image/png") << QStringLiteral("image/jpeg");
2011-07-15 12:58:56 +02:00
QCOMPARE(ps.mimeTypes("images"), mimeTypes);
QCOMPARE(ps.mimeTypes("theme"), mimeTypes);
}
QTEST_MAIN(PackageStructureTest)