--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/videocollection/videocollectionwrapper/tsrc/testvideocollectionlistener/src/testvideocollectionlistener.cpp Thu Apr 01 22:38:49 2010 +0300
@@ -0,0 +1,1085 @@
+
+/**
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: tester for methods in CVideoCollectionListener
+*
+*/
+
+
+// INCLUDES
+#include <e32cmn.h>
+#include <mpxmediacontainerdefs.h>
+#include <mpxmediageneraldefs.h>
+#include <mpxmessagecontainerdefs.h>
+#include <mpxmessagegeneraldefs.h>
+#include <mpxcollectioncommanddefs.h>
+#include <mpxcollectionmessage.h>
+#include <vcxmyvideosdefs.h>
+#include <vcxmyvideosuids.h>
+#include "testvideocollectionlistener.h"
+#include "mediaobjectfactory.h"
+#include "stub/inc/stubsignalreceiver.h"
+#include "stub/inc/stubcollection.h"
+
+#include "videocollectionutils.h"
+
+#define private public
+#include "videocollectionlistener.h"
+#undef private
+
+
+// -----------------------------------------------------------------------------
+// main
+// -----------------------------------------------------------------------------
+//
+int main(int argc, char *argv[])
+{
+ TestVideoCollectionListener tv;
+
+ char *pass[3];
+ pass[0] = argv[0];
+ pass[1] = "-o";
+ pass[2] = "c:\\data\\testvideocollectionlistener.txt";
+
+ int res = QTest::qExec(&tv, 3, pass);
+
+ return res;
+}
+
+// -----------------------------------------------------------------------------
+// initTestCase
+// -----------------------------------------------------------------------------
+//
+void TestVideoCollectionListener::initTestCase()
+{
+ mMediaFactory = new MediaObjectFactory();
+}
+
+// -----------------------------------------------------------------------------
+// init
+// -----------------------------------------------------------------------------
+//
+void TestVideoCollectionListener::init()
+{
+ mStubCollectionClient = new VideoCollectionClient();
+
+ mTestObject = new VideoCollectionListener(*mStubCollectionClient);
+
+ mStubCollection = new StubCollection(*mTestObject);
+
+ qRegisterMetaType<CMPXMediaArray*>("CMPXMediaArray*");
+ mSpyNewVideoList = new QSignalSpy(mTestObject, SIGNAL(newVideoList(CMPXMediaArray*)));
+
+ mSpyVideoListAppended = new QSignalSpy(mTestObject, SIGNAL(videoListAppended(CMPXMediaArray*)));
+
+ qRegisterMetaType<CMPXMedia*>("CMPXMedia*");
+ mSpyNewVideoAvailable = new QSignalSpy(mTestObject, SIGNAL(newVideoAvailable(CMPXMedia*)));
+
+ qRegisterMetaType<TMPXItemId>("TMPXItemId");
+
+ mSpyVideoDeleted = new QSignalSpy(mTestObject, SIGNAL(videoDeleted(TMPXItemId)));
+
+ qRegisterMetaType<QList<TMPXItemId>*>("QList<TMPXItemId>*");
+ mSpyVideoDeleteCompleted = new QSignalSpy(mTestObject, SIGNAL(videoDeleteCompleted(int, QList<TMPXItemId>*)));
+
+ mSpyVideoDetailsCompleted = new QSignalSpy(mTestObject, SIGNAL(videoDetailsCompleted(TMPXItemId)));
+}
+
+// -----------------------------------------------------------------------------
+// cleanup
+// -----------------------------------------------------------------------------
+//
+void TestVideoCollectionListener::cleanup()
+{
+ delete mTestObject;
+ mTestObject = 0;
+
+ delete mStubCollectionClient;
+ mStubCollectionClient = 0;
+
+ delete mStubCollection;
+ mStubCollection = 0;
+
+ delete mSpyNewVideoList;
+ mSpyNewVideoList = 0;
+
+ delete mSpyVideoListAppended;
+ mSpyVideoListAppended = 0;
+
+ delete mSpyNewVideoAvailable;
+ mSpyNewVideoAvailable = 0;
+
+ delete mSpyVideoDeleted;
+ mSpyVideoDeleted = 0;
+
+ delete mSpyVideoDeleteCompleted;
+ mSpyVideoDeleteCompleted = 0;
+
+ delete mSpyVideoDetailsCompleted;
+ mSpyVideoDetailsCompleted = 0;
+}
+
+// -----------------------------------------------------------------------------
+// cleanupTestCase
+// -----------------------------------------------------------------------------
+//
+void TestVideoCollectionListener::cleanupTestCase()
+{
+ delete mMediaFactory;
+}
+
+// -----------------------------------------------------------------------------
+// testHandleCollectionMediaL
+// -----------------------------------------------------------------------------
+//
+void TestVideoCollectionListener::testHandleCollectionMediaLFunc()
+{
+ StubSignalReceiver receiver;
+ QVERIFY(connectSignals(&receiver));
+ // nothing to test here, because
+ // currently HandleCollectionMediaL is empty implementation required
+ // by the inheritance of MMPXCollectionObserver.
+ User::Heap().__DbgMarkStart();
+
+ CMPXMedia *media = NULL;
+ TRAP_IGNORE(media = CMPXMedia::NewL());
+ mStubCollection->callHandleCollectionMediaLFunc(*media, 0);
+ delete media;
+
+ QVERIFY(!hasSignalsEmitted());
+ QVERIFY(receiver.getLatestItemId() == TMPXItemId::InvalidId());
+ QVERIFY(receiver.getLatestPointerAddr() == 0);
+
+ int remHeap = User::Heap().__DbgMarkEnd(0);
+ QVERIFY(remHeap == 0);
+}
+
+// -----------------------------------------------------------------------------
+// testHandleOpenLMediaFunc
+// -----------------------------------------------------------------------------
+//
+void TestVideoCollectionListener::testHandleOpenLMediaFunc()
+{
+ StubSignalReceiver receiver;
+ QVERIFY(connectSignals(&receiver));
+
+ User::Heap().__DbgMarkStart();
+
+ mStubCollectionClient->setCollectionLevel(VideoCollectionClient::ELevelVideos);
+ CMPXMedia *media = mMediaFactory->newMedia(0);
+
+ // error != KErrNone
+ mStubCollection->callHandleOpenLFunc(*media, 0, true, -2 );
+ QVERIFY(receiver.getLatestPointerAddr() == 0);
+ QVERIFY(mSpyNewVideoList->count() == 0);
+ QVERIFY(mSpyVideoListAppended->count() == 0);
+
+ // collectionLevel != LevelVideos
+ mStubCollectionClient->setCollectionLevel(-100);
+ mStubCollection->callHandleOpenLFunc(*media, 0, true, 0 );
+
+ QVERIFY(receiver.getLatestPointerAddr() == 0);
+ QVERIFY(mSpyNewVideoList->count() == 0);
+ QVERIFY(mSpyVideoListAppended->count() == 0);
+ mStubCollectionClient->setCollectionLevel(VideoCollectionClient::ELevelVideos);
+
+ // empty media (== media does not contain array)
+ mStubCollection->callHandleOpenLFunc(*media, 0, true, 0 );
+ QVERIFY(receiver.getLatestPointerAddr() == 0);
+ QVERIFY(mSpyNewVideoList->count() == 0);
+ QVERIFY(mSpyVideoListAppended->count() == 0);
+
+ // signal emitting: correct media-array passed
+ CMPXMediaArray *array = mMediaFactory->newMediaArray();
+
+ // empty array
+ mMediaFactory->putValuePtr<CMPXMediaArray>(media, KMPXMediaArrayContents, array);
+ mStubCollection->callHandleOpenLFunc(*media, 0, true, 0 );
+ QVERIFY(receiver.getLatestPointerAddr() != 0);
+ QVERIFY(mSpyNewVideoList->count() == 1);
+ QVERIFY(mSpyVideoListAppended->count() == 0);
+
+ // item for invalid level, no new signals emitted
+ mStubCollectionClient->setCollectionLevel(VideoCollectionClient::ELevelCategory);
+ mMediaFactory->putArrayContent(array, mMediaFactory->newMedia(1, 2));
+ mStubCollection->callHandleOpenLFunc(*media, 0, true, 0 );
+ QVERIFY(receiver.getLatestPointerAddr() != 0);
+ QVERIFY(mSpyNewVideoList->count() == 1);
+ QVERIFY(mSpyVideoListAppended->count() == 0);
+
+ mStubCollectionClient->setCollectionLevel(VideoCollectionClient::ELevelVideos);
+ delete array;
+ array = mMediaFactory->newMediaArray();
+ mMediaFactory->putArrayContent(array, mMediaFactory->newMedia(1));
+ mMediaFactory->putArrayContent(array, mMediaFactory->newMedia(2));
+ mMediaFactory->putArrayContent(array, mMediaFactory->newMedia(3));
+
+ mMediaFactory->putValuePtr<CMPXMediaArray>(media, KMPXMediaArrayContents, array);
+ mTestObject->setRequestNewMediaArray(true);
+ mStubCollection->callHandleOpenLFunc(*media, 0, true, 0 );
+
+ QVERIFY(receiver.getLatestPointerAddr() != 0);
+ QVERIFY(mSpyNewVideoList->count() == 2);
+ QVERIFY(mSpyVideoListAppended->count() == 0);
+
+ mStubCollection->callHandleOpenLFunc(*media, 0, true, 0 );
+
+ QVERIFY(receiver.getLatestPointerAddr() != 0);
+ QVERIFY(mSpyNewVideoList->count() == 2);
+ QVERIFY(mSpyVideoListAppended->count() == 1);
+
+
+ CMPXMediaArray *gottenArray = static_cast<CMPXMediaArray*>(receiver.getLatestPointerAddr());
+ QVERIFY(gottenArray->Count() == 3);
+
+ TMPXItemId mediaId = TMPXItemId::InvalidId();
+ VideoCollectionUtils::instance().mediaValue<TMPXItemId>((*gottenArray)[0], KMPXMediaGeneralId, mediaId );
+ QVERIFY(mediaId.iId1 == 1);
+ VideoCollectionUtils::instance().mediaValue<TMPXItemId>((*gottenArray)[1], KMPXMediaGeneralId, mediaId );
+ QVERIFY(mediaId.iId1 == 2);
+ VideoCollectionUtils::instance().mediaValue<TMPXItemId>((*gottenArray)[2], KMPXMediaGeneralId, mediaId );
+ QVERIFY(mediaId.iId1 == 3);
+
+ delete array;
+ delete media;
+ mSpyNewVideoList->clear();
+ mSpyVideoListAppended->clear();
+ QVERIFY(!hasSignalsEmitted());
+ QVERIFY(receiver.getLatestItemId() == TMPXItemId::InvalidId());
+
+ int remHeap = User::Heap().__DbgMarkEnd(0);
+ QVERIFY(remHeap == 0);
+}
+
+// -----------------------------------------------------------------------------
+// testHandleOpenLPlaylistFunc
+// -----------------------------------------------------------------------------
+//
+void TestVideoCollectionListener::testHandleOpenLPlaylistFunc()
+{
+ StubSignalReceiver receiver;
+ QVERIFY(connectSignals(&receiver));
+
+ // nothing to test here, because
+ // currently HandleCollectionMediaL is empty implementation required
+ // by the inheritance of MMPXCollectionObserver.
+ User::Heap().__DbgMarkStart();
+ CMPXCollectionPlaylist *plList = 0;
+
+ mStubCollection->callHandleOpenLFunc(*plList, 0);
+
+ QVERIFY(!hasSignalsEmitted());
+ QVERIFY(receiver.getLatestItemId() == TMPXItemId::InvalidId());
+ QVERIFY(receiver.getLatestPointerAddr() == 0);
+
+ int remHeap = User::Heap().__DbgMarkEnd(0);
+ QVERIFY(remHeap == 0);
+}
+
+// -----------------------------------------------------------------------------
+// testHandleCommandComplete
+// -----------------------------------------------------------------------------
+//
+void TestVideoCollectionListener::testHandleCommandComplete()
+{
+ StubSignalReceiver receiver;
+ QVERIFY(connectSignals(&receiver));
+
+ User::Heap().__DbgMarkStart();
+
+ CMPXCommand *pCommand = mMediaFactory->newMedia(0);
+
+ // error != KErrNone
+ mStubCollection->callHandleCommandComplete(pCommand, -2);
+ QVERIFY(receiver.getLatestItemId() == TMPXItemId::InvalidId());
+ QVERIFY(mSpyVideoDetailsCompleted->count() == 0);
+
+ // command == NULL
+ mStubCollection->callHandleCommandComplete(0, 0);
+ QVERIFY(receiver.getLatestItemId() == TMPXItemId::InvalidId());
+ QVERIFY(mSpyVideoDetailsCompleted->count() == 0);
+
+ // null command + error != KErrNone
+ mStubCollection->callHandleCommandComplete(0, -2);
+ QVERIFY(receiver.getLatestItemId() == TMPXItemId::InvalidId());
+ QVERIFY(mSpyVideoDetailsCompleted->count() == 0);
+
+ // command without id
+ delete pCommand;
+ pCommand = mMediaFactory->newMedia();
+ mStubCollection->callHandleCommandComplete(pCommand, 0);
+ QVERIFY(receiver.getLatestItemId() == TMPXItemId::InvalidId());
+ QVERIFY(mSpyVideoDetailsCompleted->count() == 0);
+
+ // no command attribute
+ delete pCommand;
+ pCommand = mMediaFactory->newMedia(0);
+ mStubCollection->callHandleCommandComplete(pCommand, 0);
+ QVERIFY(receiver.getLatestItemId() == TMPXItemId::InvalidId());
+ QVERIFY(mSpyVideoDetailsCompleted->count() == 0);
+
+ // invalid KVcxMediaMyVideosCommandId
+ int value = (KVcxCommandMyVideosGetMediaFullDetailsByMpxId + 10);
+ mMediaFactory->putTValue<int>(pCommand, KVcxMediaMyVideosCommandId, value );
+ mStubCollection->callHandleCommandComplete(pCommand, 0);
+ QVERIFY(receiver.getLatestItemId() == TMPXItemId::InvalidId());
+ QVERIFY(mSpyVideoDetailsCompleted->count() == 0);
+
+ // no media object in command
+ value = KVcxCommandMyVideosGetMediaFullDetailsByMpxId;
+ mMediaFactory->putTValue<int>(pCommand, KVcxMediaMyVideosCommandId, value );
+ mStubCollection->callHandleCommandComplete(pCommand, 0);
+ QVERIFY(receiver.getLatestItemId() == TMPXItemId::InvalidId());
+ QVERIFY(mSpyVideoDetailsCompleted->count() == 0);
+
+ // NOTE! we cannot test with item without KMPXMediaGeneralId, because after creation CMPXMedia
+ // always contain default value
+
+ // correct item
+ CMPXMedia *subMedia = mMediaFactory->newMedia(10);
+ mMediaFactory->putValuePtr<CMPXMedia>(pCommand, KMPXCommandColAddMedia, subMedia);
+ mStubCollection->callHandleCommandComplete(pCommand, 0);
+ QVERIFY(receiver.getLatestItemId().iId1 == 10);
+ QVERIFY(mSpyVideoDetailsCompleted->count() == 1);
+ delete subMedia;
+ delete pCommand;
+ mSpyVideoDetailsCompleted->clear();
+
+ QVERIFY(!hasSignalsEmitted());
+ QVERIFY(receiver.getLatestPointerAddr() == 0);
+
+ int remHeap = User::Heap().__DbgMarkEnd(0);
+ QVERIFY(remHeap == 0);
+}
+
+// -----------------------------------------------------------------------------
+// testCollectionMessageError
+// -----------------------------------------------------------------------------
+//
+void TestVideoCollectionListener::testCollectionMessageError()
+{
+ StubSignalReceiver receiver;
+ QVERIFY(connectSignals(&receiver));
+
+ User::Heap().__DbgMarkStart();
+
+ CMPXMessage *message = mMediaFactory->newMedia(0);
+
+ // correct message, error != KErrNone
+ mStubCollection->callHandleCollectionMessage(message, -1);
+ QVERIFY(mStubCollectionClient->getOpenStatus() == -1);
+
+ // message does not contain KMPXMessageGeneralId
+ mStubCollection->callHandleCollectionMessage(message, 0);
+ QVERIFY(mStubCollectionClient->getOpenStatus() == -1);
+
+ delete message;
+
+ // empty message
+ mStubCollection->callHandleCollectionMessage(0, 0);
+ QVERIFY(mStubCollectionClient->getOpenStatus() == -1);
+
+ // none of above calls should not cause any signal emitting
+ QVERIFY(!hasSignalsEmitted());
+ QVERIFY(receiver.getLatestItemId() == TMPXItemId::InvalidId());
+ QVERIFY(receiver.getLatestPointerAddr() == 0);
+ QVERIFY(receiver.getLatestIntegerData() == -1);
+
+ int remHeap = User::Heap().__DbgMarkEnd(0);
+ QVERIFY(remHeap == 0);
+}
+
+// -----------------------------------------------------------------------------
+// testCollectionMessageNotOpened
+// -----------------------------------------------------------------------------
+//
+void TestVideoCollectionListener::testCollectionMessageNotOpened()
+{
+ StubSignalReceiver receiver;
+ QVERIFY(connectSignals(&receiver));
+
+ User::Heap().__DbgMarkStart();
+ mStubCollectionClient->setOpenStatus( VideoCollectionClient::ECollectionOpening);
+
+ // collection not opened, empty message
+ mStubCollection->callHandleCollectionMessage(0, 0);
+ QVERIFY(mStubCollectionClient->getOpenStatus() == VideoCollectionClient::ECollectionOpening);
+
+ // collection not opened, no msg id
+ CMPXMessage *message = mMediaFactory->newMedia(0);
+ mStubCollection->callHandleCollectionMessage(message, 0);
+ QVERIFY(mStubCollectionClient->getOpenStatus() == VideoCollectionClient::ECollectionOpening);
+
+ TMPXMessageId msgId = 1;
+ mMediaFactory->putTValue<TMPXMessageId>(message, KMPXMessageGeneralId, msgId);
+
+ // collection not opened, invalid msg id
+ mStubCollection->callHandleCollectionMessage(message, 0);
+ QVERIFY(mStubCollectionClient->getOpenStatus() == VideoCollectionClient::ECollectionOpening);
+
+ msgId = KMPXMessageGeneral;
+ mMediaFactory->putTValue<TMPXMessageId>(message, KMPXMessageGeneralId, msgId);
+
+ // collection not opened, correct msg id, missing all details
+ mStubCollection->callHandleCollectionMessage(message, 0);
+ QVERIFY(mStubCollectionClient->getOpenStatus() == VideoCollectionClient::ECollectionOpening);
+
+ int value = -1;
+ mMediaFactory->putTValue<int>(message, KMPXMessageGeneralEvent, value);
+
+ // collection not opened, correct msg id, missing KMPXMessageGeneralData
+ mStubCollection->callHandleCollectionMessage(message, 0);
+ QVERIFY(mStubCollectionClient->getOpenStatus() == VideoCollectionClient::ECollectionOpening);
+
+ delete message;
+ message = mMediaFactory->newMedia(0);
+ mMediaFactory->putTValue<TMPXMessageId>(message, KMPXMessageGeneralId, msgId);
+ mMediaFactory->putTValue<int>(message, KMPXMessageGeneralData, value);
+
+ // collection not opened, correct msg id, missing KMPXMessageGeneralEvent
+ mStubCollection->callHandleCollectionMessage(message, 0);
+ QVERIFY(mStubCollectionClient->getOpenStatus() == VideoCollectionClient::ECollectionOpening);
+
+ mMediaFactory->putTValue<int>(message, KMPXMessageGeneralEvent, value);
+
+ // collection not opened, correct msg id, invalid detail values
+ mStubCollection->callHandleCollectionMessage(message, 0);
+ QVERIFY(mStubCollectionClient->getOpenStatus() == VideoCollectionClient::ECollectionOpening);
+
+ value = EMcContainerOpened;
+ mMediaFactory->putTValue<int>(message, KMPXMessageGeneralData, value);
+
+ // collection not opened, correct msg id, invalid KMPXMessageGeneralEvent value
+ mStubCollection->callHandleCollectionMessage(message, 0);
+ QVERIFY(mStubCollectionClient->getOpenStatus() == VideoCollectionClient::ECollectionOpening);
+
+ value = -1;
+ mMediaFactory->putTValue<int>(message, KMPXMessageGeneralData, value);
+ value = TMPXCollectionMessage::EPathChanged;
+ mMediaFactory->putTValue<int>(message, KMPXMessageGeneralEvent, value);
+
+ // collection not opened, correct msg id, invalid KMPXMessageGeneralData value
+ mStubCollection->callHandleCollectionMessage(message, 0);
+ QVERIFY(mStubCollectionClient->getOpenStatus() == VideoCollectionClient::ECollectionOpening);
+
+ value = EMcContainerOpened;
+ mMediaFactory->putTValue<int>(message, KMPXMessageGeneralData, value);
+ mStubCollectionClient->setOpenStatus(-1);
+ // correct message, open status != CVideoCollectionClient::ECollectionOpening
+ mStubCollection->callHandleCollectionMessage(message, 0);
+ QVERIFY(mStubCollectionClient->getOpenStatus() == -1);
+
+ mStubCollectionClient->setOpenStatus(VideoCollectionClient::ECollectionOpening);
+ // correct message, open status == CVideoCollectionClient::ECollectionOpening
+ mStubCollection->callHandleCollectionMessage(message, 0);
+ QVERIFY(mStubCollectionClient->getOpenStatus() == VideoCollectionClient::ECollectionOpened);
+
+ // none of above calls should not cause any signal emitting
+ QVERIFY(!hasSignalsEmitted());
+ QVERIFY(receiver.getLatestItemId() == TMPXItemId::InvalidId());
+ QVERIFY(receiver.getLatestPointerAddr() == 0);
+ QVERIFY(receiver.getLatestIntegerData() == -1);
+
+ delete message;
+
+ int remHeap = User::Heap().__DbgMarkEnd(0);
+ QVERIFY(remHeap == 0);
+}
+
+// -----------------------------------------------------------------------------
+// testCollectionMessageMyVidCommandId
+// -----------------------------------------------------------------------------
+//
+void TestVideoCollectionListener::testCollectionMessageMyVidCommandId()
+{
+ StubSignalReceiver receiver;
+ QVERIFY(connectSignals(&receiver));
+
+ User::Heap().__DbgMarkStart();
+
+ mStubCollectionClient->setOpenStatus(VideoCollectionClient::ECollectionOpened);
+ CMPXMessage *message = mMediaFactory->newMedia(0);
+ TMPXMessageId msgId = KVcxCommandIdMyVideos;
+ mMediaFactory->putTValue<TMPXMessageId>(message, KMPXMessageGeneralId, msgId);
+
+ // KMPXMessageCollectionId != KVcxUidMyVideosMpxCollection
+ mStubCollection->callHandleCollectionMessage(message, 0);
+
+ TUid uid = {KVcxUidMyVideosMpxCollection};
+ mMediaFactory->putTValue<TUid>(message, KMPXMessageCollectionId, uid);
+
+ // does not contain KVcxMediaMyVideosCommandId
+ mStubCollection->callHandleCollectionMessage(message, 0);
+
+ int value = KVcxMessageMyVideosMessageArray + 1;
+ mMediaFactory->putTValue<int>( message, KVcxMediaMyVideosCommandId, value);
+
+ // non KVcxMessageMyVideosMessageArray, invalid value
+ // (this is tested throughoutly in testCollectionMessageNonMyVidMsgArray)
+ mStubCollection->callHandleCollectionMessage(message, 0);
+
+ value = KVcxMessageMyVideosMessageArray;
+ mMediaFactory->putTValue<int>( message, KVcxMediaMyVideosCommandId, value);
+ CMPXMediaArray *nullArray = 0;
+ mMediaFactory->putValuePtr<CMPXMediaArray>(message, KMPXMediaArrayContents, nullArray);
+ // KVcxMessageMyVideosMessageArray, but no contents.
+ // (this is tested throughoutly in testCollectionMessageMyVidMsgArray)
+ mStubCollection->callHandleCollectionMessage(message, 0);
+ delete message;
+
+ // none of above calls should not cause any signal emitting
+ QVERIFY(!hasSignalsEmitted());
+ QVERIFY(receiver.getLatestItemId() == TMPXItemId::InvalidId());
+ QVERIFY(receiver.getLatestPointerAddr() == 0);
+ QVERIFY(receiver.getLatestIntegerData() == -1);
+
+ int remHeap = User::Heap().__DbgMarkEnd(0);
+ QVERIFY(remHeap == 0);
+
+}
+
+// -----------------------------------------------------------------------------
+// testHandleMyVideosMessageArray
+// -----------------------------------------------------------------------------
+//
+void TestVideoCollectionListener::testHandleMyVideosMessageArray()
+{
+ StubSignalReceiver receiver;
+ QVERIFY(connectSignals(&receiver));
+
+ User::Heap().__DbgMarkStart();
+
+ mStubCollectionClient->setOpenStatus(VideoCollectionClient::ECollectionOpened);
+ CMPXMessage *message = mMediaFactory->newMedia(0);
+ TMPXMessageId msgId = KVcxCommandIdMyVideos;
+ mMediaFactory->putTValue<TMPXMessageId>(message, KMPXMessageGeneralId, msgId);
+ TUid uid = {KVcxUidMyVideosMpxCollection};
+ mMediaFactory->putTValue<TUid>(message, KMPXMessageCollectionId, uid);
+ int value = KVcxMessageMyVideosMessageArray;
+ mMediaFactory->putTValue<int>( message, KVcxMediaMyVideosCommandId, value);
+
+ // no message array
+ mStubCollection->callHandleCollectionMessage(message, 0);
+
+ // CMPXMedia *subMedia = mMediaFactory->newMedia(0);
+ // mMediaFactory->putValuePtr<CMPXMedia>( message, KMPXMessageArrayContents, subMedia);
+ //////////////////
+ // NOTE
+ // We cannot test case where message containsCMPXMedia instead of CMPXMessageArray.
+ // collection fw does not support type check of pointers. Whatever pointer we have it is supported as long as
+ // it is saved into message with correct attribute.
+ //
+ // this kind of situation causes crash in application because we cannot validate type.
+
+ // mStubCollection->callHandleCollectionMessage(message, 0);
+ // delete subMedia;
+ CMPXMediaArray *array = mMediaFactory->newMediaArray();
+ mMediaFactory->putValuePtr<CMPXMediaArray>( message, KMPXMessageArrayContents, array);
+
+ // empty message array
+ mStubCollection->callHandleCollectionMessage(message, 0);
+
+ mMediaFactory->putArrayContent(array, mMediaFactory->newMedia(1));
+ mMediaFactory->putArrayContent(array, mMediaFactory->newMedia(2));
+ mMediaFactory->putArrayContent(array, mMediaFactory->newMedia(3));
+ mMediaFactory->putArrayContent(array, mMediaFactory->newMedia(4));
+
+ // message array containing invalid ( == empty) items
+ mStubCollection->callHandleCollectionMessage(message, 0);
+
+ delete array;
+ array = mMediaFactory->newMediaArray();
+ CMPXMedia *media = 0;
+
+ value = 0;
+ media = mMediaFactory->newMedia(1);
+ mMediaFactory->putTValue<int>(media, KVcxMediaMyVideosCommandId, value );
+ mMediaFactory->putArrayContent(array, media);
+ value = -1;
+ media = mMediaFactory->newMedia(2);
+ mMediaFactory->putTValue<int>(media, KVcxMediaMyVideosCommandId, value );
+ mMediaFactory->putArrayContent(array, media);
+ value = -2;
+ media = mMediaFactory->newMedia(3);
+ mMediaFactory->putTValue<int>(media, KVcxMediaMyVideosCommandId, value );
+ mMediaFactory->putArrayContent(array, media);
+
+ mMediaFactory->putValuePtr<CMPXMediaArray>( message, KMPXMessageArrayContents, array);
+
+ // message array containing KVcxMediaMyVideosCommandId -typed items
+ mStubCollection->callHandleCollectionMessage(message, 0);
+
+ delete array;
+ array = mMediaFactory->newMediaArray();
+ TMPXMessageId valueid = 1;
+ media = mMediaFactory->newMedia(1);
+ mMediaFactory->putTValue<TMPXMessageId>(media, KMPXMessageGeneralId, valueid );
+ mMediaFactory->putArrayContent(array, media);
+ valueid = 2;
+ media = mMediaFactory->newMedia(2);
+ mMediaFactory->putTValue<TMPXMessageId>(media, KMPXMessageGeneralId, valueid );
+ mMediaFactory->putArrayContent(array, media);
+ valueid = 3;
+ media = mMediaFactory->newMedia(3);
+ mMediaFactory->putTValue<TMPXMessageId>(media, KMPXMessageGeneralId, valueid );
+ mMediaFactory->putArrayContent(array, media);
+
+ mMediaFactory->putValuePtr<CMPXMediaArray>( message, KMPXMessageArrayContents, array);
+
+ // message array containing KMPXMessageGeneralId -typed items
+ mStubCollection->callHandleCollectionMessage(message, 0);
+
+ delete array;
+ array = mMediaFactory->newMediaArray();
+ valueid = 0;
+ media = mMediaFactory->newMedia(1);
+ mMediaFactory->putTValue<TMPXMessageId>(media, KMPXMessageGeneralId, valueid );
+ mMediaFactory->putArrayContent(array, media);
+ value = 1;
+ media = mMediaFactory->newMedia(2);
+ mMediaFactory->putTValue<TMPXMessageId>(media, KVcxMediaMyVideosCommandId, valueid );
+ mMediaFactory->putArrayContent(array, media);
+ valueid = 2;
+ media = mMediaFactory->newMedia(3);
+ mMediaFactory->putTValue<TMPXMessageId>(media, KMPXMessageGeneralId, valueid );
+ mMediaFactory->putArrayContent(array, media);
+
+ mMediaFactory->putValuePtr<CMPXMediaArray>( message, KMPXMessageArrayContents, array);
+
+ // message array contains both KVcxMediaMyVideosCommandId and KMPXMessageGeneralId typed items
+ mStubCollection->callHandleCollectionMessage(message, 0);
+ delete array;
+ delete message;
+ // none of above calls should cause any signal emitting
+ QVERIFY(!hasSignalsEmitted());
+ QVERIFY(receiver.getLatestItemId() == TMPXItemId::InvalidId());
+ QVERIFY(receiver.getLatestPointerAddr() == 0);
+ QVERIFY(receiver.getLatestIntegerData() == -1);
+
+ int remHeap = User::Heap().__DbgMarkEnd(0);
+ QVERIFY(remHeap == 0);
+}
+
+// -----------------------------------------------------------------------------
+// testHandleMyVideosMPXMessage
+// -----------------------------------------------------------------------------
+//
+void TestVideoCollectionListener::testHandleMyVideosMPXMessage()
+{
+ // tests all other my videos msg ids than KVcxMessageMyVideosDeleteResp.
+ // it is tested in testMyVideosDeleteMsgArray
+
+ StubSignalReceiver receiver;
+ QVERIFY(connectSignals(&receiver));
+
+ User::Heap().__DbgMarkStart();
+
+ mStubCollectionClient->setOpenStatus(VideoCollectionClient::ECollectionOpened);
+ CMPXMessage *message = mMediaFactory->newMedia(0);
+ TMPXMessageId msgId = KVcxCommandIdMyVideos;
+ mMediaFactory->putTValue<TMPXMessageId>(message, KMPXMessageGeneralId, msgId);
+ TUid uid = {KVcxUidMyVideosMpxCollection};
+ mMediaFactory->putTValue<TUid>(message, KMPXMessageCollectionId, uid);
+
+ // msg ids, that should not cause any additional funtionality (verified at the end of the method)
+ int value = KVcxMessageMyVideosDeleteStarted;
+ mMediaFactory->putTValue<int>( message, KVcxMediaMyVideosCommandId, value);
+ mStubCollection->callHandleCollectionMessage(message, 0);
+
+ value = KVcxMessageMyVideosMoveOrCopyStarted;
+ mMediaFactory->putTValue<int>( message, KVcxMediaMyVideosCommandId, value);
+ mStubCollection->callHandleCollectionMessage(message, 0);
+
+ value = KVcxMessageMyVideosMoveResp;
+ mMediaFactory->putTValue<int>( message, KVcxMediaMyVideosCommandId, value);
+ mStubCollection->callHandleCollectionMessage(message, 0);
+
+ value = KVcxMessageMyVideosCopyResp;
+ mMediaFactory->putTValue<int>( message, KVcxMediaMyVideosCommandId, value);
+ mStubCollection->callHandleCollectionMessage(message, 0);
+
+ // Handling of KVcxMessageMyVideosItemsAppended
+ VideoCollectionClient::mStartOpenCurrentStateCallCount = 0;
+ value = KVcxMessageMyVideosItemsAppended;
+ mMediaFactory->putTValue<int>( message, KVcxMediaMyVideosCommandId, value);
+ mStubCollection->callHandleCollectionMessage(message, 0);
+ QCOMPARE(VideoCollectionClient::mStartOpenCurrentStateCallCount, 1);
+
+ // Handling of // Handling of KVcxMessageMyVideosItemsAppended
+ VideoCollectionClient::mStartOpenCurrentStateCallCount = 0;
+ value = KVcxMessageMyVideosListComplete;
+ mMediaFactory->putTValue<int>( message, KVcxMediaMyVideosCommandId, value);
+ mStubCollection->callHandleCollectionMessage(message, 0);
+ QCOMPARE(VideoCollectionClient::mStartOpenCurrentStateCallCount, 1);
+
+ //////
+ // KVcxMessageMyVideosGetMediasByMpxIdResp
+ value = KVcxMessageMyVideosGetMediasByMpxIdResp;
+ mMediaFactory->putTValue<int>( message, KVcxMediaMyVideosCommandId, value);
+
+ // no contents
+ mStubCollection->callHandleCollectionMessage(message, 0);
+ QVERIFY(mSpyNewVideoAvailable->count() == 0);
+ QVERIFY(receiver.getLatestPointerAddr() == 0);
+ QVERIFY(receiver.getLatestIntegerData() == -1);
+
+ CMPXMediaArray *array = mMediaFactory->newMediaArray();
+ mMediaFactory->putValuePtr<CMPXMediaArray>( message, KMPXMediaArrayContents, array);
+
+ // empty array
+ mStubCollection->callHandleCollectionMessage(message, 0);
+ QVERIFY(mSpyNewVideoAvailable->count() == 0);
+ QVERIFY(receiver.getLatestPointerAddr() == 0);
+ QVERIFY(receiver.getLatestIntegerData() == -1);
+
+ mMediaFactory->putArrayContent( array, mMediaFactory->newMedia(10));
+ mMediaFactory->putArrayContent( array, mMediaFactory->newMedia(11));
+
+ // item(s) exists
+ mStubCollection->callHandleCollectionMessage(message, 0);
+ QVERIFY(mSpyNewVideoAvailable->count() == 1);
+ QVERIFY(receiver.getLatestPointerAddr() != 0);
+ CMPXMedia *fetched = static_cast<CMPXMedia*>(receiver.getLatestPointerAddr());
+ int fetchedId = -1;
+ VideoCollectionUtils::instance().mediaValue<int>(fetched, KMPXMediaGeneralId, fetchedId );
+ QVERIFY(fetchedId == 10);
+
+ mSpyNewVideoAvailable->clear();
+ delete array;
+ delete message;
+ QVERIFY(!hasSignalsEmitted());
+ QVERIFY(receiver.getLatestItemId() == TMPXItemId::InvalidId());
+ QVERIFY(receiver.getLatestPointerAddr() != 0);
+ QVERIFY(receiver.getLatestIntegerData() == -1);
+
+ int remHeap = User::Heap().__DbgMarkEnd(0);
+ QVERIFY(remHeap == 0);
+}
+
+// -----------------------------------------------------------------------------
+// testCollectionMessageNonMyVidMsgArray
+// -----------------------------------------------------------------------------
+//
+void TestVideoCollectionListener::testMyVideosDeleteMsgArray()
+{
+ StubSignalReceiver receiver;
+ QVERIFY(connectSignals(&receiver));
+
+ User::Heap().__DbgMarkStart();
+
+ mStubCollectionClient->setOpenStatus(VideoCollectionClient::ECollectionOpened);
+ CMPXMessage *message = mMediaFactory->newMedia(0);
+ TMPXMessageId msgId = KVcxCommandIdMyVideos;
+ mMediaFactory->putTValue<TMPXMessageId>(message, KMPXMessageGeneralId, msgId);
+ TUid uid = {KVcxUidMyVideosMpxCollection};
+ mMediaFactory->putTValue<TUid>(message, KMPXMessageCollectionId, uid);
+
+ int value = KVcxMessageMyVideosDeleteResp;
+ mMediaFactory->putTValue<int>( message, KVcxMediaMyVideosCommandId, value);
+
+ // null array mSpyVideoDeleteCompleted->count()
+ mStubCollection->callHandleCollectionMessage(message, 0);
+ QVERIFY(receiver.getLatestItemId() == TMPXItemId::InvalidId());
+ QVERIFY(receiver.getLatestPointerAddr() == 0);
+ QVERIFY(receiver.getLatestIntegerData() == -1);
+ QVERIFY(mSpyVideoDeleteCompleted->count() == 0);
+
+ // empty array
+ CMPXMediaArray *array = mMediaFactory->newMediaArray();
+ mMediaFactory->putValuePtr<CMPXMediaArray>( message, KMPXMediaArrayContents, array);
+ mStubCollection->callHandleCollectionMessage(message, 0);
+ QVERIFY(receiver.getLatestItemId() == TMPXItemId::InvalidId());
+ QVERIFY(receiver.getLatestPointerAddr() == 0);
+ QVERIFY(receiver.getLatestIntegerData() == -1);
+ QVERIFY(mSpyVideoDeleteCompleted->count() == 0);
+
+ // item(s) does not contain KVcxMediaMyVideosInt32Value
+ mMediaFactory->putArrayContent( array, mMediaFactory->newMedia(1));
+ mMediaFactory->putArrayContent( array, mMediaFactory->newMedia(2));
+ mMediaFactory->putArrayContent( array, mMediaFactory->newMedia(3));
+ mMediaFactory->putArrayContent( array, mMediaFactory->newMedia(4));
+ mMediaFactory->putValuePtr<CMPXMediaArray>( message, KMPXMessageArrayContents, array);
+ mStubCollection->callHandleCollectionMessage(message, 0);
+ QVERIFY(receiver.getLatestItemId() == TMPXItemId::InvalidId());
+ QVERIFY(receiver.getLatestPointerAddr() != 0);
+ QVERIFY(receiver.getLatestIntegerData() == 4);
+ QVERIFY(receiver.getLatestListData().count() == 0);
+ QVERIFY(mSpyVideoDeleteCompleted->count() == 1);
+ mSpyVideoDeleteCompleted->clear();
+
+ delete array;
+ array = mMediaFactory->newMediaArray();
+ mMediaFactory->putValuePtr<CMPXMediaArray>( message, KMPXMediaArrayContents, array);
+
+ // item(s) containing KVcxMediaMyVideosInt32Value -values, both incorrect (1) and correct (3)
+ CMPXMedia *media = 0;
+ mMediaFactory->putArrayContent( array, mMediaFactory->newMedia(1));
+
+ media = mMediaFactory->newMedia(2);
+ value = 1;
+ mMediaFactory->putTValue<int>( media, KVcxMediaMyVideosInt32Value, value);
+ mMediaFactory->putArrayContent( array, media);
+
+ media = mMediaFactory->newMedia(3);
+ value = 1;
+ mMediaFactory->putTValue<int>( media, KVcxMediaMyVideosInt32Value, value);
+ mMediaFactory->putArrayContent( array, media);
+
+ media = mMediaFactory->newMedia(4);
+ value = 0;
+ mMediaFactory->putTValue<int>( media, KVcxMediaMyVideosInt32Value, value);
+ mMediaFactory->putArrayContent( array, media);
+
+ media = mMediaFactory->newMedia(5);
+ value = 1;
+ mMediaFactory->putTValue<int>( media, KVcxMediaMyVideosInt32Value, value);
+ mMediaFactory->putArrayContent( array, media);
+
+ mMediaFactory->putArrayContent( array, mMediaFactory->newMedia(6));
+ mStubCollection->callHandleCollectionMessage(message, 0);
+ QVERIFY(receiver.getLatestItemId() == TMPXItemId::InvalidId());
+ QVERIFY(receiver.getLatestIntegerData() == 6);
+ QVERIFY(receiver.getLatestPointerAddr() != 0);
+ QVERIFY(receiver.getLatestListData().count() == 3);
+ QVERIFY(receiver.getLatestListData().value(0).iId1 == 2);
+ QVERIFY(receiver.getLatestListData().value(1).iId1 == 3);
+ QVERIFY(receiver.getLatestListData().value(2).iId1 == 5);
+ QVERIFY(mSpyVideoDeleteCompleted->count() == 1);
+
+ receiver.resetLatestItems();
+ mSpyVideoDeleteCompleted->clear();
+ delete array;
+ delete message;
+
+ QVERIFY(!hasSignalsEmitted());
+
+ int remHeap = User::Heap().__DbgMarkEnd(0);
+ QVERIFY(remHeap == 0);
+}
+
+// -----------------------------------------------------------------------------
+// testCollectionMessageNonMyVidCommandId
+// -----------------------------------------------------------------------------
+//
+void TestVideoCollectionListener::testHandleMPXMessage()
+{
+ StubSignalReceiver receiver;
+ QVERIFY(connectSignals(&receiver));
+
+ User::Heap().__DbgMarkStart();
+
+ mStubCollectionClient->setOpenStatus(VideoCollectionClient::ECollectionOpened);
+ CMPXMessage *message = mMediaFactory->newMedia(0);
+ TMPXMessageId msgId = KMPXMessageGeneral;
+ mMediaFactory->putTValue<TMPXMessageId>(message, KMPXMessageGeneralId, msgId);
+ TUid uid = {KVcxUidMyVideosMpxCollection};
+ mMediaFactory->putTValue<TUid>(message, KMPXMessageCollectionId, uid);
+
+ // NOTE:
+ // - we're testing only for KMPXMessageGeneral only once, because handleGeneralMPXMessage is already verified
+ mStubCollection->callHandleCollectionMessage(message, 0);
+ QVERIFY(receiver.getLatestItemId() == TMPXItemId::InvalidId());
+ QVERIFY(receiver.getLatestPointerAddr() == 0);
+ QVERIFY(!hasSignalsEmitted());
+
+
+ // invalid
+ msgId = KMPXMessageIdItemChanged + 1;
+ mStubCollection->callHandleCollectionMessage(message, 0);
+ QVERIFY(receiver.getLatestItemId() == TMPXItemId::InvalidId());
+ QVERIFY(receiver.getLatestPointerAddr() == 0);
+ QVERIFY(!hasSignalsEmitted());
+
+ // KMPXMessageIdItemChanged with no content
+ mStubCollectionClient->setCollectionLevel(VideoCollectionClient::ELevelVideos);
+ msgId = KMPXMessageIdItemChanged;
+ mMediaFactory->putTValue<TMPXMessageId>(message, KMPXMessageGeneralId, msgId);
+ mStubCollection->callHandleCollectionMessage(message, 0);
+ QVERIFY(receiver.getLatestItemId() == TMPXItemId::InvalidId());
+ QVERIFY(receiver.getLatestPointerAddr() == 0);
+ QVERIFY(!hasSignalsEmitted());
+
+ // KMPXMessageIdItemChanged with level != CVideoCollectionClient::ELevelVideos
+ mStubCollectionClient->setCollectionLevel(VideoCollectionClient::ELevelVideos - 1);
+ mStubCollection->callHandleCollectionMessage(message, 0);
+ QVERIFY(receiver.getLatestItemId() == TMPXItemId::InvalidId());
+ QVERIFY(receiver.getLatestPointerAddr() == 0);
+ QVERIFY(!hasSignalsEmitted());
+
+ // KMPXMessageIdItemChanged with existing, not handled event type with missing KMPXMessageMediaGeneralId
+ mStubCollectionClient->setCollectionLevel(VideoCollectionClient::ELevelVideos);
+ TMPXChangeEventType eventType = EMPXItemModified;
+ mMediaFactory->putTValue<TMPXChangeEventType>(message, KMPXMessageChangeEventType, eventType);
+ mStubCollection->callHandleCollectionMessage(message, 0);
+ QVERIFY(receiver.getLatestItemId() == TMPXItemId::InvalidId());
+ QVERIFY(receiver.getLatestPointerAddr() == 0);
+ QVERIFY(!hasSignalsEmitted());
+
+ // KMPXMessageIdItemChanged with existing, not handled event type
+ TMPXItemId eventId;
+ eventId.iId1 = 10;
+ mMediaFactory->putTValue<TMPXItemId>(message, KMPXMessageMediaGeneralId, eventId);
+ mStubCollection->callHandleCollectionMessage(message, 0);
+ QVERIFY(receiver.getLatestItemId() == TMPXItemId::InvalidId());
+ QVERIFY(receiver.getLatestPointerAddr() == 0);
+ QVERIFY(!hasSignalsEmitted());
+
+ // KMPXMessageIdItemChanged with EMPXItemDeleted event type
+ eventType = EMPXItemDeleted;
+ mMediaFactory->putTValue<TMPXChangeEventType>(message, KMPXMessageChangeEventType, eventType);
+ mStubCollection->callHandleCollectionMessage(message, 0);
+ QVERIFY(receiver.getLatestItemId().iId1 == 10);
+ QVERIFY(receiver.getLatestPointerAddr() == 0);
+ QVERIFY(mSpyVideoDeleted->count() == 1);
+ mSpyVideoDeleted->clear();
+ QVERIFY(!hasSignalsEmitted());
+
+ receiver.resetLatestItems();
+ // KMPXMessageIdItemChanged with EMPXItemInserted event type with no correct id2
+ eventType = EMPXItemInserted;
+ eventId.iId2 = 2;
+ mMediaFactory->putTValue<TMPXItemId>(message, KMPXMessageMediaGeneralId, eventId);
+ mMediaFactory->putTValue<TMPXChangeEventType>(message, KMPXMessageChangeEventType, eventType);
+ mStubCollection->callHandleCollectionMessage(message, 0);
+ QVERIFY(receiver.getLatestItemId() == TMPXItemId::InvalidId());
+ QVERIFY(receiver.getLatestPointerAddr() == 0);
+ // mpx id should have not changed into 10
+ QVERIFY(mStubCollectionClient->getLatestMPXId() == 0);
+ QVERIFY(!hasSignalsEmitted());
+
+ // KMPXMessageIdItemChanged with EMPXItemInserted event type with correct id2 no media object
+ eventId.iId2 = 1;
+ mMediaFactory->putTValue<TMPXItemId>(message, KMPXMessageMediaGeneralId, eventId);
+ mStubCollection->callHandleCollectionMessage(message, 0);
+ QVERIFY(receiver.getLatestItemId() == TMPXItemId::InvalidId());
+ QVERIFY(receiver.getLatestPointerAddr() == 0);
+ QVERIFY(mStubCollectionClient->getLatestMPXId() == eventId);
+ QVERIFY(!hasSignalsEmitted());
+
+ // TODO: need to check album support
+ // KMPXMessageIdItemChanged with EMPXItemInserted event type with correct id2 with media object
+ CMPXMedia *media = mMediaFactory->newMedia(11);
+ mMediaFactory->putValuePtr<CMPXMedia>(message, KMPXCommandColAddMedia, media);
+ mStubCollection->callHandleCollectionMessage(message, 0);
+ QVERIFY(receiver.getLatestItemId() == TMPXItemId::InvalidId());
+ QVERIFY(receiver.getLatestPointerAddr() != 0);
+ QVERIFY(mSpyNewVideoAvailable->count() == 1);
+ CMPXMedia *gotten = static_cast<CMPXMedia*>(receiver.getLatestPointerAddr());
+ int fetchedId = -1;
+ VideoCollectionUtils::instance().mediaValue<int>(gotten, KMPXMediaGeneralId, fetchedId );
+ QVERIFY(fetchedId == 11);
+ mSpyNewVideoAvailable->clear();
+ QVERIFY(!hasSignalsEmitted());
+
+ delete media;
+ delete message;
+ int remHeap = User::Heap().__DbgMarkEnd(0);
+ QVERIFY(remHeap == 0);
+}
+
+// -----------------------------------------------------------------------------
+// connectSignals
+// -----------------------------------------------------------------------------
+//
+bool TestVideoCollectionListener::connectSignals(StubSignalReceiver *receiver)
+{
+ if(!QObject::connect(mTestObject, SIGNAL(newVideoList(CMPXMediaArray*)),
+ receiver, SLOT(newVideoListSlot(CMPXMediaArray*)),
+ Qt::DirectConnection))
+ {
+ return false;
+ }
+
+ if(!QObject::connect(mTestObject, SIGNAL(videoListAppended(CMPXMediaArray*)),
+ receiver, SLOT(videoListAppendedSlot(CMPXMediaArray*)),
+ Qt::DirectConnection))
+ {
+ return false;
+ }
+
+ if(!QObject::connect(mTestObject, SIGNAL(newVideoAvailable(CMPXMedia*)),
+ receiver, SLOT(newVideoAvailableSlot(CMPXMedia*)),
+ Qt::DirectConnection))
+ {
+ return false;
+ }
+
+ if(!QObject::connect(mTestObject, SIGNAL( videoListAppended(CMPXMediaArray*)),
+ receiver, SLOT(videoListAppendedSlot(CMPXMediaArray*)),
+ Qt::DirectConnection))
+ {
+ return false;
+ }
+
+ if(!QObject::connect(mTestObject, SIGNAL(videoDeleted(TMPXItemId)),
+ receiver, SLOT(videoDeletedSlot(TMPXItemId)),
+ Qt::DirectConnection))
+ {
+ return false;
+ }
+
+ if(!QObject::connect(mTestObject, SIGNAL(videoDeleteCompleted(int, QList<TMPXItemId>*)),
+ receiver, SLOT(videoDeleteCompletedSlot(int, QList<TMPXItemId>*)),
+ Qt::DirectConnection))
+ {
+ return false;
+ }
+
+ if(!QObject::connect(mTestObject, SIGNAL(videoDetailsCompleted(TMPXItemId)),
+ receiver, SLOT(videoDetailsCompletedSlot(TMPXItemId)),
+ Qt::DirectConnection))
+ {
+ return false;
+ }
+ return true;
+}
+
+// -----------------------------------------------------------------------------
+// hasSignalsEmitted
+// -----------------------------------------------------------------------------
+//
+bool TestVideoCollectionListener::hasSignalsEmitted()
+{
+ if(mSpyNewVideoList->count() > 0)
+ {
+ return true;
+ }
+ if(mSpyVideoListAppended->count() > 0)
+ {
+ return true;
+ }
+ if(mSpyNewVideoAvailable->count() > 0)
+ {
+ return true;
+ }
+ if(mSpyVideoDeleted->count() > 0)
+ {
+ return true;
+ }
+ if(mSpyVideoDeleteCompleted->count() > 0)
+ {
+ return true;
+ }
+ if(mSpyVideoDetailsCompleted->count() > 0)
+ {
+ return true;
+ }
+ return false;
+}
+
+
+// End of file
+
+
+