/*
* 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:  CGlxCommandHandlerDRM unit test cases
*
*/




//  CLASS HEADER
#include "t_glxcommandhandlerdrm.h"

//  EXTERNAL INCLUDES
#include <EUnitMacros.h>
#include <EUnitDecorators.h>

#include "glxcommandhandlerdrm.h"
#include "ut_glxdummymedialist.h"

#include <glxcommandhandlers.hrh>

#include <mpxmediadrmdefs.h>
#include <mpxmediageneraldefs.h>
#include <glxmediageneraldefs.h>

#include "glxdummyvlm.h"

#include <Ecom/ECom.h>

//  INTERNAL INCLUDES

CGlxCommandHandlerDRMTester* CGlxCommandHandlerDRMTester::NewL()
    {
    CGlxCommandHandlerDRMTester* self = new(ELeave)CGlxCommandHandlerDRMTester();
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }
    
CGlxCommandHandlerDRMTester::~CGlxCommandHandlerDRMTester()
    {
    iDRMHandler->Deactivate();
    
    iCommandHandlerList.ResetAndDestroy();
	iCommandHandlerList.Close();
	
	delete iMediaList;
    }

TBool CGlxCommandHandlerDRMTester::ExecuteL(TInt aCommand)
    {
    return iCommandHandlerList[0]->ExecuteL( aCommand );
    }
	

MGlxMediaList& CGlxCommandHandlerDRMTester::MediaList()
    {
    return *iMediaList;
    }
    
void CGlxCommandHandlerDRMTester::AddNonProtectedItemL()
    {
	TGlxMediaId testId(KGlxIdNone);
    CGlxMedia* newMedia = new (ELeave) CGlxMedia (testId);
    CleanupStack::PushL(newMedia);
    iMediaList->AppendL(0, newMedia);
	CleanupStack::Pop(newMedia);
    }
	
void CGlxCommandHandlerDRMTester::AddProtectedItemL(TInt aId, CGlxMedia* aMedia)
    {
    iMediaList->AppendL(aId, aMedia);
    }
    
void CGlxCommandHandlerDRMTester::ForceFocusChangeEventL( TInt aFocus )
    {
    iMediaList->SetFocusL( NGlxListDefs::EAbsolute, aFocus );
    
    // issue focus change event to command handler
    iDRMHandler->HandleFocusChangedL( aFocus, 0.0, NULL,
                        NGlxListDefs::EUnknown);
    }
    
void CGlxCommandHandlerDRMTester::ForceHandleAttributeL( TInt aFocus )
    {
    iMediaList->SetFocusL( NGlxListDefs::EAbsolute, aFocus );

    iMediaList->HandleAttributesAvailableL();
    }
	
CGlxCommandHandlerDRMTester::CGlxCommandHandlerDRMTester()
    {
    
    }
    
void CGlxCommandHandlerDRMTester::ConstructL()
    {
    EUNIT_PRINT(_L("CGlxCommandHandlerDRMTester::ConstructL"));
    // create 'dummy' media list
    iMediaList = new (ELeave) _CGlxTestMediaList;
    
    // create our command handler
    iDRMHandler = CGlxCommandHandlerDrm::NewL( this, EFalse );
    
    iCommandHandlerList.AppendL(iDRMHandler);
    
    iDRMHandler->ActivateL(0);
    }


// CONSTRUCTION
T_GlxCommandHandlerDRM* T_GlxCommandHandlerDRM::NewL()
    {
    T_GlxCommandHandlerDRM* self = T_GlxCommandHandlerDRM::NewLC();
    CleanupStack::Pop();

    return self;
    }

T_GlxCommandHandlerDRM* T_GlxCommandHandlerDRM::NewLC()
    {
    T_GlxCommandHandlerDRM* self = new( ELeave ) T_GlxCommandHandlerDRM();
    CleanupStack::PushL( self );

    self->ConstructL();

    return self;
    }

// Destructor (virtual by CBase)
T_GlxCommandHandlerDRM::~T_GlxCommandHandlerDRM()
    {
    }

// Default constructor
T_GlxCommandHandlerDRM::T_GlxCommandHandlerDRM()
    {
    }

// Second phase construct
void T_GlxCommandHandlerDRM::ConstructL()
    {
    // The ConstructL from the base class CEUnitTestSuiteClass must be called.
    // It generates the test case table.
    CEUnitTestSuiteClass::ConstructL();
    
    REComSession::FinalClose();
    }

//  METHODS


void T_GlxCommandHandlerDRM::SetupL(  )
    {
    EUNIT_PRINT(_L("T_GlxCommandHandlerDRM::SetupL"));
    iDRMHandlerTester = CGlxCommandHandlerDRMTester::NewL();
    }
    

void T_GlxCommandHandlerDRM::Teardown(  )
    {
    delete iDRMHandlerTester;
    
    REComSession::FinalClose();
    }
    

void T_GlxCommandHandlerDRM::T_CreateL(  )
    {
    // no implementation
    }
    
void T_GlxCommandHandlerDRM::T_TestEmptyMediaListL()
    {
    TBool exe = iDRMHandlerTester->ExecuteL(EGlxCmdDRMOpen);
    EUNIT_ASSERT_DESC( exe == EFalse, "No items in list not executed ");
    }
        
void T_GlxCommandHandlerDRM::T_TestHandleCommandsL()
    {
    MGlxMediaList& mlist = iDRMHandlerTester->MediaList();
    
    // test with item, no DRM attribute
    iDRMHandlerTester->AddNonProtectedItemL();
    
    TBool exe = iDRMHandlerTester->ExecuteL(EGlxCmdDRMOpen);
    EUNIT_ASSERT_DESC( exe == ETrue, "No DRM attribute ");
    
    // test with item,  DRM attribute set to false
    TGlxMediaId testId(0);
    CGlxMedia* newMedia = new (ELeave) CGlxMedia(testId);
    CleanupStack::PushL(newMedia);
    
    newMedia->SetTObjectValueL(KMPXMediaDrmProtected, EFalse);
   
    iDRMHandlerTester->AddProtectedItemL(0, newMedia);
    
	CleanupStack::Pop(newMedia);
	
	mlist.SetFocusL(NGlxListDefs::EAbsolute, 1);
	
	exe = iDRMHandlerTester->ExecuteL( EGlxCmdDRMOpen );
	EUNIT_ASSERT_DESC( exe == ETrue, "DRM attribute false ");
    
    // test with item,  DRM attribute set to true no URI
    newMedia->SetTObjectValueL(KMPXMediaDrmProtected, ETrue);
	
	exe = iDRMHandlerTester->ExecuteL(EGlxCmdDRMOpen);
	EUNIT_ASSERT_DESC( exe == ETrue, "No URI attribute ");
    
    newMedia->SetTObjectValueL(KMPXMediaDrmProtected, ETrue);
    
    newMedia->SetTextValueL(KMPXMediaGeneralUri, _L("DRM valid"));
   
	// test with item,  DRM attribute set to true no category
	exe = iDRMHandlerTester->ExecuteL(EGlxCmdDRMOpen);
	EUNIT_ASSERT_DESC( exe == ETrue, "No category attribute");
	
    // test with video item,  DRM attribute set to true 
    newMedia->SetTObjectValueL(KMPXMediaDrmProtected, ETrue);
    
    newMedia->SetTextValueL(KMPXMediaGeneralUri, _L("DRM valid"));
    
    newMedia->SetTObjectValueL(KMPXMediaGeneralCategory, EMPXVideo);
	
	exe = iDRMHandlerTester->ExecuteL(EGlxCmdDRMOpen);
	EUNIT_ASSERT_DESC( exe == ETrue, "Video");
	
    // test with iamge item,  DRM attribute set to true no size attr
    newMedia->SetTObjectValueL(KMPXMediaDrmProtected, ETrue);
    
    newMedia->SetTObjectValueL(KMPXMediaGeneralCategory, EMPXImage);
    
    newMedia->SetTextValueL(KMPXMediaGeneralUri, _L("DRM valid"));
   
   
	exe = iDRMHandlerTester->ExecuteL(EGlxCmdDRMOpen);
	EUNIT_ASSERT_DESC( exe == ETrue, "Image");
	
    
    newMedia->SetTObjectValueL(KMPXMediaDrmProtected, ETrue);
    
    newMedia->SetTObjectValueL(KMPXMediaGeneralCategory, EMPXImage);
    
    newMedia->SetTextValueL(KMPXMediaGeneralUri, _L("DRM valid"));
    
    newMedia->SetTObjectValueL(KGlxMediaGeneralDimensions, TSize(100,100));
   
	exe = iDRMHandlerTester->ExecuteL(EGlxCmdDRMOpen);
	EUNIT_ASSERT_DESC( exe == ETrue, "Size");
	
	newMedia->SetTObjectValueL(KGlxMediaGeneralDimensions, TSize(1000,1000));
   
	exe = iDRMHandlerTester->ExecuteL(EGlxCmdDRMOpen);
	EUNIT_ASSERT_DESC( exe == ETrue, "Size");
	
	newMedia->SetTObjectValueL(KMPXMediaDrmProtected, ETrue);
    
    newMedia->SetTObjectValueL(KMPXMediaGeneralCategory, EMPXImage);
    
    newMedia->SetTextValueL(KMPXMediaGeneralUri, _L("DRM invalid"));
    
    newMedia->SetTObjectValueL(KGlxMediaGeneralDimensions, TSize(100,100));
   
	exe = iDRMHandlerTester->ExecuteL(EGlxCmdDRMOpen);
	EUNIT_ASSERT_DESC( exe == ETrue, "Size");
	
	// test non supported commands
	exe = iDRMHandlerTester->ExecuteL(EGlxCmdStateBrowse);
	
	EUNIT_ASSERT_DESC( exe == EFalse, "Execute fullscreen - command not consumed");
	
	exe = iDRMHandlerTester->ExecuteL(EGlxCmdStateView);
	
	EUNIT_ASSERT_DESC( exe == EFalse, "Execute fullscreen - command not consumed");
	
	exe = iDRMHandlerTester->ExecuteL(EGlxCmdSlideshowPlay);
	
	EUNIT_ASSERT_DESC( exe == EFalse, "Execute non supported command - command not consumed");
    }

void T_GlxCommandHandlerDRM::T_TestHandleFocusChangedL()
    {
    TGlxMediaId testId(12346);
    CGlxMedia* newMedia = new (ELeave) CGlxMedia(testId);
    CleanupStack::PushL(newMedia);
    
    newMedia->SetTObjectValueL(KMPXMediaDrmProtected, ETrue);
    
    newMedia->SetTObjectValueL(KMPXMediaGeneralCategory, EMPXImage);
    
    newMedia->SetTextValueL(KMPXMediaGeneralUri, _L("DRM valid"));
    
    newMedia->SetTObjectValueL(KGlxMediaGeneralDimensions, TSize(100,100));
   
    iDRMHandlerTester->AddProtectedItemL(123456, newMedia);
    
	CleanupStack::Pop(newMedia);
	
	TGlxMediaId testId2(12347);
    CGlxMedia* newMedia2 = new (ELeave) CGlxMedia(testId2);
    CleanupStack::PushL(newMedia2);
    
    newMedia2->SetTObjectValueL(KMPXMediaDrmProtected, ETrue);
    
    newMedia2->SetTObjectValueL(KMPXMediaGeneralCategory, EMPXImage);
    
    newMedia2->SetTextValueL(KMPXMediaGeneralUri, _L("DRM valid"));
    
    newMedia2->SetTObjectValueL(KGlxMediaGeneralDimensions, TSize(100,100));
   
    iDRMHandlerTester->AddProtectedItemL(123457, newMedia2);
    
	CleanupStack::Pop(newMedia2);
	
	TBool exe = iDRMHandlerTester->ExecuteL(EGlxCmdDRMOpen);
	EUNIT_ASSERT_DESC( exe == ETrue, "Execute DRM open");
	
	iDRMHandlerTester->ForceFocusChangeEventL(1);
	
	exe = iDRMHandlerTester->ExecuteL(EGlxCmdStateView);
	
	EUNIT_ASSERT_DESC( exe == EFalse, "Execute fullscreen - command not consumed");
	iDRMHandlerTester->ForceFocusChangeEventL(1);
	
	exe = iDRMHandlerTester->ExecuteL(EGlxCmdStateBrowse);
	
	EUNIT_ASSERT_DESC( exe == EFalse, "Execute not fullscreen - command not consumed");
	iDRMHandlerTester->ForceFocusChangeEventL(1);
    }
    
void T_GlxCommandHandlerDRM::T_TestHandleAttributeL()  
    {
    TGlxMediaId testId(12346);
    CGlxMedia* newMedia = new (ELeave) CGlxMedia(testId);
    CleanupStack::PushL(newMedia);
    
    newMedia->SetTObjectValueL(KMPXMediaDrmProtected, ETrue);
    
    newMedia->SetTObjectValueL(KMPXMediaGeneralCategory, EMPXImage);
    
    newMedia->SetTextValueL(KMPXMediaGeneralUri, _L("DRM valid"));
    
    newMedia->SetTObjectValueL(KGlxMediaGeneralDimensions, TSize(100,100));
   
    iDRMHandlerTester->AddProtectedItemL(123456, newMedia);
    
	CleanupStack::Pop(newMedia);
	
	TGlxMediaId testId2(12347);
    CGlxMedia* newMedia2 = new (ELeave) CGlxMedia(testId2);
    CleanupStack::PushL(newMedia2);
    
    newMedia2->SetTObjectValueL(KMPXMediaDrmProtected, ETrue);
    
    newMedia2->SetTObjectValueL(KMPXMediaGeneralCategory, EMPXImage);
    
    newMedia2->SetTextValueL(KMPXMediaGeneralUri, _L("DRM valid"));
    
    newMedia2->SetTObjectValueL(KGlxMediaGeneralDimensions, TSize(100,100));
   
    iDRMHandlerTester->AddProtectedItemL(123457, newMedia2);
    
	CleanupStack::Pop(newMedia2);
	
	iDRMHandlerTester->ForceHandleAttributeL( 1 );
	
	TBool exe = iDRMHandlerTester->ExecuteL(EGlxCmdStateView);
	
	EUNIT_ASSERT_DESC( exe == EFalse, "Execute fullscreen");
	
	iDRMHandlerTester->ForceHandleAttributeL( 1 );
    }

//  TEST TABLE
EUNIT_BEGIN_TEST_TABLE(
    T_GlxCommandHandlerDRM,
    "Add test suite description here.",
    "UNIT" )
   
EUNIT_TEST(
    "T_CreateL",
    "Create DRM command handler",
    "T_CreateL",
    "FUNCTIONALITY",
    SetupL, T_CreateL, Teardown)

EUNIT_TEST(
    "T_Test1L",
    "Test with empty media list",
    "T_Test1L",
    "FUNCTIONALITY",
    SetupL, T_TestEmptyMediaListL, Teardown)
    
EUNIT_TEST(
    "T_Test2",
    "Test command functionality",
    "T_Test2L",
    "FUNCTIONALITY",
    SetupL, T_TestHandleCommandsL, Teardown)
    
EUNIT_TEST(
    "T_Test3",
    "Test response to HandleFocusChangedL",
    "T_Test3L",
    "FUNCTIONALITY",
    SetupL, T_TestHandleFocusChangedL, Teardown)
    
EUNIT_TEST(
    "T_Test4",
    "Test response to HandleAttributesAvailableL",
    "T_Test4L",
    "FUNCTIONALITY",
    SetupL, T_TestHandleAttributeL, Teardown)
  
EUNIT_END_TEST_TABLE

//  END OF FILE