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 "t_tsmodel.h"

    19 #include <qservicemanager.h>

    20 #include <QtTest/QtTest>

    21 #include "tsmodel.h"

    22 #include "afmanager.h"

    23 #include <afstorageglobals.h>

    24 #include "tstaskchangeinfo.h"

    25 

    26 #include <hbicon.h>

    27 

    28 #define TSTASKMONITOR_TEST 1

    29 

    30 const int dataSetsCount(50);

    31 const char serviceName [] = "TestActivityService";

    32 const char ActivityIconKeyword [] = "screenshot";

    33 const char ActivityVisibleKeyword [] = "visible";

    34 

    35 //TEST CASES

    36 

    37 void T_TsModel::testData()

    38 {

    39     QVERIFY(mModel);

    40     QVERIFY(activityService());

    41     for (int dataSet(0); dataSet < activityDataSetsCount(); ++dataSet) {

    42         QList<QVariantHash>data(activityDataSet(dataSet));

    43         //provide test data to TestActivityManager

    44         QMetaObject::invokeMethod(activityService(),

    45                                   "setActivitiesList",

    46                                   Q_ARG(QList<QVariantHash>, data));

    47         QList<TsTaskChange> applications(appDataSetFull(dataSet));

    48         QMetaObject::invokeMethod(mAppSrv,

    49                                   "setTaskList",

    50                                   Q_ARG(QList<TsTaskChange>, applications));

    51         //force data update on model. framework doesnt provide observer functionality

    52         mModel->fullUpdate();

    53 

    54         int offset =0;

    55 

    56         //Verify data. Applications come first...

    57         

    58         foreach ( TsTaskChange application, applications) {

    59             if(application.first.changeType() == TsTaskChangeInfo::EChangeCancel ) {

    60                 continue;

    61             }

    62             QVERIFY(application.second->name() == mModel->data(mModel->index(offset), Qt::DisplayRole).toString());

    63             //icon can't be realy checked, but can be called

    64             mModel->data(mModel->index(offset), Qt::DecorationRole);

    65             QVERIFY(application.second->isClosable() == mModel->data(mModel->index(offset), Qt::UserRole + 1).toBool());//is closable

    66 

    67             QVERIFY(!mModel->data(mModel->index(offset), Qt::UserRole + 100).isValid());//call some unsupported role

    68             ++offset;//move to next model row

    69         }

    70 

    71         //Activity come second

    72         QList<QVariantHash>::const_iterator activity(data.begin());

    73         for (; activity != data.end(); ++activity) {

    74             QString debstr = mModel->data(mModel->index(offset), Qt::DisplayRole).toString();

    75             QVERIFY(0>=mModel->data(mModel->index(offset), Qt::DisplayRole).toString().length());

    76             //icon can't be realy checked, but can be called

    77             mModel->data(mModel->index(offset), Qt::DecorationRole);

    78             QVERIFY(!mModel->data(mModel->index(offset), Qt::UserRole + 1).toBool());//is closable

    79 

    80             QVERIFY(!mModel->data(mModel->index(offset), Qt::UserRole + 100).isValid());//call some unsupported role

    81             ++offset;//move to next model row

    82         }

    83         //call data out of range

    84         QVERIFY(!mModel->data(mModel->index(-1), Qt::DisplayRole).isValid());

    85     }

    86 }

    87 

    88 void T_TsModel::testRowCount()

    89 {

    90     QVERIFY(mModel);

    91     QVERIFY(activityService());

    92     for (int dataSet(0); dataSet < activityDataSetsCount(); ++dataSet) {

    93         QList<QVariantHash> activity(activityDataSet(dataSet));

    94         //provide test data to TestActivityManager

    95         QMetaObject::invokeMethod(activityService(),

    96                                   "setActivitiesList",

    97                                   Q_ARG(QList<QVariantHash>, activity));

    98         

    99         

   100         QList<TsTaskChange> applications(appDataSetFull(dataSet));

   101         //provide test data to TestActivityManager

   102         QMetaObject::invokeMethod(mAppSrv,

   103                                   "setTaskList",

   104                                   Q_ARG(QList<TsTaskChange>, applications));

   105         

   106         

   107         //force data update on model. framework doesnt provide observer functionality

   108         mModel->fullUpdate();

   109         QVERIFY(mModel->rowCount() <= (activity.count() + applications.count()));

   110     }

   111 }

   112 

   113 void T_TsModel::testOpenApplication()

   114 {

   115     QMetaObject::invokeMethod(activityService(),

   116                               "setActivitiesList",

   117                               Q_ARG(QList<QVariantHash>, activityDataSet(1)));

   118     mModel->fullUpdate();

   119     for (int i =0; i < mModel->rowCount(); ++i) {

   120         mModel->openApplication(mModel->index(i));//just call without veryfication

   121     }

   122     mModel->openApplication(mModel->index(-1));//just call without veryfication

   123 

   124 }

   125 

   126 void T_TsModel::testCloseApplication()

   127 {

   128     QMetaObject::invokeMethod(activityService(),

   129                               "setActivitiesList",

   130                               Q_ARG(QList<QVariantHash>, activityDataSet(1)));

   131     mModel->fullUpdate();

   132     for (int i =0; i < mModel->rowCount(); ++i) {

   133         mModel->closeApplication(mModel->index(i));//just call without veryfication

   134     }

   135     mModel->closeApplication(mModel->index(-1));//just call without veryfication

   136 }

   137 

   138 void T_TsModel::testActivityWithNoIdDisplaysProperApplicationName()

   139 {

   140     // prepare activity entry with no activity ID, but with proper application name

   141     QVariantHash activity;

   142     RProcess process;

   143     activity.insert(ActivityApplicationKeyword, static_cast<int>(process.SecureId().iId));

   144     

   145     // prepare data set with only prepared activity

   146     QVERIFY(QMetaObject::invokeMethod(activityService(),

   147                                       "setActivitiesList",

   148                                       Q_ARG(QList<QVariantHash>, QList<QVariantHash>() << activity)));

   149     QVERIFY(QMetaObject::invokeMethod(mAppSrv,

   150                                   "setTaskList",

   151                                   Q_ARG(QList<TsTaskChange>, QList<TsTaskChange>())));

   152     mModel->fullUpdate();

   153  

   154     // verify the application name is correctly returned as a DisplayRole

   155     QCOMPARE(mModel->rowCount(), 1);

   156     QVERIFY(mModel->index(0).isValid());

   157     QVERIFY(!mModel->data(mModel->index(0), Qt::DisplayRole).toString().isEmpty()); 

   158 }

   159 

   160 void T_TsModel::testDataChangedSignalIsEmittedWhenActivityScreenshotIsUpdated()

   161 {

   162     // prepare activity entry

   163     QVariantHash activity;

   164     activity.insert(ActivityIconKeyword, "FakeScreenshotPath");

   165     

   166     // prepare data set with only prepared activity

   167     QVERIFY(QMetaObject::invokeMethod(activityService(),

   168                                       "setActivitiesList",

   169                                       Q_ARG(QList<QVariantHash>, QList<QVariantHash>() << activity)));

   170     QVERIFY(QMetaObject::invokeMethod(mAppSrv,

   171                                   "setTaskList",

   172                                   Q_ARG(QList<TsTaskChange>, QList<TsTaskChange>())));

   173     mModel->fullUpdate();

   174  

   175     // prepare signal spy    

   176     qRegisterMetaType<QModelIndex>("QModelIndex");

   177     QSignalSpy spy(mModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)));

   178     QVERIFY(spy.isValid());

   179  

   180     // getting the decoration role should trigger asynchronous screenshot retrieval and dataChanged signal emission

   181     QCOMPARE(mModel->rowCount(), 1);

   182     QVERIFY(mModel->index(0).isValid());

   183     mModel->data(mModel->index(0), Qt::DecorationRole);

   184     

   185     // verify proper data passed in signal

   186     QCOMPARE(spy.count(), 1);

   187     QCOMPARE(spy.first().at(0).value<QModelIndex>().row(), 0);

   188     QCOMPARE(spy.first().at(1).value<QModelIndex>().row(), 0);

   189 }

   190 

   191 void T_TsModel::testCustomNameIsUsedIfPresent()

   192 {

   193     RProcess process;

   194     int applicationId = static_cast<int>(process.SecureId().iId);

   195 

   196     // prepare activity entries

   197     QVariantHash activityWithCustomName;

   198     activityWithCustomName.insert(ActivityApplicationName, "Custom Activity Name");

   199     activityWithCustomName.insert(ActivityApplicationKeyword, applicationId);

   200     

   201     QVariantHash otherActivity;

   202     otherActivity.insert(ActivityApplicationKeyword, applicationId);

   203     

   204     // prepare data set with only prepared activities

   205     QVERIFY(QMetaObject::invokeMethod(activityService(),

   206                                       "setActivitiesList",

   207                                       Q_ARG(QList<QVariantHash>, QList<QVariantHash>() << activityWithCustomName << otherActivity)));

   208     QVERIFY(QMetaObject::invokeMethod(mAppSrv,

   209                                   "setTaskList",

   210                                   Q_ARG(QList<TsTaskChange>, QList<TsTaskChange>())));

   211     mModel->fullUpdate();

   212 

   213     // first activity uses custom name

   214     QCOMPARE(mModel->rowCount(), 2);

   215     QCOMPARE(mModel->data(mModel->index(0), Qt::DisplayRole), QVariant("Custom Activity Name"));

   216  

   217     // second one didn't define custom name, so it uses application name

   218     QVERIFY(!mModel->data(mModel->index(1), Qt::DisplayRole).toString().isEmpty()); 

   219 }

   220 

   221 void T_TsModel::testInsert1()

   222 {

   223     QVERIFY(mModel);

   224     clearModel();

   225     QVERIFY(QMetaObject::invokeMethod(mAppSrv,

   226                                    "setTaskList",

   227                                    Q_ARG(QList<TsTaskChange>, changeDataSet5New())));

   228     QCOMPARE(mModel->rowCount(), 5);

   229     QVERIFY(QMetaObject::invokeMethod(mAppSrv,

   230                                    "setTaskList",

   231                                    Q_ARG(QList<TsTaskChange>, changeDataSetInsert1(3))));

   232     QCOMPARE(mModel->rowCount(), 6);    

   233     QVERIFY(changeDataSetInsert1(3)[0].second->name() == mModel->data(mModel->index(3), Qt::DisplayRole).toString());

   234     

   235 }

   236 

   237 void T_TsModel::testDelete1()

   238 {

   239     QVERIFY(mModel);

   240     clearModel();

   241     QVERIFY(QMetaObject::invokeMethod(mAppSrv,

   242                                    "setTaskList",

   243                                    Q_ARG(QList<TsTaskChange>, changeDataSet5New())));

   244     QCOMPARE(mModel->rowCount(), 5);

   245     QVERIFY(QMetaObject::invokeMethod(mAppSrv,

   246                                    "setTaskList",

   247                                    Q_ARG(QList<TsTaskChange>, changeDataSetDelete1(1))));

   248     QCOMPARE(mModel->rowCount(), 4);    

   249     QCOMPARE(changeDataSet5New()[3].second->name(), mModel->data(mModel->index(1), Qt::DisplayRole).toString());    

   250 }

   251 

   252 void T_TsModel::testChange1()

   253 {

   254     QVERIFY(mModel);

   255     clearModel();

   256     QVERIFY(QMetaObject::invokeMethod(mAppSrv,

   257                                    "setTaskList",

   258                                    Q_ARG(QList<TsTaskChange>, changeDataSet5New())));

   259     QCOMPARE(mModel->rowCount(), 5);

   260     QVERIFY(QMetaObject::invokeMethod(mAppSrv,

   261                                    "setTaskList",

   262                                    Q_ARG(QList<TsTaskChange>, changeDataSetChange1(2))));

   263     QCOMPARE(mModel->rowCount(), 5);    

   264     QCOMPARE(changeDataSetChange1(2)[0].second->name(), mModel->data(mModel->index(2), Qt::DisplayRole).toString());      

   265 }

   266 

   267 void T_TsModel::testMove1()

   268 {

   269     QVERIFY(mModel);

   270     clearModel();

   271     QVERIFY(QMetaObject::invokeMethod(mAppSrv,

   272                                    "setTaskList",

   273                                    Q_ARG(QList<TsTaskChange>, changeDataSet5New())));

   274     QCOMPARE(mModel->rowCount(), 5);

   275     QVERIFY(QMetaObject::invokeMethod(mAppSrv,

   276                                    "setTaskList",

   277                                    Q_ARG(QList<TsTaskChange>, changeDataSetMove1(1,2))));

   278     QCOMPARE(mModel->rowCount(), 5);    

   279     QCOMPARE(changeDataSet5New()[2].second->name(), mModel->data(mModel->index(2), Qt::DisplayRole).toString());

   280     QCOMPARE(changeDataSet5New()[3].second->name(), mModel->data(mModel->index(1), Qt::DisplayRole).toString());   

   281 }

   282 

   283 void T_TsModel::testFullUpdateFromActivities()

   284 {

   285     QVERIFY(mModel);

   286     QVERIFY(activityService());

   287     clearModel();

   288     QList<QVariantHash> activity(activityDataSet(5));

   289     //provide test data to TestActivityManager

   290     QMetaObject::invokeMethod(activityService(),

   291                               "setActivitiesList",

   292                               Q_ARG(QList<QVariantHash>, activity));

   293     QMetaObject::invokeMethod(activityService(),

   294                               "emitDataChanged");   

   295     QCOMPARE(mModel->rowCount(), 5); 

   296 }

   297 

   298 //QTEST CALLBACKS

   299 

   300 void T_TsModel::initTestCase()

   301 {

   302     mAppSrv = new MockTsTaskMonitor();

   303     mActSrv = new AfManager();

   304     QVERIFY(mAppSrv);

   305     QVERIFY(mActSrv);

   306     mModel = new TsModel(*mAppSrv, *mActSrv);

   307     QVERIFY(mModel);

   308 

   309 }

   310 

   311 void T_TsModel::cleanupTestCase()

   312 {

   313     delete mModel;

   314     mModel = 0;

   315     delete mActSrv;

   316     mActSrv = 0;

   317     QtMobility::QServiceManager manager;

   318     manager.removeService(serviceName);

   319     delete mAppSrv;

   320 }

   321 

   322 // HELPER FUNCTIONS

   323 

   324 QObject *T_TsModel::activityService()

   325 {

   326     return mActSrv;

   327 }

   328 

   329 QList<QVariantHash> T_TsModel::activityDataSet(int setId)const

   330 {

   331     if (setId >100) {

   332         setId = 0;

   333     }

   334     QList<QVariantHash> retVal;

   335     QVariantHash node;

   336     int visibility = 0;

   337     for (int i =0; i < setId; ++i) {

   338 

   339         //valid node

   340         node.clear();

   341         node.insert(ActivityApplicationKeyword, i+120);

   342         node.insert(ActivityActivityKeyword, QString("testactivity%1").arg(i+120));

   343         node.insert(ActivityIconKeyword, QString());

   344         switch (visibility++) {

   345             case 0://visible

   346                 node.insert(ActivityVisibleKeyword, true);

   347                 break;

   348             case 1://invisible

   349                 node.insert(ActivityVisibleKeyword, false);

   350                 break;

   351             default://empty

   352                 break;

   353         };

   354         if (2 < visibility) {

   355             visibility = 0;

   356         }

   357         retVal.append(node);

   358     }

   359     return retVal;

   360 }

   361 

   362 QList<TsTaskChange> T_TsModel::appDataSetFull(int setId)

   363 {

   364     if (setId >100) {

   365         setId = 0;

   366     }

   367     QList<TsTaskChange> retVal;

   368     TsTaskChangeInfo qtChangeItem(-2, -2);

   369     

   370     retVal.append(TsTaskChange(qtChangeItem, QSharedPointer<TsTask>()));

   371     for (int iter(0); iter < setId; ++iter) {

   372         //valid node

   373         qtChangeItem = TsTaskChangeInfo(iter, TsTaskChangeInfo::KInvalidOffset);

   374         QSharedPointer<TsTask> node(new TsTask(new TsTaskContent(QString("testapplication%1").arg(iter), iter % 2, iter % 3), *this));

   375         retVal.append(TsTaskChange(qtChangeItem, node));

   376     }

   377     return retVal;

   378 }

   379 

   380 QList<TsTaskChange> T_TsModel::changeDataSet5New()

   381 {

   382     QList<TsTaskChange> retVal;

   383     TsTaskChangeInfo qtChangeItem = TsTaskChangeInfo();

   384     // 1 cancel item at start of full update

   385     retVal.append(TsTaskChange(qtChangeItem, QSharedPointer<TsTask>()));

   386     // now 5 new items and changesetitem set to insert

   387     for (int iter(0); iter < 5; iter++) {

   388         qtChangeItem = TsTaskChangeInfo(iter, TsTaskChangeInfo::KInvalidOffset);

   389         QSharedPointer<TsTask> node(new TsTask(new TsTaskContent(QString("test %1").arg(iter+1), true, true), *this));

   390         retVal.append(TsTaskChange(qtChangeItem, node));

   391     }

   392     return retVal;

   393 }

   394 

   395 QList<TsTaskChange> T_TsModel::changeDataSetDelete1(int index)

   396 {

   397     QList<TsTaskChange> retVal;

   398     TsTaskChangeInfo qtChangeItem(TsTaskChangeInfo::KInvalidOffset, index);    

   399     

   400     retVal.append(TsTaskChange(qtChangeItem, QSharedPointer<TsTask>()));

   401     

   402     return retVal;

   403 }

   404 

   405 QList<TsTaskChange> T_TsModel::changeDataSetInsert1(int index)

   406 {

   407     QList<TsTaskChange> retVal;

   408     TsTaskChangeInfo qtChangeItem(index, TsTaskChangeInfo::KInvalidOffset);    

   409     QSharedPointer<TsTask> node(new TsTask(new TsTaskContent(QString("inserted %1").arg(index+1), true, true), *this));

   410     

   411     retVal.append(TsTaskChange(qtChangeItem, node));

   412     

   413     return retVal;    

   414 }

   415 

   416 QList<TsTaskChange> T_TsModel::changeDataSetChange1(int index)

   417 {

   418     QList<TsTaskChange> retVal;

   419     TsTaskChangeInfo qtChangeItem(index, index);    

   420     QSharedPointer<TsTask> node(new TsTask(new TsTaskContent(QString("changed %1").arg(index+1), true, true), *this));

   421     

   422     retVal.append(TsTaskChange(qtChangeItem, node));

   423     

   424     return retVal;   

   425 }

   426 

   427 QList<TsTaskChange> T_TsModel::changeDataSetMove1(int newIndex, int oldIndex)

   428 {

   429     QList<TsTaskChange> retVal;

   430     TsTaskChangeInfo qtChangeItem(newIndex, oldIndex);   

   431     

   432     retVal.append(TsTaskChange(qtChangeItem, QSharedPointer<TsTask>()));

   433   

   434     return retVal;  

   435 }

   436 

   437 int T_TsModel::activityDataSetsCount()const

   438 {

   439     return dataSetsCount;

   440 }

   441 

   442 void T_TsModel::clearModel()

   443 {

   444     QMetaObject::invokeMethod(mAppSrv,

   445                               "clearTasks");

   446     QMetaObject::invokeMethod(activityService(),

   447                               "clearActivities"); 

   448     mModel->fullUpdate();

   449 }

   450 

   451 QTEST_MAIN(T_TsModel)