/*

* Copyright (c) 2006 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:  CommandHandlerShowViaUPnP unit test cases

*

*/

//  CLASS HEADER

#include "t_cglxcommandhandlershowviaupnp.h"

//  EXTERNAL INCLUDES

#include <digia/eunit/eunitmacros.h>

#include <digia/eunit/eunitdecorators.h>

#include <glxcommandhandlers.hrh>

#include <mglxmedialist.h>

#include <upnpshowcommand.h>

//  INTERNAL INCLUDES

#include "glxupnprenderer.h" 

class _CGlxTestMediaList: public CBase, public MGlxMediaList

    {

public:

    ~_CGlxTestMediaList() 

        {

        iItems.Close();

        iMedia.ResetAndDestroy();

        iSelectedItems.Close();

        }

    virtual void Close() 

        {

        };

    virtual TGlxMediaListId Id() const 

        {

        return KGlxIdNone;

        }

    virtual TInt Count(NGlxListDefs::TCountType /*aType*/) const 

        {

        return iItems.Count();

        }

    virtual TInt FocusIndex() const 

        {

        return iFocusIndex;

        }

    virtual void SetFocusL(NGlxListDefs::TFocusSetType /*aType*/, TInt aValue) 

        {

        iFocusIndex = aValue;

        }

    virtual const TGlxMedia& Item(TInt aIndex) const 

        {

        return iItems[aIndex];

        }

    virtual TInt Index(const TGlxIdSpaceId& /* aIdSpaceId */, const TGlxMediaId& aId) const 

        {

        TInt count = iItems.Count();

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

            {

            if (iItems[i].Id() == aId)

                {

                return i;

                }

            }

        return KErrNotFound;

        }

    virtual void AddMediaListObserverL(MGlxMediaListObserver* /*aObserver*/) 

        {

        }

    virtual void RemoveMediaListObserver(MGlxMediaListObserver* /*aObserver*/) 

        {

        }

    virtual void AddContextL(const MGlxFetchContext* /*aContext*/, TInt /*aPriority*/) 

        {

        }

    virtual void RemoveContext(const MGlxFetchContext* /*aContext*/) 

        {

        }

    virtual MMPXCollection& Collection() const 

        {

        // we know that this method is not called in our tests, this is just to make the code compile

        MMPXCollection* empty = NULL;

        return *empty;

        }

    virtual TBool IsSelected(TInt aIndex) const 

        {

        TInt idx = iSelectedItems.Find(aIndex);

        return (idx != KErrNotFound);

        }

    virtual void SetSelectedL(TInt aIndex, TBool aSelected) 

        {

        if (aSelected)

            {

            iSelectedItems.InsertInOrder(aIndex);

            }

        else 

            {

            iSelectedItems.Remove(iSelectedItems.Find(aIndex));

            }

        }

    virtual const TArray<TInt> Selection() const 

        {

        return iSelectedItems.Array();

        }

    virtual void CommandL(CMPXCommand& /*aCommand*/) 

        {

        }

    virtual void CancelCommand() 

        {

        }

    virtual void SetFilterL(CMPXFilter* /*aFilter*/) 

        {

        }

    virtual CMPXFilter* Filter() const 

        {

        return NULL;

        }

    virtual TGlxIdSpaceId IdSpaceId(TInt /*aIndex*/) const 

        {

        return KGlxIdNone;

        }

    void AppendL(TInt aId, TBool aCreateMedia) 

        {

        if (aCreateMedia) 

            {

            CGlxMedia* media = new (ELeave) CGlxMedia(TGlxMediaId(aId));

            CleanupStack::PushL(media);

            iMedia.AppendL(media);

            CleanupStack::Pop(media);

            iItems.AppendL(TGlxMedia(TGlxMediaId(aId), media));

            }

        else 

            {

            iItems.AppendL(TGlxMedia(TGlxMediaId(aId)));

            }

        }

    CGlxMedia* MediaObj(TInt aIndex) const 

        {

        return const_cast<CGlxMedia*>(static_cast<const CGlxMedia*>(iItems[aIndex].Properties()));

        }

    CMPXCollectionPath* PathLC(NGlxListDefs::TPathType /*aType*/) const

        {

        return NULL;

        }

    TInt SelectionCount() const

        {

        return iSelectedItems.Count();

        }

    TInt SelectedItemIndex(TInt /*aSelectionIndex*/) const

        {

        return 0;

        }

    TBool IsPopulated() const

        {

        return ETrue;

        }

    void AddStaticItemL( CGlxMedia* /*aStaticItem*/,

        NGlxListDefs::TInsertionPosition /*aTargetPosition*/ ) {};

    void RemoveStaticItem(const TGlxMediaId& /*aItemId*/) {};

    void SetStaticItemsEnabled( TBool aEnabled ) { iStaticItemsEnabled = aEnabled; };

    TBool IsStaticItemsEnabled() const { return iStaticItemsEnabled; };

    void SetFocusInitialPosition(NGlxListDefs::TFocusInitialPosition aFocusInitialPosition){};

    void ResetFocus(){};        

    void SetVisibleWindowIndexL( TInt aIndex ){};

    TInt VisibleWindowIndex() const {};

    virtual void CancelPreviousRequests() {};

    RArray<TGlxMedia> iItems;

    RPointerArray<CGlxMedia> iMedia;

    RArray<TInt> iSelectedItems;

    TInt iFocusIndex;

    TBool iStaticItemsEnabled;

    };

// CONSTRUCTION

t_cglxcommandhandlershowviaupnp* t_cglxcommandhandlershowviaupnp::NewL()

    {

    t_cglxcommandhandlershowviaupnp* self = t_cglxcommandhandlershowviaupnp::NewLC();

    CleanupStack::Pop();

    return self;

    }

t_cglxcommandhandlershowviaupnp* t_cglxcommandhandlershowviaupnp::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor (virtual by CBase)

t_cglxcommandhandlershowviaupnp::~t_cglxcommandhandlershowviaupnp()

    {

    }

// Default constructor

t_cglxcommandhandlershowviaupnp::t_cglxcommandhandlershowviaupnp()

    {

    }

// Second phase construct

void t_cglxcommandhandlershowviaupnp::ConstructL()

    {

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

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

//Create the media List

MGlxMediaList& t_cglxcommandhandlershowviaupnp::MediaList()

    {

#if 0

    EUNIT_PRINT(_L("Entering  MediaList"));

    CMPXCollectionPath* path = CMPXCollectionPath :: NewL();

    CleanupStack::PushL(path);      

    EUNIT_PRINT(_L("MediaList :: MPXCollectionPath created"));

    iList = MGlxMediaList::InstanceL(*path,TGlxHierarchyId(NULL),NULL);

    EUNIT_PRINT(_L("Exiting  MediaList"));

    CleanupStack::PopAndDestroy(path);         

    return *iList;

#endif

    }

//  METHODS

//Test the NewL() without medialist

void t_cglxcommandhandlershowviaupnp::SetupL(  )

    {          

    iCommandShowUpnp = CGlxCommandHandlerShowViaUpnp :: NewL(NULL, EFalse);

    }

//  Medialist created 

void t_cglxcommandhandlershowviaupnp::SetupL1(  )

    { 

    //create the medialist

  //  MediaList();  

    iList = new (ELeave) _CGlxTestMediaList;

    EUNIT_PRINT(_L("SetupL1 :: created Medialist"));

    iCommandShowUpnp = CGlxCommandHandlerShowViaUpnp :: NewL(this, EFalse);

    EUNIT_PRINT(_L("Exiting  SetupL1"));

    }

//Test DoIsDisabled

//Command Id ShowViaUpnp

void t_cglxcommandhandlershowviaupnp::T_DoIsDisabled_Show()

    {       

    TBool result =  ETrue;                                   

    EUNIT_ASSERT_EQUALS(result,(iCommandShowUpnp->DoIsDisabled(EGlxShowViaUpnp,*iList)));                                        

    }

//Command Id StopShowing

void t_cglxcommandhandlershowviaupnp::T_DoIsDisabled_Stop()

    {

    TBool result =  ETrue;   

    EUNIT_ASSERT_EQUALS(result,(iCommandShowUpnp->DoIsDisabled(EGlxStopShowing,*iList)));  

    }

//Command Id Null

void t_cglxcommandhandlershowviaupnp::T_DoIsDisabled_NULL()

    {

    TBool result =  ETrue;   

    EUNIT_ASSERT_EQUALS(result,(iCommandShowUpnp->DoIsDisabled(NULL,*iList)));  

    }

//Command Id Invalid 

void t_cglxcommandhandlershowviaupnp::T_DoIsDisabled_Invalid()

    {

    TBool result =  ETrue;   

    EUNIT_ASSERT_EQUALS(result,(iCommandShowUpnp->DoIsDisabled(100,*iList)));  

    }

//Show Command Available

//Command Id ShowViaUpnp

void t_cglxcommandhandlershowviaupnp::T_DoIsDisabled_Show_Available()

    { 

    EUNIT_PRINT(_L("Entering  T_DoIsDisabled_Show_Available"));

    TBool result =  ETrue;                                   

    CUpnpShowCommand::SetUpIsAvailable(ETrue);

    EUNIT_ASSERT_EQUALS(result,(iCommandShowUpnp->DoIsDisabled(EGlxShowViaUpnp,*iList)));                                        

    }

//Command Id StopShowing

void t_cglxcommandhandlershowviaupnp::T_DoIsDisabled_Stop_Available()

    {

    TBool result =  EFalse;     

    CUpnpShowCommand::SetUpIsAvailable(ETrue);

    GlxUpnpRenderer::StartShowingL();

    EUNIT_ASSERT_EQUALS(result,(iCommandShowUpnp->DoIsDisabled(EGlxStopShowing,*iList)));  

    GlxUpnpRenderer::StopShowingL();    

    }

//Command Id Null

void t_cglxcommandhandlershowviaupnp::T_DoIsDisabled_NULL_Available()

    {

    TBool result =  ETrue; 

    CUpnpShowCommand::SetUpIsAvailable(ETrue);

    EUNIT_ASSERT_EQUALS(result,(iCommandShowUpnp->DoIsDisabled(NULL,*iList)));  

    }

//Command Id Invalid 

void t_cglxcommandhandlershowviaupnp::T_DoIsDisabled_Invalid_Available()

    {

    TBool result =  ETrue;   

    CUpnpShowCommand::SetUpIsAvailable(ETrue);

    EUNIT_ASSERT_EQUALS(result,(iCommandShowUpnp->DoIsDisabled(100,*iList)));  

    }

//Test DoExecuteL

//Command Id start

void t_cglxcommandhandlershowviaupnp::T_DoExecuteL_Show()

    {

    TBool result =  ETrue;    

    EUNIT_ASSERT_EQUALS(result,(iCommandShowUpnp->DoExecuteL(EGlxShowViaUpnp,*iList))); 

    GlxUpnpRenderer::StopShowingL();                             

    }

//Command Id Stop

void t_cglxcommandhandlershowviaupnp::T_DoExecuteL_Stop()

    {

    GlxUpnpRenderer::StartShowingL();

    TBool result =  ETrue;  

    EUNIT_ASSERT_EQUALS(result,(iCommandShowUpnp->DoExecuteL(EGlxStopShowing,*iList)));            

    }

//Command Id NUll - return EFalse command should not be handled

void t_cglxcommandhandlershowviaupnp::T_DoExecuteL_NULL()

    {

    TBool result =  EFalse;  

    EUNIT_ASSERT_EQUALS(result,(iCommandShowUpnp->DoExecuteL(NULL,*iList)));

    }

//Command Id Invalid -return EFalse command should not be handled

void t_cglxcommandhandlershowviaupnp::T_DoExecuteL_Invalid()

    {

    TBool result =  EFalse;  

    EUNIT_ASSERT_EQUALS(result,(iCommandShowUpnp->DoExecuteL(100,*iList)));

    }

//Tear down

void t_cglxcommandhandlershowviaupnp::Teardown(  )

    {

    EUNIT_PRINT(_L("before teardown"));

    if(iCommandShowUpnp)

        {

        delete iCommandShowUpnp;                  

        }    

    if(iList)   

        {

        EUNIT_PRINT(_L("before closing list"));

        delete iList;

        iList = NULL;

        }   

    EUNIT_PRINT(_L("After teardown"));        

    }

//Check the creation

void t_cglxcommandhandlershowviaupnp::T_CGlxCommandHandlerShowViaUpnpL(  )

    {

    EUNIT_ASSERT_DESC( iCommandShowUpnp, "Creation Failed");

    }

//  TEST TABLE

EUNIT_BEGIN_TEST_TABLE(

    t_cglxcommandhandlershowviaupnp,

    "Add test suite description here.",

    "UNIT" )

//Set up function without Media List

EUNIT_TEST(

    "Create-nomedialist",

    "CGlxCommandHandlerShowViaUpnp",

    "NewL",

    "UNIT",

    SetupL, T_CGlxCommandHandlerShowViaUpnpL, Teardown)

//Set up function without Media List

EUNIT_TEST(

    "Create-medialist",

    "CGlxCommandHandlerShowViaUpnp",

    "NewL-medialist",

    "UNIT",

    SetupL1, T_CGlxCommandHandlerShowViaUpnpL, Teardown)

//DoIsDisable the command handler with UpnpShowCommand Not available

EUNIT_TEST(

    "Create1",

    "CGlxCommandHandlerShowViaUpnp",

    "Disable_show_NotAvailable",

    "UNIT",

    SetupL, T_DoIsDisabled_Show, Teardown)

EUNIT_TEST(

    "Create2",

    "CGlxCommandHandlerShowViaUpnp",

    "Disable_stop_NotAvailable",

    "UNIT",

    SetupL, T_DoIsDisabled_Stop, Teardown)

EUNIT_TEST(

    "Create3",

    "CGlxCommandHandlerShowViaUpnp",

    "Disable_Null_NotAvailable",

    "UNIT",

    SetupL, T_DoIsDisabled_NULL, Teardown)

EUNIT_TEST(

    "Create4",

    "CGlxCommandHandlerShowViaUpnp",

    "Disable_Invalid_NotAvailable",

    "UNIT",

    SetupL, T_DoIsDisabled_Invalid, Teardown)

//Disabling the command handler with UpnpShowCommand Available

/*EUNIT_TEST(

    "Create5",

    "CGlxCommandHandlerShowViaUpnp",

    "Disable_stop_Available",

    "UNIT",

    SetupL1, T_DoIsDisabled_Show_Available, Teardown)*/

EUNIT_TEST(

    "Create6",

    "CGlxCommandHandlerShowViaUpnp",

    "Disable_Null_Available",

    "UNIT",

    SetupL1, T_DoIsDisabled_NULL_Available, Teardown)

EUNIT_TEST(

    "Create7",

    "CGlxCommandHandlerShowViaUpnp",

    "Disable_Invalid_Available",

    "UNIT",

    SetupL1, T_DoIsDisabled_Invalid_Available, Teardown) 

/*EUNIT_TEST(

    "Create8",

    "CGlxCommandHandlerShowViaUpnp",

    "Disable_show_NotAvailable",

    "UNIT",

    SetupL1, T_DoIsDisabled_Stop_Available, Teardown)

//DoExecuteL with with UpnpShowCommand Not available

EUNIT_TEST(

    "Create9",

    "CGlxCommandHandlerShowViaUpnp",

    "Execute_Show",

    "UNIT",

    SetupL1, T_DoExecuteL_Show, Teardown)

EUNIT_TEST(