contentstorage/caclient/tsrc/t_caclient/src/t_caclient_notifier.cpp
changeset 117 c63ee96dbe5f
equal deleted inserted replaced
115:3ab5c078b490 117:c63ee96dbe5f
       
     1 /*
       
     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description:  Main test class for hspluginmodel library.
       
    15 *
       
    16 */
       
    17 
       
    18 #include <QScopedPointer>
       
    19 #include <qservicemanager.h>
       
    20 
       
    21 #include "t_caclient.h"
       
    22 #include "caservice.h"
       
    23 #include "canotifier.h"
       
    24 #include "canotifierfilter.h"
       
    25 #include "caquery.h"
       
    26 #include "t_caclientNotifier.h"
       
    27 
       
    28 const int entryIdFake(-1);
       
    29 const int waitTime500ms(500);
       
    30 const int waitTime1sec(1000);
       
    31 
       
    32 QTM_USE_NAMESPACE
       
    33 
       
    34 QStringList pluginPaths;
       
    35 QString xmlName("caapphandlerplugin.xml");
       
    36 
       
    37 // ---------------------------------------------------------------------------
       
    38 // ---------------------------------------------------------------------------
       
    39 //
       
    40 void TestCaClient::initTestCase()
       
    41 {
       
    42 #ifdef Q_OS_SYMBIAN
       
    43     startThread();
       
    44 #endif //Q_OS_SYMBIAN
       
    45     mService = CaService::instance();
       
    46 }
       
    47 // ---------------------------------------------------------------------------
       
    48 // ---------------------------------------------------------------------------
       
    49 //
       
    50 void TestCaClient::cleanupTestCase()
       
    51 {
       
    52 #ifdef Q_OS_SYMBIAN
       
    53     stopThread();
       
    54 #endif //Q_OS_SYMBIAN
       
    55     QSharedPointer<CaService> serviceNull(NULL);
       
    56     mService = serviceNull;
       
    57     QTest::qWait(5000);
       
    58 }
       
    59 
       
    60 
       
    61 // ---------------------------------------------------------------------------
       
    62 // ---------------------------------------------------------------------------
       
    63 int threadFunction(void *params)
       
    64 {
       
    65 #ifdef Q_OS_SYMBIAN
       
    66     while (ETrue) {
       
    67         User::ResetInactivityTime();//it should help for Viewserver11 panic
       
    68         User::After(5000000);
       
    69     }
       
    70 #endif //Q_OS_SYMBIAN
       
    71     return 0;
       
    72 }
       
    73 
       
    74 // ---------------------------------------------------------------------------
       
    75 // ---------------------------------------------------------------------------
       
    76 //
       
    77 void TestCaClient::startThread()
       
    78 {
       
    79 #ifdef Q_OS_SYMBIAN
       
    80     User::LeaveIfError(iThread.Create(
       
    81                            _L("thread_kill_viewsrv11"),
       
    82                            threadFunction,
       
    83                            16384,
       
    84                            4000,
       
    85                            4000,
       
    86                            NULL));
       
    87     iThread.Resume();
       
    88 #endif //Q_OS_SYMBIAN
       
    89 }
       
    90 // ---------------------------------------------------------------------------
       
    91 // ---------------------------------------------------------------------------
       
    92 //
       
    93 void TestCaClient::stopThread()
       
    94 {
       
    95 #ifdef Q_OS_SYMBIAN
       
    96     iThread.Close();
       
    97 #endif //Q_OS_SYMBIAN
       
    98 }
       
    99 
       
   100 
       
   101 // ---------------------------------------------------------------------------
       
   102 //
       
   103 void TestCaClient::TestAssignmentOperatorNotifier()
       
   104 {
       
   105 #ifdef Q_OS_SYMBIAN
       
   106 #ifdef UT_MEMORY_CHECK
       
   107 // __UHEAP_MARK;
       
   108 #endif//UT_MEMORY_CHECK
       
   109 #endif//Q_OS_SYMBIAN
       
   110     {
       
   111         CaNotifierFilter filter;
       
   112         filter.setEntryRole(ItemEntryRole);
       
   113         filter.setTypeNames(QStringList() << "typeName1" << "typeName2");
       
   114         filter.setParentId(22);
       
   115         filter.setIds(QList<int>() << 11 << 22);
       
   116 
       
   117         CaNotifierFilter filterAssign;
       
   118         filterAssign = filter;
       
   119         QCOMPARE(filterAssign.getEntryRole(), filter.getEntryRole());
       
   120         QCOMPARE(filterAssign.getParentId(), filter.getParentId());
       
   121         for (int i(0); i < filter.getIds().count(); i++) {
       
   122             QCOMPARE(filterAssign.getIds().at(i),
       
   123             filter.getIds().at(i));
       
   124         }
       
   125         for (int i(0); i < filter.getTypeNames().count(); i++) {
       
   126             QCOMPARE(filterAssign.getTypeNames().at(i),
       
   127             filter.getTypeNames().at(i));
       
   128         }
       
   129 
       
   130         filter.setEntryRole(GroupEntryRole);
       
   131         filter.getTypeNames().clear();
       
   132         filter.setTypeNames(QStringList() << "typeName3" << "typeName4");
       
   133         filter.setParentId(55);
       
   134         filter.getIds().clear();
       
   135         filter.setIds(QList<int>() << 33 << 44);
       
   136 
       
   137         QVERIFY(filterAssign.getEntryRole() != filter.getEntryRole());
       
   138         QVERIFY(filterAssign.getParentId() != filter.getParentId());
       
   139         for (int i(0); i < filter.getIds().count(); i++) {
       
   140             QVERIFY(filterAssign.getIds().at(i)
       
   141             != filter.getIds().at(i));
       
   142         }
       
   143         for (int i(0); i < filter.getTypeNames().count(); i++) {
       
   144             QVERIFY(filterAssign.getTypeNames().at(i)
       
   145             != filter.getTypeNames().at(i));
       
   146         }
       
   147 
       
   148         CaNotifierFilter filterCopyConstructor(filter);
       
   149         QCOMPARE(filterCopyConstructor.getEntryRole(), filter.getEntryRole());
       
   150         QCOMPARE(filterCopyConstructor.getParentId(), filter.getParentId());
       
   151         for (int i(0); i < filter.getIds().count(); i++) {
       
   152             QCOMPARE(filterCopyConstructor.getIds().at(i),
       
   153             filter.getIds().at(i));
       
   154         }
       
   155         for (int i(0); i < filter.getTypeNames().count(); i++) {
       
   156             QCOMPARE(filterCopyConstructor.getTypeNames().at(i),
       
   157             filter.getTypeNames().at(i));
       
   158         }
       
   159 
       
   160         CaQuery query;
       
   161         query.setEntryRoles(GroupEntryRole);
       
   162         query.setEntryTypeNames(QStringList() << "Query1" << "Query2");
       
   163         query.setParentId(77);
       
   164 
       
   165         CaNotifierFilter filterQuery(query);
       
   166         QCOMPARE(filterQuery.getEntryRole(), query.entryRoles());
       
   167         QCOMPARE(filterQuery.getParentId(), query.parentId());
       
   168         QCOMPARE(filterQuery.getIds().count(), 0);
       
   169         for (int i(0); i < query.entryTypeNames().count(); i++) {
       
   170             QCOMPARE(filterQuery.getTypeNames().at(i),
       
   171             query.entryTypeNames().at(i));
       
   172         }
       
   173     }
       
   174 #ifdef Q_OS_SYMBIAN
       
   175 #ifdef UT_MEMORY_CHECK
       
   176 // __UHEAP_MARKEND;
       
   177 #endif//UT_MEMORY_CHECK
       
   178 #endif//Q_OS_SYMBIAN
       
   179 }
       
   180 // ---------------------------------------------------------------------------
       
   181 // ---------------------------------------------------------------------------
       
   182 //
       
   183 void TestCaClient::TestAddItemChangeTypeNotifier()
       
   184 {
       
   185 #ifdef Q_OS_SYMBIAN
       
   186 #ifdef UT_MEMORY_CHECK
       
   187 // __UHEAP_MARK;
       
   188 #endif//UT_MEMORY_CHECK
       
   189 #endif//Q_OS_SYMBIAN
       
   190     {
       
   191         CaNotifierFilter *filter = new CaNotifierFilter();
       
   192         filter->setEntryRole(ItemEntryRole);
       
   193         QStringList strList;
       
   194         strList.append("TypeName");
       
   195         filter->setTypeNames(strList);
       
   196         TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService, filter);
       
   197         CaNotifier *notifier = clientNotifier->getNotifier();
       
   198 
       
   199         connect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
   200         clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
   201         QTest::qWait(waitTime1sec);
       
   202         CaEntry item;
       
   203         item.setText("Text");
       
   204         item.setEntryTypeName("TypeName");
       
   205         QSharedPointer<CaEntry> entry = mService->createEntry(item);
       
   206         QTest::qWait(waitTime1sec);
       
   207 
       
   208         QCOMPARE(clientNotifier->mChangeType, AddChangeType);
       
   209         QVERIFY(clientNotifier->mEntryId > 0);
       
   210         QCOMPARE(clientNotifier->mEntryId, entry->id());
       
   211 
       
   212         // cleanup
       
   213         disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
   214         clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
   215         QTest::qWait(waitTime500ms);
       
   216         delete clientNotifier;
       
   217         delete filter;
       
   218         mService->removeEntry(entry->id());
       
   219         QTest::qWait(waitTime500ms);
       
   220         QTest::qWait(waitTime500ms);
       
   221     }
       
   222 #ifdef Q_OS_SYMBIAN
       
   223 #ifdef UT_MEMORY_CHECK
       
   224 // __UHEAP_MARKEND;
       
   225 #endif//UT_MEMORY_CHECK
       
   226 #endif//Q_OS_SYMBIAN
       
   227 }
       
   228 // ---------------------------------------------------------------------------
       
   229 //
       
   230 void TestCaClient::TestAddGroupChangeTypeNotifier()
       
   231 {
       
   232 #ifdef Q_OS_SYMBIAN
       
   233 #ifdef UT_MEMORY_CHECK
       
   234 // __UHEAP_MARK;
       
   235 #endif//UT_MEMORY_CHECK
       
   236 #endif//Q_OS_SYMBIAN
       
   237     {
       
   238 
       
   239         CaNotifierFilter *filter = new CaNotifierFilter();
       
   240         filter->setEntryRole(GroupEntryRole);
       
   241         filter->setTypeNames(QStringList() << "TypeName");
       
   242         TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService, filter);
       
   243         CaNotifier *notifier = clientNotifier->getNotifier();
       
   244 
       
   245         connect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
   246         clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
   247         QTest::qWait(waitTime500ms);
       
   248         CaEntry group(GroupEntryRole);
       
   249         group.setText("Text");
       
   250         group.setEntryTypeName("TypeName");
       
   251 
       
   252         QSharedPointer<CaEntry> entry = mService->createEntry(group);
       
   253         QTest::qWait(waitTime1sec);
       
   254 
       
   255         QCOMPARE(clientNotifier->mChangeType, AddChangeType);
       
   256         QVERIFY(clientNotifier->mEntryId > 0);
       
   257         QCOMPARE(clientNotifier->mEntryId, entry->id());
       
   258 
       
   259         // cleanup
       
   260         disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
   261         clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
   262         QTest::qWait(waitTime500ms);
       
   263         delete clientNotifier;
       
   264         mService->removeEntry(entry->id());
       
   265     }
       
   266 #ifdef Q_OS_SYMBIAN
       
   267 #ifdef UT_MEMORY_CHECK
       
   268 // __UHEAP_MARKEND;
       
   269 #endif//UT_MEMORY_CHECK
       
   270 #endif//Q_OS_SYMBIAN
       
   271 }
       
   272 // ---------------------------------------------------------------------------
       
   273 //
       
   274 void TestCaClient::TestRemoveEntryChangeTypeNotifier()
       
   275 {
       
   276 #ifdef Q_OS_SYMBIAN
       
   277 #ifdef UT_MEMORY_CHECK
       
   278 // __UHEAP_MARK;
       
   279 #endif//UT_MEMORY_CHECK
       
   280 #endif//Q_OS_SYMBIAN
       
   281     {
       
   282 
       
   283         CaNotifierFilter *filter = new CaNotifierFilter();
       
   284         filter->setEntryRole(ItemEntryRole);
       
   285         filter->setTypeNames(QStringList() << "TypeName");
       
   286         TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService, filter);
       
   287         CaNotifier *notifier = clientNotifier->getNotifier();
       
   288 
       
   289         connect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
   290         clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
   291         QTest::qWait(waitTime500ms);
       
   292         connect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)),
       
   293         clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType)));
       
   294         QTest::qWait(waitTime500ms);
       
   295         CaEntry item;
       
   296         item.setText("Text");
       
   297         item.setEntryTypeName("TypeName");
       
   298 
       
   299         QSharedPointer<CaEntry> entry = mService->createEntry(item);
       
   300         QTest::qWait(waitTime1sec);
       
   301 
       
   302         QCOMPARE(clientNotifier->mChangeType, AddChangeType);
       
   303         QVERIFY(clientNotifier->mEntryId > 0);
       
   304         QCOMPARE(clientNotifier->mEntryId, entry->id());
       
   305 
       
   306         int entryId = clientNotifier->mEntryId;
       
   307         clientNotifier->mEntryId = 0;
       
   308 
       
   309         bool removed = mService->removeEntry(*entry);
       
   310         QTest::qWait(waitTime1sec);
       
   311 
       
   312         QCOMPARE(clientNotifier->mChangeType, RemoveChangeType);
       
   313         QVERIFY(clientNotifier->mEntryId > 0);
       
   314         QCOMPARE(clientNotifier->mEntryId, entryId);
       
   315         QCOMPARE(removed, TRUE);
       
   316 
       
   317         // cleanup
       
   318         disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
   319         clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
   320         disconnect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)),
       
   321         clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType)));
       
   322         QTest::qWait(waitTime500ms);
       
   323         delete clientNotifier;
       
   324         mService->removeEntry(entry->id());
       
   325     }
       
   326 #ifdef Q_OS_SYMBIAN
       
   327 #ifdef UT_MEMORY_CHECK
       
   328 // __UHEAP_MARKEND;
       
   329 #endif//UT_MEMORY_CHECK
       
   330 #endif//Q_OS_SYMBIAN
       
   331 }
       
   332 // ---------------------------------------------------------------------------
       
   333 //
       
   334 void TestCaClient::TestRemoveEntryIdChangeTypeNotifier()
       
   335 {
       
   336 #ifdef Q_OS_SYMBIAN
       
   337 #ifdef UT_MEMORY_CHECK
       
   338 // __UHEAP_MARK;
       
   339 #endif//UT_MEMORY_CHECK
       
   340 #endif//Q_OS_SYMBIAN
       
   341     {
       
   342 
       
   343 
       
   344         CaEntry item;
       
   345         item.setText("Text");
       
   346         item.setEntryTypeName("TypeName");
       
   347 
       
   348         QSharedPointer<CaEntry> entry = mService->createEntry(item);
       
   349         QTest::qWait(waitTime1sec);
       
   350 
       
   351         CaNotifierFilter *filter = new CaNotifierFilter();
       
   352         filter->setEntryRole(ItemEntryRole);
       
   353         filter->setTypeNames(QStringList() << "TypeName");
       
   354         filter->setIds(QList<int>() << entry->id());
       
   355         TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService, filter);
       
   356         CaNotifier *notifier = clientNotifier->getNotifier();
       
   357 
       
   358         connect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
   359         clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
   360         connect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)),
       
   361         clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType)));
       
   362         QTest::qWait(waitTime500ms);
       
   363 
       
   364         int entryId = entry->id();
       
   365         clientNotifier->mEntryId = 0;
       
   366 
       
   367         bool removed = mService->removeEntry(entryId);
       
   368         QTest::qWait(waitTime1sec);
       
   369 
       
   370         QCOMPARE(clientNotifier->mChangeType, RemoveChangeType);
       
   371         QVERIFY(clientNotifier->mEntryId > 0);
       
   372         QCOMPARE(clientNotifier->mEntryId, entryId);
       
   373         QCOMPARE(removed, TRUE);
       
   374 
       
   375         // cleanup
       
   376         disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
   377         clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
   378         disconnect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)),
       
   379         clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType)));
       
   380         QTest::qWait(waitTime500ms);
       
   381         delete clientNotifier;
       
   382         delete filter;
       
   383         mService->removeEntry(entry->id());
       
   384     }
       
   385 #ifdef Q_OS_SYMBIAN
       
   386 #ifdef UT_MEMORY_CHECK
       
   387 // __UHEAP_MARKEND;
       
   388 #endif//UT_MEMORY_CHECK
       
   389 #endif//Q_OS_SYMBIAN
       
   390 }
       
   391 // ---------------------------------------------------------------------------
       
   392 //
       
   393 void TestCaClient::TestRemoveEntryChangeTypeNotifierFake()
       
   394 {
       
   395 #ifdef Q_OS_SYMBIAN
       
   396 #ifdef UT_MEMORY_CHECK
       
   397 // __UHEAP_MARK;
       
   398 #endif//UT_MEMORY_CHECK
       
   399 #endif//Q_OS_SYMBIAN
       
   400     {
       
   401 
       
   402         TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService);
       
   403         CaNotifier *notifier = clientNotifier->getNotifier();
       
   404 
       
   405         connect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
   406         clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
   407         connect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)),
       
   408         clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType)));
       
   409         QTest::qWait(waitTime500ms);
       
   410         CaEntry item;
       
   411         item.setText("Text");
       
   412         item.setEntryTypeName("TypeName");
       
   413 
       
   414         QSharedPointer<CaEntry> entry = mService->createEntry(item);
       
   415         QTest::qWait(waitTime1sec);
       
   416 
       
   417         QCOMPARE(clientNotifier->mChangeType, AddChangeType);
       
   418         QVERIFY(clientNotifier->mEntryId > 0);
       
   419         QCOMPARE(clientNotifier->mEntryId, entry->id());
       
   420 
       
   421         clientNotifier->mEntryId = 0;
       
   422         CaEntry *entryFake = new CaEntry();
       
   423         entryFake->setText("Text");
       
   424         entryFake->setEntryTypeName("TypeName");
       
   425 
       
   426         bool removed = mService->removeEntry(*entryFake);
       
   427 
       
   428         QCOMPARE(clientNotifier->mChangeType, AddChangeType);
       
   429         QCOMPARE(clientNotifier->mEntryId, 0);
       
   430         QCOMPARE(removed, FALSE);
       
   431 
       
   432         // cleanup
       
   433         disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
   434         clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
   435         disconnect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)),
       
   436         clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType)));
       
   437         QTest::qWait(waitTime500ms);
       
   438         delete clientNotifier;
       
   439         mService->removeEntry(entry->id());
       
   440         delete entryFake;
       
   441     }
       
   442 #ifdef Q_OS_SYMBIAN
       
   443 #ifdef UT_MEMORY_CHECK
       
   444 // __UHEAP_MARKEND;
       
   445 #endif//UT_MEMORY_CHECK
       
   446 #endif//Q_OS_SYMBIAN
       
   447 }
       
   448 // ---------------------------------------------------------------------------
       
   449 //
       
   450 void TestCaClient::TestRemoveEntryIdChangeTypeNotifierFake()
       
   451 {
       
   452 #ifdef Q_OS_SYMBIAN
       
   453 #ifdef UT_MEMORY_CHECK
       
   454 // __UHEAP_MARK;
       
   455 #endif//UT_MEMORY_CHECK
       
   456 #endif//Q_OS_SYMBIAN
       
   457     {
       
   458 
       
   459         TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService);
       
   460         CaNotifier *notifier = clientNotifier->getNotifier();
       
   461 
       
   462         connect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
   463         clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
   464         connect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)),
       
   465         clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType)));
       
   466         QTest::qWait(waitTime500ms);
       
   467         CaEntry item;
       
   468         item.setText("Text");
       
   469         item.setEntryTypeName("TypeName");
       
   470         QSharedPointer<CaEntry> entry = mService->createEntry(item);
       
   471         QTest::qWait(waitTime1sec);
       
   472 
       
   473         QCOMPARE(clientNotifier->mChangeType, AddChangeType);
       
   474         QVERIFY(clientNotifier->mEntryId > 0);
       
   475         QCOMPARE(clientNotifier->mEntryId, entry->id());
       
   476 
       
   477         clientNotifier->mEntryId = 0;
       
   478         bool removed = mService->removeEntry(entryIdFake);
       
   479         QTest::qWait(waitTime1sec);
       
   480 
       
   481         QCOMPARE(clientNotifier->mChangeType, AddChangeType);
       
   482         QCOMPARE(clientNotifier->mEntryId, 0);
       
   483         QCOMPARE(removed, FALSE);
       
   484 
       
   485         // cleanup
       
   486         disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
   487         clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
   488         disconnect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)),
       
   489         clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType)));
       
   490         QTest::qWait(waitTime500ms);
       
   491         delete clientNotifier;
       
   492         mService->removeEntry(entry->id());
       
   493     }
       
   494 #ifdef Q_OS_SYMBIAN
       
   495 #ifdef UT_MEMORY_CHECK
       
   496 // __UHEAP_MARKEND;
       
   497 #endif//UT_MEMORY_CHECK
       
   498 #endif//Q_OS_SYMBIAN
       
   499 }
       
   500 // ---------------------------------------------------------------------------
       
   501 //
       
   502 void TestCaClient::TestRemoveEntriesChangeTypeNotifier()
       
   503 {
       
   504 #ifdef Q_OS_SYMBIAN
       
   505 #ifdef UT_MEMORY_CHECK
       
   506 // __UHEAP_MARK;
       
   507 #endif//UT_MEMORY_CHECK
       
   508 #endif//Q_OS_SYMBIAN
       
   509     {
       
   510 
       
   511 
       
   512         CaEntry item1;
       
   513         item1.setText("Text");
       
   514         item1.setEntryTypeName("TypeName");
       
   515         QSharedPointer<CaEntry> entry1 = mService->createEntry(item1);
       
   516         QTest::qWait(waitTime1sec);
       
   517         CaEntry item2;
       
   518         item2.setText("Text");
       
   519         item2.setEntryTypeName("TypeName");
       
   520         QSharedPointer<CaEntry> entry2 = mService->createEntry(item2);
       
   521         QTest::qWait(waitTime1sec);
       
   522         CaEntry item3;
       
   523         item3.setText("Text");
       
   524         item3.setEntryTypeName("TypeName");
       
   525         QSharedPointer<CaEntry> entry3 = mService->createEntry(item3);
       
   526         QTest::qWait(waitTime1sec);
       
   527         CaEntry item4;
       
   528         item4.setText("Text");
       
   529         item4.setEntryTypeName("TypeName");
       
   530         QSharedPointer<CaEntry> entry4 = mService->createEntry(item4);
       
   531         QTest::qWait(waitTime1sec);
       
   532 
       
   533         QList< QSharedPointer<CaEntry> > entriesList;
       
   534         entriesList.append(entry1);
       
   535         entriesList.append(entry2);
       
   536         entriesList.append(entry3);
       
   537         entriesList.append(entry4);
       
   538 
       
   539         CaNotifierFilter *filter = new CaNotifierFilter();
       
   540         filter->setEntryRole(ItemEntryRole);
       
   541         filter->setTypeNames(QStringList() << "TypeName");
       
   542         filter->setIds(QList<int>() << entry2->id() << entry3->id());
       
   543         TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService, filter);
       
   544         CaNotifier *notifier = clientNotifier->getNotifier();
       
   545 
       
   546         connect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)),
       
   547         clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType)));
       
   548         connect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
   549         clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
   550         QTest::qWait(waitTime500ms);
       
   551 
       
   552         clientNotifier->mEntryId = 0;
       
   553 
       
   554         bool removed = mService->removeEntries(entriesList);
       
   555         QTest::qWait(waitTime1sec);
       
   556 
       
   557         QCOMPARE(clientNotifier->mChangeType, RemoveChangeType);
       
   558         QVERIFY(clientNotifier->mEntryId > 0);
       
   559         QCOMPARE(clientNotifier->mEntryId, entry3->id());
       
   560         QCOMPARE(removed, TRUE);
       
   561 
       
   562         // cleanup
       
   563         disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
   564         clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
   565         disconnect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)),
       
   566         clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType)));
       
   567         QTest::qWait(waitTime500ms);
       
   568         delete clientNotifier;
       
   569         delete filter;
       
   570         mService->removeEntries(entriesList);
       
   571         QTest::qWait(waitTime500ms);
       
   572         entriesList.clear();
       
   573     }
       
   574 #ifdef Q_OS_SYMBIAN
       
   575 #ifdef UT_MEMORY_CHECK
       
   576 // __UHEAP_MARKEND;
       
   577 #endif//UT_MEMORY_CHECK
       
   578 #endif//Q_OS_SYMBIAN
       
   579 }
       
   580 // ---------------------------------------------------------------------------
       
   581 //
       
   582 void TestCaClient::TestRemoveEntriesIdsChangeTypeNotifier()
       
   583 {
       
   584 #ifdef Q_OS_SYMBIAN
       
   585 #ifdef UT_MEMORY_CHECK
       
   586 // __UHEAP_MARK;
       
   587 #endif//UT_MEMORY_CHECK
       
   588 #endif//Q_OS_SYMBIAN
       
   589     {
       
   590 
       
   591         TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService);
       
   592         CaNotifier *notifier = clientNotifier->getNotifier();
       
   593 
       
   594         connect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
   595         clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
   596         connect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)),
       
   597         clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType)));
       
   598         QTest::qWait(waitTime500ms);
       
   599         CaEntry item1;
       
   600         item1.setText("Text");
       
   601         item1.setEntryTypeName("TypeName");
       
   602         QSharedPointer<CaEntry> entry1 = mService->createEntry(item1);
       
   603         QTest::qWait(waitTime1sec);
       
   604         CaEntry item2;
       
   605         item2.setText("Text");
       
   606         item2.setEntryTypeName("TypeName");
       
   607         QSharedPointer<CaEntry> entry2 = mService->createEntry(item2);
       
   608         QTest::qWait(waitTime1sec);
       
   609         CaEntry item3;
       
   610         item3.setText("Text");
       
   611         item3.setEntryTypeName("TypeName");
       
   612         QSharedPointer<CaEntry> entry3 = mService->createEntry(item3);
       
   613         QTest::qWait(waitTime1sec);
       
   614         CaEntry item4;
       
   615         item4.setText("Text");
       
   616         item4.setEntryTypeName("TypeName");
       
   617         QSharedPointer<CaEntry> entry4 = mService->createEntry(item4);
       
   618         QTest::qWait(waitTime1sec);
       
   619 
       
   620         QList<int> entriesIdsList;
       
   621         entriesIdsList.append(entry1->id());
       
   622         entriesIdsList.append(entry2->id());
       
   623         entriesIdsList.append(entry3->id());
       
   624         entriesIdsList.append(entry4->id());
       
   625 
       
   626         clientNotifier->mEntryId = 0;
       
   627 
       
   628         bool removed = mService->removeEntries(entriesIdsList);
       
   629         QTest::qWait(waitTime1sec);
       
   630 
       
   631         QCOMPARE(clientNotifier->mChangeType, RemoveChangeType);
       
   632         QVERIFY(clientNotifier->mEntryId > 0);
       
   633         QCOMPARE(clientNotifier->mEntryId, entry4->id());
       
   634         QCOMPARE(removed, TRUE);
       
   635 
       
   636         // cleanup
       
   637         disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
   638         clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
   639         disconnect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)),
       
   640         clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType)));
       
   641         QTest::qWait(waitTime500ms);
       
   642         delete clientNotifier;
       
   643         mService->removeEntries(entriesIdsList);
       
   644         QTest::qWait(waitTime500ms);
       
   645         entriesIdsList.clear();
       
   646     }
       
   647 #ifdef Q_OS_SYMBIAN
       
   648 #ifdef UT_MEMORY_CHECK
       
   649 // __UHEAP_MARKEND;
       
   650 #endif//UT_MEMORY_CHECK
       
   651 #endif//Q_OS_SYMBIAN
       
   652 }
       
   653 // ---------------------------------------------------------------------------
       
   654 //
       
   655 void TestCaClient::TestRemoveEntriesChangeTypeNotifierFake()
       
   656 {
       
   657 #ifdef Q_OS_SYMBIAN
       
   658 #ifdef UT_MEMORY_CHECK
       
   659 // __UHEAP_MARK;
       
   660 #endif//UT_MEMORY_CHECK
       
   661 #endif//Q_OS_SYMBIAN
       
   662     {
       
   663 
       
   664         TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService);
       
   665         CaNotifier *notifier = clientNotifier->getNotifier();
       
   666 
       
   667         connect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
   668         clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
   669         connect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)),
       
   670         clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType)));
       
   671         QTest::qWait(waitTime500ms);
       
   672         CaEntry item1;
       
   673         item1.setText("Text");
       
   674         item1.setEntryTypeName("TypeName");
       
   675         QSharedPointer<CaEntry> entry1 = mService->createEntry(item1);
       
   676         QTest::qWait(waitTime1sec);
       
   677         CaEntry item2;
       
   678         item2.setText("Text");
       
   679         item2.setEntryTypeName("TypeName");
       
   680         QSharedPointer<CaEntry> entry2 = mService->createEntry(item2);
       
   681         QTest::qWait(waitTime1sec);
       
   682         CaEntry item3;
       
   683         item3.setText("Text");
       
   684         item3.setEntryTypeName("TypeName");
       
   685         QSharedPointer<CaEntry> entry3 = mService->createEntry(item3);
       
   686         QTest::qWait(waitTime1sec);
       
   687         CaEntry item4;
       
   688         item4.setText("Text");
       
   689         item4.setEntryTypeName("TypeName");
       
   690         QSharedPointer<CaEntry> entry4 = mService->createEntry(item4);
       
   691         QTest::qWait(waitTime1sec);
       
   692 
       
   693         QList<QSharedPointer<CaEntry> > entriesList;
       
   694         entriesList.append(entry1);
       
   695         entriesList.append(entry2);
       
   696         entriesList.append(entry3);
       
   697         entriesList.append(entry4);
       
   698 
       
   699         clientNotifier->mEntryId = 0;
       
   700 
       
   701         CaEntry itemFake1;
       
   702         itemFake1.setText("Text");
       
   703         itemFake1.setEntryTypeName("TypeName");
       
   704         QSharedPointer<CaEntry> entryFake1 = mService->createEntry(itemFake1);
       
   705         int entryFake1Id = entryFake1->id();
       
   706         entryFake1->setId(entryIdFake);
       
   707         QTest::qWait(waitTime1sec);
       
   708         CaEntry itemFake2;
       
   709         itemFake2.setText("Text");
       
   710         itemFake2.setEntryTypeName("TypeName");
       
   711         QSharedPointer<CaEntry> entryFake2 = mService->createEntry(itemFake2);
       
   712         int entryFake2Id = entryFake2->id();
       
   713         entryFake2->setId(entryIdFake);
       
   714         QTest::qWait(waitTime1sec);
       
   715         QList<QSharedPointer<CaEntry> > entriesListFake;
       
   716         entriesListFake.append(entryFake1);
       
   717         entriesListFake.append(entryFake2);
       
   718 
       
   719         clientNotifier->mEntryId = 0;
       
   720         clientNotifier->mChangeType = AddChangeType;
       
   721 
       
   722         bool removed = mService->removeEntries(entriesListFake);
       
   723         QTest::qWait(waitTime1sec);
       
   724 
       
   725         QCOMPARE(clientNotifier->mChangeType, AddChangeType);
       
   726         QCOMPARE(clientNotifier->mEntryId, 0);
       
   727         QCOMPARE(removed, FALSE);
       
   728 
       
   729         entryFake1->setId(entryFake1Id);
       
   730         entryFake2->setId(entryFake2Id);
       
   731 
       
   732         // cleanup
       
   733         disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
   734         clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
   735         disconnect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)),
       
   736         clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType)));
       
   737         QTest::qWait(waitTime500ms);
       
   738         delete clientNotifier;
       
   739         mService->removeEntries(entriesList);
       
   740         mService->removeEntries(entriesListFake);
       
   741         QTest::qWait(waitTime500ms);
       
   742         entriesList.clear();
       
   743         entriesListFake.clear();
       
   744     }
       
   745 #ifdef Q_OS_SYMBIAN
       
   746 #ifdef UT_MEMORY_CHECK
       
   747 // __UHEAP_MARKEND;
       
   748 #endif//UT_MEMORY_CHECK
       
   749 #endif//Q_OS_SYMBIAN
       
   750 }
       
   751 // ---------------------------------------------------------------------------
       
   752 //
       
   753 void TestCaClient::TestRemoveEntriesIdsChangeTypeNotifierFake()
       
   754 {
       
   755 #ifdef Q_OS_SYMBIAN
       
   756 #ifdef UT_MEMORY_CHECK
       
   757 // __UHEAP_MARK;
       
   758 #endif//UT_MEMORY_CHECK
       
   759 #endif//Q_OS_SYMBIAN
       
   760 
       
   761     TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService);
       
   762     CaNotifier *notifier = clientNotifier->getNotifier();
       
   763 
       
   764     connect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
   765             clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
   766     connect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)),
       
   767             clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType)));
       
   768     QTest::qWait(waitTime500ms);
       
   769     CaEntry item1;
       
   770     item1.setText("Text");
       
   771     item1.setEntryTypeName("TypeName");
       
   772     QSharedPointer<CaEntry> entry1 = mService->createEntry(item1);
       
   773     QTest::qWait(waitTime1sec);
       
   774     CaEntry item2;
       
   775     item2.setText("Text");
       
   776     item2.setEntryTypeName("TypeName");
       
   777     QSharedPointer<CaEntry> entry2 = mService->createEntry(item2);
       
   778     QTest::qWait(waitTime1sec);
       
   779     CaEntry item3;
       
   780     item3.setText("Text");
       
   781     item3.setEntryTypeName("TypeName");
       
   782     QSharedPointer<CaEntry> entry3 = mService->createEntry(item3);
       
   783     QTest::qWait(waitTime1sec);
       
   784     CaEntry item4;
       
   785     item4.setText("Text");
       
   786     item4.setEntryTypeName("TypeName");
       
   787     QSharedPointer<CaEntry> entry4 = mService->createEntry(item4);
       
   788     QTest::qWait(waitTime1sec);
       
   789 
       
   790     QList<int> entriesIdsList;
       
   791     entriesIdsList.append(entry1->id());
       
   792     entriesIdsList.append(entry2->id());
       
   793     entriesIdsList.append(entry3->id());
       
   794     entriesIdsList.append(entry4->id());
       
   795 
       
   796     CaEntry itemFake1;
       
   797     itemFake1.setText("Text");
       
   798     itemFake1.setEntryTypeName("TypeName");
       
   799     QSharedPointer<CaEntry> entryFake1 = mService->createEntry(itemFake1);
       
   800     int entryFake1Id = entryFake1->id();
       
   801     entryFake1->setId(entryIdFake);
       
   802     QTest::qWait(waitTime1sec);
       
   803     CaEntry itemFake2;
       
   804     itemFake2.setText("Text");
       
   805     itemFake2.setEntryTypeName("TypeName");
       
   806     QSharedPointer<CaEntry> entryFake2 = mService->createEntry(itemFake2);
       
   807     int entryFake2Id = entryFake2->id();
       
   808     entryFake2->setId(entryIdFake);
       
   809     QTest::qWait(waitTime1sec);
       
   810     QList<int> entriesIdsListFake;
       
   811     entriesIdsListFake.append(entryFake1->id());
       
   812     entriesIdsListFake.append(entryFake2->id());
       
   813 
       
   814     clientNotifier->mEntryId = 0;
       
   815     clientNotifier->mChangeType = AddChangeType;
       
   816 
       
   817     bool removed = mService->removeEntries(entriesIdsListFake);
       
   818     QTest::qWait(waitTime1sec);
       
   819 
       
   820     QCOMPARE(clientNotifier->mChangeType, AddChangeType);
       
   821     QCOMPARE(clientNotifier->mEntryId, 0);
       
   822     QCOMPARE(removed, FALSE);
       
   823 
       
   824     entryFake1->setId(entryFake1Id);
       
   825     entryFake2->setId(entryFake2Id);
       
   826 
       
   827     // cleanup
       
   828     disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
   829                clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
   830     disconnect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)),
       
   831                clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType)));
       
   832     QTest::qWait(waitTime500ms);
       
   833     delete clientNotifier;
       
   834     mService->removeEntries(entriesIdsList);
       
   835     mService->removeEntry(*entryFake1);
       
   836     mService->removeEntry(*entryFake2);
       
   837     QTest::qWait(waitTime1sec);
       
   838     entriesIdsList.clear();
       
   839     entriesIdsListFake.clear();
       
   840 
       
   841 #ifdef Q_OS_SYMBIAN
       
   842 #ifdef UT_MEMORY_CHECK
       
   843 // __UHEAP_MARKEND;
       
   844 #endif//UT_MEMORY_CHECK
       
   845 #endif//Q_OS_SYMBIAN
       
   846 }
       
   847 // ---------------------------------------------------------------------------
       
   848 //
       
   849 void TestCaClient::TestRemoveGroupChangeTypeNotifier()
       
   850 {
       
   851 #ifdef Q_OS_SYMBIAN
       
   852 #ifdef UT_MEMORY_CHECK
       
   853 // __UHEAP_MARK;
       
   854 #endif//UT_MEMORY_CHECK
       
   855 #endif//Q_OS_SYMBIAN
       
   856 
       
   857 
       
   858     TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService);
       
   859     CaNotifier *notifier = clientNotifier->getNotifier();
       
   860 
       
   861     connect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
   862             clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
   863     connect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)),
       
   864             clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType)));
       
   865     QTest::qWait(waitTime500ms);
       
   866     CaEntry group(GroupEntryRole);
       
   867     group.setText("Text");
       
   868     group.setEntryTypeName("TypeName");
       
   869     QSharedPointer<CaEntry> entry = mService->createEntry(group);
       
   870     QTest::qWait(waitTime1sec);
       
   871 
       
   872     QCOMPARE(clientNotifier->mChangeType, AddChangeType);
       
   873     QVERIFY(clientNotifier->mEntryId > 0);
       
   874     QCOMPARE(clientNotifier->mEntryId, entry->id());
       
   875 
       
   876     int entryId = clientNotifier->mEntryId;
       
   877     clientNotifier->mEntryId = 0;
       
   878 
       
   879     bool removed = mService->removeEntry(*entry);
       
   880     QTest::qWait(waitTime1sec);
       
   881 
       
   882     QCOMPARE(clientNotifier->mChangeType, RemoveChangeType);
       
   883     QVERIFY(clientNotifier->mEntryId > 0);
       
   884     QCOMPARE(clientNotifier->mEntryId, entryId);
       
   885     QCOMPARE(removed, TRUE);
       
   886 
       
   887     // cleanup
       
   888     disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
   889                clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
   890     disconnect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)),
       
   891                clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType)));
       
   892     QTest::qWait(waitTime500ms);
       
   893     delete clientNotifier;
       
   894     mService->removeEntry(entry->id());
       
   895     QTest::qWait(waitTime1sec);
       
   896 
       
   897 #ifdef Q_OS_SYMBIAN
       
   898 #ifdef UT_MEMORY_CHECK
       
   899 // __UHEAP_MARKEND;
       
   900 #endif//UT_MEMORY_CHECK
       
   901 #endif//Q_OS_SYMBIAN
       
   902 }
       
   903 // ---------------------------------------------------------------------------
       
   904 //
       
   905 void TestCaClient::TestRemoveGroupsChangeTypeNotifier()
       
   906 {
       
   907 #ifdef Q_OS_SYMBIAN
       
   908 #ifdef UT_MEMORY_CHECK
       
   909 // __UHEAP_MARK;
       
   910 #endif//UT_MEMORY_CHECK
       
   911 #endif//Q_OS_SYMBIAN
       
   912 
       
   913 
       
   914 
       
   915     CaEntry group1(GroupEntryRole);
       
   916     group1.setText("Text");
       
   917     group1.setEntryTypeName("TypeName1");
       
   918     QSharedPointer<CaEntry> entry1 = mService->createEntry(group1);
       
   919     QTest::qWait(waitTime1sec);
       
   920     CaEntry group2(GroupEntryRole);
       
   921     group2.setText("Text");
       
   922     group2.setEntryTypeName("TypeName2");
       
   923     QSharedPointer<CaEntry> entry2 = mService->createEntry(group2);
       
   924     QTest::qWait(waitTime1sec);
       
   925     CaEntry group3(GroupEntryRole);
       
   926     group3.setText("Text");
       
   927     group3.setEntryTypeName("TypeName3");
       
   928     QSharedPointer<CaEntry> entry3 = mService->createEntry(group3);
       
   929     QTest::qWait(waitTime1sec);
       
   930     CaEntry group4(GroupEntryRole);
       
   931     group4.setText("Text");
       
   932     group4.setEntryTypeName("TypeName4");
       
   933     QSharedPointer<CaEntry> entry4 = mService->createEntry(group4);
       
   934     QTest::qWait(waitTime1sec);
       
   935 
       
   936     QList< QSharedPointer<CaEntry> > entriesList;
       
   937     entriesList.append(entry1);
       
   938     entriesList.append(entry2);
       
   939     entriesList.append(entry3);
       
   940     entriesList.append(entry4);
       
   941 
       
   942     CaNotifierFilter *filter = new CaNotifierFilter();
       
   943     filter->setEntryRole(GroupEntryRole);
       
   944     filter->setTypeNames(QStringList() << "TypeName3" << "TypeName4");
       
   945     filter->setIds(QList<int>() << entry3->id());
       
   946     TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService, filter);
       
   947     CaNotifier *notifier = clientNotifier->getNotifier();
       
   948 
       
   949     connect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
   950             clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
   951     connect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)),
       
   952             clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType)));
       
   953     QTest::qWait(waitTime500ms);
       
   954 
       
   955     clientNotifier->mEntryId = 0;
       
   956 
       
   957     bool removed = mService->removeEntries(entriesList);
       
   958     QTest::qWait(waitTime1sec);
       
   959 
       
   960     QCOMPARE(clientNotifier->mChangeType, RemoveChangeType);
       
   961     QVERIFY(clientNotifier->mEntryId > 0);
       
   962     QCOMPARE(clientNotifier->mEntryId, entry3->id());
       
   963     QCOMPARE(removed, TRUE);
       
   964 
       
   965     // cleanup
       
   966     disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
   967                clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
   968     disconnect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)),
       
   969                clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType)));
       
   970     QTest::qWait(waitTime500ms);
       
   971     delete clientNotifier;
       
   972     delete filter;
       
   973     mService->removeEntries(entriesList);
       
   974     QTest::qWait(waitTime1sec);
       
   975     entriesList.clear();
       
   976 
       
   977 #ifdef Q_OS_SYMBIAN
       
   978 #ifdef UT_MEMORY_CHECK
       
   979 // __UHEAP_MARK;
       
   980 #endif//UT_MEMORY_CHECK
       
   981 #endif//Q_OS_SYMBIAN
       
   982 }
       
   983 // ---------------------------------------------------------------------------
       
   984 // ---------------------------------------------------------------------------
       
   985 //
       
   986 void TestCaClient::TestUpdateChangeTypeNotifier()
       
   987 {
       
   988 #ifdef Q_OS_SYMBIAN
       
   989 #ifdef UT_MEMORY_CHECK
       
   990 // __UHEAP_MARK;
       
   991 #endif//UT_MEMORY_CHECK
       
   992 #endif//Q_OS_SYMBIAN
       
   993 
       
   994 
       
   995     TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService);
       
   996     CaNotifier *notifier = clientNotifier->getNotifier();
       
   997 
       
   998     connect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
   999             clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
  1000     connect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)),
       
  1001             clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType)));
       
  1002     QTest::qWait(waitTime500ms);
       
  1003 
       
  1004     CaEntry item;
       
  1005     item.setText("Text");
       
  1006     item.setEntryTypeName("TypeName");
       
  1007     item.setDescription("description");
       
  1008 
       
  1009     QSharedPointer<CaEntry> entry = mService->createEntry(item);
       
  1010 
       
  1011     QTest::qWait(waitTime1sec);
       
  1012 
       
  1013     QCOMPARE(clientNotifier->mChangeType, AddChangeType);
       
  1014     QVERIFY(clientNotifier->mEntryId > 0);
       
  1015     QCOMPARE(clientNotifier->mEntryId, entry->id());
       
  1016 
       
  1017     disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
  1018                clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
  1019     disconnect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)),
       
  1020                clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType)));
       
  1021     QTest::qWait(waitTime500ms);
       
  1022     int entryId = clientNotifier->mEntryId;
       
  1023     delete clientNotifier;
       
  1024 
       
  1025     CaNotifierFilter *filter = new CaNotifierFilter();
       
  1026     filter->setEntryRole(ItemEntryRole);
       
  1027     filter->setIds(QList<int>() << entry->id());
       
  1028     TestCaClientNotifier *clientNotifierUpdate = new TestCaClientNotifier(*mService, filter);
       
  1029     CaNotifier *notifierUpdate = clientNotifierUpdate->getNotifier();
       
  1030 
       
  1031     connect(notifierUpdate, SIGNAL(entryChanged(int,ChangeType)),
       
  1032             clientNotifierUpdate, SLOT(entryChanged(int,ChangeType)));
       
  1033     connect(notifierUpdate, SIGNAL(entryChanged(const CaEntry &,ChangeType)),
       
  1034             clientNotifierUpdate, SLOT(entryChanged(const CaEntry &,ChangeType)));
       
  1035     QTest::qWait(waitTime500ms);
       
  1036 
       
  1037     bool updated = mService->updateEntry(*entry);
       
  1038     QTest::qWait(waitTime1sec);
       
  1039 
       
  1040     QCOMPARE(clientNotifierUpdate->mChangeType, UpdateChangeType);
       
  1041     QVERIFY(clientNotifierUpdate->mEntryId > 0);
       
  1042     QCOMPARE(clientNotifierUpdate->mEntryId, entryId);
       
  1043     QCOMPARE(clientNotifierUpdate->mEntryId, entry->id());
       
  1044     QCOMPARE(clientNotifierUpdate->mEntry->description(), QString("description"));
       
  1045     QCOMPARE(updated, TRUE);
       
  1046 
       
  1047     // cleanup
       
  1048     disconnect(notifierUpdate, SIGNAL(entryChanged(int,ChangeType)),
       
  1049                clientNotifierUpdate, SLOT(entryChanged(int,ChangeType)));
       
  1050     disconnect(notifierUpdate, SIGNAL(entryChanged(const CaEntry &,ChangeType)),
       
  1051                clientNotifierUpdate, SLOT(entryChanged(const CaEntry &,ChangeType)));
       
  1052     QTest::qWait(waitTime500ms);
       
  1053 
       
  1054     delete clientNotifierUpdate;
       
  1055     delete filter;
       
  1056     mService->removeEntry(entry->id());
       
  1057     QTest::qWait(waitTime1sec);
       
  1058 
       
  1059 #ifdef Q_OS_SYMBIAN
       
  1060 #ifdef UT_MEMORY_CHECK
       
  1061 // __UHEAP_MARK;
       
  1062 #endif//UT_MEMORY_CHECK
       
  1063 #endif//Q_OS_SYMBIAN
       
  1064 }
       
  1065 // ---------------------------------------------------------------------------
       
  1066 //
       
  1067 void TestCaClient::TestUpdateChangeTypeNotifierFake()
       
  1068 {
       
  1069 #ifdef Q_OS_SYMBIAN
       
  1070 #ifdef UT_MEMORY_CHECK
       
  1071 // __UHEAP_MARK;
       
  1072 #endif//UT_MEMORY_CHECK
       
  1073 #endif//Q_OS_SYMBIAN
       
  1074 
       
  1075 
       
  1076     TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService);
       
  1077     CaNotifier *notifier = clientNotifier->getNotifier();
       
  1078 
       
  1079     connect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
  1080             clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
  1081     connect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)),
       
  1082             clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType)));
       
  1083 
       
  1084     QTest::qWait(waitTime500ms);
       
  1085     CaEntry item;
       
  1086     item.setText("Text");
       
  1087     item.setEntryTypeName("TypeName");
       
  1088     QSharedPointer<CaEntry> entry = mService->createEntry(item);
       
  1089     QTest::qWait(waitTime1sec);
       
  1090 
       
  1091     QCOMPARE(clientNotifier->mChangeType, AddChangeType);
       
  1092     QVERIFY(clientNotifier->mEntryId > 0);
       
  1093     QCOMPARE(clientNotifier->mEntryId, entry->id());
       
  1094 
       
  1095 
       
  1096     int entryId = clientNotifier->mEntryId;
       
  1097     clientNotifier->mEntryId = 0;
       
  1098     CaEntry itemFake;
       
  1099     itemFake.setText("Text");
       
  1100     itemFake.setEntryTypeName("TypeName");
       
  1101 
       
  1102     bool updated = mService->updateEntry(itemFake);
       
  1103     QTest::qWait(waitTime1sec);
       
  1104 
       
  1105     QCOMPARE(clientNotifier->mChangeType, AddChangeType);
       
  1106     QCOMPARE(clientNotifier->mEntryId, 0);
       
  1107     QCOMPARE(updated, FALSE);
       
  1108 
       
  1109     // cleanup
       
  1110     disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
  1111                clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
  1112     disconnect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)),
       
  1113                clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType)));
       
  1114     QTest::qWait(waitTime500ms);
       
  1115     delete clientNotifier;
       
  1116     mService->removeEntry(entry->id());
       
  1117     QTest::qWait(waitTime1sec);
       
  1118 
       
  1119 #ifdef Q_OS_SYMBIAN
       
  1120 #ifdef UT_MEMORY_CHECK
       
  1121 // __UHEAP_MARKEND;
       
  1122 #endif//UT_MEMORY_CHECK
       
  1123 #endif//Q_OS_SYMBIAN
       
  1124 }
       
  1125 // ---------------------------------------------------------------------------
       
  1126 //
       
  1127 void TestCaClient::TestAddUpdateRemove()
       
  1128 {
       
  1129 #ifdef Q_OS_SYMBIAN
       
  1130 #ifdef UT_MEMORY_CHECK
       
  1131 // __UHEAP_MARK;
       
  1132 #endif//UT_MEMORY_CHECK
       
  1133 #endif//Q_OS_SYMBIAN
       
  1134 
       
  1135 
       
  1136     TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService);
       
  1137     CaNotifier *notifier = clientNotifier->getNotifier();
       
  1138 
       
  1139     connect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
  1140             clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
  1141     connect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)),
       
  1142             clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType)));
       
  1143     QTest::qWait(waitTime500ms);
       
  1144 
       
  1145     CaEntry item;
       
  1146     item.setText("Text");
       
  1147     item.setEntryTypeName("TypeName");
       
  1148     QSharedPointer<CaEntry> entry = mService->createEntry(item);
       
  1149     QTest::qWait(waitTime1sec);
       
  1150 
       
  1151     QCOMPARE(clientNotifier->mChangeType, AddChangeType);
       
  1152     QVERIFY(clientNotifier->mEntryId > 0);
       
  1153     QCOMPARE(clientNotifier->mEntryId, entry->id());
       
  1154 
       
  1155 
       
  1156     int entryId = clientNotifier->mEntryId;
       
  1157     clientNotifier->mEntryId = 0;
       
  1158 
       
  1159     bool updated = mService->updateEntry(*entry);
       
  1160     QTest::qWait(waitTime1sec);
       
  1161 
       
  1162     QCOMPARE(clientNotifier->mChangeType, UpdateChangeType);
       
  1163     QVERIFY(clientNotifier->mEntryId > 0);
       
  1164     QCOMPARE(clientNotifier->mEntryId, entry->id());
       
  1165     QCOMPARE(updated, TRUE);
       
  1166 
       
  1167     entryId = clientNotifier->mEntryId;
       
  1168     clientNotifier->mEntryId = 0;
       
  1169 
       
  1170     bool removed = mService->removeEntry(entryId);
       
  1171     QTest::qWait(waitTime1sec);
       
  1172 
       
  1173     QCOMPARE(clientNotifier->mChangeType, RemoveChangeType);
       
  1174     QVERIFY(clientNotifier->mEntryId > 0);
       
  1175     QCOMPARE(removed, TRUE);
       
  1176 
       
  1177     // cleanup
       
  1178     disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
  1179                clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
  1180     disconnect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)),
       
  1181                clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType)));
       
  1182     QTest::qWait(waitTime500ms);
       
  1183     delete clientNotifier;
       
  1184     mService->removeEntry(entry->id());
       
  1185     QTest::qWait(waitTime1sec);
       
  1186 
       
  1187 #ifdef Q_OS_SYMBIAN
       
  1188 #ifdef UT_MEMORY_CHECK
       
  1189 // __UHEAP_MARKEND;
       
  1190 #endif//UT_MEMORY_CHECK
       
  1191 #endif//Q_OS_SYMBIAN
       
  1192 }
       
  1193 // ---------------------------------------------------------------------------
       
  1194 //
       
  1195 void TestCaClient::TestRegisterNotifier()
       
  1196 {
       
  1197 #ifdef Q_OS_SYMBIAN
       
  1198 #ifdef UT_MEMORY_CHECK
       
  1199 // __UHEAP_MARK;
       
  1200 #endif//UT_MEMORY_CHECK
       
  1201 #endif//Q_OS_SYMBIAN
       
  1202 
       
  1203 
       
  1204     TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService);
       
  1205     CaNotifier *notifier = clientNotifier->getNotifier();
       
  1206 
       
  1207     connect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
  1208             clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
  1209     connect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)),
       
  1210             clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType)));
       
  1211     connect(notifier, SIGNAL(entryTouched(int)),
       
  1212             clientNotifier, SLOT(entryTouched(int)));
       
  1213     connect(notifier, SIGNAL(groupContentChanged(int)),
       
  1214             clientNotifier, SLOT(groupContentChanged(int)));
       
  1215     QTest::qWait(waitTime1sec);
       
  1216     QCOMPARE(notifier->receivers(SIGNAL(entryChanged(int,ChangeType))), 1);
       
  1217     QCOMPARE(notifier->receivers(SIGNAL(entryChanged(CaEntry,ChangeType))), 1);
       
  1218     QCOMPARE(notifier->receivers(SIGNAL(entryTouched(int))), 1);
       
  1219     QCOMPARE(notifier->receivers(SIGNAL(groupContentChanged(int))), 1);
       
  1220 
       
  1221     // cleanup
       
  1222     disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
  1223                clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
  1224     disconnect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)),
       
  1225                clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType)));
       
  1226     disconnect(notifier, SIGNAL(entryTouched(int)),
       
  1227                clientNotifier, SLOT(entryTouched(int)));
       
  1228     disconnect(notifier, SIGNAL(groupContentChanged(int)),
       
  1229                clientNotifier, SLOT(groupContentChanged(int)));
       
  1230     QTest::qWait(waitTime1sec);
       
  1231 
       
  1232     QCOMPARE(notifier->receivers(SIGNAL(entryChanged(int,ChangeType))), 0);
       
  1233     QCOMPARE(notifier->receivers(SIGNAL(entryChanged(CaEntry,ChangeType))), 0);
       
  1234     QCOMPARE(notifier->receivers(SIGNAL(entryTouched(int))), 0);
       
  1235     QCOMPARE(notifier->receivers(SIGNAL(groupContentChanged(int))), 0);
       
  1236 
       
  1237     delete clientNotifier;
       
  1238 
       
  1239 #ifdef Q_OS_SYMBIAN
       
  1240 #ifdef UT_MEMORY_CHECK
       
  1241 // __UHEAP_MARKEND;
       
  1242 #endif//UT_MEMORY_CHECK
       
  1243 #endif//Q_OS_SYMBIAN
       
  1244 }
       
  1245 // ---------------------------------------------------------------------------
       
  1246 //
       
  1247 void TestCaClient::TestUnregisterNotifier()
       
  1248 {
       
  1249 #ifdef Q_OS_SYMBIAN
       
  1250 #ifdef UT_MEMORY_CHECK
       
  1251 // __UHEAP_MARK;
       
  1252 #endif//UT_MEMORY_CHECK
       
  1253 #endif//Q_OS_SYMBIAN
       
  1254 
       
  1255     TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService);
       
  1256     CaNotifier *notifier = clientNotifier->getNotifier();
       
  1257 
       
  1258     connect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
  1259             clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
  1260     connect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)),
       
  1261             clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType)));
       
  1262     connect(notifier, SIGNAL(entryTouched(int)),
       
  1263             clientNotifier, SLOT(entryTouched(int)));
       
  1264     QTest::qWait(waitTime500ms);
       
  1265     disconnect(notifier, SIGNAL(entryTouched(int)),
       
  1266                clientNotifier, SLOT(entryTouched(int)));
       
  1267     connect(notifier, SIGNAL(entryTouched(int)),
       
  1268             clientNotifier, SLOT(entryTouched(int)));
       
  1269     connect(notifier, SIGNAL(groupContentChanged(int)),
       
  1270             clientNotifier, SLOT(groupContentChanged(int)));
       
  1271     connect(notifier, SIGNAL(groupContentChanged(int)),
       
  1272             clientNotifier, SLOT(groupContentChanged(int)));
       
  1273     QTest::qWait(waitTime500ms);
       
  1274     disconnect(notifier, SIGNAL(groupContentChanged(int)),
       
  1275                clientNotifier, SLOT(groupContentChanged(int)));
       
  1276     QTest::qWait(waitTime500ms);
       
  1277     connect(notifier, SIGNAL(groupContentChanged(int)),
       
  1278             clientNotifier, SLOT(groupContentChanged(int)));
       
  1279     QTest::qWait(waitTime500ms);
       
  1280 
       
  1281     QCOMPARE(notifier->receivers(SIGNAL(entryChanged(int,ChangeType))), 1);
       
  1282     QCOMPARE(notifier->receivers(SIGNAL(entryChanged(CaEntry,ChangeType))), 1);
       
  1283     QCOMPARE(notifier->receivers(SIGNAL(entryTouched(int))), 1);
       
  1284     QCOMPARE(notifier->receivers(SIGNAL(groupContentChanged(int))), 1);
       
  1285 
       
  1286     disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
  1287                clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
  1288     disconnect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)),
       
  1289                clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType)));
       
  1290     disconnect(notifier, SIGNAL(entryTouched(int)),
       
  1291                clientNotifier, SLOT(entryTouched(int)));
       
  1292     disconnect(notifier, SIGNAL(groupContentChanged(int)),
       
  1293                clientNotifier, SLOT(groupContentChanged(int)));
       
  1294     connect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
  1295             clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
  1296     disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
  1297                clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
  1298     disconnect(notifier, SIGNAL(groupContentChanged(int)),
       
  1299                clientNotifier, SLOT(groupContentChanged(int)));
       
  1300     QTest::qWait(waitTime1sec);
       
  1301 
       
  1302     QCOMPARE(notifier->receivers(SIGNAL(entryChanged(int,ChangeType))), 0);
       
  1303     QCOMPARE(notifier->receivers(SIGNAL(entryChanged(CaEntry,ChangeType))), 0);
       
  1304     QCOMPARE(notifier->receivers(SIGNAL(entryTouched(int))), 0);
       
  1305     QCOMPARE(notifier->receivers(SIGNAL(groupContentChanged(int))), 0);
       
  1306 
       
  1307     delete clientNotifier;
       
  1308     QTest::qWait(waitTime500ms);
       
  1309 
       
  1310 #ifdef Q_OS_SYMBIAN
       
  1311 #ifdef UT_MEMORY_CHECK
       
  1312 // __UHEAP_MARKEND;
       
  1313 #endif//UT_MEMORY_CHECK
       
  1314 #endif//Q_OS_SYMBIAN
       
  1315 }
       
  1316 // ---------------------------------------------------------------------------
       
  1317 //
       
  1318 void TestCaClient::TestTouchEntryNotifier()
       
  1319 {
       
  1320 #ifdef Q_OS_SYMBIAN
       
  1321 #ifdef UT_MEMORY_CHECK
       
  1322 // __UHEAP_MARK;
       
  1323 #endif//UT_MEMORY_CHECK
       
  1324 #endif//Q_OS_SYMBIAN
       
  1325 
       
  1326     CaEntry item;
       
  1327     item.setText("Text");
       
  1328     item.setEntryTypeName("TypeName");
       
  1329     QSharedPointer<CaEntry> entry = mService->createEntry(item);
       
  1330     QTest::qWait(waitTime1sec);
       
  1331 
       
  1332     CaNotifierFilter *filter = new CaNotifierFilter();
       
  1333     filter->setEntryRole(ItemEntryRole);
       
  1334     filter->setIds(QList<int>() << entry->id());
       
  1335     TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService, filter);
       
  1336     CaNotifier *notifier = clientNotifier->getNotifier();
       
  1337 
       
  1338     connect(notifier, SIGNAL(entryTouched(int)),
       
  1339             clientNotifier, SLOT(entryTouched(int)));
       
  1340     QTest::qWait(waitTime500ms);
       
  1341 
       
  1342     bool touched = mService->touch(*entry);
       
  1343     QTest::qWait(waitTime1sec);
       
  1344 
       
  1345     QVERIFY(clientNotifier->mEntryId > 0);
       
  1346     QCOMPARE(clientNotifier->mEntryId, entry->id());
       
  1347     QCOMPARE(touched, TRUE);
       
  1348 
       
  1349     // cleanup
       
  1350     disconnect(notifier, SIGNAL(entryTouched(int)),
       
  1351                clientNotifier, SLOT(entryTouched(int)));
       
  1352     QTest::qWait(waitTime500ms);
       
  1353     delete clientNotifier;
       
  1354     delete filter;
       
  1355     mService->removeEntry(entry->id());
       
  1356     QTest::qWait(waitTime1sec);
       
  1357 
       
  1358 #ifdef Q_OS_SYMBIAN
       
  1359 #ifdef UT_MEMORY_CHECK
       
  1360 // __UHEAP_MARKEND;
       
  1361 #endif//UT_MEMORY_CHECK
       
  1362 #endif//Q_OS_SYMBIAN
       
  1363 }
       
  1364 // ---------------------------------------------------------------------------
       
  1365 //
       
  1366 void TestCaClient::TestTouchEntryIdNotifier()
       
  1367 {
       
  1368 #ifdef Q_OS_SYMBIAN
       
  1369 #ifdef UT_MEMORY_CHECK
       
  1370 // __UHEAP_MARK;
       
  1371 #endif//UT_MEMORY_CHECK
       
  1372 #endif//Q_OS_SYMBIAN
       
  1373 
       
  1374 
       
  1375     TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService);
       
  1376     CaNotifier *notifier = clientNotifier->getNotifier();
       
  1377 
       
  1378     connect(notifier, SIGNAL(entryTouched(int)),
       
  1379             clientNotifier, SLOT(entryTouched(int)));
       
  1380     QTest::qWait(waitTime500ms);
       
  1381     CaEntry item;
       
  1382     item.setText("Text");
       
  1383     item.setEntryTypeName("TypeName");
       
  1384     QSharedPointer<CaEntry> entry = mService->createEntry(item);
       
  1385     QTest::qWait(waitTime1sec);
       
  1386     QCOMPARE(clientNotifier->mEntryId, 0);
       
  1387 
       
  1388     bool touched = mService->touch(*entry);
       
  1389     QTest::qWait(waitTime1sec);
       
  1390 
       
  1391     QVERIFY(clientNotifier->mEntryId > 0);
       
  1392     QCOMPARE(clientNotifier->mEntryId, entry->id());
       
  1393     QCOMPARE(touched, TRUE);
       
  1394 
       
  1395     // cleanup
       
  1396     disconnect(notifier, SIGNAL(entryTouched(int)),
       
  1397                clientNotifier, SLOT(entryTouched(int)));
       
  1398     QTest::qWait(waitTime500ms);
       
  1399     delete clientNotifier;
       
  1400     mService->removeEntry(entry->id());
       
  1401     QTest::qWait(waitTime1sec);
       
  1402 
       
  1403 #ifdef Q_OS_SYMBIAN
       
  1404 #ifdef UT_MEMORY_CHECK
       
  1405 // __UHEAP_MARKEND;
       
  1406 #endif//UT_MEMORY_CHECK
       
  1407 #endif//Q_OS_SYMBIAN
       
  1408 }
       
  1409 // ---------------------------------------------------------------------------
       
  1410 //
       
  1411 void TestCaClient::TestTouchEntryNotifierFake()
       
  1412 {
       
  1413 #ifdef Q_OS_SYMBIAN
       
  1414 #ifdef UT_MEMORY_CHECK
       
  1415 // __UHEAP_MARK;
       
  1416 #endif//UT_MEMORY_CHECK
       
  1417 #endif//Q_OS_SYMBIAN
       
  1418 
       
  1419 
       
  1420     TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService);
       
  1421     CaNotifier *notifier = clientNotifier->getNotifier();
       
  1422 
       
  1423     connect(notifier, SIGNAL(entryTouched(int)),
       
  1424             clientNotifier, SLOT(entryTouched(int)));
       
  1425     QTest::qWait(waitTime500ms);
       
  1426     CaEntry item;
       
  1427     item.setText("Text");
       
  1428     item.setEntryTypeName("TypeName");
       
  1429     QSharedPointer<CaEntry> entry = mService->createEntry(item);
       
  1430     QTest::qWait(waitTime1sec);
       
  1431 
       
  1432     QCOMPARE(clientNotifier->mEntryId, 0);
       
  1433 
       
  1434     CaEntry *entryFake = new CaEntry();
       
  1435     entryFake->setText("Text");
       
  1436     entryFake->setEntryTypeName("TypeName");
       
  1437 
       
  1438     bool touched = mService->touch(*entryFake);
       
  1439     QTest::qWait(waitTime1sec);
       
  1440 
       
  1441     QCOMPARE(clientNotifier->mEntryId, 0);
       
  1442     QCOMPARE(touched, FALSE);
       
  1443 
       
  1444     // cleanup
       
  1445     disconnect(notifier, SIGNAL(entryTouched(int)),
       
  1446                clientNotifier, SLOT(entryTouched(int)));
       
  1447     QTest::qWait(waitTime500ms);
       
  1448     delete clientNotifier;
       
  1449     mService->removeEntry(entry->id());
       
  1450     QTest::qWait(waitTime1sec);
       
  1451     delete entryFake;
       
  1452 
       
  1453 #ifdef Q_OS_SYMBIAN
       
  1454 #ifdef UT_MEMORY_CHECK
       
  1455 // __UHEAP_MARKEND;
       
  1456 #endif//UT_MEMORY_CHECK
       
  1457 #endif//Q_OS_SYMBIAN
       
  1458 }
       
  1459 
       
  1460 
       
  1461 void TestCaClient::TestTouchEntryUidNotifier()
       
  1462 {
       
  1463 #ifdef Q_OS_SYMBIAN
       
  1464 #ifdef UT_MEMORY_CHECK
       
  1465 // __UHEAP_MARK;
       
  1466 #endif//UT_MEMORY_CHECK
       
  1467 #endif//Q_OS_SYMBIAN
       
  1468 
       
  1469 
       
  1470     QScopedPointer<TestCaClientNotifier> clientNotifier(
       
  1471         new TestCaClientNotifier(*mService));
       
  1472 
       
  1473     CaNotifier *notifier = clientNotifier->getNotifier();
       
  1474 
       
  1475     connect(notifier, SIGNAL(entryTouched(int)),
       
  1476             clientNotifier.data(), SLOT(entryTouched(int)));
       
  1477 
       
  1478     CaEntry item;
       
  1479     item.setText("Text");
       
  1480     item.setEntryTypeName("application");
       
  1481     item.setAttribute(
       
  1482         "application:uid",
       
  1483         "-3");
       
  1484 
       
  1485     QSharedPointer<CaEntry> entry = mService->createEntry(item);
       
  1486 
       
  1487     QTest::qWait(waitTime1sec);
       
  1488 
       
  1489     QVERIFY(!entry.isNull());
       
  1490 
       
  1491     const int expectedEntryId = entry->id();
       
  1492 
       
  1493     entry->setId(0);
       
  1494 
       
  1495     QCOMPARE(clientNotifier->mEntryId, 0);
       
  1496 
       
  1497     bool touched = mService->touch(*entry);
       
  1498 
       
  1499     QTest::qWait(waitTime1sec);
       
  1500 
       
  1501     QCOMPARE(clientNotifier->mEntryId, expectedEntryId);
       
  1502     QCOMPARE(touched, true);
       
  1503 
       
  1504     // cleanup
       
  1505     disconnect(notifier, SIGNAL(entryTouched(int)),
       
  1506                clientNotifier.data(), SLOT(entryTouched(int)));
       
  1507 
       
  1508     QTest::qWait(waitTime500ms);
       
  1509 
       
  1510     mService->removeEntry(expectedEntryId);
       
  1511     QTest::qWait(waitTime1sec);
       
  1512 
       
  1513 #ifdef Q_OS_SYMBIAN
       
  1514 #ifdef UT_MEMORY_CHECK
       
  1515 // __UHEAP_MARKEND;
       
  1516 #endif//UT_MEMORY_CHECK
       
  1517 #endif//Q_OS_SYMBIAN
       
  1518 }
       
  1519 
       
  1520 
       
  1521 // ---------------------------------------------------------------------------
       
  1522 //
       
  1523 void TestCaClient::TestTouchEntryIdNotifierFake()
       
  1524 {
       
  1525 #ifdef Q_OS_SYMBIAN
       
  1526 #ifdef UT_MEMORY_CHECK
       
  1527 // __UHEAP_MARK;
       
  1528 #endif//UT_MEMORY_CHECK
       
  1529 #endif//Q_OS_SYMBIAN
       
  1530 
       
  1531     TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService);
       
  1532     CaNotifier *notifier = clientNotifier->getNotifier();
       
  1533 
       
  1534     connect(notifier, SIGNAL(entryTouched(int)),
       
  1535             clientNotifier, SLOT(entryTouched(int)));
       
  1536     QTest::qWait(waitTime500ms);
       
  1537     CaEntry item;
       
  1538     item.setText("Text");
       
  1539     item.setEntryTypeName("TypeName");
       
  1540     QSharedPointer<CaEntry> entry = mService->createEntry(item);
       
  1541     QTest::qWait(waitTime1sec);
       
  1542 
       
  1543     QCOMPARE(clientNotifier->mEntryId, 0);
       
  1544 
       
  1545     QScopedPointer<CaEntry> entryFake(new CaEntry());
       
  1546     entryFake->setText("Text");
       
  1547     entryFake->setEntryTypeName("TypeName");
       
  1548     entryFake->setId(entryIdFake);
       
  1549 
       
  1550     bool touched = mService->touch(*entryFake);
       
  1551     QTest::qWait(waitTime1sec);
       
  1552 
       
  1553     QCOMPARE(clientNotifier->mEntryId, 0);
       
  1554     QCOMPARE(touched, FALSE);
       
  1555 
       
  1556     // cleanup
       
  1557     disconnect(notifier, SIGNAL(entryTouched(int)),
       
  1558                clientNotifier, SLOT(entryTouched(int)));
       
  1559     QTest::qWait(waitTime500ms);
       
  1560     delete clientNotifier;
       
  1561     mService->removeEntry(entry->id());
       
  1562     QTest::qWait(waitTime1sec);
       
  1563 
       
  1564 #ifdef Q_OS_SYMBIAN
       
  1565 #ifdef UT_MEMORY_CHECK
       
  1566 // __UHEAP_MARKEND;
       
  1567 #endif//UT_MEMORY_CHECK
       
  1568 #endif//Q_OS_SYMBIAN
       
  1569 }
       
  1570 // ---------------------------------------------------------------------------
       
  1571 //
       
  1572 void TestCaClient::TestTouchGroupNotifier()
       
  1573 {
       
  1574 #ifdef Q_OS_SYMBIAN
       
  1575 #ifdef UT_MEMORY_CHECK
       
  1576 // __UHEAP_MARK;
       
  1577 #endif//UT_MEMORY_CHECK
       
  1578 #endif//Q_OS_SYMBIAN
       
  1579 
       
  1580 
       
  1581     TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService);
       
  1582     CaNotifier *notifier = clientNotifier->getNotifier();
       
  1583 
       
  1584     connect(notifier, SIGNAL(entryTouched(int)),
       
  1585             clientNotifier, SLOT(entryTouched(int)));
       
  1586     QTest::qWait(waitTime500ms);
       
  1587     CaEntry group(GroupEntryRole);
       
  1588     group.setText("Text");
       
  1589     group.setEntryTypeName("TypeName");
       
  1590     QSharedPointer<CaEntry> entry = mService->createEntry(group);
       
  1591     QTest::qWait(waitTime1sec);
       
  1592 
       
  1593     QCOMPARE(clientNotifier->mEntryId, 0);
       
  1594 
       
  1595     bool touched = mService->touch(*entry);
       
  1596     QTest::qWait(waitTime1sec);
       
  1597 
       
  1598     QVERIFY(clientNotifier->mEntryId > 0);
       
  1599     QCOMPARE(clientNotifier->mEntryId, entry->id());
       
  1600     QCOMPARE(touched, TRUE);
       
  1601 
       
  1602     // cleanup
       
  1603     disconnect(notifier, SIGNAL(entryTouched(int)),
       
  1604                clientNotifier, SLOT(entryTouched(int)));
       
  1605     QTest::qWait(waitTime500ms);
       
  1606     delete clientNotifier;
       
  1607     mService->removeEntry(entry->id());
       
  1608     QTest::qWait(waitTime1sec);
       
  1609 
       
  1610 #ifdef Q_OS_SYMBIAN
       
  1611 #ifdef UT_MEMORY_CHECK
       
  1612 // __UHEAP_MARKEND;
       
  1613 #endif//UT_MEMORY_CHECK
       
  1614 #endif//Q_OS_SYMBIAN
       
  1615 }
       
  1616 // ---------------------------------------------------------------------------
       
  1617 //
       
  1618 void TestCaClient::TestAppendEntryGroupNotifier()
       
  1619 {
       
  1620 #ifdef Q_OS_SYMBIAN
       
  1621 #ifdef UT_MEMORY_CHECK
       
  1622 // __UHEAP_MARK;
       
  1623 #endif//UT_MEMORY_CHECK
       
  1624 #endif//Q_OS_SYMBIAN
       
  1625 
       
  1626     TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService);
       
  1627     CaNotifier *notifier = clientNotifier->getNotifier();
       
  1628 
       
  1629     connect(notifier, SIGNAL(entryChanged(int, ChangeType)),
       
  1630             clientNotifier, SLOT(entryChanged(int, ChangeType)));
       
  1631     QTest::qWait(waitTime500ms);
       
  1632     CaEntry group(GroupEntryRole);
       
  1633     group.setText("Text");
       
  1634     group.setEntryTypeName("TypeName");
       
  1635     QSharedPointer<CaEntry> entryG = mService->createEntry(group);
       
  1636     QTest::qWait(waitTime1sec);
       
  1637 
       
  1638     QCOMPARE(clientNotifier->mChangeType, AddChangeType);
       
  1639     QVERIFY(clientNotifier->mEntryId > 0);
       
  1640     QCOMPARE(clientNotifier->mEntryId, entryG->id());
       
  1641 
       
  1642     connect(notifier, SIGNAL(groupContentChanged(int)),
       
  1643             clientNotifier, SLOT(groupContentChanged(int)));
       
  1644     QTest::qWait(waitTime500ms);
       
  1645     CaEntry item;
       
  1646     item.setText("Text");
       
  1647     item.setEntryTypeName("TypeName");
       
  1648     QSharedPointer<CaEntry> entryI = mService->createEntry(item);
       
  1649     QTest::qWait(waitTime1sec);
       
  1650     int groupId = entryG->id();
       
  1651 
       
  1652     clientNotifier->mChangeType = RemoveChangeType;
       
  1653     clientNotifier->mEntryId = 0;
       
  1654     clientNotifier->mGroupId = 0;
       
  1655 
       
  1656     bool appended = mService->appendEntryToGroup((CaEntry &)(*entryG), *entryI);
       
  1657     QTest::qWait(waitTime1sec);
       
  1658 
       
  1659     QVERIFY(clientNotifier->mGroupId > 0);
       
  1660     QCOMPARE(clientNotifier->mGroupId, groupId);
       
  1661     QCOMPARE(clientNotifier->mGroupId, entryG->id());
       
  1662     QCOMPARE(appended, TRUE);
       
  1663 
       
  1664     // cleanup
       
  1665     disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
  1666                clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
  1667     disconnect(notifier, SIGNAL(groupContentChanged(int)),
       
  1668                clientNotifier, SLOT(groupContentChanged(int)));
       
  1669     QTest::qWait(waitTime500ms);
       
  1670     delete clientNotifier;
       
  1671     mService->removeEntry(entryI->id());
       
  1672     QTest::qWait(waitTime1sec);
       
  1673     mService->removeEntry(entryG->id());
       
  1674     QTest::qWait(waitTime1sec);
       
  1675 
       
  1676 #ifdef Q_OS_SYMBIAN
       
  1677 #ifdef UT_MEMORY_CHECK
       
  1678 // __UHEAP_MARKEND;
       
  1679 #endif//UT_MEMORY_CHECK
       
  1680 #endif//Q_OS_SYMBIAN
       
  1681 }
       
  1682 // ---------------------------------------------------------------------------
       
  1683 //
       
  1684 void TestCaClient::TestAppendEntryGroupIdNotifier()
       
  1685 {
       
  1686 #ifdef Q_OS_SYMBIAN
       
  1687 #ifdef UT_MEMORY_CHECK
       
  1688 // __UHEAP_MARK;
       
  1689 #endif//UT_MEMORY_CHECK
       
  1690 #endif//Q_OS_SYMBIAN
       
  1691 
       
  1692 
       
  1693     TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService);
       
  1694     CaNotifier *notifier = clientNotifier->getNotifier();
       
  1695 
       
  1696     connect(notifier, SIGNAL(entryChanged(int, ChangeType)),
       
  1697             clientNotifier, SLOT(entryChanged(int, ChangeType)));
       
  1698     QTest::qWait(waitTime500ms);
       
  1699     CaEntry group(GroupEntryRole);
       
  1700     group.setText("Text");
       
  1701     group.setEntryTypeName("TypeName");
       
  1702     QSharedPointer<CaEntry> entryG = mService->createEntry(group);
       
  1703     QTest::qWait(waitTime1sec);
       
  1704 
       
  1705     QCOMPARE(clientNotifier->mChangeType, AddChangeType);
       
  1706     QVERIFY(clientNotifier->mEntryId > 0);
       
  1707     QCOMPARE(clientNotifier->mEntryId, entryG->id());
       
  1708 
       
  1709     connect(notifier, SIGNAL(groupContentChanged(int)),
       
  1710             clientNotifier, SLOT(groupContentChanged(int)));
       
  1711     QTest::qWait(waitTime500ms);
       
  1712     CaEntry item;
       
  1713     item.setText("Text");
       
  1714     item.setEntryTypeName("TypeName");
       
  1715     QSharedPointer<CaEntry> entryI = mService->createEntry(item);
       
  1716     QTest::qWait(waitTime1sec);
       
  1717     int groupId = entryG->id();
       
  1718 
       
  1719     clientNotifier->mChangeType = RemoveChangeType;
       
  1720     clientNotifier->mEntryId = 0;
       
  1721     clientNotifier->mGroupId = 0;
       
  1722 
       
  1723     bool appended = mService->appendEntryToGroup(((CaEntry &)*entryG).id(), (*entryI).id());
       
  1724     QTest::qWait(waitTime1sec);
       
  1725 
       
  1726     QVERIFY(clientNotifier->mGroupId > 0);
       
  1727     QCOMPARE(clientNotifier->mGroupId, groupId);
       
  1728     QCOMPARE(clientNotifier->mGroupId, entryG->id());
       
  1729     QCOMPARE(appended, TRUE);
       
  1730 
       
  1731     // cleanup
       
  1732     disconnect(notifier, SIGNAL(entryChanged(int, ChangeType)),
       
  1733                clientNotifier, SLOT(entryChanged(int, ChangeType)));
       
  1734     disconnect(notifier, SIGNAL(groupContentChanged(int)),
       
  1735                clientNotifier, SLOT(groupContentChanged(int)));
       
  1736     QTest::qWait(waitTime500ms);
       
  1737     delete clientNotifier;
       
  1738     mService->removeEntry(entryI->id());
       
  1739     QTest::qWait(waitTime1sec);
       
  1740     mService->removeEntry(entryG->id());
       
  1741     QTest::qWait(waitTime1sec);
       
  1742 
       
  1743 #ifdef Q_OS_SYMBIAN
       
  1744 #ifdef UT_MEMORY_CHECK
       
  1745 // __UHEAP_MARKEND;
       
  1746 #endif//UT_MEMORY_CHECK
       
  1747 #endif//Q_OS_SYMBIAN
       
  1748 }
       
  1749 // ---------------------------------------------------------------------------
       
  1750 //
       
  1751 void TestCaClient::TestAppendEntriesGroupNotifier()
       
  1752 {
       
  1753 #ifdef Q_OS_SYMBIAN
       
  1754 #ifdef UT_MEMORY_CHECK
       
  1755 // __UHEAP_MARK;
       
  1756 #endif//UT_MEMORY_CHECK
       
  1757 #endif//Q_OS_SYMBIAN
       
  1758 
       
  1759 
       
  1760     TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService);
       
  1761     CaNotifier *notifier = clientNotifier->getNotifier();
       
  1762 
       
  1763     connect(notifier, SIGNAL(entryChanged(int, ChangeType)),
       
  1764             clientNotifier, SLOT(entryChanged(int, ChangeType)));
       
  1765     QTest::qWait(waitTime500ms);
       
  1766     CaEntry group(GroupEntryRole);
       
  1767     group.setText("Text");
       
  1768     group.setEntryTypeName("TypeName");
       
  1769     QSharedPointer<CaEntry> entryGroup = mService->createEntry(group);
       
  1770     QTest::qWait(waitTime1sec);
       
  1771     int groupId = entryGroup->id();
       
  1772 
       
  1773     QCOMPARE(clientNotifier->mChangeType, AddChangeType);
       
  1774     QVERIFY(clientNotifier->mEntryId > 0);
       
  1775     QCOMPARE(clientNotifier->mEntryId, entryGroup->id());
       
  1776 
       
  1777     connect(notifier, SIGNAL(groupContentChanged(int)),
       
  1778             clientNotifier, SLOT(groupContentChanged(int)));
       
  1779     QTest::qWait(waitTime500ms);
       
  1780     CaEntry item1;
       
  1781     item1.setText("Text");
       
  1782     item1.setEntryTypeName("TypeName");
       
  1783     QSharedPointer<CaEntry> entry1 = mService->createEntry(item1);
       
  1784     QTest::qWait(waitTime1sec);
       
  1785     CaEntry item2;
       
  1786     item2.setText("Text");
       
  1787     item2.setEntryTypeName("TypeName");
       
  1788     QSharedPointer<CaEntry> entry2 = mService->createEntry(item2);
       
  1789     QTest::qWait(waitTime1sec);
       
  1790 
       
  1791     QList< QSharedPointer<CaEntry>  > entriesList;
       
  1792     entriesList.append(entry1);
       
  1793     entriesList.append(entry2);
       
  1794 
       
  1795     clientNotifier->mChangeType = RemoveChangeType;
       
  1796     clientNotifier->mEntryId = 0;
       
  1797     clientNotifier->mGroupId = 0;
       
  1798 
       
  1799     bool appended = mService->appendEntriesToGroup((CaEntry &)*entryGroup, entriesList);
       
  1800     QTest::qWait(waitTime1sec);
       
  1801 
       
  1802     QVERIFY(clientNotifier->mGroupId > 0);
       
  1803     QCOMPARE(clientNotifier->mGroupId, groupId);
       
  1804     QCOMPARE(clientNotifier->mGroupId, entryGroup->id());
       
  1805     QCOMPARE(appended, TRUE);
       
  1806 
       
  1807     // cleanup
       
  1808     disconnect(notifier, SIGNAL(entryChanged(int, ChangeType)),
       
  1809                clientNotifier, SLOT(entryChanged(int, ChangeType)));
       
  1810     disconnect(notifier, SIGNAL(groupContentChanged(int)),
       
  1811                clientNotifier, SLOT(groupContentChanged(int)));
       
  1812     QTest::qWait(waitTime500ms);
       
  1813     delete clientNotifier;
       
  1814     mService->removeEntries(entriesList);
       
  1815     QTest::qWait(waitTime1sec);
       
  1816     mService->removeEntry(entryGroup->id());
       
  1817     QTest::qWait(waitTime1sec);
       
  1818     entriesList.clear();
       
  1819 
       
  1820 #ifdef Q_OS_SYMBIAN
       
  1821 #ifdef UT_MEMORY_CHECK
       
  1822 // __UHEAP_MARKEND;
       
  1823 #endif//UT_MEMORY_CHECK
       
  1824 #endif//Q_OS_SYMBIAN
       
  1825 }
       
  1826 // ---------------------------------------------------------------------------
       
  1827 //
       
  1828 void TestCaClient::TestAppendEntriesGroupIdNotifier()
       
  1829 {
       
  1830 #ifdef Q_OS_SYMBIAN
       
  1831 #ifdef UT_MEMORY_CHECK
       
  1832 // __UHEAP_MARK;
       
  1833 #endif//UT_MEMORY_CHECK
       
  1834 #endif//Q_OS_SYMBIAN
       
  1835 
       
  1836 
       
  1837     TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService);
       
  1838     CaNotifier *notifier = clientNotifier->getNotifier();
       
  1839 
       
  1840     connect(notifier, SIGNAL(entryChanged(int, ChangeType)),
       
  1841             clientNotifier, SLOT(entryChanged(int, ChangeType)));
       
  1842     QTest::qWait(waitTime500ms);
       
  1843     CaEntry group(GroupEntryRole);
       
  1844     group.setText("Text");
       
  1845     group.setEntryTypeName("TypeName");
       
  1846     QSharedPointer<CaEntry> entryGroup = mService->createEntry(group);
       
  1847     QTest::qWait(waitTime1sec);
       
  1848     int groupId = entryGroup->id();
       
  1849 
       
  1850     QCOMPARE(clientNotifier->mChangeType, AddChangeType);
       
  1851     QVERIFY(clientNotifier->mEntryId > 0);
       
  1852     QCOMPARE(clientNotifier->mEntryId, entryGroup->id());
       
  1853 
       
  1854     connect(notifier, SIGNAL(groupContentChanged(int)),
       
  1855             clientNotifier, SLOT(groupContentChanged(int)));
       
  1856     QTest::qWait(waitTime500ms);
       
  1857     CaEntry item1;
       
  1858     item1.setText("Text");
       
  1859     item1.setEntryTypeName("TypeName");
       
  1860     QSharedPointer<CaEntry> entryItem1 = mService->createEntry(item1);
       
  1861     QTest::qWait(waitTime1sec);
       
  1862     CaEntry item2;
       
  1863     item2.setText("Text");
       
  1864     item2.setEntryTypeName("TypeName");
       
  1865     QSharedPointer<CaEntry> entryItem2 = mService->createEntry(item2);
       
  1866     QTest::qWait(waitTime1sec);
       
  1867 
       
  1868     QList<int> entriesIdsList;
       
  1869     entriesIdsList.append(entryItem1->id());
       
  1870     entriesIdsList.append(entryItem2->id());
       
  1871 
       
  1872     clientNotifier->mChangeType = RemoveChangeType;
       
  1873     clientNotifier->mEntryId = 0;
       
  1874     clientNotifier->mGroupId = 0;
       
  1875 
       
  1876     bool appended = mService->appendEntriesToGroup(((CaEntry &)*entryGroup).id(), entriesIdsList);
       
  1877     QTest::qWait(waitTime1sec);
       
  1878 
       
  1879     QVERIFY(clientNotifier->mGroupId > 0);
       
  1880     QCOMPARE(clientNotifier->mGroupId, groupId);
       
  1881     QCOMPARE(clientNotifier->mGroupId, entryGroup->id());
       
  1882     QCOMPARE(appended, TRUE);
       
  1883 
       
  1884     // cleanup
       
  1885     disconnect(notifier, SIGNAL(entryChanged(int, ChangeType)),
       
  1886                clientNotifier, SLOT(entryChanged(int, ChangeType)));
       
  1887     disconnect(notifier, SIGNAL(groupContentChanged(int)),
       
  1888                clientNotifier, SLOT(groupContentChanged(int)));
       
  1889     QTest::qWait(waitTime500ms);
       
  1890     delete clientNotifier;
       
  1891     mService->removeEntries(entriesIdsList);
       
  1892     QTest::qWait(waitTime1sec);
       
  1893     mService->removeEntry(entryGroup->id());
       
  1894     QTest::qWait(waitTime1sec);
       
  1895     entriesIdsList.clear();
       
  1896 
       
  1897 #ifdef Q_OS_SYMBIAN
       
  1898 #ifdef UT_MEMORY_CHECK
       
  1899 // __UHEAP_MARKEND;
       
  1900 #endif//UT_MEMORY_CHECK
       
  1901 #endif//Q_OS_SYMBIAN
       
  1902 }
       
  1903 // ---------------------------------------------------------------------------
       
  1904 //
       
  1905 void TestCaClient::TestPrependEntryGroupNotifier()
       
  1906 {
       
  1907 #ifdef Q_OS_SYMBIAN
       
  1908 #ifdef UT_MEMORY_CHECK
       
  1909 // __UHEAP_MARK;
       
  1910 #endif//UT_MEMORY_CHECK
       
  1911 #endif//Q_OS_SYMBIAN
       
  1912 
       
  1913 
       
  1914     TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService);
       
  1915     CaNotifier *notifier = clientNotifier->getNotifier();
       
  1916 
       
  1917     connect(notifier, SIGNAL(entryChanged(int, ChangeType)),
       
  1918             clientNotifier, SLOT(entryChanged(int, ChangeType)));
       
  1919     QTest::qWait(waitTime500ms);
       
  1920     CaEntry group(GroupEntryRole);
       
  1921     group.setText("Text");
       
  1922     group.setEntryTypeName("TypeName");
       
  1923     QSharedPointer<CaEntry> entryG = mService->createEntry(group);
       
  1924     QTest::qWait(waitTime1sec);
       
  1925 
       
  1926     QCOMPARE(clientNotifier->mChangeType, AddChangeType);
       
  1927     QVERIFY(clientNotifier->mEntryId > 0);
       
  1928     QCOMPARE(clientNotifier->mEntryId, entryG->id());
       
  1929 
       
  1930     connect(notifier, SIGNAL(groupContentChanged(int)),
       
  1931             clientNotifier, SLOT(groupContentChanged(int)));
       
  1932     QTest::qWait(waitTime500ms);
       
  1933     CaEntry item;
       
  1934     item.setText("Text");
       
  1935     item.setEntryTypeName("TypeName");
       
  1936     QSharedPointer<CaEntry> entryI = mService->createEntry(item);
       
  1937     QTest::qWait(waitTime1sec);
       
  1938     int groupId = entryG->id();
       
  1939 
       
  1940     clientNotifier->mChangeType = RemoveChangeType;
       
  1941     clientNotifier->mEntryId = 0;
       
  1942     clientNotifier->mGroupId = 0;
       
  1943 
       
  1944     bool appended = mService->prependEntryToGroup((CaEntry &)(*entryG), *entryI);
       
  1945     QTest::qWait(waitTime1sec);
       
  1946 
       
  1947     QVERIFY(clientNotifier->mGroupId > 0);
       
  1948     QCOMPARE(clientNotifier->mGroupId, groupId);
       
  1949     QCOMPARE(clientNotifier->mGroupId, entryG->id());
       
  1950     QCOMPARE(appended, TRUE);
       
  1951 
       
  1952     // cleanup
       
  1953     disconnect(notifier, SIGNAL(entryChanged(int, ChangeType)),
       
  1954                clientNotifier, SLOT(entryChanged(int, ChangeType)));
       
  1955     disconnect(notifier, SIGNAL(groupContentChanged(int)),
       
  1956                clientNotifier, SLOT(groupContentChanged(int)));
       
  1957     QTest::qWait(waitTime500ms);
       
  1958     delete clientNotifier;
       
  1959     mService->removeEntry(entryI->id());
       
  1960     QTest::qWait(waitTime1sec);
       
  1961     mService->removeEntry(entryG->id());
       
  1962     QTest::qWait(waitTime1sec);
       
  1963 
       
  1964 #ifdef Q_OS_SYMBIAN
       
  1965 #ifdef UT_MEMORY_CHECK
       
  1966 // __UHEAP_MARKEND;
       
  1967 #endif//UT_MEMORY_CHECK
       
  1968 #endif//Q_OS_SYMBIAN
       
  1969 }
       
  1970 // ---------------------------------------------------------------------------
       
  1971 //
       
  1972 void TestCaClient::TestPrependEntryGroupIdNotifier()
       
  1973 {
       
  1974 #ifdef Q_OS_SYMBIAN
       
  1975 #ifdef UT_MEMORY_CHECK
       
  1976 // __UHEAP_MARK;
       
  1977 #endif//UT_MEMORY_CHECK
       
  1978 #endif//Q_OS_SYMBIAN
       
  1979 
       
  1980 
       
  1981     TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService);
       
  1982     CaNotifier *notifier = clientNotifier->getNotifier();
       
  1983 
       
  1984     connect(notifier, SIGNAL(entryChanged(int, ChangeType)),
       
  1985             clientNotifier, SLOT(entryChanged(int, ChangeType)));
       
  1986     QTest::qWait(waitTime500ms);
       
  1987     CaEntry group(GroupEntryRole);
       
  1988     group.setText("Text");
       
  1989     group.setEntryTypeName("TypeName");
       
  1990     QSharedPointer<CaEntry> entryG = mService->createEntry(group);
       
  1991     QTest::qWait(waitTime1sec);
       
  1992 
       
  1993     QCOMPARE(clientNotifier->mChangeType, AddChangeType);
       
  1994     QVERIFY(clientNotifier->mEntryId > 0);
       
  1995     QCOMPARE(clientNotifier->mEntryId, entryG->id());
       
  1996 
       
  1997     connect(notifier, SIGNAL(groupContentChanged(int)),
       
  1998             clientNotifier, SLOT(groupContentChanged(int)));
       
  1999     QTest::qWait(waitTime500ms);
       
  2000     CaEntry item;
       
  2001     item.setText("Text");
       
  2002     item.setEntryTypeName("TypeName");
       
  2003     QSharedPointer<CaEntry> entryI = mService->createEntry(item);
       
  2004     QTest::qWait(waitTime1sec);
       
  2005     int groupId = entryG->id();
       
  2006 
       
  2007     clientNotifier->mChangeType = RemoveChangeType;
       
  2008     clientNotifier->mEntryId = 0;
       
  2009     clientNotifier->mGroupId = 0;
       
  2010 
       
  2011     bool appended = mService->prependEntryToGroup(((CaEntry &)*entryG).id(), (*entryI).id());
       
  2012     QTest::qWait(waitTime1sec);
       
  2013 
       
  2014     QVERIFY(clientNotifier->mGroupId > 0);
       
  2015     QCOMPARE(clientNotifier->mGroupId, groupId);
       
  2016     QCOMPARE(clientNotifier->mGroupId, entryG->id());
       
  2017     QCOMPARE(appended, TRUE);
       
  2018 
       
  2019     // cleanup
       
  2020     disconnect(notifier, SIGNAL(entryChanged(int, ChangeType)),
       
  2021                clientNotifier, SLOT(entryChanged(int, ChangeType)));
       
  2022     disconnect(notifier, SIGNAL(groupContentChanged(int)),
       
  2023                clientNotifier, SLOT(groupContentChanged(int)));
       
  2024     QTest::qWait(waitTime500ms);
       
  2025     delete clientNotifier;
       
  2026     mService->removeEntry(entryI->id());
       
  2027     QTest::qWait(waitTime1sec);
       
  2028     mService->removeEntry(entryG->id());
       
  2029     QTest::qWait(waitTime1sec);
       
  2030 
       
  2031 #ifdef Q_OS_SYMBIAN
       
  2032 #ifdef UT_MEMORY_CHECK
       
  2033 // __UHEAP_MARKEND;
       
  2034 #endif//UT_MEMORY_CHECK
       
  2035 #endif//Q_OS_SYMBIAN
       
  2036 }
       
  2037 // ---------------------------------------------------------------------------
       
  2038 //
       
  2039 void TestCaClient::TestPrependEntriesGroupNotifier()
       
  2040 {
       
  2041 #ifdef Q_OS_SYMBIAN
       
  2042 #ifdef UT_MEMORY_CHECK
       
  2043 // __UHEAP_MARK;
       
  2044 #endif//UT_MEMORY_CHECK
       
  2045 #endif//Q_OS_SYMBIAN
       
  2046 
       
  2047 
       
  2048     TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService);
       
  2049     CaNotifier *notifier = clientNotifier->getNotifier();
       
  2050 
       
  2051     connect(notifier, SIGNAL(entryChanged(int, ChangeType)),
       
  2052             clientNotifier, SLOT(entryChanged(int, ChangeType)));
       
  2053     QTest::qWait(waitTime500ms);
       
  2054     CaEntry group(GroupEntryRole);
       
  2055     group.setText("Text");
       
  2056     group.setEntryTypeName("TypeName");
       
  2057     QSharedPointer<CaEntry> entryGroup = mService->createEntry(group);
       
  2058     QTest::qWait(waitTime1sec);
       
  2059     int groupId = entryGroup->id();
       
  2060 
       
  2061     QCOMPARE(clientNotifier->mChangeType, AddChangeType);
       
  2062     QVERIFY(clientNotifier->mEntryId > 0);
       
  2063     QCOMPARE(clientNotifier->mEntryId, entryGroup->id());
       
  2064 
       
  2065     connect(notifier, SIGNAL(groupContentChanged(int)),
       
  2066             clientNotifier, SLOT(groupContentChanged(int)));
       
  2067     QTest::qWait(waitTime500ms);
       
  2068     CaEntry item1;
       
  2069     item1.setText("Text");
       
  2070     item1.setEntryTypeName("TypeName");
       
  2071     QSharedPointer<CaEntry> entry1 = mService->createEntry(item1);
       
  2072     QTest::qWait(waitTime1sec);
       
  2073     CaEntry item2;
       
  2074     item2.setText("Text");
       
  2075     item2.setEntryTypeName("TypeName");
       
  2076     QSharedPointer<CaEntry> entry2 = mService->createEntry(item2);
       
  2077     QTest::qWait(waitTime1sec);
       
  2078 
       
  2079     QList< QSharedPointer<CaEntry> > entriesList;
       
  2080     entriesList.append(entry1);
       
  2081     entriesList.append(entry2);
       
  2082 
       
  2083     clientNotifier->mChangeType = RemoveChangeType;
       
  2084     clientNotifier->mEntryId = 0;
       
  2085     clientNotifier->mGroupId = 0;
       
  2086 
       
  2087     bool appended = mService->prependEntriesToGroup((CaEntry &)*entryGroup, entriesList);
       
  2088     QTest::qWait(waitTime1sec);
       
  2089 
       
  2090     QVERIFY(clientNotifier->mGroupId > 0);
       
  2091     QCOMPARE(clientNotifier->mGroupId, groupId);
       
  2092     QCOMPARE(clientNotifier->mGroupId, entryGroup->id());
       
  2093     QCOMPARE(appended, TRUE);
       
  2094 
       
  2095     // cleanup
       
  2096     disconnect(notifier, SIGNAL(entryChanged(int, ChangeType)),
       
  2097                clientNotifier, SLOT(entryChanged(int, ChangeType)));
       
  2098     disconnect(notifier, SIGNAL(groupContentChanged(int)),
       
  2099                clientNotifier, SLOT(groupContentChanged(int)));
       
  2100     QTest::qWait(waitTime500ms);
       
  2101     delete clientNotifier;
       
  2102     mService->removeEntries(entriesList);
       
  2103     QTest::qWait(waitTime1sec);
       
  2104     mService->removeEntry(entryGroup->id());
       
  2105     QTest::qWait(waitTime1sec);
       
  2106     entriesList.clear();
       
  2107 
       
  2108 #ifdef Q_OS_SYMBIAN
       
  2109 #ifdef UT_MEMORY_CHECK
       
  2110 // __UHEAP_MARKEND;
       
  2111 #endif//UT_MEMORY_CHECK
       
  2112 #endif//Q_OS_SYMBIAN
       
  2113 }
       
  2114 // ---------------------------------------------------------------------------
       
  2115 //
       
  2116 void TestCaClient::TestPrependEntriesGroupIdNotifier()
       
  2117 {
       
  2118 #ifdef Q_OS_SYMBIAN
       
  2119 #ifdef UT_MEMORY_CHECK
       
  2120 // __UHEAP_MARK;
       
  2121 #endif//UT_MEMORY_CHECK
       
  2122 #endif//Q_OS_SYMBIAN
       
  2123 
       
  2124 
       
  2125     TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService);
       
  2126     CaNotifier *notifier = clientNotifier->getNotifier();
       
  2127 
       
  2128     connect(notifier, SIGNAL(entryChanged(int, ChangeType)),
       
  2129             clientNotifier, SLOT(entryChanged(int, ChangeType)));
       
  2130     QTest::qWait(waitTime500ms);
       
  2131     CaEntry group(GroupEntryRole);
       
  2132     group.setText("Text");
       
  2133     group.setEntryTypeName("TypeName");
       
  2134     QSharedPointer<CaEntry> entryGroup = mService->createEntry(group);
       
  2135     QTest::qWait(waitTime1sec);
       
  2136     int groupId = entryGroup->id();
       
  2137 
       
  2138     QCOMPARE(clientNotifier->mChangeType, AddChangeType);
       
  2139     QVERIFY(clientNotifier->mEntryId > 0);
       
  2140     QCOMPARE(clientNotifier->mEntryId, entryGroup->id());
       
  2141 
       
  2142     connect(notifier, SIGNAL(groupContentChanged(int)),
       
  2143             clientNotifier, SLOT(groupContentChanged(int)));
       
  2144     QTest::qWait(waitTime500ms);
       
  2145     CaEntry item1;
       
  2146     item1.setText("Text");
       
  2147     item1.setEntryTypeName("TypeName");
       
  2148     QSharedPointer<CaEntry> entryItem1 = mService->createEntry(item1);
       
  2149     QTest::qWait(waitTime1sec);
       
  2150     CaEntry item2;
       
  2151     item2.setText("Text");
       
  2152     item2.setEntryTypeName("TypeName");
       
  2153     QSharedPointer<CaEntry> entryItem2 = mService->createEntry(item2);
       
  2154     QTest::qWait(waitTime1sec);
       
  2155 
       
  2156     QList<int> entriesIdsList;
       
  2157     entriesIdsList.append(entryItem1->id());
       
  2158     entriesIdsList.append(entryItem2->id());
       
  2159 
       
  2160     clientNotifier->mChangeType = RemoveChangeType;
       
  2161     clientNotifier->mEntryId = 0;
       
  2162     clientNotifier->mGroupId = 0;
       
  2163 
       
  2164     bool appended = mService->prependEntriesToGroup(((CaEntry &)*entryGroup).id(), entriesIdsList);
       
  2165     QTest::qWait(waitTime1sec);
       
  2166 
       
  2167     QVERIFY(clientNotifier->mGroupId > 0);
       
  2168     QCOMPARE(clientNotifier->mGroupId, groupId);
       
  2169     QCOMPARE(clientNotifier->mGroupId, entryGroup->id());
       
  2170     QCOMPARE(appended, TRUE);
       
  2171 
       
  2172     // cleanup
       
  2173     disconnect(notifier, SIGNAL(entryChanged(int, ChangeType)),
       
  2174                clientNotifier, SLOT(entryChanged(int, ChangeType)));
       
  2175     disconnect(notifier, SIGNAL(groupContentChanged(int)),
       
  2176                clientNotifier, SLOT(groupContentChanged(int)));
       
  2177     QTest::qWait(waitTime500ms);
       
  2178     delete clientNotifier;
       
  2179     mService->removeEntries(entriesIdsList);
       
  2180     QTest::qWait(waitTime1sec);
       
  2181     mService->removeEntry(entryGroup->id());
       
  2182     QTest::qWait(waitTime1sec);
       
  2183     entriesIdsList.clear();
       
  2184 
       
  2185 #ifdef Q_OS_SYMBIAN
       
  2186 #ifdef UT_MEMORY_CHECK
       
  2187 // __UHEAP_MARKEND;
       
  2188 #endif//UT_MEMORY_CHECK
       
  2189 #endif//Q_OS_SYMBIAN
       
  2190 }
       
  2191 // ---------------------------------------------------------------------------
       
  2192 //
       
  2193 void TestCaClient::TestRemoveEntryGroupNotifier()
       
  2194 {
       
  2195 #ifdef Q_OS_SYMBIAN
       
  2196 #ifdef UT_MEMORY_CHECK
       
  2197 // __UHEAP_MARK;
       
  2198 #endif//UT_MEMORY_CHECK
       
  2199 #endif//Q_OS_SYMBIAN
       
  2200 
       
  2201     TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService);
       
  2202     CaNotifier *notifier = clientNotifier->getNotifier();
       
  2203 
       
  2204     connect(notifier, SIGNAL(entryChanged(int, ChangeType)),
       
  2205             clientNotifier, SLOT(entryChanged(int, ChangeType)));
       
  2206     QTest::qWait(waitTime500ms);
       
  2207     CaEntry group(GroupEntryRole);
       
  2208     group.setText("Text");
       
  2209     group.setEntryTypeName("TypeName");
       
  2210     QSharedPointer<CaEntry> entryGroup = mService->createEntry(group);
       
  2211     QTest::qWait(waitTime1sec);
       
  2212     int groupId = entryGroup->id();
       
  2213 
       
  2214     QCOMPARE(clientNotifier->mChangeType, AddChangeType);
       
  2215     QVERIFY(clientNotifier->mEntryId > 0);
       
  2216     QCOMPARE(clientNotifier->mEntryId, entryGroup->id());
       
  2217 
       
  2218     connect(notifier, SIGNAL(groupContentChanged(int)),
       
  2219             clientNotifier, SLOT(groupContentChanged(int)));
       
  2220     QTest::qWait(waitTime500ms);
       
  2221     CaEntry item1;
       
  2222     item1.setText("Text");
       
  2223     item1.setEntryTypeName("TypeName");
       
  2224     QSharedPointer<CaEntry> entry1 = mService->createEntry(item1);
       
  2225     QTest::qWait(waitTime1sec);
       
  2226     CaEntry item2;
       
  2227     item2.setText("Text");
       
  2228     item2.setEntryTypeName("TypeName");
       
  2229     QSharedPointer<CaEntry> entry2 = mService->createEntry(item2);
       
  2230     QTest::qWait(waitTime1sec);
       
  2231 
       
  2232     QList< QSharedPointer<CaEntry> > entriesList;
       
  2233     entriesList.append(entry1);
       
  2234     entriesList.append(entry2);
       
  2235 
       
  2236     bool appended = mService->appendEntriesToGroup((CaEntry &)*entryGroup, entriesList);
       
  2237     QTest::qWait(waitTime1sec);
       
  2238     QCOMPARE(appended, TRUE);
       
  2239 
       
  2240     clientNotifier->mChangeType = AddChangeType;
       
  2241     clientNotifier->mEntryId = 0;
       
  2242     clientNotifier->mGroupId = 0;
       
  2243     bool removed = mService->removeEntryFromGroup((CaEntry &)*entryGroup, *entry1);
       
  2244     QTest::qWait(waitTime1sec);
       
  2245 
       
  2246     QVERIFY(clientNotifier->mGroupId > 0);
       
  2247     QCOMPARE(clientNotifier->mGroupId, groupId);
       
  2248     QCOMPARE(clientNotifier->mGroupId, entryGroup->id());
       
  2249     QCOMPARE(removed, TRUE);
       
  2250 
       
  2251     clientNotifier->mChangeType = AddChangeType;
       
  2252     clientNotifier->mEntryId = 0;
       
  2253     clientNotifier->mGroupId = 0;
       
  2254     removed = mService->removeEntryFromGroup((CaEntry &)*entryGroup, *entry2);
       
  2255     QTest::qWait(waitTime1sec);
       
  2256 
       
  2257     QVERIFY(clientNotifier->mGroupId > 0);
       
  2258     QCOMPARE(clientNotifier->mGroupId, groupId);
       
  2259     QCOMPARE(clientNotifier->mGroupId, entryGroup->id());
       
  2260     QCOMPARE(removed, TRUE);
       
  2261 
       
  2262     // cleanup
       
  2263     disconnect(notifier, SIGNAL(entryChanged(int, ChangeType)),
       
  2264                clientNotifier, SLOT(entryChanged(int, ChangeType)));
       
  2265     disconnect(notifier, SIGNAL(groupContentChanged(int)),
       
  2266                clientNotifier, SLOT(groupContentChanged(int)));
       
  2267     QTest::qWait(waitTime500ms);
       
  2268     delete clientNotifier;
       
  2269     mService->removeEntries(entriesList);
       
  2270     QTest::qWait(waitTime1sec);
       
  2271     mService->removeEntry(entryGroup->id());
       
  2272     QTest::qWait(waitTime1sec);
       
  2273     entriesList.clear();
       
  2274 
       
  2275 #ifdef Q_OS_SYMBIAN
       
  2276 #ifdef UT_MEMORY_CHECK
       
  2277 // __UHEAP_MARKEND;
       
  2278 #endif//UT_MEMORY_CHECK
       
  2279 #endif//Q_OS_SYMBIAN
       
  2280 }
       
  2281 // ---------------------------------------------------------------------------
       
  2282 //
       
  2283 void TestCaClient::TestRemoveEntryGroupIdNotifier()
       
  2284 {
       
  2285 #ifdef Q_OS_SYMBIAN
       
  2286 #ifdef UT_MEMORY_CHECK
       
  2287 // __UHEAP_MARK;
       
  2288 #endif//UT_MEMORY_CHECK
       
  2289 #endif//Q_OS_SYMBIAN
       
  2290 
       
  2291 
       
  2292     TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService);
       
  2293     CaNotifier *notifier = clientNotifier->getNotifier();
       
  2294 
       
  2295     connect(notifier, SIGNAL(entryChanged(int, ChangeType)),
       
  2296             clientNotifier, SLOT(entryChanged(int, ChangeType)));
       
  2297     QTest::qWait(waitTime500ms);
       
  2298     CaEntry group(GroupEntryRole);
       
  2299     group.setText("Text");
       
  2300     group.setEntryTypeName("TypeName");
       
  2301     QSharedPointer<CaEntry> entryGroup = mService->createEntry(group);
       
  2302     QTest::qWait(waitTime1sec);
       
  2303     int groupId = entryGroup->id();
       
  2304 
       
  2305     QCOMPARE(clientNotifier->mChangeType, AddChangeType);
       
  2306     QVERIFY(clientNotifier->mEntryId > 0);
       
  2307     QCOMPARE(clientNotifier->mEntryId, entryGroup->id());
       
  2308 
       
  2309     connect(notifier, SIGNAL(groupContentChanged(int)),
       
  2310             clientNotifier, SLOT(groupContentChanged(int)));
       
  2311     QTest::qWait(waitTime500ms);
       
  2312     CaEntry item1;
       
  2313     item1.setText("Text");
       
  2314     item1.setEntryTypeName("TypeName");
       
  2315     QSharedPointer<CaEntry> entry1 = mService->createEntry(item1);
       
  2316     QTest::qWait(waitTime1sec);
       
  2317     CaEntry item2;
       
  2318     item2.setText("Text");
       
  2319     item2.setEntryTypeName("TypeName");
       
  2320     QSharedPointer<CaEntry> entry2 = mService->createEntry(item2);
       
  2321     QTest::qWait(waitTime1sec);
       
  2322 
       
  2323     QList< QSharedPointer<CaEntry> > entriesList;
       
  2324     entriesList.append(entry1);
       
  2325     entriesList.append(entry2);
       
  2326 
       
  2327     bool appended = mService->appendEntriesToGroup((CaEntry &)*entryGroup, entriesList);
       
  2328     QTest::qWait(waitTime1sec);
       
  2329     QCOMPARE(appended, TRUE);
       
  2330 
       
  2331     clientNotifier->mEntryId = 0;
       
  2332     clientNotifier->mGroupId = 0;
       
  2333     bool removed = mService->removeEntryFromGroup(entryGroup->id(), entry1->id());
       
  2334     QTest::qWait(waitTime1sec);
       
  2335 
       
  2336     QVERIFY(clientNotifier->mGroupId > 0);
       
  2337     QCOMPARE(clientNotifier->mGroupId, groupId);
       
  2338     QCOMPARE(clientNotifier->mGroupId, entryGroup->id());
       
  2339     QCOMPARE(removed, TRUE);
       
  2340 
       
  2341     clientNotifier->mEntryId = 0;
       
  2342     clientNotifier->mGroupId = 0;
       
  2343     removed = mService->removeEntryFromGroup(entryGroup->id(), entry2->id());
       
  2344     QTest::qWait(waitTime1sec);
       
  2345 
       
  2346     QVERIFY(clientNotifier->mGroupId > 0);
       
  2347     QCOMPARE(clientNotifier->mGroupId, groupId);
       
  2348     QCOMPARE(clientNotifier->mGroupId, entryGroup->id());
       
  2349     QCOMPARE(removed, TRUE);
       
  2350 
       
  2351     // cleanup
       
  2352     disconnect(notifier, SIGNAL(entryChanged(int, ChangeType)),
       
  2353                clientNotifier, SLOT(entryChanged(int, ChangeType)));
       
  2354     disconnect(notifier, SIGNAL(groupContentChanged(int)),
       
  2355                clientNotifier, SLOT(groupContentChanged(int)));
       
  2356     QTest::qWait(waitTime500ms);
       
  2357     delete clientNotifier;
       
  2358     mService->removeEntries(entriesList);
       
  2359     QTest::qWait(waitTime1sec);
       
  2360     mService->removeEntry(entryGroup->id());
       
  2361     QTest::qWait(waitTime1sec);
       
  2362     entriesList.clear();
       
  2363 
       
  2364 #ifdef Q_OS_SYMBIAN
       
  2365 #ifdef UT_MEMORY_CHECK
       
  2366 // __UHEAP_MARKEND;
       
  2367 #endif//UT_MEMORY_CHECK
       
  2368 #endif//Q_OS_SYMBIAN
       
  2369 }
       
  2370 // ---------------------------------------------------------------------------
       
  2371 //
       
  2372 void TestCaClient::TestRemoveEntriesGroupNotifier()
       
  2373 {
       
  2374 #ifdef Q_OS_SYMBIAN
       
  2375 #ifdef UT_MEMORY_CHECK
       
  2376 // __UHEAP_MARK;
       
  2377 #endif//UT_MEMORY_CHECK
       
  2378 #endif//Q_OS_SYMBIAN
       
  2379 
       
  2380     TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService);
       
  2381     CaNotifier *notifier = clientNotifier->getNotifier();
       
  2382 
       
  2383     connect(notifier, SIGNAL(entryChanged(int, ChangeType)),
       
  2384             clientNotifier, SLOT(entryChanged(int, ChangeType)));
       
  2385     QTest::qWait(waitTime500ms);
       
  2386     CaEntry group(GroupEntryRole);
       
  2387     group.setText("Text");
       
  2388     group.setEntryTypeName("TypeName");
       
  2389     QSharedPointer<CaEntry> entryGroup = mService->createEntry(group);
       
  2390     QTest::qWait(waitTime1sec);
       
  2391     int groupId = entryGroup->id();
       
  2392 
       
  2393     QCOMPARE(clientNotifier->mChangeType, AddChangeType);
       
  2394     QVERIFY(clientNotifier->mEntryId > 0);
       
  2395     QCOMPARE(clientNotifier->mEntryId, entryGroup->id());
       
  2396 
       
  2397     connect(notifier, SIGNAL(groupContentChanged(int)),
       
  2398             clientNotifier, SLOT(groupContentChanged(int)));
       
  2399     QTest::qWait(waitTime500ms);
       
  2400     CaEntry item1;
       
  2401     item1.setText("Text");
       
  2402     item1.setEntryTypeName("TypeName");
       
  2403     QSharedPointer<CaEntry> entry1 = mService->createEntry(item1);
       
  2404     QTest::qWait(waitTime1sec);
       
  2405     CaEntry item2;
       
  2406     item2.setText("Text");
       
  2407     item2.setEntryTypeName("TypeName");
       
  2408     QSharedPointer<CaEntry> entry2 = mService->createEntry(item2);
       
  2409     QTest::qWait(waitTime1sec);
       
  2410 
       
  2411     QList<QSharedPointer<CaEntry> > entriesList;
       
  2412     entriesList.append(entry1);
       
  2413     entriesList.append(entry2);
       
  2414 
       
  2415     bool appended = mService->appendEntriesToGroup((CaEntry &)*entryGroup, entriesList);
       
  2416     QTest::qWait(waitTime1sec);
       
  2417     QCOMPARE(appended, TRUE);
       
  2418 
       
  2419     clientNotifier->mEntryId = 0;
       
  2420     clientNotifier->mGroupId = 0;
       
  2421     bool removed = mService->removeEntriesFromGroup((CaEntry &)*entryGroup, entriesList);
       
  2422     QTest::qWait(waitTime1sec);
       
  2423 
       
  2424     QVERIFY(clientNotifier->mGroupId > 0);
       
  2425     QCOMPARE(clientNotifier->mGroupId, groupId);
       
  2426     QCOMPARE(clientNotifier->mGroupId, entryGroup->id());
       
  2427     QCOMPARE(removed, TRUE);
       
  2428 
       
  2429     // cleanup
       
  2430     disconnect(notifier, SIGNAL(entryChanged(int, ChangeType)),
       
  2431                clientNotifier, SLOT(entryChanged(int, ChangeType)));
       
  2432     disconnect(notifier, SIGNAL(groupContentChanged(int)),
       
  2433                clientNotifier, SLOT(groupContentChanged(int)));
       
  2434     QTest::qWait(waitTime500ms);
       
  2435     delete clientNotifier;
       
  2436     mService->removeEntries(entriesList);
       
  2437     QTest::qWait(waitTime1sec);
       
  2438     mService->removeEntry(entryGroup->id());
       
  2439     QTest::qWait(waitTime1sec);
       
  2440     entriesList.clear();
       
  2441 
       
  2442 #ifdef Q_OS_SYMBIAN
       
  2443 #ifdef UT_MEMORY_CHECK
       
  2444 // __UHEAP_MARKEND;
       
  2445 #endif//UT_MEMORY_CHECK
       
  2446 #endif//Q_OS_SYMBIAN
       
  2447 }
       
  2448 // ---------------------------------------------------------------------------
       
  2449 //
       
  2450 void TestCaClient::TestRemoveEntriesGroupIdNotifier()
       
  2451 {
       
  2452 #ifdef Q_OS_SYMBIAN
       
  2453 #ifdef UT_MEMORY_CHECK
       
  2454 // __UHEAP_MARK;
       
  2455 #endif//UT_MEMORY_CHECK
       
  2456 #endif//Q_OS_SYMBIAN
       
  2457 
       
  2458     TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService);
       
  2459     CaNotifier *notifier = clientNotifier->getNotifier();
       
  2460 
       
  2461     connect(notifier, SIGNAL(entryChanged(int, ChangeType)),
       
  2462             clientNotifier, SLOT(entryChanged(int, ChangeType)));
       
  2463     QTest::qWait(waitTime500ms);
       
  2464     CaEntry group(GroupEntryRole);
       
  2465     group.setText("Text");
       
  2466     group.setEntryTypeName("TypeName");
       
  2467     QSharedPointer<CaEntry> entryGroup = mService->createEntry(group);
       
  2468     QTest::qWait(waitTime1sec);
       
  2469     int groupId = entryGroup->id();
       
  2470 
       
  2471     QCOMPARE(clientNotifier->mChangeType, AddChangeType);
       
  2472     QVERIFY(clientNotifier->mEntryId > 0);
       
  2473     QCOMPARE(clientNotifier->mEntryId, entryGroup->id());
       
  2474 
       
  2475     connect(notifier, SIGNAL(groupContentChanged(int)),
       
  2476             clientNotifier, SLOT(groupContentChanged(int)));
       
  2477     QTest::qWait(waitTime500ms);
       
  2478     CaEntry item1;
       
  2479     item1.setText("Text");
       
  2480     item1.setEntryTypeName("TypeName");
       
  2481     QSharedPointer<CaEntry> entry1 = mService->createEntry(item1);
       
  2482     QTest::qWait(waitTime1sec);
       
  2483     CaEntry item2;
       
  2484     item2.setText("Text");
       
  2485     item2.setEntryTypeName("TypeName");
       
  2486     QSharedPointer<CaEntry> entry2 = mService->createEntry(item2);
       
  2487     QTest::qWait(waitTime1sec);
       
  2488 
       
  2489     QList<QSharedPointer<CaEntry> > entriesList;
       
  2490     entriesList.append(entry1);
       
  2491     entriesList.append(entry2);
       
  2492 
       
  2493     bool appended = mService->appendEntriesToGroup((CaEntry &)*entryGroup, entriesList);
       
  2494     QTest::qWait(waitTime1sec);
       
  2495     QCOMPARE(appended, TRUE);
       
  2496 
       
  2497     QList<int> entriesIdList;
       
  2498     entriesIdList.append(entry1->id());
       
  2499     entriesIdList.append(entry2->id());
       
  2500     clientNotifier->mEntryId = 0;
       
  2501     clientNotifier->mGroupId = 0;
       
  2502     bool removed = mService->removeEntriesFromGroup(entryGroup->id(), entriesIdList);
       
  2503     QTest::qWait(waitTime1sec);
       
  2504 
       
  2505     QVERIFY(clientNotifier->mGroupId > 0);
       
  2506     QCOMPARE(clientNotifier->mGroupId, groupId);
       
  2507     QCOMPARE(clientNotifier->mGroupId, entryGroup->id());
       
  2508     QCOMPARE(removed, TRUE);
       
  2509 
       
  2510     // cleanup
       
  2511     disconnect(notifier, SIGNAL(entryChanged(int, ChangeType)),
       
  2512                clientNotifier, SLOT(entryChanged(int, ChangeType)));
       
  2513     disconnect(notifier, SIGNAL(groupContentChanged(int)),
       
  2514                clientNotifier, SLOT(groupContentChanged(int)));
       
  2515     QTest::qWait(waitTime500ms);
       
  2516     delete clientNotifier;
       
  2517     mService->removeEntries(entriesList);
       
  2518     QTest::qWait(waitTime1sec);
       
  2519     mService->removeEntry(entryGroup->id());
       
  2520     QTest::qWait(waitTime1sec);
       
  2521     entriesList.clear();
       
  2522     entriesIdList.clear();
       
  2523 
       
  2524 #ifdef Q_OS_SYMBIAN
       
  2525 #ifdef UT_MEMORY_CHECK
       
  2526 // __UHEAP_MARKEND;
       
  2527 #endif//UT_MEMORY_CHECK
       
  2528 #endif//Q_OS_SYMBIAN
       
  2529 }
       
  2530 // ---------------------------------------------------------------------------
       
  2531 //
       
  2532 void TestCaClient::TestInsertEntryGroupNotifier()
       
  2533 {
       
  2534 #ifdef Q_OS_SYMBIAN
       
  2535 #ifdef UT_MEMORY_CHECK
       
  2536 // __UHEAP_MARK;
       
  2537 #endif//UT_MEMORY_CHECK
       
  2538 #endif//Q_OS_SYMBIAN
       
  2539 
       
  2540     TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService);
       
  2541     CaNotifier *notifier = clientNotifier->getNotifier();
       
  2542 
       
  2543     connect(notifier, SIGNAL(entryChanged(int, ChangeType)),
       
  2544             clientNotifier, SLOT(entryChanged(int, ChangeType)));
       
  2545     QTest::qWait(waitTime500ms);
       
  2546     CaEntry group(GroupEntryRole);
       
  2547     group.setText("Text");
       
  2548     group.setEntryTypeName("TypeName");
       
  2549     QSharedPointer<CaEntry> entryG = mService->createEntry(group);
       
  2550     QTest::qWait(waitTime1sec);
       
  2551     int groupId = entryG->id();
       
  2552 
       
  2553     QCOMPARE(clientNotifier->mChangeType, AddChangeType);
       
  2554     QVERIFY(clientNotifier->mEntryId > 0);
       
  2555     QCOMPARE(clientNotifier->mEntryId, entryG->id());
       
  2556 
       
  2557     connect(notifier, SIGNAL(groupContentChanged(int)),
       
  2558             clientNotifier, SLOT(groupContentChanged(int)));
       
  2559     QTest::qWait(waitTime500ms);
       
  2560     CaEntry item1;
       
  2561     item1.setText("Text1");
       
  2562     item1.setEntryTypeName("TypeName1");
       
  2563     QSharedPointer<CaEntry> entryI1 = mService->createEntry(item1);
       
  2564     QTest::qWait(waitTime1sec);
       
  2565     CaEntry item2;
       
  2566     item2.setText("Text2");
       
  2567     item2.setEntryTypeName("TypeName2");
       
  2568     QSharedPointer<CaEntry> entryI2 = mService->createEntry(item2);
       
  2569     QTest::qWait(waitTime1sec);
       
  2570 
       
  2571     bool appended = mService->appendEntryToGroup((CaEntry &)(*entryG), *entryI1);
       
  2572     QTest::qWait(waitTime500ms);
       
  2573     QCOMPARE(appended, TRUE);
       
  2574     appended = mService->prependEntryToGroup((CaEntry &)(*entryG), *entryI2);
       
  2575     QTest::qWait(waitTime500ms);
       
  2576     QCOMPARE(appended, TRUE);
       
  2577 
       
  2578     CaEntry item3;
       
  2579     item3.setText("Text3");
       
  2580     item3.setEntryTypeName("TypeName3");
       
  2581     QSharedPointer<CaEntry> entryI3 = mService->createEntry(item3);
       
  2582     QTest::qWait(waitTime1sec);
       
  2583     clientNotifier->mEntryId = 0;
       
  2584     clientNotifier->mGroupId = 0;
       
  2585 
       
  2586     bool inserted = mService->insertEntryIntoGroup((CaEntry &)*entryG, *entryI3, entryI2->id());
       
  2587     QTest::qWait(waitTime1sec);
       
  2588 
       
  2589     QVERIFY(clientNotifier->mGroupId > 0);
       
  2590     QCOMPARE(clientNotifier->mGroupId, groupId);
       
  2591     QCOMPARE(clientNotifier->mGroupId, entryG->id());
       
  2592     QCOMPARE(inserted, TRUE);
       
  2593 
       
  2594     // cleanup
       
  2595     disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
  2596                clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
  2597     disconnect(notifier, SIGNAL(groupContentChanged(int)),
       
  2598                clientNotifier, SLOT(groupContentChanged(int)));
       
  2599     QTest::qWait(waitTime500ms);
       
  2600     delete clientNotifier;
       
  2601     mService->removeEntry(entryI1->id());
       
  2602     QTest::qWait(waitTime500ms);
       
  2603     mService->removeEntry(entryI2->id());
       
  2604     QTest::qWait(waitTime500ms);
       
  2605     mService->removeEntry(entryI3->id());
       
  2606     QTest::qWait(waitTime500ms);
       
  2607     mService->removeEntry(entryG->id());
       
  2608     QTest::qWait(waitTime1sec);
       
  2609 
       
  2610 #ifdef Q_OS_SYMBIAN
       
  2611 #ifdef UT_MEMORY_CHECK
       
  2612 // __UHEAP_MARKEND;
       
  2613 #endif//UT_MEMORY_CHECK
       
  2614 #endif//Q_OS_SYMBIAN
       
  2615 }
       
  2616 // ---------------------------------------------------------------------------
       
  2617 //
       
  2618 // ---------------------------------------------------------------------------
       
  2619 //
       
  2620 void TestCaClient::TestInsertEntryGroupIdNotifier()
       
  2621 {
       
  2622 #ifdef Q_OS_SYMBIAN
       
  2623 #ifdef UT_MEMORY_CHECK
       
  2624 // __UHEAP_MARK;
       
  2625 #endif//UT_MEMORY_CHECK
       
  2626 #endif//Q_OS_SYMBIAN
       
  2627 
       
  2628     TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService);
       
  2629     CaNotifier *notifier = clientNotifier->getNotifier();
       
  2630 
       
  2631     connect(notifier, SIGNAL(entryChanged(int, ChangeType)),
       
  2632             clientNotifier, SLOT(entryChanged(int, ChangeType)));
       
  2633     QTest::qWait(waitTime500ms);
       
  2634     CaEntry group(GroupEntryRole);
       
  2635     group.setText("Text");
       
  2636     group.setEntryTypeName("TypeName");
       
  2637     QSharedPointer<CaEntry> entryG = mService->createEntry(group);
       
  2638     QTest::qWait(waitTime1sec);
       
  2639     int groupId = entryG->id();
       
  2640 
       
  2641     QCOMPARE(clientNotifier->mChangeType, AddChangeType);
       
  2642     QVERIFY(clientNotifier->mEntryId > 0);
       
  2643     QCOMPARE(clientNotifier->mEntryId, entryG->id());
       
  2644 
       
  2645     connect(notifier, SIGNAL(groupContentChanged(int)),
       
  2646             clientNotifier, SLOT(groupContentChanged(int)));
       
  2647     QTest::qWait(waitTime500ms);
       
  2648     CaEntry item1;
       
  2649     item1.setText("Text1");
       
  2650     item1.setEntryTypeName("TypeName1");
       
  2651     QSharedPointer<CaEntry> entryI1 = mService->createEntry(item1);
       
  2652     QTest::qWait(waitTime1sec);
       
  2653     CaEntry item2;
       
  2654     item2.setText("Text2");
       
  2655     item2.setEntryTypeName("TypeName2");
       
  2656     QSharedPointer<CaEntry> entryI2 = mService->createEntry(item2);
       
  2657     QTest::qWait(waitTime1sec);
       
  2658 
       
  2659     bool appended = mService->appendEntryToGroup(entryG->id(), entryI1->id());
       
  2660     QTest::qWait(waitTime500ms);
       
  2661     QCOMPARE(appended, TRUE);
       
  2662     appended = mService->prependEntryToGroup(entryG->id(), entryI2->id());
       
  2663     QTest::qWait(waitTime500ms);
       
  2664     QCOMPARE(appended, TRUE);
       
  2665 
       
  2666     CaEntry item3;
       
  2667     item3.setText("Text3");
       
  2668     item3.setEntryTypeName("TypeName3");
       
  2669     QSharedPointer<CaEntry> entryI3 = mService->createEntry(item3);
       
  2670     QTest::qWait(waitTime1sec);
       
  2671     clientNotifier->mEntryId = 0;
       
  2672     clientNotifier->mGroupId = 0;
       
  2673 
       
  2674     bool inserted = mService->insertEntryIntoGroup(entryG->id(), entryI3->id(), entryI2->id());
       
  2675     QTest::qWait(waitTime1sec);
       
  2676 
       
  2677     QVERIFY(clientNotifier->mGroupId > 0);
       
  2678     QCOMPARE(clientNotifier->mGroupId, groupId);
       
  2679     QCOMPARE(clientNotifier->mGroupId, entryG->id());
       
  2680     QCOMPARE(inserted, TRUE);
       
  2681 
       
  2682     // cleanup
       
  2683     disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
  2684                clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
  2685     disconnect(notifier, SIGNAL(groupContentChanged(int)),
       
  2686                clientNotifier, SLOT(groupContentChanged(int)));
       
  2687     QTest::qWait(waitTime500ms);
       
  2688     delete clientNotifier;
       
  2689     mService->removeEntry(entryI1->id());
       
  2690     QTest::qWait(waitTime500ms);
       
  2691     mService->removeEntry(entryI2->id());
       
  2692     QTest::qWait(waitTime500ms);
       
  2693     mService->removeEntry(entryI3->id());
       
  2694     QTest::qWait(waitTime500ms);
       
  2695     mService->removeEntry(entryG->id());
       
  2696     QTest::qWait(waitTime1sec);
       
  2697 
       
  2698 #ifdef Q_OS_SYMBIAN
       
  2699 #ifdef UT_MEMORY_CHECK
       
  2700 // __UHEAP_MARKEND;
       
  2701 #endif//UT_MEMORY_CHECK
       
  2702 #endif//Q_OS_SYMBIAN
       
  2703 }
       
  2704 // ---------------------------------------------------------------------------
       
  2705 //
       
  2706 void TestCaClient::TestInsertEntriesGroupNotifier()
       
  2707 {
       
  2708 #ifdef Q_OS_SYMBIAN
       
  2709 #ifdef UT_MEMORY_CHECK
       
  2710 // __UHEAP_MARK;
       
  2711 #endif//UT_MEMORY_CHECK
       
  2712 #endif//Q_OS_SYMBIAN
       
  2713 
       
  2714     TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService);
       
  2715     CaNotifier *notifier = clientNotifier->getNotifier();
       
  2716 
       
  2717     connect(notifier, SIGNAL(entryChanged(int, ChangeType)),
       
  2718             clientNotifier, SLOT(entryChanged(int, ChangeType)));
       
  2719     QTest::qWait(waitTime500ms);
       
  2720     CaEntry group(GroupEntryRole);
       
  2721     group.setText("Text");
       
  2722     group.setEntryTypeName("TypeName");
       
  2723     QSharedPointer<CaEntry> entryG = mService->createEntry(group);
       
  2724     QTest::qWait(waitTime1sec);
       
  2725     int groupId = entryG->id();
       
  2726 
       
  2727     QCOMPARE(clientNotifier->mChangeType, AddChangeType);
       
  2728     QVERIFY(clientNotifier->mEntryId > 0);
       
  2729     QCOMPARE(clientNotifier->mEntryId, entryG->id());
       
  2730 
       
  2731     connect(notifier, SIGNAL(groupContentChanged(int)),
       
  2732             clientNotifier, SLOT(groupContentChanged(int)));
       
  2733     QTest::qWait(waitTime500ms);
       
  2734     CaEntry item1;
       
  2735     item1.setText("Text1");
       
  2736     item1.setEntryTypeName("TypeName1");
       
  2737     QSharedPointer<CaEntry> entryI1 = mService->createEntry(item1);
       
  2738     QTest::qWait(waitTime1sec);
       
  2739     CaEntry item2;
       
  2740     item2.setText("Text2");
       
  2741     item2.setEntryTypeName("TypeName2");
       
  2742     QSharedPointer<CaEntry> entryI2 = mService->createEntry(item2);
       
  2743     QTest::qWait(waitTime1sec);
       
  2744 
       
  2745     bool appended = mService->appendEntryToGroup((CaEntry &)(*entryG), *entryI1);
       
  2746     QTest::qWait(waitTime500ms);
       
  2747     QCOMPARE(appended, TRUE);
       
  2748     appended = mService->prependEntryToGroup((CaEntry &)(*entryG), *entryI2);
       
  2749     QTest::qWait(waitTime500ms);
       
  2750     QCOMPARE(appended, TRUE);
       
  2751 
       
  2752     CaEntry item3;
       
  2753     item3.setText("Text3");
       
  2754     item3.setEntryTypeName("TypeName3");
       
  2755     QSharedPointer<CaEntry> entryI3 = mService->createEntry(item3);
       
  2756     QTest::qWait(waitTime1sec);
       
  2757     CaEntry item4;
       
  2758     item4.setText("Text4");
       
  2759     item4.setEntryTypeName("TypeName4");
       
  2760     QSharedPointer<CaEntry> entryI4 = mService->createEntry(item4);
       
  2761     QTest::qWait(waitTime1sec);
       
  2762 
       
  2763     QList<QSharedPointer<CaEntry> > entriesList;
       
  2764     entriesList.append(entryI3);
       
  2765     entriesList.append(entryI4);
       
  2766     clientNotifier->mEntryId = 0;
       
  2767     clientNotifier->mGroupId = 0;
       
  2768 
       
  2769     bool inserted = mService->insertEntriesIntoGroup((CaEntry &)*entryG, entriesList, entryI2->id());
       
  2770     QTest::qWait(waitTime1sec);
       
  2771 
       
  2772     QVERIFY(clientNotifier->mGroupId > 0);
       
  2773     QCOMPARE(clientNotifier->mGroupId, groupId);
       
  2774     QCOMPARE(clientNotifier->mGroupId, entryG->id());
       
  2775     QCOMPARE(inserted, TRUE);
       
  2776 
       
  2777     // cleanup
       
  2778     disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
  2779                clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
  2780     disconnect(notifier, SIGNAL(groupContentChanged(int)),
       
  2781                clientNotifier, SLOT(groupContentChanged(int)));
       
  2782     QTest::qWait(waitTime500ms);
       
  2783     delete clientNotifier;
       
  2784     mService->removeEntry(entryI1->id());
       
  2785     QTest::qWait(waitTime500ms);
       
  2786     mService->removeEntry(entryI2->id());
       
  2787     QTest::qWait(waitTime500ms);
       
  2788     mService->removeEntry(entryI3->id());
       
  2789     QTest::qWait(waitTime500ms);
       
  2790     mService->removeEntry(entryI4->id());
       
  2791     QTest::qWait(waitTime500ms);
       
  2792     mService->removeEntry(entryG->id());
       
  2793     QTest::qWait(waitTime1sec);
       
  2794     entriesList.clear();
       
  2795 #ifdef Q_OS_SYMBIAN
       
  2796 #ifdef UT_MEMORY_CHECK
       
  2797 // __UHEAP_MARKEND;
       
  2798 #endif//UT_MEMORY_CHECK
       
  2799 #endif//Q_OS_SYMBIAN
       
  2800 }
       
  2801 // ---------------------------------------------------------------------------
       
  2802 //
       
  2803 void TestCaClient::TestInsertEntriesGroupIdNotifier()
       
  2804 {
       
  2805 #ifdef Q_OS_SYMBIAN
       
  2806 #ifdef UT_MEMORY_CHECK
       
  2807 // __UHEAP_MARK;
       
  2808 #endif//UT_MEMORY_CHECK
       
  2809 #endif//Q_OS_SYMBIAN
       
  2810 
       
  2811     TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService);
       
  2812     CaNotifier *notifier = clientNotifier->getNotifier();
       
  2813 
       
  2814     connect(notifier, SIGNAL(entryChanged(int, ChangeType)),
       
  2815             clientNotifier, SLOT(entryChanged(int, ChangeType)));
       
  2816     QTest::qWait(waitTime500ms);
       
  2817     CaEntry group(GroupEntryRole);
       
  2818     group.setText("Text");
       
  2819     group.setEntryTypeName("TypeName");
       
  2820     QSharedPointer<CaEntry> entryG = mService->createEntry(group);
       
  2821     QTest::qWait(waitTime1sec);
       
  2822     int groupId = entryG->id();
       
  2823 
       
  2824     QCOMPARE(clientNotifier->mChangeType, AddChangeType);
       
  2825     QVERIFY(clientNotifier->mEntryId > 0);
       
  2826     QCOMPARE(clientNotifier->mEntryId, entryG->id());
       
  2827 
       
  2828     connect(notifier, SIGNAL(groupContentChanged(int)),
       
  2829             clientNotifier, SLOT(groupContentChanged(int)));
       
  2830     QTest::qWait(waitTime500ms);
       
  2831     CaEntry item1;
       
  2832     item1.setText("Text1");
       
  2833     item1.setEntryTypeName("TypeName1");
       
  2834     QSharedPointer<CaEntry> entryI1 = mService->createEntry(item1);
       
  2835     QTest::qWait(waitTime1sec);
       
  2836     CaEntry item2;
       
  2837     item2.setText("Text2");
       
  2838     item2.setEntryTypeName("TypeName2");
       
  2839     QSharedPointer<CaEntry> entryI2 = mService->createEntry(item2);
       
  2840     QTest::qWait(waitTime1sec);
       
  2841 
       
  2842     bool appended = mService->appendEntryToGroup((CaEntry &)(*entryG), *entryI1);
       
  2843     QTest::qWait(waitTime500ms);
       
  2844     QCOMPARE(appended, TRUE);
       
  2845     appended = mService->prependEntryToGroup((CaEntry &)(*entryG), *entryI2);
       
  2846     QTest::qWait(waitTime500ms);
       
  2847     QCOMPARE(appended, TRUE);
       
  2848 
       
  2849     CaEntry item3;
       
  2850     item3.setText("Text3");
       
  2851     item3.setEntryTypeName("TypeName3");
       
  2852     QSharedPointer<CaEntry> entryI3 = mService->createEntry(item3);
       
  2853     QTest::qWait(waitTime1sec);
       
  2854     CaEntry item4;
       
  2855     item4.setText("Text4");
       
  2856     item4.setEntryTypeName("TypeName4");
       
  2857     QSharedPointer<CaEntry> entryI4 = mService->createEntry(item4);
       
  2858     QTest::qWait(waitTime1sec);
       
  2859 
       
  2860     QList<int> entriesIdsList;
       
  2861     entriesIdsList.append(entryI3->id());
       
  2862     entriesIdsList.append(entryI4->id());
       
  2863     clientNotifier->mEntryId = 0;
       
  2864     clientNotifier->mGroupId = 0;
       
  2865 
       
  2866     bool inserted = mService->insertEntriesIntoGroup(entryG->id(), entriesIdsList, entryI2->id());
       
  2867     QTest::qWait(waitTime1sec);
       
  2868 
       
  2869     QVERIFY(clientNotifier->mGroupId > 0);
       
  2870     QCOMPARE(clientNotifier->mGroupId, groupId);
       
  2871     QCOMPARE(clientNotifier->mGroupId, entryG->id());
       
  2872     QCOMPARE(inserted, TRUE);
       
  2873 
       
  2874     // cleanup
       
  2875     disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
  2876                clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
  2877     disconnect(notifier, SIGNAL(groupContentChanged(int)),
       
  2878                clientNotifier, SLOT(groupContentChanged(int)));
       
  2879     QTest::qWait(waitTime500ms);
       
  2880     delete clientNotifier;
       
  2881     mService->removeEntry(entryI1->id());
       
  2882     QTest::qWait(waitTime500ms);
       
  2883     mService->removeEntry(entryI2->id());
       
  2884     QTest::qWait(waitTime500ms);
       
  2885     mService->removeEntry(entryI3->id());
       
  2886     QTest::qWait(waitTime500ms);
       
  2887     mService->removeEntry(entryI4->id());
       
  2888     QTest::qWait(waitTime500ms);
       
  2889     mService->removeEntry(entryG->id());
       
  2890     QTest::qWait(waitTime1sec);
       
  2891     entriesIdsList.clear();
       
  2892 
       
  2893 #ifdef Q_OS_SYMBIAN
       
  2894 #ifdef UT_MEMORY_CHECK
       
  2895 // __UHEAP_MARKEND;
       
  2896 #endif//UT_MEMORY_CHECK
       
  2897 #endif//Q_OS_SYMBIAN
       
  2898 }
       
  2899 
       
  2900 // ---------------------------------------------------------------------------
       
  2901 //
       
  2902 void TestCaClient::TestChangeEntryWithParentIdNotifier()
       
  2903 {
       
  2904 #ifdef Q_OS_SYMBIAN
       
  2905 #ifdef UT_MEMORY_CHECK
       
  2906 // __UHEAP_MARK;
       
  2907 #endif//UT_MEMORY_CHECK
       
  2908 #endif//Q_OS_SYMBIAN
       
  2909     CaNotifierFilter *filter = new CaNotifierFilter();
       
  2910     filter->setParentId(1); // AllCollections
       
  2911     TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService, filter);
       
  2912 
       
  2913     CaNotifier *notifier = clientNotifier->getNotifier();
       
  2914 
       
  2915     connect(notifier, SIGNAL(entryChanged(int, ChangeType)),
       
  2916             clientNotifier, SLOT(entryChanged(int, ChangeType)));
       
  2917     connect(notifier, SIGNAL(groupContentChanged(int)),
       
  2918             clientNotifier, SLOT(groupContentChanged(int)));
       
  2919     QTest::qWait(waitTime500ms);
       
  2920 
       
  2921     CaEntry entryToAdd(ItemEntryRole);
       
  2922     entryToAdd.setText("Text");
       
  2923     entryToAdd.setEntryTypeName("TypeName");
       
  2924     QSharedPointer<CaEntry> entry = mService->createEntry(entryToAdd);
       
  2925     QTest::qWait(waitTime1sec);
       
  2926     int entryId = entry->id();
       
  2927 
       
  2928     QCOMPARE(clientNotifier->mChangeType, AddChangeType);
       
  2929     QCOMPARE(clientNotifier->mEntryId, 0);
       
  2930     QCOMPARE(clientNotifier->mCount, 0);
       
  2931 
       
  2932     bool appended = mService->appendEntryToGroup(3, entryId); // office
       
  2933     QTest::qWait(waitTime1sec);
       
  2934 
       
  2935 
       
  2936     QCOMPARE(clientNotifier->mChangeType, AddChangeType);
       
  2937     QVERIFY(clientNotifier->mGroupId > 0);
       
  2938     QCOMPARE(clientNotifier->mCount, 1);
       
  2939 
       
  2940     mService->removeEntry(entryId);
       
  2941 
       
  2942     QTest::qWait(waitTime1sec);
       
  2943 
       
  2944     QCOMPARE(clientNotifier->mChangeType, RemoveChangeType);
       
  2945     QVERIFY(clientNotifier->mGroupId > 0);
       
  2946     QCOMPARE(clientNotifier->mCount, 2);
       
  2947 
       
  2948     disconnect(notifier, SIGNAL(entryChanged(int, ChangeType)),
       
  2949                clientNotifier, SLOT(entryChanged(int, ChangeType)));
       
  2950     disconnect(notifier, SIGNAL(groupContentChanged(int)),
       
  2951                clientNotifier, SLOT(groupContentChanged(int)));
       
  2952 
       
  2953     QTest::qWait(waitTime500ms);
       
  2954 
       
  2955     delete clientNotifier;
       
  2956     delete filter;
       
  2957 
       
  2958 
       
  2959 #ifdef Q_OS_SYMBIAN
       
  2960 #ifdef UT_MEMORY_CHECK
       
  2961 // __UHEAP_MARKEND;
       
  2962 #endif//UT_MEMORY_CHECK
       
  2963 #endif//Q_OS_SYMBIAN
       
  2964 }
       
  2965 
       
  2966 //QTEST_MAIN(homescreen::test::TestCaClient)