--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/qtmobility/plugins/contacts/qtcontacts-tracker/tests/ut_qtcontacts_trackerplugin/ut_qtcontacts_trackerplugin.cpp Mon May 03 13:18:40 2010 +0300
@@ -0,0 +1,1820 @@
+/****************************************************************************
+**
+** 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 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 "ut_qtcontacts_trackerplugin.h"
+
+#include <QMap>
+#include <QPair>
+#include <QUuid>
+
+#include <QtTracker/Tracker>
+#include <QtTracker/ontologies/nco.h>
+#include <QtTracker/ontologies/nie.h>
+#include <qcontactfilters.h>
+#include <QContactChangeLogFilter>
+#include <qtcontacts.h>
+#include <trackerchangelistener.h>
+#include <qcontactrelationshipsaverequest.h>
+#include <qcontactrelationshipfetchrequest.h>
+#include <qtrackercontactidfetchrequest.h>
+#include <qcontacttrackerbackend_p.h>
+#include <qtrackercontactasyncrequest.h>
+
+#include "contactmanager.h"
+
+// update this when creating debian package
+const QString PATH_TO_SPARQL_TESTS("./ut_qtcontacts_trackerplugin_data");
+
+ut_qtcontacts_trackerplugin::ut_qtcontacts_trackerplugin()
+{
+
+}
+
+void ut_qtcontacts_trackerplugin::initTestCase()
+{
+ QMap<QString, QString> trackerEngineParams;
+ trackerEngine = new QContactTrackerEngine(trackerEngineParams);
+ errorMap = new QMap<int, QContactManager::Error>();
+}
+
+void ut_qtcontacts_trackerplugin::testContacts()
+{
+ QContact c1;
+ QContact c2;
+
+ trackerEngine->saveContact(&c1, error);
+ trackerEngine->saveContact(&c2, error);
+ QVERIFY2((error == QContactManager::NoError),"Saving contact");
+ QList<QContactLocalId> contacts = trackerEngine->contactIds(queryFilter, sortOrders, error);
+ QVERIFY2(contacts.contains(c1.localId()), "Previously added contact is not found");
+ QVERIFY2(contacts.contains(c2.localId()), "Previously added contact is not found");
+}
+
+void ut_qtcontacts_trackerplugin::testContact()
+{
+ // Test invalid contact id
+ QContact invalidContact = trackerEngine->contact_impl( -1, QStringList(), error);
+ QVERIFY(error != QContactManager::NoError);
+
+ // Add a contact
+ QContact newContact;
+ const QContactLocalId oldid = newContact.localId();
+ QVERIFY( trackerEngine->saveContact( &newContact, error ) );
+
+ QContactLocalId id = newContact.localId();
+ QVERIFY( id != oldid );
+
+ // Find the added contact
+ QContact c = trackerEngine->contact_impl( id, QStringList(), error );
+ QVERIFY( c.localId() == newContact.localId() );
+}
+
+void ut_qtcontacts_trackerplugin::testSaveName()
+{
+ QContact c;
+ QContactLocalId initialId = c.localId();
+ int detailsAdded = 0;
+
+ QMap<QString,QString> nameValues;
+ QContactName name;
+ nameValues.insert(QLatin1String(QContactName::FieldPrefix), "Mr");
+ nameValues.insert(QLatin1String(QContactName::FieldFirst), "John");
+ nameValues.insert(QLatin1String(QContactName::FieldMiddle), "Rupert");
+ nameValues.insert(QLatin1String(QContactName::FieldLast), "Doe");
+// nameValues.insert(QContactName::FieldSuffix, "III");
+
+ foreach (QString field, nameValues.keys()) {
+ name.setValue(field, nameValues.value(field));
+ }
+ c.saveDetail(&name);
+
+ QContactNickname nick;
+ nick.setValue(QLatin1String(QContactNickname::FieldNickname), "Johnny");
+ c.saveDetail(&nick);
+
+ QVERIFY(c.detail<QContactName>().prefix() == "Mr");
+ QVERIFY(c.detail<QContactName>().firstName() == "John");
+ QVERIFY(c.detail<QContactName>().middleName() == "Rupert");
+ QVERIFY(c.detail<QContactName>().lastName() == "Doe");
+ QVERIFY(c.detail<QContactNickname>().nickname() == "Johnny");
+
+ detailsAdded++;
+
+ trackerEngine->saveContact(&c, error);
+ QCOMPARE(error, QContactManager::NoError);
+ QVERIFY(c.localId() != initialId);
+ QContact contact = this->contact(c.localId());
+ QList<QContactName> details = contact.details<QContactName>();
+ QList<QContactNickname> details2 = contact.details<QContactNickname>();
+ QCOMPARE(details.count(), detailsAdded);
+ QCOMPARE(details2.count(), detailsAdded);
+ // Name is unique
+ foreach(QString field, nameValues.keys()) {
+ QCOMPARE(details.at(0).value(field), nameValues.value(field));
+ }
+ QCOMPARE(details2.at(0).value(QLatin1String(QContactNickname::FieldNickname)), QString("Johnny"));
+
+ // Try changing the name of the saved contact.
+ {
+ QMap<QString,QString> nameValues;
+ QContactName name = c.detail<QContactName>();
+ nameValues.insert(QLatin1String(QContactName::FieldPrefix), "Mr2");
+ nameValues.insert(QLatin1String(QContactName::FieldFirst), "John2");
+ nameValues.insert(QLatin1String(QContactName::FieldMiddle), "Rupert2");
+ nameValues.insert(QLatin1String(QContactName::FieldLast), "");
+ // nameValues.insert(QContactName::FieldSuffix, "III");
+
+ foreach (QString field, nameValues.keys()) {
+ name.setValue(field, nameValues.value(field));
+ }
+ c.saveDetail(&name);
+
+ QContactNickname nick = c.detail<QContactNickname>();
+ nick.setValue(QLatin1String(QContactNickname::FieldNickname), "Johnny2");
+ c.saveDetail(&nick);
+
+
+ QVERIFY(trackerEngine->saveContact(&c, error));
+ QCOMPARE(error, QContactManager::NoError);
+ QVERIFY(c.localId() != initialId);
+
+ QContact contact = trackerEngine->contact_impl(c.localId(), QStringList(), error);
+ QCOMPARE(error, QContactManager::NoError);
+ QList<QContactName> details = contact.details<QContactName>();
+ QList<QContactNickname> details2 = contact.details<QContactNickname>();
+ QCOMPARE(details.count(), detailsAdded);
+ QCOMPARE(details2.count(), detailsAdded);
+ // Name is unique
+ foreach(QString field, nameValues.keys()) {
+ QCOMPARE(details.at(0).value(field), nameValues.value(field));
+ }
+ QCOMPARE(details2.at(0).value(QLatin1String(QContactNickname::FieldNickname)), QString("Johnny2"));
+
+ // now try to add new name detail fails - this is how currently unique fields are implemented
+ // so cover it in unit tests
+ QContactName name1;
+ name1.setValue(QContactName::FieldFirst, "Something that wont be stored as name is unique");
+ c.saveDetail(&name1);
+ // validate that unique name is not saved
+ QVERIFY(!trackerEngine->saveContact(&c, error));
+ details = contact.details<QContactName>();
+ details2 = contact.details<QContactNickname>();
+ QCOMPARE(details.count(), detailsAdded);
+ QCOMPARE(details2.count(), detailsAdded);
+ }
+}
+
+void ut_qtcontacts_trackerplugin::testSavePhoneNumber()
+{
+ // use the same values for 2 contacts
+ for (int i = 0; i <2; i++ )
+ {
+ QContact c;
+ QContactLocalId initialId = c.localId();
+ int detailsAdded = 0;
+ QContactName name;
+ name.setFirstName("I have phone numbers");
+ name.setLastName("Girl");
+ c.saveDetail(&name);
+
+ // key: phonenumber; value: context,subtype
+ QMap<QString,QPair<QString,QString> > phoneValues;
+
+ phoneValues.insert("(704)486-6472", QPair<QString,QString>(QLatin1String(QContactDetail::ContextHome), QString()));
+ phoneValues.insert("(765)957-1663", QPair<QString,QString>(QLatin1String(QContactDetail::ContextHome), QString()));
+ phoneValues.insert("(999)888-1111", QPair<QString,QString>(QLatin1String(QContactDetail::ContextHome),
+ QLatin1String(QContactPhoneNumber::SubTypeMobile)));
+
+ phoneValues.insert("(792)123-6113", QPair<QString,QString>(QLatin1String(QContactDetail::ContextWork), QString()));
+ phoneValues.insert("(918)491-7361", QPair<QString,QString>(QLatin1String(QContactDetail::ContextWork),
+ QLatin1String(QContactPhoneNumber::SubTypeMobile)));
+ phoneValues.insert("(412)670-1514", QPair<QString,QString>(QLatin1String(QContactDetail::ContextWork),
+ QLatin1String(QContactPhoneNumber::SubTypeCar)));
+ QMap<QString,QPair<QString,QString> > formattedPhoneValues;
+
+
+ foreach (QString number, phoneValues.keys()) {
+ QContactPhoneNumber phone;
+ phone.setNumber(number);
+ // Stripped automatically on saving RFC 3966 visual-separators reg exp "[(|-|.|)| ]"
+ formattedPhoneValues.insert(QString(number).replace( QRegExp("[\\(|" \
+ "\\-|" \
+ "\\.|" \
+ "\\)|" \
+ " ]"), ""),phoneValues.value(number));
+ if (!phoneValues.value(number).first.isEmpty()) {
+ phone.setContexts(phoneValues.value(number).first);
+ }
+ if (!phoneValues.value(number).second.isEmpty()) {
+ phone.setSubTypes(phoneValues.value(number).second);
+ }
+ c.saveDetail(&phone);
+ detailsAdded++;
+ }
+
+ trackerEngine->saveContact(&c, error);
+ QCOMPARE(error, QContactManager::NoError);
+ QVERIFY(c.localId() != initialId);
+ // wait for commit transaction to be done, no signals yet
+ for(int i = 0; i < 100; i++)
+ {
+ usleep(10000);
+ QCoreApplication::processEvents();
+ }
+
+
+ // verify with synchronous read too
+ QContact contact = trackerEngine->contact_impl(c.localId(), QStringList(), error);
+ QCOMPARE(error, QContactManager::NoError);
+ QList<QContactPhoneNumber> details = contact.details<QContactPhoneNumber>();
+
+
+ QCOMPARE(details.count(), detailsAdded);
+
+
+ foreach (QContactPhoneNumber detail, details) {
+ // Verify that the stored values and attributes are the same as given
+ QVERIFY(formattedPhoneValues.contains(detail.number()));
+ QCOMPARE(detail.contexts()[0], formattedPhoneValues.value(detail.number()).first);
+ if( formattedPhoneValues.value(detail.number()).second.isEmpty()) // default empty is voice
+ QCOMPARE(detail.subTypes()[0], QLatin1String(QContactPhoneNumber::SubTypeVoice));
+ else
+ QCOMPARE(detail.subTypes()[0], formattedPhoneValues.value(detail.number()).second);
+ }
+
+ // edit one of numbers . values, context and subtypes and save again
+ QString editedPhoneValue = "+7044866473";
+ QContactPhoneNumber phone = details[0];
+ phone.setNumber(editedPhoneValue);
+ phone.setContexts(QContactDetail::ContextWork);
+ phone.setSubTypes(QContactPhoneNumber::SubTypeMobile);
+ c = contact;
+ c.saveDetail(&phone);
+ trackerEngine->saveContact(&c, error);
+ QCOMPARE(error, QContactManager::NoError);
+ c = this->contact(c.localId(), QStringList()<<QContactPhoneNumber::DefinitionName);
+ details = c.details<QContactPhoneNumber>();
+ QCOMPARE(details.count(), detailsAdded);
+ bool found = false;
+ foreach (QContactPhoneNumber detail, details) {
+ if(detail.number() == phone.number())
+ {
+ found = true;
+ QVERIFY(detail.subTypes().contains(QContactPhoneNumber::SubTypeMobile));
+ QVERIFY(detail.contexts().contains(QContactPhoneNumber::ContextWork));
+ break;
+ }
+ }
+ QVERIFY(found);
+ }
+}
+
+void ut_qtcontacts_trackerplugin::testPhoneNumberContext()
+{
+ QContact c;
+ QContactPhoneNumber phone;
+ phone.setContexts(QContactDetail::ContextHome);
+ phone.setNumber("555-888");
+ phone.setSubTypes(QContactPhoneNumber::SubTypeMobile);
+ c.saveDetail(&phone);
+ QContact contactToSave = c;
+ // Let's do this all twice, first time save new detail, and next iteration change the context
+ for (int iterations = 0; iterations < 2; iterations++) {
+ QVERIFY(trackerEngine->saveContact(&contactToSave, error));
+ // wait for commit transaction to be done, no signals yet
+ for(int i = 0; i < 100; i++) {
+ usleep(10000);
+ QCoreApplication::processEvents();
+ }
+
+ QContactFetchRequest request;
+ QContactLocalIdFilter filter;
+ QList<QContactLocalId> ids;
+ ids.append(contactToSave.localId());
+ filter.setIds(ids);
+ request.setFilter(filter);
+
+ QStringList details;
+ details << QContactPhoneNumber::DefinitionName;
+ request.setDefinitionRestrictions(details);
+
+ Slots slot;
+ QObject::connect(&request, SIGNAL(resultsAvailable()),
+ &slot, SLOT(resultsAvailable()));
+
+ trackerEngine->startRequest(&request);
+
+ for(int i = 0; i < 100; i++) {
+ usleep(100000);
+ QCoreApplication::processEvents();
+ if(request.isFinished() )
+ break;
+ }
+
+ // if it takes more, then something is wrong
+ QVERIFY(request.isFinished());
+ QVERIFY(!slot.contacts.isEmpty());
+
+ QContact contactToTest;
+ foreach (QContact savedContact, slot.contacts) {
+ if (savedContact.localId() == contactToSave.localId()) {
+ contactToTest = savedContact;
+ }
+ }
+ QVERIFY(contactToTest.localId() == contactToSave.localId()); // Just to be sure we got the saved contact
+ qDebug()<<contactToTest.details<QContactPhoneNumber>().count();
+
+ QVERIFY(contactToTest.details<QContactPhoneNumber>().count() == 1);
+ if (0 == iterations) {
+ // perform context change
+ QContactPhoneNumber phoneToEdit = contactToTest.detail<QContactPhoneNumber>();
+ phoneToEdit.setContexts(QContactDetail::ContextWork);
+ contactToTest.saveDetail(&phoneToEdit);
+ contactToSave = contactToTest;
+ }
+ QVERIFY(contactToTest.details<QContactPhoneNumber>().count() == 1);
+ }
+}
+
+void ut_qtcontacts_trackerplugin::testWritingOnlyWorkMobile()
+{
+ QContact c;
+ QContactPhoneNumber phone;
+ phone.setContexts(QContactDetail::ContextWork);
+ phone.setNumber("555999");
+ phone.setSubTypes(QContactPhoneNumber::SubTypeMobile);
+ c.saveDetail(&phone);
+ QContact& contactToSave = c;
+ QVERIFY(trackerEngine->saveContact(&contactToSave, error));
+ // wait for commit transaction to be done, no signals yet
+ for(int i = 0; i < 100; i++) {
+ usleep(10000);
+ QCoreApplication::processEvents();
+ }
+
+ QContactFetchRequest request;
+ QContactLocalIdFilter filter;
+ QList<QContactLocalId> ids;
+ ids.append(contactToSave.localId());
+ filter.setIds(ids);
+ request.setFilter(filter);
+ QStringList details;
+ details << QContactPhoneNumber::DefinitionName;
+ request.setDefinitionRestrictions(details);
+
+ Slots slot;
+ QObject::connect(&request, SIGNAL(resultsAvailable()),
+ &slot, SLOT(resultsAvailable()));
+
+ trackerEngine->startRequest(&request);
+
+ for(int i = 0; i < 100; i++) {
+ usleep(100000);
+ QCoreApplication::processEvents();
+ if(request.isFinished() )
+ break;
+ }
+
+ // if it takes more, then something is wrong
+ QVERIFY(request.isFinished());
+ QVERIFY(!slot.contacts.isEmpty());
+
+ QContact contactToTest;
+ foreach (QContact savedContact, slot.contacts) {
+ if (savedContact.localId() == c.localId()) {
+ contactToTest = savedContact;
+ }
+ }
+ QVERIFY(contactToTest.localId() == c.localId()); // Just to be sure we got the saved contact
+ QVERIFY(contactToTest.details<QContactPhoneNumber>().count() == 1);
+ QVERIFY(contactToTest.detail<QContactPhoneNumber>().number() == phone.number());
+ QVERIFY(contactToTest.detail<QContactPhoneNumber>().subTypes() == phone.subTypes());
+ QVERIFY(contactToTest.detail<QContactPhoneNumber>().contexts() == phone.contexts());
+}
+
+void ut_qtcontacts_trackerplugin::testSaveAddress()
+{
+ QContact c;
+ QContactName name;
+ name.setFirstName("Aruba & Barbados");
+ name.setLastName("Girl");
+ c.saveDetail(&name);
+ QContactLocalId initialId = c.localId();
+ int detailsAdded = 0;
+
+ // List of pairs of field-value map and context
+ typedef QMap<QString,QString> typeAddress;
+ typedef QPair<typeAddress,QString> typeAddressWithContext;
+ QList<typeAddressWithContext> addressValues;
+
+ // TODO check status of 137174 and other libqttracker1pre6 bugs before refactoring
+ typeAddress values;
+ values.insert(QLatin1String(QContactAddress::FieldCountry), "Barbados");
+ values.insert(QLatin1String(QContactAddress::FieldPostcode), "55555");
+ values.insert(QLatin1String(QContactAddress::FieldStreet), "Martindales Rd");
+ values.insert(QLatin1String(QContactAddress::FieldRegion), "Bridgetown");
+ addressValues.append(typeAddressWithContext(values, QLatin1String(QContactDetail::ContextHome)));
+ values.clear();
+ values.insert(QLatin1String(QContactAddress::FieldCountry), "Aruba");
+ values.insert(QLatin1String(QContactAddress::FieldPostcode), "44444");
+ values.insert(QLatin1String(QContactAddress::FieldStreet), "Brazilie Straat");
+ values.insert(QLatin1String(QContactAddress::FieldRegion), "Oranjestad");
+ addressValues.append(typeAddressWithContext(values, QLatin1String(QContactDetail::ContextHome)));
+ values.clear();
+ values.insert(QLatin1String(QContactAddress::FieldCountry), "ArubaWork");
+ values.insert(QLatin1String(QContactAddress::FieldPostcode), "44445");
+ values.insert(QLatin1String(QContactAddress::FieldStreet), "Sunset Blvd");
+ values.insert(QLatin1String(QContactAddress::FieldRegion), "Oranjestad");
+ addressValues.append(typeAddressWithContext(values, QLatin1String(QContactDetail::ContextHome)));
+ foreach (typeAddressWithContext addressWithContext, addressValues) {
+ QContactAddress address;
+ foreach (QString field, addressWithContext.first.keys()) {
+ address.setValue(field, addressWithContext.first.value(field));
+ }
+ address.setContexts(addressWithContext.second);
+ c.saveDetail(&address);
+ detailsAdded++;
+ }
+
+ trackerEngine->saveContact(&c, error);
+ QCOMPARE(error, QContactManager::NoError);
+ QVERIFY(c.localId() != initialId);
+ QContact contact = trackerEngine->contact_impl(c.localId(), QStringList(), error);
+ QList<QContactAddress> details = contact.details<QContactAddress>();
+ QCOMPARE(details.count(), detailsAdded);
+ bool found = false;
+ // Test if inserted values are found in some of the details
+ foreach (typeAddressWithContext addressWithContext, addressValues) {
+ foreach (QContactAddress detail, details) {
+ foreach (QString field, addressWithContext.first.keys()) {
+ found = (detail.value(field) == addressWithContext.first.value(field));
+ if (!found)
+ break;
+ }
+ if (found)
+ break;
+ }
+ QVERIFY2(found, "Inserted detail was not found in the fetched details");
+ }
+}
+
+void ut_qtcontacts_trackerplugin::testSaveEmailAddress()
+{
+ QContact c;
+ QContactLocalId initialId = c.localId();
+ int detailsAdded = 0;
+
+ QMap<QString,QString> values;
+ values.insert("john.does@hotmail.com", QContactDetail::ContextHome);
+ values.insert("john.doe@gmail.com", QContactDetail::ContextWork);
+ values.insert("john.doe@nokia.com", QContactDetail::ContextWork);
+ values.insert("john.doe@johndoe.com", QContactDetail::ContextHome);
+ foreach(QString address, values.keys()) {
+ QContactEmailAddress emailAddress;
+ emailAddress.setEmailAddress(address);
+ emailAddress.setContexts(values.value(address));
+ c.saveDetail(&emailAddress);
+ detailsAdded++;
+ }
+ QContactName name;
+ name.setFirstName("Jo");
+ name.setLastName("H N Doe");
+ c.saveDetail(&name);
+ trackerEngine->saveContact(&c, error);
+ QCOMPARE(error, QContactManager::NoError);
+ QVERIFY(c.localId() != initialId);
+ QContact contact = trackerEngine->contact_impl(c.localId(), QStringList(), error);
+ QList<QContactEmailAddress> details = contact.details<QContactEmailAddress>();
+ QCOMPARE(details.count(), detailsAdded);
+ foreach (QContactEmailAddress detail, details) {
+ QString address = detail.value(QContactEmailAddress::FieldEmailAddress);
+ QVERIFY(values.contains(address));
+ QCOMPARE(detail.contexts()[0], values.value(address));
+ }
+}
+
+void ut_qtcontacts_trackerplugin::testRemoveContact()
+{
+ QContact c;
+ QContactPhoneNumber phone;
+ phone.setNumber("+358501234567");
+ c.saveDetail(&phone);
+ QContactEmailAddress email;
+ email.setEmailAddress("super.man@hotmail.com");
+ c.saveDetail(&email);
+ QContactName name;
+ name.setFirstName("Super");
+ name.setLastName("Man");
+ c.saveDetail(&name);
+
+ QVERIFY2(trackerEngine->saveContact(&c, error) && error == QContactManager::NoError, "Saving a contact failed");
+ QVERIFY2(trackerEngine->removeContact(c.localId(), error), "Removing a contact failed");
+ QCOMPARE(error, QContactManager::NoError);
+ QVERIFY2(trackerEngine->contact_impl(c.localId(), QStringList(), error) == QContact(), "Found a contact, which should have been removed");
+}
+
+void ut_qtcontacts_trackerplugin::testSaveContacts()
+{
+ QList<QContact> contacts;
+ for (int i = 0; i < 3; i++) {
+ QContact c;
+ QContactName name;
+ name.setFirstName("John");
+ name.setLastName(QString::number(i,10));
+ c.saveDetail(&name);
+ contacts.append(c);
+ }
+
+ QMap<int, QContactManager::Error>* errorMap;
+ trackerEngine->saveContacts(&contacts, errorMap, error);
+ QCOMPARE(error, QContactManager::NoError);
+ for (int i = 0; i < contacts.count(); i++) {
+ QVERIFY(contacts[i].localId() != 0);
+ QList<QContactName> details = trackerEngine->contact_impl(contacts[i].localId(), QStringList(), error).details<QContactName>();
+ QVERIFY(details.count());
+ QCOMPARE(details.at(0).lastName(),
+ QString("%1").arg(QString::number(i,10)));
+ }
+}
+
+void ut_qtcontacts_trackerplugin::testRemoveContacts()
+{
+ QList<QContactLocalId> addedIds;
+ for (int i = 0; i < 5; i++) {
+ QContact c;
+ QContactName name;
+ name.setFirstName(QString("John%1").arg(QString::number(i,10)));
+ c.saveDetail(&name);
+ QVERIFY2(trackerEngine->saveContact(&c, error) && error == QContactManager::NoError, "Saving a contact failed");
+ addedIds.append(c.localId());
+ }
+ QList<QContactLocalId> toApiRemove;
+ toApiRemove.append(addedIds.takeLast());
+ toApiRemove.append(addedIds.takeLast());
+ QList<QContactLocalId> toPluginRemove(addedIds);
+ // Remove all, but last of the added contacts
+ bool success = trackerEngine->removeContacts(&toPluginRemove, errorMap, error);
+ QCOMPARE(success, true);
+ for (int i = 0; i < errorMap->count(); i++) {
+ QVERIFY(toPluginRemove[i] == 0);
+ }
+ QCOMPARE(error, QContactManager::NoError);
+
+ success = ContactManager::instance()->removeContacts(&toApiRemove, errorMap);
+ QCOMPARE(success, true);
+ for (int i = 0; i < errorMap->count(); i++) {
+ QVERIFY(toApiRemove[i] == 0);
+ }
+
+ // Try to remove some previously removed contacts, but one valid contact
+ success = trackerEngine->removeContacts(&addedIds, errorMap, error);
+ QCOMPARE(errorMap->count(), addedIds.count());
+ for (int i = 0; i < errorMap->count() - 1; i++) {
+ QVERIFY2(addedIds[i] != 0, "Manager should not mark id as zero");
+ }
+}
+
+void ut_qtcontacts_trackerplugin::testAvatar()
+{
+ QContact contactWithAvatar;
+ QContactAvatar avatar;
+
+ avatar.setAvatar("file:///home/user/.contacts/avatars/default_avatar.png");
+ contactWithAvatar.saveDetail(&avatar);
+ QContactName name;
+ name.setFirstName("John");name.setLastName("A Frog");
+ contactWithAvatar.saveDetail(&name);
+ QVERIFY(trackerEngine->saveContact( &contactWithAvatar, error));
+
+ QContact c = trackerEngine->contact_impl( contactWithAvatar.localId(), QStringList(), error);
+ QList<QContactAvatar> avatars = c.details<QContactAvatar>();
+ QVERIFY( avatars.size() );
+ QCOMPARE( avatars[0].avatar(), avatar.avatar() );
+}
+
+void ut_qtcontacts_trackerplugin::testUrl()
+{
+
+ //Context home, homepage url
+ QContact contactWithUrl1;
+ QContactUrl url1;
+ url1.setUrl("http://home.homepage");
+ url1.setContexts(QContactDetail::ContextHome);
+ url1.setSubType(QContactUrl::SubTypeHomePage);
+ QContactName name;
+ name.setFirstName("John");name.setLastName("TestUrl1");
+ contactWithUrl1.saveDetail(&name);
+ contactWithUrl1.saveDetail(&url1);
+ QVERIFY(trackerEngine->saveContact(&contactWithUrl1, error));
+
+ //Context work, homepage url
+ QContact contactWithUrl2;
+ QContactUrl url2;
+ url2.setUrl("http://work.homepage");
+ url2.setContexts(QContactDetail::ContextWork);
+ url2.setSubType(QContactUrl::SubTypeHomePage);
+ QContactName name2;
+ name2.setLastName("TestUrl2");
+ contactWithUrl2.saveDetail(&name2);
+ contactWithUrl2.saveDetail(&url2);
+ QVERIFY(trackerEngine->saveContact(&contactWithUrl2, error));
+
+ //Context home, favourite url
+ QContact contactWithUrl3;
+ QContactUrl url3;
+ url3.setUrl("http://home.favourite");
+ url3.setContexts(QContactDetail::ContextHome);
+ url3.setSubType(QContactUrl::SubTypeFavourite);
+
+ name2.setLastName("TestUrl3");
+ contactWithUrl3.saveDetail(&name2);
+ contactWithUrl3.saveDetail(&url3);
+ QVERIFY(trackerEngine->saveContact(&contactWithUrl3, error));
+
+
+ QContactLocalId id1 = contactWithUrl1.localId();
+ QContactLocalId id2 = contactWithUrl2.localId();
+ QContactLocalId id3 = contactWithUrl3.localId();
+ QCOMPARE(contact(id1).detail<QContactUrl>().url(), QString("http://home.homepage"));
+ QCOMPARE(contact(id2).detail<QContactUrl>().url(), QString("http://work.homepage"));
+ QCOMPARE(contact(id3).detail<QContactUrl>().url(), QString("http://home.favourite"));
+
+ QVERIFY(contact(id1).detail<QContactUrl>().contexts()[0] == QContactDetail::ContextHome );
+ QVERIFY(contact(id2).detail<QContactUrl>().contexts()[0] == QContactDetail::ContextWork );
+ QVERIFY(contact(id3).detail<QContactUrl>().contexts()[0] == QContactDetail::ContextHome );
+
+ QVERIFY(contact(id1).detail<QContactUrl>().subType() == QContactUrl::SubTypeHomePage );
+ QVERIFY(contact(id2).detail<QContactUrl>().subType() == QContactUrl::SubTypeHomePage );
+ QVERIFY(contact(id3).detail<QContactUrl>().subType() == QContactUrl::SubTypeFavourite );
+
+}
+
+/*
+void ut_qtcontacts_trackerplugin::testGroups()
+{
+ qDebug() << "Not implemented";
+ QVERIFY(false);
+}
+
+void ut_qtcontacts_trackerplugin::testGroup()
+{
+ qDebug() << "Not implemented";
+ QVERIFY(false);
+}
+
+void ut_qtcontacts_trackerplugin::testSaveGroup()
+{
+ qDebug() << "Not implemented";
+ QVERIFY(false);
+}
+
+void ut_qtcontacts_trackerplugin::testRemoveGroup()
+{
+ qDebug() << "Not implemented";
+ QVERIFY(false);
+}
+
+void ut_qtcontacts_trackerplugin::testDetailDefinitions()
+{
+ qDebug() << "Not implemented";
+ QVERIFY(false);
+}
+
+void ut_qtcontacts_trackerplugin::testDetailDefinition()
+{
+ qDebug() << "Not implemented";
+ QVERIFY(false);
+}
+
+void ut_qtcontacts_trackerplugin::testSaveDetailDefinition()
+{
+ qDebug() << "Not implemented";
+ QVERIFY(false);
+}
+
+void ut_qtcontacts_trackerplugin::testRemoveDetailDefinition()
+{
+ qDebug() << "Not implemented";
+ QVERIFY(false);
+}
+*/
+
+void ut_qtcontacts_trackerplugin::testSyncContactManagerContactsAddedSince()
+{
+ // FIXME move this code out: not supposed to compile in and load the same code as dll plugin
+ QSKIP("Statically and dinamically linking the same code is not working", SkipAll);
+
+ QDateTime start;
+ QList<QContactLocalId> addedIds;
+ syncContactsAddedSinceHelper(start, addedIds);
+
+ QContactChangeLogFilter filter(QContactChangeLogFilter::EventAdded);
+ filter.setSince(start);
+
+ QList<QContactSortOrder> sortOrder;
+
+ QList<QContact> contactIds = ContactManager::instance()->contacts( filter, sortOrder, QStringList() );
+ qDebug() << "addedIds" << addedIds.size();
+ qDebug() << "contactIds" << contactIds.size();
+ QVERIFY2( contactIds.size() == addedIds.size(), "Incorrect number of filtered contacts");
+}
+
+void ut_qtcontacts_trackerplugin::testSyncTrackerEngineContactsIdsAddedSince()
+{
+ QDateTime start;
+ QList<QContactLocalId> addedIds;
+ syncContactsAddedSinceHelper(start, addedIds);
+
+ QContactChangeLogFilter filter(QContactChangeLogFilter::EventAdded);
+ filter.setSince(start);
+
+ QList<QContactSortOrder> sortOrder;
+ QContactManager::Error error;
+
+ QList<QContactLocalId> contactIds = trackerEngine->contactIds( filter, sortOrder, error );
+ qDebug() << "addedIds" << addedIds;
+ qDebug() << "contactIds" << contactIds;
+ QVERIFY2( contactIds.size() == addedIds.size(), "Incorrect number of filtered contacts");
+}
+
+void ut_qtcontacts_trackerplugin::testSyncContactManagerContactIdsAddedSince()
+{
+ // FIXME move this code out: not supposed to compile in and load the same code as dll plugin
+ QSKIP("Statically and dinamically linking the same code is not working", SkipAll);
+ QDateTime start;
+ QList<QContactLocalId> addedIds;
+ syncContactsAddedSinceHelper(start, addedIds);
+ QContactChangeLogFilter filter(QContactChangeLogFilter::EventAdded);
+ filter.setSince(start);
+ QList<QContactSortOrder> sortOrder;
+
+
+ QList<QContactLocalId> contactIds = ContactManager::instance()->contactIds(filter, sortOrder);
+ qDebug() << "addedIds" << addedIds;
+ qDebug() << "contactIds" << contactIds;
+ QVERIFY2( contactIds.size() == addedIds.size(), "Incorrect number of filtered contacts");
+}
+
+
+void ut_qtcontacts_trackerplugin::syncContactsAddedSinceHelper(QDateTime& start, QList<QContactLocalId>& addedIds)
+{
+ for (int i = 0; i < 3; i++) {
+ QContact c;
+ QContactName name;
+ name.setFirstName("A"+QString::number(i));
+ QVERIFY2(c.saveDetail(&name), "Failed to save detail");
+ QVERIFY2(trackerEngine->saveContact(&c, error), "Failed to save contact");
+ }
+
+ QTest::qWait(1000);
+ start = QDateTime::currentDateTime();
+
+ for (int i = 0; i < 3; i++) {
+ QContact c;
+ QContactName name;
+ name.setFirstName("B"+QString::number(i));
+ QVERIFY2(c.saveDetail(&name), "Failed to save detail");
+ QVERIFY2(trackerEngine->saveContact(&c, error), "Failed to save contact");
+ addedIds.append(c.localId());
+ }
+}
+
+void ut_qtcontacts_trackerplugin::testContactsAddedSince()
+{
+ QList<QContactLocalId> addedIds;
+ QDateTime start;
+ for (int i = 0; i < 3; i++) {
+ QContact c;
+ QContactName name;
+ name.setFirstName("A"+QString::number(i));
+ QVERIFY2(c.saveDetail(&name), "Failed to save detail");
+ QVERIFY2(trackerEngine->saveContact(&c, error), "Failed to save contact");
+ }
+
+ QTest::qWait(1000);
+ start = QDateTime::currentDateTime();
+
+ for (int i = 0; i < 3; i++) {
+ QContact c;
+ QContactName name;
+ name.setFirstName("B"+QString::number(i));
+ QVERIFY2(c.saveDetail(&name), "Failed to save detail");
+ QVERIFY2(trackerEngine->saveContact(&c, error), "Failed to save contact");
+ addedIds.append(c.localId());
+ }
+
+ // now one asynchronous request to read all the
+ QContactFetchRequest request;
+ QContactChangeLogFilter filter(QContactChangeLogFilter::EventAdded);
+ filter.setSince(start);
+ request.setFilter(filter);
+
+ // here You specify which details are of interest
+ QStringList details;
+ details << QContactAvatar::DefinitionName
+ << QContactBirthday::DefinitionName
+ << QContactAddress::DefinitionName
+ << QContactEmailAddress::DefinitionName
+ << QContactDisplayLabel::DefinitionName
+ << QContactGender::DefinitionName
+ << QContactAnniversary::DefinitionName
+ << QContactName::DefinitionName
+ << QContactOnlineAccount::DefinitionName
+ << QContactOrganization::DefinitionName
+ << QContactPhoneNumber::DefinitionName;
+ request.setDefinitionRestrictions(details);
+
+ Slots slot;
+ QObject::connect(&request, SIGNAL(resultsAvailable()),
+ &slot, SLOT(resultsAvailable()));
+
+ // start. clients should, instead of following use
+ // request.setManager(trackermanagerinstance);
+ // request.start();
+ trackerEngine->startRequest(&request);
+ trackerEngine->waitForRequestFinished(&request, 10000);
+ // if it takes more, then something is wrong
+ QVERIFY(request.isFinished());
+ QCOMPARE(slot.contacts.count(), addedIds.count());
+
+ foreach(QContact cont, slot.contacts) {
+ QVERIFY2(addedIds.contains(cont.localId()), "One of the added contacts was not reported as added");
+ }
+
+ QContactLocalIdFetchRequest idreq;
+ filter.setSince(start);
+ idreq.setFilter(filter);
+
+ Slots slot2;
+ QObject::connect(&idreq, SIGNAL(resultsAvailable()),
+ &slot2, SLOT(idResultsAvailable()));
+ trackerEngine->startRequest(&idreq);
+ trackerEngine->waitForRequestFinished(&idreq, 10000);
+ QVERIFY(idreq.isFinished());
+ QCOMPARE(slot2.ids.count(), addedIds.count());
+ foreach(QContactLocalId id, slot2.ids) {
+ QVERIFY2(addedIds.contains(id), "One of the added contacts was not reported as added");
+ }
+
+}
+
+void ut_qtcontacts_trackerplugin::testContactsModifiedSince()
+{
+ QDateTime start;
+ QList<QContactLocalId> addedIds;
+ QList<QContactLocalId> modified;
+
+ const int contactsToAdd = 5;
+ const int contactsToModify = 3;
+ QVERIFY2(contactsToAdd >= contactsToModify, "Cannot modify more contacts than this test has added");
+ QVERIFY2(contactsToModify+1 <= contactsToAdd, "Cannot modify more contacts than this test has added");
+
+ // Add contacts with only first name and store them to list of added
+ for (int i = 0; i < contactsToAdd; i++) {
+ QContact c;
+ QContactName name;
+ name.setFirstName("A"+QString::number(i));
+ QVERIFY2(c.saveDetail(&name), "Failed to save detail");
+ QVERIFY2(trackerEngine->saveContact(&c, error), "Failed to save contact");
+ addedIds.append(c.localId());
+ }
+
+ QTest::qWait(2000);
+ start = QDateTime::currentDateTime();
+
+ // Modify and save rest of the contacts
+ for (int i = 0; i < contactsToModify; i++) {
+ QContact c = contact(addedIds[i]);
+ QContactName name = c.detail<QContactName>();
+ // Modify name
+ name.setFirstName("B"+QString::number(i));
+ QVERIFY2(c.saveDetail(&name), "Failed to save detail");
+ QVERIFY2(trackerEngine->saveContact(&c, error), "Failed to save contact");
+ modified.append(c.localId());
+ }
+ // Set filter
+ QContactChangeLogFilter filter(QContactChangeLogFilter::EventChanged);
+ filter.setSince(start);
+
+ QContactLocalIdFetchRequest idfetch;
+ QContactFetchRequest fetch;
+ idfetch.setFilter(filter);
+ fetch.setFilter(filter);
+ trackerEngine->startRequest(&idfetch);
+ trackerEngine->waitForRequestFinished(&idfetch, 10000);
+ QVERIFY2(idfetch.isFinished(), "Id fetch request did not finish on time");
+ QVERIFY2(idfetch.error() == QContactManager::NoError, "Id fetch request finished with errors");
+ QList<QContactLocalId> actuallyModifiedIds = idfetch.ids();
+ trackerEngine->startRequest(&fetch);
+ trackerEngine->waitForRequestFinished(&fetch, 10000);
+ QVERIFY2(fetch.isFinished(), "Fetch request did not finish on time");
+ QVERIFY2(fetch.error() == QContactManager::NoError, "Fetch request finished with errors");
+ QList<QContact> actuallyModified = fetch.contacts();
+
+ // Num of actually modified should be same as supposedly modified
+ QCOMPARE(actuallyModifiedIds.count(), modified.count());
+ QCOMPARE(actuallyModified.count(), modified.count());
+ // All the ids of the modified contacts should be found in the result list
+ foreach (QContactLocalId id, modified) {
+ QVERIFY2(actuallyModifiedIds.contains(id), "One the modified contacts was not reported as modified");
+ }
+}
+
+void ut_qtcontacts_trackerplugin::testContactsRemovedSince()
+{
+ QDateTime start = QDateTime::currentDateTime();
+ QContactChangeLogFilter filter(QContactChangeLogFilter::EventRemoved);
+ filter.setSince(start);
+ QList<QContactSortOrder> sorts;
+ QList<QContactLocalId> actuallyRemoved = trackerEngine->contactIds(filter, sorts, error);
+ QVERIFY(actuallyRemoved.isEmpty());
+ QVERIFY(error == QContactManager::NotSupportedError);
+}
+/*
+void ut_qtcontacts_trackerplugin::testGroupsAddedSince()
+{
+ qDebug() << "Not implemented";
+ QVERIFY(false);
+}
+
+void ut_qtcontacts_trackerplugin::testGroupsModifiedSince()
+{
+ qDebug() << "Not implemented";
+ QVERIFY(false);
+}
+
+void ut_qtcontacts_trackerplugin::testGroupsRemovedSince()
+{
+ qDebug() << "Not implemented";
+ QVERIFY(false);
+}
+*/
+
+void ut_qtcontacts_trackerplugin::cleanupTestCase()
+{
+ delete trackerEngine;
+ delete errorMap;
+}
+
+void ut_qtcontacts_trackerplugin::cleanup()
+{
+ foreach (QContactLocalId id, addedContacts) {
+ trackerEngine->removeContact(id, error);
+ }
+ addedContacts.clear();
+}
+
+
+void ut_qtcontacts_trackerplugin::testNcoTypes()
+{
+ using namespace SopranoLive;
+
+ QList<QContactLocalId> ids;
+ RDFVariable RDFContact = RDFVariable::fromType<nco::PersonContact>();
+ RDFSelect query;
+
+ query.addColumn("contact_uri", RDFContact);
+ query.addColumn("contactId", RDFContact.property<nco::contactUID>());
+ LiveNodes ncoContacts = ::tracker()->modelQuery(query);
+ foreach( Live<nco::PersonContact> p, ncoContacts ) {
+ QVERIFY(p.hasType<nco::Contact>());
+ QVERIFY(p.hasType<nco::Role>());
+ QVERIFY(p.hasType<nco::PersonContact>());
+ }
+}
+
+void ut_qtcontacts_trackerplugin::testAsyncReadContacts()
+{
+ addedContacts.clear();
+ // Add at least one contact to be sure that this doesn't fail because tracker is clean
+
+ QStringList firstNames, lastNames;
+ firstNames << "aa" << "ab" << "ac" << "dd" << "fe";
+ lastNames << "fe" << "ab" << "dd" << "dd" << "aa";
+ for (int i = 0; i < firstNames.count(); i++) {
+ QContact c;
+ QContactName name;
+ name.setFirstName(firstNames.at(i));
+ name.setLastName(lastNames.at(i));
+ QContactAvatar avatar;
+ avatar.setAvatar("default_avatar.png");
+ avatar.setSubType(QContactAvatar::SubTypeImage);
+ QVERIFY(c.saveDetail(&name));
+ QVERIFY(c.saveDetail(&avatar));
+ QVERIFY(trackerEngine->saveContact(&c, error));
+ addedContacts.append(c.localId());
+ }
+
+ // Prepare the filter for the request - we really should test only the contact we add here.
+ QContactLocalIdFilter filter;
+ filter.setIds(addedContacts);
+
+ // this one will get complete contacts
+
+ Slots slot;
+ QContactFetchRequest request;
+ QList<QContactSortOrder> sorting;
+ QContactSortOrder sort, sort1;
+ sort.setDetailDefinitionName(QContactName::DefinitionName, QContactName::FieldLast);
+ sort1.setDetailDefinitionName(QContactName::DefinitionName, QContactName::FieldFirst);
+ sorting << sort << sort1;
+ QStringList details; details << QContactName::DefinitionName << QContactAvatar::DefinitionName;
+ request.setDefinitionRestrictions(details);
+ request.setSorting(sorting);
+ request.setFilter(filter);
+
+ QObject::connect(&request, SIGNAL(resultsAvailable()),
+ &slot, SLOT(resultsAvailable()));
+
+ // this one only ids
+ QContactLocalIdFetchRequest request1;
+ request1.setFilter(filter);
+ QObject::connect(&request1, SIGNAL(resultsAvailable()),
+ &slot, SLOT(idResultsAvailable()));
+
+ // the purpose is to compare if all contacts are loaded, and
+ // if optional fields are defined properly in request
+
+ // start both at once
+ trackerEngine->startRequest(&request);
+ trackerEngine->startRequest(&request1);
+ trackerEngine->waitForRequestFinished(&request, 10000);
+ trackerEngine->waitForRequestFinished(&request1, 10000);
+
+
+ // if it takes more, then something is wrong
+ QVERIFY(request.isFinished());
+ QVERIFY(request1.isFinished());
+
+ // there need1 to be something added to be verified
+ QVERIFY(!request.contacts().isEmpty());
+ // now ask for one contact
+ QVERIFY(!slot.contacts.isEmpty());
+ // there need to be something added to be verified
+ QVERIFY(!request1.ids().isEmpty());
+ // now ask for one contact
+ QVERIFY(!slot.ids.isEmpty());
+
+ QVERIFY2(slot.contacts.count() == slot.ids.count(), "not all contacts were loaded");
+ QVERIFY(slot.contacts.count() >= firstNames.count());
+ for( int i = 0; i < slot.contacts.size() -1 ; i++)
+ {
+ QContact contact = slot.contacts[i];
+ QContact contact1 = slot.contacts[i+1];
+ QString last0 = contact.detail<QContactName>().lastName();
+ QString first0 = contact.detail<QContactName>().firstName();
+ QString last1 = contact1.detail<QContactName>().lastName();
+ QString first1 = contact1.detail<QContactName>().firstName();
+ // sorting
+ qDebug() << "contacts:" << contact.localId() << first0 << last0;
+ bool test = last0 < last1 || (last0 == last1 && first0 <= first1);
+ if (!test) {
+ qDebug() << "contacts sort failed. First: " << contact1.localId() << first0 << last1 << "lasts: " << last0 << last1;
+ }
+ QVERIFY2(test, "Sorting failed.");
+ }
+
+}
+
+void ut_qtcontacts_trackerplugin::testFilterContacts()
+{
+ // this one will get complete contacts
+ QContact c;
+ QContactName name;
+ name.setFirstName("Zuba");
+ name.setLastName("Zub");
+ c.saveDetail(&name);
+ QContactPhoneNumber phone;
+
+ phone.setNumber("4872444");
+ c.saveDetail(&phone);
+
+ QContactBirthday birthday;
+ birthday.setDate(QDate(2010, 2, 14));
+ c.saveDetail(&birthday);
+
+ trackerEngine->saveContact(&c, error);
+
+ QStringList details;
+ details << QContactName::DefinitionName << QContactAvatar::DefinitionName
+ << QContactPhoneNumber::DefinitionName;
+
+ QContactFetchRequest request;
+ QContactDetailFilter filter;
+ filter.setDetailDefinitionName(QContactPhoneNumber::DefinitionName, QContactPhoneNumber::FieldNumber);
+
+ Slots slot;
+ QObject::connect(&request, SIGNAL(resultsAvailable()),
+ &slot, SLOT(resultsAvailable()));
+ filter.setValue(QString("4872444"));
+ filter.setMatchFlags(QContactFilter::MatchEndsWith);
+
+ request.setDefinitionRestrictions(details);
+ request.setFilter(filter);
+
+ trackerEngine->startRequest(&request);
+
+ for(int i = 0; i < 100; i++)
+ {
+ usleep(100000);
+ QCoreApplication::processEvents();
+ if(request.isFinished() )
+ break;
+ }
+
+ // if it takes more, then something is wrong
+ QVERIFY(request.isFinished());
+ QVERIFY(!request.contacts().isEmpty());
+
+ QVERIFY(!slot.contacts.isEmpty());
+
+ bool containsThisId = false;
+ foreach(const QContact &contact, slot.contacts)
+ {
+ if( contact.localId() == c.localId())
+ containsThisId = true;
+ bool containsPhone = false;
+ foreach(const QContactDetail &detail, contact.details(QContactPhoneNumber::DefinitionName))
+ {
+ if(detail.value(QContactPhoneNumber::FieldNumber).contains("4872444"))
+ {
+ containsPhone = true;
+ break;
+ }
+ }
+ QVERIFY(containsPhone);
+ }
+ QVERIFY(containsThisId);
+
+ // filter by birthday range
+ QContactDetailRangeFilter rangeFilter;
+ rangeFilter.setDetailDefinitionName(QContactBirthday::DefinitionName, QContactBirthday::FieldBirthday);
+ // include lower & exclude upper by default
+ rangeFilter.setRange(QDate(2010, 2, 14), QDate(2010, 2, 15));
+ QList<QContact> contacts = trackerEngine->contacts(rangeFilter, QList<QContactSortOrder>(), QStringList()<< QContactBirthday::DefinitionName, error);
+ QVERIFY(!contacts.isEmpty());
+ bool containsOurContact(false);
+ foreach(const QContact &cont, contacts)
+ {
+ QVERIFY(cont.detail<QContactBirthday>().date() == QDate(2010, 2, 14));
+ if( c.id() == cont.id() )
+ containsOurContact = true;
+ }
+ QVERIFY(containsOurContact);
+}
+
+void ut_qtcontacts_trackerplugin::testFilterContactsEndsWith()
+{
+ QSettings settings(QSettings::IniFormat, QSettings::UserScope, "Nokia", "Trackerplugin");
+ QString restoreValue = settings.value("phoneNumberMatchDigitCount", "7").toString();
+
+ QContact matchingContact;
+ QContactName name;
+ name.setFirstName("Zuba");
+ name.setLastName("Zub");
+ matchingContact.saveDetail(&name);
+ QContactPhoneNumber phone;
+ // TODO doesnt work yet phone.setContexts(QContactPhoneNumber::ContextWork);
+ phone.setNumber("3210987654321");
+ matchingContact.saveDetail(&phone);
+ trackerEngine->saveContact(&matchingContact, error);
+
+ QStringList details;
+ details << QContactName::DefinitionName << QContactAvatar::DefinitionName
+ << QContactPhoneNumber::DefinitionName;
+
+ QContactFetchRequest request;
+ QContactDetailFilter filter;
+ filter.setDetailDefinitionName(QContactPhoneNumber::DefinitionName, QContactPhoneNumber::FieldNumber);
+
+ Slots slot;
+ QObject::connect(&request, SIGNAL(resultsAvailable()),
+ &slot, SLOT(resultsAvailable()));
+
+ {
+ // test matching of 7 last digits
+ int matchCount = 7;
+ qDebug() << "Test matching of" << matchCount << "last digits.";
+ settings.setValue("phoneNumberMatchDigitCount", matchCount);
+ QString matchValue = "3000007654321";
+ QContact nonMatchingContact;
+ nonMatchingContact.saveDetail(&name);
+ phone.setNumber("3210980654321");
+ nonMatchingContact.saveDetail(&phone);
+ trackerEngine->saveContact(&nonMatchingContact, error);
+
+ filter.setValue(matchValue);
+ filter.setMatchFlags(QContactFilter::MatchEndsWith);
+
+ request.setDefinitionRestrictions(details);
+ request.setFilter(filter);
+
+ trackerEngine->startRequest(&request);
+
+ for(int i = 0; i < 100; i++) {
+ usleep(100000);
+ QCoreApplication::processEvents();
+ if (request.isFinished())
+ break;
+ }
+ QVERIFY(request.isFinished());
+ QVERIFY(!slot.contacts.isEmpty());
+
+ bool containsMatchingId = false;
+ bool containsNonMatchingId = false;
+ foreach(const QContact &contact, slot.contacts) {
+ if (contact.localId() == nonMatchingContact.localId())
+ containsNonMatchingId = true;
+ if (contact.localId() == matchingContact.localId())
+ containsMatchingId = true;
+ bool containsPhone = false;
+ foreach(const QContactDetail &detail, contact.details(QContactPhoneNumber::DefinitionName)) {
+ if (detail.value(QContactPhoneNumber::FieldNumber).endsWith(matchValue.right(matchCount))) {
+ containsPhone = true;
+ break;
+ }
+ }
+ QVERIFY(containsPhone);
+ }
+ QVERIFY(containsMatchingId);
+ QVERIFY(!containsNonMatchingId);
+ }
+
+ {
+ // test matching of 11 last digits
+ int matchCount = 11;
+ qDebug() << "Test matching of" << matchCount << "last digits.";
+ settings.setValue("phoneNumberMatchDigitCount", matchCount);
+ QString matchValue = "3010987654321";
+ QContact nonMatchingContact;
+ nonMatchingContact.saveDetail(&name);
+ phone.setNumber("3200987654321");
+ nonMatchingContact.saveDetail(&phone);
+ trackerEngine->saveContact(&nonMatchingContact, error);
+
+ QContact matchingContactWithShorterNumber;
+ QContactName name1;
+ name1.setFirstName("ShortNumber");
+ name1.setLastName("Zub1");
+ matchingContactWithShorterNumber.saveDetail(&name1);
+ QContactPhoneNumber phone1;
+ phone1.setNumber("54321");
+ matchingContactWithShorterNumber.saveDetail(&phone1);
+ trackerEngine->saveContact(&matchingContactWithShorterNumber, error);
+ QVERIFY(QContactManager::NoError == error);
+
+
+ filter.setValue(matchValue);
+ filter.setMatchFlags(QContactFilter::MatchEndsWith);
+
+ request.setDefinitionRestrictions(details);
+ request.setFilter(filter);
+
+ trackerEngine->startRequest(&request);
+
+ for(int i = 0; i < 100; i++) {
+ usleep(100000);
+ QCoreApplication::processEvents();
+ if (request.isFinished())
+ break;
+ }
+ QVERIFY(request.isFinished());
+ QVERIFY(!slot.contacts.isEmpty());
+
+ bool containsMatchingId = false;
+ bool containsNonMatchingId = false;
+ foreach(const QContact &contact, slot.contacts) {
+ if (contact.localId() == nonMatchingContact.localId())
+ containsNonMatchingId = true;
+ if (contact.localId() == matchingContact.localId())
+ containsMatchingId = true;
+ bool containsPhone = false;
+ foreach(const QContactDetail &detail, contact.details(QContactPhoneNumber::DefinitionName)) {
+ if (detail.value(QContactPhoneNumber::FieldNumber).endsWith(matchValue.right(matchCount))) {
+ containsPhone = true;
+ break;
+ }
+ }
+ QVERIFY(containsPhone);
+ }
+ QVERIFY(containsMatchingId);
+ QVERIFY(!containsNonMatchingId);
+
+ // now verify with short number
+ filter.setValue("54321");
+ filter.setMatchFlags(QContactFilter::MatchEndsWith);
+
+ request.setDefinitionRestrictions(details);
+ request.setFilter(filter);
+
+ trackerEngine->startRequest(&request);
+
+ for(int i = 0; i < 100; i++) {
+ usleep(100000);
+ QCoreApplication::processEvents();
+ if (request.isFinished())
+ break;
+ }
+ QVERIFY(request.isFinished());
+ QVERIFY(!slot.contacts.isEmpty());
+ bool containsShort = false;
+ foreach(const QContact &contact, slot.contacts) {
+ if (contact.localId() == matchingContactWithShorterNumber.localId())
+ containsShort = true;
+ }
+ QVERIFY(containsShort);
+ }
+ settings.setValue("phoneNumberMatchDigitCount", restoreValue);
+}
+
+void ut_qtcontacts_trackerplugin::testFilterTwoNameFields()
+{
+ // init test
+ QMap<QContactLocalId, QContactName> names;
+ for (int i = 0; i < 3; i++) {
+ QContact c;
+ QContactName name;
+ name.setFirstName(QUuid::createUuid().toString() + QString::number(i));
+ name.setLastName(QUuid::createUuid().toString() + QString::number(i));
+ c.saveDetail(&name);
+ QContactAvatar avatar;
+ avatar.setAvatar(QUuid::createUuid().toString());
+ c.saveDetail(&avatar);
+ QVERIFY(trackerEngine->saveContact(&c, error));
+ names.insert(c.localId(), name);
+ QCOMPARE(error, QContactManager::NoError);
+ addedContacts.append(c.localId());
+ }
+
+ // Init filter
+ QContactLocalId searchId = names.keys().at(1);
+ QString searchFirst = names.value(searchId).firstName();
+ QString searchLast = names.value(searchId).lastName();
+ QContactUnionFilter ufilter;
+ QContactDetailFilter filterFirst;
+ filterFirst.setDetailDefinitionName(QContactName::DefinitionName, QContactName::FieldFirst);
+ filterFirst.setMatchFlags(QContactFilter::MatchExactly);
+ filterFirst.setValue(searchFirst);
+ QContactDetailFilter filterLast;
+ filterLast.setDetailDefinitionName(QContactName::DefinitionName, QContactName::FieldLast);
+ filterLast.setMatchFlags(QContactFilter::MatchExactly);
+ filterLast.setValue(searchLast);
+ ufilter.setFilters(QList<QContactFilter>() << filterFirst << filterLast);
+
+ // Init request
+ QContactFetchRequest request;
+ request.setFilter(ufilter);
+ trackerEngine->startRequest(&request);
+ trackerEngine->waitForRequestFinished(&request, 10000);
+
+
+ // Test fetch result
+ QCOMPARE(request.contacts().count(), 1);
+ QCOMPARE(request.contacts().at(0).localId(), searchId);
+ QCOMPARE(request.contacts().at(0).detail<QContactName>().firstName(), searchFirst);
+ QCOMPARE(request.contacts().at(0).detail<QContactName>().lastName(), searchLast);
+}
+
+void ut_qtcontacts_trackerplugin::testTrackerUriToUniqueId()
+{
+ QString uri = "contact:1234567";
+ QContactLocalId id = url2UniqueId( uri );
+ QCOMPARE( (int)id, 1234567 );
+}
+
+void ut_qtcontacts_trackerplugin::testQRelationshipAndMergingContacts()
+{
+ QContact firstContact;
+ QContactName name;
+ name.setFirstName("FirstMeta");
+ firstContact.saveDetail(&name);
+ QVERIFY(trackerEngine->saveContact(&firstContact, error));
+
+ QList<QContactLocalId> secondIds;
+ QStringList names(QStringList()<<"SecondMeta"<<"ThirdMeta");
+ foreach (QString firstname, names)
+ {
+ QContact secondContact;
+ QContactName name1;
+ name1.setFirstName(firstname);
+ secondContact.saveDetail(&name1);
+ QVERIFY(trackerEngine->saveContact(&secondContact, error));
+ secondIds<<secondContact.id().localId();
+ QContactRelationship rel;
+ rel.setRelationshipType(QContactRelationship::Is);
+ rel.setFirst(firstContact.id());
+ rel.setSecond(secondContact.id());
+ QContactRelationshipSaveRequest req;
+ req.setRelationships(QList<QContactRelationship>()<<rel);
+ QVERIFY(trackerEngine->startRequest(&req));
+ trackerEngine->waitForRequestFinished(&req, 10000);
+ // if it takes more, then something is wrong
+ QVERIFY(req.isFinished());
+ QVERIFY(QContactManager::NoError == req.error());
+ }
+
+ // once they are merged - that's it - no contacts or relationship track exists
+ foreach( QContactLocalId mergedId, secondIds)
+ {
+ QContact second = contact(mergedId, QStringList()<<QContactName::DefinitionName);
+ QVERIFY(second.localId() == 0); // as not existing
+ }
+ QVERIFY(contact(firstContact.localId(), QStringList()<<QContactName::DefinitionName).localId() != 0);
+ // TODO check that values from secondids are merged to firstcontact
+
+}
+
+void ut_qtcontacts_trackerplugin::insertContact(const QString& URI, QContactLocalId uid, QString imId, QString imStatus, QString accountPath, QString protocol )
+{
+ QProcess inserter;
+ QStringList args;
+ args << URI << QString::number(uid) << imId << accountPath << imStatus << "In Helsinki" << protocol << "Some" << "Guy";
+ inserter.start( PATH_TO_SPARQL_TESTS+"/insertTpContact.sparql", args );
+ inserter.waitForFinished();
+}
+
+void ut_qtcontacts_trackerplugin::updateIMContactStatus(const QString& uri, QString imStatus)
+{
+ QProcess inserter;
+ QStringList args;
+ args << uri << imStatus;
+ inserter.start( PATH_TO_SPARQL_TESTS+"/updateTpStatus.sparql", args );
+ inserter.waitForFinished();
+}
+
+void ut_qtcontacts_trackerplugin::testMergeTwoOnlineContacts()
+{
+ QList<QContact> contacts;
+ for( int i = 0; i < 3; i++ )
+ {
+ unsigned int contactid = 555+i;
+ insertContact(QString("contact:") + QString::number(contactid),
+ contactid, QString::number(contactid)+ "@ovi.com", "nco:presence-status-available", QString("/org/freedesktop/fake/account/%1").arg(contactid),"ovi.com");
+ QContact c = contact(contactid, QStringList()<<QContactOnlineAccount::DefinitionName);
+ contacts << c;
+ }
+ QContactRelationship rel;
+ rel.setFirst(contacts.at(0).id());
+ rel.setSecond(contacts.at(1).id());
+ QContactRelationship rel2;
+ rel2.setFirst(contacts.at(0).id());
+ rel2.setSecond(contacts.at(2).id());
+
+ QContactRelationshipSaveRequest req;
+ //TODO adding rel2 to the following causes segfault
+ req.setRelationships(QList<QContactRelationship>()<<rel);
+ QVERIFY(trackerEngine->startRequest(&req));
+ trackerEngine->waitForRequestFinished(&req, 1000);
+ QVERIFY(req.isFinished());
+ QVERIFY(QContactManager::NoError == req.error());
+
+ QList<QContactOnlineAccount> onlineAccounts = contacts.at(0).details<QContactOnlineAccount>();
+ qDebug() << onlineAccounts.size();
+ QEXPECT_FAIL("", "Do net yet support merging multiple im contacts", Continue);
+ QVERIFY(onlineAccounts.size() == 2);
+}
+
+void ut_qtcontacts_trackerplugin::testIMContactsAndMetacontactMasterPresence()
+{
+ if( !QFileInfo(PATH_TO_SPARQL_TESTS).exists() )
+ {
+ qWarning()<<Q_FUNC_INFO<<"is disabled - test scripts are not installed";
+ return;
+ }
+ QList<unsigned int> idstomerge;
+ QContactLocalId masterContactId; // using one master contact later for additional testing
+ for( int i = 0; i < 2; i++ )
+ {
+ unsigned int contactid = 999998+i;
+ idstomerge << contactid;
+ insertContact(QString("contact:") + QString::number(999998+i),
+ contactid, QString::number(999998 + i)+ "@ovi.com", "nco:presence-status-available", QString("/org/freedesktop/fake/account/%1").arg(999998+i),"ovi.com");
+ QContact c = contact(contactid, QStringList()<<QContactOnlineAccount::DefinitionName);
+ QVERIFY(c.localId() == contactid);
+ QVERIFY(c.detail<QContactOnlineAccount>().serviceProvider() == "ovi.com");
+ QContact firstContact;
+ QContactName name;
+ name.setFirstName("FirstMetaWithIM"+QString::number(contactid));
+ firstContact.saveDetail(&name);
+ QVERIFY(trackerEngine->saveContact(&firstContact, error));
+
+ // save metarelationship
+ QContactRelationship rel;
+ rel.setRelationshipType(QContactRelationship::Is);
+ rel.setFirst(firstContact.id());
+ masterContactId = firstContact.localId();
+ rel.setSecond(c.id());
+ QContactRelationshipSaveRequest req;
+ req.setRelationships(QList<QContactRelationship>()<<rel);
+ QVERIFY(trackerEngine->startRequest(&req));
+ trackerEngine->waitForRequestFinished(&req, 1000);
+ QVERIFY(req.isFinished());
+ QVERIFY(QContactManager::NoError == req.error());
+ }
+
+ // expected behavior - is that master contact contains all details aggregated
+ {
+ QList<QContact> cons = contacts(QList<QContactLocalId> ()
+ << masterContactId << 999999, QStringList()
+ << QContactOnlineAccount::DefinitionName);
+ QVERIFY(cons.size() == 1);
+ QVERIFY(cons[0].id().localId() == masterContactId);
+
+ bool containDetail = false;
+ foreach(QContactOnlineAccount det, cons[0].details<QContactOnlineAccount>())
+ {
+ if (det.value("Account") == "999999@ovi.com" // deprecated, going to account URI
+ || det.accountUri() == "999999@ovi.com")
+ {
+ QVERIFY(det.presence() == QContactOnlineAccount::PresenceAvailable);
+ containDetail = true;
+ }
+ }
+ QVERIFY(containDetail);
+ }
+ //now update presence to IM Address and check it in contact (TODO and if signal is emitted)
+ updateIMContactStatus("telepathy:/org/freedesktop/fake/account/999999/999999@ovi.com", "nco:presence-status-offline");
+ {
+ QList<QContact> cons = contacts(QList<QContactLocalId> ()
+ << masterContactId << 999999, QStringList()
+ << QContactOnlineAccount::DefinitionName);
+ QVERIFY(cons.size() == 1);
+ QVERIFY(cons[0].id().localId() == masterContactId);
+
+ bool containDetail = false;
+ foreach(QContactOnlineAccount det, cons[0].details<QContactOnlineAccount>())
+ {
+ if (det.value("Account") == "999999@ovi.com" // deprecated, going to account URI
+ || det.accountUri() == "999999@ovi.com")
+ {
+ QVERIFY(det.presence() == QContactOnlineAccount::PresenceOffline);
+ containDetail = true;
+ }
+ }
+ QVERIFY(containDetail);
+ }
+
+ // load contact should load also all merged content from other contacts (that dont exis anymore)
+ {
+ QList<QContact> cons = contacts(QList<QContactLocalId> ()
+ << masterContactId, QStringList()
+ << QContactOnlineAccount::DefinitionName);
+ QVERIFY(cons.size() == 1);
+ QVERIFY(cons[0].id().localId() == masterContactId);
+
+ bool containDetail = false;
+ foreach(QContactOnlineAccount det, cons[0].details<QContactOnlineAccount>())
+ {
+ if (det.value("Account") == "999999@ovi.com" // deprecated, going to account URI
+ || det.accountUri() == "999999@ovi.com")
+ {
+ QVERIFY(det.presence() == QContactOnlineAccount::PresenceOffline);
+ containDetail = true;
+ }
+ }
+ QVERIFY(containDetail);
+ }
+
+ // remove them
+ QVERIFY2(trackerEngine->removeContact(masterContactId, error), "Removing a contact failed");
+
+ foreach(unsigned int id, idstomerge)
+ {
+ QVERIFY2(!trackerEngine->removeContact(id, error), "Merged contact doesn't exist and removing it shoudl fail");
+ }
+}
+
+void ut_qtcontacts_trackerplugin::testIMContactsFilterring()
+{
+ QList<unsigned int> idstoremove;
+ QList<QContactLocalId> idsToRetrieveThroughFilter;
+ for( int i = 0; i < 3; i++ )
+ {
+ unsigned int contactid = qHash(QString("/org/freedesktop/fake/account/") + QString::number(999995+i) + "@ovi.com");
+ idstoremove << contactid;
+ insertContact(QString("telepathy:/org/freedesktop/fake/account/") + QString::number(999995+i) + "@ovi.com",
+ contactid, QString::number(999995 + i)+ "@ovi.com", "nco:presence-status-available",
+ QString("/org/freedesktop/fake/account/%1").arg(i/2), QString("ovi%1.com").arg(i/2));
+ if(!i/2)
+ idsToRetrieveThroughFilter << contactid;
+ }
+
+ {
+ // now filter by service provider ovi0.com needs to return 2 contacts, 999995 & 999996
+ QList<QContactLocalId> ids(idsToRetrieveThroughFilter);
+
+ QContactFetchRequest request;
+ QContactDetailFilter filter;
+ filter.setDetailDefinitionName(QContactOnlineAccount::DefinitionName, QContactOnlineAccount::FieldServiceProvider);
+
+ Slots slot;
+ QObject::connect(&request, SIGNAL(resultsAvailable()),
+ &slot, SLOT(resultsAvailable()));
+ filter.setValue(QString("ovi0.com"));
+ filter.setMatchFlags(QContactFilter::MatchExactly);
+
+ request.setDefinitionRestrictions(QStringList()<<QContactOnlineAccount::DefinitionName);
+ request.setFilter(filter);
+
+ trackerEngine->startRequest(&request);
+
+ for(int i = 0; i < 100; i++)
+ {
+ usleep(100000);
+ QCoreApplication::processEvents();
+ if(request.isFinished() )
+ break;
+ }
+
+ // if it takes more, then something is wrong
+ QVERIFY(request.isFinished());
+ QVERIFY(!request.contacts().isEmpty());
+
+ QVERIFY(request.contacts().size() >= 2);
+ foreach(const QContact &contact, request.contacts())
+ {
+ //qDebug() << contact.localId()<< "acc"<<contact.detail<QContactOnlineAccount>().serviceProvider();
+ QVERIFY(contact.detail<QContactOnlineAccount>().serviceProvider() == "ovi0.com");
+ ids.removeOne(contact.localId());
+ }
+ QVERIFY(ids.isEmpty());
+ }
+
+ // now account path filter
+ {
+ // now filter by account path 999995 & 999996
+ QList<QContactLocalId> ids(idsToRetrieveThroughFilter);
+
+ QContactFetchRequest request;
+ QContactDetailFilter filter;
+ filter.setDetailDefinitionName(QContactOnlineAccount::DefinitionName, "AccountPath");
+
+ Slots slot;
+ QObject::connect(&request, SIGNAL(resultsAvailable()),
+ &slot, SLOT(resultsAvailable()));
+ // see insertTpContact
+ filter.setValue(QString("/org/freedesktop/fake/account/0"));
+ filter.setMatchFlags(QContactFilter::MatchExactly);
+
+ request.setDefinitionRestrictions(QStringList()<<QContactOnlineAccount::DefinitionName);
+ request.setFilter(filter);
+
+ trackerEngine->startRequest(&request);
+
+ for(int i = 0; i < 100; i++)
+ {
+ usleep(100000);
+ QCoreApplication::processEvents();
+ if(request.isFinished() )
+ break;
+ }
+
+ // if it takes more, then something is wrong
+ QVERIFY(request.isFinished());
+ QVERIFY(!request.contacts().isEmpty());
+
+ QVERIFY(request.contacts().size() >= 2);
+ foreach(const QContact &contact, request.contacts())
+ {
+ QVERIFY(contact.detail<QContactOnlineAccount>().serviceProvider() == "ovi0.com");
+ ids.removeOne(contact.localId());
+ }
+ QVERIFY(ids.isEmpty());
+ }
+
+
+ // remove them
+ foreach(unsigned int id, idstoremove)
+ {
+ QVERIFY2(trackerEngine->removeContact(id, error), "Removing a contact failed");
+ }
+
+}
+
+void ut_qtcontacts_trackerplugin::testContactsWithoutMeContact() {
+ QContact c;
+ QContactName name;
+ name.setFirstName("Totally");
+ name.setLastName("Unique");
+ c.saveDetail(&name);
+ trackerEngine->saveContact(&c, error);
+ QContactLocalId id = c.localId(); // Store ID for later removal.
+
+ // Prepare the filter for the request - we fetch only the one contact saved above.
+ QList<QContactLocalId> ids;
+ ids << id;
+ QContactLocalIdFilter filter;
+ filter.setIds(ids);
+
+ // Prepare the requst - give filter to it and specify which fields to fetch. We fetch only the name.
+ QStringList details;
+ details << QContactName::DefinitionName;
+
+ QContactLocalIdFetchRequest nameFetchRequest;
+ nameFetchRequest.setFilter(filter);
+
+ // Start the request and wait for it to finish.
+ trackerEngine->startRequest(&nameFetchRequest);
+ trackerEngine->waitForRequestFinished(&nameFetchRequest, 1000);
+
+ // Requst finished. Test that only one contact is removed.
+ QList<QContactLocalId> contacts = nameFetchRequest.ids();
+ QVERIFY2(contacts.count() < 2, "We expected to get only one contact. Got more.");
+ QVERIFY2(contacts.count() != 0, "We expected to get one contact. Got none.");
+ QVERIFY2(contacts.first() == id, "Did not get the requested contact back.");
+
+ // Cleaning up.
+ trackerEngine->removeContact(id, error);
+
+}
+
+void ut_qtcontacts_trackerplugin::testDefinitionNames()
+{
+ QContactManager *cm(ContactManager::instance());
+ QMap<QString, QContactDetailDefinition> defs(cm->detailDefinitions());
+
+ foreach(QString key, defs.keys()) {
+ QCOMPARE(defs[key].name(), key);
+ }
+}
+
+
+/*************************** Helper functions for unit tests ***************'*/
+
+QContact ut_qtcontacts_trackerplugin::contact(QContactLocalId id, QStringList details)
+{
+ QContactManager::Error error;
+ return trackerEngine->contact_impl(id, details, error);
+}
+
+QList<QContact> ut_qtcontacts_trackerplugin::contacts(QList<QContactLocalId> ids, QStringList details)
+{
+ QContactFetchRequest request;
+ QContactLocalIdFilter filter;
+ filter.setIds(ids);
+ request.setFilter(filter);
+
+ request.setDefinitionRestrictions(details);
+
+ trackerEngine->startRequest(&request);
+ trackerEngine->waitForRequestFinished(&request, 1000);
+
+ return request.contacts();
+}
+
+void Slots::idResultsAvailable()
+{
+ QContactLocalIdFetchRequest* self = qobject_cast<QContactLocalIdFetchRequest*>(sender());
+ ids << self->ids();
+}
+
+void Slots::resultsAvailable()
+{
+ QContactFetchRequest* self = qobject_cast<QContactFetchRequest*>(sender());
+ contacts = self->contacts();
+ QList<QContactLocalId> idsFromAllContactReq;
+ foreach( QContact contact, contacts)
+ {
+ idsFromAllContactReq << contact.localId();
+ }
+}
+
+QTEST_MAIN(ut_qtcontacts_trackerplugin)