Mercurial Mercurial > oss > FCL > sf > app > videoplayer / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
videocollection/videocollectionwrapper/tsrc/testvideosortfilterproxymodel/src/testvideosortfilterproxymodel.cpp
changeset 55 4bfa887905cf
parent 50 21fe8338c6bf
equal deleted inserted replaced
50:21fe8338c6bf 55:4bfa887905cf 
   810     QVERIFY(mTestObject->open(VideoCollectionCommon::ELevelVideos) == 0);
 
   810     QVERIFY(mTestObject->open(VideoCollectionCommon::ELevelVideos) == 0);
 
   811     
   811     
   812     // these signals are emitted during sorting procedure from the fw
 
   812     // these signals are emitted during sorting procedure from the fw
 
   813     QSignalSpy spyAboutToChange(mTestObject, SIGNAL(layoutAboutToBeChanged()));
 
   813     QSignalSpy spyAboutToChange(mTestObject, SIGNAL(layoutAboutToBeChanged()));
 
   814     QSignalSpy spyChanged(mTestObject, SIGNAL(layoutChanged()));
 
   814     QSignalSpy spyChanged(mTestObject, SIGNAL(layoutChanged()));
 
       
   815     QSignalSpy spySorted(mTestObject, SIGNAL(modelSorted()));
 
   815     
   816     
   816     QString name1 = "cc";
 
   817     QString name1 = "cc";
 
   817     QString name2 = "bb";
 
   818     QString name2 = "bb";
 
   818     QString name3 = "aa";
 
   819     QString name3 = "aa";
 
   819     QString name4 = "11";
 
   820     QString name4 = "11";
 
   849     
   850     
   850     int sortingRole;
 
   851     int sortingRole;
 
   851     Qt::SortOrder sortingOrder;
 
   852     Qt::SortOrder sortingOrder;
 
   852 
   853 
   853     // first sort call, includes timer creation and setup
 
   854     // first sort call, includes timer creation and setup
 
   854     VideoThumbnailData::mStartBackgroundFetchingCallCount = 0;
 
       
   855     mTestObject->doSorting(VideoCollectionCommon::KeyTitle, Qt::AscendingOrder);
 
   855     mTestObject->doSorting(VideoCollectionCommon::KeyTitle, Qt::AscendingOrder);
 
   856     // need to wait for awhile to make sure zero-counter gets 
   856     // need to wait for awhile to make sure zero-counter gets 
   857     // processing time.
 
   857     // processing time.
 
   858     QTest::qWait(500);
 
   858     QTest::qWait(500);
 
   859     QCOMPARE(spyAboutToChange.count(), 1); 
   859     QCOMPARE(spyAboutToChange.count(), 1); 
   860     QCOMPARE(spyChanged.count(), 1); 
   860     QCOMPARE(spyChanged.count(), 1); 
   861     QCOMPARE(mTestObject->sortRole(), (int)VideoCollectionCommon::KeyTitle);
 
   861     QCOMPARE(mTestObject->sortRole(), (int)VideoCollectionCommon::KeyTitle);
 
   862     QCOMPARE(mTestObject->sortOrder(), Qt::AscendingOrder);
 
   862     QCOMPARE(mTestObject->sortOrder(), Qt::AscendingOrder);
 
   863     QVERIFY(VideoThumbnailData::mStartBackgroundFetchingCallCount == 1);
 
   863     QCOMPARE(spySorted.count(), 1);
 
   864     mTestObject->getSorting(sortingRole, sortingOrder);
 
   864     mTestObject->getSorting(sortingRole, sortingOrder);
 
   865     QCOMPARE(sortingRole, (int)VideoCollectionCommon::KeyTitle);
 
   865     QCOMPARE(sortingRole, (int)VideoCollectionCommon::KeyTitle);
 
   866     QCOMPARE(sortingOrder, Qt::AscendingOrder);
 
   866     QCOMPARE(sortingOrder, Qt::AscendingOrder);
 
   867     
   867     
   868     // reset spys
 
   868     // reset spys
 
   869     spyAboutToChange.clear();
 
   869     spyAboutToChange.clear();
 
   870     spyChanged.clear();
 
   870     spyChanged.clear();
 
       
   871     spySorted.clear();
 
   871 
   872 
   872     // second sort call, should use same timer appropriately
 
   873     // second sort call, should use same timer appropriately
 
   873     VideoThumbnailData::mStartBackgroundFetchingCallCount = 0;
 
       
   874     mTestObject->doSorting(VideoCollectionCommon::KeyTitle, Qt::DescendingOrder);
 
   874     mTestObject->doSorting(VideoCollectionCommon::KeyTitle, Qt::DescendingOrder);
 
   875     QTest::qWait(500);
 
   875     QTest::qWait(500);
 
   876     QCOMPARE(spyAboutToChange.count(), 1);
 
   876     QCOMPARE(spyAboutToChange.count(), 1);
 
   877     QCOMPARE(spyChanged.count(), 1);
 
   877     QCOMPARE(spyChanged.count(), 1);
 
   878     QCOMPARE(mTestObject->sortRole(), (int)VideoCollectionCommon::KeyTitle);
 
   878     QCOMPARE(mTestObject->sortRole(), (int)VideoCollectionCommon::KeyTitle);
 
   879     QCOMPARE(mTestObject->sortOrder(), Qt::DescendingOrder);
 
   879     QCOMPARE(mTestObject->sortOrder(), Qt::DescendingOrder);
 
   880     QVERIFY(VideoThumbnailData::mStartBackgroundFetchingCallCount == 1);
 
   880     QCOMPARE(spySorted.count(), 1);
 
   881     mTestObject->getSorting(sortingRole, sortingOrder);
 
   881     mTestObject->getSorting(sortingRole, sortingOrder);
 
   882     QCOMPARE(sortingRole, (int)VideoCollectionCommon::KeyTitle);
 
   882     QCOMPARE(sortingRole, (int)VideoCollectionCommon::KeyTitle);
 
   883     QCOMPARE(sortingOrder, Qt::DescendingOrder);
 
   883     QCOMPARE(sortingOrder, Qt::DescendingOrder);
 
   884     
   884     
   885     // reset spys
 
   885     // reset spys
 
   886     spyAboutToChange.clear();
 
   886     spyAboutToChange.clear();
 
   887     spyChanged.clear();    
   887     spyChanged.clear();
 
       
   888     spySorted.clear();
 
   888     
   889     
   889     // double call without first letting timer to timeout
 
   890     // double call without first letting timer to timeout
 
   890     VideoThumbnailData::mStartBackgroundFetchingCallCount = 0;
 
   891     VideoThumbnailData::mStartBackgroundFetchingCallCount = 0;
 
   891     mTestObject->doSorting(VideoCollectionCommon::KeyTitle, Qt::DescendingOrder);
 
   892     mTestObject->doSorting(VideoCollectionCommon::KeyTitle, Qt::DescendingOrder);
 
   892     mTestObject->doSorting(VideoCollectionCommon::KeyTitle, Qt::AscendingOrder);
 
   893     mTestObject->doSorting(VideoCollectionCommon::KeyTitle, Qt::AscendingOrder);
 
   893     QTest::qWait(500);
 
   894     QTest::qWait(500);
 
   894     QCOMPARE(spyAboutToChange.count(), 1);
 
   895     QCOMPARE(spyAboutToChange.count(), 1);
 
   895     QCOMPARE(spyChanged.count(), 1);
 
   896     QCOMPARE(spyChanged.count(), 1);
 
   896     QCOMPARE(mTestObject->sortRole(), (int)VideoCollectionCommon::KeyTitle);
 
   897     QCOMPARE(mTestObject->sortRole(), (int)VideoCollectionCommon::KeyTitle);
 
   897     QCOMPARE(mTestObject->sortOrder(), Qt::AscendingOrder);
 
   898     QCOMPARE(mTestObject->sortOrder(), Qt::AscendingOrder);
 
   898     QVERIFY(VideoThumbnailData::mStartBackgroundFetchingCallCount == 1);
 
   899     QCOMPARE(spySorted.count(), 1);
 
   899     mTestObject->getSorting(sortingRole, sortingOrder);
 
   900     mTestObject->getSorting(sortingRole, sortingOrder);
 
   900     QCOMPARE(sortingRole, (int)VideoCollectionCommon::KeyTitle);
 
   901     QCOMPARE(sortingRole, (int)VideoCollectionCommon::KeyTitle);
 
   901     QCOMPARE(sortingOrder, Qt::AscendingOrder);
 
   902     QCOMPARE(sortingOrder, Qt::AscendingOrder);
 
   902     
   903     
   903     spyAboutToChange.clear();
 
   904     spyAboutToChange.clear();
 
   904     spyChanged.clear();
 
   905     spyChanged.clear();
 
       
   906     spySorted.clear();
 
   905     
   907     
   906     // syncronous call checks
 
   908     // syncronous call checks
 
   907     VideoThumbnailData::mStartBackgroundFetchingCallCount = 0;
 
       
   908     mTestObject->doSorting(VideoCollectionCommon::KeyTitle, Qt::DescendingOrder, false);
 
   909     mTestObject->doSorting(VideoCollectionCommon::KeyTitle, Qt::DescendingOrder, false);
 
   909     QCOMPARE(spyAboutToChange.count(), 1);
 
   910     QCOMPARE(spyAboutToChange.count(), 1);
 
   910     QCOMPARE(spyChanged.count(), 1);
 
   911     QCOMPARE(spyChanged.count(), 1);
 
   911     QCOMPARE(mTestObject->sortRole(), (int)VideoCollectionCommon::KeyTitle);
 
   912     QCOMPARE(mTestObject->sortRole(), (int)VideoCollectionCommon::KeyTitle);
 
   912     QCOMPARE(mTestObject->sortOrder(), Qt::DescendingOrder);
 
   913     QCOMPARE(mTestObject->sortOrder(), Qt::DescendingOrder);
 
   913     QVERIFY(VideoThumbnailData::mStartBackgroundFetchingCallCount == 1);
 
   914     QCOMPARE(spySorted.count(), 1);
 
   914     mTestObject->getSorting(sortingRole, sortingOrder);
 
   915     mTestObject->getSorting(sortingRole, sortingOrder);
 
   915     QCOMPARE(sortingRole, (int)VideoCollectionCommon::KeyTitle);
 
   916     QCOMPARE(sortingRole, (int)VideoCollectionCommon::KeyTitle);
 
   916     QCOMPARE(sortingOrder, Qt::DescendingOrder);
 
   917     QCOMPARE(sortingOrder, Qt::DescendingOrder);
 
   917     
   918     
   918     spyAboutToChange.clear();
 
   919     spyAboutToChange.clear();
 
   919     spyChanged.clear();
 
   920     spyChanged.clear();
 
   920     
   921     spySorted.clear();
 
   921     VideoThumbnailData::mStartBackgroundFetchingCallCount = 0;
 
   922     
   922     mTestObject->doSorting(VideoCollectionCommon::KeyTitle, Qt::AscendingOrder, false);
 
   923     mTestObject->doSorting(VideoCollectionCommon::KeyTitle, Qt::AscendingOrder, false);
 
   923     QCOMPARE(spyAboutToChange.count(), 1);
 
   924     QCOMPARE(spyAboutToChange.count(), 1);
 
   924     QCOMPARE(spyChanged.count(), 1);
 
   925     QCOMPARE(spyChanged.count(), 1);
 
   925     QCOMPARE(mTestObject->sortRole(), (int)VideoCollectionCommon::KeyTitle);
 
   926     QCOMPARE(mTestObject->sortRole(), (int)VideoCollectionCommon::KeyTitle);
 
   926     QCOMPARE(mTestObject->sortOrder(), Qt::AscendingOrder);
 
   927     QCOMPARE(mTestObject->sortOrder(), Qt::AscendingOrder);
 
   927     QVERIFY(VideoThumbnailData::mStartBackgroundFetchingCallCount == 1);
 
   928     QCOMPARE(spySorted.count(), 1);
 
   928     mTestObject->getSorting(sortingRole, sortingOrder);
 
   929     mTestObject->getSorting(sortingRole, sortingOrder);
 
   929     QCOMPARE(sortingRole, (int)VideoCollectionCommon::KeyTitle);
 
   930     QCOMPARE(sortingRole, (int)VideoCollectionCommon::KeyTitle);
 
   930     QCOMPARE(sortingOrder, Qt::AscendingOrder);
 
   931     QCOMPARE(sortingOrder, Qt::AscendingOrder);
 
   931     
   932     
   932     spyAboutToChange.clear();
 
   933     spyAboutToChange.clear();
 
   933     spyChanged.clear();
 
   934     spyChanged.clear();
 
       
   935     spySorted.clear();
 
   934     
   936     
   935     // check that layout signals are not send if the sorting values don't change.
 
   937     // check that layout signals are not send if the sorting values don't change.
 
   936     VideoThumbnailData::mStartBackgroundFetchingCallCount = 0;
 
       
   937     mTestObject->doSorting(VideoCollectionCommon::KeyTitle, Qt::AscendingOrder);
 
   938     mTestObject->doSorting(VideoCollectionCommon::KeyTitle, Qt::AscendingOrder);
 
   938     QCOMPARE(spyAboutToChange.count(), 0);
 
   939     QCOMPARE(spyAboutToChange.count(), 0);
 
   939     QCOMPARE(spyChanged.count(), 0);
 
   940     QCOMPARE(spyChanged.count(), 0);
 
       
   941     QCOMPARE(spySorted.count(), 0);
 
   940     QCOMPARE(mTestObject->sortRole(), (int)VideoCollectionCommon::KeyTitle);
 
   942     QCOMPARE(mTestObject->sortRole(), (int)VideoCollectionCommon::KeyTitle);
 
   941     QCOMPARE(mTestObject->sortOrder(), Qt::AscendingOrder);
 
   943     QCOMPARE(mTestObject->sortOrder(), Qt::AscendingOrder);
 
   942     QVERIFY(VideoThumbnailData::mStartBackgroundFetchingCallCount == 0);
 
       
   943     mTestObject->getSorting(sortingRole, sortingOrder);
 
   944     mTestObject->getSorting(sortingRole, sortingOrder);
 
   944     QCOMPARE(sortingRole, (int)VideoCollectionCommon::KeyTitle);
 
   945     QCOMPARE(sortingRole, (int)VideoCollectionCommon::KeyTitle);
 
   945     QCOMPARE(sortingOrder, Qt::AscendingOrder);
 
   946     QCOMPARE(sortingOrder, Qt::AscendingOrder);
 
   946     
   947     
   947     spyAboutToChange.clear();
 
   948     spyAboutToChange.clear();
 
   948     spyChanged.clear();
 
   949     spyChanged.clear();
 
       
   950     spySorted.clear();
 
   949     
   951     
   950     // date role check    
   952     // date role check    
   951     VideoThumbnailData::mStartBackgroundFetchingCallCount = 0;
 
       
   952     mTestObject->doSorting(VideoCollectionCommon::KeyDateTime, Qt::AscendingOrder);
 
   953     mTestObject->doSorting(VideoCollectionCommon::KeyDateTime, Qt::AscendingOrder);
 
   953     QTest::qWait(500);
 
   954     QTest::qWait(500);
 
   954     int count = spyAboutToChange.count();
 
   955     int count = spyAboutToChange.count();
 
   955     QCOMPARE(spyAboutToChange.count(), 1);
 
   956     QCOMPARE(spyAboutToChange.count(), 1);
 
   956     QCOMPARE(spyChanged.count(), 1);
 
   957     QCOMPARE(spyChanged.count(), 1);
 
   957     QCOMPARE(mTestObject->sortRole(), (int)VideoCollectionCommon::KeyDateTime);
 
   958     QCOMPARE(mTestObject->sortRole(), (int)VideoCollectionCommon::KeyDateTime);
 
   958     QVERIFY(VideoThumbnailData::mStartBackgroundFetchingCallCount == 1);
 
   959     QCOMPARE(spySorted.count(), 1);
 
   959     mTestObject->getSorting(sortingRole, sortingOrder);
 
   960     mTestObject->getSorting(sortingRole, sortingOrder);
 
   960     QCOMPARE(sortingRole, (int)VideoCollectionCommon::KeyDateTime);
 
   961     QCOMPARE(sortingRole, (int)VideoCollectionCommon::KeyDateTime);
 
   961     QCOMPARE(sortingOrder, Qt::AscendingOrder);
 
   962     QCOMPARE(sortingOrder, Qt::AscendingOrder);
 
   962     
   963     
   963     spyAboutToChange.clear();
 
   964     spyAboutToChange.clear();
 
   964     spyChanged.clear();
 
   965     spyChanged.clear();
 
       
   966     spySorted.clear();
 
   965     
   967     
   966     // size role check
 
   968     // size role check
 
   967     VideoThumbnailData::mStartBackgroundFetchingCallCount = 0;
 
       
   968     mTestObject->doSorting(VideoCollectionCommon::KeySizeValue, Qt::AscendingOrder);
 
   969     mTestObject->doSorting(VideoCollectionCommon::KeySizeValue, Qt::AscendingOrder);
 
   969     QTest::qWait(500);
 
   970     QTest::qWait(500);
 
   970     QCOMPARE(spyAboutToChange.count(), 1);
 
   971     QCOMPARE(spyAboutToChange.count(), 1);
 
   971     QCOMPARE(spyChanged.count(), 1);
 
   972     QCOMPARE(spyChanged.count(), 1);
 
   972     QCOMPARE(mTestObject->sortRole(),  (int)VideoCollectionCommon::KeySizeValue);
 
   973     QCOMPARE(mTestObject->sortRole(),  (int)VideoCollectionCommon::KeySizeValue);
 
   973     QVERIFY(VideoThumbnailData::mStartBackgroundFetchingCallCount == 1);
 
   974     QCOMPARE(spySorted.count(), 1);
 
   974     mTestObject->getSorting(sortingRole, sortingOrder);
 
   975     mTestObject->getSorting(sortingRole, sortingOrder);
 
   975     QCOMPARE(sortingRole, (int)VideoCollectionCommon::KeySizeValue);
 
   976     QCOMPARE(sortingRole, (int)VideoCollectionCommon::KeySizeValue);
 
   976     QCOMPARE(sortingOrder, Qt::AscendingOrder);
 
   977     QCOMPARE(sortingOrder, Qt::AscendingOrder);
 
   977 
   978 
   978     spyAboutToChange.clear();
 
   979     spyAboutToChange.clear();
 
   979     spyChanged.clear();
 
   980     spyChanged.clear();
 
       
   981     spySorted.clear();
 
   980 
   982 
   981     // number of items role check
 
   983     // number of items role check
 
   982     VideoThumbnailData::mStartBackgroundFetchingCallCount = 0;
 
       
   983     mTestObject->doSorting(VideoCollectionCommon::KeyNumberOfItems, Qt::AscendingOrder);
 
   984     mTestObject->doSorting(VideoCollectionCommon::KeyNumberOfItems, Qt::AscendingOrder);
 
   984     QTest::qWait(500);
 
   985     QTest::qWait(500);
 
   985     QCOMPARE(spyAboutToChange.count(), 1);
 
   986     QCOMPARE(spyAboutToChange.count(), 1);
 
   986     QCOMPARE(spyChanged.count(), 1);
 
   987     QCOMPARE(spyChanged.count(), 1);
 
   987     QCOMPARE(mTestObject->sortRole(),  (int)VideoCollectionCommon::KeyNumberOfItems);
 
   988     QCOMPARE(mTestObject->sortRole(),  (int)VideoCollectionCommon::KeyNumberOfItems);
 
   988     QVERIFY(VideoThumbnailData::mStartBackgroundFetchingCallCount == 1);
 
   989     QCOMPARE(spySorted.count(), 1);
 
   989     mTestObject->getSorting(sortingRole, sortingOrder);
 
   990     mTestObject->getSorting(sortingRole, sortingOrder);
 
   990     QCOMPARE(sortingRole, (int)VideoCollectionCommon::KeyNumberOfItems);
 
   991     QCOMPARE(sortingRole, (int)VideoCollectionCommon::KeyNumberOfItems);
 
   991     QCOMPARE(sortingOrder, Qt::AscendingOrder);
 
   992     QCOMPARE(sortingOrder, Qt::AscendingOrder);
 
   992 
   993 
   993     spyAboutToChange.clear();
 
   994     spyAboutToChange.clear();
 
   994     spyChanged.clear();    
   995     spyChanged.clear();
 
       
   996     spySorted.clear();
 
   995     
   997     
   996     // invalid role call, sorting should be set to date
 
   998     // invalid role call, sorting should be set to date
 
   997     VideoThumbnailData::mStartBackgroundFetchingCallCount = 0;
 
       
   998     mTestObject->mType = VideoCollectionCommon::EModelTypeAllVideos;
 
   999     mTestObject->mType = VideoCollectionCommon::EModelTypeAllVideos;
 
   999     mTestObject->doSorting(VideoCollectionCommon::KeyTitle - 100, Qt::AscendingOrder);
 
  1000     mTestObject->doSorting(VideoCollectionCommon::KeyTitle - 100, Qt::AscendingOrder);
 
  1000     QTest::qWait(500);
 
  1001     QTest::qWait(500);
 
  1001     QCOMPARE(spyAboutToChange.count(), 1);
 
  1002     QCOMPARE(spyAboutToChange.count(), 1);
 
  1002     QCOMPARE(spyChanged.count(), 1);
 
  1003     QCOMPARE(spyChanged.count(), 1);
 
  1003     QCOMPARE(mTestObject->sortRole(), (int)VideoCollectionCommon::KeyDateTime);
 
  1004     QCOMPARE(mTestObject->sortRole(), (int)VideoCollectionCommon::KeyDateTime);
 
       
  1005     QCOMPARE(spySorted.count(), 1);
 
       
  1006 
  1004     spyAboutToChange.clear();
 
  1007     spyAboutToChange.clear();
 
  1005     spyChanged.clear();
 
  1008     spyChanged.clear();
 
  1006     QVERIFY(VideoThumbnailData::mStartBackgroundFetchingCallCount == 1);
 
  1009     spySorted.clear();
 
  1007     
  1010     
  1008     // invalid role call, model type is categories, sorting should be set to VideoCollectionCommon::KeyTitle
 
  1011     // invalid role call, model type is categories, sorting should be set to VideoCollectionCommon::KeyTitle
 
  1009     VideoThumbnailData::mStartBackgroundFetchingCallCount = 0;
 
       
  1010     mTestObject->mType = VideoCollectionCommon::EModelTypeCollections;
 
  1012     mTestObject->mType = VideoCollectionCommon::EModelTypeCollections;
 
  1011     mTestObject->doSorting(VideoCollectionCommon::KeyTitle - 100, Qt::AscendingOrder);
 
  1013     mTestObject->doSorting(VideoCollectionCommon::KeyTitle - 100, Qt::AscendingOrder);
 
  1012     QTest::qWait(500);
 
  1014     QTest::qWait(500);
 
  1013     QCOMPARE(spyAboutToChange.count(), 1);
 
  1015     QCOMPARE(spyAboutToChange.count(), 1);
 
  1014     QCOMPARE(spyChanged.count(), 1);
 
  1016     QCOMPARE(spyChanged.count(), 1);
 
  1015     QCOMPARE(mTestObject->sortRole(), (int)VideoCollectionCommon::KeyTitle);
 
  1017     QCOMPARE(mTestObject->sortRole(), (int)VideoCollectionCommon::KeyTitle);
 
       
  1018     QCOMPARE(spySorted.count(), 1);   
       
  1019 
  1016     spyAboutToChange.clear();
 
  1020     spyAboutToChange.clear();
 
  1017     spyChanged.clear();
 
  1021     spyChanged.clear();
 
  1018     QVERIFY(VideoThumbnailData::mStartBackgroundFetchingCallCount == 1);   
  1022     spySorted.clear();
 
  1019     
  1023     
  1020     // sync sorting call for non -changing sort order (for coverity)
 
  1024     // sync sorting call for non -changing sort order (for coverity)
 
  1021     VideoThumbnailData::mStartBackgroundFetchingCallCount = 0;
 
       
  1022     mTestObject->mType = VideoCollectionCommon::EModelTypeAllVideos;
 
  1025     mTestObject->mType = VideoCollectionCommon::EModelTypeAllVideos;
 
  1023     mTestObject->mIdleSortTimer = 0;
 
  1026     mTestObject->mIdleSortTimer = 0;
 
  1024     mTestObject->doSorting(VideoCollectionCommon::KeyTitle - 100, Qt::AscendingOrder, false);
 
  1027     mTestObject->doSorting(VideoCollectionCommon::KeyTitle - 100, Qt::AscendingOrder, false);
 
  1025     spyAboutToChange.clear();
 
  1028     spyAboutToChange.clear();
 
  1026     spyChanged.clear();
 
  1029     spyChanged.clear();
 
  1028     QCOMPARE(spyAboutToChange.count(), 0);
 
  1031     QCOMPARE(spyAboutToChange.count(), 0);
 
  1029     QCOMPARE(spyChanged.count(), 0);
 
  1032     QCOMPARE(spyChanged.count(), 0);
 
  1030     QCOMPARE(mTestObject->sortRole(), (int)VideoCollectionCommon::KeyDateTime);
 
  1033     QCOMPARE(mTestObject->sortRole(), (int)VideoCollectionCommon::KeyDateTime);
 
  1031     spyAboutToChange.clear();
 
  1034     spyAboutToChange.clear();
 
  1032     spyChanged.clear();
 
  1035     spyChanged.clear();
 
  1033     QVERIFY(VideoThumbnailData::mStartBackgroundFetchingCallCount == 2);
 
  1036     QCOMPARE(spySorted.count(), 2);
 
  1034 }
 
  1037 }
 
  1035 
  1038 
  1036 // ---------------------------------------------------------------------------
 
  1039 // ---------------------------------------------------------------------------
 
  1037 // testFilterAcceptsRow
 
  1040 // testFilterAcceptsRow
 
  1038 // ---------------------------------------------------------------------------
 
  1041 // ---------------------------------------------------------------------------
FCL/sf/app/videoplayer