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/testvideomodel_p/src/testvideomodel_p.cpp
changeset 36 8aed59de29f9
parent 35 3738fe97f027
child 38 ff53afa8ad05
equal deleted inserted replaced
35:3738fe97f027 36:8aed59de29f9 
    14 * Description: 
    14 * Description: 
    15 *
 
    15 *
 
    16 */
 
    16 */
 
    17 
    17 
    18 // INCLUDES
 
    18 // INCLUDES
 
       
    19 #include <hbglobal.h>
 
       
    20 #include <hbextendedlocale.h>
 
    19 #include <mpxmediageneraldefs.h>
 
    21 #include <mpxmediageneraldefs.h>
 
    20 #include <mpxmediaarray.h>
 
    22 #include <mpxmediaarray.h>
 
    21 #include <mpxmedia.h>
 
    23 #include <mpxmedia.h>
 
    22 #include <vcxmyvideosdefs.h>
 
    24 #include <vcxmyvideosdefs.h>
 
    23 #include <qabstractitemmodel.h>
 
    25 #include <qabstractitemmodel.h>
 
    28 #include "videolistdatamodel.h"
 
    30 #include "videolistdatamodel.h"
 
    29 
    31 
    30 #include "mediaobjectfactory.h"
 
    32 #include "mediaobjectfactory.h"
 
    31 #include "videocollectioncommon.h"
 
    33 #include "videocollectioncommon.h"
 
    32 #include "videocollectionutils.h"
 
    34 #include "videocollectionutils.h"
 
       
    35 #include "metadatasignalspy.h"
 
    33 
    36 
    34 #define private public
 
    37 #define private public
 
    35 #include "videolistdatamodel_p.h"
 
    38 #include "videolistdatamodel_p.h"
 
    36 #undef private
 
    39 #undef private
 
    37 
    40 
   452     QVERIFY(mTestObject->getVideoDateFromIndex(MEDIA_COUNT - 1) == excepted);
 
   455     QVERIFY(mTestObject->getVideoDateFromIndex(MEDIA_COUNT - 1) == excepted);
 
   453     disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*)));
 
   456     disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*)));
 
   454 }
 
   457 }
 
   455 
   458 
   456 // -----------------------------------------------------------------------------
 
   459 // -----------------------------------------------------------------------------
 
   457 // testGetMetaDataFromIndex
 
       
   458 // -----------------------------------------------------------------------------
 
       
   459 //
 
       
   460 void TestVideoModel_p::testGetMetaDataFromIndex()
 
       
   461 {
 
       
   462     using namespace VideoCollectionCommon;
 
       
   463     QMap<QString, QVariant> map = mTestObject->getMetaDataFromIndex(0);
 
       
   464     QVERIFY(map.isEmpty());
 
       
   465     map = mTestObject->getMetaDataFromIndex(-1);
 
       
   466     QVERIFY(map.isEmpty());
 
       
   467     
       
   468     mMediaFactory->removeArray();
 
       
   469     QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));           
       
   470     mMediaFactory->createMediaItems(MEDIA_COUNT);
 
       
   471     emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
 
       
   472         
       
   473     map = mTestObject->getMetaDataFromIndex(-1);
 
       
   474     QVERIFY(map.isEmpty());
 
       
   475     
       
   476     map = mTestObject->getMetaDataFromIndex(-1);
 
       
   477     QVERIFY(map.isEmpty());
 
       
   478     
       
   479     map = mTestObject->getMetaDataFromIndex(0);
 
       
   480     
       
   481     QVERIFY(map.contains(MetaKeyDate));
 
       
   482     QVERIFY(map.contains(MetaKeyDurationString));
 
       
   483     QVERIFY(map.contains(MetaKeySizeString));
 
       
   484     QVERIFY(map.contains(MetaKeyStarRating));
 
       
   485     QVERIFY(map.contains(MetaKeyDescription));
 
       
   486     QVERIFY(map.contains(MetaKeyModifiedDate));
 
       
   487     QVERIFY(map.contains(MetaKeyAuthor));
 
       
   488     QVERIFY(map.contains(MetaKeyCopyright));
 
       
   489     QVERIFY(map.contains(MetaKeyLanguageString));
 
       
   490     QVERIFY(map.contains(MetaKeyFormat));
 
       
   491     
       
   492     // one or several of these will fail, when rest of the metadata is implemented.
 
       
   493     QVERIFY(map.contains(MetaKeyDRMInfo) == false);
 
       
   494     QVERIFY(map.contains(MetaKeyServiceURL) == false);
 
       
   495     QVERIFY(map.contains(MetaKeyShotLocation) == false);
 
       
   496     QVERIFY(map.contains(MetaKeyAudioType) == false);
 
       
   497     QVERIFY(map.contains(MetaKeyKeywords) == false);
 
       
   498     QVERIFY(map.contains(MetaKeyVideoResolutionString) == false);
 
       
   499     QVERIFY(map.contains(MetaKeyBitRate) == false);
 
       
   500     
       
   501     QCOMPARE(map[MetaKeyDate].toDate(), QDate(2009, 1, 1));
 
       
   502     QVERIFY(map[MetaKeyDurationString].toString().isEmpty() == false);
 
       
   503     QVERIFY(map[MetaKeySizeString].toString().isEmpty() == false);
 
       
   504     QCOMPARE(map[MetaKeyStarRating].toUInt(), (uint)1);
 
       
   505     QCOMPARE(map[MetaKeyDescription].toString(), gQTMediaDescPrefix + "0");
 
       
   506     QCOMPARE(map[MetaKeyModifiedDate].toDate(), QDate::currentDate().addDays(2));
 
       
   507     QCOMPARE(map[MetaKeyAuthor].toString(), gQTMediaAuthorPrefix + "0");
 
       
   508     QCOMPARE(map[MetaKeyCopyright].toString(), gQTMediaCopyrightPrefix + "0");
 
       
   509     QCOMPARE(map[MetaKeyLanguageString].toString(), gQTMediaLanguagePrefix + "0");
 
       
   510     QCOMPARE(map[MetaKeyFormat].toString(), gQTMediaFormatPrefix + "0");
 
       
   511     
       
   512     // data does not exist
 
       
   513     mTestObject->mMediaData.clear();
 
       
   514     mMediaFactory->removeArray();
 
       
   515     mMediaFactory->createMediaItems(MEDIA_COUNT, MediaDataId);    
       
   516     emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
 
       
   517     VideoCollectionUtils::mPrepareLengthStringReturnValue = "";
 
       
   518     VideoCollectionUtils::mPrepareSizeStringReturnValue = "";
 
       
   519     
       
   520     map = mTestObject->getMetaDataFromIndex(-1);
 
       
   521     QVERIFY(map.isEmpty());
 
       
   522     
       
   523     map = mTestObject->getMetaDataFromIndex(MEDIA_COUNT);
 
       
   524     QVERIFY(map.isEmpty());
 
       
   525     
       
   526     map = mTestObject->getMetaDataFromIndex(0);
 
       
   527     QCOMPARE(map.count(), 0); 
       
   528     
       
   529     map = mTestObject->getMetaDataFromIndex(MEDIA_COUNT - 1);
 
       
   530     QCOMPARE(map.count(), 0);
 
       
   531     
       
   532     disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*)));
 
       
   533 }
 
       
   534 
       
   535 // -----------------------------------------------------------------------------
 
       
   536 // testVideoMarkAndRestoreDeleted
 
   460 // testVideoMarkAndRestoreDeleted
 
   537 // -----------------------------------------------------------------------------
 
   461 // -----------------------------------------------------------------------------
 
   538 //
 
   462 //
 
   539 void TestVideoModel_p::testVideoMarkAndRestoreDeleted()
 
   463 void TestVideoModel_p::testVideoMarkAndRestoreDeleted()
 
   540 {
 
   464 {
 
   655     QCOMPARE(path, gQTMediaPathPrefix + "0");
 
   579     QCOMPARE(path, gQTMediaPathPrefix + "0");
 
   656     
   580     
   657     // data does not exist
 
   581     // data does not exist
 
   658     mTestObject->mMediaData.clear();
 
   582     mTestObject->mMediaData.clear();
 
   659     mMediaFactory->removeArray();
 
   583     mMediaFactory->removeArray();
 
   660     mMediaFactory->createMediaItems(MEDIA_COUNT, MediaDataId);    
   584     mMediaFactory->createMediaItems(MEDIA_COUNT, MediaDataId);
 
   661     emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
 
   585     emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
 
   662     
   586     
   663     path = mTestObject->getFilePathForId(TMPXItemId(0,0));
 
   587     path = mTestObject->getFilePathForId(TMPXItemId(0,0));
 
   664     QVERIFY(path.isNull());
 
   588     QVERIFY(path.isNull());
 
   665     
   589     
   874     
   798     
   875     VideoListDataModel::mFirstInserted = -1;
 
   799     VideoListDataModel::mFirstInserted = -1;
 
   876     VideoListDataModel::mLastInserted = -1;
 
   800     VideoListDataModel::mLastInserted = -1;
 
   877     
   801     
   878     // append null
 
   802     // append null
 
   879    emit signalAppendVideoList(0);
 
   803     emit signalAppendVideoList(0);
 
   880     QVERIFY(VideoListDataModel::mFirstInserted == -1);
 
   804     QVERIFY(VideoListDataModel::mFirstInserted == -1);
 
   881     QVERIFY(VideoListDataModel::mLastInserted == -1);
 
   805     QVERIFY(VideoListDataModel::mLastInserted == -1);
 
   882     QVERIFY(mTestObject->getVideoCount() == 0);
 
   806     QVERIFY(mTestObject->getVideoCount() == 0);
 
   883     QVERIFY(spyModelChanged.count() == 0);
 
   807     QVERIFY(spyModelChanged.count() == 0);
 
   884     
   808     
  1010     disconnect(this, SIGNAL(signalAlbumListAvailable(TMPXItemId, CMPXMediaArray*)),
 
   934     disconnect(this, SIGNAL(signalAlbumListAvailable(TMPXItemId, CMPXMediaArray*)),
 
  1011                 mTestObject, SLOT(albumListAvailableSlot(TMPXItemId, CMPXMediaArray*)));
 
   935                 mTestObject, SLOT(albumListAvailableSlot(TMPXItemId, CMPXMediaArray*)));
 
  1012 }
 
   936 }
 
  1013 
   937 
  1014 // -----------------------------------------------------------------------------
 
   938 // -----------------------------------------------------------------------------
 
       
   939 // testItemModifiedSlot
 
       
   940 // -----------------------------------------------------------------------------
 
       
   941 //
 
       
   942 void TestVideoModel_p::testItemModifiedSlot()
 
       
   943 {
 
       
   944     mMediaFactory->removeArray();
 
       
   945 
       
   946     QVERIFY(connect(this, SIGNAL(signalItemModified(const TMPXItemId &)), mTestObject, SLOT(itemModifiedSlot(const TMPXItemId &))));  
       
   947     
       
   948     QSignalSpy spysignal(mTestObject, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex &)));
 
       
   949 
       
   950     // invalid item id, no items
 
       
   951     TMPXItemId id = TMPXItemId::InvalidId();
 
       
   952     emit signalItemModified(id);
 
       
   953     QVERIFY(spysignal.count() == 0);
 
       
   954     
       
   955     // invalid item id, model has items
 
       
   956     QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));           
       
   957     mMediaFactory->createMediaItems(MEDIA_COUNT);
 
       
   958     emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
 
       
   959 
       
   960     emit signalItemModified(id);
 
       
   961     QVERIFY(spysignal.count() == 0);
 
       
   962     
       
   963     // ok item id, model has items
 
       
   964     id = TMPXItemId(0, 0);
 
       
   965     emit signalItemModified(id);
 
       
   966     QVERIFY(spysignal.count() == 1);
 
       
   967     spysignal.clear();
 
       
   968     
       
   969     // ok item id, model has items but returns invalid index
 
       
   970     VideoListDataModel::mIndexReturnsInvalid = true;
 
       
   971     id = TMPXItemId(0, 0);
 
       
   972     emit signalItemModified(id);
 
       
   973     QVERIFY(spysignal.count() == 0);
 
       
   974     spysignal.clear();
 
       
   975 
       
   976     disconnect(this, SIGNAL(signalItemModified(const TMPXItemId &)), mTestObject, SLOT(itemModifiedSlot(const TMPXItemId &)));    
       
   977     VideoListDataModel::mIndexReturnsInvalid = false;
 
       
   978 }
 
       
   979 
       
   980 // -----------------------------------------------------------------------------
 
  1015 // testNewVideoAvailableSlot
 
   981 // testNewVideoAvailableSlot
 
  1016 // -----------------------------------------------------------------------------
 
   982 // -----------------------------------------------------------------------------
 
  1017 //
 
   983 //
 
  1018 void TestVideoModel_p::testNewVideoAvailableSlot()
 
   984 void TestVideoModel_p::testNewVideoAvailableSlot()
 
  1019 {
 
   985 {
 
       
   986     VideoListDataModel::mIndexReturnsInvalid = false;
 
  1020     QVERIFY(mTestObject->initialize() == 0);
 
   987     QVERIFY(mTestObject->initialize() == 0);
 
  1021     
   988     
  1022     connect(this, SIGNAL(signalNewVideoAvailable(CMPXMedia*)), mTestObject, SLOT(newVideoAvailableSlot(CMPXMedia*)));
 
   989     connect(this, SIGNAL(signalNewVideoAvailable(CMPXMedia*)), mTestObject, SLOT(newVideoAvailableSlot(CMPXMedia*)));
 
  1023     connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))); 
   990     connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))); 
  1024     
   991     
  1319 
  1286 
  1320 // -----------------------------------------------------------------------------
 
  1287 // -----------------------------------------------------------------------------
 
  1321 // testVideoDetailsCompletedSlot
 
  1288 // testVideoDetailsCompletedSlot
 
  1322 // -----------------------------------------------------------------------------
 
  1289 // -----------------------------------------------------------------------------
 
  1323 //
 
  1290 //
 
  1324 
       
  1325 void TestVideoModel_p::testVideoDetailsCompletedSlot()
 
  1291 void TestVideoModel_p::testVideoDetailsCompletedSlot()
 
  1326 {
 
  1292 {
 
  1327     mMediaFactory->removeArray();
 
  1293     using namespace VideoCollectionCommon;
 
  1328     QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));  
  1294     
  1329     QVERIFY(connect(this, SIGNAL(signalVideoDetailsCompleted(TMPXItemId)), mTestObject, SLOT(videoDetailsCompletedSlot(TMPXItemId))));      
  1295     mMediaFactory->removeArray();
 
  1330     
  1296 //    QVERIFY(connect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*))));  
  1331     QSignalSpy spysignal(mTestObject, SIGNAL(videoDetailsReady(TMPXItemId)));
 
  1297     QVERIFY(connect(this, SIGNAL(signalVideoDetailsCompleted(CMPXMedia*)), mTestObject, SLOT(videoDetailsCompletedSlot(CMPXMedia*))));      
  1332 
  1298     
  1333     // no videos, id ok
 
  1299     HbExtendedLocale locale = HbExtendedLocale::system();
 
  1334     emit signalVideoDetailsCompleted(TMPXItemId(0,0));
 
  1300     
  1335     QVERIFY(spysignal.count() == 1);        
  1301     MetaDataSignalSpy spysignal(mTestObject, SIGNAL(videoDetailsReady(QVariant&)));
 
       
  1302     
       
  1303     // check with NULL media.
 
       
  1304     emit signalVideoDetailsCompleted(0);
 
       
  1305     QCOMPARE(spysignal.count, 0);
 
       
  1306     
       
  1307     // setup medias.
 
       
  1308     mMediaFactory->createMediaItems(2);
 
       
  1309     CMPXMedia* media = mMediaFactory->mediaArray()->operator [](0);
 
       
  1310     
       
  1311     // ok case
 
       
  1312     emit signalVideoDetailsCompleted(media);
 
       
  1313     QCOMPARE(spysignal.count, 1);
 
       
  1314     QMap<QString, QVariant> map = spysignal.arg.toMap();
 
       
  1315     
       
  1316     QVERIFY(map.contains(MetaKeyDate));
 
       
  1317     QVERIFY(map.contains(MetaKeyDurationString));
 
       
  1318     QVERIFY(map.contains(MetaKeySizeString));
 
       
  1319     QVERIFY(map.contains(MetaKeyStarRating));
 
       
  1320     QVERIFY(map.contains(MetaKeyDescription));
 
       
  1321     QVERIFY(map.contains(MetaKeyModifiedDate));
 
       
  1322     QVERIFY(map.contains(MetaKeyAuthor));
 
       
  1323     QVERIFY(map.contains(MetaKeyCopyright));
 
       
  1324     QVERIFY(map.contains(MetaKeyLanguageString));
 
       
  1325     QVERIFY(map.contains(MetaKeyFormat));
 
       
  1326     QVERIFY(map.contains(MetaKeyVideoResolutionString));
 
       
  1327     QVERIFY(map.contains(MetaKeyBitRate));
 
       
  1328     
       
  1329     // one or several of these will fail, when rest of the metadata is implemented.
 
       
  1330     QVERIFY(map.contains(MetaKeyDRMInfo) == false);
 
       
  1331     QVERIFY(map.contains(MetaKeyServiceURL) == false);
 
       
  1332     QVERIFY(map.contains(MetaKeyShotLocation) == false);
 
       
  1333     QVERIFY(map.contains(MetaKeyAudioType) == false);
 
       
  1334     QVERIFY(map.contains(MetaKeyKeywords) == false);
 
       
  1335     
       
  1336     QCOMPARE(map[MetaKeyDate].toString(), locale.format(QDate(2009, 1, 1), r_qtn_date_usual));
 
       
  1337     QVERIFY(map[MetaKeyDurationString].toString().isEmpty() == false);
 
       
  1338     QVERIFY(map[MetaKeySizeString].toString().isEmpty() == false);
 
       
  1339     QCOMPARE(map[MetaKeyStarRating].toUInt(), (uint)1);
 
       
  1340     QCOMPARE(map[MetaKeyDescription].toString(), gQTMediaDescPrefix + "0");
 
       
  1341     QCOMPARE(map[MetaKeyModifiedDate].toString(), locale.format(QDate::currentDate().addDays(2), r_qtn_date_usual));
 
       
  1342     QCOMPARE(map[MetaKeyAuthor].toString(), gQTMediaAuthorPrefix + "0");
 
       
  1343     QCOMPARE(map[MetaKeyCopyright].toString(), gQTMediaCopyrightPrefix + "0");
 
       
  1344     QCOMPARE(map[MetaKeyLanguageString].toString(), gQTMediaLanguagePrefix + "0");
 
       
  1345     QCOMPARE(map[MetaKeyFormat].toString(), gQTMediaFormatPrefix + "0");
 
       
  1346     QCOMPARE(map[MetaKeyVideoResolutionString].toString(), hbTrId("txt_videos_list_l1l2").arg(1).arg(2));
 
       
  1347     QCOMPARE(map[MetaKeyBitRate].toString(), hbTrId("txt_videos_list_l1_kbps", 800));
 
       
  1348     
       
  1349     // Mbps case
 
       
  1350     media = mMediaFactory->mediaArray()->operator [](1);
 
       
  1351     emit signalVideoDetailsCompleted(media);
 
       
  1352     QCOMPARE(spysignal.count, 2);
 
       
  1353     map = spysignal.arg.toMap();    
       
  1354     QVERIFY(map.contains(MetaKeyBitRate));
 
       
  1355     QCOMPARE(map[MetaKeyBitRate].toString(), hbTrId("txt_videos_list_l1_mbps", 2));
 
       
  1356     
       
  1357     // empty media case
 
  1336     spysignal.clear();
 
  1358     spysignal.clear();
 
  1337     
  1359     mMediaFactory->removeArray();
 
  1338     mMediaFactory->createMediaItems(MEDIA_COUNT);
 
  1360     mMediaFactory->createMediaItems(1, MediaDataId);
 
  1339     emit signalNewVideoList(mMediaFactory->copyOfMediaArray());
 
  1361     CMPXMedia* emptyMedia = mMediaFactory->mediaArray()->operator [](0);
 
  1340     
  1362     
  1341     // invalid id
 
  1363     emit signalVideoDetailsCompleted(emptyMedia);
 
  1342     emit signalVideoDetailsCompleted(TMPXItemId::InvalidId());
 
  1364     QCOMPARE(spysignal.count, 1);
 
  1343     QVERIFY(spysignal.count() == 0); 
  1365     map = spysignal.arg.toMap();
 
  1344     
  1366     QCOMPARE(map.count(), 2);
 
  1345     // correct ids
 
  1367     QVERIFY(map.contains(MetaKeyDurationString));
 
  1346     emit signalVideoDetailsCompleted(TMPXItemId(0,0));
 
  1368     QVERIFY(map.contains(MetaKeySizeString));
 
  1347     QVERIFY(spysignal.count() == 1); 
       
  1348     QVERIFY(spysignal.value(0).at(0).toInt() == 0);
 
       
  1349     spysignal.clear();
 
       
  1350     emit signalVideoDetailsCompleted(TMPXItemId(MEDIA_COUNT - 1,0));
 
       
  1351     QVERIFY(spysignal.count() == 1); 
       
  1352     
  1369     
  1353     disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*)));  
  1370     disconnect(this, SIGNAL(signalNewVideoList(CMPXMediaArray*)), mTestObject, SLOT(newVideoListSlot(CMPXMediaArray*)));  
  1354     disconnect(this, SIGNAL(signalVideoDetailsCompleted(TMPXItemId)), mTestObject, SLOT(videoDetailsCompletedSlot(TMPXItemId)));
 
  1371     disconnect(this, SIGNAL(signalVideoDetailsCompleted(TMPXItemId)), mTestObject, SLOT(videoDetailsCompletedSlot(TMPXItemId)));
 
  1355 }
 
  1372 }
 
  1356 
  1373
FCL/sf/app/videoplayer