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/testvideocollectionlistener/src/testvideocollectionlistener.cpp
changeset 36 8aed59de29f9
parent 34 bbb98528c666
child 38 ff53afa8ad05
equal deleted inserted replaced
35:3738fe97f027 36:8aed59de29f9 
     1 
       
     2 /**
 
     1 /**
 
     3 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 
     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 
     4 * All rights reserved.
 
     3 * All rights reserved.
 
     5 * This component and the accompanying materials are made available
 
     4 * This component and the accompanying materials are made available
 
     6 * under the terms of "Eclipse Public License v1.0"
 
     5 * under the terms of "Eclipse Public License v1.0"
 
   176     
   175     
   177     // signal emitting: correct media-array passed
 
   176     // signal emitting: correct media-array passed
 
   178     CMPXMediaArray *array = mMediaFactory->newMediaArray();  
   177     CMPXMediaArray *array = mMediaFactory->newMediaArray();  
   179     
   178     
   180     CMPXMediaArray *arrayToTest = 0;
 
   179     CMPXMediaArray *arrayToTest = 0;
 
   181   
   180 
   182     QWARN("test for other paths than all videos are missing");
 
   181     // empty array, no path   
       
   182     mMediaFactory->putValuePtr<CMPXMediaArray>(media, KMPXMediaArrayContents, array);
 
       
   183     mStubCollection->callHandleOpenLFunc(*media, 0, true, 0 ); 
       
   184     arrayToTest = static_cast<CMPXMediaArray*>(mSignalReceiver->getLatestPointerAddr());
 
       
   185     QVERIFY(arrayToTest == 0);
 
       
   186 
   183     CMPXCollectionPath* collectionPath = 0;
 
   187     CMPXCollectionPath* collectionPath = 0;
 
   184     TRAP_IGNORE(
 
   188     TRAP_IGNORE(
 
   185             collectionPath =  CMPXCollectionPath::NewL();
 
   189            collectionPath =  CMPXCollectionPath::NewL();
 
   186             collectionPath->AppendL( KVcxUidMyVideosMpxCollection );
 
   190            collectionPath->AppendL( KVcxUidMyVideosMpxCollection ););
 
   187             collectionPath->AppendL( KVcxMvcCategoryIdAll););
 
   191     
   188   
   192     // empty array, path exists level incorrect (new video list, not category neither album level)     
   189     // empty array
 
       
   190     mMediaFactory->putValuePtr<CMPXMediaArray>(media, KMPXMediaArrayContents, array);   
       
   191     mMediaFactory->putValuePtr<CMPXCollectionPath>(media, KMPXMediaGeneralContainerPath, collectionPath); 
   193     mMediaFactory->putValuePtr<CMPXCollectionPath>(media, KMPXMediaGeneralContainerPath, collectionPath); 
   192     mStubCollection->callHandleOpenLFunc(*media, 0, true, 0 ); 
   194     mStubCollection->callHandleOpenLFunc(*media, 0, true, 0 ); 
   193     arrayToTest = static_cast<CMPXMediaArray*>(mSignalReceiver->getLatestPointerAddr());
 
   195     arrayToTest = static_cast<CMPXMediaArray*>(mSignalReceiver->getLatestPointerAddr());
 
   194     QVERIFY(arrayToTest != 0);
 
   196     QVERIFY(arrayToTest != 0);
 
   195     QVERIFY(arrayToTest->Count() == array->Count());
 
   197     QVERIFY(arrayToTest->Count() == array->Count());
 
       
   198     
       
   199     delete collectionPath;
 
       
   200     // empty array, path exists level correct      
       
   201     collectionPath = 0;
 
       
   202     TRAP_IGNORE(
 
       
   203           collectionPath =  CMPXCollectionPath::NewL();
 
       
   204           collectionPath->AppendL( KVcxUidMyVideosMpxCollection );
 
       
   205           collectionPath->AppendL( KVcxMvcCategoryIdAll););
 
   196 
   206 
   197     // array of items from different levels, everything is reported 
   207     // array of items from different levels, everything is reported 
   198     mStubCollectionClient->setCollectionLevel(VideoCollectionCommon::ELevelCategory);
 
   208     mStubCollectionClient->setCollectionLevel(VideoCollectionCommon::ELevelCategory);
 
   199     mMediaFactory->putArrayContent(array, mMediaFactory->newMedia(1, 2));
 
   209     mMediaFactory->putArrayContent(array, mMediaFactory->newMedia(1, 2));
 
   200     mMediaFactory->putValuePtr<CMPXCollectionPath>(media, KMPXMediaGeneralContainerPath, collectionPath); 
   210     mMediaFactory->putValuePtr<CMPXCollectionPath>(media, KMPXMediaGeneralContainerPath, collectionPath); 
   217     mStubCollection->callHandleOpenLFunc(*media, 0, true, 0 );    
   227     mStubCollection->callHandleOpenLFunc(*media, 0, true, 0 );    
   218     
   228     
   219     arrayToTest = static_cast<CMPXMediaArray*>(mSignalReceiver->getLatestPointerAddr());
 
   229     arrayToTest = static_cast<CMPXMediaArray*>(mSignalReceiver->getLatestPointerAddr());
 
   220     QVERIFY(arrayToTest != 0);
 
   230     QVERIFY(arrayToTest != 0);
 
   221     QVERIFY(arrayToTest->Count() == array->Count());
 
   231     QVERIFY(arrayToTest->Count() == array->Count());
 
       
   232     
       
   233     delete collectionPath;
 
       
   234     collectionPath = 0;
 
       
   235     TRAP_IGNORE(
 
       
   236          collectionPath =  CMPXCollectionPath::NewL();
 
       
   237          collectionPath->AppendL( KVcxUidMyVideosMpxCollection );
 
       
   238          collectionPath->AppendL( KVcxMvcMediaTypeCategory););
 
       
   239     mMediaFactory->putValuePtr<CMPXCollectionPath>(media, KMPXMediaGeneralContainerPath, collectionPath); 
   222     
   240     
   223     mStubCollection->callHandleOpenLFunc(*media, 0, true, 0 );    
   241     mStubCollection->callHandleOpenLFunc(*media, 0, true, 0 );    
   224        
   242        
   225     arrayToTest = static_cast<CMPXMediaArray*>(mSignalReceiver->getLatestPointerAddr());
 
   243     arrayToTest = static_cast<CMPXMediaArray*>(mSignalReceiver->getLatestPointerAddr());
 
   226     QVERIFY(arrayToTest != 0);
 
   244     QVERIFY(arrayToTest != 0);
 
   300     int remHeap = User::Heap().__DbgMarkEnd(0);
 
   318     int remHeap = User::Heap().__DbgMarkEnd(0);
 
   301     QVERIFY(remHeap == 0); 
   319     QVERIFY(remHeap == 0); 
   302 }
 
   320 }
 
   303 
   321 
   304 // -----------------------------------------------------------------------------
 
   322 // -----------------------------------------------------------------------------
 
   305 // testHandleCommandComplete
 
   323 // testHandleCommandCompleteInvalid
 
   306 // -----------------------------------------------------------------------------
 
   324 // -----------------------------------------------------------------------------
 
   307 //
 
   325 //
 
   308 void TestVideoCollectionListener::testHandleCommandComplete()
 
   326 void TestVideoCollectionListener::testHandleCommandCompleteInvalid()
 
   309 {
 
   327 {
 
   310     
   328     
   311     User::Heap().__DbgMarkStart(); 
   329     User::Heap().__DbgMarkStart(); 
   312     
   330     
   313     CMPXCommand *pCommand = mMediaFactory->newMedia(0);
 
   331     CMPXCommand *pCommand = mMediaFactory->newMedia(0);
 
   314     
   332     
   315     // error != KErrNone
 
   333     // error != KErrNone
 
   316     mStubCollection->callHandleCommandComplete(pCommand, -2);
 
   334     mStubCollection->callHandleCommandComplete(pCommand, -2);
 
   317     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());
 
   335     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());
 
       
   336     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
   318     
   337     
   319     // command == NULL
 
   338     // command == NULL
 
   320     mStubCollection->callHandleCommandComplete(0, 0);
 
   339     mStubCollection->callHandleCommandComplete(0, 0);
 
   321     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());
 
   340     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());
 
       
   341     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
   322     
   342     
   323     // null command + error != KErrNone
 
   343     // null command + error != KErrNone
 
   324     mStubCollection->callHandleCommandComplete(0, -2);
 
   344     mStubCollection->callHandleCommandComplete(0, -2);
 
   325     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());
 
   345     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());
 
       
   346     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
   326      
   347      
   327     // command without id
 
   348     // command without id
 
   328     delete pCommand;
 
   349     delete pCommand;
 
   329     pCommand = mMediaFactory->newMedia();
 
   350     pCommand = mMediaFactory->newMedia();
 
   330     mStubCollection->callHandleCommandComplete(pCommand, 0);
 
   351     mStubCollection->callHandleCommandComplete(pCommand, 0);
 
   331     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());
 
   352     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());
 
       
   353     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
   332     
   354     
   333     // no command attribute
 
   355     // no command attribute
 
   334     delete pCommand;
 
   356     delete pCommand;
 
   335     pCommand = mMediaFactory->newMedia(0);
 
   357     pCommand = mMediaFactory->newMedia(0);
 
   336     mStubCollection->callHandleCommandComplete(pCommand, 0);
 
   358     mStubCollection->callHandleCommandComplete(pCommand, 0);
 
   337     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());
 
   359     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());
 
       
   360     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
   338     
   361     
   339     // invalid KVcxMediaMyVideosCommandId
 
   362     // invalid KVcxMediaMyVideosCommandId
 
   340     int value = (KVcxCommandMyVideosGetMediaFullDetailsByMpxId + 10);
 
   363     int value = (KVcxCommandMyVideosGetMediaFullDetailsByMpxId + 10);
 
   341     mMediaFactory->putTValue<int>(pCommand, KVcxMediaMyVideosCommandId, value );
 
   364     mMediaFactory->putTValue<int>(pCommand, KVcxMediaMyVideosCommandId, value );
 
   342     mStubCollection->callHandleCommandComplete(pCommand, 0);
 
   365     mStubCollection->callHandleCommandComplete(pCommand, 0);
 
   343     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());
 
   366     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());
 
   344     
   367     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
       
   368     
       
   369     delete pCommand;
 
       
   370 
       
   371     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
       
   372     
       
   373     int remHeap = User::Heap().__DbgMarkEnd(0);
 
       
   374     QVERIFY(remHeap == 0);   
       
   375 }
 
       
   376 
       
   377 // -----------------------------------------------------------------------------
 
       
   378 // testHandleCommandCompleteGetDetails
 
       
   379 // -----------------------------------------------------------------------------
 
       
   380 //
 
       
   381 void TestVideoCollectionListener::testHandleCommandCompleteGetDetails()
 
       
   382 {
 
       
   383     mSignalReceiver->resetLatestItems();
 
       
   384     User::Heap().__DbgMarkStart(); 
       
   385     CMPXCommand *pCommand = mMediaFactory->newMedia(0);
 
       
   386     // cmd KVcxCommandMyVideosGetMediaFullDetailsByMpxId
 
   345     // no media object in command
 
   387     // no media object in command
 
       
   388     int value;
 
   346     value = KVcxCommandMyVideosGetMediaFullDetailsByMpxId;
 
   389     value = KVcxCommandMyVideosGetMediaFullDetailsByMpxId;
 
   347     mMediaFactory->putTValue<int>(pCommand, KVcxMediaMyVideosCommandId, value );
 
   390     mMediaFactory->putTValue<int>(pCommand, KVcxMediaMyVideosCommandId, value );
 
   348     mStubCollection->callHandleCommandComplete(pCommand, 0);
 
   391     mStubCollection->callHandleCommandComplete(pCommand, 0);
 
   349     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());
 
   392     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
   350     
   393     
   351     // NOTE! we cannot test with item without KMPXMediaGeneralId, because after creation CMPXMedia 
   394     // correct item 
   352     //       always contain default value
 
   395     delete pCommand;
 
   353     
   396     pCommand = mMediaFactory->newMedia();
 
   354     // correct item    
       
   355     CMPXMedia *subMedia = mMediaFactory->newMedia(10);
 
   397     CMPXMedia *subMedia = mMediaFactory->newMedia(10);
 
       
   398     mMediaFactory->putTValue<int>(pCommand, KVcxMediaMyVideosCommandId, value );
 
   356     mMediaFactory->putValuePtr<CMPXMedia>(pCommand, KMPXCommandColAddMedia, subMedia);
 
   399     mMediaFactory->putValuePtr<CMPXMedia>(pCommand, KMPXCommandColAddMedia, subMedia);
 
   357     mStubCollection->callHandleCommandComplete(pCommand, 0);
 
   400     mStubCollection->callHandleCommandComplete(pCommand, 0);
 
   358     QVERIFY(mSignalReceiver->getLatestItemId().iId1  == 10);
 
   401     TMPXItemId itemId = TMPXItemId::InvalidId();
 
   359 
   402     TMPXItemId expectedId = TMPXItemId::InvalidId();
 
       
   403     TRAP_IGNORE(itemId = static_cast<CMPXMedia*>(mSignalReceiver->getLatestPointerAddr())->ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId));
 
       
   404     TRAP_IGNORE(expectedId = subMedia->ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId));
 
       
   405     QVERIFY(itemId == expectedId);
 
       
   406     
   360     delete subMedia;
 
   407     delete subMedia;
 
   361     delete pCommand;
 
   408     delete pCommand;
 
   362     
   409     
   363     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
   410     int remHeap = User::Heap().__DbgMarkEnd(0);
 
       
   411     QVERIFY(remHeap == 0);   
       
   412 }
 
       
   413 
       
   414 // -----------------------------------------------------------------------------
 
       
   415 // testHandleCommandCompleteRemoveAlbums
 
       
   416 // -----------------------------------------------------------------------------
 
       
   417 //
 
       
   418 void TestVideoCollectionListener::testHandleCommandCompleteRemoveAlbums()
 
       
   419 {
 
       
   420     mSignalReceiver->resetLatestItems();
 
       
   421     
       
   422     User::Heap().__DbgMarkStart(); 
       
   423     CMPXCommand *pCommand = mMediaFactory->newMedia(0);
 
       
   424     
       
   425     int value = KVcxCommandMyVideosRemoveAlbums;
 
       
   426 
       
   427     // no messageArray object in command
 
       
   428     mMediaFactory->putTValue<int>(pCommand, KVcxMediaMyVideosCommandId, value );
 
       
   429     mStubCollection->callHandleCommandComplete(pCommand, 0);
 
       
   430     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
       
   431     
       
   432     delete pCommand;
 
       
   433     pCommand = mMediaFactory->newMedia();
 
       
   434     
       
   435     // empty message array    
       
   436     mMediaFactory->putTValue<int>(pCommand, KVcxMediaMyVideosCommandId, value );
 
       
   437     CMPXMediaArray *array = mMediaFactory->newMediaArray();
 
       
   438     mMediaFactory->putValuePtr<CMPXMediaArray>(pCommand, KMPXMediaArrayContents, array);
 
       
   439     mStubCollection->callHandleCommandComplete(pCommand, 0);
 
       
   440     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
       
   441     
       
   442     delete array;
 
       
   443     delete pCommand;
 
       
   444     pCommand = mMediaFactory->newMedia();
 
       
   445     
       
   446     // some items, no failed
 
       
   447     mMediaFactory->putTValue<int>(pCommand, KVcxMediaMyVideosCommandId, value );
 
       
   448     CMPXMedia *media1 = mMediaFactory->newMedia(1,0);
 
       
   449     CMPXMedia *media2 = mMediaFactory->newMedia(2,0);
 
       
   450     CMPXMedia *media3 = mMediaFactory->newMedia(3,0);
 
       
   451     array = mMediaFactory->newMediaArray();
 
       
   452     TRAP_IGNORE(
 
       
   453         array->AppendL(media1);
 
       
   454         array->AppendL(media2);
 
       
   455         array->AppendL(media3););
 
       
   456     
       
   457     mMediaFactory->putValuePtr<CMPXMediaArray>(pCommand, KMPXMediaArrayContents, array);
 
       
   458     mStubCollection->callHandleCommandComplete(pCommand, 0);
 
       
   459     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
       
   460     delete array;
 
       
   461     delete pCommand;
 
       
   462 
       
   463     // some items, one invalid item, no failed   
       
   464     array = mMediaFactory->newMediaArray();
 
       
   465     pCommand = mMediaFactory->newMedia();
 
       
   466     mMediaFactory->putTValue<int>(pCommand, KVcxMediaMyVideosCommandId, value );
 
       
   467     media1 = mMediaFactory->newMedia(1,0);
 
       
   468     media2 = mMediaFactory->newMedia(2,0);
 
       
   469     media3 = mMediaFactory->newMedia(3,0);
 
       
   470     CMPXMedia *media4;
 
       
   471     TRAP_IGNORE(media4 = CMPXMedia::NewL());
 
       
   472     TRAP_IGNORE(
 
       
   473         array->AppendL(media1);
 
       
   474         array->AppendL(media2);
 
       
   475         array->AppendL(media3);
 
       
   476         array->AppendL(media4););
 
       
   477     
       
   478     mMediaFactory->putValuePtr<CMPXMediaArray>(pCommand, KMPXMediaArrayContents, array);
 
       
   479     mStubCollection->callHandleCommandComplete(pCommand, 0);
 
       
   480     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
       
   481     
       
   482     delete array;
 
       
   483     delete pCommand;
 
       
   484     
       
   485     // some items, one failed    
       
   486     array = mMediaFactory->newMediaArray();
 
       
   487     pCommand = mMediaFactory->newMedia();
 
       
   488     mMediaFactory->putTValue<int>(pCommand, KVcxMediaMyVideosCommandId, value );
 
       
   489     media1 = mMediaFactory->newMedia(1,0);
 
       
   490     value = 0;
 
       
   491     mMediaFactory->putTValue<int>(media1, KVcxMediaMyVideosInt32Value, value);
 
       
   492     media2 = mMediaFactory->newMedia(2,0);
 
       
   493     value = 1;
 
       
   494     mMediaFactory->putTValue<int>(media2, KVcxMediaMyVideosInt32Value, value);
 
       
   495     media3 = mMediaFactory->newMedia(3,0);
 
       
   496     TRAP_IGNORE(
 
       
   497             array->AppendL(media1);
 
       
   498             array->AppendL(media2);
 
       
   499             array->AppendL(media3););
 
       
   500     
       
   501     mMediaFactory->putValuePtr<CMPXMediaArray>(pCommand, KMPXMediaArrayContents, array);
 
       
   502     mStubCollection->callHandleCommandComplete(pCommand, 0);
 
       
   503     QVERIFY(mSignalReceiver->getLatestPointerAddr() != 0);
 
       
   504     QVERIFY(mSignalReceiver->getLatestListData().count() == 1);
 
       
   505     QVERIFY(mSignalReceiver->getLatestListData().at(0) == TMPXItemId(2,0));
 
       
   506     mSignalReceiver->resetLatestItems();
 
       
   507     delete array;
 
       
   508     delete pCommand;
 
   364     
   509     
   365     int remHeap = User::Heap().__DbgMarkEnd(0);
 
   510     int remHeap = User::Heap().__DbgMarkEnd(0);
 
   366     QVERIFY(remHeap == 0);   
   511     QVERIFY(remHeap == 0);   
   367 }
 
   512 }
 
   368 
   513 
   803     QVERIFY(mSignalReceiver->getLatestListData().count() == 0);
 
   948     QVERIFY(mSignalReceiver->getLatestListData().count() == 0);
 
   804     
   949     
   805     delete array;
 
   950     delete array;
 
   806     array = mMediaFactory->newMediaArray();
 
   951     array = mMediaFactory->newMediaArray();
 
   807     mMediaFactory->putValuePtr<CMPXMediaArray>( message, KMPXMediaArrayContents, array);
 
   952     mMediaFactory->putValuePtr<CMPXMediaArray>( message, KMPXMediaArrayContents, array);
 
       
   953     
       
   954     // item(s) does contain KVcxMediaMyVideosInt32Value + one invalid item (== no id) before of that
 
       
   955     mSignalReceiver->resetLatestItems();
 
       
   956     CMPXMedia *media = 0;
 
       
   957     TRAP_IGNORE(media = CMPXMedia::NewL());
 
       
   958     mMediaFactory->putArrayContent( array, mMediaFactory->newMedia(1));
 
       
   959     mMediaFactory->putArrayContent( array, media);
 
       
   960     media = mMediaFactory->newMedia(3); 
       
   961     value = 1;
 
       
   962     mMediaFactory->putTValue<int>( media, KVcxMediaMyVideosInt32Value, value);
 
       
   963     mMediaFactory->putArrayContent( array, media);  
       
   964     mMediaFactory->putValuePtr<CMPXMediaArray>( message, KMPXMessageArrayContents, array);
 
       
   965     mStubCollection->callHandleCollectionMessage(message, 0);
 
       
   966     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId()); 
       
   967     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
       
   968     QVERIFY(mSignalReceiver->getLatestIntegerData() == -1);
 
       
   969     QVERIFY(mSignalReceiver->getLatestListData().count() == 0);
 
       
   970     
       
   971     delete array;
 
       
   972     array = mMediaFactory->newMediaArray();
 
       
   973     mMediaFactory->putValuePtr<CMPXMediaArray>( message, KMPXMediaArrayContents, array);
 
   808    
   974    
   809     // item(s) containing KVcxMediaMyVideosInt32Value -values, both incorrect (1) and correct (3)
 
   975     // item(s) containing KVcxMediaMyVideosInt32Value -values, both incorrect (1) and correct (3)
 
   810     CMPXMedia *media = 0;
 
   976     
   811     mMediaFactory->putArrayContent( array, mMediaFactory->newMedia(1));
 
   977     mMediaFactory->putArrayContent( array, mMediaFactory->newMedia(1));
 
   812     
   978     
   813     media = mMediaFactory->newMedia(2);
 
   979     media = mMediaFactory->newMedia(2);
 
   814     value = 1;
 
   980     value = 1;
 
   815     mMediaFactory->putTValue<int>( media, KVcxMediaMyVideosInt32Value, value);
 
   981     mMediaFactory->putTValue<int>( media, KVcxMediaMyVideosInt32Value, value);
 
   867     
  1033     
   868     // NOTE: 
  1034     // NOTE: 
   869     // - we're testing only for KMPXMessageGeneral only once, because handleGeneralMPXMessage is already verified
 
  1035     // - we're testing only for KMPXMessageGeneral only once, because handleGeneralMPXMessage is already verified
 
   870     mStubCollection->callHandleCollectionMessage(message, 0);
 
  1036     mStubCollection->callHandleCollectionMessage(message, 0);
 
   871     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());
 
  1037     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());
 
       
  1038     QVERIFY(mSignalReceiver->getLatestModifiedItemId() == TMPXItemId::InvalidId());
 
   872     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
  1039     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
   873     
  1040     
   874     // invalid
 
  1041     // invalid
 
   875     msgId = KMPXMessageIdItemChanged + 1;
 
  1042     msgId = KMPXMessageIdItemChanged + 1;
 
   876     mStubCollection->callHandleCollectionMessage(message, 0);
 
  1043     mStubCollection->callHandleCollectionMessage(message, 0);
 
   877     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());
 
  1044     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());
 
       
  1045     QVERIFY(mSignalReceiver->getLatestModifiedItemId() == TMPXItemId::InvalidId());
 
   878     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
  1046     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
   879     
  1047     
   880     // KMPXMessageIdItemChanged with no content 
  1048     // KMPXMessageIdItemChanged with no content 
   881     mStubCollectionClient->setCollectionLevel(VideoCollectionCommon::ELevelVideos);
 
  1049     mStubCollectionClient->setCollectionLevel(VideoCollectionCommon::ELevelVideos);
 
   882     msgId = KMPXMessageIdItemChanged;
 
  1050     msgId = KMPXMessageIdItemChanged;
 
   883     mMediaFactory->putTValue<TMPXMessageId>(message, KMPXMessageGeneralId, msgId);
 
  1051     mMediaFactory->putTValue<TMPXMessageId>(message, KMPXMessageGeneralId, msgId);
 
   884     mStubCollection->callHandleCollectionMessage(message, 0);
 
  1052     mStubCollection->callHandleCollectionMessage(message, 0);
 
   885     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());
 
  1053     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());
 
       
  1054     QVERIFY(mSignalReceiver->getLatestModifiedItemId() == TMPXItemId::InvalidId());
 
   886     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
  1055     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
   887     
  1056     
   888     // KMPXMessageIdItemChanged with level != CVideoCollectionClient::ELevelVideos
 
  1057     // KMPXMessageIdItemChanged with level != CVideoCollectionClient::ELevelVideos
 
   889     mStubCollectionClient->setCollectionLevel(VideoCollectionCommon::ELevelVideos - 1);
 
  1058     mStubCollectionClient->setCollectionLevel(VideoCollectionCommon::ELevelVideos - 1);
 
   890     mStubCollection->callHandleCollectionMessage(message, 0);
 
  1059     mStubCollection->callHandleCollectionMessage(message, 0);
 
   891     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());
 
  1060     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());
 
       
  1061     QVERIFY(mSignalReceiver->getLatestModifiedItemId() == TMPXItemId::InvalidId());
 
   892     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
  1062     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
   893              
  1063              
   894     // KMPXMessageIdItemChanged with EMPXItemModified event type, no id
 
  1064     // KMPXMessageIdItemChanged with EMPXItemModified event type, no id
 
   895     mStubCollectionClient->setCollectionLevel(VideoCollectionCommon::ELevelVideos);
 
  1065     mStubCollectionClient->setCollectionLevel(VideoCollectionCommon::ELevelVideos);
 
   896     TMPXChangeEventType eventType = EMPXItemModified;
 
  1066     TMPXChangeEventType eventType = EMPXItemModified;
 
   897     mMediaFactory->putTValue<TMPXChangeEventType>(message, KMPXMessageChangeEventType, eventType);   
  1067     mMediaFactory->putTValue<TMPXChangeEventType>(message, KMPXMessageChangeEventType, eventType);   
   898     mStubCollection->callHandleCollectionMessage(message, 0);
 
  1068     mStubCollection->callHandleCollectionMessage(message, 0);
 
   899     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());
 
  1069     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());
 
       
  1070     QVERIFY(mSignalReceiver->getLatestModifiedItemId() == TMPXItemId::InvalidId());
 
   900     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
  1071     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
   901     
  1072     
   902     // KMPXMessageIdItemChanged with existing with EMPXItemModified event type, iId2 != album
 
  1073     // KMPXMessageIdItemChanged with existing with EMPXItemModified event type, iId2 != album
 
   903     TMPXItemId eventId;
 
  1074     TMPXItemId eventId;
 
   904     eventId.iId1 = 1;
 
  1075     eventId.iId1 = 1;
 
   905     eventId.iId2 = 0;
 
  1076     eventId.iId2 = 0;
 
   906     mMediaFactory->putTValue<TMPXItemId>(message, KMPXMessageMediaGeneralId, eventId);
 
  1077     mMediaFactory->putTValue<TMPXItemId>(message, KMPXMessageMediaGeneralId, eventId);
 
   907     mStubCollection->callHandleCollectionMessage(message, 0);
 
  1078     mStubCollection->callHandleCollectionMessage(message, 0);
 
   908     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());
 
  1079     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());
 
   909     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
  1080     QVERIFY(mSignalReceiver->getLatestModifiedItemId() == eventId);
 
   910     
  1081     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
       
  1082 
   911     // KMPXMessageIdItemChanged with existing with EMPXItemModified event type iId2 == album, not same as opened
 
  1083     // KMPXMessageIdItemChanged with existing with EMPXItemModified event type iId2 == album, not same as opened
 
   912     eventId.iId1 = 1;
 
  1084     eventId.iId1 = 1;
 
   913     eventId.iId2 = 2;
 
  1085     eventId.iId2 = 2;
 
   914     mMediaFactory->putTValue<TMPXItemId>(message, KMPXMessageMediaGeneralId, eventId);
 
  1086     mMediaFactory->putTValue<TMPXItemId>(message, KMPXMessageMediaGeneralId, eventId);
 
   915     mStubCollection->callHandleCollectionMessage(message, 0);
 
  1087     mStubCollection->callHandleCollectionMessage(message, 0);
 
   916     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());
 
  1088     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());
 
       
  1089     QVERIFY(mSignalReceiver->getLatestModifiedItemId() == eventId);
 
       
  1090     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
       
  1091     
       
  1092     // KMPXMessageIdItemChanged with existing with EMPXItemModified event type iId2 == category, not same as opened
 
       
  1093     eventId.iId1 = 1;
 
       
  1094     eventId.iId2 = 1;
 
       
  1095     mMediaFactory->putTValue<TMPXItemId>(message, KMPXMessageMediaGeneralId, eventId);
 
       
  1096     mStubCollection->callHandleCollectionMessage(message, 0);
 
       
  1097     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());
 
       
  1098     QVERIFY(mSignalReceiver->getLatestModifiedItemId() == eventId);
 
   917     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
  1099     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
   918     
  1100     
   919     // KMPXMessageIdItemChanged with existing with EMPXItemModified event type iId2 == album, same as opened
 
  1101     // KMPXMessageIdItemChanged with existing with EMPXItemModified event type iId2 == album, same as opened
 
   920     eventId.iId1 = 1;
 
  1102     eventId.iId1 = 2;
 
   921     eventId.iId2 = 2;
 
  1103     eventId.iId2 = 2;
 
   922     int callCount = mStubCollectionClient->mOpenItemCallCount;    
  1104     int callCount = mStubCollectionClient->mOpenItemCallCount;    
   923     mStubCollectionClient->openItem(eventId);
 
  1105     mStubCollectionClient->openItem(eventId);
 
   924     QVERIFY(mStubCollectionClient->mOpenItemCallCount == callCount + 1);
 
  1106     QVERIFY(mStubCollectionClient->mOpenItemCallCount == callCount + 1);
 
   925     mMediaFactory->putTValue<TMPXItemId>(message, KMPXMessageMediaGeneralId, eventId);
 
  1107     mMediaFactory->putTValue<TMPXItemId>(message, KMPXMessageMediaGeneralId, eventId);
 
   926     mStubCollection->callHandleCollectionMessage(message, 0);
 
  1108     mStubCollection->callHandleCollectionMessage(message, 0);
 
       
  1109     QVERIFY(mSignalReceiver->getLatestModifiedItemId() == eventId);
 
   927     QVERIFY(mStubCollectionClient->mOpenItemCallCount == callCount + 2);
 
  1110     QVERIFY(mStubCollectionClient->mOpenItemCallCount == callCount + 2);
 
   928     mSignalReceiver->resetLatestItems();
 
  1111     mSignalReceiver->resetLatestItems();
 
   929     
  1112     
   930     // KMPXMessageIdItemChanged with EMPXItemDeleted event type 
  1113     // KMPXMessageIdItemChanged with EMPXItemDeleted event type 
   931     eventType = EMPXItemDeleted;
 
  1114     eventType = EMPXItemDeleted;
 
   933     eventId.iId2 = 0;
 
  1116     eventId.iId2 = 0;
 
   934     mMediaFactory->putTValue<TMPXChangeEventType>(message, KMPXMessageChangeEventType, eventType);
 
  1117     mMediaFactory->putTValue<TMPXChangeEventType>(message, KMPXMessageChangeEventType, eventType);
 
   935     mMediaFactory->putTValue<TMPXItemId>(message, KMPXMessageMediaGeneralId, eventId);
 
  1118     mMediaFactory->putTValue<TMPXItemId>(message, KMPXMessageMediaGeneralId, eventId);
 
   936     mStubCollection->callHandleCollectionMessage(message, 0);
 
  1119     mStubCollection->callHandleCollectionMessage(message, 0);
 
   937     QVERIFY(mSignalReceiver->getLatestItemId().iId1 == 10);
 
  1120     QVERIFY(mSignalReceiver->getLatestItemId().iId1 == 10);
 
       
  1121     QVERIFY(mSignalReceiver->getLatestModifiedItemId() == TMPXItemId::InvalidId());
 
   938     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
  1122     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
   939     
  1123     
   940     mSignalReceiver->resetLatestItems();
 
  1124     mSignalReceiver->resetLatestItems();
 
   941     
  1125     
   942     // KMPXMessageIdItemChanged with EMPXItemInserted event type with id2 differrent than videos
 
  1126     // KMPXMessageIdItemChanged with EMPXItemInserted event type with id2 differrent than videos
 
   944     eventId.iId2 = 2;
 
  1128     eventId.iId2 = 2;
 
   945     mMediaFactory->putTValue<TMPXItemId>(message, KMPXMessageMediaGeneralId, eventId);
 
  1129     mMediaFactory->putTValue<TMPXItemId>(message, KMPXMessageMediaGeneralId, eventId);
 
   946     mMediaFactory->putTValue<TMPXChangeEventType>(message, KMPXMessageChangeEventType, eventType);
 
  1130     mMediaFactory->putTValue<TMPXChangeEventType>(message, KMPXMessageChangeEventType, eventType);
 
   947     mStubCollection->callHandleCollectionMessage(message, 0);
 
  1131     mStubCollection->callHandleCollectionMessage(message, 0);
 
   948     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());
 
  1132     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());
 
       
  1133     QVERIFY(mSignalReceiver->getLatestModifiedItemId() == TMPXItemId::InvalidId());
 
   949     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
  1134     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
   950     // mpx id should have not changed into 10
 
  1135     // mpx id should have not changed into 10
 
   951     QVERIFY(mStubCollectionClient->getLatestMPXId() == eventId);
 
  1136     QVERIFY(mStubCollectionClient->getLatestMPXId() == eventId);
 
   952     
  1137     
   953     // KMPXMessageIdItemChanged with EMPXItemInserted event type with correct id2 no media object
 
  1138     // KMPXMessageIdItemChanged with EMPXItemInserted event type with correct id2 no media object
 
   954     eventId.iId2 = 1;
 
  1139     eventId.iId2 = 1;
 
   955     mMediaFactory->putTValue<TMPXItemId>(message, KMPXMessageMediaGeneralId, eventId);
 
  1140     mMediaFactory->putTValue<TMPXItemId>(message, KMPXMessageMediaGeneralId, eventId);
 
   956     mStubCollection->callHandleCollectionMessage(message, 0);
 
  1141     mStubCollection->callHandleCollectionMessage(message, 0);
 
   957     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());
 
  1142     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());
 
       
  1143     QVERIFY(mSignalReceiver->getLatestModifiedItemId() == TMPXItemId::InvalidId());
 
   958     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
  1144     QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);
 
   959     QVERIFY(mStubCollectionClient->getLatestMPXId() == eventId);
 
  1145     QVERIFY(mStubCollectionClient->getLatestMPXId() == eventId);
 
   960     
  1146     
   961  
  1147  
   962     // KMPXMessageIdItemChanged with EMPXItemInserted event type with correct id2 with media object
 
  1148     // KMPXMessageIdItemChanged with EMPXItemInserted event type with correct id2 with media object
 
   963     CMPXMedia *media = mMediaFactory->newMedia(11);
 
  1149     CMPXMedia *media = mMediaFactory->newMedia(11);
 
   964     mMediaFactory->putValuePtr<CMPXMedia>(message, KMPXCommandColAddMedia, media);
 
  1150     mMediaFactory->putValuePtr<CMPXMedia>(message, KMPXCommandColAddMedia, media);
 
   965     mStubCollection->callHandleCollectionMessage(message, 0);
 
  1151     mStubCollection->callHandleCollectionMessage(message, 0);
 
   966     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());
 
  1152     QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());
 
       
  1153     QVERIFY(mSignalReceiver->getLatestModifiedItemId() == TMPXItemId::InvalidId());
 
   967     QVERIFY(mSignalReceiver->getLatestPointerAddr() != 0);
 
  1154     QVERIFY(mSignalReceiver->getLatestPointerAddr() != 0);
 
   968     CMPXMedia *gotten = static_cast<CMPXMedia*>(mSignalReceiver->getLatestPointerAddr());
 
  1155     CMPXMedia *gotten = static_cast<CMPXMedia*>(mSignalReceiver->getLatestPointerAddr());
 
   969     int fetchedId = -1;
 
  1156     int fetchedId = -1;
 
   970     VideoCollectionUtils::instance().mediaValue<int>(gotten, KMPXMediaGeneralId, fetchedId );
 
  1157     VideoCollectionUtils::instance().mediaValue<int>(gotten, KMPXMediaGeneralId, fetchedId );
 
   971     QVERIFY(fetchedId == 11);
 
  1158     QVERIFY(fetchedId == 11);
FCL/sf/app/videoplayer