/**

* 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 "videocollectioncommon.h"

#include "stubsignalreceiver.h"

#include "stubcollection.h"

#include "videocollectionutils.h"

#define private public

#include "videocollectionlistener.h"

#undef private

// -----------------------------------------------------------------------------

// main

// -----------------------------------------------------------------------------

//

int main(int argc, char *argv[])

{

    TestVideoCollectionListener tv;

    int res;

    if(argc > 1)

    {   

        res = QTest::qExec(&tv, argc, argv);

    }

    else

    {

        char *pass[3];

        pass[0] = argv[0];

        pass[1] = "-o";

        pass[2] = "c:\\data\\testvideocollectionlistener.txt";

        res = QTest::qExec(&tv, 3, pass);

    }

    return res;

}

// -----------------------------------------------------------------------------

// initTestCase

// -----------------------------------------------------------------------------

//

void TestVideoCollectionListener::initTestCase()

{

    mMediaFactory = new MediaObjectFactory();

}

// -----------------------------------------------------------------------------

// init

// -----------------------------------------------------------------------------

//

void TestVideoCollectionListener::init()

{   

    mStubCollectionClient = new VideoCollectionClient();

    mSignalReceiver = new StubSignalReceiver();

    mTestObject = new VideoCollectionListener(*mStubCollectionClient, *mSignalReceiver);

    mStubCollection = new StubCollection(*mTestObject);

    qRegisterMetaType<CMPXMediaArray*>("CMPXMediaArray*");

    qRegisterMetaType<CMPXMedia*>("CMPXMedia*");

    qRegisterMetaType<TMPXItemId>("TMPXItemId");

    qRegisterMetaType<QList<TMPXItemId>*>("QList<TMPXItemId>*");

}

// -----------------------------------------------------------------------------

// cleanup

// -----------------------------------------------------------------------------

//

void TestVideoCollectionListener::cleanup()

{

    delete mTestObject;

    mTestObject = 0;

    delete mSignalReceiver;

    mSignalReceiver = 0;

    delete mStubCollectionClient;

    mStubCollectionClient = 0;

    delete mStubCollection;

    mStubCollection = 0;

}

// -----------------------------------------------------------------------------

// cleanupTestCase

// -----------------------------------------------------------------------------

//

void TestVideoCollectionListener::cleanupTestCase()

{

    delete mMediaFactory;

}

// -----------------------------------------------------------------------------

// testHandleCollectionMediaL

// -----------------------------------------------------------------------------

//

void TestVideoCollectionListener::testHandleCollectionMediaLFunc()

{

    // 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(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());  

    QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);

    int remHeap = User::Heap().__DbgMarkEnd(0);

    QVERIFY(remHeap == 0);   

}

// -----------------------------------------------------------------------------

// testHandleOpenLMediaFunc

// -----------------------------------------------------------------------------

//

void TestVideoCollectionListener::testHandleOpenLMediaFunc()

{   

    mStubCollectionClient->setCollectionLevel(VideoCollectionCommon::ELevelVideos);      

    CMPXMedia *media = mMediaFactory->newMedia(0);

    // error != KErrNone

    mStubCollection->callHandleOpenLFunc(*media, 0, true, -2 );

    QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);

    // collectionLevel != LevelVideos

    mStubCollectionClient->setCollectionLevel(-100);

    mStubCollection->callHandleOpenLFunc(*media, 0, true, 0 );

    QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);

    mStubCollectionClient->setCollectionLevel(VideoCollectionCommon::ELevelVideos);

    // empty media (== media does not contain array)

    mStubCollection->callHandleOpenLFunc(*media, 0, true, 0 );

    QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);

    // signal emitting: correct media-array passed

    CMPXMediaArray *array = mMediaFactory->newMediaArray();  

    CMPXMediaArray *arrayToTest = 0;

    QWARN("test for other paths than all videos are missing");

    CMPXCollectionPath* collectionPath = 0;

    TRAP_IGNORE(

            collectionPath =  CMPXCollectionPath::NewL();

            collectionPath->AppendL( KVcxUidMyVideosMpxCollection );

            collectionPath->AppendL( KVcxMvcCategoryIdAll););

    // empty array

    mMediaFactory->putValuePtr<CMPXMediaArray>(media, KMPXMediaArrayContents, array);   

    mMediaFactory->putValuePtr<CMPXCollectionPath>(media, KMPXMediaGeneralContainerPath, collectionPath); 

    mStubCollection->callHandleOpenLFunc(*media, 0, true, 0 ); 

    arrayToTest = static_cast<CMPXMediaArray*>(mSignalReceiver->getLatestPointerAddr());

    QVERIFY(arrayToTest != 0);

    QVERIFY(arrayToTest->Count() == array->Count());

    // array of items from different levels, everything is reported 

    mStubCollectionClient->setCollectionLevel(VideoCollectionCommon::ELevelCategory);

    mMediaFactory->putArrayContent(array, mMediaFactory->newMedia(1, 2));

    mMediaFactory->putValuePtr<CMPXCollectionPath>(media, KMPXMediaGeneralContainerPath, collectionPath); 

    mStubCollection->callHandleOpenLFunc(*media, 0, true, 0 );  

    arrayToTest = static_cast<CMPXMediaArray*>(mSignalReceiver->getLatestPointerAddr());

    QVERIFY(arrayToTest != 0);

    QVERIFY(arrayToTest->Count() == array->Count());

    mStubCollectionClient->setCollectionLevel(VideoCollectionCommon::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);

    mMediaFactory->putValuePtr<CMPXCollectionPath>(media, KMPXMediaGeneralContainerPath, collectionPath); 

    mStubCollection->callHandleOpenLFunc(*media, 0, true, 0 );    

    arrayToTest = static_cast<CMPXMediaArray*>(mSignalReceiver->getLatestPointerAddr());

    QVERIFY(arrayToTest != 0);

    QVERIFY(arrayToTest->Count() == array->Count());

    mStubCollection->callHandleOpenLFunc(*media, 0, true, 0 );    

    arrayToTest = static_cast<CMPXMediaArray*>(mSignalReceiver->getLatestPointerAddr());

    QVERIFY(arrayToTest != 0);

    QVERIFY(arrayToTest->Count() == array->Count());

    CMPXMediaArray *gottenArray = static_cast<CMPXMediaArray*>(mSignalReceiver->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);

    collectionPath->Reset();

    delete collectionPath;

    TMPXItemId albumId(100,2);

    TRAP_IGNORE(

                collectionPath =  CMPXCollectionPath::NewL();

                collectionPath->AppendL( KVcxUidMyVideosMpxCollection );

                collectionPath->AppendL( albumId ););

    //  level == album

    mStubCollectionClient->setCollectionLevel(VideoCollectionCommon::ELevelAlbum);

    mSignalReceiver->resetLatestItems();

    delete array;

    array = mMediaFactory->newMediaArray();  

    mMediaFactory->putArrayContent(array, mMediaFactory->newMedia(1));

    mMediaFactory->putArrayContent(array, mMediaFactory->newMedia(2));

    mMediaFactory->putArrayContent(array, mMediaFactory->newMedia(3));

    // call open item to update latest item id in stub collection client

    mStubCollectionClient->openItem(albumId);

    mMediaFactory->putValuePtr<CMPXMediaArray>(media, KMPXMediaArrayContents, array);

    mMediaFactory->putValuePtr<CMPXCollectionPath>(media, KMPXMediaGeneralContainerPath, collectionPath); 

    mStubCollection->callHandleOpenLFunc(*media, 0, true, 0 );    

    gottenArray = static_cast<CMPXMediaArray*>(mSignalReceiver->getLatestPointerAddr());

    QVERIFY(gottenArray->Count() == 3);

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

    mediaId = mSignalReceiver->getLatestItemId();

    QVERIFY(mediaId == albumId);

    delete array;

    delete media;

    collectionPath->Reset();

    delete collectionPath;

    mSignalReceiver->resetLatestItems();

}

// -----------------------------------------------------------------------------

// testHandleOpenLPlaylistFunc

// -----------------------------------------------------------------------------

//

void TestVideoCollectionListener::testHandleOpenLPlaylistFunc()

{

    // 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(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());  

    QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);

    int remHeap = User::Heap().__DbgMarkEnd(0);

    QVERIFY(remHeap == 0); 

}

// -----------------------------------------------------------------------------

// testHandleCommandComplete

// -----------------------------------------------------------------------------

//

void TestVideoCollectionListener::testHandleCommandComplete()

{

    User::Heap().__DbgMarkStart(); 

    CMPXCommand *pCommand = mMediaFactory->newMedia(0);

    // error != KErrNone

    mStubCollection->callHandleCommandComplete(pCommand, -2);

    QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());

    // command == NULL

    mStubCollection->callHandleCommandComplete(0, 0);

    QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());

    // null command + error != KErrNone

    mStubCollection->callHandleCommandComplete(0, -2);

    QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());

    // command without id

    delete pCommand;

    pCommand = mMediaFactory->newMedia();

    mStubCollection->callHandleCommandComplete(pCommand, 0);

    QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());

    // no command attribute

    delete pCommand;

    pCommand = mMediaFactory->newMedia(0);

    mStubCollection->callHandleCommandComplete(pCommand, 0);

    QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());

    // invalid KVcxMediaMyVideosCommandId

    int value = (KVcxCommandMyVideosGetMediaFullDetailsByMpxId + 10);

    mMediaFactory->putTValue<int>(pCommand, KVcxMediaMyVideosCommandId, value );

    mStubCollection->callHandleCommandComplete(pCommand, 0);

    QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());

    // no media object in command

    value = KVcxCommandMyVideosGetMediaFullDetailsByMpxId;

    mMediaFactory->putTValue<int>(pCommand, KVcxMediaMyVideosCommandId, value );

    mStubCollection->callHandleCommandComplete(pCommand, 0);

    QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());

    // 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(mSignalReceiver->getLatestItemId().iId1  == 10);

    delete subMedia;

    delete pCommand;

    QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);

    int remHeap = User::Heap().__DbgMarkEnd(0);

    QVERIFY(remHeap == 0);   

}

// -----------------------------------------------------------------------------

// testCollectionMessageError

// -----------------------------------------------------------------------------

//

void TestVideoCollectionListener::testCollectionMessageError()

{

    mSignalReceiver->resetLatestItems();

    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 callbacks

    QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());  

    QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0);

    QVERIFY(mSignalReceiver->getLatestIntegerData() == -1);

    int remHeap = User::Heap().__DbgMarkEnd(0);

    QVERIFY(remHeap == 0);    

}

// -----------------------------------------------------------------------------

// testCollectionMessageNotOpened

// -----------------------------------------------------------------------------

//

void TestVideoCollectionListener::testCollectionMessageNotOpened()

{

    mSignalReceiver->resetLatestItems();

    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 callbacks

    QVERIFY(mSignalReceiver->getLatestItemId() == TMPXItemId::InvalidId());  

    QVERIFY(mSignalReceiver->getLatestPointerAddr() == 0); 

    QVERIFY(mSignalReceiver->getLatestIntegerData() == -1);

    delete message;

    int remHeap = User::Heap().__DbgMarkEnd(0);

    QVERIFY(remHeap == 0);     

}

// -----------------------------------------------------------------------------

// testCollectionMessageMyVidCommandId

// -----------------------------------------------------------------------------

//

void TestVideoCollectionListener::testCollectionMessageMyVidCommandId()

{

    mSignalReceiver->resetLatestItems();

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