contentstorage/caclient/tsrc/t_caclient/src/t_caclient_notifier_ext.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:  Extra tests notifications.
       
    15 *
       
    16 */
       
    17 
       
    18 
       
    19 #include "t_caclient.h"
       
    20 #include "caservice.h"
       
    21 #include "canotifier.h"
       
    22 #include "canotifierfilter.h"
       
    23 #include "t_caclientnotifier.h"
       
    24 
       
    25 const int entryIdFake(-1);
       
    26 const int waitTimeMin(100);
       
    27 const int waitTime500ms(500);
       
    28 const int waitTime1sec(1000);
       
    29 
       
    30 const int noOfClients(3);
       
    31 const int noOfManyClients(20);
       
    32 
       
    33 class Thread: public QThread
       
    34 {
       
    35 public:
       
    36     enum OpType {None, AddItem, RemoveEntry, RemoveEntryId, TooMuchClients};
       
    37     void run();
       
    38     Thread(): mOpType(None), mRemoved(false), mEntry(), mId(0), mClientNotifier(NULL), mNotifier(NULL) { }
       
    39     ~Thread();
       
    40 
       
    41     OpType mOpType;
       
    42     bool mRemoved;
       
    43     QSharedPointer<CaEntry> mEntry;
       
    44     int mId;
       
    45     TestCaClientNotifier *mClientNotifier;
       
    46     CaNotifier *mNotifier;
       
    47 };
       
    48 
       
    49 Thread::~Thread()
       
    50 {
       
    51     QSharedPointer<CaService> service = CaService::instance();
       
    52     service->removeEntry(mId);
       
    53     disconnect(mNotifier, SIGNAL(entryChanged(int,ChangeType)),
       
    54                mClientNotifier, SLOT(entryChanged(int,ChangeType)));
       
    55     QTest::qWait(waitTime500ms);
       
    56     delete mClientNotifier;
       
    57 }
       
    58 
       
    59 void Thread::run()
       
    60 {
       
    61     QTest::qWait(waitTimeMin);
       
    62     QSharedPointer<CaService> service = CaService::instance();
       
    63     CaNotifierFilter *filter = new CaNotifierFilter();
       
    64     filter->setEntryRole(ItemEntryRole);
       
    65     filter->setTypeNames(QStringList() << "TypeName");
       
    66     mClientNotifier = new TestCaClientNotifier(*service, filter);
       
    67     mNotifier = mClientNotifier->getNotifier();
       
    68     CaEntry item;
       
    69     item.setText("Text");
       
    70     item.setEntryTypeName("TypeName");
       
    71     switch (mOpType) {
       
    72     case AddItem: {
       
    73         connect(mNotifier, SIGNAL(entryChanged(int,ChangeType)),
       
    74                 mClientNotifier, SLOT(entryChanged(int,ChangeType)));
       
    75         QTest::qWait(waitTime1sec);
       
    76         QSharedPointer<CaEntry> entry = service->createEntry(item);
       
    77         mId = entry->id();
       
    78     }
       
    79     break;
       
    80     case RemoveEntry: {
       
    81         connect(mNotifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)),
       
    82                 mClientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType)));
       
    83         QTest::qWait(waitTime1sec);
       
    84         mRemoved = service->removeEntry(*mEntry);
       
    85     }
       
    86     break;
       
    87     case RemoveEntryId: {
       
    88         connect(mNotifier, SIGNAL(entryChanged(int,ChangeType)),
       
    89                 mClientNotifier, SLOT(entryChanged(int,ChangeType)));
       
    90         QTest::qWait(waitTime1sec);
       
    91         mRemoved = service->removeEntry(mId);
       
    92     }
       
    93     break;
       
    94     case TooMuchClients: {
       
    95         connect(mNotifier, SIGNAL(entryChanged(int,ChangeType)),
       
    96                 mClientNotifier, SLOT(entryChanged(int,ChangeType)));
       
    97     }
       
    98     break;
       
    99     default:
       
   100         qWarning("Thread::run: unknown operation (mOpType)");
       
   101         break;
       
   102     }
       
   103 
       
   104     exec();
       
   105 }
       
   106 
       
   107 /*
       
   108 class ThreadRemoveEntry: public QThread
       
   109 {
       
   110 public:
       
   111     void run();
       
   112     ~ThreadRemoveEntry();
       
   113 
       
   114     bool mRemoved;
       
   115     CaEntry *mEntry;
       
   116     int mId;
       
   117     TestCaClientNotifier *mClientNotifier;
       
   118     CaNotifier *mNotifier;
       
   119 };
       
   120 
       
   121 ThreadRemoveEntry::~ThreadRemoveEntry()
       
   122 {
       
   123     disconnect(mNotifier, SIGNAL(entryChanged(int,ChangeType)),
       
   124         mClientNotifier, SLOT(entryChanged(int,ChangeType)) );
       
   125     QTest::qWait(waitTime500ms);
       
   126     delete mClientNotifier;
       
   127 }
       
   128 
       
   129 void ThreadRemoveEntry::run()
       
   130 {
       
   131     QSharedPointer<CaService> service = CaService::instance();
       
   132     TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*service);
       
   133     CaNotifier *notifier = clientNotifier->getNotifier();
       
   134     connect( notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType )),
       
   135             clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType )) );
       
   136 
       
   137     CaEntry item;
       
   138     item.setText("Text");
       
   139     item.setEntryTypeName("TypeName");
       
   140 
       
   141     mRemoved = service->removeEntry(*mEntry);
       
   142 
       
   143     exec();
       
   144 }
       
   145 */
       
   146 
       
   147 // ---------------------------------------------------------------------------
       
   148 // ---------------------------------------------------------------------------
       
   149 //
       
   150 void TestCaClient::TestAddItemChangeTypeNotifierNClients()
       
   151 {
       
   152 #ifdef Q_OS_SYMBIAN
       
   153 #ifdef UT_MEMORY_CHECK
       
   154     __UHEAP_MARK;
       
   155 #endif//UT_MEMORY_CHECK
       
   156 #endif//Q_OS_SYMBIAN
       
   157     {
       
   158         QSharedPointer<CaService> service = CaService::instance();
       
   159         TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*service);
       
   160         CaNotifier *notifier = clientNotifier->getNotifier();
       
   161         connect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
   162                 clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
   163 
       
   164         QTest::qWait(waitTime1sec);
       
   165         CaEntry item;
       
   166         item.setText("Text");
       
   167         item.setEntryTypeName("TypeName");
       
   168         QSharedPointer<CaEntry> entries[noOfClients];
       
   169         for (int i=0; i<noOfClients; i++) {
       
   170             item.setText("Text");
       
   171             item.setEntryTypeName("TypeName");
       
   172             entries[i] = service->createEntry(item);
       
   173             QTest::qWait(waitTime1sec);
       
   174             QCOMPARE(clientNotifier->mChangeType, AddChangeType);
       
   175             QCOMPARE(clientNotifier->mEntryId, entries[i]->id());
       
   176             QCOMPARE(clientNotifier->mCount, i+1);
       
   177         }
       
   178 
       
   179         for (int i=0; i<noOfClients; i++) {
       
   180             for (int j=i+1; j<noOfClients; j++) {
       
   181                 QVERIFY(entries[i]->id() != entries[j]->id());
       
   182             }
       
   183         }
       
   184 
       
   185         // cleanup
       
   186         disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
   187                    clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
   188         QTest::qWait(waitTime500ms);
       
   189         delete clientNotifier;
       
   190         for (int i=0; i<noOfClients; i++) {
       
   191             service->removeEntry(entries[i]->id());
       
   192         }
       
   193     }
       
   194 
       
   195 
       
   196 #ifdef Q_OS_SYMBIAN
       
   197 #ifdef UT_MEMORY_CHECK
       
   198     __UHEAP_MARKEND;
       
   199 #endif//UT_MEMORY_CHECK
       
   200 #endif//Q_OS_SYMBIAN
       
   201 }
       
   202 
       
   203 // ---------------------------------------------------------------------------
       
   204 // ---------------------------------------------------------------------------
       
   205 //
       
   206 void TestCaClient::TestAddItemChangeTypeNotifierNClientsFast()
       
   207 {
       
   208 #ifdef Q_OS_SYMBIAN
       
   209 #ifdef UT_MEMORY_CHECK
       
   210     __UHEAP_MARK;
       
   211 #endif//UT_MEMORY_CHECK
       
   212 #endif//Q_OS_SYMBIAN
       
   213     {
       
   214         QSharedPointer<CaService> service = CaService::instance();
       
   215         TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*service);
       
   216         CaNotifier *notifier = clientNotifier->getNotifier();
       
   217         connect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
   218                 clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
   219 
       
   220         QTest::qWait(waitTime1sec);
       
   221         CaEntry item;
       
   222         item.setText("Text");
       
   223         item.setEntryTypeName("TypeName");
       
   224         QSharedPointer<CaEntry> entries[noOfClients];
       
   225         item.setText("Text");
       
   226         item.setEntryTypeName("TypeName");
       
   227         for (int i=0; i<noOfClients; i++) {
       
   228             entries[i] = service->createEntry(item);
       
   229         }
       
   230         QTest::qWait(waitTime1sec);
       
   231         QCOMPARE(clientNotifier->mCount, 3);
       
   232         for (int i=0; i<noOfClients; i++) {
       
   233             QVERIFY(clientNotifier->mEntryIds->contains(entries[i]->id()));
       
   234             for (int j=i+1; j<noOfClients; j++) {
       
   235                 QVERIFY(entries[i]->id() != entries[j]->id());
       
   236             }
       
   237         }
       
   238 
       
   239         // cleanup
       
   240         disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
   241                    clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
   242         QTest::qWait(waitTime500ms);
       
   243         delete clientNotifier;
       
   244         for (int i=0; i<noOfClients; i++) {
       
   245             service->removeEntry(entries[i]->id());
       
   246         }
       
   247     }
       
   248 
       
   249 
       
   250 #ifdef Q_OS_SYMBIAN
       
   251 #ifdef UT_MEMORY_CHECK
       
   252     __UHEAP_MARKEND;
       
   253 #endif//UT_MEMORY_CHECK
       
   254 #endif//Q_OS_SYMBIAN
       
   255 }
       
   256 
       
   257 // ---------------------------------------------------------------------------
       
   258 // ---------------------------------------------------------------------------
       
   259 //
       
   260 void TestCaClient::TestAddItemChangeTypeNotifierNClientsThreads()
       
   261 {
       
   262 #ifdef Q_OS_SYMBIAN
       
   263 #ifdef UT_MEMORY_CHECK
       
   264     __UHEAP_MARK;
       
   265 #endif//UT_MEMORY_CHECK
       
   266 #endif//Q_OS_SYMBIAN
       
   267     {
       
   268         Thread threads[noOfClients];
       
   269         for (int i=0; i<noOfClients; i++) {
       
   270             threads[i].mOpType = Thread::AddItem;
       
   271             threads[i].start();
       
   272         }
       
   273         QTest::qWait(6*noOfClients*waitTime1sec);
       
   274 
       
   275         for (int i=0; i<noOfClients; i++) {
       
   276             QCOMPARE(threads[i].mClientNotifier->mCount, noOfClients);
       
   277             for (int j=0; j<noOfClients; j++) {
       
   278                 for (int k=j+1; k<noOfClients; k++) {
       
   279                     QVERIFY(threads[i].mClientNotifier->mEntryIds->at(j)
       
   280                             != threads[i].mClientNotifier->mEntryIds->at(k));
       
   281                 }
       
   282             }
       
   283         }
       
   284         for (int i=0; i<noOfClients; i++) {
       
   285             for (int j=0; j<noOfClients; j++) {
       
   286                 QVERIFY(threads[j].mClientNotifier->mEntryIds->contains(threads[i].mId));
       
   287             }
       
   288         }
       
   289 
       
   290         for (int i=0; i<noOfClients; i++) {
       
   291             threads[i].exit(0);
       
   292         }
       
   293         QTest::qWait(waitTime500ms);
       
   294 
       
   295     }
       
   296 
       
   297 #ifdef Q_OS_SYMBIAN
       
   298 #ifdef UT_MEMORY_CHECK
       
   299     __UHEAP_MARKEND;
       
   300 #endif//UT_MEMORY_CHECK
       
   301 #endif//Q_OS_SYMBIAN
       
   302 }
       
   303 
       
   304 // ---------------------------------------------------------------------------
       
   305 // ---------------------------------------------------------------------------
       
   306 //
       
   307 void TestCaClient::TestRemoveEntryChangeTypeNotifierNClients()
       
   308 {
       
   309 #ifdef Q_OS_SYMBIAN
       
   310 #ifdef UT_MEMORY_CHECK
       
   311     __UHEAP_MARK;
       
   312 #endif//UT_MEMORY_CHECK
       
   313 #endif//Q_OS_SYMBIAN
       
   314     {
       
   315         QSharedPointer<CaService> service = CaService::instance();
       
   316         TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*service);
       
   317         CaNotifier *notifier = clientNotifier->getNotifier();
       
   318         connect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
   319                 clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
   320         QTest::qWait(waitTime500ms);
       
   321         connect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)),
       
   322                 clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType)));
       
   323 
       
   324         QTest::qWait(waitTime1sec);
       
   325         CaEntry item;
       
   326         item.setText("Text");
       
   327         item.setEntryTypeName("TypeName");
       
   328         QSharedPointer<CaEntry> entries[noOfClients];
       
   329         for (int i=0; i<noOfClients; i++) {
       
   330             entries[i] = service->createEntry(item);
       
   331             QTest::qWait(waitTime1sec);
       
   332             QCOMPARE(clientNotifier->mChangeType, AddChangeType);
       
   333             QCOMPARE(clientNotifier->mEntryId, entries[i]->id());
       
   334             QCOMPARE(clientNotifier->mCount, 2*(i+1));
       
   335         }
       
   336         for (int i=0; i<noOfClients; i++) {
       
   337             bool removed = service->removeEntry(*entries[i]);
       
   338             QVERIFY(removed);
       
   339             QTest::qWait(waitTime1sec);
       
   340             QCOMPARE(clientNotifier->mChangeType, RemoveChangeType);
       
   341             QCOMPARE(clientNotifier->mEntryId, entries[i]->id());
       
   342         }
       
   343 
       
   344         // cleanup
       
   345         disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)),
       
   346                    clientNotifier, SLOT(entryChanged(int,ChangeType)));
       
   347         QTest::qWait(waitTime500ms);
       
   348         delete clientNotifier;
       
   349     }
       
   350 
       
   351 #ifdef Q_OS_SYMBIAN
       
   352 #ifdef UT_MEMORY_CHECK
       
   353     __UHEAP_MARKEND;
       
   354 #endif//UT_MEMORY_CHECK
       
   355 #endif//Q_OS_SYMBIAN
       
   356 }
       
   357 
       
   358 // ---------------------------------------------------------------------------
       
   359 // ---------------------------------------------------------------------------
       
   360 //
       
   361 void TestCaClient::TestRemoveEntryChangeTypeNotifierNClientsThreads()
       
   362 {
       
   363 #ifdef Q_OS_SYMBIAN
       
   364 #ifdef UT_MEMORY_CHECK
       
   365     __UHEAP_MARK;
       
   366 #endif//UT_MEMORY_CHECK
       
   367 #endif//Q_OS_SYMBIAN
       
   368     {
       
   369         QSharedPointer<CaService> service = CaService::instance();
       
   370         QTest::qWait(waitTime1sec);
       
   371         CaEntry item;
       
   372         item.setText("Text");
       
   373         item.setEntryTypeName("TypeName");
       
   374         QSharedPointer<CaEntry> entries[noOfClients];
       
   375         for (int i=0; i<noOfClients; i++) {
       
   376             entries[i] = service->createEntry(item);
       
   377         }
       
   378 
       
   379         QTest::qWait(waitTime1sec);
       
   380         Thread threads[noOfClients];
       
   381         for (int i=0; i<noOfClients; i++) {
       
   382             threads[i].mOpType = Thread::RemoveEntry;
       
   383             threads[i].mEntry = entries[i];
       
   384             threads[i].start();
       
   385         }
       
   386         QTest::qWait(6*noOfClients*waitTime1sec);
       
   387         for (int i=0; i<noOfClients; i++) {
       
   388             QVERIFY(threads[i].mRemoved);
       
   389             QCOMPARE(threads[i].mClientNotifier->mChangeType, RemoveChangeType);
       
   390             QCOMPARE(threads[i].mClientNotifier->mCount, noOfClients);
       
   391             QVERIFY(threads[i].mClientNotifier->mEntryIds->contains(entries[i]->id()));
       
   392         }
       
   393 
       
   394         for (int i=0; i<noOfClients; i++) {
       
   395             threads[i].exit(0);
       
   396         }
       
   397         QTest::qWait(waitTime500ms);
       
   398         
       
   399         // cleanup
       
   400         for (int i=0; i<noOfClients; i++) {
       
   401             bool removed = service->removeEntry(*entries[i]);
       
   402             QTest::qWait(waitTime1sec);
       
   403         }
       
   404 
       
   405     }
       
   406 
       
   407 #ifdef Q_OS_SYMBIAN
       
   408 #ifdef UT_MEMORY_CHECK
       
   409     __UHEAP_MARKEND;
       
   410 #endif//UT_MEMORY_CHECK
       
   411 #endif//Q_OS_SYMBIAN
       
   412 }
       
   413 
       
   414 // ---------------------------------------------------------------------------
       
   415 // ---------------------------------------------------------------------------
       
   416 //
       
   417 void TestCaClient::TestRemoveEntryIdChangeTypeNotifierNClientsThreads()
       
   418 {
       
   419 #ifdef Q_OS_SYMBIAN
       
   420 #ifdef UT_MEMORY_CHECK
       
   421     __UHEAP_MARK;
       
   422 #endif//UT_MEMORY_CHECK
       
   423 #endif//Q_OS_SYMBIAN
       
   424     {
       
   425         QSharedPointer<CaService> service = CaService::instance();
       
   426         QTest::qWait(waitTime1sec);
       
   427         CaEntry item;
       
   428         item.setText("Text");
       
   429         item.setEntryTypeName("TypeName");
       
   430         int ids[noOfClients];
       
   431         for (int i=0; i<noOfClients; i++) {
       
   432             ids[i] = service->createEntry(item)->id();
       
   433         }
       
   434 
       
   435         QTest::qWait(waitTime1sec);
       
   436         Thread threads[noOfClients];
       
   437         for (int i=0; i<noOfClients; i++) {
       
   438             threads[i].mOpType = Thread::RemoveEntryId;
       
   439             threads[i].mId = ids[i];
       
   440             threads[i].start();
       
   441         }
       
   442         QTest::qWait(6*noOfClients*waitTime1sec);
       
   443         for (int i=0; i<noOfClients; i++) {
       
   444             QVERIFY(threads[i].mRemoved);
       
   445             QCOMPARE(threads[i].mClientNotifier->mChangeType, RemoveChangeType);
       
   446             QCOMPARE(threads[i].mClientNotifier->mCount, noOfClients);
       
   447             QVERIFY(threads[i].mClientNotifier->mEntryIds->contains(ids[i]));
       
   448         }
       
   449 
       
   450         for (int i=0; i<noOfClients; i++) {
       
   451             threads[i].exit(0);
       
   452         }
       
   453         QTest::qWait(waitTime500ms);
       
   454         
       
   455         // cleanup
       
   456         for (int i=0; i<noOfClients; i++) {
       
   457             bool removed = service->removeEntry(ids[i]);
       
   458             QTest::qWait(waitTime1sec);
       
   459         }
       
   460 
       
   461     }
       
   462 
       
   463 #ifdef Q_OS_SYMBIAN
       
   464 #ifdef UT_MEMORY_CHECK
       
   465     __UHEAP_MARKEND;
       
   466 #endif//UT_MEMORY_CHECK
       
   467 #endif//Q_OS_SYMBIAN
       
   468 }
       
   469 
       
   470 // ---------------------------------------------------------------------------
       
   471 // ---------------------------------------------------------------------------
       
   472 //
       
   473 void TestCaClient::TestAddItemChangeTypeNotifierManyClientsThreads()
       
   474 {
       
   475 #ifdef Q_OS_SYMBIAN
       
   476 #ifdef UT_MEMORY_CHECK
       
   477     __UHEAP_MARK;
       
   478 #endif//UT_MEMORY_CHECK
       
   479 #endif//Q_OS_SYMBIAN
       
   480     {
       
   481         QSharedPointer<CaService> service = CaService::instance();
       
   482 
       
   483         Thread threads[noOfManyClients];
       
   484         for (int i=0; i<noOfManyClients; i++) {
       
   485             threads[i].mOpType = Thread::TooMuchClients;
       
   486             threads[i].start();
       
   487         }
       
   488         QTest::qWait(10*waitTime1sec);
       
   489         CaEntry item;
       
   490         item.setText("Text");
       
   491         item.setEntryTypeName("TypeName");
       
   492         int ids[noOfClients];
       
   493         for (int i=0; i<noOfClients; i++) {
       
   494             ids[i] = service->createEntry(item)->id();
       
   495         }
       
   496         QTest::qWait(6*noOfManyClients*waitTime1sec);
       
   497 
       
   498         for (int i=0; i<noOfManyClients; i++) {
       
   499             QCOMPARE(threads[i].mClientNotifier->mCount, noOfClients);
       
   500             for (int j=0; j<noOfClients; j++) {
       
   501                 for (int k=j+1; k<noOfClients; k++) {
       
   502                     QVERIFY(threads[i].mClientNotifier->mEntryIds->at(j)
       
   503                             != threads[i].mClientNotifier->mEntryIds->at(k));
       
   504                 }
       
   505             }
       
   506         }
       
   507         for (int i=0; i<noOfClients; i++) {
       
   508             for (int j=0; j<noOfManyClients; j++) {
       
   509                 QVERIFY(threads[j].mClientNotifier->mEntryIds->contains(ids[i]));
       
   510             }
       
   511         }
       
   512 
       
   513         for (int i=0; i<noOfManyClients; i++) {
       
   514             threads[i].exit(0);
       
   515         }
       
   516         QTest::qWait(waitTime500ms);
       
   517         
       
   518         // cleanup
       
   519         for (int i=0; i<noOfClients; i++) {
       
   520             bool removed = service->removeEntry(ids[i]);
       
   521             QVERIFY(removed);
       
   522             QTest::qWait(waitTime1sec);
       
   523         }
       
   524 
       
   525     }
       
   526 
       
   527 #ifdef Q_OS_SYMBIAN
       
   528 #ifdef UT_MEMORY_CHECK
       
   529     __UHEAP_MARKEND;
       
   530 #endif//UT_MEMORY_CHECK
       
   531 #endif//Q_OS_SYMBIAN
       
   532 }