tsdevicedialog/tsdevicedialogplugin/tsrc/t_tsmodel/t_tsmodel.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:
       
    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)