Mercurial Mercurial > oss > FCL > sf > mw > qtextensions / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
qtmobility/plugins/contacts/symbian/tsrc/ut_symbian/ut_cntrelationship.cpp
changeset 4 90517678cc4f
parent 1 2b40d63a9c3d
child 8 71781823f776
equal deleted inserted replaced
1:2b40d63a9c3d 4:90517678cc4f 
    71 {
 
    71 {
 
    72     qRegisterMetaType<QContactLocalId>("QContactLocalId");
 
    72     qRegisterMetaType<QContactLocalId>("QContactLocalId");
 
    73     qRegisterMetaType<QList<QContactLocalId> >("QList<QContactLocalId>");
 
    73     qRegisterMetaType<QList<QContactLocalId> >("QList<QContactLocalId>");
 
    74 
    74 
    75     //create manager
 
    75     //create manager
 
    76     m_manager = new QContactManager("symbian");
 
    76     QContactManager::Error err;
 
       
    77     m_manager = new CntSymbianEngine(QMap<QString, QString>(), &err);
 
    77 
    78 
    78     //open symbian database
 
    79     //open symbian database
 
    79     TRAPD(error, m_database = CContactDatabase::OpenL());
 
    80     TRAPD(error, m_database = CContactDatabase::OpenL());
 
    80     QVERIFY(error == KErrNone);
 
    81     QVERIFY(error == KErrNone);
 
    81 
    82 
    82     // create relationship
 
    83     // create relationship
 
    83     m_relationship = new CntRelationship(m_database, m_manager->managerUri());
 
    84     m_relationship = new CntRelationship(m_database, m_manager->m_managerUri);
 
    84 }
 
    85 }
 
    85 
    86 
    86 
    87 
    87 /*
 
    88 /*
 
    88  * Cleanup after all test
 
    89  * Cleanup after all test
 
    98  * Initialization done before each test
 
    99  * Initialization done before each test
 
    99  */
 
   100  */
 
   100 void TestCntRelationship::init()
 
   101 void TestCntRelationship::init()
 
   101 {
 
   102 {
 
   102     //delete all contacts from the database
 
   103     //delete all contacts from the database
 
   103     QList<QContactLocalId> contacts = m_manager->contactIds();
 
   104     QContactManager::Error err;
 
   104     m_manager->removeContacts(&contacts);
 
   105     QList<QContactLocalId> contacts = m_manager->contactIds(QContactFilter(), QList<QContactSortOrder>(), &err);
 
       
   106     
       
   107     QMap<int, QContactManager::Error> errorMap;
 
       
   108     m_manager->removeContacts(contacts, &errorMap, &err);
 
   105 }
 
   109 }
 
   106 
   110 
   107 void TestCntRelationship::cleanup()
 
   111 void TestCntRelationship::cleanup()
 
   108 {}
 
   112 {}
 
   109 
   113 
   121     bool returnValue(false);
 
   125     bool returnValue(false);
 
   122 
   126 
   123     //save & remove relationships
 
   127     //save & remove relationships
 
   124     QList<QContactRelationship> relationships;
 
   128     QList<QContactRelationship> relationships;
 
   125     relationships.append(relationship);
 
   129     relationships.append(relationship);
 
   126     QList <QContactManager::Error> errors;
 
       
   127 
   130 
   128     //save relationship
 
   131     //save relationship
 
   129     returnValue = m_relationship->saveRelationship(&affectedContactIds, &relationship, error);
 
   132     returnValue = m_relationship->saveRelationship(&affectedContactIds, &relationship, &error);
 
   130     QVERIFY(returnValue == false);
 
   133     QVERIFY(returnValue == false);
 
   131     QVERIFY(affectedContactIds.count() == 0);
 
   134     QVERIFY(affectedContactIds.count() == 0);
 
   132     QVERIFY(error == QContactManager::NotSupportedError);
 
   135     QVERIFY(error == QContactManager::NotSupportedError);
 
   133 
   136 
   134     //remove relationship
 
   137     //remove relationship
 
   135     returnValue = m_relationship->removeRelationship(&affectedContactIds, relationship, error);
 
   138     returnValue = m_relationship->removeRelationship(&affectedContactIds, relationship, &error);
 
   136     QVERIFY(returnValue == false);
 
   139     QVERIFY(returnValue == false);
 
   137     QVERIFY(affectedContactIds.count() == 0);
 
   140     QVERIFY(affectedContactIds.count() == 0);
 
   138     QVERIFY(error == QContactManager::NotSupportedError);
 
   141     QVERIFY(error == QContactManager::NotSupportedError);
 
   139 
   142 
   140     //save relationships
 
   143     //save relationships
 
   141     errors = m_relationship->saveRelationships(&affectedContactIds, &relationships, error);
 
   144     QMap<int, QContactManager::Error> errorMap;
 
   142     QVERIFY(affectedContactIds.count() == 0);
 
   145     QVERIFY(!m_relationship->saveRelationships(&affectedContactIds, &relationships, &errorMap, &error));
 
   143     for(int i = 0; i < errors.count(); i++){
 
   146     QVERIFY(affectedContactIds.count() == 0);
 
   144         QVERIFY(errors.at(i) == QContactManager::NotSupportedError);
 
   147     foreach (QContactManager::Error err, errorMap) {
 
       
   148         QVERIFY(err == QContactManager::NotSupportedError);
 
   145     }
 
   149     }
 
   146 
   150 
   147     //remove relationships
 
   151     //remove relationships
 
   148     errors = m_relationship->removeRelationships(&affectedContactIds, relationships, error);
 
   152     QVERIFY(m_relationship->removeRelationships(&affectedContactIds, relationships, &errorMap, &error));
 
   149     QVERIFY(affectedContactIds.count() == 0);
 
   153     QVERIFY(affectedContactIds.count() == 0);
 
   150     for(int i = 0; i < errors.count(); i++){
 
   154     foreach (QContactManager::Error err, errorMap) {
 
   151         QVERIFY(errors.at(i) == QContactManager::NotSupportedError);
 
   155         QVERIFY(err == QContactManager::NotSupportedError);
 
   152     }
 
   156     }
 
   153 
   157 
   154     //relationships
 
   158     //relationships
 
   155     QList<QContactRelationship> relationshipList;
 
   159     QList<QContactRelationship> relationshipList;
 
   156     QContactId id;
 
   160     QContactId id;
 
   157 
   161 
   158     relationshipList = m_relationship->relationships(QLatin1String("invalid relationship"), id, QContactRelationshipFilter::Either, error);
 
   162     relationshipList = m_relationship->relationships(QLatin1String("invalid relationship"), id, QContactRelationship::Either, &error);
 
   159     QVERIFY(relationshipList.count() == 0);
 
   163     QVERIFY(relationshipList.count() == 0);
 
   160     QVERIFY(error == QContactManager::NotSupportedError);
 
   164     QVERIFY(error == QContactManager::NotSupportedError);
 
   161 }
 
   165 }
 
   162 
   166 
   163 /*
 
   167 /*
 
   166 void TestCntRelationship::validGroupRelationship()
 
   170 void TestCntRelationship::validGroupRelationship()
 
   167 {
 
   171 {
 
   168     //create a group
 
   172     //create a group
 
   169     QContact groupContact;
 
   173     QContact groupContact;
 
   170     groupContact.setType(QContactType::TypeGroup);
 
   174     groupContact.setType(QContactType::TypeGroup);
 
   171     m_manager->saveContact(&groupContact);
 
   175     QContactManager::Error err;
 
       
   176     m_manager->saveContact(&groupContact, &err);
 
   172 
   177 
   173     //create a contact
 
   178     //create a contact
 
   174     QContact contact;
 
   179     QContact contact;
 
   175     contact.setType(QContactType::TypeContact);
 
   180     contact.setType(QContactType::TypeContact);
 
   176     m_manager->saveContact(&contact);
 
   181     m_manager->saveContact(&contact, &err);
 
   177 
   182 
   178     //create relationship
 
   183     //create relationship
 
   179     QContactRelationship relationship;
 
   184     QContactRelationship relationship;
 
   180     relationship.setRelationshipType(QContactRelationship::HasMember);
 
   185     relationship.setRelationshipType(QContactRelationship::HasMember);
 
   181     relationship.setFirst(groupContact.id());
 
   186     relationship.setFirst(groupContact.id());
 
   183 
   188 
   184     //save relationship
 
   189     //save relationship
 
   185     bool returnValue(false);
 
   190     bool returnValue(false);
 
   186     QContactManager::Error error;
 
   191     QContactManager::Error error;
 
   187     QSet<QContactLocalId> affectedContactIds;
 
   192     QSet<QContactLocalId> affectedContactIds;
 
   188     returnValue = m_relationship->saveRelationship(&affectedContactIds, &relationship, error);
 
   193     returnValue = m_relationship->saveRelationship(&affectedContactIds, &relationship, &error);
 
   189     QVERIFY2(returnValue == true, "save");
 
   194     QVERIFY2(returnValue == true, "save");
 
   190     QVERIFY2(affectedContactIds.count() == 2, "save");
 
   195     QVERIFY2(affectedContactIds.count() == 2, "save");
 
   191     QVERIFY2(affectedContactIds.toList().contains(groupContact.localId()), "save");
 
   196     QVERIFY2(affectedContactIds.toList().contains(groupContact.localId()), "save");
 
   192     QVERIFY2(affectedContactIds.toList().contains(contact.localId()), "save");
 
   197     QVERIFY2(affectedContactIds.toList().contains(contact.localId()), "save");
 
   193     QVERIFY2(error == QContactManager::NoError, "save");
 
   198     QVERIFY2(error == QContactManager::NoError, "save");
 
   194 
   199 
   195     //retrieve the relationships
 
   200     //retrieve the relationships
 
   196     QList<QContactRelationship> relationshipList;
 
   201     QList<QContactRelationship> relationshipList;
 
   197 
   202 
   198     //Retrive group
 
   203     //Retrive group
 
   199     relationshipList = m_relationship->relationships(QLatin1String(QContactRelationship::HasMember), groupContact.id(), QContactRelationshipFilter::First, error);
 
   204     relationshipList = m_relationship->relationships(QLatin1String(QContactRelationship::HasMember), groupContact.id(), QContactRelationship::First, &error);
 
       
   205 
   200     QVERIFY2(relationshipList.count() == 1, "group - First");
 
   206     QVERIFY2(relationshipList.count() == 1, "group - First");
 
   201     QVERIFY2(error == QContactManager::NoError, "group - First");
 
   207     QVERIFY2(error == QContactManager::NoError, "group - First");
 
   202 
   208 
   203     relationshipList = m_relationship->relationships(QLatin1String(QContactRelationship::HasMember), groupContact.id(), QContactRelationshipFilter::Second, error);
 
   209     relationshipList = m_relationship->relationships(QLatin1String(QContactRelationship::HasMember), groupContact.id(), QContactRelationship::Second, &error);
 
   204     QVERIFY2(relationshipList.count() == 0, "group - Second");
 
   210     QVERIFY2(relationshipList.count() == 0, "group - Second");
 
   205     QVERIFY2(error == QContactManager::NoError, "group - Second");
 
   211     QVERIFY2(error == QContactManager::DoesNotExistError, "group - Second");
 
   206 
   212 
   207     relationshipList = m_relationship->relationships(QLatin1String(QContactRelationship::HasMember), groupContact.id(), QContactRelationshipFilter::Either, error);
 
   213     relationshipList = m_relationship->relationships(QLatin1String(QContactRelationship::HasMember), groupContact.id(), QContactRelationship::Either, &error);
 
   208     QVERIFY2(relationshipList.count() == 1, "group - Either");
 
   214     QVERIFY2(relationshipList.count() == 1, "group - Either");
 
   209     QVERIFY2(error == QContactManager::NoError, "group - Either");
 
   215     QVERIFY2(error == QContactManager::NoError, "group - Either");
 
   210 
   216 
   211     //Retrive contact
 
   217     //Retrive contact
 
   212     relationshipList = m_relationship->relationships(QLatin1String(QContactRelationship::HasMember), contact.id(), QContactRelationshipFilter::First, error);
 
   218     relationshipList = m_relationship->relationships(QLatin1String(QContactRelationship::HasMember), contact.id(), QContactRelationship::First, &error);
 
   213     QVERIFY2(relationshipList.count() == 0, "contact - First");
 
   219     QVERIFY2(relationshipList.count() == 0, "contact - First");
 
   214     QVERIFY2(error == QContactManager::NoError, "contact - First");
 
   220     QVERIFY2(error == QContactManager::DoesNotExistError, "contact - First");
 
   215 
   221 
   216     relationshipList = m_relationship->relationships(QLatin1String(QContactRelationship::HasMember), contact.id(), QContactRelationshipFilter::Second, error);
 
   222     relationshipList = m_relationship->relationships(QLatin1String(QContactRelationship::HasMember), contact.id(), QContactRelationship::Second, &error);
 
   217     QVERIFY2(relationshipList.count() == 1, "contact - Second");
 
   223     QVERIFY2(relationshipList.count() == 1, "contact - Second");
 
   218     QVERIFY2(error == QContactManager::NoError, "contact - Second");
 
   224     QVERIFY2(error == QContactManager::NoError, "contact - Second");
 
   219 
   225 
   220     relationshipList = m_relationship->relationships(QLatin1String(QContactRelationship::HasMember), contact.id(), QContactRelationshipFilter::Either, error);
 
   226     relationshipList = m_relationship->relationships(QLatin1String(QContactRelationship::HasMember), contact.id(), QContactRelationship::Either, &error);
 
   221     QVERIFY2(relationshipList.count() == 1, "contact - Either");
 
   227     QVERIFY2(relationshipList.count() == 1, "contact - Either");
 
   222     QVERIFY2(error == QContactManager::NoError, "contact - Either");   
   228     QVERIFY2(error == QContactManager::NoError, "contact - Either");   
   223     
   229     
       
   230     //Relationship for empty contact -> all relationships are returned 
       
   231     relationshipList = m_relationship->relationships(QLatin1String(QContactRelationship::HasMember), QContactId(),
 
       
   232                 QContactRelationship::First, &error);
 
       
   233     QVERIFY2(relationshipList.count() == 1, "All relationships");
 
       
   234     QVERIFY2(error == QContactManager::NoError, "All relatiosnships");
 
   224     
   235     
   225     //Validate Filter
 
   236     //Validate Filter
 
   226     QList<QContactLocalId> expectedContacts;
 
   237     QList<QContactLocalId> expectedContacts;
 
   227     expectedContacts += contact.localId();
 
   238     expectedContacts += contact.localId();
 
   228     QVERIFY(true == validateRelationshipFilter(QContactRelationshipFilter::First, groupContact.id(), expectedContacts));
 
   239     QVERIFY(true == validateRelationshipFilter(QContactRelationship::First, groupContact.id(), expectedContacts));
 
       
   240     
       
   241     QList<QContactLocalId> expectedContacts1;
 
       
   242     expectedContacts1 += groupContact.localId();
 
       
   243     expectedContacts1 += contact.localId();
 
       
   244     QList<QContactLocalId> expectedContacts2;
 
       
   245     expectedContacts2 += contact.localId();
 
       
   246     expectedContacts2 += groupContact.localId(); 
       
   247     QVERIFY(true == (validateRelationshipFilter(QContactRelationship::Either, groupContact.id(), expectedContacts1) ||
 
       
   248                      validateRelationshipFilter(QContactRelationship::Either, groupContact.id(), expectedContacts2)));
 
       
   249 
       
   250     expectedContacts.clear();
 
       
   251     expectedContacts += groupContact.localId();
 
       
   252     QVERIFY(true == validateRelationshipFilter(QContactRelationship::Second, contact.id(), expectedContacts));
 
   229     
   253     
   230     //remove relationship
 
   254     //remove relationship
 
   231     returnValue = m_relationship->removeRelationship(&affectedContactIds, relationship, error);
 
   255     returnValue = m_relationship->removeRelationship(&affectedContactIds, relationship, &error);
 
   232     QVERIFY2(returnValue == true, "remove");
 
   256     QVERIFY2(returnValue == true, "remove");
 
   233     QVERIFY2(affectedContactIds.count() == 2, "remove");
 
   257     QVERIFY2(affectedContactIds.count() == 2, "remove");
 
   234     QVERIFY2(affectedContactIds.toList().contains(groupContact.localId()), "remove");
 
   258     QVERIFY2(affectedContactIds.toList().contains(groupContact.localId()), "remove");
 
   235     QVERIFY2(affectedContactIds.toList().contains(contact.localId()), "remove");
 
   259     QVERIFY2(affectedContactIds.toList().contains(contact.localId()), "remove");
 
   236     QVERIFY2(error == QContactManager::NoError, "remove");
 
   260     QVERIFY2(error == QContactManager::NoError, "remove");
 
   256 void TestCntRelationship::invalidFirstContactGroupRelationship()
 
   280 void TestCntRelationship::invalidFirstContactGroupRelationship()
 
   257 {
 
   281 {
 
   258     //create a contact
 
   282     //create a contact
 
   259     QContact contact;
 
   283     QContact contact;
 
   260     contact.setType(QContactType::TypeContact);
 
   284     contact.setType(QContactType::TypeContact);
 
   261     m_manager->saveContact(&contact);
 
   285     QContactManager::Error err;
 
       
   286     m_manager->saveContact(&contact, &err);
 
   262 
   287 
   263     //create relationship
 
   288     //create relationship
 
   264     QContactId invalidId;
 
   289     QContactId invalidId;
 
   265     QContactRelationship relationship;
 
   290     QContactRelationship relationship;
 
   266     relationship.setRelationshipType(QContactRelationship::HasMember);
 
   291     relationship.setRelationshipType(QContactRelationship::HasMember);
 
   269 
   294 
   270     //save relationship
 
   295     //save relationship
 
   271     bool returnValue(false);
 
   296     bool returnValue(false);
 
   272     QContactManager::Error error;
 
   297     QContactManager::Error error;
 
   273     QSet<QContactLocalId> affectedContactIds;
 
   298     QSet<QContactLocalId> affectedContactIds;
 
   274     returnValue = m_relationship->saveRelationship(&affectedContactIds, &relationship, error);
 
   299     returnValue = m_relationship->saveRelationship(&affectedContactIds, &relationship, &error);
 
   275     QVERIFY(returnValue == false);
 
   300     QVERIFY(returnValue == false);
 
   276     QVERIFY(affectedContactIds.count() == 0);
 
   301     QVERIFY(affectedContactIds.count() == 0);
 
   277     QVERIFY(error != QContactManager::NoError);
 
   302     QVERIFY(error != QContactManager::NoError);
 
   278 
   303 
   279     //remove relationship
 
   304     //remove relationship
 
   280     returnValue = m_relationship->removeRelationship(&affectedContactIds, relationship, error);
 
   305     returnValue = m_relationship->removeRelationship(&affectedContactIds, relationship, &error);
 
   281     QVERIFY(returnValue == false);
 
   306     QVERIFY(returnValue == false);
 
   282     QVERIFY(affectedContactIds.count() == 0);
 
   307     QVERIFY(affectedContactIds.count() == 0);
 
   283     QVERIFY(error != QContactManager::NoError);
 
   308     QVERIFY(error != QContactManager::NoError);
 
   284 }
 
   309 }
 
   285 
   310 
   289 void TestCntRelationship::invalidSecondContactGroupRelationship()
 
   314 void TestCntRelationship::invalidSecondContactGroupRelationship()
 
   290 {
 
   315 {
 
   291     //create a group
 
   316     //create a group
 
   292     QContact groupContact;
 
   317     QContact groupContact;
 
   293     groupContact.setType(QContactType::TypeGroup);
 
   318     groupContact.setType(QContactType::TypeGroup);
 
   294     m_manager->saveContact(&groupContact);
 
   319     QContactManager::Error err;
 
       
   320     m_manager->saveContact(&groupContact, &err);
 
   295 
   321 
   296     //create relationship
 
   322     //create relationship
 
   297     QContactId invalidId;
 
   323     QContactId invalidId;
 
   298     QContactRelationship relationship;
 
   324     QContactRelationship relationship;
 
   299     relationship.setRelationshipType(QContactRelationship::HasMember);
 
   325     relationship.setRelationshipType(QContactRelationship::HasMember);
 
   302 
   328 
   303     //save relationship
 
   329     //save relationship
 
   304     bool returnValue(false);
 
   330     bool returnValue(false);
 
   305     QContactManager::Error error;
 
   331     QContactManager::Error error;
 
   306     QSet<QContactLocalId> affectedContactIds;
 
   332     QSet<QContactLocalId> affectedContactIds;
 
   307     returnValue = m_relationship->saveRelationship(&affectedContactIds, &relationship, error);
 
   333     returnValue = m_relationship->saveRelationship(&affectedContactIds, &relationship, &error);
 
   308     QVERIFY2(returnValue == false, "save");
 
   334     QVERIFY2(returnValue == false, "save");
 
   309     QVERIFY2(affectedContactIds.count() == 0, "save");
 
   335     QVERIFY2(affectedContactIds.count() == 0, "save");
 
   310     QVERIFY2(error != QContactManager::NoError, "save");
 
   336     QVERIFY2(error != QContactManager::NoError, "save");
 
   311 
   337 
   312     //remove relationship
 
   338     //remove relationship
 
   313     returnValue = m_relationship->removeRelationship(&affectedContactIds, relationship, error);
 
   339     returnValue = m_relationship->removeRelationship(&affectedContactIds, relationship, &error);
 
       
   340     QVERIFY2(returnValue == false, "remove");
 
       
   341     QVERIFY2(affectedContactIds.count() == 0, "remove");
 
       
   342     QVERIFY2(error != QContactManager::NoError, "remove");
 
       
   343     
       
   344     //remove relationship: cyclic relantionship
 
       
   345     relationship.setRelationshipType(QContactRelationship::HasMember);
 
       
   346     relationship.setFirst(groupContact.id());
 
       
   347     relationship.setSecond(groupContact.id());
 
       
   348     returnValue = m_relationship->removeRelationship(&affectedContactIds, relationship, &error);
 
   314     QVERIFY2(returnValue == false, "remove");
 
   349     QVERIFY2(returnValue == false, "remove");
 
   315     QVERIFY2(affectedContactIds.count() == 0, "remove");
 
   350     QVERIFY2(affectedContactIds.count() == 0, "remove");
 
   316     QVERIFY2(error != QContactManager::NoError, "remove");
 
   351     QVERIFY2(error != QContactManager::NoError, "remove");
 
   317 }
 
   352 }
 
   318 
   353 
   330 
   365 
   331     //save relationship
 
   366     //save relationship
 
   332     bool returnValue(false);
 
   367     bool returnValue(false);
 
   333     QContactManager::Error error;
 
   368     QContactManager::Error error;
 
   334     QSet<QContactLocalId> affectedContactIds;
 
   369     QSet<QContactLocalId> affectedContactIds;
 
   335     returnValue = m_relationship->saveRelationship(&affectedContactIds, &relationship, error);
 
   370     returnValue = m_relationship->saveRelationship(&affectedContactIds, &relationship, &error);
 
   336     QVERIFY(returnValue == false);
 
   371     QVERIFY(returnValue == false);
 
   337     QVERIFY(affectedContactIds.count() == 0);
 
   372     QVERIFY(affectedContactIds.count() == 0);
 
   338     QVERIFY(error != QContactManager::NoError);
 
   373     QVERIFY(error != QContactManager::NoError);
 
   339 
   374 
   340     //remove relationship
 
   375     //remove relationship
 
   341     returnValue = m_relationship->removeRelationship(&affectedContactIds, relationship, error);
 
   376     returnValue = m_relationship->removeRelationship(&affectedContactIds, relationship, &error);
 
   342     QVERIFY(returnValue == false);
 
   377     QVERIFY(returnValue == false);
 
   343     QVERIFY(affectedContactIds.count() == 0);
 
   378     QVERIFY(affectedContactIds.count() == 0);
 
   344     QVERIFY(error != QContactManager::NoError);
 
   379     QVERIFY(error != QContactManager::NoError);
 
   345 }
 
   380     
   346 
   381     //remove relationship: first contact's manager is not the same as cntrelationship's 
   347 bool TestCntRelationship::validateRelationshipFilter(const QContactRelationshipFilter::Role role, const QContactId contactId, const QList<QContactLocalId> expectedContacts)
 
   382     QContactRelationship relationshipDifManagers;
 
       
   383     QContactId id1;
 
       
   384     id1.setLocalId(10);
 
       
   385     id1.setManagerUri("manager1");
 
       
   386     QContactId id2;
 
       
   387     id2.setLocalId(15);
 
       
   388     id2.setManagerUri("manager2");
 
       
   389     relationshipDifManagers.setRelationshipType(QContactRelationship::HasMember);
 
       
   390     relationshipDifManagers.setFirst(id1);
 
       
   391     relationshipDifManagers.setSecond(id2);
 
       
   392     returnValue = m_relationship->removeRelationship(&affectedContactIds, relationshipDifManagers, &error);
 
       
   393     QVERIFY(returnValue == false);
 
       
   394     QVERIFY(affectedContactIds.count() == 0);
 
       
   395     QVERIFY(error != QContactManager::NoError);
 
       
   396     
       
   397     //remove relationship: second contact's manager is not the same as cntrelationship's
 
       
   398     QContact contact;
 
       
   399     contact.setType(QContactType::TypeContact);
 
       
   400     QContactManager::Error err;
 
       
   401     m_manager->saveContact(&contact, &err);
 
       
   402     QContactRelationship relationshipDifManagers2;
 
       
   403     id2.setLocalId(15);
 
       
   404     id2.setManagerUri("manager2");
 
       
   405     relationshipDifManagers2.setRelationshipType(QContactRelationship::HasMember);
 
       
   406     relationshipDifManagers2.setFirst(contact.id());
 
       
   407     relationshipDifManagers2.setSecond(id2);
 
       
   408     returnValue = m_relationship->removeRelationship(&affectedContactIds, relationshipDifManagers2, &error);
 
       
   409     QVERIFY(returnValue == false);
 
       
   410     QVERIFY(affectedContactIds.count() == 0);
 
       
   411     QVERIFY(error != QContactManager::NoError);
 
       
   412 }
 
       
   413 
       
   414 bool TestCntRelationship::validateRelationshipFilter(const QContactRelationship::Role role, const QContactId contactId, const QList<QContactLocalId> expectedContacts)
 
   348     {
 
   415     {
 
   349     QContactRelationshipFilter filter;
 
   416     QContactRelationshipFilter filter;
 
   350     filter.setRelationshipType(QContactRelationship::HasMember);
 
   417     filter.setRelationshipType(QContactRelationship::HasMember);
 
   351     filter.setRelatedContactRole(role);
 
   418     filter.setRelatedContactRole(role);
 
   352     filter.setRelatedContactId(contactId);
 
   419     filter.setRelatedContactId(contactId);
 
   353     
   420     
   354     QList<QContactLocalId> result = m_manager->contactIds(filter);
 
   421     QContactManager::Error err;
 
       
   422     QList<QContactLocalId> result = m_manager->contactIds(filter, QList<QContactSortOrder>(), &err);
 
   355     
   423     
   356     for(int i = 0; i < result.count(); i++)
 
   424     for(int i = 0; i < result.count(); i++)
 
   357         qDebug() << "result: " << result.at(i);
 
   425         qDebug() << "result: " << result.at(i);
 
   358     
   426     
   359     for(int i = 0; i < expectedContacts.count(); i++)
 
   427     for(int j = 0; j < expectedContacts.count(); j++)
 
   360             qDebug() << "expectedContacts: " << expectedContacts.at(i);
 
   428             qDebug() << "expectedContacts: " << expectedContacts.at(j);
 
   361     
   429     
   362     return (result == expectedContacts);
 
   430     return (result == expectedContacts);
 
   363     }
 
   431     }
 
   364 
   432
FCL/sf/mw/qtextensions