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);