--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tests/auto/databasemanager/tst_databasemanager.cpp Wed Aug 25 15:49:42 2010 +0300
@@ -0,0 +1,1316 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Qt Mobility Components.
+**
+** $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 <QtTest/QtTest>
+#include <QtCore>
+#define private public
+#include <qserviceinterfacedescriptor.h>
+#include <qserviceinterfacedescriptor_p.h>
+#include "../qsfwtestutil.h"
+#include <databasemanager_p.h>
+
+#if defined(Q_OS_SYMBIAN)
+# define TESTDATA_DIR "."
+#endif
+
+QTM_USE_NAMESPACE
+
+class tst_DatabaseManager: public QObject
+{
+ Q_OBJECT
+private slots:
+ void initTestCase();
+ void registerService();
+ void getInterfaces();
+ void getServiceNames();
+ void defaultService();
+ void unregisterService();
+#ifdef Q_OS_UNIX
+ void permissions();
+ void onlyUserDbAvailable();
+ void defaultServiceCornerCases();
+#endif
+ void nonWritableSystemDb();
+ void CWRTXmlCompatability();
+ void cleanupTestCase();
+private:
+ bool compareDescriptor(QServiceInterfaceDescriptor interface,
+ QString interfaceName,
+ QString serviceName,
+ int majorVersion,
+ int minorVersion);
+
+ bool compareDescriptor(QServiceInterfaceDescriptor interface,
+ QString interfaceName,
+ QString serviceName,
+ int majorVersion,
+ int minorVersion,
+ QStringList capabilities,
+ QString filePath="",
+ QString serviceDescription="",
+ QString interfaceDescription="");
+
+ void clean();
+ void modifyPermissionSet(QFile::Permissions &permsSet,
+ int perm);
+
+ DatabaseManager *m_dbm;
+ QDir m_testdir;
+};
+
+void tst_DatabaseManager::initTestCase()
+{
+ QSfwTestUtil::setupTempUserDb();
+ QSfwTestUtil::setupTempSystemDb();
+ QSfwTestUtil::removeDirectory(QSfwTestUtil::tempSettingsPath());
+ m_dbm = new DatabaseManager;
+}
+
+void tst_DatabaseManager::registerService()
+{
+ m_testdir = QDir(TESTDATA_DIR "/testdata");
+ ServiceMetaData parser("");
+
+ QStringList userServiceFiles;
+ userServiceFiles << "ServiceAcme.xml" << "ServiceLuthorCorp.xml"
+ << "ServicePrimatech.xml"
+ << "ServiceDharma_Swan.xml"
+ << "ServiceDharma_Pearl.xml"
+ << "ServiceDharma_Flame.xml"
+ << "ServiceDecepticon.xml";
+
+ foreach (const QString &serviceFile, userServiceFiles) {
+ parser.setDevice(new QFile(m_testdir.absoluteFilePath(serviceFile)));
+ QVERIFY(parser.extractMetadata());
+ ServiceMetaDataResults results = parser.parseResults();
+ QVERIFY(m_dbm->registerService(results, DatabaseManager::UserScope));
+ }
+
+ QStringList systemServiceFiles;
+ systemServiceFiles << "ServiceOmni.xml" << "ServiceWayneEnt.xml"
+ << "ServiceDharma_Hydra.xml"
+ << "ServiceDharma_Orchid.xml"
+ << "ServiceAutobot.xml";
+ foreach (const QString &serviceFile, systemServiceFiles) {
+ parser.setDevice(new QFile(m_testdir.absoluteFilePath(serviceFile)));
+ QVERIFY(parser.extractMetadata());
+ ServiceMetaDataResults results = parser.parseResults();
+ QVERIFY(m_dbm->registerService(results, DatabaseManager::SystemScope));
+ }
+}
+
+void tst_DatabaseManager::getInterfaces()
+{
+ QString iface("com.omni.device.accelerometer");
+ QServiceFilter filter(iface);
+ QList<QServiceInterfaceDescriptor> descriptors;
+ descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);
+ QCOMPARE(descriptors.count(), 5);
+ QVERIFY(compareDescriptor(descriptors[0], iface, "LuthorCorp", 1,2));
+ QCOMPARE(descriptors[0].scope(), QService::UserScope);
+ QVERIFY(compareDescriptor(descriptors[1], iface, "Primatech", 1, 4));
+ QCOMPARE(descriptors[1].scope(), QService::UserScope);
+ QVERIFY(compareDescriptor(descriptors[2], iface, "Primatech", 1, 2));
+ QCOMPARE(descriptors[2].scope(), QService::UserScope);
+ QVERIFY(compareDescriptor(descriptors[3], iface, "OMNI", 1, 1));
+ QCOMPARE(descriptors[3].scope(), QService::SystemScope);
+ QVERIFY(compareDescriptor(descriptors[4], iface, "WayneEnt", 2, 0));
+ QCOMPARE(descriptors[4].scope(), QService::SystemScope);
+
+ //check that we can get descriptors for a service spread
+ //over the user and system databases
+ filter.setServiceName("DharmaInitiative");
+ filter.setInterface("");
+ descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);
+ QCOMPARE(descriptors.count(),10);
+
+ QStringList capabilities;
+ QVERIFY(compareDescriptor(descriptors[0], "com.dharma.electro.discharge", "DharmaInitiative", 4, 0, capabilities, "C:/island/swan.dll"));
+ QCOMPARE(descriptors[0].scope(), QService::UserScope);
+ QVERIFY(compareDescriptor(descriptors[1], "com.dharma.electro.discharge","DharmaInitiative", 8, 0, capabilities, "C:/island/pearl.dll"));
+ QCOMPARE(descriptors[1].scope(), QService::UserScope);
+ QVERIFY(compareDescriptor(descriptors[2], "com.dharma.electro.discharge", "DharmaInitiative", 15, 0, capabilities, "C:/island/flame.dll"));
+ QCOMPARE(descriptors[2].scope(), QService::UserScope);
+ QVERIFY(compareDescriptor(descriptors[3], "com.dharma.radio", "DharmaInitiative", 8, 15, capabilities, "C:/island/flame.dll"));
+ QCOMPARE(descriptors[3].scope(), QService::UserScope);
+ QVERIFY(compareDescriptor(descriptors[4], "com.dharma.electro.discharge", "DharmaInitiative", 16, 0, capabilities, "C:/island/flame.dll"));
+ QCOMPARE(descriptors[4].scope(), QService::UserScope);
+ QVERIFY(compareDescriptor(descriptors[5], "com.dharma.electro.discharge", "DharmaInitiative", 23, 0, capabilities, "C:/island/hydra.dll"));
+ QCOMPARE(descriptors[5].scope(), QService::SystemScope);
+ QVERIFY(compareDescriptor(descriptors[6], "com.dharma.electro.discharge", "DharmaInitiative", 42, 0, capabilities, "C:/island/hydra.dll"));
+ QCOMPARE(descriptors[6].scope(), QService::SystemScope);
+ QVERIFY(compareDescriptor(descriptors[7], "com.dharma.cage", "DharmaInitiative", 3, 16, capabilities, "C:/island/hydra.dll"));
+ QCOMPARE(descriptors[7].scope(), QService::SystemScope);
+ //note; the following system interface implementation overlaps with an interface implementation already provided in the user database
+ QVERIFY(compareDescriptor(descriptors[8], "com.dharma.electro.discharge", "DharmaInitiative", 4, 0, capabilities, "C:/island/orchid.dll"));
+ QCOMPARE(descriptors[8].scope(), QService::SystemScope);
+ QVERIFY(compareDescriptor(descriptors[9], "com.dharma.wheel", "DharmaInitiative", 1, 0, capabilities, "C:/island/orchid.dll"));
+ QCOMPARE(descriptors[9].scope(), QService::SystemScope);
+
+ //do a system database only search
+ descriptors = m_dbm->getInterfaces(filter, DatabaseManager::SystemScope);
+ QCOMPARE(descriptors.count(), 5);
+ QVERIFY(compareDescriptor(descriptors[0], "com.dharma.electro.discharge", "DharmaInitiative", 23, 0, capabilities, "C:/island/hydra.dll"));
+ QCOMPARE(descriptors[0].scope(), QService::SystemScope);
+ QVERIFY(compareDescriptor(descriptors[1], "com.dharma.electro.discharge", "DharmaInitiative", 42, 0, capabilities, "C:/island/hydra.dll"));
+ QCOMPARE(descriptors[1].scope(), QService::SystemScope);
+ QVERIFY(compareDescriptor(descriptors[2], "com.dharma.cage", "DharmaInitiative", 3, 16, capabilities, "C:/island/hydra.dll"));
+ QCOMPARE(descriptors[2].scope(), QService::SystemScope);
+ QVERIFY(compareDescriptor(descriptors[3], "com.dharma.electro.discharge", "DharmaInitiative", 4, 0, capabilities, "C:/island/orchid.dll"));
+ QCOMPARE(descriptors[3].scope(), QService::SystemScope);
+ QVERIFY(compareDescriptor(descriptors[4], "com.dharma.wheel", "DharmaInitiative", 1, 0, capabilities, "C:/island/orchid.dll"));
+ QCOMPARE(descriptors[4].scope(), QService::SystemScope);
+
+ //search for a non-existent interface
+ filter.setServiceName("");
+ filter.setInterface("com.omni.device.fluxcapacitor");
+ descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);
+ QCOMPARE(descriptors.count(), 0);
+ QCOMPARE(m_dbm->lastError().code(), DBError::NoError);
+}
+
+void tst_DatabaseManager::getServiceNames()
+{
+ //try getting a lost of service names only in user database
+ QStringList serviceNames;
+ serviceNames = m_dbm->getServiceNames("", DatabaseManager::UserOnlyScope);
+ QStringList expectedNames;
+ expectedNames << "acme" << "LuthorCorp" << "Primatech" << "DharmaInitiative" << "Decepticon";
+ QCOMPARE(serviceNames.count(), expectedNames.count());
+ foreach(const QString &expectedName, expectedNames)
+ QVERIFY(serviceNames.contains(expectedName, Qt::CaseInsensitive));
+
+ //try getting a list of service names in the system database
+ serviceNames = m_dbm->getServiceNames("", DatabaseManager::SystemScope);
+ expectedNames.clear();
+ expectedNames << "OMNI" << "WayneEnt" << "DharmaInitiative" << "Autobot";
+ QCOMPARE(serviceNames.count(), expectedNames.count());
+ foreach(const QString &expectedName, expectedNames)
+ QVERIFY(serviceNames.contains(expectedName, Qt::CaseInsensitive));
+
+ //try getting a list of service names from both databases
+ //and ensure there are no duplicates
+ serviceNames = m_dbm->getServiceNames("", DatabaseManager::UserScope);
+ expectedNames.clear();
+ expectedNames << "acme" << "LuthorCorp" << "Primatech" << "omni" << "WayneEnt"
+ << "DharmaInitiative" << "Autobot" << "Decepticon";
+ QCOMPARE(serviceNames.count(), expectedNames.count());
+ foreach(const QString &expectedName, expectedNames)
+ QVERIFY(serviceNames.contains(expectedName, Qt::CaseInsensitive));
+
+ //try getting names of services that implement particular interface
+ serviceNames = m_dbm->getServiceNames("com.omni.device.accelerometer", DatabaseManager::UserScope);
+ expectedNames.clear();
+ expectedNames << "LuthorCorp" << "Primatech" << "omni" << "WayneEnt";
+ QCOMPARE(serviceNames.count(), expectedNames.count());
+ foreach(const QString &expectedName, expectedNames)
+ QVERIFY(serviceNames.contains(expectedName, Qt::CaseInsensitive));
+}
+
+void tst_DatabaseManager::defaultService()
+{
+ QServiceInterfaceDescriptor descriptor;
+
+ //get a user default service at user scope
+ descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",
+ DatabaseManager::UserScope);
+ QVERIFY(compareDescriptor(descriptor,"com.omni.device.accelerometer", "LuthorCorp", 1, 2));
+ QVERIFY(descriptor.scope()==QService::UserScope);
+
+ //get a sytem default from user scope
+ descriptor = m_dbm->interfaceDefault("com.Dharma.wheel", DatabaseManager::UserScope);
+ QVERIFY(compareDescriptor(descriptor,"com.dharma.wheel", "DharmaInitiative", 1,0));
+ QVERIFY(descriptor.scope() == QService::SystemScope);
+
+ //get a system default service at system scope
+ descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",
+ DatabaseManager::SystemScope);
+ QVERIFY(compareDescriptor(descriptor, "com.omni.device.accelerometer", "omni", 1, 1));
+
+ //set a user default from a user interface implementation
+ QList<QServiceInterfaceDescriptor> descriptors;
+ QServiceFilter filter;
+ filter.setServiceName("Primatech");
+ filter.setInterface("com.omni.device.accelerometer", "1.4");
+ descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);
+ QCOMPARE(descriptors.count(), 1);
+
+ QVERIFY(m_dbm->setInterfaceDefault(descriptors[0], DatabaseManager::UserScope));
+ descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",
+ DatabaseManager::UserScope);
+ QVERIFY(compareDescriptor(descriptor,"com.omni.device.accelerometer", "Primatech", 1, 4));
+ QVERIFY(descriptor.scope() == QService::UserScope);
+
+ //set a system default from a system interface implementation
+ filter.setServiceName("WayneEnt");
+ filter.setInterface("com.omni.device.accelerometer","2.0");
+ descriptors = m_dbm->getInterfaces(filter, DatabaseManager::SystemScope);
+ QCOMPARE(descriptors.count(), 1);
+
+ QVERIFY(m_dbm->setInterfaceDefault(descriptors[0], DatabaseManager::SystemScope));
+ descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",
+ DatabaseManager::SystemScope);
+ QVERIFY(compareDescriptor(descriptor, "com.omni.device.accelerometer", "WayneEnt", 2,0));
+ QVERIFY(descriptor.scope() == QService::SystemScope );
+
+ //set a user default with a system interface descriptor
+ filter.setServiceName("omni");
+ filter.setInterface("com.omni.device.accelerometer","1.1");
+ descriptors = m_dbm->getInterfaces(filter, DatabaseManager::SystemScope);
+ QCOMPARE(descriptors.count(), 1);
+ QVERIFY(m_dbm->setInterfaceDefault(descriptors[0], DatabaseManager::UserScope));
+ descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",
+ DatabaseManager::UserScope);
+ QVERIFY(descriptor.isValid());
+ QVERIFY(compareDescriptor(descriptor, "com.omni.device.accelerometer", "omni", 1, 1));
+ QVERIFY(descriptor.scope() == QService::SystemScope );
+
+ //set a system default using a user interface descriptor
+ filter.setServiceName("Primatech");
+ filter.setInterface("com.omni.device.accelerometer","1.4");
+ descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);
+ QCOMPARE(descriptors.count(), 1);
+
+ QVERIFY(!m_dbm->setInterfaceDefault(descriptors[0], DatabaseManager::SystemScope));
+ QCOMPARE(m_dbm->lastError().code(), DBError::InvalidDescriptorScope);
+
+ // == try setting defaults using setInterfaceDefault(serviceName, interfaceName, ...)
+ //set a local default in the user scope database
+ descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",
+ DatabaseManager::UserScope);
+ QVERIFY(compareDescriptor(descriptor, "com.omni.device.accelerometer", "omni", 1, 1));
+ QVERIFY(m_dbm->setInterfaceDefault("LuthorCorp", "com.omni.device.accelerometer",
+ DatabaseManager::UserScope));
+ descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",
+ DatabaseManager::UserScope);
+ QVERIFY(compareDescriptor(descriptor, "com.omni.device.accelerometer", "LuthorCorp", 1, 2));
+
+ //set a system default in the user scope database
+ descriptor = m_dbm->interfaceDefault("com.dharma.electro.disCHARGE",
+ DatabaseManager::UserScope);
+ QVERIFY(compareDescriptor(descriptor, "com.dharma.electro.discharge",
+ "DharmaInitiative", 4, 0));
+ QVERIFY(descriptor.scope() == QService::UserScope);
+ m_dbm->setInterfaceDefault("DharmaInitiative", "com.dharma.electro.discharge",
+ DatabaseManager::UserScope);
+
+ descriptor = m_dbm->interfaceDefault("com.dharma.electro.discharge",
+ DatabaseManager::UserScope);
+ QVERIFY(m_dbm->lastError().code() == DBError::NoError);
+ QVERIFY(compareDescriptor(descriptor, "com.dharma.electro.discharge",
+ "DharmaInitiative", 42, 0));
+
+ //set a user default in the user scope database but where there
+ //exist interface implementations in both user and system databases
+ //also check that the system scope default has not changed
+ filter.setServiceName("Autobot");
+ filter.setInterface("com.cybertron.transform", "2.5", QServiceFilter::ExactVersionMatch );
+ descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);
+ QCOMPARE(descriptors.count(), 1);
+ m_dbm->setInterfaceDefault(descriptors[0], DatabaseManager::UserScope);
+ descriptor = m_dbm->interfaceDefault("com.cybertron.transform",
+ DatabaseManager::UserScope);
+ QVERIFY(compareDescriptor(descriptors[0], "com.cybertron.transform",
+ "Autobot", 2, 5));
+ descriptor = m_dbm->interfaceDefault("com.cybertron.transform",
+ DatabaseManager::SystemScope);
+ QVERIFY(compareDescriptor(descriptors[0], "com.cybertron.transform",
+ "Autobot", 2, 5));
+
+ m_dbm->setInterfaceDefault("Decepticon", "com.cybertron.transform", DatabaseManager::UserScope);
+ descriptor = m_dbm->interfaceDefault("com.cybertron.transform",
+ DatabaseManager::UserScope);
+ QVERIFY(compareDescriptor(descriptor, "com.cybertron.transform",
+ "Decepticon", 5,3));
+ descriptor = m_dbm->interfaceDefault("com.cybertron.transform",
+ DatabaseManager::SystemScope);
+ QVERIFY(compareDescriptor(descriptors[0], "com.cybertron.transform",
+ "Autobot", 2, 5));
+
+ //Look up a default service for a non-existent interface
+ descriptor = m_dbm->interfaceDefault("com.omni.device.fluxcapacitor", DatabaseManager::UserScope);
+ QVERIFY(!descriptor.isValid());
+ QCOMPARE(m_dbm->lastError().code(), DBError::NotFound);
+}
+
+void tst_DatabaseManager::unregisterService()
+{
+ //try remove a service that only exists in the user database
+ QServiceFilter filter;
+ filter.setServiceName("acme");
+ QVERIFY(m_dbm->getInterfaces(filter, DatabaseManager::UserScope).count() > 0);
+ m_dbm->unregisterService("acme", DatabaseManager::UserScope);
+ QCOMPARE(m_dbm->getInterfaces(filter, DatabaseManager::UserScope).count(), 0);
+
+ //try remove a service that only exists in the system database
+ filter.setServiceName("omni");
+ QVERIFY(m_dbm->getInterfaces(filter, DatabaseManager::SystemScope).count() > 0);
+ QVERIFY(m_dbm->getInterfaces(filter, DatabaseManager::UserScope).count() > 0);
+ m_dbm->unregisterService("omni", DatabaseManager::SystemScope);
+ QCOMPARE(m_dbm->getInterfaces(filter, DatabaseManager::SystemScope).count(), 0);
+ QCOMPARE(m_dbm->getInterfaces(filter, DatabaseManager::UserScope).count(), 0);
+
+ //try remove a service from the user database that also exists in the system database
+ filter.setServiceName("dharmainitiative");
+ int systemCount = m_dbm->getInterfaces(filter, DatabaseManager::SystemScope).count();
+ QVERIFY(m_dbm->getInterfaces(filter, DatabaseManager::SystemScope).count() > 0);
+ QVERIFY(m_dbm->getInterfaces(filter, DatabaseManager::UserScope).count() > 0);
+ m_dbm->unregisterService("dharmainitiative", DatabaseManager::UserScope);
+ QVERIFY(m_dbm->getInterfaces(filter, DatabaseManager::SystemScope).count() > 0);
+ QCOMPARE(m_dbm->getInterfaces(filter, DatabaseManager::UserScope).count(), systemCount);
+
+ //re-add the service to the user database for the next test
+ ServiceMetaData parser("");
+ parser.setDevice(new QFile(m_testdir.absoluteFilePath("ServiceDharma_Swan.xml")));
+ QVERIFY(parser.extractMetadata());
+ ServiceMetaDataResults results = parser.parseResults();
+ QVERIFY(m_dbm->registerService(results, DatabaseManager::UserScope));
+
+ //try to remove a service from the system database that also exist in the user database
+ filter.setServiceName("dharmainitiative");
+ int userCount = m_dbm->getInterfaces(filter, DatabaseManager::UserScope).count()
+ - m_dbm->getInterfaces(filter, DatabaseManager::SystemScope).count();
+ QVERIFY(userCount > 0);
+ QVERIFY(m_dbm->getInterfaces(filter, DatabaseManager::SystemScope).count() > 0);
+ QVERIFY(m_dbm->getInterfaces(filter, DatabaseManager::UserScope).count() > 0);
+ m_dbm->unregisterService("dharmainitiative", DatabaseManager::SystemScope);
+ QCOMPARE(m_dbm->getInterfaces(filter, DatabaseManager::SystemScope).count(), 0);
+ QCOMPARE(m_dbm->getInterfaces(filter, DatabaseManager::UserScope).count(), userCount);
+
+ //try and drop a table in the database by SQL injection
+ QVERIFY(!m_dbm->unregisterService("; drop table Interface;", DatabaseManager::UserScope));
+ QCOMPARE(m_dbm->lastError().code(), DBError::NotFound);
+
+ clean();
+}
+
+bool tst_DatabaseManager::compareDescriptor(QServiceInterfaceDescriptor interface,
+ QString interfaceName, QString serviceName, int majorVersion, int minorVersion)
+{
+ if (interface.d == NULL )
+ return false;
+ interface.d->attributes[QServiceInterfaceDescriptor::Capabilities] = QStringList();
+
+ return compareDescriptor(interface, interfaceName, serviceName, majorVersion, minorVersion,
+ QStringList());
+}
+
+bool tst_DatabaseManager::compareDescriptor(QServiceInterfaceDescriptor interface,
+ QString interfaceName, QString serviceName, int majorVersion, int minorVersion,
+ QStringList capabilities, QString filePath, QString serviceDescription,
+ QString interfaceDescription)
+{
+
+ if(interface.interfaceName().compare(interfaceName, Qt::CaseInsensitive) !=0) {
+ qWarning() << "Interface name mismatch: expected =" << interfaceName
+ << " actual =" << interface.interfaceName();
+ return false;
+ }
+
+ if (interface.serviceName().compare(serviceName, Qt::CaseInsensitive) != 0) {
+ qWarning() << "Service name mismatch: expected =" << serviceName
+ << " actual =" << interface.serviceName();
+ return false;
+ }
+
+ if (interface.majorVersion() != majorVersion) {
+ qWarning() << "Major version mismatch: expected =" << majorVersion
+ << " actual =" << interface.majorVersion();
+ return false;
+ }
+
+ if (interface.minorVersion() != minorVersion) {
+ qWarning() << "Minor version mismatch: expected =" << minorVersion
+ << " actual =" << interface.minorVersion();
+ return false;
+ }
+
+ if (capabilities.count() != 0 || interface.attribute(QServiceInterfaceDescriptor::Capabilities).toStringList().count() != 0 ) {
+ QStringList securityCapabilities;
+ securityCapabilities = interface.attribute(QServiceInterfaceDescriptor::Capabilities).toStringList();
+
+ if(securityCapabilities.count() != capabilities.count()) {
+ qWarning() << "Capabilities count mismatch: expected =" << capabilities.count()
+ << " actual="<< securityCapabilities.count()
+ << "\texpected capabilities =" << capabilities
+ << "actual capabilities =" << securityCapabilities;
+ return false;
+ }
+
+ for (int i = 0; i < securityCapabilities.count(); ++i) {
+ if (securityCapabilities[i] != capabilities[i]) {
+ qWarning() << "Capability mismatch: expected =" << capabilities[i]
+ << " actual =" << securityCapabilities[i];
+ return false;
+ }
+ }
+ }
+
+ if (!filePath.isEmpty()) {
+ if (interface.attribute(QServiceInterfaceDescriptor::Location).toString() != filePath) {
+ qWarning() << "File path mismatch: expected =" << filePath
+ << " actual =" << interface.attribute(QServiceInterfaceDescriptor::Location).toString();
+ return false;
+ }
+ }
+ if (!serviceDescription.isEmpty()) {
+ if (interface.attribute(QServiceInterfaceDescriptor::ServiceDescription).toString() != serviceDescription) {
+ qWarning() << "Service Description mismatch: expected =" << serviceDescription
+ << " actual=" << interface.attribute(QServiceInterfaceDescriptor::ServiceDescription).toString();
+ return false;
+ }
+ }
+ if (!interfaceDescription.isEmpty()) {
+ if (interface.attribute(QServiceInterfaceDescriptor::InterfaceDescription).toString() != interfaceDescription) {
+ qWarning() << "Interface Description mismatch: expected =" << interfaceDescription
+ << " actual =" << interface.attribute(QServiceInterfaceDescriptor::InterfaceDescription).toString();
+ return false;
+ }
+
+ }
+ return true;
+}
+#ifdef Q_OS_UNIX
+void tst_DatabaseManager::permissions()
+{
+ ServiceMetaDataResults results;
+ //try create a user scope database with no permissions
+ //to create the directory needed for the user db
+ QString userDir = QSfwTestUtil::userDirectory();
+ QString systemDir = QSfwTestUtil::systemDirectory();
+
+ QDir::root().mkpath(userDir);
+ QDir::root().mkpath(systemDir);
+
+ QFile::Permissions userPermsSet = QFile::permissions(userDir);
+ modifyPermissionSet(userPermsSet, ~QFile::ExeOwner);
+ QVERIFY(QFile::setPermissions(userDir, userPermsSet));
+
+ m_testdir = QDir(TESTDATA_DIR "/testdata");
+ ServiceMetaData parser("");
+ parser.setDevice(new QFile(m_testdir.absoluteFilePath("ServiceAcme.xml")));
+ QVERIFY(parser.extractMetadata());
+ m_dbm = new DatabaseManager;
+ results = parser.parseResults();
+ QVERIFY(!m_dbm->registerService(results, DatabaseManager::UserScope));
+ QCOMPARE(m_dbm->lastError().code(), DBError::CannotOpenServiceDb);
+
+ //try to create a system scope database with no permission to
+ //create the directory needed for the system db
+ QFile::Permissions systemPermsSet = QFile::permissions(systemDir);
+ modifyPermissionSet(systemPermsSet, ~QFile::ExeOwner);
+ QVERIFY(QFile::setPermissions(systemDir, systemPermsSet));
+
+ QVERIFY(!m_dbm->registerService(results, DatabaseManager::SystemScope));
+ QCOMPARE(m_dbm->lastError().code(), DBError::CannotOpenServiceDb);
+
+ //restore directory permissions
+ modifyPermissionSet(userPermsSet, QFile::ExeOwner);
+ QVERIFY(QFile::setPermissions(userDir, userPermsSet));
+ modifyPermissionSet(systemPermsSet, QFile::ExeOwner);
+ QVERIFY(QFile::setPermissions(systemDir, systemPermsSet));
+
+ //try to create a user scope database without sufficient permissions
+ //for creation of the database file
+ QDir::root().mkpath(userDir + "/Nokia/");
+ userPermsSet = QFile::permissions(userDir + "/Nokia/");
+ modifyPermissionSet(userPermsSet, ~QFile::WriteOwner);
+ QVERIFY(QFile::setPermissions(userDir + "/Nokia/", userPermsSet));
+ QVERIFY(!m_dbm->registerService(results, DatabaseManager::UserScope));
+ QCOMPARE(m_dbm->lastError().code(), DBError::CannotOpenServiceDb);
+
+ //restore user directory permissions and create and populate a user database
+ modifyPermissionSet(userPermsSet, QFile::WriteOwner);
+ QVERIFY(QFile::setPermissions(userDir + "/Nokia", userPermsSet));
+ QVERIFY(m_dbm->registerService(results, DatabaseManager::UserScope));
+ QString userDbFilePath = m_dbm->m_userDb->databasePath();
+
+ //try to access database without read permissions
+ userPermsSet = QFile::permissions(userDbFilePath);
+ modifyPermissionSet(userPermsSet, ~QFile::ReadOwner);
+
+ QVERIFY(QFile::setPermissions(userDbFilePath, userPermsSet));
+ delete m_dbm;
+ QServiceFilter filter;
+ m_dbm = new DatabaseManager;
+ QList<QServiceInterfaceDescriptor> descriptors;
+ descriptors= m_dbm->getInterfaces(filter, DatabaseManager::UserScope);
+ QVERIFY(!m_dbm->m_userDb->isOpen());
+ QVERIFY(!m_dbm->m_systemDb->isOpen());
+ QCOMPARE(m_dbm->lastError().code(), DBError::CannotOpenServiceDb);
+
+ //restore permissions
+ modifyPermissionSet(userPermsSet, QFile::ReadOwner);
+ QVERIFY(QFile::setPermissions(userDbFilePath, userPermsSet));
+
+ //try to access an artificially corrupted user database
+ QFile userDbFile(userDbFilePath);
+ QFile acmeFile(m_testdir.absoluteFilePath("ServiceAcme.xml"));
+ QVERIFY(acmeFile.open(QIODevice::ReadWrite));
+ QVERIFY(userDbFile.open(QIODevice::ReadWrite));
+ userDbFile.resize(50);
+ userDbFile.seek(100);
+ QVERIFY(userDbFile.write(acmeFile.readAll()) != -1);
+ userDbFile.close();
+ acmeFile.close();
+ descriptors= m_dbm->getInterfaces(filter, DatabaseManager::UserScope);
+ QVERIFY(!m_dbm->m_userDb->isOpen());
+ QVERIFY(!m_dbm->m_systemDb->isOpen());
+ QCOMPARE(m_dbm->lastError().code(), DBError::InvalidDatabaseFile);
+
+ //recreate a valid user database
+ userDbFile.remove();
+ QVERIFY(m_dbm->registerService(results, DatabaseManager::UserScope));
+ filter.setServiceName("");
+ filter.setInterface("");
+ descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);
+ QCOMPARE(descriptors.count(), 5);
+
+ //try to register a service in the user db without write permissions
+ delete m_dbm;
+ userPermsSet = QFile::permissions(userDbFilePath);
+ modifyPermissionSet(userPermsSet, ~QFile::WriteOwner);
+ QVERIFY(QFile::setPermissions(userDbFilePath, userPermsSet));
+ m_dbm = new DatabaseManager;
+ parser.setDevice(new QFile(m_testdir.absoluteFilePath("ServiceLuthorCorp.xml")));
+ QVERIFY(parser.extractMetadata());
+ results = parser.parseResults();
+ QVERIFY(!m_dbm->registerService(results, DatabaseManager::UserScope));
+ QCOMPARE(m_dbm->lastError().code(), DBError::NoWritePermissions);
+ descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);
+ QCOMPARE(descriptors.count(), 5);
+
+ modifyPermissionSet(userPermsSet, QFile::WriteOwner);
+ QVERIFY(QFile::setPermissions(userDbFilePath, userPermsSet));
+ clean();
+}
+
+void tst_DatabaseManager::onlyUserDbAvailable()
+{
+ QString userNokiaDir = QSfwTestUtil::userDirectory() + "/Nokia/";
+ QString systemNokiaDir = QSfwTestUtil::systemDirectory() + "/Nokia/";
+
+ QDir::root().mkpath(userNokiaDir);
+ QDir::root().mkpath(systemNokiaDir);
+ QFile::Permissions systemPermsSet = QFile::permissions(systemNokiaDir);
+ modifyPermissionSet(systemPermsSet, ~QFile::WriteOwner);
+ QFile::setPermissions(systemNokiaDir, systemPermsSet);
+
+ m_dbm = new DatabaseManager;
+
+ //check that we can register services with the user database
+ ServiceMetaData parser("");
+
+ QStringList userServiceFiles;
+ userServiceFiles << "ServiceAcme.xml" << "ServiceLuthorCorp.xml"
+ << "ServicePrimatech.xml";
+ foreach (const QString &serviceFile, userServiceFiles) {
+ parser.setDevice(new QFile(m_testdir.absoluteFilePath(serviceFile)));
+ QVERIFY(parser.extractMetadata());
+ ServiceMetaDataResults results = parser.parseResults();
+ QVERIFY(m_dbm->registerService(results, DatabaseManager::UserScope));
+ QCOMPARE(m_dbm->lastError().code(), DBError::NoError);
+ }
+
+ QVERIFY(m_dbm->m_userDb->isOpen());
+ QVERIFY(!m_dbm->m_systemDb->isOpen());
+
+ parser.setDevice(new QFile(m_testdir.absoluteFilePath("ServiceOmni.xml")));
+ ServiceMetaDataResults results = parser.parseResults();
+ QVERIFY(!m_dbm->registerService(results, DatabaseManager::SystemScope));
+ QCOMPARE(m_dbm->lastError().code(), DBError::CannotOpenServiceDb);
+
+ QServiceFilter filter;
+ filter.setServiceName("");
+ filter.setInterface("");
+ QList<QServiceInterfaceDescriptor> descriptors;
+ descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);
+ QCOMPARE(descriptors.count(), 8);
+ QCOMPARE(m_dbm->lastError().code(), DBError::NoError);
+
+ //Use getInterfaces where the database has not already been opened
+ //( via a previous call to register service)
+ delete m_dbm;
+ m_dbm = new DatabaseManager;
+ descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);
+ QCOMPARE(descriptors.count(), 8);
+ QVERIFY(m_dbm->m_userDb->isOpen());
+ QVERIFY(!m_dbm->m_systemDb->isOpen());
+ QCOMPARE(m_dbm->lastError().code(), DBError::NoError);
+
+ //Use getServiceNames where the database has not already been opened
+ delete m_dbm;
+ m_dbm = new DatabaseManager;
+ QStringList serviceNames;
+ serviceNames = m_dbm->getServiceNames("", DatabaseManager::UserScope);
+ QCOMPARE(serviceNames.count(), 3);
+ QCOMPARE(m_dbm->lastError().code(), DBError::NoError);
+
+ //Use defaultService where database has not already been opened
+ delete m_dbm;
+ m_dbm = new DatabaseManager;
+ QServiceInterfaceDescriptor descriptor;
+ descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",
+ DatabaseManager::UserScope);
+ QVERIFY(compareDescriptor(descriptor, "com.omni.device.accelerometer",
+ "LuthorCorp", 1, 2));
+ QCOMPARE(m_dbm->lastError().code(), DBError::NoError);
+ QVERIFY(m_dbm->m_userDb->isOpen());
+ QVERIFY(!m_dbm->m_systemDb->isOpen());
+
+ //Use setInterfaceDefault(servicename, interfacename, scope)
+ delete m_dbm;
+ m_dbm = new DatabaseManager;
+ QVERIFY(m_dbm->setInterfaceDefault("Primatech", "com.omni.device.accelerometer",
+ DatabaseManager::UserScope));
+ QCOMPARE(m_dbm->lastError().code(), DBError::NoError);
+ descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",
+ DatabaseManager::UserScope);
+ QVERIFY(compareDescriptor(descriptor, "com.omni.device.accelerometer",
+ "Primatech", 1, 4));
+ QCOMPARE(m_dbm->lastError().code(), DBError::NoError);
+
+ QVERIFY(!m_dbm->setInterfaceDefault("Primatech", "com.omni.device.accelerometer",
+ DatabaseManager::SystemScope));
+ QCOMPARE(m_dbm->lastError().code(), DBError::CannotOpenServiceDb);
+
+ //Use setInterfaceDefault(descriptor, scope)
+ filter.setServiceName("Primatech");
+ filter.setInterface("com.omni.device.accelerometer", "1.2",
+ QServiceFilter::ExactVersionMatch);
+ descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);
+ QCOMPARE(descriptors.count(), 1);
+ QVERIFY(compareDescriptor(descriptors[0], "com.omni.device.accelerometer",
+ "Primatech", 1,2));
+ QVERIFY(m_dbm->setInterfaceDefault(descriptors[0],
+ DatabaseManager::UserScope));
+ QCOMPARE(m_dbm->lastError().code(), DBError::NoError);
+ descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",
+ DatabaseManager::UserScope);
+ QCOMPARE(m_dbm->lastError().code(), DBError::NoError);
+ QVERIFY(compareDescriptor(descriptor, "com.omni.device.accelerometer",
+ "Primatech", 1,2));
+ QVERIFY(!m_dbm->setInterfaceDefault(descriptor, DatabaseManager::SystemScope));
+ QCOMPARE(m_dbm->lastError().code(), DBError::InvalidDescriptorScope);
+
+ //Use unregisterService()
+ delete m_dbm;
+ m_dbm = new DatabaseManager;
+ QVERIFY(m_dbm->unregisterService("primatech", DatabaseManager::UserScope));
+ QCOMPARE(m_dbm->lastError().code(), DBError::NoError);
+ filter.setServiceName("Primatech");
+ filter.setInterface("");
+ descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);
+ QCOMPARE(m_dbm->lastError().code(), DBError::NoError);
+ QCOMPARE(descriptors.count(),0);
+
+ QVERIFY(!m_dbm->unregisterService("primatech", DatabaseManager::SystemScope));
+ QCOMPARE(m_dbm->lastError().code(), DBError::CannotOpenServiceDb);
+
+ //restore permissions so we can clean up the test directories
+ modifyPermissionSet(systemPermsSet, QFile::WriteOwner);
+ QFile::setPermissions(systemNokiaDir, systemPermsSet);
+ clean();
+}
+
+void tst_DatabaseManager::defaultServiceCornerCases()
+{
+ m_dbm = new DatabaseManager;
+ ServiceMetaData parser("");
+
+ QStringList userServiceFiles;
+ userServiceFiles << "ServiceAcme.xml" << "ServiceLuthorCorp.xml"
+ << "ServicePrimatech.xml"
+ << "ServiceDharma_Swan.xml"
+ << "ServiceDharma_Pearl.xml"
+ << "ServiceDharma_Flame.xml"
+ << "ServiceDecepticon.xml";
+
+ foreach (const QString &serviceFile, userServiceFiles) {
+ parser.setDevice(new QFile(m_testdir.absoluteFilePath(serviceFile)));
+ QVERIFY(parser.extractMetadata());
+ ServiceMetaDataResults results = parser.parseResults();
+ QVERIFY(m_dbm->registerService(results, DatabaseManager::UserScope));
+ }
+
+ QStringList systemServiceFiles;
+ systemServiceFiles << "ServiceOmni.xml" << "ServiceWayneEnt.xml"
+ << "ServiceDharma_Hydra.xml"
+ << "ServiceDharma_Orchid.xml"
+ << "ServiceAutobot.xml";
+ foreach (const QString &serviceFile, systemServiceFiles) {
+ parser.setDevice(new QFile(m_testdir.absoluteFilePath(serviceFile)));
+ QVERIFY(parser.extractMetadata());
+ ServiceMetaDataResults results = parser.parseResults();
+ QVERIFY(m_dbm->registerService(results, DatabaseManager::SystemScope));
+ }
+
+ // == set a system service interface implementation as a default at user scope then
+ // delete the system service and observe whether a new default
+ // has been chosen ==
+ m_dbm->setInterfaceDefault("DharmaInitiative", "com.dharma.electro.discharge",
+ DatabaseManager::UserScope);
+ QServiceInterfaceDescriptor descriptor =
+ m_dbm->interfaceDefault("com.dharma.electro.discharge",
+ DatabaseManager::UserScope);
+ QVERIFY(compareDescriptor(descriptor, "com.dharma.electro.discharge",
+ "DharmaInitiative", 42, 0));
+ QVERIFY(descriptor.scope() == QService::SystemScope);
+ QVERIFY(m_dbm->unregisterService("DharmaInitiative", DatabaseManager::SystemScope));
+ descriptor = m_dbm->interfaceDefault("com.dharma.electro.discharge",
+ DatabaseManager::UserScope);
+ QVERIFY(compareDescriptor(descriptor, "com.dharma.electro.discharge",
+ "DharmaInitiative", 16, 0));
+ // check again because there was a bug where the default service
+ // was correctly returned the first time but not the second
+ descriptor = m_dbm->interfaceDefault("com.dharma.electro.discharge",
+ DatabaseManager::UserScope);
+ QVERIFY(compareDescriptor(descriptor, "com.dharma.electro.discharge",
+ "DharmaInitiative", 16, 0));
+
+ QCOMPARE(m_dbm->lastError().code(), DBError::NoError);
+
+ // == set a system service interface as a default at user scope,
+ // remove availability to system db and confirm default cannot be found
+ // for that interface. Then restore the system db and confirm
+ // that a default can indeed be found. ==
+ QVERIFY(m_dbm->setInterfaceDefault("WayneEnt", "com.omni.device.accelerometer",
+ DatabaseManager::UserScope));
+ descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",
+ DatabaseManager::UserScope);
+ QVERIFY(compareDescriptor(descriptor, "com.omni.device.accelerometer",
+ "WayneEnt", 2, 0));
+ QString systemDbFilePath = m_dbm->m_systemDb->databasePath();
+ QFile::Permissions systemPermsSet = QFile::permissions(systemDbFilePath);
+ modifyPermissionSet(systemPermsSet, ~QFile::ReadOwner);
+ QFile::setPermissions(systemDbFilePath, systemPermsSet);
+
+ delete m_dbm;
+ m_dbm = new DatabaseManager;
+ descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",
+ DatabaseManager::UserScope);
+ QVERIFY(m_dbm->m_userDb->isOpen());
+ QVERIFY(!m_dbm->m_systemDb->isOpen());
+ QVERIFY(!descriptor.isValid());
+ QCOMPARE(m_dbm->lastError().code(), DBError::NotFound);
+
+ modifyPermissionSet(systemPermsSet, QFile::ReadOwner);
+ QFile::setPermissions(systemDbFilePath, systemPermsSet);
+ descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",
+ DatabaseManager::UserScope);
+ QVERIFY(m_dbm->m_systemDb->isOpen());
+ QVERIFY(descriptor.isValid());
+ QCOMPARE(m_dbm->lastError().code(), DBError::NoError);
+ QVERIFY(compareDescriptor(descriptor, "com.omni.device.accelerometer",
+ "WayneEnt", 2, 0));
+
+ //== set a system service interface as a user scope default,
+ // delete the service from the system scope database,
+ // ensure that when the default interface is queried
+ // it no longer exists ==
+ m_dbm->setInterfaceDefault("omni", "com.omni.device.lights", //(will set an entry in the
+ DatabaseManager::UserScope); //defaults table of the user db database)
+ descriptor = m_dbm->interfaceDefault("com.omni.device.lights",
+ DatabaseManager::UserScope);
+ QVERIFY(compareDescriptor(descriptor, "com.omni.device.lights",
+ "omni", 9, 0));
+ QVERIFY(m_dbm->unregisterService("omni", DatabaseManager::SystemScope));
+ descriptor = m_dbm->interfaceDefault("com.omni.device.lights",
+ DatabaseManager::UserScope);
+ QVERIFY(!descriptor.isValid());
+ QCOMPARE(m_dbm->lastError().code(), DBError::NotFound);
+ clean();
+ //Reinitialise the database
+ m_dbm = new DatabaseManager;
+
+ userServiceFiles.clear();
+ userServiceFiles << "ServiceAcme.xml" << "ServiceLuthorCorp.xml"
+ << "ServicePrimatech.xml"
+ << "ServiceDharma_Swan.xml"
+ << "ServiceDecepticon.xml";
+
+ foreach (const QString &serviceFile, userServiceFiles) {
+ parser.setDevice(new QFile(m_testdir.absoluteFilePath(serviceFile)));
+ QVERIFY(parser.extractMetadata());
+ ServiceMetaDataResults results = parser.parseResults();
+ QVERIFY(m_dbm->registerService(results, DatabaseManager::UserScope));
+ }
+ systemServiceFiles.clear();
+ systemServiceFiles << "ServiceOmni.xml" << "ServiceWayneEnt.xml"
+ << "ServiceDharma_Hydra.xml"
+ << "ServiceDharma_Orchid.xml"
+ << "ServiceAutobot.xml";
+ foreach (const QString &serviceFile, systemServiceFiles) {
+ parser.setDevice(new QFile(m_testdir.absoluteFilePath(serviceFile)));
+ QVERIFY(parser.extractMetadata());
+ ServiceMetaDataResults results = parser.parseResults();
+ QVERIFY(m_dbm->registerService(results, DatabaseManager::SystemScope));
+ }
+
+ //== Set a couple of external defaults in the user scope database,
+ // -remove the service that provides these defaults at the system scope.
+ // this will leave "hanging" default links in the user scope database
+ // -also set one default which will not be a hanging link
+ // -recreate the database manager and run getServiceNames so it will
+ // connect to both system and user scope databases.
+ // -verify that the hanging defaults links have been appropriately removed
+ // or reset to a new default interface implementation
+ // -also verify that the non-hanging link still exists ==
+ QServiceFilter filter;
+ filter.setServiceName("DharmaInitiative");
+ filter.setInterface("com.dharma.electro.discharge");
+ QList<QServiceInterfaceDescriptor> descriptors;
+ descriptors = m_dbm->getInterfaces(filter, DatabaseManager::SystemScope);
+ QVERIFY(descriptors.count() > 0);
+ QVERIFY(m_dbm->setInterfaceDefault(descriptors[0], DatabaseManager::UserScope));
+
+ filter.setServiceName("DharmaInitiative");
+ filter.setInterface("com.dharma.wheel");
+ descriptors = m_dbm->getInterfaces(filter, DatabaseManager::SystemScope);
+ QVERIFY(descriptors.count() > 0);
+ QVERIFY(m_dbm->setInterfaceDefault(descriptors[0], DatabaseManager::UserScope));
+
+ filter.setServiceName("WayneEnt");
+ filter.setInterface("com.omni.device.accelerometer");
+ descriptors = m_dbm->getInterfaces(filter, DatabaseManager::SystemScope);
+ QCOMPARE(descriptors.count(), 1);
+ QVERIFY(m_dbm->setInterfaceDefault(descriptors[0], DatabaseManager::UserScope));
+
+ QVERIFY(m_dbm->unregisterService("DharmaInitiative", DatabaseManager::SystemScope));
+ QList<QPair<QString, QString> > externalDefaultsInfo = m_dbm->m_userDb->externalDefaultsInfo();
+ QCOMPARE(m_dbm->lastError().code(), DBError::NoError);
+ QCOMPARE(externalDefaultsInfo.length(), 3);
+
+ delete m_dbm;
+
+ m_dbm = new DatabaseManager;
+ m_dbm->getServiceNames("", DatabaseManager::UserScope);
+ QCOMPARE(m_dbm->m_userDb->externalDefaultsInfo().count(), 1);
+ descriptor = m_dbm->interfaceDefault("com.dharma.electro.discharge",
+ DatabaseManager::UserScope);
+ QVERIFY(compareDescriptor(descriptor,"com.dharma.electro.discharge",
+ "DharmaInitiative", 4,0));
+ descriptor = m_dbm->interfaceDefault("com.dharma.wheel",
+ DatabaseManager::UserScope);
+ QVERIFY(!descriptor.isValid());
+ QCOMPARE(m_dbm->lastError().code(), DBError::NotFound);
+
+ descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",
+ DatabaseManager::UserScope);
+ QVERIFY(compareDescriptor(descriptor, "com.omni.device.accelerometer",
+ "WayneEnt", 2,0));
+
+ // == set a system service interface as a default at user scope
+ // -remove the availability of the system db and confirm the default
+ // cannot be found
+ // -set a new default
+ // -restore availability of the system db and confirm the default
+ // is still the new default
+ filter.setServiceName("omni");
+ filter.setInterface("com.omni.device.accelerometer");
+ descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);
+ QCOMPARE(descriptors.count(), 1);
+ QVERIFY(m_dbm->setInterfaceDefault(descriptors[0], DatabaseManager::UserScope));
+ delete m_dbm;
+
+ systemPermsSet = QFile::permissions(systemDbFilePath);
+ modifyPermissionSet(systemPermsSet, ~QFile::ReadOwner);
+ QFile::setPermissions(systemDbFilePath, systemPermsSet);
+
+ m_dbm = new DatabaseManager;
+ descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",
+ DatabaseManager::UserScope);
+ QVERIFY(!descriptor.isValid());
+ QCOMPARE(m_dbm->lastError().code(), DBError::NotFound);
+
+ filter.setServiceName("LuthorCorp");
+ filter.setInterface("com.omni.device.accelerometer");
+ descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);
+ QCOMPARE(descriptors.count(), 1);
+ QVERIFY(m_dbm->m_userDb->isOpen());
+ QVERIFY(!m_dbm->m_systemDb->isOpen());
+ QVERIFY(m_dbm->setInterfaceDefault(descriptors[0], DatabaseManager::UserScope));
+ descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",
+ DatabaseManager::UserScope);
+ QCOMPARE(m_dbm->lastError().code(), DBError::NoError);
+ QVERIFY(compareDescriptor(descriptor, "com.omni.device.accelerometer",
+ "LuthorCorp", 1,2));
+ modifyPermissionSet(systemPermsSet, QFile::ReadOwner);
+ QFile::setPermissions(systemDbFilePath, systemPermsSet);
+ m_dbm->getServiceNames("", DatabaseManager::UserScope);//this call is just to open the system db
+ QVERIFY(m_dbm->m_systemDb->isOpen());
+
+ descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",
+ DatabaseManager::UserScope);
+ QVERIFY(descriptor.isValid());
+ QVERIFY(compareDescriptor(descriptor, "com.omni.device.accelerometer",
+ "LuthorCorp", 1,2));
+
+ // == Try set a descriptor as a default but the descriptor is invalid
+ // because the service it belongs to has been removed ==
+ descriptor = m_dbm->interfaceDefault("com.cybertron.transform",
+ DatabaseManager::SystemScope);
+ QVERIFY(compareDescriptor(descriptor, "com.cybertron.transform",
+ "Autobot", 2, 7));
+ QVERIFY(m_dbm->unregisterService("Autobot",
+ DatabaseManager::SystemScope));
+ QVERIFY(!m_dbm->setInterfaceDefault(descriptor, DatabaseManager::UserScope));
+ QCOMPARE(m_dbm->lastError().code(), DBError::NotFound);
+
+ QVERIFY(!m_dbm->setInterfaceDefault(descriptor, DatabaseManager::SystemScope));
+ QCOMPARE(m_dbm->lastError().code(), DBError::NotFound);
+
+ clean();
+}
+#endif
+
+void tst_DatabaseManager::nonWritableSystemDb()
+{
+ m_dbm = new DatabaseManager;
+ ServiceMetaData parser("");
+
+ // Setup Initial user and system databases
+ QStringList userServiceFiles;
+ userServiceFiles << "ServiceAcme.xml" << "ServiceLuthorCorp.xml"
+ << "ServicePrimatech.xml";
+ foreach (const QString &serviceFile, userServiceFiles) {
+ parser.setDevice(new QFile(m_testdir.absoluteFilePath(serviceFile)));
+ QVERIFY(parser.extractMetadata());
+ ServiceMetaDataResults results = parser.parseResults();
+ QVERIFY(m_dbm->registerService(results, DatabaseManager::UserScope));
+ }
+
+ QStringList systemServiceFiles;
+ systemServiceFiles << "ServiceOmni.xml" << "ServiceWayneEnt.xml"
+ << "ServiceDharma_Orchid.xml"
+ << "ServiceDharma_Hydra.xml";
+ foreach (const QString &serviceFile, systemServiceFiles) {
+ parser.setDevice(new QFile(m_testdir.absoluteFilePath(serviceFile)));
+ QVERIFY(parser.extractMetadata());
+ ServiceMetaDataResults results = parser.parseResults();
+ QVERIFY(m_dbm->registerService(results, DatabaseManager::SystemScope));
+ }
+
+ //make system database non-writable
+ QString systemDbFilePath = m_dbm->m_systemDb->databasePath();
+ QFile::Permissions systemPermsSet = QFile::permissions(systemDbFilePath);
+ modifyPermissionSet(systemPermsSet, ~QFile::WriteOwner);
+ QFile::setPermissions(systemDbFilePath, systemPermsSet);
+
+ //== test registration() ==
+ delete m_dbm;
+ m_dbm = new DatabaseManager;
+ parser.setDevice(new QFile(m_testdir.absoluteFilePath("ServiceDharma_Swan.xml")));
+ QVERIFY(parser.extractMetadata());
+ ServiceMetaDataResults results = parser.parseResults();
+ QVERIFY(m_dbm->registerService(results, DatabaseManager::UserScope));
+ QCOMPARE(m_dbm->lastError().code(), DBError::NoError);
+
+ parser.setDevice(new QFile(m_testdir.absoluteFilePath("ServiceAutobot.xml")));
+ QVERIFY(parser.extractMetadata());
+ results = parser.parseResults();
+ QVERIFY(!m_dbm->registerService(results, DatabaseManager::SystemScope));
+ QCOMPARE(m_dbm->lastError().code(), DBError::NoWritePermissions);
+
+ //== test getInterfaces() ==
+ delete m_dbm;
+ m_dbm = new DatabaseManager;
+ QList<QServiceInterfaceDescriptor> descriptors;
+ QServiceFilter filter;
+ filter.setServiceName("");
+ filter.setInterface("");
+ descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);
+ QCOMPARE(descriptors.count(), 18);
+
+ descriptors = m_dbm->getInterfaces(filter, DatabaseManager::SystemScope);
+ QCOMPARE(descriptors.count(), 9);
+
+ // try a more restrictive filter with getInterfaces
+ filter.setServiceName("");
+ filter.setInterface("com.dharma.electro.discharge", "4.0");
+ descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);
+ QCOMPARE(descriptors.count(), 4);
+
+ descriptors = m_dbm->getInterfaces(filter, DatabaseManager::SystemScope);
+ QCOMPARE(descriptors.count(), 3);
+
+ // ==test getServiceName() ==
+ delete m_dbm;
+ m_dbm = new DatabaseManager;
+ QStringList expectedNames;
+ expectedNames << "LuthorCorp" << "Primatech" << "WayneEnt" << "omni";
+ QStringList serviceNames = m_dbm->getServiceNames("com.omni.device.accelerometer",
+ DatabaseManager::UserScope);
+ foreach(const QString expectedName, expectedNames)
+ QVERIFY(serviceNames.contains(expectedName, Qt::CaseInsensitive));
+ QCOMPARE(serviceNames.count(), expectedNames.count());
+
+ expectedNames.clear();
+ expectedNames << "WayneEnt" << "omni";
+ serviceNames = m_dbm->getServiceNames("com.omni.device.accelerometer",
+ DatabaseManager::SystemScope);
+ foreach(const QString expectedName, expectedNames)
+ QVERIFY(serviceNames.contains(expectedName, Qt::CaseInsensitive));
+ QCOMPARE(serviceNames.count(), expectedNames.count());
+
+ //== test interfaceDefault() ==
+ delete m_dbm;
+ m_dbm = new DatabaseManager;
+ QServiceInterfaceDescriptor descriptor;
+ descriptor = m_dbm->interfaceDefault("com.dharma.electro.discharge",
+ DatabaseManager::UserScope);
+ QStringList capabilities;
+ QVERIFY(compareDescriptor(descriptor, "com.dharma.electro.discharge",
+ "DharmaInitiative", 4, 0, capabilities, "C:/island/swan.dll"));
+
+ descriptor = m_dbm->interfaceDefault("com.dharma.electro.discharge",
+ DatabaseManager::SystemScope);
+ QVERIFY(compareDescriptor(descriptor, "com.dharma.electro.discharge",
+ "DharmaInitiative", 4, 0, capabilities, "C:/island/orchid.dll"));
+ //test setInterfaceDefault(service, interface, scope)
+ delete m_dbm;
+ m_dbm = new DatabaseManager;
+ descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",
+ DatabaseManager::UserScope);
+ QVERIFY(compareDescriptor(descriptor, "com.omni.device.accelerometer",
+ "LuthorCorp", 1,2));
+ QVERIFY(m_dbm->setInterfaceDefault("Primatech", "com.omni.device.accelerometer",
+ DatabaseManager::UserScope));
+ descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",
+ DatabaseManager::UserScope);
+
+ // try setting descriptor that originates from the system db
+ descriptor = m_dbm->interfaceDefault("com.dharma.electro.discharge",
+ DatabaseManager::UserScope);
+ QVERIFY(compareDescriptor(descriptor, "com.dharma.electro.discharge",
+ "DharmaInitiative", 4, 0));
+ QVERIFY(m_dbm->setInterfaceDefault("DharmaInitiative", "com.dhARMa.electro.discharge",
+ DatabaseManager::UserScope));
+ QCOMPARE(m_dbm->lastError().code(), DBError::NoError);
+ descriptor = m_dbm->interfaceDefault("com.dharma.electro.discharge",
+ DatabaseManager::UserScope);
+ QVERIFY(compareDescriptor(descriptor, "com.dharma.electro.discharge",
+ "DharmaInitiative", 42, 0));
+
+ // try setting a default at systems scope (this should fail)
+ descriptor = m_dbm->interfaceDefault("com.dharma.electro.Discharge",
+ DatabaseManager::SystemScope);
+ QVERIFY(compareDescriptor(descriptor, "com.dharma.electro.discharge",
+ "DharmaInitiative", 4, 0));
+ QVERIFY(!m_dbm->setInterfaceDefault("DharmaInitiative", "com.dharma.electro.discharge",
+ DatabaseManager::SystemScope));
+ QCOMPARE(m_dbm->lastError().code(), DBError::NoWritePermissions);
+ descriptor = m_dbm->interfaceDefault("com.dharma.electro.Discharge",
+ DatabaseManager::SystemScope);
+ QVERIFY(compareDescriptor(descriptor, "com.dharma.electro.discharge",
+ "DharmaInitiative", 4, 0));
+
+ //== test setInterfaceDefault(descriptor,scope) ==
+ delete m_dbm;
+ m_dbm = new DatabaseManager;
+ filter.setServiceName("primatech");
+ filter.setInterface("com.omni.device.accelerometer", "1.2",
+ QServiceFilter::ExactVersionMatch);
+ descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",
+ DatabaseManager::UserScope);
+ QVERIFY(compareDescriptor(descriptor, "com.omni.device.accelerometer",
+ "Primatech", 1, 4));
+ descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);
+ QCOMPARE(descriptors.count(), 1);
+ QVERIFY(m_dbm->setInterfaceDefault(descriptors[0], DatabaseManager::UserScope));
+ QCOMPARE(m_dbm->lastError().code(), DBError::NoError);
+ descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",
+ DatabaseManager::UserScope);
+ QVERIFY(compareDescriptor(descriptor, "com.omni.device.accelerometer",
+ "Primatech", 1, 2));
+
+ // try setting a descriptor that originates from the system db
+ delete m_dbm;
+ m_dbm = new DatabaseManager;
+ filter.setServiceName("WayneEnt");
+ filter.setInterface("com.omni.device.accelerometer", "2.0",
+ QServiceFilter::ExactVersionMatch);
+ descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);
+ QCOMPARE(descriptors.count(), 1);
+ QCOMPARE(descriptors[0].scope(), QService::SystemScope);
+ QVERIFY(m_dbm->setInterfaceDefault(descriptors[0],
+ DatabaseManager::UserScope));
+ descriptor = m_dbm->interfaceDefault("com.omni.device.accelerometer",
+ DatabaseManager::UserScope);
+ QVERIFY(compareDescriptor(descriptor, "com.omni.device.accelerometer",
+ "WayneEnt", 2, 0));
+
+ // try setting a descriptor at system scope
+ QVERIFY(!m_dbm->setInterfaceDefault(descriptor,
+ DatabaseManager::SystemScope));
+ QCOMPARE(m_dbm->lastError().code(), DBError::NoWritePermissions);
+
+ //==test unregisterService()==
+ delete m_dbm;
+ m_dbm = new DatabaseManager;
+ QVERIFY(m_dbm->unregisterService("primatech", DatabaseManager::UserScope));
+ QCOMPARE(m_dbm->lastError().code(), DBError::NoError);
+ filter.setServiceName("Primatech");
+ filter.setInterface("");
+ descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);
+ QCOMPARE(m_dbm->lastError().code(), DBError::NoError);
+ QCOMPARE(descriptors.count(), 0);
+
+ QVERIFY(!m_dbm->unregisterService("DharmaInitiative",
+ DatabaseManager::SystemScope));
+ QCOMPARE(m_dbm->lastError().code(), DBError::NoWritePermissions);
+
+ //make system database writable again
+ modifyPermissionSet(systemPermsSet, QFile::WriteOwner);
+ QFile::setPermissions(systemDbFilePath, systemPermsSet);
+
+ clean();
+}
+
+void tst_DatabaseManager::CWRTXmlCompatability()
+{
+ m_dbm = new DatabaseManager;
+ ServiceMetaData parser("");
+
+ QStringList userServiceFiles;
+ userServiceFiles << "ServiceTest.xml" << "ServiceTest1.xml";
+ foreach (const QString &serviceFile, userServiceFiles) {
+ parser.setDevice(new QFile(m_testdir.absoluteFilePath(serviceFile)));
+ QVERIFY(parser.extractMetadata());
+ ServiceMetaDataResults results = parser.parseResults();
+ QVERIFY(m_dbm->registerService(results, DatabaseManager::UserScope));
+ }
+
+ QString test("Test");
+ for(int i = 0; i <= 10; ++i) {
+ parser.setDevice(new QFile(m_testdir.absoluteFilePath(test + QString::number(i) + QLatin1String(".xml"))));
+ if (i == 6)
+ QVERIFY(parser.extractMetadata());
+ else
+ QVERIFY(!parser.extractMetadata());
+ }
+
+ QStringList systemServiceFiles;
+ systemServiceFiles << "ServiceTest2.xml" << "ServiceTest3.xml";
+ foreach (const QString &serviceFile, systemServiceFiles) {
+ parser.setDevice(new QFile(m_testdir.absoluteFilePath(serviceFile)));
+ if (serviceFile == "ServiceTest3.xml") {
+ QVERIFY(!parser.extractMetadata());//versions less than 1.0 are not allowed
+ continue;
+ } else {
+ QVERIFY(parser.extractMetadata());
+ }
+ ServiceMetaDataResults results = parser.parseResults();
+ QVERIFY(m_dbm->registerService(results, DatabaseManager::SystemScope));
+ }
+
+ QServiceFilter filter;
+ filter.setInterface("com.nokia.ILocation");
+ QList<QServiceInterfaceDescriptor> descriptors;
+ descriptors = m_dbm->getInterfaces(filter, DatabaseManager::UserScope);
+ QVERIFY(compareDescriptor(descriptors[0], "com.nokia.ILocation", "TestService", 1,0));
+ QVERIFY(compareDescriptor(descriptors[1], "com.nokia.ILocation", "TestService1", 1,1));
+ QVERIFY(compareDescriptor(descriptors[2], "com.nokia.ILocation", "TestService2", 1,2));
+}
+
+void tst_DatabaseManager::modifyPermissionSet(QFile::Permissions &permsSet,
+ int perm)
+{
+ switch(perm) {
+ case(QFile::ReadOwner):
+ permsSet |= QFile::ReadOwner;
+ permsSet |= QFile::ReadUser;
+ permsSet |= QFile::ReadGroup;
+ permsSet |= QFile::ReadOther;
+ break;
+ case(~QFile::ReadOwner):
+ permsSet &= ~QFile::ReadOwner;
+ permsSet &= ~QFile::ReadUser;
+ permsSet &= ~QFile::ReadGroup;
+ permsSet &= ~QFile::ReadOther;
+ break;
+ case(QFile::WriteOwner):
+ permsSet |= QFile::WriteOwner;
+ permsSet |= QFile::WriteUser;
+ permsSet |= QFile::WriteGroup;
+ permsSet |= QFile::WriteOther;
+ break;
+ case(~QFile::WriteOwner):
+ permsSet &= ~QFile::WriteOwner;
+ permsSet &= ~QFile::WriteUser;
+ permsSet &= ~QFile::WriteGroup;
+ permsSet &= ~QFile::WriteOther;
+ break;
+ case(QFile::ExeOwner):
+ permsSet |= QFile::ExeOwner;
+ permsSet |= QFile::ExeUser;
+ permsSet |= QFile::ExeGroup;
+ permsSet |= QFile::ExeOther;
+ break;
+ case(~QFile::ExeOwner):
+ permsSet &= ~QFile::ExeOwner;
+ permsSet &= ~QFile::ExeUser;
+ permsSet &= ~QFile::ExeGroup;
+ permsSet &= ~QFile::ExeOther;
+ break;
+ default:
+ break;
+ }
+}
+
+void tst_DatabaseManager::clean()
+{
+ if (m_dbm != 0 ) {
+ delete m_dbm;
+ }
+ m_dbm = 0;
+
+ QSfwTestUtil::removeDirectory(QSfwTestUtil::tempSettingsPath());
+}
+
+void tst_DatabaseManager::cleanupTestCase()
+{
+ clean();
+}
+
+QTEST_MAIN(tst_DatabaseManager)
+
+#include "tst_databasemanager.moc"
+