Mercurial Mercurial > oss > FCL > sf > app > contacts / 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.
phonebookengines/mobcntmodel/tsrc/ut_mobcntmodel/src/ut_mobcntmodel.cpp
changeset 37 fd64c38c277d
parent 31 2a11b5b00470
equal deleted inserted replaced
31:2a11b5b00470 37:fd64c38c277d 
    18 #include "ut_mobcntmodel.h"
 
    18 #include "ut_mobcntmodel.h"
 
    19 #include "mobcntmodel.h"
 
    19 #include "mobcntmodel.h"
 
    20 #include "mobcntmodel_p.h"
 
    20 #include "mobcntmodel_p.h"
 
    21 
    21 
    22 #include <qtcontacts.h>
 
    22 #include <qtcontacts.h>
 
    23 #include <QSignalSpy>
 
    23 #include <QUrl>
 
    24 
    24 
    25 void TestMobCntModel::initTestCase()
 
    25 void TestMobCntModel::initTestCase()
 
    26 {
 
    26 {
 
    27     //let's have clean database before running tests 
    27     //let's have clean database before running tests 
    28     mManager = new QContactManager("symbian");
 
    28     mManager = new QContactManager("symbian");
 
    29     QList<QContactLocalId> ids = mManager->contactIds();
 
    29     QList<QContactLocalId> ids = mManager->contactIds();
 
    30     QMap<int, QContactManager::Error> errorMapInit;
 
    30     QMap<int, QContactManager::Error> errorMapInit;
 
    31     mManager->removeContacts(ids, &errorMapInit);
 
    31     mManager->removeContacts(ids, &errorMapInit);
 
       
    32 }
 
       
    33 
       
    34 void TestMobCntModel::contactReady(int startRow, int endRow)
 
       
    35 {
 
       
    36     QVERIFY(startRow == endRow);
 
       
    37     mDataReady = true;
 
    32 }
 
    38 }
 
    33 
    39 
    34 void TestMobCntModel::create()
 
    40 void TestMobCntModel::create()
 
    35 {
 
    41 {
 
    36     mCntModel = new MobCntModel();
 
    42     mCntModel = new MobCntModel();
 
    37     QVERIFY(mCntModel != 0);
 
    43     QVERIFY(mCntModel != 0);
 
    38     QVERIFY(mCntModel->rowCount() == 1);
 
    44     QVERIFY(mCntModel->rowCount() == 1);
 
    39     QVERIFY(mCntModel->mIconManager);
 
    45     QVERIFY(mCntModel->d->m_cache);
 
    40     QVERIFY(mCntModel->d->ownedContactManager);
 
    46     QVERIFY(mCntModel->d->ownedContactManager);
 
    41     QVERIFY(mCntModel->d->m_contactManager != 0);
 
    47     QVERIFY(mCntModel->d->m_contactManager != 0);
 
    42     
    48     
    43     delete mCntModel;
 
    49     delete mCntModel;
 
    44     mCntModel = 0;
 
    50     mCntModel = 0;
 
    45     
    51     
    46     mCntModel = new MobCntModel(mManager);
 
    52     mCntModel = new MobCntModel(mManager);
 
    47     QVERIFY(mCntModel != 0);
 
    53     QVERIFY(mCntModel != 0);
 
    48     QCOMPARE(mCntModel->rowCount(),1);
 
    54     QCOMPARE(mCntModel->rowCount(),1);
 
    49     QVERIFY(mCntModel->rowCount() == 1);
 
    55     QVERIFY(mCntModel->rowCount() == 1);
 
    50     QVERIFY(mCntModel->mIconManager);
 
    56     QVERIFY(mCntModel->d->m_cache);
 
    51     QVERIFY(!mCntModel->d->ownedContactManager);
 
    57     QVERIFY(!mCntModel->d->ownedContactManager);
 
    52     QVERIFY(mCntModel->d->m_contactManager != 0);
 
    58     QVERIFY(mCntModel->d->m_contactManager != 0);
 
    53 }
 
    59 }
 
    54 
    60 
    55 void TestMobCntModel::data()
 
    61 void TestMobCntModel::data()
 
    56 {
 
    62 {
 
       
    63     mModelListener = new ModelListener(this);
 
       
    64     mDataReady = false;
 
       
    65 
    57     //create and save contact
 
    66     //create and save contact
 
    58     QContact c;
 
    67     QContact c;
 
    59     QContactName name;
 
    68     QContactName name;
 
    60     name.setFirstName("firstname");
 
    69     name.setFirstName("firstname");
 
    61     name.setLastName("lastname");
 
    70     name.setLastName("lastname");
 
    89     QVERIFY(ret.type() == QVariant::StringList);
 
    98     QVERIFY(ret.type() == QVariant::StringList);
 
    90     QStringList displayContent;
 
    99     QStringList displayContent;
 
    91     displayContent = ret.toStringList();
 
   100     displayContent = ret.toStringList();
 
    92     QVERIFY(displayContent.count() == 2);
 
   101     QVERIFY(displayContent.count() == 2);
 
    93     QVERIFY(displayContent.at(0) == "firstname lastname");
 
   102     QVERIFY(displayContent.at(0) == "firstname lastname");
 
       
   103     // second string is only an empty placeholder, e.g. " ", until cache has fetched the value
 
       
   104 
       
   105     // wait for cache to signal that all contact info is ready
 
       
   106     while (!mDataReady) { QTest::qWait(200); QApplication::processEvents(); }
 
       
   107     mDataReady = false;
 
       
   108     ret = mCntModel->data(modelIndex, Qt::DisplayRole); 
       
   109 
       
   110     QVERIFY(ret.type() == QVariant::StringList);
 
       
   111     displayContent = ret.toStringList();
 
       
   112     QVERIFY(displayContent.count() == 2);
 
       
   113     QVERIFY(displayContent.at(0) == "firstname lastname");
 
    94     QVERIFY(displayContent.at(1) == "1234567");
 
   114     QVERIFY(displayContent.at(1) == "1234567");
 
    95     
   115    
    96     // check backgroundrole
 
   116     // check backgroundrole
 
    97     ret = mCntModel->data(modelIndex, Qt::BackgroundRole); 
   117     ret = mCntModel->data(modelIndex, Qt::BackgroundRole); 
    98     QVERIFY(ret.isNull());
 
   118     QVERIFY(ret.isNull());
 
    99     
   119     
   100     //check decoration role
 
   120     //check decoration role
 
   101     ret = mCntModel->data(modelIndex, Qt::DecorationRole); 
   121     ret = mCntModel->data(modelIndex, Qt::DecorationRole); 
   102     QVERIFY(ret.type() == QVariant::List);
 
   122     QVERIFY(ret.type() == QVariant::List);
 
   103     
   123 
   104     // add empty avatar and check decoration
 
   124     // add empty avatar and check decoration
 
   105     QContactAvatar avatar;
 
   125     QContactAvatar avatar;
 
   106     avatar.setSubType(QContactAvatar::SubTypeImage);
 
       
   107     c.saveDetail(&avatar);
 
   126     c.saveDetail(&avatar);
 
   108     QVERIFY(mManager->saveContact(&c));
 
   127     QVERIFY(mManager->saveContact(&c));
 
   109     QTest::qWait(1000);
 
   128     QTest::qWait(1000);
 
   110     ret = mCntModel->data(modelIndex, Qt::DecorationRole); 
   129     ret = mCntModel->data(modelIndex, Qt::DecorationRole); 
   111     QVERIFY(ret.type() == QVariant::List);
 
   130     QVERIFY(ret.type() == QVariant::List);
 
   112     
   131     
   113     // add data to the avatar and check decoration
 
   132     // add data to the avatar and check decoration
 
   114     avatar.setAvatar("dummyimagepath");
 
   133     avatar.setImageUrl(QUrl("dummyimagepath"));
 
   115     c.saveDetail(&avatar);
 
   134     c.saveDetail(&avatar);
 
   116     QVERIFY(mManager->saveContact(&c));
 
   135     QVERIFY(mManager->saveContact(&c));
 
   117     QTest::qWait(1000);
 
   136     QTest::qWait(1000);
 
   118     modelIndex = mCntModel->indexOfContact(c);
 
   137     modelIndex = mCntModel->indexOfContact(c);
 
       
   138     ret = mCntModel->data(modelIndex, Qt::DecorationRole); 
       
   139 
       
   140     // wait for cache to signal that all contact info is ready
 
       
   141     while (!mDataReady) { QTest::qWait(200); QApplication::processEvents(); }
 
       
   142     mDataReady = false;
 
   119     ret = mCntModel->data(modelIndex, Qt::DecorationRole); 
   143     ret = mCntModel->data(modelIndex, Qt::DecorationRole); 
   120     QVERIFY(ret.type() == QVariant::List);
 
   144     QVERIFY(ret.type() == QVariant::List);
 
   121     
   145     
   122     // check MyCard info from the model
 
   146     // check MyCard info from the model
 
   123     modelIndex = mCntModel->index(0, 0);
 
   147     modelIndex = mCntModel->index(0, 0);
 
   138     QVERIFY(!ret.isNull());
 
   162     QVERIFY(!ret.isNull());
 
   139     
   163     
   140     ret = mCntModel->data(modelIndex, Qt::DisplayRole);
 
   164     ret = mCntModel->data(modelIndex, Qt::DisplayRole);
 
   141     QVERIFY(ret.type() == QVariant::StringList);
 
   165     QVERIFY(ret.type() == QVariant::StringList);
 
   142     displayContent = ret.toStringList();
 
   166     displayContent = ret.toStringList();
 
   143     QVERIFY(displayContent.count() == 2);// "My card" ; "Create my identity"
 
   167     QVERIFY(displayContent.count() == 1); // "Unnamed"
 
   144     
   168     
   145     // add some content to MyCard
 
   169     // add some content to MyCard
 
   146     myCard.saveDetail(&number);
 
   170     myCard.saveDetail(&number);
 
   147     QVERIFY(mManager->saveContact(&myCard));
 
   171     QVERIFY(mManager->saveContact(&myCard));
 
   148     QTest::qWait(1000);
 
   172     QTest::qWait(1000);
 
   149     ret = mCntModel->data(modelIndex, Qt::DisplayRole);
 
   173     ret = mCntModel->data(modelIndex, Qt::DisplayRole);
 
       
   174     // wait for cache
 
       
   175     QTest::qWait(1000);
 
       
   176     ret = mCntModel->data(modelIndex, Qt::DisplayRole);
 
   150     QVERIFY(ret.type() == QVariant::StringList);
 
   177     QVERIFY(ret.type() == QVariant::StringList);
 
   151     displayContent = ret.toStringList();
 
   178     displayContent = ret.toStringList();
 
   152     QVERIFY(displayContent.contains(myCard.displayLabel()));
 
   179     QVERIFY(displayContent.contains(hbTrId("txt_phob_list_unnamed")));
 
   153 }
 
   180 }
 
   154 
   181 
   155 void TestMobCntModel::rowCount()
 
   182 void TestMobCntModel::rowCount()
 
   156 {
 
   183 {
 
   157     // we should have 2 contacts in the model saved from the last test case
 
   184     // we should have 2 contacts in the model saved from the last test case
 
   210 }
 
   237 }
 
   211 
   238 
   212 void TestMobCntModel::setFilterAndSortOrder()
 
   239 void TestMobCntModel::setFilterAndSortOrder()
 
   213 {
 
   240 {
 
   214     QList<QContactLocalId> ids = mManager->contactIds();
 
   241     QList<QContactLocalId> ids = mManager->contactIds();
 
   215     mManager->removeContacts(&ids);
 
   242     QMap<int, QContactManager::Error> errorMap;
 
       
   243     mManager->removeContacts(ids,&errorMap);
 
   216     QTest::qWait(1000);
 
   244     QTest::qWait(1000);
 
   217     
   245     
   218     QContact c;
 
   246     QContact c;
 
   219     QContactName name;
 
   247     QContactName name;
 
   220     name.setFirstName("firstname");
 
   248     name.setFirstName("firstname");
 
   258     mCntModel = 0;
 
   286     mCntModel = 0;
 
   259     
   287     
   260     mCntModel = new MobCntModel(mManager);
 
   288     mCntModel = new MobCntModel(mManager);
 
   261     
   289     
   262     QList<QContactLocalId> ids = mManager->contactIds();
 
   290     QList<QContactLocalId> ids = mManager->contactIds();
 
   263     mManager->removeContacts(&ids);
 
   291     QMap<int, QContactManager::Error> errorMap;
 
       
   292     mManager->removeContacts(ids,&errorMap);
 
   264     QTest::qWait(1000);
 
   293     QTest::qWait(1000);
 
   265     
   294     
   266     QContact c;
 
   295     QContact c;
 
   267     QContactName name;
 
   296     QContactName name;
 
   268     name.setFirstName("firstname");
 
   297     name.setFirstName("firstname");
 
   299 }
 
   328 }
 
   300 
   329 
   301 void TestMobCntModel::rowId()
 
   330 void TestMobCntModel::rowId()
 
   302 {
 
   331 {
 
   303     QList<QContactLocalId> ids = mManager->contactIds();
 
   332     QList<QContactLocalId> ids = mManager->contactIds();
 
   304     mManager->removeContacts(&ids);
 
   333     QMap<int, QContactManager::Error> errorMap;
 
       
   334     mManager->removeContacts(ids,&errorMap);
 
   305     QTest::qWait(1000);
 
   335     QTest::qWait(1000);
 
   306     
   336     
   307     QContact c;
 
   337     QContact c;
 
   308     QContactName name;
 
   338     QContactName name;
 
   309     name.setFirstName("firstname");
 
   339     name.setFirstName("firstname");
 
   319 }
 
   349 }
 
   320 
   350 
   321 void TestMobCntModel::dataForDisplayRole()
 
   351 void TestMobCntModel::dataForDisplayRole()
 
   322 {
 
   352 {
 
   323     QList<QContactLocalId> ids = mManager->contactIds();
 
   353     QList<QContactLocalId> ids = mManager->contactIds();
 
   324     mManager->removeContacts(&ids);
 
   354     QMap<int, QContactManager::Error> errorMap;
 
       
   355     mManager->removeContacts(ids,&errorMap);
 
   325     QTest::qWait(1000);
 
   356     QTest::qWait(1000);
 
   326     
   357     
   327     QContact c;
 
   358     QContact c;
 
   328     QContactName name;
 
   359     QContactName name;
 
   329     name.setFirstName("firstname");
 
   360     name.setFirstName("firstname");
 
   337     
   368     
   338     var = mCntModel->dataForDisplayRole(0);
 
   369     var = mCntModel->dataForDisplayRole(0);
 
   339     QVERIFY(var.type() == QVariant::StringList);
 
   370     QVERIFY(var.type() == QVariant::StringList);
 
   340 }
 
   371 }
 
   341 
   372 
   342 void TestMobCntModel::updateContactIcon()
 
   373 void TestMobCntModel::handleAdded()
 
   343 {
 
   374 {
 
   344     QList<QContactLocalId> ids = mManager->contactIds();
 
   375     QList<QContactLocalId> ids = mManager->contactIds();
 
   345     mManager->removeContacts(&ids);
 
   376     QMap<int, QContactManager::Error> errorMap;
 
   346     QTest::qWait(1000);
 
   377     mManager->removeContacts(ids,&errorMap);
 
   347     
   378     QTest::qWait(1000);
 
   348     QContact c;
 
   379 
   349     QContactName name;
 
   380     QSignalSpy spy(mCntModel, SIGNAL(rowsAboutToBeInserted(const QModelIndex&, int, int)));
 
   350     name.setFirstName("firstname");
 
   381     
   351     name.setLastName("lastname");
 
   382     QContact c;
 
   352     c.saveDetail(&name);
 
   383     QContactName name;
 
   353     QVERIFY(mManager->saveContact(&c));
 
   384     name.setFirstName("firstname");
 
   354     
   385     name.setLastName("lastname");
 
   355     int row = mCntModel->rowId(c.localId());
 
   386     c.saveDetail(&name);
 
   356     
   387     QVERIFY(mManager->saveContact(&c));
 
   357     QSignalSpy spy(mCntModel, SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&)));
 
   388 
   358     
       
   359     mCntModel->updateContactIcon(row);
 
       
   360     QCOMPARE(spy.count(), 1);
 
   389     QCOMPARE(spy.count(), 1);
 
   361 }
 
   390 }
 
   362 
   391 
   363 void TestMobCntModel::handleAdded()
 
   392 void TestMobCntModel::handleChanged()
 
   364 {
 
   393 {
 
   365     QList<QContactLocalId> ids = mManager->contactIds();
 
   394     QList<QContactLocalId> ids = mManager->contactIds();
 
   366     QMap<int, QContactManager::Error> errorMapHandleAdded;
 
   395     QMap<int, QContactManager::Error> errorMap;
 
   367     mManager->removeContacts(ids,&errorMapHandleAdded);
 
   396     mManager->removeContacts(ids,&errorMap);
 
   368     QTest::qWait(1000);
 
   397     QTest::qWait(1000);
 
   369 
   398     
   370     QSignalSpy spy(mCntModel, SIGNAL(rowsAboutToBeInserted(const QModelIndex&, int, int)));
 
   399     QContact c;
 
   371     
   400     QContactName name;
 
   372     QContact c;
 
   401     name.setFirstName("firstname");
 
   373     QContactName name;
 
   402     name.setLastName("lastname");
 
   374     name.setFirstName("firstname");
 
   403     c.saveDetail(&name);
 
   375     name.setLastName("lastname");
 
   404     QVERIFY(mManager->saveContact(&c));
 
       
   405     
       
   406     QSignalSpy spy(mCntModel, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex&)));
 
       
   407 
       
   408     name.setMiddleName("mid");
 
   376     c.saveDetail(&name);
 
   409     c.saveDetail(&name);
 
   377     QVERIFY(mManager->saveContact(&c));
 
   410     QVERIFY(mManager->saveContact(&c));
 
   378 
   411 
   379     QCOMPARE(spy.count(), 1);
 
   412     QCOMPARE(spy.count(), 1);
 
   380 }
 
   413 }
 
   381 
   414 
   382 void TestMobCntModel::handleChanged()
 
   415 void TestMobCntModel::handleRemoved()
 
   383 {
 
   416 {
 
   384     QList<QContactLocalId> ids = mManager->contactIds();
 
   417     QSignalSpy spy(mCntModel, SIGNAL(rowsAboutToBeRemoved(const QModelIndex&, int, int)));
 
   385     QMap<int, QContactManager::Error> errorMapHandleChanged;
 
   418     
   386     mManager->removeContacts(ids,&errorMapHandleChanged);
 
   419     QList<QContactLocalId> ids = mManager->contactIds();
 
   387     QTest::qWait(1000);
 
   420     QMap<int, QContactManager::Error> errorMap;
 
   388     
   421     mManager->removeContacts(ids,&errorMap);
 
   389     QContact c;
 
   422     QTest::qWait(1000);
 
   390     QContactName name;
 
   423     
   391     name.setFirstName("firstname");
 
       
   392     name.setLastName("lastname");
 
       
   393     c.saveDetail(&name);
 
       
   394     QVERIFY(mManager->saveContact(&c));
 
       
   395     
       
   396     QSignalSpy spy(mCntModel, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex&)));
 
       
   397 
       
   398     name.setMiddleName("mid");
 
       
   399     c.saveDetail(&name);
 
       
   400     QVERIFY(mManager->saveContact(&c));
 
       
   401 
       
   402     QCOMPARE(spy.count(), 1);
 
   424     QCOMPARE(spy.count(), 1);
 
   403 }
 
   425 }
 
   404 
   426 
   405 void TestMobCntModel::handleRemoved()
 
       
   406 {
 
       
   407     QSignalSpy spy(mCntModel, SIGNAL(rowsAboutToBeRemoved(const QModelIndex&, int, int)));
 
       
   408     
       
   409     QList<QContactLocalId> ids = mManager->contactIds();
 
       
   410     QMap<int, QContactManager::Error> errorMapHandle;
 
       
   411     mManager->removeContacts(ids,&errorMapHandle);
 
       
   412     QTest::qWait(1000);
 
       
   413     
       
   414     QCOMPARE(spy.count(), 1);
 
       
   415 }
 
       
   416 
       
   417 void TestMobCntModel::handleMyCardChanged()
 
   427 void TestMobCntModel::handleMyCardChanged()
 
   418 {
 
   428 {
 
   419     QList<QContactLocalId> ids = mManager->contactIds();
 
   429     QList<QContactLocalId> ids = mManager->contactIds();
 
   420     mManager->removeContacts(&ids);
 
   430     QMap<int, QContactManager::Error> errorMap;
 
       
   431     mManager->removeContacts(ids,&errorMap);
 
   421     QTest::qWait(1000);
 
   432     QTest::qWait(1000);
 
   422     
   433     
   423     QContact c;
 
   434     QContact c;
 
   424     QContactName name;
 
   435     QContactName name;
 
   425     name.setFirstName("firstname");
 
   436     name.setFirstName("firstname");
 
   443     QList<QContactLocalId> ids = mManager->contactIds();
 
   454     QList<QContactLocalId> ids = mManager->contactIds();
 
   444     QMap<int, QContactManager::Error> errorMap;
 
   455     QMap<int, QContactManager::Error> errorMap;
 
   445     mManager->removeContacts(ids, &errorMap);
 
   456     mManager->removeContacts(ids, &errorMap);
 
   446     delete mManager;
 
   457     delete mManager;
 
   447     mManager = 0;
 
   458     mManager = 0;
 
   448 }
 
   459     delete mModelListener;
 
   449 
   460     mModelListener = 0;
 
       
   461 }
 
       
   462 
       
   463 
       
   464 ModelListener::ModelListener(TestMobCntModel* parent)
 
       
   465     : mParent(parent)
 
       
   466 {
 
       
   467     connect(mParent->mCntModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(onDataChanged(QModelIndex,QModelIndex)));
 
       
   468 }
 
       
   469 
       
   470 void ModelListener::onDataChanged(QModelIndex start, QModelIndex end)
 
       
   471 {
 
       
   472     mParent->contactReady(start.row(), end.row());
 
       
   473 }
 
       
   474
FCL/sf/app/contacts