/*

* Copyright (c) 2007 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:    CGlxMediaList unit tests

*

*/

//  CLASS HEADER

#include "ut_cglxmedialist.h"

//  EXTERNAL INCLUDES

#include <digia/eunit/eunitmacros.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxmediageneraldefs.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxmessageprogressdefs.h>

#include <mpxcollectionmessage.h>

#include <glxcommandgeneraldefs.h>

#include <glxdrmutility.h>

//  INTERNAL INCLUDES

#include "glxmedialist.h"

#include "glxattributecontext.h"

_LIT(KTitle, "Albums");

const TInt KTestCollectionPluginUid = 0x20007195;

const TInt KTestAlbumCollectionPluginUid = 0x2000718B;

const TInt KFavouritesAlbumId = 3000;

const TInt KFavouritesAlbumFirstItemId = 3009;

const TInt KProgressTotalCount = 10;

const TMPXAttribute KProgressCountAttr(KMPXMessageContentIdProgress, EMPXMessageProgressCurrentCount);

const TMPXAttribute KProgressTotalCountAttr(KMPXMessageContentIdProgress, EMPXMessageProgressTotalCount);

void CGlxDRMUtility::Close()

    {

    delete this;

    }

TBool CGlxDRMUtility::CheckOpenRightsL(const TDesC&, TBool)

    {

    return ETrue;

    }

CGlxDRMUtility* CGlxDRMUtility::InstanceL()

    {

    CGlxDRMUtility* drm = new(ELeave)CGlxDRMUtility();

    return drm;

    }

TSize CGlxDRMUtility::DRMThumbnailSize(TSize& aSize)

    {

    return aSize;

    }

CGlxDRMUtility::CGlxDRMUtility()

    {

    }

CGlxDRMUtility::~CGlxDRMUtility()

    {

    }

// CONSTRUCTION

UT_CGlxMediaList* UT_CGlxMediaList::NewL()

    {

    UT_CGlxMediaList* self = UT_CGlxMediaList::NewLC();

    CleanupStack::Pop();

    return self;

    }

UT_CGlxMediaList* UT_CGlxMediaList::NewLC()

    {

    UT_CGlxMediaList* self = new( ELeave ) UT_CGlxMediaList();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor (virtual by CBase)

UT_CGlxMediaList::~UT_CGlxMediaList()

    {

    }

// Default constructor

UT_CGlxMediaList::UT_CGlxMediaList()

    {

    }

// Second phase construct

void UT_CGlxMediaList::ConstructL()

    {

    // The ConstructL from the base class CEUnitTestSuiteClass must be called.

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

//  METHODS

void UT_CGlxMediaList::HandleItemAddedL(TInt /*aStartIndex*/, TInt /*aEndIndex*/, MGlxMediaList* /*aList*/)

    {

    iSchedulerWait->AsyncStop();

    }

void UT_CGlxMediaList::HandleAttributesAvailableL(TInt /*aItemIndex*/, const RArray<TMPXAttribute>& /*aAttributes*/, MGlxMediaList* /*aList*/)

    {

    iSchedulerWait->AsyncStop();

    }

void UT_CGlxMediaList::SetupL(  )

    {

    CMPXCollectionPath* path = CMPXCollectionPath::NewL();

    CleanupStack::PushL(path);

    path->AppendL(KTestCollectionPluginUid);

    path->AppendL(KFavouritesAlbumId);

    iCGlxMediaList = CGlxMediaList::InstanceL(*path, NULL);

    CleanupStack::PopAndDestroy(); // path

    iCGlxMediaList->AddMediaListObserverL(this);

    iContext = CGlxDefaultAttributeContext::NewL();

    iContext->AddAttributeL(KMPXMediaGeneralTitle);

    iCGlxMediaList->AddContextL(iContext, 0);

    iSchedulerWait = new (ELeave) CActiveSchedulerWait();

    iSchedulerWait->Start(); // wait for Media list to be populated (HandleItemAddedL will be called)

    }

void UT_CGlxMediaList::Teardown(  )

    {

    iCGlxMediaList->RemoveContext(iContext);

    delete iContext;

    iContext = NULL;

    iCGlxMediaList->RemoveMediaListObserver(this);

    iCGlxMediaList->Close();

    delete iSchedulerWait;

    iSchedulerWait = NULL;

    }

void UT_CGlxMediaList::UT_CGlxMediaList_InstanceLL(  )

    {

    // Obtain instance of media list to existing path with filter applied

    CMPXCollectionPath* existingPath = CMPXCollectionPath::NewL();

    CleanupStack::PushL(existingPath);

    existingPath->AppendL(KTestCollectionPluginUid);

    existingPath->AppendL(KFavouritesAlbumId);

    CMPXFilter* filter1 = CMPXFilter::NewL();

    CleanupStack::PushL(filter1);

    EUNIT_PRINT(_L("Obtain instance of media list to existing path with filter applied"));

    CGlxMediaList* filteredCGlxMediaList1 = CGlxMediaList::InstanceL(*existingPath, KGlxIdNone, filter1);

    // filter ownership passed to media list

    CleanupStack::Pop(filter1);

    CleanupClosePushL(*filteredCGlxMediaList1);

    // Check instance is different

    EUNIT_PRINT(_L("Check instance is different"));

    EUNIT_ASSERT(filteredCGlxMediaList1 != iCGlxMediaList);

    // Obtain instance of media list with different path

    CMPXCollectionPath* differentPath = CMPXCollectionPath::NewL();

    CleanupStack::PushL(differentPath);

    differentPath->AppendL(KTestAlbumCollectionPluginUid);

    differentPath->AppendL(KFavouritesAlbumId);

    EUNIT_PRINT(_L("Obtain instance of media list with different path"));

    CGlxMediaList* cGlxMediaList1 = CGlxMediaList::InstanceL(*differentPath, NULL);

    CleanupClosePushL(*cGlxMediaList1);

    // Check instance is different

    EUNIT_PRINT(_L("Check instance is different"));

    EUNIT_ASSERT(cGlxMediaList1 != iCGlxMediaList);

    // Obtain instance of media list to existing path with filter applied

    CMPXFilter* filter2 = CMPXFilter::NewL();

    CleanupStack::PushL(filter2);

    EUNIT_PRINT(_L("Obtain instance of media list to existing path with filter applied"));

    CGlxMediaList* filteredCGlxMediaList2 = CGlxMediaList::InstanceL(*existingPath, KGlxIdNone, filter2);

    // filter ownership passed to media list

    CleanupStack::Pop(filter2);

    CleanupClosePushL(*filteredCGlxMediaList2);

    // Check instance is different

    EUNIT_PRINT(_L("Check instance is different"));

    EUNIT_ASSERT(filteredCGlxMediaList2 != filteredCGlxMediaList1) 

    // Obtain instance of media list with same path

    EUNIT_PRINT(_L("Obtain instance of media list with same path"));

    CGlxMediaList* cGlxMediaList2 = CGlxMediaList::InstanceL(*existingPath, NULL);

    CleanupClosePushL(*cGlxMediaList2);

    // Check instance is the same

    EUNIT_PRINT(_L("Check instance is the same"));

    EUNIT_ASSERT(cGlxMediaList2 == iCGlxMediaList);

    CleanupStack::PopAndDestroy(cGlxMediaList2);

    CleanupStack::PopAndDestroy(filteredCGlxMediaList2);

    CleanupStack::PopAndDestroy(cGlxMediaList1);

    CleanupStack::PopAndDestroy(differentPath);

    CleanupStack::PopAndDestroy(filteredCGlxMediaList1);

    CleanupStack::PopAndDestroy(existingPath);

    }

void UT_CGlxMediaList::UT_CGlxMediaList_MediaListsL(  )

    {

    // Check media lists array

    EUNIT_PRINT(_L("Check media lists array"));

    RPointerArray<CGlxMediaList>& mediaLists = CGlxMediaList::MediaListsL();

    // Check media lists initial count

    TInt mediaListCount = mediaLists.Count();

    EUNIT_PRINT(_L("Check media lists initial count"));

    EUNIT_ASSERT(mediaListCount == 1);

    // Check media lists initial item

    EUNIT_PRINT(_L("Check media lists initial item"));

    EUNIT_ASSERT(mediaLists[0] == iCGlxMediaList);

    // Obtain instance of media list with different path

    CMPXCollectionPath* differentPath = CMPXCollectionPath::NewL();

    CleanupStack::PushL(differentPath);

    differentPath->AppendL(KTestAlbumCollectionPluginUid);

    differentPath->AppendL(KFavouritesAlbumId);

    EUNIT_PRINT(_L("Obtain instance of media list with different path"));

    CGlxMediaList* cGlxMediaList1 = CGlxMediaList::InstanceL(*differentPath, NULL);

    CleanupClosePushL(*cGlxMediaList1);

    // Check media lists count

    mediaListCount = mediaLists.Count();

    EUNIT_PRINT(_L("Check media lists count"));

    EUNIT_ASSERT(mediaListCount == 2);

    // Check media lists items

    EUNIT_PRINT(_L("Check media lists items"));

    EUNIT_ASSERT((mediaLists[0] == cGlxMediaList1) && (mediaLists[1] == iCGlxMediaList));

    // Obtain instance of media list to existing path

    CMPXCollectionPath* existingPath = CMPXCollectionPath::NewL();

    CleanupStack::PushL(existingPath);

    existingPath->AppendL(KTestCollectionPluginUid);

    existingPath->AppendL(KFavouritesAlbumId);

    EUNIT_PRINT(_L("Obtain instance of media list with existing path"));

    CGlxMediaList* cGlxMediaList2 = CGlxMediaList::InstanceL(*existingPath, NULL);

    CleanupClosePushL(*cGlxMediaList2);

    // Check media lists count

    mediaListCount = mediaLists.Count();

    EUNIT_PRINT(_L("Check media lists count"));

    EUNIT_ASSERT(mediaListCount == 2);

    // Check media lists items

    EUNIT_PRINT(_L("Check media lists items"));

    EUNIT_ASSERT((mediaLists[1] == cGlxMediaList1) && (mediaLists[0] == iCGlxMediaList));

    CleanupStack::PopAndDestroy(cGlxMediaList2);

    CleanupStack::PopAndDestroy(existingPath);

    CleanupStack::PopAndDestroy(cGlxMediaList1);

    CleanupStack::PopAndDestroy(differentPath);

    }

void UT_CGlxMediaList::UT_CGlxMediaList_NewLCL(  )

    {

    EUNIT_ASSERT( EFalse );

    }

void UT_CGlxMediaList::UT_CGlxMediaList_OpenLL(  )

    {

    EUNIT_ASSERT( EFalse );

    }

void UT_CGlxMediaList::UT_CGlxMediaList_AddReferenceL(  )

    {

    EUNIT_ASSERT( EFalse );

    }

void UT_CGlxMediaList::UT_CGlxMediaList_RemoveReferenceL(  )

    {

    EUNIT_ASSERT( EFalse );

    }

void UT_CGlxMediaList::UT_CGlxMediaList_ReferenceCountL(  )

    {

    EUNIT_ASSERT( EFalse );

    }

void UT_CGlxMediaList::UT_CGlxMediaList_EqualsL(  )

    {

    EUNIT_ASSERT( EFalse );

    }

void UT_CGlxMediaList::UT_CGlxMediaList_OfferMediaL(  )

    {

    EUNIT_ASSERT( EFalse );

    }

void UT_CGlxMediaList::UT_CGlxMediaList_HandleAttributesAvailableLL(  )

    {

    EUNIT_ASSERT( EFalse );

    }

void UT_CGlxMediaList::UT_CGlxMediaList_AttributeRequestLL(  )

    {

    EUNIT_ASSERT( EFalse );

    }

void UT_CGlxMediaList::UT_CGlxMediaList_CloseL(  )

    {

    EUNIT_ASSERT( EFalse );

    }

void UT_CGlxMediaList::UT_CGlxMediaList_IdL(  )

    {

    EUNIT_ASSERT( EFalse );

    }

void UT_CGlxMediaList::UT_CGlxMediaList_CountL(  )

    {

    EUNIT_ASSERT( EFalse );

    }

void UT_CGlxMediaList::UT_CGlxMediaList_FocusIndexL(  )

    {

    // Setup test

    SetupFocusTestL();

    // Check focus is index 3

    EUNIT_PRINT(_L("Check focus is index 3"));

    TInt focusIndex = iCGlxMediaList->FocusIndex();

    EUNIT_ASSERT(focusIndex == 3);

    }

void UT_CGlxMediaList::UT_CGlxMediaList_SetFocusLL(  )

    {

    // Setup test

    SetupFocusTestL();

    MoveFocusAbsoluteGreaterThanCurrentFocusL();

    MoveFocusAbsoluteLessThanCurrentFocusL();

    MoveFocusRelativeForwardL();

    MoveFocusRelativeBackwardL();

    MoveFocusRelativeForwardGreaterThanListCountL();

    MoveFocusRelativeBackwardLessThanZeroL();

    }

void UT_CGlxMediaList::UT_CGlxMediaList_ItemL(  )

    {

    EUNIT_ASSERT( EFalse );

    }

void UT_CGlxMediaList::UT_CGlxMediaList_IndexL(  )

    {

    EUNIT_ASSERT( EFalse );

    }

void UT_CGlxMediaList::UT_CGlxMediaList_AddMediaListObserverLL(  )

    {

    EUNIT_ASSERT( EFalse );

    }

void UT_CGlxMediaList::UT_CGlxMediaList_RemoveMediaListObserverL(  )

    {

    EUNIT_ASSERT( EFalse );

    }

void UT_CGlxMediaList::UT_CGlxMediaList_AddContextLL(  )

    {

    EUNIT_ASSERT( EFalse );

    }

void UT_CGlxMediaList::UT_CGlxMediaList_RemoveContextL(  )

    {

    EUNIT_ASSERT( EFalse );

    }

void UT_CGlxMediaList::UT_CGlxMediaList_CollectionL(  )

    {

    EUNIT_ASSERT( EFalse );

    }

void UT_CGlxMediaList::UT_CGlxMediaList_PathLCL(  )

    {

    // Setup test

    SetupPathTestL();

    CMPXCollectionPath* path = iCGlxMediaList->PathLC();

    // Check path has 3 levels

    EUNIT_PRINT(_L("Check path has 3 levels"));

    EUNIT_ASSERT(path->Levels() == 3);

    // Check level 0 is test collection plugin uid

    EUNIT_PRINT(_L("Check level 0 is test collection plugin uid"));

    EUNIT_ASSERT(path->Id(0) == KTestCollectionPluginUid);

    // Check level 1 is favourites album id

    EUNIT_PRINT(_L("Check level 1 is favourites album id"));

    EUNIT_ASSERT(path->Id(1) == KFavouritesAlbumId);

    // Check level 2 is favourites album first item id

    EUNIT_PRINT(_L("Check level 2 is favourites album first item id"));

    EUNIT_ASSERT(path->Id(2) == KFavouritesAlbumFirstItemId);

    // Check path item count

    TInt pathCount = path->Count();

    TInt listCount = iCGlxMediaList->Count();

    EUNIT_PRINT(_L("Check path item count"));

    EUNIT_ASSERT(pathCount == listCount);

    // Check path items

    EUNIT_PRINT(_L("Check path items"));

    for (TInt count = 0; count < pathCount; ++count)

        {

        EUNIT_ASSERT(path->IdOfIndex(count) == TMPXItemId(iCGlxMediaList->Item(count).Id().Value()));

        }

    // Check path selection count

    TArray<TInt> pathSelection = path->Selection();

    TInt pathSelectionCount = pathSelection.Count();

    TInt listSelectionCount = iCGlxMediaList->SelectionCount();

    EUNIT_PRINT(_L("Check path selection count"));

    EUNIT_ASSERT(pathSelectionCount == listSelectionCount);

    // Check path selected items

    EUNIT_PRINT(_L("Check path selected items"));

    for (TInt count = 0; count < pathSelectionCount; ++count)

        {

        EUNIT_ASSERT(pathSelection[count] == iCGlxMediaList->SelectedItemIndex(count));

        }

    // Check focused item

    EUNIT_PRINT(_L("Check focused item"));

    EUNIT_ASSERT(path->Id() == TMPXItemId(iCGlxMediaList->Item(iCGlxMediaList->FocusIndex()).Id().Value()));

    CleanupStack::PopAndDestroy(path);

    }

void UT_CGlxMediaList::UT_CGlxMediaList_IsSelectedL(  )

    {

    // Setup test

    SetupSelectionTestL();

    TBool isSelected = EFalse;

    // Check 2 is selected

    EUNIT_PRINT(_L("Check 2 is selected"));

    isSelected = iCGlxMediaList->IsSelected(2);

    EUNIT_ASSERT(isSelected == ETrue);

    // Check 3 is not selected

    EUNIT_PRINT(_L("Check 3 is not selected"));

    isSelected = iCGlxMediaList->IsSelected(3);

    EUNIT_ASSERT(isSelected == EFalse);

    }

void UT_CGlxMediaList::UT_CGlxMediaList_SetSelectedLL(  )

    {

    // Setup test

    SetupSelectionTestL();

    // Select 1 (insert at beginning)

    EUNIT_PRINT(_L("Select 1"));

    iCGlxMediaList->SetSelectedL(1, ETrue);

    RArray<TInt> selection;

    CleanupClosePushL(selection);

    TInt selectionCount = iCGlxMediaList->SelectionCount();

    for (TInt count = 0; count < selectionCount; ++count)

        {

        selection.AppendL(iCGlxMediaList->SelectedItemIndex(count));

        }

    EUNIT_PRINT(_L("Check 1, 2 and 4 is selected in order"));

    EUNIT_ASSERT(selection.Count() == 3 && selection[0] == 1 && selection[1] == 2 && selection[2] == 4);

    // Select 3 (insert in middle)

    EUNIT_PRINT(_L("Select 3"));

    iCGlxMediaList->SetSelectedL(3, ETrue);

    selection.Reset();

    selectionCount = iCGlxMediaList->SelectionCount();

    for (TInt count = 0; count < selectionCount; ++count)

        {

        selection.AppendL(iCGlxMediaList->SelectedItemIndex(count));