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