/**

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

    // empty array, no path   

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

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

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

    QVERIFY(arrayToTest == 0);

    CMPXCollectionPath* collectionPath = 0;

    TRAP_IGNORE(

           collectionPath =  CMPXCollectionPath::NewL();

    // empty array, path exists level incorrect (new video list, not category neither album level)     

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

    delete collectionPath;

    // empty array, path exists level correct      

    collectionPath = 0;

    TRAP_IGNORE(

          collectionPath =  CMPXCollectionPath::NewL();

          collectionPath->AppendL( KVcxUidMyVideosMpxCollection );

          collectionPath->AppendL( KVcxMvcCategoryIdAll););

    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;

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

    delete collectionPath;

    collectionPath = 0;

    TRAP_IGNORE(

         collectionPath =  CMPXCollectionPath::NewL();

         collectionPath->AppendL( KVcxUidMyVideosMpxCollection );

         collectionPath->AppendL( KVcxMvcMediaTypeCategory););

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

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

}

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

// testHandleCommandCompleteInvalid

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

//

void TestVideoCollectionListener::testHandleCommandCompleteInvalid()

{

    User::Heap().__DbgMarkStart(); 

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

    // error != KErrNone

    mStubCollection->callHandleCommandComplete(pCommand, -2);

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

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

    // command == NULL

    mStubCollection->callHandleCommandComplete(0, 0);

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

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

    // null command + error != KErrNone

    mStubCollection->callHandleCommandComplete(0, -2);

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

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

    // command without id

    delete pCommand;

    pCommand = mMediaFactory->newMedia();

    mStubCollection->callHandleCommandComplete(pCommand, 0);

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

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

    // no command attribute

    delete pCommand;

    pCommand = mMediaFactory->newMedia(0);

    mStubCollection->callHandleCommandComplete(pCommand, 0);

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

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

    // invalid KVcxMediaMyVideosCommandId

    int value = (KVcxCommandMyVideosGetMediaFullDetailsByMpxId + 10);

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

    mStubCollection->callHandleCommandComplete(pCommand, 0);

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

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

    delete pCommand;

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

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

    QVERIFY(remHeap == 0);   

}

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

// testHandleCommandCompleteGetDetails

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

//

void TestVideoCollectionListener::testHandleCommandCompleteGetDetails()

{

    mSignalReceiver->resetLatestItems();

    User::Heap().__DbgMarkStart(); 

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

    // cmd KVcxCommandMyVideosGetMediaFullDetailsByMpxId

    // no media object in command

    int value;

    value = KVcxCommandMyVideosGetMediaFullDetailsByMpxId;

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

    mStubCollection->callHandleCommandComplete(pCommand, 0);

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

    // correct item 

    delete pCommand;

    pCommand = mMediaFactory->newMedia();

    CMPXMedia *subMedia = mMediaFactory->newMedia(10);

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

    mMediaFactory->putValuePtr<CMPXMedia>(pCommand, KMPXCommandColAddMedia, subMedia);

    mStubCollection->callHandleCommandComplete(pCommand, 0);

    TMPXItemId itemId = TMPXItemId::InvalidId();

    TMPXItemId expectedId = TMPXItemId::InvalidId();

    TRAP_IGNORE(itemId = static_cast<CMPXMedia*>(mSignalReceiver->getLatestPointerAddr())->ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId));

    TRAP_IGNORE(expectedId = subMedia->ValueTObjectL<TMPXItemId>(KMPXMediaGeneralId));

    QVERIFY(itemId == expectedId);

    delete subMedia;

    delete pCommand;

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

    QVERIFY(remHeap == 0);   

}

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

// testHandleCommandCompleteRemoveAlbums

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

//

void TestVideoCollectionListener::testHandleCommandCompleteRemoveAlbums()

{

    mSignalReceiver->resetLatestItems();

    User::Heap().__DbgMarkStart(); 

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

    int value = KVcxCommandMyVideosRemoveAlbums;

    // no messageArray object in command

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

    mStubCollection->callHandleCommandComplete(pCommand, 0);

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

    delete pCommand;

    pCommand = mMediaFactory->newMedia();

    // empty message array    

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

    CMPXMediaArray *array = mMediaFactory->newMediaArray();

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

    mStubCollection->callHandleCommandComplete(pCommand, 0);

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

    delete array;

    delete pCommand;

    pCommand = mMediaFactory->newMedia();

    // some items, no failed

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

    CMPXMedia *media1 = mMediaFactory->newMedia(1,0);

    CMPXMedia *media2 = mMediaFactory->newMedia(2,0);

    CMPXMedia *media3 = mMediaFactory->newMedia(3,0);

    array = mMediaFactory->newMediaArray();

    TRAP_IGNORE(

        array->AppendL(media1);

        array->AppendL(media2);

        array->AppendL(media3););

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

    mStubCollection->callHandleCommandComplete(pCommand, 0);

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

    delete array;

    delete pCommand;

    // some items, one invalid item, no failed   

    array = mMediaFactory->newMediaArray();

    pCommand = mMediaFactory->newMedia();

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

    media1 = mMediaFactory->newMedia(1,0);

    media2 = mMediaFactory->newMedia(2,0);

    media3 = mMediaFactory->newMedia(3,0);

    CMPXMedia *media4;

    TRAP_IGNORE(media4 = CMPXMedia::NewL());

    TRAP_IGNORE(

        array->AppendL(media1);

        array->AppendL(media2);

        array->AppendL(media3);

        array->AppendL(media4););

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

    mStubCollection->callHandleCommandComplete(pCommand, 0);

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

    delete array;

    delete pCommand;

    // some items, one failed    

    array = mMediaFactory->newMediaArray();

    pCommand = mMediaFactory->newMedia();

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

    media1 = mMediaFactory->newMedia(1,0);

    value = 0;

    mMediaFactory->putTValue<int>(media1, KVcxMediaMyVideosInt32Value, value);

    media2 = mMediaFactory->newMedia(2,0);

    value = 1;

    mMediaFactory->putTValue<int>(media2, KVcxMediaMyVideosInt32Value, value);

    media3 = mMediaFactory->newMedia(3,0);

    TRAP_IGNORE(

            array->AppendL(media1);

            array->AppendL(media2);

            array->AppendL(media3););

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

    mStubCollection->callHandleCommandComplete(pCommand, 0);