FCL/sf/mw/qtextensions: comparison qtmobility/plugins/contacts/symbian/tsrc/ut_symbian/ut

equal deleted inserted replaced

-:2b40d63a9c3d
+:90517678cc4f
 void TestSymbianEngine::initTestCase()
 {
 QContactManager::Error error;
 QMap<QString, QString> emptyParameters;
-m_engine = new CntSymbianEngine(emptyParameters, error);
+m_engine = new CntSymbianEngine(emptyParameters, &error);
 if (error == QContactManager::NoError)
 removeAllContacts();
 else
 QSKIP("Error creating manager", SkipAll);
 }
 void TestSymbianEngine::removeAllContacts()
 {
 if(m_engine) {
 // Empty cnt database
-QContactManager::Error err;
+QContactManager::Error err(QContactManager::NoError);
 QList<QContactSortOrder> sortOrders;
-QList<QContactLocalId> cnts_ids = m_engine->contactIds(sortOrders, err);
+QContactFilter defaultFilter = QContactFilter();
+QList<QContactLocalId> cnts_ids = m_engine->contactIds(defaultFilter, sortOrders, &err);
 QVERIFY(err == QContactManager::NoError);
 for(int i=0; i<cnts_ids.count(); i++) {
-QVERIFY(m_engine->removeContact(cnts_ids[i], err));
+QVERIFY(m_engine->removeContact(cnts_ids[i], &err));
 }
 }
 }
 void TestSymbianEngine::ctors()
 QContactManager::Error error;
 QMap<QString, QString> params;
 // Ctor
 CntSymbianEngine *ce;
-ce = new CntSymbianEngine(params, error);
+ce = new CntSymbianEngine(params, &error);
 QVERIFY(ce != NULL);
 QVERIFY(error == QContactManager::NoError);
 if (error == QContactManager::NoError) {
 QVERIFY(ce->managerName() == CNT_SYMBIAN_MANAGER_NAME);
 QVERIFY(ce->m_contactFilter != 0);
 QVERIFY(ce->m_contactSorter == ce1->m_contactSorter);
 QVERIFY(ce->m_dataBase == ce1->m_dataBase);
 QVERIFY(ce->m_relationship == ce1->m_relationship);
 QVERIFY(ce->m_transformContact == ce1->m_transformContact);
-// dref
+delete ce;
-ce->deref();
 /*
 QVERIFY(ce->m_contactFilter == 0xDEDEDEDE);
 QVERIFY(ce->m_contactSorter == 0xDEDEDEDE);
 QVERIFY(ce->m_dataBase == 0xDEDEDEDE);
 QVERIFY(ce->m_relationship == 0xDEDEDEDE);
 void TestSymbianEngine::saveContact()
 {
 QContactManager::Error err;
 QList<QContactSortOrder> sortOrders;
 QContactId empty;
+QContactFilter defaultFilter = QContactFilter();
-int init_count = m_engine->contactIds(sortOrders, err).count();
+int init_count = m_engine->contactIds(defaultFilter, sortOrders, &err).count();
 QVERIFY(err == QContactManager::NoError);
 // Save a "NULL" contact
-QVERIFY(!m_engine->saveContact(NULL, err));
+QVERIFY(!m_engine->saveContact(NULL, &err));
 QVERIFY(err == QContactManager::BadArgumentError);
-int current_count = m_engine->contactIds(sortOrders, err).count();
+int current_count = m_engine->contactIds(defaultFilter, sortOrders, &err).count();
 QVERIFY(err == QContactManager::NoError);
 QVERIFY(init_count == current_count);
 // Save a contact that is not in database
 QContact invaId;
-QVERIFY(m_engine->saveContact(&invaId, err));   // Add to db
+QVERIFY(m_engine->saveContact(&invaId, &err));   // Add to db
 QVERIFY(err == QContactManager::NoError);
 QContactId cId = invaId.id();
-m_engine->removeContact(invaId.localId(), err);   // Ensure not in db
+m_engine->removeContact(invaId.localId(), &err);   // Ensure not in db
 QVERIFY(err == QContactManager::NoError);
 invaId.setId(cId);
-QVERIFY(!m_engine->saveContact(&invaId, err));   // Update non existent contact
+QVERIFY(!m_engine->saveContact(&invaId, &err));   // Update non existent contact
 QVERIFY(err == QContactManager::DoesNotExistError);
-current_count = m_engine->contactIds(sortOrders, err).count();
+current_count = m_engine->contactIds(defaultFilter, sortOrders, &err).count();
 QVERIFY(err == QContactManager::NoError);
 QVERIFY(init_count == current_count);
 QContact alice;
 alice.setType("Jargon");
 // Save a "non contact(Jargon) type" contact
-QVERIFY(!m_engine->saveContact(&alice, err));
+QVERIFY(!m_engine->saveContact(&alice, &err));
 QVERIFY(err == QContactManager::InvalidDetailError);
 QVERIFY(alice.id() == empty);
 QVERIFY(alice.localId() == 0);
-current_count = m_engine->contactIds(sortOrders, err).count();
+current_count = m_engine->contactIds(defaultFilter, sortOrders, &err).count();
 QVERIFY(err == QContactManager::NoError);
 QVERIFY(init_count == current_count);
 // Save a valid contact
 alice.setType(QContactType::TypeContact);
-QVERIFY(m_engine->saveContact(&alice, err));
+QVERIFY(m_engine->saveContact(&alice, &err));
 QVERIFY(err == QContactManager::NoError);
 QVERIFY(alice.id() != empty);
 QVERIFY(alice.localId() != 0);
 QString uri = QString(QLatin1String(CNT_SYMBIAN_MANAGER_NAME));
 QVERIFY(alice.id().managerUri().contains(uri, Qt::CaseInsensitive));
-current_count = m_engine->contactIds(sortOrders, err).count();
+current_count = m_engine->contactIds(defaultFilter, sortOrders, &err).count();
 QVERIFY(err == QContactManager::NoError);
 QVERIFY(init_count + 1 == current_count);
 // Save a valid contact
 QContact g;
 g.setType(QContactType::TypeGroup);
 QContactName en;
 en.setCustomLabel("ccc");
 QVERIFY(g.saveDetail(&en));
-QVERIFY(m_engine->saveContact(&g, err));
+QVERIFY(m_engine->saveContact(&g, &err));
 QVERIFY(err == QContactManager::NoError);
 QVERIFY(g.id() != empty);
 QVERIFY(g.localId() != 0);
 QVERIFY(g.id().managerUri().contains(uri, Qt::CaseInsensitive));
 }
 QContactEmailAddress email;
 email.setEmailAddress("dummyemail");
 c.saveDetail(&email);
 c.setPreferredDetail("email", email);
-QVERIFY(m_engine->saveContact(&c, err));
+QVERIFY(m_engine->saveContact(&c, &err));
 QVERIFY(err == QContactManager::NoError);
 //fetch the saved contact and check preferred details
-QContact fetched = m_engine->contact(c.localId(), QStringList(), err);
+QContactFetchHint hint = QContactFetchHint();
+QContact fetched = m_engine->contact(c.localId(), hint, &err);
 QVERIFY(err == QContactManager::NoError);
 QContactDetail callDetail1 = fetched.preferredDetail("call");
 QVERIFY(callDetail1.definitionName() == QContactPhoneNumber::DefinitionName);
 QContactPhoneNumber fetchedNumber1 = static_cast<QContactPhoneNumber>(callDetail1);
 c2.saveDetail(&number1);
 c2.setPreferredDetail("call", number1);
 c2.setPreferredDetail("videocall", number1);
 c2.setPreferredDetail("message", number1);
-QVERIFY(m_engine->saveContact(&c2, err));
+QVERIFY(m_engine->saveContact(&c2, &err));
 QVERIFY(err == QContactManager::NoError);
 //fetch the saved contact and check preferred details
-QContact fetched2 = m_engine->contact(c2.localId(), QStringList(), err);
+QContact fetched2 = m_engine->contact(c2.localId(), hint, &err);
 QVERIFY(err == QContactManager::NoError);
 QContactDetail callDetail4 = fetched2.preferredDetail("call");
 QVERIFY(callDetail4.definitionName() == QContactPhoneNumber::DefinitionName);
 QContactPhoneNumber fetchedNumber4 = static_cast<QContactPhoneNumber>(callDetail4);
 }
 void TestSymbianEngine::saveContacts()
 {
 QContactManager::Error err;
+QContactFilter defaultFilter = QContactFilter();
 QList<QContactSortOrder> sortOrders;
 QList<QContact> contacts;
 QContactId empty;
 int count = 5;
-int init_count = m_engine->contactIds(sortOrders, err).count();
+int init_count = m_engine->contactIds(defaultFilter, sortOrders, &err).count();
 QVERIFY(err == QContactManager::NoError);
 // NULL
 QMap<int, QContactManager::Error> errorMap;
-QVERIFY(!m_engine->saveContacts(NULL, &errorMap, err));
+QVERIFY(!m_engine->saveContacts(NULL, &errorMap, &err));
 QVERIFY(errorMap.count() == 0);
 QVERIFY(err == QContactManager::BadArgumentError);
-int current_count = m_engine->contactIds(sortOrders, err).count();
+int current_count = m_engine->contactIds(defaultFilter, sortOrders, &err).count();
 QVERIFY(err == QContactManager::NoError);
 QVERIFY(init_count == current_count);
 // Save a "non contact(Jargon) type" contacts
 for(int i=0; i<count; i++) {
 QContact alice;
 alice.setType("Jargon");
 contacts.append(alice);
 }
-QVERIFY(!m_engine->saveContacts(&contacts, &errorMap, err));
+QVERIFY(!m_engine->saveContacts(&contacts, &errorMap, &err));
 QVERIFY(err == QContactManager::InvalidDetailError);
 foreach(QContactManager::Error err, errorMap) {
 QVERIFY(err == QContactManager::InvalidDetailError);
 }
-foreach(QContact c, contacts) {
+foreach(const QContact& c, contacts) {
 QVERIFY(c.id() == empty);
 QVERIFY(c.localId() == 0);
 }
-current_count = m_engine->contactIds(sortOrders, err).count();
+current_count = m_engine->contactIds(defaultFilter, sortOrders, &err).count();
 QVERIFY(err == QContactManager::NoError);
 QVERIFY(init_count == current_count);
 contacts.clear();
 // Save valid contacts
 for(int i=0; i<count; i++) {
 QContact alice;
 alice.setType(QContactType::TypeContact);
 contacts.append(alice);
 }
-QVERIFY(m_engine->saveContacts(&contacts, &errorMap, err));
+QVERIFY(m_engine->saveContacts(&contacts, &errorMap, &err));
 QVERIFY(err == QContactManager::NoError);
 foreach(QContactManager::Error err, errorMap) {
 QVERIFY(err == QContactManager::NoError);
 }
 QString uri = QString(QLatin1String(CNT_SYMBIAN_MANAGER_NAME));
-foreach(QContact c, contacts) {
+foreach(const QContact& c, contacts) {
 QVERIFY(c.id() != empty);
 QVERIFY(c.localId() != 0);
 QVERIFY(c.id().managerUri().contains(uri, Qt::CaseInsensitive));
 }
-current_count = m_engine->contactIds(sortOrders, err).count();
+current_count = m_engine->contactIds(defaultFilter, sortOrders, &err).count();
 QVERIFY(err == QContactManager::NoError);
 QVERIFY(init_count + count == current_count);
 contacts.clear();
 // Save with one invalid contact in list
-init_count = m_engine->contactIds(sortOrders, err).count();
+init_count = m_engine->contactIds(defaultFilter, sortOrders, &err).count();
 for(int i=0; i<count; i++) {
 QContact alice;
 alice.setType(QContactType::TypeContact);
 contacts.append(alice);
 }
 QContact invalid;
 invalid.setType("Jasdfasd");
 contacts.insert(3, invalid);
-QVERIFY(!m_engine->saveContacts(&contacts, &errorMap, err));
+QVERIFY(!m_engine->saveContacts(&contacts, &errorMap, &err));
 QVERIFY(err == QContactManager::InvalidDetailError);
 foreach(QContactManager::Error err, errorMap) {
 QVERIFY(err == QContactManager::InvalidDetailError);
 }
 QVERIFY(c.id() != empty);
 QVERIFY(c.localId() != 0);
 QVERIFY(c.id().managerUri().contains(uri, Qt::CaseInsensitive));
 }
 }
-current_count = m_engine->contactIds(sortOrders, err).count();
+current_count = m_engine->contactIds(defaultFilter, sortOrders, &err).count();
 QVERIFY(err == QContactManager::NoError);
 QVERIFY(init_count + count == current_count);
 contacts.clear();
 }
 void TestSymbianEngine::retrieveContact()
 {
 QContactManager::Error err;
+QContactFetchHint hint = QContactFetchHint();
 QContact alice;
 alice.setType(QContactType::TypeContact);
-QVERIFY(m_engine->saveContact(&alice, err));
+QVERIFY(m_engine->saveContact(&alice, &err));
 QVERIFY(err == QContactManager::NoError);
 // Retrieve "non contact"
-QContact c = m_engine->contact(0, QStringList(), err);
+QContact c = m_engine->contact(0, hint, &err);
 QVERIFY(&c != NULL);
 QVERIFY(c.localId() == 0);
 QVERIFY(err == QContactManager::DoesNotExistError);
 // Retrieve valid existing contact
 QContactLocalId aid = alice.localId();
-c = m_engine->contact(aid, QStringList(), err);
+c = m_engine->contact(aid, hint, &err);
 QVERIFY(&c != NULL);
 QVERIFY(c.localId() == aid);
 QVERIFY(err == QContactManager::NoError);
 }
 void TestSymbianEngine::retrieveContacts()
 {
 QContactManager::Error err;
 QContactFilter f;
+QContactFilter defaultFilter = QContactFilter();
+QContactFetchHint hint = QContactFetchHint();
 QList<QContactSortOrder> s;
 QList<QContactLocalId> cnt_ids;
 QContact c;
 c.setType(QContactType::TypeContact);
 QContactPhoneNumber number;
 number.setContexts("Home");
 number.setSubTypes("Mobile");
 number.setNumber("12345678");
 QVERIFY(c.saveDetail(&number));
-QVERIFY(m_engine->saveContact(&c, err));
+QVERIFY(m_engine->saveContact(&c, &err));
 QVERIFY(err == QContactManager::NoError);
 QContact d;
 d.setType(QContactType::TypeContact);
 QContactName dn;
 dn.setFirstName("bbb");
 QVERIFY(d.saveDetail(&dn));
-QVERIFY(m_engine->saveContact(&d, err));
+QVERIFY(m_engine->saveContact(&d, &err));
 QVERIFY(err == QContactManager::NoError);
 QContact e;
 e.setType(QContactType::TypeGroup);
 QContactName en;
 en.setCustomLabel("ccc");
 QVERIFY(e.saveDetail(&en));
-QVERIFY(m_engine->saveContact(&e, err));
+QVERIFY(m_engine->saveContact(&e, &err));
 QVERIFY(err == QContactManager::NoError);
 // Retrieve all contacts
-cnt_ids = m_engine->contactIds(f, s, err);
+cnt_ids = m_engine->contactIds(f, s, &err);
 QVERIFY(err == QContactManager::NoError);
+QVERIFY(cnt_ids.count() > 0);
 QContactDetailFilter mobileFilter;
 mobileFilter.setDetailDefinitionName(QContactPhoneNumber::DefinitionName, QContactPhoneNumber::FieldSubTypes);
 mobileFilter.setValue(QLatin1String(QContactPhoneNumber::SubTypeMobile));
 // Retrieve contacts with mobile number
-cnt_ids = m_engine->contactIds(mobileFilter, s, err);
+cnt_ids = m_engine->contactIds(mobileFilter, s, &err);
 QVERIFY(err == QContactManager::NoError);
+QVERIFY(cnt_ids.count() > 0);
+// Slow filter
+QList<QContactLocalId> fast_ids = m_engine->contactIds(mobileFilter, s, &err);
+QList<QContactLocalId> all_ids = m_engine->contactIds(f, s, &err);
+QList<QContactLocalId> slow_ids = m_engine->slowFilter(mobileFilter, all_ids, &err);
+QVERIFY(err == QContactManager::NoError);
+QVERIFY(slow_ids.count() == fast_ids.count());
 QContactDetailFilter invalidFilter;
 mobileFilter.setDetailDefinitionName("asfdasdf", "asdfasdf");
 // Retrieve contacts with invalid filter
-cnt_ids = m_engine->contactIds(invalidFilter, s, err);
+cnt_ids = m_engine->contactIds(invalidFilter, s, &err);
 QVERIFY(err == QContactManager::NotSupportedError);
 // Retrieve sorted contacts
 QContactSortOrder sortOrder;
 QList<QContactSortOrder> s1;
-sortOrder.setDetailDefinitionName(QContactName::DefinitionName,  QContactName::FieldFirst);
+sortOrder.setDetailDefinitionName(QContactName::DefinitionName,  QContactName::FieldFirstName);
 sortOrder.setBlankPolicy(QContactSortOrder::BlanksLast);
 sortOrder.setDirection(Qt::AscendingOrder);
 sortOrder.setCaseSensitivity(Qt::CaseInsensitive);
 s1.append(sortOrder);
-cnt_ids = m_engine->contactIds(s1, err);
+cnt_ids = m_engine->contactIds(defaultFilter, s1, &err);
 QVERIFY(err == QContactManager::NoError);
 // Retrieve with invalid sort order
 QContactSortOrder sortOrder1;
 QList<QContactSortOrder> s2;
 sortOrder1.setDetailDefinitionName("asdfasdf", "asdfasd");
-cnt_ids = m_engine->contactIds(s2, err);
+cnt_ids = m_engine->contactIds(defaultFilter, s2, &err);
+QVERIFY(err == QContactManager::NoError);
+// Retrieve full contacts (with all details)
+QList<QContact> contactList;
+QList<QContactSortOrder> sortOrders;
+QStringList definitionRestrictions;
+contactList = m_engine->contacts(defaultFilter, sortOrders, hint, &err);
+QVERIFY(err == QContactManager::NoError);
+QContactFilter filter;
+contactList = m_engine->contacts(filter, sortOrders, hint, &err);
 QVERIFY(err == QContactManager::NoError);
 }
 void TestSymbianEngine::updateContact()
 {
 QContactManager::Error err;
+QContactFetchHint hint = QContactFetchHint();
 QContact c;
-QVERIFY(m_engine->saveContact(&c, err));
+QVERIFY(m_engine->saveContact(&c, &err));
 QVERIFY(err == QContactManager::NoError);
 int details_before = c.details().count();
 QContactName aliceName;
 number.setNumber("12345678");
 c.saveDetail(&number);
 // update the contact
 QContactLocalId id = c.localId();
-QVERIFY(m_engine->saveContact(&c, err));
+QVERIFY(m_engine->saveContact(&c, &err));
 QVERIFY(err == QContactManager::NoError);
 // Verify that contact has been updated
-QContact d = m_engine->contact(id, QStringList(), err);
+QContact d = m_engine->contact(id, hint, &err);
 QVERIFY(err == QContactManager::NoError);
 QVERIFY(d.localId() == id);
 QVERIFY(d.details().count() > details_before);
 QString str = d.detail(QContactPhoneNumber::DefinitionName).definitionName();
 QVERIFY(str == QContactPhoneNumber::DefinitionName);
 void TestSymbianEngine::updateContactByUid()
 {
 QContactManager::Error err;
 QContact c;
-QVERIFY(m_engine->saveContact(&c, err));
+QVERIFY(m_engine->saveContact(&c, &err));
 QVERIFY(err == QContactManager::NoError);
 QContactLocalId initialId = c.localId();
 QContactGuid guidDetail = static_cast<QContactGuid>(c.details(QContactGuid::DefinitionName).at(0));
 QString uid = guidDetail.guid();
 number.setSubTypes("Mobile");
 number.setNumber("12345678");
 c.saveDetail(&number);
 //verify that the same contact was updated
-QVERIFY(m_engine->saveContact(&c, err));
+QVERIFY(m_engine->saveContact(&c, &err));
 QContactLocalId id = c.localId();
 QVERIFY(err == QContactManager::NoError);
 QVERIFY(initialId == id);
 }
 void TestSymbianEngine::removeContact()
 {
 QContactManager::Error err;
+QContactFetchHint hint = QContactFetchHint();
 QContact c;
 c.setType(QContactType::TypeContact);
-QVERIFY(m_engine->saveContact(&c, err));
+QVERIFY(m_engine->saveContact(&c, &err));
 QVERIFY(err == QContactManager::NoError);
 // Remove existing contact
 QContactLocalId id = c.localId();
-QVERIFY(m_engine->removeContact(id, err));
+QVERIFY(m_engine->removeContact(id, &err));
 QVERIFY(err == QContactManager::NoError);
 // Verify that contact has been removed
-QContact f = m_engine->contact(id, QStringList(), err);
+QContact f = m_engine->contact(id, hint, &err);
 QVERIFY(f.localId() == 0);
 QVERIFY(err == QContactManager::DoesNotExistError);
 // Remove non existent contact
-QVERIFY(!m_engine->removeContact(0, err));
+QVERIFY(!m_engine->removeContact(0, &err));
 QVERIFY(err == QContactManager::DoesNotExistError);
 }
 void TestSymbianEngine::removeContacts()
 {
 QContactManager::Error err;
+QContactFetchHint hint = QContactFetchHint();
 QList<QContactLocalId> contacts;
 int count = 5;
 // Remove non existent contacts
 QMap<int, QContactManager::Error> errorMap;
-QVERIFY(m_engine->removeContacts(&contacts, &errorMap, err));
+QVERIFY(m_engine->removeContacts(contacts, &errorMap, &err));
 QVERIFY(err == QContactManager::NoError);
 QVERIFY(errorMap.count() == 0);
-// NULL argument
-QVERIFY(!m_engine->removeContacts(NULL, &errorMap, err));
-QVERIFY(errorMap.count() == 0);
-QVERIFY(err == QContactManager::BadArgumentError);
 // Remove existing contacts
 for(int i=0; i<count; i++) {
 QContact c;
 c.setType(QContactType::TypeContact);
-QVERIFY(m_engine->saveContact(&c, err));
+QVERIFY(m_engine->saveContact(&c, &err));
 QVERIFY(err == QContactManager::NoError);
 contacts.append(c.localId());
 }
-QVERIFY(m_engine->removeContacts(&contacts, &errorMap, err));
+QVERIFY(m_engine->removeContacts(contacts, &errorMap, &err));
 QVERIFY(err == QContactManager::NoError);
 foreach(QContactManager::Error e, errorMap) {
 QVERIFY(e == QContactManager::NoError);
 }
 // Verify that contacts have been removed
 for(int i=0; i<contacts.count(); i++) {
-QContact f = m_engine->contact(contacts[i], QStringList(), err);
+QContact f = m_engine->contact(contacts[i], hint, &err);
 QVERIFY(f.localId() == 0);
 QVERIFY(err == QContactManager::DoesNotExistError);
 }
 // Remove a list with one non existent contact
 contacts.clear();
 for(int i=0; i<count; i++) {
 QContact c;
 c.setType(QContactType::TypeContact);
-QVERIFY(m_engine->saveContact(&c, err));
+QVERIFY(m_engine->saveContact(&c, &err));
 QVERIFY(err == QContactManager::NoError);
 contacts.append(c.localId());
 }
 contacts.insert(3, 0);
-QVERIFY(!m_engine->removeContacts(&contacts, &errorMap, err));
+QVERIFY(!m_engine->removeContacts(contacts, &errorMap, &err));
 QVERIFY(err == QContactManager::DoesNotExistError);
 foreach(QContactManager::Error e, errorMap) {
 QVERIFY(e == QContactManager::DoesNotExistError);
 }
 for(int i=0; i<contacts.count(); i++) {
-QContact f = m_engine->contact(contacts[i], QStringList(), err);
+QContact f = m_engine->contact(contacts[i], hint, &err);
 QVERIFY(f.localId() == 0);
 QVERIFY(err == QContactManager::DoesNotExistError);
 }
 }
 // Create a new contact own card
 QContact own;
 QContactName ownName;
 ownName.setFirstName("Own");
 own.saveDetail(&ownName);
-QVERIFY(m_engine->saveContact(&own, err));
+QVERIFY(m_engine->saveContact(&own, &err));
 QVERIFY(err == QContactManager::NoError);
 // Set a non existent contact as own card and verify
 // ensure this contact does not exist in dbase
 QContactLocalId id(12);
-m_engine->removeContact(id, err);   // Dont test err. May or may not be in dbase
+m_engine->removeContact(id, &err);   // Don't test err. May or may not be in dbase
-QVERIFY(!m_engine->setSelfContactId(id, err)); // does not exist
+QVERIFY(!m_engine->setSelfContactId(id, &err)); // does not exist
 QVERIFY(err == QContactManager::DoesNotExistError);
 // Test a "0" contact id
-QVERIFY(!m_engine->setSelfContactId(0, err)); // Bad argument
+QVERIFY(!m_engine->setSelfContactId(0, &err)); // Bad argument
 QVERIFY(err == QContactManager::BadArgumentError);
 // Set an existent contact as own card
-QVERIFY(m_engine->setSelfContactId(own.localId(), err));
+QVERIFY(m_engine->setSelfContactId(own.localId(), &err));
 QVERIFY(err == QContactManager::NoError);
 }
 void TestSymbianEngine::retrieveOwnCard()
 {
 // Create a new contact own card
 QContact own;
 QContactName ownName;
 ownName.setFirstName("Own");
 own.saveDetail(&ownName);
-QVERIFY(m_engine->saveContact(&own, err));
+QVERIFY(m_engine->saveContact(&own, &err));
 QVERIFY(err == QContactManager::NoError);
-QVERIFY(m_engine->setSelfContactId(own.localId(), err));
+QVERIFY(m_engine->setSelfContactId(own.localId(), &err));
 QVERIFY(err == QContactManager::NoError);
 // Fetch existing self contact
-QContactLocalId own_id = m_engine->selfContactId(err);
+QContactLocalId own_id = m_engine->selfContactId(&err);
 QVERIFY(err == QContactManager::NoError);
 QVERIFY(own_id == own.localId());
 // Remove self contact and verify
-QVERIFY(m_engine->removeContact(own.localId(), err));
+QVERIFY(m_engine->removeContact(own.localId(), &err));
-QContactLocalId idr = m_engine->selfContactId(err);
+QContactLocalId idr = m_engine->selfContactId(&err);
 QVERIFY(err == QContactManager::DoesNotExistError);
 QVERIFY(idr == 0);
 }
 void TestSymbianEngine::filterSupport()
 // Add valid group contact
 QContact g;
 g.setType(QContactType::TypeGroup);
-QVERIFY(m_engine->saveContact(&g, err));
+QVERIFY(m_engine->saveContact(&g, &err));
 QVERIFY(err == QContactManager::NoError);
 QVERIFY(g.id() != empty);
 QVERIFY(g.localId() != 0);
 QString uri = QString(QLatin1String(CNT_SYMBIAN_MANAGER_NAME));
 QVERIFY(g.id().managerUri().contains(uri, Qt::CaseInsensitive));
 // Add invalid group contact
 QContact g1;
 g1.setType("Jargon");
-QVERIFY(!m_engine->saveContact(&g1, err));
+QVERIFY(!m_engine->saveContact(&g1, &err));
 QVERIFY(err == QContactManager::InvalidDetailError);
 QVERIFY(g1.id() == empty);
 QVERIFY(g1.localId() == 0);
 }
 // retrieve group contacts
 QContactDetailFilter filter;
 filter.setDetailDefinitionName(QContactType::DefinitionName, QContactType::FieldType);
 filter.setValue(QString(QLatin1String(QContactType::TypeGroup)));
-QList<QContactLocalId> grp_ids = m_engine->contactIds(filter, s, err);
+QList<QContactLocalId> grp_ids = m_engine->contactIds(filter, s, &err);
 QVERIFY(err == QContactManager::NoError);
 QVERIFY(err == QContactManager::NoError);
 QContact g;
 g.setType(QContactType::TypeGroup);
-QVERIFY(m_engine->saveContact(&g, err));
+QVERIFY(m_engine->saveContact(&g, &err));
 QVERIFY(err == QContactManager::NoError);
-QList<QContactLocalId> grp_ids1 = m_engine->contactIds(filter, s, err);
+QList<QContactLocalId> grp_ids1 = m_engine->contactIds(filter, s, &err);
 QVERIFY(err == QContactManager::NoError);
 QVERIFY(grp_ids.count() + 1 == grp_ids1.count());
 }
 // More relationships logic is tested in relationship unit tests.
 // We do simple tests here
 QContactManager::Error error;
 QContact a;
-QVERIFY(m_engine->saveContact(&a, error));
+QVERIFY(m_engine->saveContact(&a, &error));
 QContact b;
-QVERIFY(m_engine->saveContact(&b, error));
+QVERIFY(m_engine->saveContact(&b, &error));
 QContactRelationship rel;
 rel.setFirst(a.id());
 rel.setSecond(b.id());
 rel.setRelationshipType(QContactRelationship::HasSpouse);
 // Add relationship
-m_engine->saveRelationship(&rel, error);
+m_engine->saveRelationship(&rel, &error);
 bool isValid(false);
 if (error == QContactManager::NoError ||
 error == QContactManager::NotSupportedError)
 isValid = true;
 QVERIFY(isValid);
 // Remove relationship
-m_engine->removeRelationship(rel, error);
+m_engine->removeRelationship(rel, &error);
 if (error == QContactManager::NoError ||
 error == QContactManager::NotSupportedError)
 isValid = true;
 else
 isValid = false;
 QVERIFY(isValid);
-QStringList supportedRelationships =
+// TODO: replacement?
+/*QStringList supportedRelationships =
 m_engine->supportedRelationshipTypes(QContactType::TypeGroup);
 QVERIFY(supportedRelationships.contains(QContactRelationship::HasMember));
+*/
 }
 void TestSymbianEngine::batchRelationships()
 {
 // More relationships logic is tested somewhere else.
 // We do simple tests here
 QContactManager::Error error;
 QContact a;
-QVERIFY(m_engine->saveContact(&a, error));
+QVERIFY(m_engine->saveContact(&a, &error));
 QContact b;
-QVERIFY(m_engine->saveContact(&b, error));
+QVERIFY(m_engine->saveContact(&b, &error));
 QContactRelationship rel;
 rel.setFirst(a.id());
 rel.setSecond(b.id());
 rel.setRelationshipType(QContactRelationship::HasSpouse);
 QList<QContactRelationship> list;
 list.append(rel);
 bool isValid(false);
 // Add relationships
-QList<QContactManager::Error> errors = m_engine->saveRelationships(&list, error);
+QMap<int, QContactManager::Error> errorMap;
-QVERIFY(&errors != NULL);
+QVERIFY(m_engine->saveRelationships(&list, &errorMap, &error));
-foreach(QContactManager::Error err, errors) {
+foreach(QContactManager::Error err, errorMap) {
 if (err == QContactManager::NoError ||
 err == QContactManager::NotSupportedError)
 isValid = true;
 else
 isValid = false;
 QVERIFY(isValid);
 }
 // fetch relationships
-QContactRelationshipFilter::Role role;
+QContactRelationship::Role role;
-role = QContactRelationshipFilter::First;
+role = QContactRelationship::First;
 list.clear();
-list = m_engine->relationships(QContactRelationship::HasSpouse, a.id(), role, error);
+list = m_engine->relationships(QContactRelationship::HasSpouse, a.id(), role, &error);
 QVERIFY(&list != NULL);
 if (error == QContactManager::NoError ||
 error == QContactManager::NotSupportedError)
 isValid = true;
 else
 isValid = false;
 QVERIFY(isValid);
 // Remove relationships
-errors = m_engine->removeRelationships(list, error);
+QVERIFY(m_engine->removeRelationships(list, &errorMap, &error));
-QVERIFY(&errors != NULL);
+foreach(QContactManager::Error err, errorMap) {
-foreach(QContactManager::Error err, errors) {
 if (err == QContactManager::NoError ||
 err == QContactManager::NotSupportedError)
 isValid = true;
 else
 isValid = false;
 void TestSymbianEngine::synthesizeDisplaylable()
 {
 QContactManager::Error err = QContactManager::NoError;
 QContact empty;
-QString label = m_engine->synthesizedDisplayLabel(empty, err);
+QString label = m_engine->synthesizedDisplayLabel(empty, &err);
 QVERIFY(err == QContactManager::NoError);
 QVERIFY(label == QString("Unnamed"));
 QContact first;
 QContactName fn;
 fn.setFirstName("Alice");
 first.saveDetail(&fn);
-label = m_engine->synthesizedDisplayLabel(first, err);
+label = m_engine->synthesizedDisplayLabel(first, &err);
 QVERIFY(err == QContactManager::NoError);
 QVERIFY(label == QString("Alice"));
 QContact last;
 QContactName ln;
 ln.setLastName("Jones");
 last.saveDetail(&ln);
-label = m_engine->synthesizedDisplayLabel(last, err);
+label = m_engine->synthesizedDisplayLabel(last, &err);
 QVERIFY(err == QContactManager::NoError);
 QVERIFY(label == QString("Jones"));
 QContact orgContact;
 QContactOrganization org;
 org.setName("Nokia");
 org.setDepartment(QStringList("Services"));
 org.setTitle("Assistant Manager");
 org.setLocation("Nokia Cyber Park");
 orgContact.saveDetail(&org);
-label = m_engine->synthesizedDisplayLabel(orgContact, err);
+label = m_engine->synthesizedDisplayLabel(orgContact, &err);
 QVERIFY(err == QContactManager::NoError);
 QVERIFY(label == QString("Nokia"));
 QContact jargon;
 jargon.setType("jargon");
-label = m_engine->synthesizedDisplayLabel(jargon, err);
+label = m_engine->synthesizedDisplayLabel(jargon, &err);
 QVERIFY(err == QContactManager::InvalidContactTypeError);
 QVERIFY(label.isEmpty());
 QContact group;
 group.setType(QContactType::TypeGroup);
 QContactName gn;
 gn.setCustomLabel("grouplable");
 group.saveDetail(&gn);
-label = m_engine->synthesizedDisplayLabel(group, err);
+label = m_engine->synthesizedDisplayLabel(group, &err);
 QVERIFY(err == QContactManager::NoError);
 QVERIFY(label == QString("grouplable"));
 }
 void TestSymbianEngine::definitionDetails()
 {
 QMap<QString, QContactDetailDefinition> defs;
 QContactManager::Error err;
 // Wrong contact type
-defs = m_engine->detailDefinitions("aerafa", err);
+defs = m_engine->detailDefinitions("aerafa", &err);
 QVERIFY(err = QContactManager::InvalidContactTypeError);
 QVERIFY(defs.count() == 0);
 // Valid defs
-defs = m_engine->detailDefinitions(QContactType::TypeContact, err);
+defs = m_engine->detailDefinitions(QContactType::TypeContact, &err);
 QVERIFY(err == QContactManager::NoError);
-defs = m_engine->detailDefinitions(QContactType::TypeGroup, err);
+defs = m_engine->detailDefinitions(QContactType::TypeGroup, &err);
 QVERIFY(err == QContactManager::NoError);
 }
+void TestSymbianEngine::asyncRequests()
+{
+//create a contact
+QContactManager::Error err;
+QContact dummy;
+dummy.setType(QContactType::TypeContact);
+QContactName name;
+name.setFirstName("dummy");
+dummy.saveDetail(&name);
+QVERIFY(m_engine->saveContact(&dummy, &err));
+QVERIFY(err == QContactManager::NoError);
+//create a group with members
+QContact groupContact;
+groupContact.setType(QContactType::TypeGroup);
+m_engine->saveContact(&groupContact, &err);
+QVERIFY(err == QContactManager::NoError);
+QContactRelationship relationship;
+relationship.setRelationshipType(QContactRelationship::HasMember);
+relationship.setFirst(groupContact.id());
+relationship.setSecond(dummy.id());
+bool returnValue(false);
+returnValue = m_engine->saveRelationship(&relationship, &err);
+QVERIFY(returnValue == true);
+QVERIFY(err == QContactManager::NoError);
+//fetch request
+QContactFetchRequest fetch;
+QVERIFY(m_engine->startRequest(&fetch));
+QTest::qWait(1000); //1sec
+QVERIFY(fetch.error() == QContactManager::NoError);
+QVERIFY(fetch.state() == QContactFetchRequest::FinishedState);
+QVERIFY(fetch.contacts().count() > 0);
+//fetch ids request
+QContactLocalIdFetchRequest fetchIds;
+QVERIFY(m_engine->startRequest(&fetchIds));
+QTest::qWait(1000); //1sec
+QVERIFY(fetchIds.error() == QContactManager::NoError);
+QVERIFY(fetchIds.state() == QContactFetchRequest::FinishedState);
+QVERIFY(fetchIds.ids().count() > 0);
+//save request
+QContactSaveRequest saveReq;
+QContact c;
+c.setType(QContactType::TypeContact);
+QList<QContact> contactList;
+contactList += c;
+saveReq.setContacts(contactList);
+QVERIFY(m_engine->startRequest(&saveReq));
+QTest::qWait(1000); //1sec
+QVERIFY(saveReq.error() == QContactManager::NoError);
+QVERIFY(saveReq.state() == QContactFetchRequest::FinishedState);
+QVERIFY(saveReq.contacts().count() > 0);
+//remove request
+QContactRemoveRequest removeReq;
+QList<QContactLocalId> idList;
+idList += saveReq.contacts().at(0).localId();
+removeReq.setContactIds(idList);
+QVERIFY(m_engine->startRequest(&removeReq));
+QTest::qWait(1000); //1sec
+int err_temp = removeReq.error();
+QVERIFY(removeReq.error() == QContactManager::NoError);
+QVERIFY(removeReq.state() == QContactFetchRequest::FinishedState);
+//detail definition request
+QContactDetailDefinitionFetchRequest detDefReq;
+detDefReq.setContactType(QContactType::TypeContact);
+QStringList defList;
+defList += QContactName::DefinitionName;
+detDefReq.setDefinitionNames(defList);
+QVERIFY(m_engine->startRequest(&detDefReq));
+QTest::qWait(1000); //1sec
+QVERIFY(detDefReq.error() == QContactManager::NoError);
+QVERIFY(detDefReq.state() == QContactFetchRequest::FinishedState);
+//relationship fetch request
+QContactRelationshipFetchRequest relFetchReq;
+relFetchReq.setFirst(groupContact.id());
+relFetchReq.setSecond(dummy.id());
+relFetchReq.setRelationshipType(QContactRelationship::HasMember);
+QVERIFY(m_engine->startRequest(&relFetchReq));
+QTest::qWait(1000); //1sec
+QVERIFY(relFetchReq.error() == QContactManager::NoError);
+QVERIFY(relFetchReq.state() == QContactFetchRequest::FinishedState);
+QVERIFY(relFetchReq.relationships().count() > 0);
+//relationship remove request
+QContactRelationshipRemoveRequest relRemoveReq;
+QList<QContactRelationship> relList;
+relList += relationship;
+relRemoveReq.setRelationships(relList);
+QVERIFY(m_engine->startRequest(&relRemoveReq));
+QTest::qWait(1000); //1sec
+QVERIFY(relRemoveReq.error() == QContactManager::NoError);
+QVERIFY(relRemoveReq.state() == QContactFetchRequest::FinishedState);
+//relationship save request
+QContactRelationshipSaveRequest relSaveReq;
+relSaveReq.setRelationships(relList);
+QVERIFY(m_engine->startRequest(&relSaveReq));
+QTest::qWait(1000); //1sec
+QVERIFY(relSaveReq.error() == QContactManager::NoError);
+QVERIFY(relSaveReq.state() == QContactFetchRequest::FinishedState);
+//cancel request
+QVERIFY(m_engine->startRequest(&relRemoveReq));
+m_engine->cancelRequest(&relRemoveReq);
+QTest::qWait(1000); //1sec
+QVERIFY(relRemoveReq.error() == QContactManager::NoError);
+QVERIFY(relRemoveReq.state() == QContactFetchRequest::CanceledState);
+//wait for a request finish
+QVERIFY(!m_engine->waitForRequestFinished(&relSaveReq, 1000));
+QVERIFY(m_engine->startRequest(&relRemoveReq));
+QVERIFY(m_engine->waitForRequestFinished(&relRemoveReq, 1000));
+QTest::qWait(1000); //1sec
+QVERIFY(relRemoveReq.error() == QContactManager::NoError);
+QVERIFY(relRemoveReq.state() == QContactFetchRequest::FinishedState);
+//destroy request
+QVERIFY(m_engine->startRequest(&relRemoveReq));
+m_engine->requestDestroyed(&relRemoveReq);
+QVERIFY(!m_engine->m_asynchronousOperations.contains(&relRemoveReq));
+}

changeset 4	90517678cc4f
parent 1	2b40d63a9c3d
child 5	453da2cfceef