/*

* Copyright (c) 2002 - 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:  DRMCommonTest hard coded test cases

*

*/

// INCLUDE FILES

#include <f32file.h>

#include <apmstd.h>

#include <drmcommon.h>

#include "drmcommontest.h"

#include "drmrightsclient.h"

#include "drmpermission.h"

#include "drmrights.h"

#include "drmrightsparser.h"

#include "drmpointerarray.h"

// CONSTANTS

#ifdef __WINSCW__

_LIT( KTempFile, "c:\\temp.tmp" );

_LIT( KOma1Content, "c:\\content.dcf" );

#else

_LIT( KTempFile, "e:\\testing\\data\\drm\\temp.tmp" );

_LIT( KOma1Content, "e:\\testing\\data\\drm\\content.dcf" );

#endif

_LIT8( KOma1ContentID, "cid:testcontent20090526095637-2657230746@testcontent.com" );

_LIT8( KOma1ContentMime, "image/jpeg" );

_LIT8( KROHeadOMA1, "<?xml version=\"1.0\" encoding=\"utf-8\"?>\

<!DOCTYPE o-ex:rights PUBLIC \"-//OMA//DTD DRMREL 1.0//EN\" \

\"http://www.oma.org/dtd/dr\">\

<o-ex:rights\

   xmlns:o-ex=\"http://odrl.net/1.1/ODRL-EX\" \

   xmlns:o-dd=\"http://odrl.net/1.1/ODRL-DD\" \

   xmlns:oma-dd=\"http://www.openmobilealliance.com/oma-dd\" \

   xmlns:ds=\"http://www.w3.org/2000/09/xmldsig#/\">\

  <o-ex:context>\

    <o-dd:version>1.0</o-dd:version>\

  </o-ex:context>\

  <o-ex:agreement>\

    <o-ex:asset>\

      <o-ex:context>\

        <o-dd:uid>" );

_LIT8( KROTailFullOMA1, "</o-dd:uid>\

      </o-ex:context>\

      <ds:KeyInfo><ds:KeyValue>PgIkd7w3E5TWWcc7Inp8Yw==</ds:KeyValue></ds:KeyInfo>\

    </o-ex:asset>\

  <o-ex:permission>\

\

<o-dd:play>\

      <o-ex:constraint>\

      </o-ex:constraint>\

    </o-dd:play>\

\

<o-dd:display>\

      <o-ex:constraint>\

      </o-ex:constraint>\

    </o-dd:display>\

\

<o-dd:execute>\

      <o-ex:constraint>\

      </o-ex:constraint>\

    </o-dd:execute>\

\

<o-dd:print>\

      <o-ex:constraint>\

      </o-ex:constraint>\

    </o-dd:print>\

  </o-ex:permission>\

  </o-ex:agreement>\

</o-ex:rights>" );

_LIT8( KContentName, "Content-Name" );

_LIT8( KNewName, "New Name" );

_LIT( KRunning, "Running" );

_LIT( KFinished, "Finished" );

_LIT( KPassed, "Passed" );

// LOCAL FUNCTION PROTOTYPES

LOCAL_C void DoResetDestroyAndClose( TAny* aPtr );

LOCAL_C void DoResetDestroyAndClose2( TAny* aPtr );

LOCAL_C void ReadFileL( RFs& aFs, const TDesC& aName, HBufC8*& aContent );

LOCAL_C void WriteFileL( RFs& aFs, const TDesC& aName, HBufC8*& aContent );

LOCAL_C void DeleteRODBL( );

LOCAL_C TUint32 AddROL( const TDesC8& aHead, const TDesC8& aCID, const TDesC8& aTail );

//LOCAL_C void ConsumeRoL( const TInt aIntent, const TDesC8& aContentID, const TInt seconds );

// ============================= LOCAL FUNCTIONS ===============================

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

// DoResetDestroyAndClose

// Does ResetAndDestroy() to given RPointerArray< CDRMRights >

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

LOCAL_C void DoResetDestroyAndClose( TAny* aPtr )

    {

    ( reinterpret_cast<RPointerArray<CDRMRights>*>( aPtr ) )->ResetAndDestroy();

    ( reinterpret_cast<RPointerArray<CDRMRights>*>( aPtr ) )->Close();

    }

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

// DoResetDestroy2

// Does ResetAndDestroy() to given RPointerArray< CDRMRights >

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

LOCAL_C void DoResetDestroyAndClose2( TAny* aPtr )

    {

    reinterpret_cast<RPointerArray<HBufC8>*>( aPtr )->ResetAndDestroy();

    reinterpret_cast<RPointerArray<HBufC8>*>( aPtr )->Close();

    }

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

// ReadFileL

// Helper function with which test cases can read file to the buffer

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

//

LOCAL_C void ReadFileL( RFs& aFs, const TDesC& aName, HBufC8*& aContent )

	{	

	RFile file;

	TInt size( 0 );

	User::LeaveIfError( file.Open ( aFs, aName, EFileRead ) );

	CleanupClosePushL( file );

	User::LeaveIfError( file.Size( size ) );

	aContent = HBufC8::NewLC( size );

	TPtr8 ptr( aContent->Des() );

	User::LeaveIfError( file.Read( 0, ptr, size ) );

	CleanupStack::Pop( aContent ); //aContent

	CleanupStack::PopAndDestroy( &file ); //file

	}

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

// WriteFileL

// Helper function with which test cases can write buffer to the file

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

//

LOCAL_C void WriteFileL( RFs& aFs, const TDesC& aName, HBufC8*& aContent )

	{	

	RFile file;

    User::LeaveIfError( file.Replace( aFs, aName, EFileWrite | EFileShareReadersOrWriters  ) );

    CleanupClosePushL( file );

    User::LeaveIfError( file.Write( *aContent ) );

    CleanupStack::PopAndDestroy( &file );

	}

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

// DeleteRODBL

// Helper function with which test cases can delete RO DB

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

//

LOCAL_C void DeleteRODBL( )

    {

	RDRMRightsClient client;

    User::LeaveIfError( client.Connect() );

    client.DeleteAll();

    client.Close();

    }

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

// AddROL

// Helper function with which test cases can add ROs

// Returns local id of added RO

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

//

LOCAL_C TUint32 AddROL(

    const TDesC8& aHead,

    const TDesC8& aCID, 

    const TDesC8& aTail

    )

    {

	TInt roSize( aHead.Size() + aCID.Size() + aTail.Size() );

    HBufC8* buf( HBufC8::NewLC( roSize ) );

    TPtr8 tmp( buf->Des() );

    tmp.Append( aHead );

    tmp.Append( aCID );

    tmp.Append( aTail );

    CDRMPointerArray<CDRMRights>* rights( CDRMPointerArray<CDRMRights>::NewLC() );

    rights->SetAutoCleanup( ETrue );

    CDrmRightsParser* rp( CDrmRightsParser::NewL() );

    CleanupStack::PushL( rp );

    rp->ParseAndStoreL( *buf, *rights );

    TUint32 localId( rights[0][0]->GetLocalID() );

    CleanupStack::PopAndDestroy( 3, buf ); //rp, rights, buf

    return localId;

	}

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

// ConsumeRoL

// Helper function which consumes content´s rights

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

//

/*LOCAL_C void ConsumeRoL( 

    const TInt aIntent, 

    const TDesC8& aContentID, 

    const TInt seconds )

    {

	RDRMRightsClient client;

    User::LeaveIfError( client.Connect() );

    client.Consume( aIntent, aContentID );

    User::After( seconds*1000*1000 ); // seconds

    client.Close();

    }*/

// ============================ MEMBER FUNCTIONS ===============================

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

// CDRMCommonTest::Case

// Returns a test case by number.

//

// This function contains an array of all available test cases 

// i.e pair of case name and test function. If case specified by parameter

// aCaseNumber is found from array, then that item is returned.

// 

// The reason for this rather complicated function is to specify all the

// test cases only in one place. It is not necessary to understand how

// function pointers to class member functions works when adding new test

// cases. See function body for instructions how to add new test case.

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

//

const TCaseInfo CDRMCommonTest::Case ( 

    const TInt aCaseNumber ) const 

     {

    /**

    * To add new test cases, implement new test case function and add new 

    * line to KCases array specify the name of the case and the function 

    * doing the test case

    * In practice, do following

    * 1) Make copy of existing test case function and change its name

    *    and functionality. Note that the function must be added to 

    *    DRMCommonTest.cpp file and to DRMCommonTest.h 

    *    header file.

    *

    * 2) Add entry to following KCases array either by using:

    *

    * 2.1: FUNCENTRY or ENTRY macro

    * ENTRY macro takes two parameters: test case name and test case 

    * function name.

    *

    * FUNCENTRY macro takes only test case function name as a parameter and

    * uses that as a test case name and test case function name.

    *

    * Or

    *

    * 2.2: OOM_FUNCENTRY or OOM_ENTRY macro. Note that these macros are used

    * only with OOM (Out-Of-Memory) testing!

    *

    * OOM_ENTRY macro takes five parameters: test case name, test case 

    * function name, TBool which specifies is method supposed to be run using

    * OOM conditions, TInt value for first heap memory allocation failure and 

    * TInt value for last heap memory allocation failure.

    * 

    * OOM_FUNCENTRY macro takes test case function name as a parameter and uses

    * that as a test case name, TBool which specifies is method supposed to be

    * run using OOM conditions, TInt value for first heap memory allocation 

    * failure and TInt value for last heap memory allocation failure. 

    */ 

    static TCaseInfoInternal const KCases[] =

        {

        // To add new test cases, add new items to this array

        // NOTE: When compiled to GCCE, there must be Classname::

        // declaration in front of the method name, e.g. 

        // CDRMCommonTest::PrintTest. Otherwise the compiler

        // gives errors.

        ENTRY( "Com::ConstructTestL", CDRMCommonTest::ConstructTestL ),

        ENTRY( "Com::VersionTestL", CDRMCommonTest::VersionTestL ),

        ENTRY( "Com::ConnectionTestL", CDRMCommonTest::ConnectionTestL ),

        ENTRY( "Com::CheckContentRightsTestL", CDRMCommonTest::CheckContentRightsTestL ),

        ENTRY( "Com::CheckFileRightsTestForFileNameL", CDRMCommonTest::CheckFileRightsTestForFileNameL ),

        ENTRY( "Com::CheckFileRightsTestForFileHandleL", CDRMCommonTest::CheckFileRightsTestForFileHandleL ),

        ENTRY( "Com::IsProtectedContentTestL", CDRMCommonTest::IsProtectedContentTestL ),

        ENTRY( "Com::IsProtectedFileTestForFileNameL", CDRMCommonTest::IsProtectedFileTestForFileNameL ),

        ENTRY( "Com::IsProtectedFileTestForFileHandleL", CDRMCommonTest::IsProtectedFileTestForFileHandleL ),

        ENTRY( "Com::GetContentInfoTestL", CDRMCommonTest::GetContentInfoTestL ),

        ENTRY( "Com::GetFileInfoTestForFileNameL", CDRMCommonTest::GetFileInfoTestForFileNameL ),

        ENTRY( "Com::GetFileInfoTestForFileHandleL", CDRMCommonTest::GetFileInfoTestForFileHandleL ),

        ENTRY( "Com::GetContentHeaderTestL", CDRMCommonTest::GetContentHeaderTestL ),

        ENTRY( "Com::GetFileHeaderTestForFileNameL", CDRMCommonTest::GetFileHeaderTestForFileNameL ),

        ENTRY( "Com::GetFileHeaderTestForFileHandleL", CDRMCommonTest::GetFileHeaderTestForFileHandleL ),

        ENTRY( "Com::SetContentHeaderTestL", CDRMCommonTest::SetContentHeaderTestL ),

        ENTRY( "Com::SetFileHeaderTestForFileNameL", CDRMCommonTest::SetFileHeaderTestForFileNameL ),

        ENTRY( "Com::SetFileHeaderTestForFileHandleL", CDRMCommonTest::SetFileHeaderTestForFileHandleL ),

        ENTRY( "Com::GetSingleRightsObjectTestL", CDRMCommonTest::GetSingleRightsObjectTestL ),

        ENTRY( "Com::GetDetailedContentRightsTestL", CDRMCommonTest::GetDetailedContentRightsTestL ),

        ENTRY( "Com::GetDetailedFileRightsTestForFileNameL", CDRMCommonTest::GetDetailedFileRightsTestForFileNameL ),

        ENTRY( "Com::GetDetailedFileRightsTestForFileHandleL", CDRMCommonTest::GetDetailedFileRightsTestForFileHandleL ),

        ENTRY( "Com::GetActiveRightsTestL", CDRMCommonTest::GetActiveRightsTestL ),

        ENTRY( "Com::GetContentURIListTestL", CDRMCommonTest::GetContentURIListTestL ),

        ENTRY( "Com::DataTypesTestL", CDRMCommonTest::DataTypesTestL ),

        ENTRY( "Com::MergeParentAndChildTestL", CDRMCommonTest::MergeParentAndChildTestL ),

        };

    // Verify that case number is valid

    if( (TUint) aCaseNumber >= sizeof( KCases ) / 

                               sizeof( TCaseInfoInternal ) )

        {

        // Invalid case, construct empty object

        TCaseInfo null( (const TText*) L"" );

        null.iMethod = NULL;

        null.iIsOOMTest = EFalse;

        null.iFirstMemoryAllocation = 0;

        null.iLastMemoryAllocation = 0;

        return null;

        } 

    // Construct TCaseInfo object and return it

    TCaseInfo tmp ( KCases[ aCaseNumber ].iCaseName );

    tmp.iMethod = KCases[ aCaseNumber ].iMethod;

    tmp.iIsOOMTest = KCases[ aCaseNumber ].iIsOOMTest;

    tmp.iFirstMemoryAllocation = KCases[ aCaseNumber ].iFirstMemoryAllocation;

    tmp.iLastMemoryAllocation = KCases[ aCaseNumber ].iLastMemoryAllocation;

    return tmp;

    }

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

// CDRMCommonTest::ConstructTestL

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

//

TInt CDRMCommonTest::ConstructTestL( 

    TTestResult& aResult )

    {

    _LIT( KData, "CDRMCommonTest::ConstructTestL" );

    TestModuleIf().Printf( 0, KRunning, KData );

    iLog->Log( KData );

    // Test Cases

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

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

    _LIT( KTestCase1, "TestCase1: Testing NewL of DrmCommon: Expecting functional DRMCommon" );

    iLog->Log( KTestCase1 );

    DRMCommon* common = DRMCommon::NewL();

    TL( common );

    delete common;

    //Passed

    iLog->Log( KPassed );

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

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

    // Test Cases End 

    TestModuleIf().Printf( 0, KFinished, KData);

    //Test case passed

    _LIT( KDescription, "CDRMCommonTest::ConstructTestL passed" );

    iLog->Log( KDescription );

    aResult.SetResult( KErrNone, KDescription );

    //Case was executed

    return KErrNone;

    }

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

// CDRMCommonTest::VersionTestL

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

//

TInt CDRMCommonTest::VersionTestL( 

    TTestResult& aResult )

    {

    _LIT( KData, "CDRMCommonTest::VersionTestL" );

    TestModuleIf().Printf( 0, KRunning, KData );

    iLog->Log( KData );

    TVersion version;

    // Test Cases

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

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

    _LIT( KTestCase1, "TestCase1: Trying to get Version of DrmCommon: Expecting version name" );

    iLog->Log( KTestCase1 );

    version = DRMCommon::Version();

    TL( version.Name() != KNullDesC );

    //Passed

    iLog->Log( KPassed );

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

    _LIT( KTestCase2, "TestCase2: Trying to get ServerVersion of DrmCommon: Expecting version name" );

    iLog->Log( KTestCase2 );

    version = DRMCommon::ServerVersion();

    TL( version.Name() != KNullDesC );

    //Passed

    iLog->Log( KPassed );

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

    _LIT( KTestCase3, "TestCase2: Trying to check supported drm methods: Expecting 15, EOMA_2_0, DRMCommon::EOk" );

    iLog->Log( KTestCase3 );

    DRMCommon* common( DRMCommon::NewL() );

    CleanupStack::PushL( common );

    TInt drmMethod( 0 );

    DRMCommon::TOMALevel omaLevel( DRMCommon::EOMA_None );

    TInt ret( KErrNone );

    ret = common->SupportedDRMMethods( drmMethod, omaLevel);

    T1L( ret, DRMCommon::EOk );

    T1L( drmMethod, 15 );

    T1L( omaLevel, DRMCommon::EOMA_2_0 );

    //Passed

    CleanupStack::PopAndDestroy( common );

    iLog->Log( KPassed );

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

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

    // Test Cases End 

    TestModuleIf().Printf( 0, KFinished, KData);

    //Test case passed

    _LIT( KDescription, "CDRMCommonTest::VersionTestL passed" );

    iLog->Log( KDescription );

    aResult.SetResult( KErrNone, KDescription );

    //Case was executed

    return KErrNone;

    }

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

// CDRMCommonTest::ConnectionTestL

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

//

TInt CDRMCommonTest::ConnectionTestL( 

    TTestResult& aResult )

    {

    _LIT( KData, "CDRMCommonTest::ConnectionTestL" );

    TestModuleIf().Printf( 0, KRunning, KData );

    iLog->Log( KData );

    DRMCommon* common( DRMCommon::NewL() );

    CleanupStack::PushL( common );

    TInt ret( DRMCommon::EOk );

    // Test Cases

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

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

    _LIT( KTestCase1, "TestCase1: Testing Connect of DrmCommon: Expecting DRMCommon::EOk" );

    iLog->Log( KTestCase1 );

    ret = common->Connect();

    T1L( ret, DRMCommon::EOk );

    //Passed

    iLog->Log( KPassed );

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

    _LIT( KTestCase2, "TestCase2: Testing Disconnect of DrmCommon: Expecting DRMCommon::EOk" );

    iLog->Log( KTestCase2 );

    ret = common->Disconnect();

    T1L( ret, DRMCommon::EOk );

    //Passed

    iLog->Log( KPassed );

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

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

    // Test Cases End 

    CleanupStack::PopAndDestroy( common );

    TestModuleIf().Printf( 0, KFinished, KData);

    //Test case passed

    _LIT( KDescription, "CDRMCommonTest::ConnectionTestL passed" );

    iLog->Log( KDescription );

    aResult.SetResult( KErrNone, KDescription );

    //Case was executed

    return KErrNone;

    }

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

// CDRMCommonTest::CheckContentRightsTestL

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

//

TInt CDRMCommonTest::CheckContentRightsTestL( 

    TTestResult& aResult )

    {

    _LIT( KData, "CDRMCommonTest::CheckContentRightsTestL" );

    TestModuleIf().Printf( 0, KRunning, KData );

    iLog->Log( KData );

    DRMCommon* common( DRMCommon::NewL() );

    CleanupStack::PushL( common );

    TInt ret( DRMCommon::EOk );

    // Test Cases

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