/*

* 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:  STIF testing for MPX Collection Playlist

*

*/

// INCLUDE FILES

#include <e32svr.h>

#include <badesca.h>

#include <StifParser.h>

#include <Stiftestinterface.h>

#include <mpxcollectionplaylist.h>

#include <mpxcollectionpath.h>

#include <mpxattribute.h>

#include "mpxcollectionplaylisttest.h"

#include "mpxcollectionobserver.h"//new added

#include "mpxcollectionutility.h"//new 

#include "mpxcollectionplaylistobserver.h"

#include "mpxcollectionopenutility.h"

#include "mpxmediageneraldefs.h"

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

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

// CMPXCollectionPlaylistTest::Delete

// Delete here all resources allocated and opened from test methods.

// Called from destructor.

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

//

void CMPXCollectionPlaylistTest::Delete()

    {

	  if ( iCollectionPlaylist )

		    {

		    delete iCollectionPlaylist;

		    }

      if ( iCollectionPath )

          {

          iCollectionPath->Reset();

          delete iCollectionPath;

          }

	  iExpectedEvents.Close();

    }

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

// CMPXCollectionPlaylistTest::AddExpectedEvent

// Add an event to the expected event list

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

void CMPXCollectionPlaylistTest::AddExpectedEvent( TExpectedEvents aEvent )

	  {

	  iLog->Log(_L("CMPXCollectionPlaylistTest::AddExpectedEvent: %d"), aEvent);

	  iExpectedEvents.Append(aEvent);

	  }

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

// CMPXCollectionPlaylistTest::RemoveExpectedEvent

// Remove the event from the expected event list

// Returns: ETrue: Event found.

//          EFalse: Event not found.

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

TBool CMPXCollectionPlaylistTest::RemoveExpectedEvent( TExpectedEvents aEvent )

	  {

	  iLog->Log(_L("CMPXCollectionPlaylistTest::RemoveExpectedEvent: %d"), aEvent);

	  TBool match = EFalse;

	  TInt index = iExpectedEvents.Find(aEvent);

	  if ( index != KErrNotFound )

		    {

		    iExpectedEvents.Remove(index);

		    match = ETrue;

		    }

	  return match;

	  }

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

// CMPXCollectionPlaylistTest::BuildCollectionPath

// Build MPX Collection Path

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

void CMPXCollectionPlaylistTest::BuildCollectionPathL()

      {

      iLog->Log(_L("CMPXCollectionPlaylistTest::BuildCollectionPath"));

      const TMPXItemId KMPXPathLevel1 = 33331;

      const TMPXItemId KMPXPathLevel2 = 33332;

      const TMPXItemId KMPXPathLevel3 = 33333;

      const TMPXItemId KMPXPathItem1 = 44441;

      const TMPXItemId KMPXPathItem2 = 44442;

      const TMPXItemId KMPXPathItem3 = 44443;

      const TMPXItemId KMPXPathItem4 = 44444;

      const TMPXItemId KMPXPathItem5 = 44445;

      RArray<TMPXItemId> itemIdArray;

      // Start from scratch

      if ( iCollectionPath )

          {

          iCollectionPath->Reset();

          delete iCollectionPath;

          }

      // build collection path

      iCollectionPath = CMPXCollectionPath::NewL();

      iCollectionPath->AppendL(KMPXPathLevel1);

      iCollectionPath->AppendL(KMPXPathLevel2);

      iCollectionPath->AppendL(KMPXPathLevel3);

      itemIdArray.Append(KMPXPathItem1);

      itemIdArray.Append(KMPXPathItem2);

      itemIdArray.Append(KMPXPathItem3);

      itemIdArray.Append(KMPXPathItem4);

      itemIdArray.Append(KMPXPathItem5);

      iCollectionPath->AppendL(itemIdArray.Array());

      itemIdArray.Close();

      }

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

// CMPXCollectionPlaylistTest::RunMethodL

// Run specified method. Contains also table of test mothods and their names.

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

//

TInt CMPXCollectionPlaylistTest::RunMethodL( CStifItemParser& aItem )

    {

    static TStifFunctionInfo const KFunctions[] =

        {

        // Copy this line for every implemented function.

        // First string is the function name used in TestScripter script file.

        // Second is the actual implementation member function.

        ENTRY( "Example", CMPXCollectionPlaylistTest::ExampleL ),

        //ADD NEW ENTRY HERE

        ENTRY( "CreateUtilityNewPlaylist", CMPXCollectionPlaylistTest::CreateUtilityNewPlaylist ),

        ENTRY( "CreateUtilityPlaylistExist", CMPXCollectionPlaylistTest::CreateUtilityPlaylistExist ),

        ENTRY( "CreateUtilityCollectionPath", CMPXCollectionPlaylistTest::CreateUtilityCollectionPath ),

        ENTRY( "CreateUtilityCollectionStream", CMPXCollectionPlaylistTest::CreateUtilityCollectionStream ),

        ENTRY( "CopyContentL", CMPXCollectionPlaylistTest::CopyContentL ),

        ENTRY( "Next", CMPXCollectionPlaylistTest::Next ),

        ENTRY( "Previous", CMPXCollectionPlaylistTest::Previous ),

        ENTRY( "SetToFirst", CMPXCollectionPlaylistTest::SetToFirst ),

        ENTRY( "SetToLast", CMPXCollectionPlaylistTest::SetToLast ),

        ENTRY( "SetToIndex", CMPXCollectionPlaylistTest::SetToIndex ),

        ENTRY( "Count", CMPXCollectionPlaylistTest::Count ),

        ENTRY( "Levels", CMPXCollectionPlaylistTest::Levels ),

        ENTRY( "Index", CMPXCollectionPlaylistTest::Index ),

        ENTRY( "Remote", CMPXCollectionPlaylistTest::Remote ),

        ENTRY( "RepeatMode", CMPXCollectionPlaylistTest::RepeatMode ),

        ENTRY( "Shuffle", CMPXCollectionPlaylistTest::Shuffle ),

        ENTRY( "Path", CMPXCollectionPlaylistTest::Path ),

        ENTRY( "MediaL", CMPXCollectionPlaylistTest::MediaL ),

        ENTRY( "SetRepeatMode", CMPXCollectionPlaylistTest::SetRepeatMode ),

        ENTRY( "SetRepeatEnabled", CMPXCollectionPlaylistTest::SetRepeatEnabled ),

        ENTRY( "SetShuffleL", CMPXCollectionPlaylistTest::SetShuffleL ),

        ENTRY( "SetShuffleEnabledL", CMPXCollectionPlaylistTest::SetShuffleEnabledL ),

        ENTRY( "StreamingL", CMPXCollectionPlaylistTest::StreamingL ),

        ENTRY( "SetObserver", CMPXCollectionPlaylistTest::SetObserver ),

        ENTRY( "EmbeddedPlaylist", CMPXCollectionPlaylistTest::EmbeddedPlaylist ),

        ENTRY( "SetEmbeddedPlaylist", CMPXCollectionPlaylistTest::SetEmbeddedPlaylist ),

        ENTRY( "SetL", CMPXCollectionPlaylistTest::SetL ),

        ENTRY( "CancelRequest", CMPXCollectionPlaylistTest::CancelRequest ),

        ENTRY( "Invalidate", CMPXCollectionPlaylistTest::Invalidate ),

        ENTRY("NextIndex", CMPXCollectionPlaylistTest::NextIndex ),

        ENTRY("PathIndex",CMPXCollectionPlaylistTest::PathIndex ),

        //add function

        ENTRY("CMPXCollectionPlaylistDestructor",CMPXCollectionPlaylistTest::CMPXCollectionPlaylistDestructor ),//Pass debug added 7,10,2008

        ENTRY("CMPXCollectionOpenUtilityCreate",CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilityCreate ), //Pass debug added 7,10,2008

        ENTRY( "CMPXCollectionOpenUtilityStartL", CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilityStartL ),//Pass added 7,10,2008

        ENTRY( "CMPXCollectionOpenUtilityStop", CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilityStop ),//Pass debug added 7,10,2008 

        ENTRY( "CMPXCollectionOpenUtilityStartUsingPath", CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilityStartUsingPath ),//Pass added 7,10,2008

        ENTRY( "CMPXCollectionOpenUtilitySetDelay", CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilitySetDelay ),//Pass debug  added 7,10,2008

        ENTRY( "CMPXCollectionOpenUtilitySetDirection", CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilitySetDirection ),//Pass debug added 7,10,2008

        ENTRY( "NewLMMPXCollectionUtility", CMPXCollectionPlaylistTest::NewLMMPXCollectionUtility ),//Pass added by 7,10,2008

        ENTRY( "CMPXCollectionOpenUtilityPathL", CMPXCollectionPlaylistTest::CMPXCollectionOpenUtilityPathL ),//Pass debug added 7,10,2008 

        };

    const TInt count = sizeof( KFunctions ) /

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

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

// CMPXCollectionPlaylistTest::HandleCollectionMediaL

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

//

void CMPXCollectionPlaylistTest::HandleCollectionMediaL( const CMPXMedia& /*aMedia*/, TInt aError )

	  {

	  iLog->Log(_L("CMPXCollectionPlaylistTest::HandleCollectionMediaL: %d"), aError);

	  }

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

// CMPXCollectionPlaylistTest::HandleCollectionMessage

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

//

void CMPXCollectionPlaylistTest::HandleCollectionMessage( CMPXMessage* /*aMsg*/, TInt aError )

	  {

	  iLog->Log(_L("CMPXCollectionPlaylistTest::HandleCollectionMessage: %d"), aError);

	  }

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

// CMPXCollectionPlaylistTest::HandleOpenL

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

//

void CMPXCollectionPlaylistTest::HandleOpenL( const CMPXMedia& /*aEntries*/, TInt /*aIndex*/, TBool /*aComplete*/, TInt aError )

	  {

	  iLog->Log(_L("CMPXCollectionPlaylistTest::HandleOpenL: %d"), aError);

	  }

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

// CMPXCollectionPlaylistTest::HandleOpenL

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

//

void CMPXCollectionPlaylistTest::HandleOpenL( const CMPXCollectionPlaylist& /*aPlaylist*/, TInt aError ) 

	  {

	  iLog->Log(_L("CMPXCollectionPlaylistTest::HandleOpenL: %d"), aError);

	  }

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

// CMPXCollectionPlaylistTest::HandleOpenL

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

//

void CMPXCollectionPlaylistTest::HandleCollectionPlaylistChange( TInt aError ) 

	  {

	  iLog->Log(_L("CMPXCollectionPlaylistTest::HandleCollectionPlaylistChange: %d"), aError);

	  }

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

// CMPXCollectionPlaylistTest::ExampleL

// Example test method function.

// (other items were commented in a header).

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

//

TInt CMPXCollectionPlaylistTest::ExampleL( CStifItemParser& aItem )

    {

    // Print to UI

    _LIT( KMPXCollectionPlaylisttest, "MPXCollectionPlaylistTest" );

    _LIT( KExample, "In Example" );

    TestModuleIf().Printf( 0, KMPXCollectionPlaylisttest, KExample );

    // Print to log file

    iLog->Log( KExample );

    TInt i = 0;

    TPtrC string;

    _LIT( KParam, "Param[%i]: %S" );

    while ( aItem.GetNextString( string ) == KErrNone )

        {

        TestModuleIf().Printf( i, KMPXCollectionPlaylisttest,

                                KParam, i, &string );

        i++;

        }

    return KErrNone;

    }

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

// CMPXCollectionPlaylistTest::CreateUtilityNewPlaylist

// ?implementation_description

// (other items were commented in a header).

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

//

TInt CMPXCollectionPlaylistTest::CreateUtilityNewPlaylist( CStifItemParser& /*aItem*/ )

    {

    iLog->Log(_L("CMPXCollectionPlaylistTest::CreateUtilityNewPlaylist"));

    TRAPD(err, iCollectionPlaylist = CMPXCollectionPlaylist::NewL());

   	iLog->Log(_L("CMPXCollectionPlaylist::NewL returned: %d"), err);

    iExpectedEvents.Reset();

    return err;

    }

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

// CMPXCollectionPlaylistTest::CreateUtilityPlaylistExist

// ?implementation_description

// (other items were commented in a header).

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

//

TInt CMPXCollectionPlaylistTest::CreateUtilityPlaylistExist( CStifItemParser& /*aItem*/ )

    {

    iLog->Log(_L("CMPXCollectionPlaylistTest::CreateUtilityPlaylistExist"));

    TInt err = KErrNone;

    CMPXCollectionPlaylist* firstPlaylist = NULL;

    // Create brand new playlist first

    TRAP(err, firstPlaylist = CMPXCollectionPlaylist::NewL());

   	iLog->Log(_L("CMPXCollectionPlaylist::NewL (firstPlaylist) returned: %d"), err);

   	if ((err == KErrNone) && firstPlaylist)

   	    {

   	    // Pass existing playlist to create another instance of playlist

   	    TRAP(err, iCollectionPlaylist = CMPXCollectionPlaylist::NewL( *firstPlaylist ));

   	    iLog->Log(_L("CMPXCollectionPlaylist::NewL returned: %d"), err);

   	    }

   	if (firstPlaylist)

   	    {   	

   	    delete firstPlaylist;

        }

    iExpectedEvents.Reset();

    return err;

    }    

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

// CMPXCollectionPlaylistTest::CreateUtilityCollectionPath

// ?implementation_description

// (other items were commented in a header).

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

//

TInt CMPXCollectionPlaylistTest::CreateUtilityCollectionPath( CStifItemParser& /*aItem*/ )

    {

    iLog->Log(_L("CMPXCollectionPlaylistTest::CreateUtilityCollectionPath"));

    TInt err = KErrNone;

    TRAP(err, BuildCollectionPathL());

   	if ((err == KErrNone) && iCollectionPath)

   	    {

   	    // Pass existing collection path to create playlist

   	    TRAP(err, iCollectionPlaylist = CMPXCollectionPlaylist::NewL( *iCollectionPath ));

   	    iLog->Log(_L("CMPXCollectionPlaylist::NewL returned: %d"), err);

   	    }

    iExpectedEvents.Reset();

    return err;

    }    

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

// CMPXCollectionPlaylistTest::CreateUtilityCollectionStream

// ?implementation_description

// (other items were commented in a header).

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

//

TInt CMPXCollectionPlaylistTest::CreateUtilityCollectionStream( CStifItemParser& /*aItem*/ )

    {

    iLog->Log(_L("CMPXCollectionPlaylistTest::CreateUtilityCollectionStream"));

    TInt err = KErrNone;

    CMPXCollectionPlaylist* firstPlaylist = NULL;

    // Create brand new playlist first

    TRAP(err, firstPlaylist = CMPXCollectionPlaylist::NewL());

    iLog->Log(_L("CMPXCollectionPlaylist::NewL (firstPlaylist) returned: %d"), err);

    if ((err == KErrNone) && firstPlaylist)

        {

        // Pass stream to create another instance of playlist

        TRAP(err,buffer = CBufFlat::NewL( 200 )); 

        CleanupStack::PushL( buffer );

        RBufWriteStream writeStream( *buffer );

        CleanupClosePushL( writeStream );

        TRAP( err,firstPlaylist->ExternalizeL( writeStream ));

        TRAP( err,writeStream.CommitL());

        buffer->Compress();

        CleanupStack::PopAndDestroy( &writeStream );

        RBufReadStream readStream( *buffer );

        CleanupClosePushL( readStream );     

        TRAP( err,iCollectionPlaylist = CMPXCollectionPlaylist::NewL(readStream));

        iLog->Log(_L("CMPXCollectionPlaylist::NewL returned: %d"), err);

        CleanupStack::PopAndDestroy( &readStream );

        CleanupStack::PopAndDestroy( buffer );

}

    if (firstPlaylist)

   	    {   	

   	    delete firstPlaylist;

        } 

    iExpectedEvents.Reset();

    return err;

    }    

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

// CMPXCollectionPlaylistTest::CopyContentL

// ?implementation_description

// (other items were commented in a header).

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

//

TInt CMPXCollectionPlaylistTest::CopyContentL( CStifItemParser& /*aItem*/ )

    {

    iLog->Log(_L("CMPXCollectionPlaylistTest::CopyContentL"));

    TInt err = KErrNone;

    CMPXCollectionPlaylist* anotherPlaylist = NULL;

    // Create another playlist to copy content from

    TRAP(err, anotherPlaylist = CMPXCollectionPlaylist::NewL());

   	iLog->Log(_L("CMPXCollectionPlaylist::NewL (anotherPlaylist) returned: %d"), err);

   	if ((err == KErrNone) && anotherPlaylist)

   	    {

   	    anotherPlaylist->CopyContentL (*iCollectionPlaylist);

   	    if ((iCollectionPlaylist->RepeatMode() == anotherPlaylist->RepeatMode()) &&

            (iCollectionPlaylist->Shuffle() == anotherPlaylist->Shuffle()) &&

            (iCollectionPlaylist->Remote() == anotherPlaylist->Remote()) &&

            (iCollectionPlaylist->Count() == anotherPlaylist->Count()) &&

            (iCollectionPlaylist->Levels() == anotherPlaylist->Levels()) &&

            (iCollectionPlaylist->Index() == anotherPlaylist->Index()) &&

            (iCollectionPlaylist->EmbeddedPlaylist() == anotherPlaylist->EmbeddedPlaylist()))

            {

            err = KErrNone;

            iLog->Log(_L("CMPXCollectionPlaylistTest::CopyContentL copy OK"));

            }

        else

            {

            err = KErrGeneral;

            iLog->Log(_L("CMPXCollectionPlaylistTest::CopyContentL copy FAIL"));

            }

   	    }

   	if (anotherPlaylist)

   	    {   	

   	    delete anotherPlaylist;

        }    

    return err;

    }

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

// CMPXCollectionPlaylistTest::Next

// ?implementation_description

// (other items were commented in a header).

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

//

TInt CMPXCollectionPlaylistTest::Next( CStifItemParser& aItem )

    {

    iLog->Log(_L("CMPXCollectionPlaylistTest::Next"));

    TInt err = KErrNone;

    TInt vRepeatIgnored;

    TBool vRetNext;

	  if ((KErrNone == aItem.GetNextInt(vRepeatIgnored)) &&

	      (vRepeatIgnored >= EFalse) && (vRepeatIgnored <= ETrue))

		    {

		    vRetNext = iCollectionPlaylist->Next (vRepeatIgnored);

		    iLog->Log(_L("CMPXCollectionPlaylist::Next returned: %d"), vRetNext);

		    }

  	else

		    {

		    iLog->Log(_L("CMPXCollectionPlaylistTest::Next: Bad parameter on config file"));

		    err = KErrBadTestParameter;

		    }

    return err;

    }

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

// CMPXCollectionPlaylistTest::Previous

// ?implementation_description

// (other items were commented in a header).

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

//

TInt CMPXCollectionPlaylistTest::Previous( CStifItemParser& aItem )

    {

    iLog->Log(_L("CMPXCollectionPlaylistTest::Previous"));

    TInt err = KErrNone;

    TBool vRepeatIgnored;

    TBool vRetNext;

	  if ((KErrNone == aItem.GetNextInt(vRepeatIgnored)) &&

	      (vRepeatIgnored >= EFalse) && (vRepeatIgnored <= ETrue))

		    {

		    vRetNext = iCollectionPlaylist->Previous (vRepeatIgnored);

		    iLog->Log(_L("CMPXCollectionPlaylist::Previous returned: %d"), vRetNext);

		    }

  	else

		    {

		    iLog->Log(_L("CMPXCollectionPlaylistTest::Previous: Bad parameter on config file"));

		    err = KErrBadTestParameter;

		    }

    return err;

    }

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

// CMPXCollectionPlaylistTest::SetToFirst

// ?implementation_description

// (other items were commented in a header).

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

//

TInt CMPXCollectionPlaylistTest::SetToFirst( CStifItemParser& /*aItem*/ )

    {

    iLog->Log(_L("CMPXCollectionPlaylistTest::SetToFirst"));

    TInt err = KErrNone;

    iCollectionPlaylist->SetToFirst();

    iLog->Log(_L("CMPXCollectionPlaylist::SetToFirst OK"));

    return err;

    }

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

// CMPXCollectionPlaylistTest::SetToLast

// ?implementation_description

// (other items were commented in a header).

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

//

TInt CMPXCollectionPlaylistTest::SetToLast( CStifItemParser& /*aItem*/ )

    {

    iLog->Log(_L("CMPXCollectionPlaylistTest::SetToLast"));

    TInt err = KErrNone;

    iCollectionPlaylist->SetToLast();

    iLog->Log(_L("CMPXCollectionPlaylist::SetToLast OK"));

    return err;

    }

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

// CMPXCollectionPlaylistTest::SetToIndex

// ?implementation_description

// (other items were commented in a header).

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

//

TInt CMPXCollectionPlaylistTest::SetToIndex( CStifItemParser& aItem )

    {

    iLog->Log(_L("CMPXCollectionPlaylistTest::SetToIndex"));

    TInt err = KErrNone;

    TInt vIndex;

	  if ( KErrNone == aItem.GetNextInt(vIndex) )

		    {

		    TInt vCount = iCollectionPlaylist->Count();

		    iLog->Log(_L("CMPXCollectionPlaylist::Count returned: %d"), vCount);

		    if ((vCount > 0) && (vIndex < vCount))

		        {