videocollection/videocollectionview/tsrc/testvideocollectionviewutils/src/testvideocollectionviewutils.cpp
changeset 36 8aed59de29f9
parent 35 3738fe97f027
child 39 f6d44a0cd476
equal deleted inserted replaced
35:3738fe97f027 36:8aed59de29f9
    18 #include <qapplication.h>
    18 #include <qapplication.h>
    19 #include "centralrepository.h"
    19 #include "centralrepository.h"
    20 #include "testvideocollectionviewutils.h"
    20 #include "testvideocollectionviewutils.h"
    21 #include "hblabel.h"
    21 #include "hblabel.h"
    22 #include "hbaction.h"
    22 #include "hbaction.h"
       
    23 #include "videocollectionwrapper.h"
       
    24 #include "videosortfilterproxymodeldata.h"
    23 #include "videocollectioncommon.h"
    25 #include "videocollectioncommon.h"
    24 #include "centralrepository.h"
    26 #include "centralrepository.h"
    25 #include "hbmessageboxdata.h"
    27 #include "hbmessageboxdata.h"
       
    28 #include "hbnotificationdialog.h"
       
    29 #include "hblistview.h"
    26 
    30 
    27 #define private public
    31 #define private public
    28 #include "videocollectionviewutils.h"
    32 #include "videocollectionviewutils.h"
    29 #undef private
    33 #undef private
       
    34 
       
    35 // following consts are copied from videocollectionviewutils.cpp
       
    36 const int KVideoSortingRoleKey(0x5);
       
    37 const int KVideoSortingOrderKey(0x6);
       
    38 const int KCollectionsSortingRoleKey(0x7);
       
    39 const int KCollectionsSortingOrderKey(0x8);
    30 
    40 
    31 // ---------------------------------------------------------------------------
    41 // ---------------------------------------------------------------------------
    32 // main
    42 // main
    33 // ---------------------------------------------------------------------------
    43 // ---------------------------------------------------------------------------
    34 //
    44 //
    72 {
    82 {
    73 
    83 
    74 }
    84 }
    75 
    85 
    76 // ---------------------------------------------------------------------------
    86 // ---------------------------------------------------------------------------
    77 // testShowErrorMsgSlot
    87 // testShowStatusMsgSlot
    78 // ---------------------------------------------------------------------------
    88 // ---------------------------------------------------------------------------
    79 //
    89 //
    80 void TestVideoVideoCollectionViewUtils::testShowErrorMsgSlot()
    90 void TestVideoVideoCollectionViewUtils::testShowStatusMsgSlot()
    81 {
    91 {
    82     VideoCollectionViewUtils &testObject(VideoCollectionViewUtils::instance());
    92     VideoCollectionViewUtils &testObject(VideoCollectionViewUtils::instance());
    83     QVariant additional;
    93     QVariant additional;
    84     QString txt = "__test__";      
    94     QString txt = "__test__";      
    85     HbMessageBoxData::mWarningCallCount = 0;
    95     HbMessageBoxData::mWarningCallCount = 0;
    86     HbMessageBoxData::mInformationCallCount = 0;
    96     HbNotificationDialog::mNotifDialogTitle = "";
       
    97     HbNotificationDialog::mTitleTextWRapping = Hb::TextNoWrap;
       
    98     HbNotificationDialog::mAttribute = Qt::WA_Disabled;
       
    99 
    87     
   100     
    88     // status: VideoCollectionCommon::statusSingleDeleteFail
   101     // status: VideoCollectionCommon::statusSingleDeleteFail
    89     additional = txt;
   102     additional = txt;
    90     testObject.showStatusMsgSlot(VideoCollectionCommon::statusSingleDeleteFail, additional);
   103     testObject.showStatusMsgSlot(VideoCollectionCommon::statusSingleDeleteFail, additional);
    91     QVERIFY(HbMessageBoxData::mWarningCallCount == 1);
   104     QVERIFY(HbMessageBoxData::mWarningCallCount == 1);
    92     QVERIFY(HbMessageBoxData::mInformationCallCount == 0);
   105     QVERIFY(HbNotificationDialog::mNotifDialogTitle.count() == 0);
       
   106     QVERIFY(HbNotificationDialog::mTitleTextWRapping == Hb::TextNoWrap);
       
   107     QVERIFY(HbNotificationDialog::mAttribute == Qt::WA_Disabled);
    93     HbMessageBoxData::mWarningCallCount = 0;
   108     HbMessageBoxData::mWarningCallCount = 0;
    94     HbMessageBoxData::mInformationCallCount = 0;
   109     HbMessageBoxData::mInformationCallCount = 0;
       
   110 
    95     
   111     
    96     // - invalid additional
   112     // - invalid additional
    97     additional = QVariant();
   113     additional = QVariant();
    98     testObject.showStatusMsgSlot(VideoCollectionCommon::statusSingleDeleteFail, additional);
   114     testObject.showStatusMsgSlot(VideoCollectionCommon::statusSingleDeleteFail, additional);
    99     QVERIFY(HbMessageBoxData::mWarningCallCount == 0);
   115     QVERIFY(HbMessageBoxData::mWarningCallCount == 0);
   100     QVERIFY(HbMessageBoxData::mInformationCallCount == 0);
   116     QVERIFY(HbNotificationDialog::mNotifDialogTitle.count() == 0);
       
   117     QVERIFY(HbNotificationDialog::mTitleTextWRapping == Hb::TextNoWrap);
       
   118     QVERIFY(HbNotificationDialog::mAttribute == Qt::WA_Disabled);
   101     
   119     
   102     // status: VideoCollectionCommon::statusMultipleDeleteFail
   120     // status: VideoCollectionCommon::statusMultipleDeleteFail
   103     additional = txt;
   121     additional = txt;
   104     testObject.showStatusMsgSlot(VideoCollectionCommon::statusMultipleDeleteFail, additional);
   122     testObject.showStatusMsgSlot(VideoCollectionCommon::statusMultipleDeleteFail, additional);
   105     QVERIFY(HbMessageBoxData::mWarningCallCount == 1);
   123     QVERIFY(HbMessageBoxData::mWarningCallCount == 1);
   106     QVERIFY(HbMessageBoxData::mInformationCallCount == 0);
   124     QVERIFY(HbNotificationDialog::mNotifDialogTitle.count() == 0);
   107     HbMessageBoxData::mWarningCallCount = 0;
   125     QVERIFY(HbNotificationDialog::mTitleTextWRapping == Hb::TextNoWrap);
   108     HbMessageBoxData::mInformationCallCount = 0;
   126     QVERIFY(HbNotificationDialog::mAttribute == Qt::WA_Disabled);
   109     
   127     HbMessageBoxData::mWarningCallCount = 0;
   110     // - invalid additional
   128 
       
   129     // - invalid additional (no change, since additional not excepted)
   111     additional = QVariant();
   130     additional = QVariant();
   112     testObject.showStatusMsgSlot(VideoCollectionCommon::statusMultipleDeleteFail, additional);
   131     testObject.showStatusMsgSlot(VideoCollectionCommon::statusMultipleDeleteFail, additional);
   113     HbMessageBoxData::mWarningCallCount = 0;
   132     QVERIFY(HbMessageBoxData::mWarningCallCount == 1);
   114     HbMessageBoxData::mInformationCallCount = 0;
   133     QVERIFY(HbNotificationDialog::mNotifDialogTitle.count() == 0);
       
   134     QVERIFY(HbNotificationDialog::mTitleTextWRapping == Hb::TextNoWrap);
       
   135     QVERIFY(HbNotificationDialog::mAttribute == Qt::WA_Disabled);
       
   136     HbMessageBoxData::mWarningCallCount = 0;
   115     
   137     
   116     // status: VideoCollectionCommon::statusMultipleRemoveFail (additional not needed)
   138     // status: VideoCollectionCommon::statusMultipleRemoveFail (additional not needed)
   117     additional = QVariant();
   139     additional = QVariant();
   118     testObject.showStatusMsgSlot(VideoCollectionCommon::statusMultiRemoveFail, additional);
   140     testObject.showStatusMsgSlot(VideoCollectionCommon::statusMultiRemoveFail, additional);
   119     QVERIFY(HbMessageBoxData::mWarningCallCount == 1);
   141     QVERIFY(HbMessageBoxData::mWarningCallCount == 1);
   120     QVERIFY(HbMessageBoxData::mInformationCallCount == 0);
   142     QVERIFY(HbNotificationDialog::mNotifDialogTitle.count() == 0);
   121     HbMessageBoxData::mWarningCallCount = 0;
   143     QVERIFY(HbNotificationDialog::mTitleTextWRapping == Hb::TextNoWrap);
   122     HbMessageBoxData::mInformationCallCount = 0;
   144     QVERIFY(HbNotificationDialog::mAttribute == Qt::WA_Disabled);
       
   145     HbMessageBoxData::mWarningCallCount = 0;
   123     
   146     
   124     // status: VideoCollectionCommon::statusVideosAddedToCollection
   147     // status: VideoCollectionCommon::statusVideosAddedToCollection
       
   148     // notification dialog shown
   125     additional = txt;
   149     additional = txt;
   126     testObject.showStatusMsgSlot(VideoCollectionCommon::statusVideosAddedToCollection, additional);
   150     testObject.showStatusMsgSlot(VideoCollectionCommon::statusVideosAddedToCollection, additional);
   127     QVERIFY(HbMessageBoxData::mWarningCallCount == 0);
   151     QVERIFY(HbMessageBoxData::mWarningCallCount == 0);
   128     QVERIFY(HbMessageBoxData::mInformationCallCount == 1);
   152     QVERIFY(HbNotificationDialog::mNotifDialogTitle.count() > 0);
   129     HbMessageBoxData::mWarningCallCount = 0;
   153     QVERIFY(HbNotificationDialog::mTitleTextWRapping == Hb::TextWordWrap);
   130     HbMessageBoxData::mInformationCallCount = 0;
   154     QVERIFY(HbNotificationDialog::mAttribute == Qt::WA_DeleteOnClose);
       
   155     HbMessageBoxData::mWarningCallCount = 0;
       
   156     HbNotificationDialog::mNotifDialogTitle = "";
       
   157     HbNotificationDialog::mTitleTextWRapping = Hb::TextNoWrap;
       
   158     HbNotificationDialog::mAttribute = Qt::WA_Disabled;
   131     
   159     
   132     // - invalid additional
   160     // - invalid additional
   133     additional = QVariant();
   161     additional = QVariant();
   134     testObject.showStatusMsgSlot(VideoCollectionCommon::statusVideosAddedToCollection, additional);
   162     testObject.showStatusMsgSlot(VideoCollectionCommon::statusVideosAddedToCollection, additional);
   135     QVERIFY(HbMessageBoxData::mWarningCallCount == 0);
   163     QVERIFY(HbMessageBoxData::mWarningCallCount == 0);
   136     QVERIFY(HbMessageBoxData::mInformationCallCount == 0);
   164     QVERIFY(HbNotificationDialog::mNotifDialogTitle.count() == 0);
       
   165     QVERIFY(HbNotificationDialog::mTitleTextWRapping == Hb::TextNoWrap);
       
   166     QVERIFY(HbNotificationDialog::mAttribute == Qt::WA_Disabled);
   137     
   167     
   138     // status: VideoCollectionCommon::statusAllVideosAlreadyInCollection
   168     // status: VideoCollectionCommon::statusAllVideosAlreadyInCollection
   139     testObject.showStatusMsgSlot(VideoCollectionCommon::statusAllVideosAlreadyInCollection, additional);
   169     testObject.showStatusMsgSlot(VideoCollectionCommon::statusAllVideosAlreadyInCollection, additional);
   140     QVERIFY(HbMessageBoxData::mWarningCallCount == 1);
   170     QVERIFY(HbMessageBoxData::mWarningCallCount == 1);
   141     QVERIFY(HbMessageBoxData::mInformationCallCount == 0);
   171     QVERIFY(HbNotificationDialog::mNotifDialogTitle.count() == 0);
   142     HbMessageBoxData::mWarningCallCount = 0;
   172     QVERIFY(HbNotificationDialog::mTitleTextWRapping == Hb::TextNoWrap);
   143     HbMessageBoxData::mInformationCallCount = 0;
   173     QVERIFY(HbNotificationDialog::mAttribute == Qt::WA_Disabled);
       
   174     HbMessageBoxData::mWarningCallCount = 0;
   144     
   175     
   145     // status: VideoCollectionCommon::statusDeleteInProgress
   176     // status: VideoCollectionCommon::statusDeleteInProgress
   146     additional = txt;
   177     additional = txt;
   147     testObject.showStatusMsgSlot(VideoCollectionCommon::statusDeleteInProgress, additional);
   178     testObject.showStatusMsgSlot(VideoCollectionCommon::statusDeleteInProgress, additional);
   148     QVERIFY(HbMessageBoxData::mWarningCallCount == 0);
   179     QVERIFY(HbMessageBoxData::mWarningCallCount == 0);
   149     QVERIFY(HbMessageBoxData::mInformationCallCount == 1);
   180     QVERIFY(HbNotificationDialog::mNotifDialogTitle.count() > 0);
   150     HbMessageBoxData::mWarningCallCount = 0;
   181     QVERIFY(HbNotificationDialog::mTitleTextWRapping == Hb::TextWordWrap);
   151     HbMessageBoxData::mInformationCallCount = 0;
   182     QVERIFY(HbNotificationDialog::mAttribute == Qt::WA_DeleteOnClose);
       
   183     HbMessageBoxData::mWarningCallCount = 0;
       
   184     HbNotificationDialog::mNotifDialogTitle = "";
       
   185     HbNotificationDialog::mTitleTextWRapping = Hb::TextNoWrap;
       
   186     HbNotificationDialog::mAttribute = Qt::WA_Disabled;
   152 
   187 
   153     // - invalid additional
   188     // - invalid additional
   154     additional = QVariant();
   189     additional = QVariant();
   155     testObject.showStatusMsgSlot(VideoCollectionCommon::statusDeleteInProgress, additional);
   190     testObject.showStatusMsgSlot(VideoCollectionCommon::statusDeleteInProgress, additional);
   156     QVERIFY(HbMessageBoxData::mWarningCallCount == 0);
   191     QVERIFY(HbMessageBoxData::mWarningCallCount == 0);
   157     QVERIFY(HbMessageBoxData::mInformationCallCount == 0);
   192     QVERIFY(HbNotificationDialog::mNotifDialogTitle.count() == 0);
   158 }
   193     QVERIFY(HbNotificationDialog::mTitleTextWRapping == Hb::TextNoWrap);
       
   194     QVERIFY(HbNotificationDialog::mAttribute == Qt::WA_Disabled);
       
   195     
       
   196     // status: VideoCollectionCommon::statusSingleRemoveFail
       
   197     additional = txt;
       
   198     testObject.showStatusMsgSlot(VideoCollectionCommon::statusSingleRemoveFail, additional);
       
   199     QVERIFY(HbMessageBoxData::mWarningCallCount == 1);
       
   200     QVERIFY(HbNotificationDialog::mNotifDialogTitle.count() == 0);
       
   201     QVERIFY(HbNotificationDialog::mTitleTextWRapping == Hb::TextNoWrap);
       
   202     QVERIFY(HbNotificationDialog::mAttribute == Qt::WA_Disabled);
       
   203     HbMessageBoxData::mWarningCallCount = 0;
       
   204     
       
   205     // - invalid additional
       
   206     additional = QVariant();
       
   207     testObject.showStatusMsgSlot(VideoCollectionCommon::statusSingleRemoveFail, additional);
       
   208     QVERIFY(HbMessageBoxData::mWarningCallCount == 0);
       
   209     QVERIFY(HbNotificationDialog::mNotifDialogTitle.count() == 0);
       
   210     QVERIFY(HbNotificationDialog::mTitleTextWRapping == Hb::TextNoWrap);
       
   211     QVERIFY(HbNotificationDialog::mAttribute == Qt::WA_Disabled);
       
   212     
       
   213     // status: statusMultiRemoveFail
       
   214     additional = txt;
       
   215     testObject.showStatusMsgSlot(VideoCollectionCommon::statusMultiRemoveFail, additional);
       
   216     QVERIFY(HbMessageBoxData::mWarningCallCount == 1);
       
   217     QVERIFY(HbNotificationDialog::mNotifDialogTitle.count() == 0);
       
   218     QVERIFY(HbNotificationDialog::mTitleTextWRapping == Hb::TextNoWrap);
       
   219     QVERIFY(HbNotificationDialog::mAttribute == Qt::WA_Disabled);
       
   220     HbMessageBoxData::mWarningCallCount = 0;
       
   221     
       
   222     // invalid additional (no change, since additional not excepted)
       
   223     additional = QVariant();
       
   224     testObject.showStatusMsgSlot(VideoCollectionCommon::statusMultiRemoveFail, additional);
       
   225     QVERIFY(HbMessageBoxData::mWarningCallCount == 1);
       
   226     QVERIFY(HbNotificationDialog::mNotifDialogTitle.count() == 0);
       
   227     QVERIFY(HbNotificationDialog::mTitleTextWRapping == Hb::TextNoWrap);
       
   228     QVERIFY(HbNotificationDialog::mAttribute == Qt::WA_Disabled);
       
   229     HbMessageBoxData::mWarningCallCount = 0;
       
   230     
       
   231     
       
   232     // invalid state
       
   233     additional = txt;
       
   234     testObject.showStatusMsgSlot(0, additional);
       
   235     QVERIFY(HbMessageBoxData::mWarningCallCount == 0);
       
   236     QVERIFY(HbNotificationDialog::mNotifDialogTitle.count() == 0);
       
   237     QVERIFY(HbNotificationDialog::mTitleTextWRapping == Hb::TextNoWrap);
       
   238     QVERIFY(HbNotificationDialog::mAttribute == Qt::WA_Disabled);
       
   239     HbMessageBoxData::mWarningCallCount = 0;
       
   240    
       
   241 }   
       
   242     
   159 
   243 
   160 // -----------------------------------------------------------------------------
   244 // -----------------------------------------------------------------------------
   161 // testSaveSortingValues
   245 // testSaveSortingValues
   162 // -----------------------------------------------------------------------------
   246 // -----------------------------------------------------------------------------
   163 //
   247 //
   165 {
   249 {
   166     VideoCollectionViewUtils &testObject(VideoCollectionViewUtils::instance());
   250     VideoCollectionViewUtils &testObject(VideoCollectionViewUtils::instance());
   167     CRepository::setNewLLeave(true);
   251     CRepository::setNewLLeave(true);
   168     int sortRole = VideoCollectionCommon::KeyDateTime;
   252     int sortRole = VideoCollectionCommon::KeyDateTime;
   169     Qt::SortOrder sortOrder = Qt::AscendingOrder;
   253     Qt::SortOrder sortOrder = Qt::AscendingOrder;
   170     
   254     VideoCollectionCommon::TCollectionLevels target = VideoCollectionCommon::ELevelInvalid;
   171     QVERIFY(testObject.saveSortingValues(sortRole, sortOrder) < 0);
   255     CRepository::mSortValues.clear();
       
   256     
       
   257     // target invalid
       
   258     QVERIFY(testObject.saveSortingValues(sortRole, sortOrder, target) < 0);
       
   259     
       
   260     // target == VideoCollectionCommon::ELevelCategory
       
   261     target = VideoCollectionCommon::ELevelCategory;    
       
   262     
       
   263     // cenrep creation fails
       
   264     CRepository::setNewLLeave(true);
       
   265     QVERIFY(testObject.saveSortingValues(sortRole, sortOrder, target) < 0);
       
   266     QCOMPARE(CRepository::mSortValues.count(), 0);
       
   267 
       
   268     // set fails
   172     CRepository::setNewLLeave(false);
   269     CRepository::setNewLLeave(false);
   173     
       
   174     CRepository::setSetFail(0);
   270     CRepository::setSetFail(0);
   175     QVERIFY(testObject.saveSortingValues(sortRole, sortOrder) < 0);
   271     QVERIFY(testObject.saveSortingValues(sortRole, sortOrder, target) < 0);
   176     
   272     QCOMPARE(CRepository::mSortValues.count(), 0);
   177     CRepository::setSetFail(1);
   273     CRepository::setSetFail(2);
   178     QVERIFY(testObject.saveSortingValues(sortRole, sortOrder) < 0);
   274     
   179     
   275     // succeed
   180     CRepository::setSetFail(255);
   276     QVERIFY(testObject.saveSortingValues(sortRole, sortOrder, target) == 0);
   181     QVERIFY(testObject.saveSortingValues(sortRole, sortOrder) == 0);
   277     QCOMPARE(CRepository::mSortValues.count(), 2);
   182     QCOMPARE(CRepository::getRoleValue(), sortRole);
   278     QVERIFY(CRepository::mSortValues.values().contains(sortRole));
   183     QCOMPARE(CRepository::getOrderValue(), (int)sortOrder);
   279     QVERIFY(CRepository::mSortValues.values().contains(sortOrder));
       
   280     
       
   281     // target != VideoCollectionCommon::ELevelCategory
       
   282     CRepository::mSortValues.clear();
       
   283     target = VideoCollectionCommon::ELevelVideos;    
       
   284     
       
   285     // cenrep creation fails
       
   286     CRepository::setNewLLeave(true);
       
   287     QVERIFY(testObject.saveSortingValues(sortRole, sortOrder, target) < 0);
       
   288     QCOMPARE(CRepository::mSortValues.count(), 0);
       
   289     
       
   290     // set fails
       
   291     CRepository::setNewLLeave(false);
       
   292     CRepository::setSetFail(0);
       
   293     QVERIFY(testObject.saveSortingValues(sortRole, sortOrder, target) < 0);
       
   294     QCOMPARE(CRepository::mSortValues.count(), 0);
       
   295     CRepository::setSetFail(2);
       
   296     // succeed
       
   297     QVERIFY(testObject.saveSortingValues(sortRole, sortOrder, target) == 0);
       
   298     QCOMPARE(CRepository::mSortValues.count(), 2);
       
   299     QVERIFY(CRepository::mSortValues.values().contains(sortRole));
       
   300     QVERIFY(CRepository::mSortValues.values().contains(sortOrder));
   184 }
   301 }
   185  
   302  
   186 // -----------------------------------------------------------------------------
   303 // -----------------------------------------------------------------------------
   187 // testLoadSortingValues
   304 // testLoadSortingValues
   188 // -----------------------------------------------------------------------------
   305 // -----------------------------------------------------------------------------
   189 //
   306 //
   190 void TestVideoVideoCollectionViewUtils::testLoadSortingValues()
   307 void TestVideoVideoCollectionViewUtils::testLoadSortingValues()
   191 {
   308 {      
       
   309     CRepository::mSortValues[KVideoSortingRoleKey] = VideoCollectionCommon::KeyDateTime;
       
   310     CRepository::mSortValues[KVideoSortingOrderKey] = Qt::DescendingOrder;
       
   311     CRepository::mSortValues[KCollectionsSortingRoleKey] = VideoCollectionCommon::KeyTitle;
       
   312     CRepository::mSortValues[KCollectionsSortingOrderKey] = Qt::DescendingOrder;
       
   313     
   192     VideoCollectionViewUtils &testObject(VideoCollectionViewUtils::instance());
   314     VideoCollectionViewUtils &testObject(VideoCollectionViewUtils::instance());
   193     
   315     
   194     int sortRole(-1);
   316     int sortRole(-1);
   195     Qt::SortOrder sortOrder(Qt::AscendingOrder);
   317     Qt::SortOrder sortOrder(Qt::AscendingOrder);   
   196     
   318     VideoCollectionCommon::TCollectionLevels target = VideoCollectionCommon::ELevelInvalid;
   197     CRepository::setRoleValue(Qt::DisplayRole);
   319     
   198     CRepository::setOrderValue(Qt::AscendingOrder);
   320     testObject.mVideosSortRole = -1;
   199     
   321     testObject.mVideosSortOrder = Qt::AscendingOrder;
       
   322     testObject.mCollectionsSortRole = -1;
       
   323     testObject.mCollectionsSortOrder = Qt::AscendingOrder;
       
   324     
       
   325     // target is invalid
       
   326     QVERIFY(testObject.loadSortingValues(sortRole, sortOrder, target) == 0);
       
   327     QVERIFY(testObject.mVideosSortRole == -1);
       
   328     QVERIFY(testObject.mVideosSortOrder == Qt::AscendingOrder);
       
   329     QVERIFY(testObject.mCollectionsSortRole == -1);
       
   330     QVERIFY(testObject.mCollectionsSortOrder == Qt::AscendingOrder);
       
   331     QVERIFY(sortRole == -1);
       
   332     QVERIFY(sortOrder == Qt::AscendingOrder);
       
   333     
       
   334     // target is VideoCollectionCommon::ELevelCategory
       
   335     target = VideoCollectionCommon::ELevelCategory;
       
   336     
       
   337     // cerep creation fails 
   200     CRepository::setNewLLeave(true);
   338     CRepository::setNewLLeave(true);
   201     testObject.mSortRole = -1;
   339     QVERIFY(testObject.loadSortingValues(sortRole, sortOrder, target) < 0);
   202     testObject.mSortOrder = Qt::DescendingOrder;
   340     QVERIFY(testObject.mVideosSortRole == -1);
   203     QVERIFY(testObject.loadSortingValues(sortRole, sortOrder) < 0);
   341     QVERIFY(testObject.mVideosSortOrder == Qt::AscendingOrder);
   204     QCOMPARE(sortRole, -1);
   342     QVERIFY(testObject.mCollectionsSortRole == -1);
   205     QCOMPARE(sortOrder, Qt::DescendingOrder);
   343     QVERIFY(testObject.mCollectionsSortOrder == Qt::AscendingOrder);
   206 
   344     QVERIFY(sortRole == -1);
       
   345     QVERIFY(sortOrder == Qt::AscendingOrder);
   207     CRepository::setNewLLeave(false);
   346     CRepository::setNewLLeave(false);
       
   347     
       
   348     // getting from cenrep fails from first
   208     CRepository::setGetFail(0);
   349     CRepository::setGetFail(0);
   209     testObject.mSortRole = -1;
   350     QVERIFY(testObject.loadSortingValues(sortRole, sortOrder, target) < 0);
   210     testObject.mSortOrder = Qt::DescendingOrder;
   351     QVERIFY(testObject.mVideosSortRole == -1);
   211     QVERIFY(testObject.loadSortingValues(sortRole, sortOrder) < 0);
   352     QVERIFY(testObject.mVideosSortOrder == Qt::AscendingOrder);
   212     QCOMPARE(sortRole, -1);
   353     QVERIFY(testObject.mCollectionsSortRole == -1);
   213     QCOMPARE(sortOrder, Qt::DescendingOrder);
   354     QVERIFY(testObject.mCollectionsSortOrder == Qt::AscendingOrder);
   214 
   355     QVERIFY(sortRole == -1);
       
   356     QVERIFY(sortOrder == Qt::AscendingOrder);
       
   357     
       
   358     // getiing from cenrep fails from the second
   215     CRepository::setGetFail(1);
   359     CRepository::setGetFail(1);
   216     testObject.mSortRole = -1;
   360     QVERIFY(testObject.loadSortingValues(sortRole, sortOrder, target) < 0);
   217     testObject.mSortOrder = Qt::DescendingOrder;
   361     QVERIFY(testObject.mVideosSortRole == -1);
   218     QVERIFY(testObject.loadSortingValues(sortRole, sortOrder) < 0);
   362     QVERIFY(testObject.mVideosSortOrder == Qt::AscendingOrder);
   219     QCOMPARE(sortRole, (int)Qt::DisplayRole);
   363     QVERIFY(testObject.mCollectionsSortRole == -1);
   220     QCOMPARE(sortOrder, Qt::DescendingOrder);
   364     QVERIFY(testObject.mCollectionsSortOrder == Qt::AscendingOrder);
   221     
   365     QVERIFY(sortRole == -1);
   222     CRepository::setGetFail(255);
   366     QVERIFY(sortOrder == Qt::AscendingOrder);
   223     testObject.mSortRole = -1;
   367     CRepository::setGetFail(2);
   224     testObject.mSortOrder = Qt::DescendingOrder;
   368     
   225     QVERIFY(testObject.loadSortingValues(sortRole, sortOrder) == 0);
   369     // succeeds
   226     QCOMPARE(sortRole, (int)Qt::DisplayRole);
   370     QVERIFY(testObject.loadSortingValues(sortRole, sortOrder, target) == 0);
   227     QCOMPARE(sortOrder, Qt::AscendingOrder);
   371     QVERIFY(testObject.mVideosSortRole == -1);
       
   372     QVERIFY(testObject.mVideosSortOrder == Qt::AscendingOrder);
       
   373     QVERIFY(testObject.mCollectionsSortRole == VideoCollectionCommon::KeyTitle);
       
   374     QVERIFY(testObject.mCollectionsSortOrder == Qt::DescendingOrder);
       
   375     QVERIFY(sortRole == VideoCollectionCommon::KeyTitle);
       
   376     QVERIFY(sortOrder == Qt::DescendingOrder);
       
   377     sortRole = -1;
       
   378     sortOrder = Qt::AscendingOrder;
       
   379 
       
   380     // another call used previously saved values
       
   381     QVERIFY(testObject.loadSortingValues(sortRole, sortOrder, target) == 0);
       
   382     QVERIFY(testObject.mVideosSortRole == -1);
       
   383     QVERIFY(testObject.mVideosSortOrder == Qt::AscendingOrder);
       
   384     QVERIFY(testObject.mCollectionsSortRole == VideoCollectionCommon::KeyTitle);
       
   385     QVERIFY(testObject.mCollectionsSortOrder == Qt::DescendingOrder);
       
   386     QVERIFY(sortRole == VideoCollectionCommon::KeyTitle);
       
   387     QVERIFY(sortOrder == Qt::DescendingOrder);
       
   388     sortRole = -1;
       
   389     sortOrder = Qt::AscendingOrder;
       
   390     
       
   391     // target is different than VideoCollectionCommon::ELevelCategory
       
   392     target = VideoCollectionCommon::ELevelVideos;
       
   393     
       
   394     // cerep creation fails 
       
   395     CRepository::setNewLLeave(true);
       
   396     QVERIFY(testObject.loadSortingValues(sortRole, sortOrder, target) < 0);
       
   397     QVERIFY(testObject.mVideosSortRole == -1);
       
   398     QVERIFY(testObject.mVideosSortOrder == Qt::AscendingOrder);
       
   399     QVERIFY(testObject.mCollectionsSortRole == VideoCollectionCommon::KeyTitle);
       
   400     QVERIFY(testObject.mCollectionsSortOrder == Qt::DescendingOrder);
       
   401     QVERIFY(sortRole == -1);
       
   402     QVERIFY(sortOrder == Qt::AscendingOrder);
       
   403     CRepository::setNewLLeave(false);
       
   404     
       
   405     CRepository::setGetFail(0);
       
   406     // getting from cenrep fails from first
       
   407     QVERIFY(testObject.loadSortingValues(sortRole, sortOrder, target) < 0);
       
   408     QVERIFY(testObject.mVideosSortRole == -1);
       
   409     QVERIFY(testObject.mVideosSortOrder == Qt::AscendingOrder);
       
   410     QVERIFY(testObject.mCollectionsSortRole == VideoCollectionCommon::KeyTitle);
       
   411     QVERIFY(testObject.mCollectionsSortOrder == Qt::DescendingOrder);
       
   412     QVERIFY(sortRole == -1);
       
   413     QVERIFY(sortOrder == Qt::AscendingOrder);
       
   414     
       
   415     CRepository::setGetFail(1);
       
   416     // getting from cenrep fails from second
       
   417     QVERIFY(testObject.loadSortingValues(sortRole, sortOrder, target) < 0);
       
   418     QVERIFY(testObject.mVideosSortRole == -1);
       
   419     QVERIFY(testObject.mVideosSortOrder == Qt::AscendingOrder);
       
   420     QVERIFY(testObject.mCollectionsSortRole == VideoCollectionCommon::KeyTitle);
       
   421     QVERIFY(testObject.mCollectionsSortOrder == Qt::DescendingOrder);
       
   422     QVERIFY(sortRole == -1);
       
   423     QVERIFY(sortOrder == Qt::AscendingOrder);
       
   424     
       
   425     CRepository::setGetFail(2);
       
   426     
       
   427     // succeeds
       
   428     QVERIFY(testObject.loadSortingValues(sortRole, sortOrder, target) == 0);
       
   429     QVERIFY(testObject.mVideosSortRole == VideoCollectionCommon::KeyDateTime);
       
   430     QVERIFY(testObject.mVideosSortOrder == Qt::DescendingOrder);
       
   431     QVERIFY(testObject.mCollectionsSortRole == VideoCollectionCommon::KeyTitle);
       
   432     QVERIFY(testObject.mCollectionsSortOrder == Qt::DescendingOrder);
       
   433     QVERIFY(sortRole == VideoCollectionCommon::KeyDateTime);
       
   434     QVERIFY(sortOrder == Qt::DescendingOrder);
       
   435     
       
   436     sortRole = -1;
       
   437     sortOrder = Qt::AscendingOrder;
       
   438     
       
   439     // another call used previously saved values
       
   440     QVERIFY(testObject.loadSortingValues(sortRole, sortOrder, target) == 0);
       
   441     QVERIFY(testObject.mVideosSortRole == VideoCollectionCommon::KeyDateTime);
       
   442     QVERIFY(testObject.mVideosSortOrder == Qt::DescendingOrder);
       
   443     QVERIFY(testObject.mCollectionsSortRole == VideoCollectionCommon::KeyTitle);
       
   444     QVERIFY(testObject.mCollectionsSortOrder == Qt::DescendingOrder);
       
   445     QVERIFY(sortRole == VideoCollectionCommon::KeyDateTime);
       
   446     QVERIFY(sortOrder == Qt::DescendingOrder);
       
   447 
   228 }
   448 }
   229 
   449 
   230 // -----------------------------------------------------------------------------
   450 // -----------------------------------------------------------------------------
   231 // testGetServiceIconStrings
   451 // testGetServiceIconStrings
   232 // -----------------------------------------------------------------------------
   452 // -----------------------------------------------------------------------------
   266 // testGetServiceIconStrings
   486 // testGetServiceIconStrings
   267 // -----------------------------------------------------------------------------
   487 // -----------------------------------------------------------------------------
   268 //
   488 //
   269 void TestVideoVideoCollectionViewUtils::testGetServiceUriString()
   489 void TestVideoVideoCollectionViewUtils::testGetServiceUriString()
   270 {
   490 {
   271     VideoCollectionViewUtils &testObject(VideoCollectionViewUtils::instance());
   491      VideoCollectionViewUtils &testObject(VideoCollectionViewUtils::instance());
   272     CRepository::setNewLLeave(true);
   492     CRepository::setNewLLeave(true);
   273     _LIT(KExpectedTDesValue, "expected");
   493     _LIT(KExpectedTDesValue, "expected");
   274     CRepository::setTDesValue(KExpectedTDesValue());
   494     CRepository::setTDesValue(KExpectedTDesValue());
   275     QString expected((QChar*)KExpectedTDesValue().Ptr(),KExpectedTDesValue().Length());
   495     QString expected((QChar*)KExpectedTDesValue().Ptr(),KExpectedTDesValue().Length());
   276     
   496     
   282     
   502     
   283     CRepository::setGetFail(255);
   503     CRepository::setGetFail(255);
   284     QCOMPARE(testObject.getServiceUriString(), expected);
   504     QCOMPARE(testObject.getServiceUriString(), expected);
   285 }
   505 }
   286 
   506 
       
   507 // -----------------------------------------------------------------------------
       
   508 // testInitListView
       
   509 // -----------------------------------------------------------------------------
       
   510 //
       
   511 void TestVideoVideoCollectionViewUtils::testInitListView()
       
   512 {    
       
   513     // empty view
       
   514     VideoCollectionViewUtils::initListView(0);
       
   515     QVERIFY(HbListView::mLatestrecycling == false);
       
   516     QVERIFY(HbListView::mLatestClamping == HbScrollArea::InvalidClamping);
       
   517     QVERIFY(HbListView::mLatestScrolling == HbScrollArea::InvalidScrolling);
       
   518     QVERIFY(HbListView::mLatestFrictionEnabled == false);
       
   519     QVERIFY(HbListView::mLatestUniformItemSizes == false);
       
   520     QVERIFY(HbListView::mSelectionMode == HbAbstractItemView::InvalidSelection);
       
   521     
       
   522     HbListView view;
       
   523     VideoCollectionViewUtils::initListView(&view);
       
   524     QVERIFY(HbListView::mLatestrecycling == true);
       
   525     QVERIFY(HbListView::mLatestClamping == HbScrollArea::BounceBackClamping);
       
   526     QVERIFY(HbListView::mLatestScrolling == HbScrollArea::PanWithFollowOn);
       
   527     QVERIFY(HbListView::mLatestFrictionEnabled == true);
       
   528     QVERIFY(HbListView::mLatestUniformItemSizes == true);
       
   529     QVERIFY(HbListView::mSelectionMode == HbAbstractItemView::NoSelection);
       
   530     
       
   531     HbListView::mLatestrecycling = false;
       
   532     HbListView::mLatestClamping = HbScrollArea::InvalidClamping;
       
   533     HbListView::mLatestScrolling = HbScrollArea::InvalidScrolling;
       
   534     HbListView::mLatestFrictionEnabled = false;
       
   535     HbListView::mLatestUniformItemSizes = false;
       
   536     HbListView::mSelectionMode = HbAbstractItemView::InvalidSelection;
       
   537     
       
   538     // no prototype from view (for coverity)
       
   539     HbListView::mReturnNullPrototype = true;
       
   540     VideoCollectionViewUtils::initListView(&view);
       
   541     QVERIFY(HbListView::mLatestrecycling == true);
       
   542     QVERIFY(HbListView::mLatestClamping == HbScrollArea::BounceBackClamping);
       
   543     QVERIFY(HbListView::mLatestScrolling == HbScrollArea::PanWithFollowOn);
       
   544     QVERIFY(HbListView::mLatestFrictionEnabled == true);
       
   545     QVERIFY(HbListView::mLatestUniformItemSizes == true);
       
   546     QVERIFY(HbListView::mSelectionMode == HbAbstractItemView::NoSelection);
       
   547     
       
   548     HbListView::mLatestrecycling = false;
       
   549     HbListView::mLatestClamping = HbScrollArea::InvalidClamping;
       
   550     HbListView::mLatestScrolling = HbScrollArea::InvalidScrolling;
       
   551     HbListView::mLatestFrictionEnabled = false;
       
   552     HbListView::mLatestUniformItemSizes = false;
       
   553     HbListView::mSelectionMode = HbAbstractItemView::InvalidSelection;
       
   554     HbListView::mReturnNullPrototype = false;
       
   555     
       
   556     // no vertical scrollbar from view (for coverity)
       
   557     HbListView::mVScrollBarIsNull = true;
       
   558     VideoCollectionViewUtils::initListView(&view);
       
   559     QVERIFY(HbListView::mLatestrecycling == true);
       
   560     QVERIFY(HbListView::mLatestClamping == HbScrollArea::BounceBackClamping);
       
   561     QVERIFY(HbListView::mLatestScrolling == HbScrollArea::PanWithFollowOn);
       
   562     QVERIFY(HbListView::mLatestFrictionEnabled == true);
       
   563     QVERIFY(HbListView::mLatestUniformItemSizes == true);
       
   564     QVERIFY(HbListView::mSelectionMode == HbAbstractItemView::NoSelection);
       
   565 
       
   566 }
       
   567 
       
   568 void TestVideoVideoCollectionViewUtils::testSortModel()
       
   569 {
       
   570     VideoCollectionViewUtils &testObject(VideoCollectionViewUtils::instance());
       
   571     testObject.mVideosSortRole = -1;
       
   572     testObject.mVideosSortOrder = Qt::AscendingOrder;
       
   573     testObject.mCollectionsSortRole = -1;
       
   574     testObject.mCollectionsSortOrder = Qt::AscendingOrder;
       
   575     
       
   576     CRepository::mSortValues[KVideoSortingRoleKey] = VideoCollectionCommon::KeyDateTime;
       
   577     CRepository::mSortValues[KVideoSortingOrderKey] = Qt::DescendingOrder;
       
   578     CRepository::mSortValues[KCollectionsSortingRoleKey] = VideoCollectionCommon::KeyTitle;
       
   579     CRepository::mSortValues[KCollectionsSortingOrderKey] = Qt::DescendingOrder;
       
   580     
       
   581     VideoCollectionCommon::TCollectionLevels target = VideoCollectionCommon::ELevelInvalid;
       
   582     
       
   583     // null model
       
   584     VideoCollectionViewUtils::sortModel(0, false, target);
       
   585     
       
   586     VideoSortFilterProxyModel *model = 
       
   587         VideoCollectionWrapper::instance().getModel(VideoCollectionCommon::EModelTypeGeneric);
       
   588     
       
   589     // target == invalid -> default values used as sort -call 
       
   590     VideoCollectionViewUtils::sortModel(model, false, target);
       
   591     
       
   592     QVERIFY(VideoSortFilterProxyModelData::mDoSortingCallCount == 1);
       
   593     QVERIFY(VideoSortFilterProxyModelData::mSortRole == VideoCollectionCommon::KeyDateTime);
       
   594     QVERIFY(VideoSortFilterProxyModelData::mSortOrder == Qt::AscendingOrder);
       
   595     QVERIFY(VideoSortFilterProxyModelData::mSortAsync == false); 
       
   596     QVERIFY(testObject.mVideosSortRole == -1);
       
   597     QVERIFY(testObject.mVideosSortOrder == Qt::AscendingOrder);
       
   598     QVERIFY(testObject.mCollectionsSortRole == -1);
       
   599     QVERIFY(testObject.mCollectionsSortOrder == Qt::AscendingOrder);
       
   600     
       
   601     VideoSortFilterProxyModelData::mDoSortingCallCount = 0;
       
   602     VideoSortFilterProxyModelData::mSortRole = -1;
       
   603     VideoSortFilterProxyModelData::mSortOrder = Qt::AscendingOrder;
       
   604     VideoSortFilterProxyModelData::mSortAsync = true;
       
   605     
       
   606     // target == VideoCollectionCommon::ELevelVideos
       
   607     target = VideoCollectionCommon::ELevelVideos;
       
   608     VideoCollectionViewUtils::sortModel(model, false, target);
       
   609     
       
   610     QVERIFY(VideoSortFilterProxyModelData::mDoSortingCallCount == 1);
       
   611     QVERIFY(VideoSortFilterProxyModelData::mSortRole == VideoCollectionCommon::KeyDateTime);
       
   612     QVERIFY(VideoSortFilterProxyModelData::mSortOrder == Qt::DescendingOrder);
       
   613     QVERIFY(VideoSortFilterProxyModelData::mSortAsync == false); 
       
   614     QVERIFY(testObject.mVideosSortRole == VideoCollectionCommon::KeyDateTime);
       
   615     QVERIFY(testObject.mVideosSortOrder == Qt::DescendingOrder);
       
   616     QVERIFY(testObject.mCollectionsSortRole == -1);
       
   617     QVERIFY(testObject.mCollectionsSortOrder == Qt::AscendingOrder);
       
   618     
       
   619     
       
   620     VideoSortFilterProxyModelData::mDoSortingCallCount = 0;
       
   621     VideoSortFilterProxyModelData::mSortRole = -1;
       
   622     VideoSortFilterProxyModelData::mSortOrder = Qt::AscendingOrder;
       
   623     VideoSortFilterProxyModelData::mSortAsync = true;
       
   624        
       
   625     // target == VideoCollectionCommon::ELevelCategory
       
   626     target = VideoCollectionCommon::ELevelCategory;
       
   627     VideoCollectionViewUtils::sortModel(model, false, target);
       
   628     
       
   629     QVERIFY(VideoSortFilterProxyModelData::mDoSortingCallCount == 1);
       
   630     QVERIFY(VideoSortFilterProxyModelData::mSortRole == VideoCollectionCommon::KeyTitle);
       
   631     QVERIFY(VideoSortFilterProxyModelData::mSortOrder == Qt::DescendingOrder);
       
   632     QVERIFY(VideoSortFilterProxyModelData::mSortAsync == false); 
       
   633     QVERIFY(testObject.mVideosSortRole == VideoCollectionCommon::KeyDateTime);
       
   634     QVERIFY(testObject.mVideosSortOrder == Qt::DescendingOrder);
       
   635     QVERIFY(testObject.mCollectionsSortRole == VideoCollectionCommon::KeyTitle);
       
   636     QVERIFY(testObject.mCollectionsSortOrder == Qt::DescendingOrder);
       
   637 }
       
   638 
   287 // End of file
   639 // End of file
   288     
   640     
   289 
   641 
   290 
   642