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 }