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:

    15 *

    16 */

    17 

    18 #include <QtTest/QtTest>

    19 #include "t_tsservicesprovider.h"

    20 #include "tsservicesproviderconfig.h"

    21 #include "tsservice.h"

    22 #include "tsservicesprovider.h"

    23 #include "tsserviceobserver.h"

    24 

    25 

    26 class QtModel: public QObject

    27 {

    28     QList<QVariantHash> taskList() const

    29     {

    30         return QList<QVariantHash>();

    31     }

    32     

    33     QList<QVariantHash> taskList(int limit) const

    34     {

    35         Q_UNUSED(limit);

    36         return QList<QVariantHash>();

    37     }

    38     

    39     bool openTask(const QVariant &/*id*/){return true;};

    40     bool closeTask(const QVariant &/*id*/){return true;};

    41 };

    42 

    43 void T_TsServiceProvider::testProvider()

    44 {

    45     CTsServiceProvider *provider(0);

    46     CTsServiceProviderConfig* config(0);

    47     //test provider with different amount of data

    48     int errNo;

    49     const int maxDataCount(4);

    50     

    51     

    52     for(TInt dataCount(0); dataCount < maxDataCount; ++dataCount) {

    53         config = CTsServiceProviderConfig::NewLC(dataCount);

    54         provider = CTsServiceProvider::NewL(*config);

    55         CleanupStack::PopAndDestroy(config);

    56         QVERIFY(dataCount == provider->count());

    57         for(TInt dataProviderIter(0); dataProviderIter < provider->count(); ++dataProviderIter) {

    58             MTsModel& model((*provider)[dataProviderIter]);

    59             

    60             //we dont verify data. just try to retrieve it. model can leave but shouldn't panic

    61             for (TInt dataIter(0); dataIter < model.count(); ++dataIter) {

    62                 TRAP_IGNORE(model.itemL(dataIter).keyL());

    63                 TRAP_IGNORE(model.itemL(dataIter).displayNameL());

    64                 TRAP_IGNORE(model.itemL(dataIter).iconHandleL());

    65                 TRAP_IGNORE(model.itemL(dataIter).isActiveL());

    66                 TRAP_IGNORE(model.itemL(dataIter).isClosableL());

    67                 TRAP_IGNORE(model.itemL(dataIter).timestampL());

    68                 TRAP_IGNORE(model.itemL(dataIter).launchL());

    69                 TRAP_IGNORE(model.itemL(dataIter).closeL());

    70             }

    71             TRAP(errNo, model.itemL(model.count()).keyL());

    72             QVERIFY(KErrNone != errNo);

    73             TRAP(errNo, model.itemL(model.count()).displayNameL());

    74             QVERIFY(KErrNone != errNo);

    75             TRAP(errNo, model.itemL(model.count()).iconHandleL());

    76             QVERIFY(KErrNone != errNo);

    77             TRAP(errNo, model.itemL(model.count()).isActiveL());

    78             QVERIFY(KErrNone != errNo);

    79             TRAP(errNo, model.itemL(model.count()).isClosableL());

    80             QVERIFY(KErrNone != errNo);

    81             TRAP(errNo, model.itemL(model.count()).timestampL());

    82             QVERIFY(KErrNone != errNo);

    83             TRAP(errNo, model.itemL(model.count()).launchL());

    84             QVERIFY(KErrNone != errNo);

    85             TRAP(errNo, model.itemL(model.count()).closeL());

    86             QVERIFY(KErrNone != errNo);

    87             

    88             TRAP(errNo, model.itemL(model.count() + 1).keyL());

    89             QVERIFY(KErrNone != errNo);

    90             TRAP(errNo, model.itemL(model.count() + 1).displayNameL());

    91             QVERIFY(KErrNone != errNo);

    92             TRAP(errNo, model.itemL(model.count() + 1).iconHandleL());

    93             QVERIFY(KErrNone != errNo);

    94             TRAP(errNo, model.itemL(model.count() + 1).isActiveL());

    95             QVERIFY(KErrNone != errNo);

    96             TRAP(errNo, model.itemL(model.count() + 1).isClosableL());

    97             QVERIFY(KErrNone != errNo);

    98             TRAP(errNo, model.itemL(model.count() + 1).timestampL());

    99             QVERIFY(KErrNone != errNo);

   100             TRAP(errNo, model.itemL(model.count() + 1).launchL());

   101             QVERIFY(KErrNone != errNo);

   102             TRAP(errNo, model.itemL(model.count() + 1).closeL());

   103             QVERIFY(KErrNone != errNo);

   104         }

   105         delete provider;

   106     }

   107 }

   108 

   109 void T_TsServiceProvider::testService()

   110 {

   111     int errNo, maxNotifications(20);

   112     CTsService* service;

   113     mNotyfications = 0;

   114     

   115     TRAP(errNo, service = CTsService::NewLC(0));

   116     QVERIFY(KErrNone != errNo);

   117     

   118     TRAP(errNo, 

   119     service = CTsService::NewLC(new QtModel());

   120     service->setObserver(0);

   121     service->DataChanged();

   122     if(0 != mNotyfications){

   123         User::Leave(KErrCorrupt);

   124     }

   125     service->setObserver(this);

   126     for(int iter(0); iter < maxNotifications; ++iter) {

   127         service->DataChanged();

   128         if(iter + 1 != mNotyfications){

   129             User::Leave(KErrCorrupt);

   130         }

   131     }

   132     CleanupStack::PopAndDestroy(service);

   133     );//TRAP

   134     QVERIFY(KErrNone == errNo);

   135 }

   136 

   137 void T_TsServiceProvider::testServiceObserver()

   138 {

   139     TsServiceObserver observer(*this);

   140     QObject::connect(this,

   141                      SIGNAL(someSignal()),

   142                      &observer,

   143                      SLOT(dataChanged()));

   144     QTimer::singleShot(5000, &mLoop, SLOT(quit()));

   145     mNotyfications = 0;

   146     emit someSignal();

   147     if(0 == mNotyfications && !mLoop.isRunning()) {

   148         mLoop.exec();

   149     }

   150     QVERIFY(1 == mNotyfications);

   151 }

   152 

   153 void T_TsServiceProvider::dataChanged(MTsModel &/*model*/)

   154 {

   155     ++mNotyfications;

   156 }

   157 

   158 void T_TsServiceProvider::dataChanged(const TTsModelItem &/*item*/)

   159 {

   160 }

   161 

   162 void T_TsServiceProvider::DataChanged()

   163 {

   164     ++mNotyfications;

   165     if(mLoop.isRunning()) {

   166         mLoop.quit();

   167     }

   168 }

   169 

   170 QTEST_MAIN(T_TsServiceProvider)