/*

* Copyright (c) 2002 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:  MPXMedia and MPXMediaArray testing implementation (mpxmedia.h,mpxmediaarray.h)

*

*/

#include <s32mem.h>

#include <mpxmedia.h>

#include <mpxmediaarray.h>

#include <mpxcollectionpath.h>

#include "commontestclass.h"

// Begin MPXMedia and MPXMediaArray testing implementation (mpxmedia.h,mpxmediaarray.h)========================

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

// CCommonTestClass::MpxMediaNewL()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::MpxMediaNewL(CStifItemParser& /*aItem*/)

    {

    FTRACE(FPrint(_L("CCommonTestClass::MpxMediaNewL testing CMPXMedia::NewL() begin")));

    iLog->Log(_L("CCommonTestClass::MpxMediaNewL testing CMPXMedia::NewL() begin"));

    TInt err=KErrNone;

    CMPXMedia* media = CMPXMedia::NewL();

    CleanupStack::PushL(media);

    if ( iMPXMediaArray )

        {

        iMPXMediaArray->AppendL(media);

        CleanupStack::Pop(media);

        }

    else

        {

        CleanupStack::PopAndDestroy(media);

        }

    return err;

    }

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

// CCommonTestClass::MpxMediaNewLSupportedIdsL()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::MpxMediaNewLSupportedIdsL(CStifItemParser& aItem)

    {

    FTRACE(FPrint(_L("CCommonTestClass::MpxMediaNewLSupportedIdsL testing CMPXMedia::NewL() begin")));

    iLog->Log(_L("CCommonTestClass::MpxMediaNewLSupportedIdsL testing CMPXMedia::NewL() begin"));

    TInt err=KErrNone;

    RArray<TInt> supportedIds;

    TInt id;

    CleanupClosePushL(supportedIds);

    // read in parameters

    while ( aItem.GetNextInt(id) == KErrNone )

        {

        supportedIds.AppendL(id);

        }

    CMPXMedia* media = CMPXMedia::NewL(supportedIds.Array());

    CleanupStack::PushL(media);

    if ( iMPXMediaArray )

        {

        iMPXMediaArray->AppendL(media);

        CleanupStack::Pop(media);

        }

    else

        {

        CleanupStack::PopAndDestroy(media);

        }

    CleanupStack::PopAndDestroy(&supportedIds);

    return err;

    }

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

// CCommonTestClass::MpxMediaNewLMediaL()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::MpxMediaNewLMediaL(CStifItemParser& aItem)

    {

    FTRACE(FPrint(_L("CCommonTestClass::MpxMediaNewLMediaL testing CMPXMedia::NewL() begin")));

    iLog->Log(_L("CCommonTestClass::MpxMediaNewLMediaL testing CMPXMedia::NewL() begin"));

    TInt err=KErrNone;

    TUint index;

    // read in parameters

    if ( aItem.GetNextInt(index) )

        {

        iLog->Log(_L("Missing Parameter: index."));

        return KErrBadTestParameter;

        }

    if ( !iMPXMediaArray )

        {

        iLog->Log(_L("Error: MPXMediaArray not created."));

        return KErrBadTestParameter;

        }

    if ( index >= iMPXMediaArray->Count() )

        {

        iLog->Log(_L("Bad Parameter: index out of range."));

        return KErrBadTestParameter;

        }

    CMPXMedia* media = CMPXMedia::NewL(*(*iMPXMediaArray)[index]);

    CleanupStack::PushL(media);

    iMPXMediaArray->AppendL(media);

    CleanupStack::Pop(media);

    return err;

    }

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

// CCommonTestClass::MpxMediaNewLDataHandleL()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::MpxMediaNewLDataHandleL(CStifItemParser& aItem)

    {

    FTRACE(FPrint(_L("CCommonTestClass::MpxMediaNewLDataHandleL testing CMPXMedia::NewL() begin")));

    iLog->Log(_L("CCommonTestClass::MpxMediaNewLDataHandleL testing CMPXMedia::NewL() begin"));

    TInt err=KErrNone;

    TUint index;

    // read in parameters

    if ( aItem.GetNextInt(index) )

        {

        iLog->Log(_L("Missing Parameter: index."));

        return KErrBadTestParameter;

        }

    if ( !iMPXMediaArray )

        {

        iLog->Log(_L("Error: MPXMediaArray not created."));

        return KErrBadTestParameter;

        }

    if ( index >= iMPXMediaArray->Count() )

        {

        iLog->Log(_L("Bad Parameter: index out of range."));

        return KErrBadTestParameter;

        }

    CMPXMedia* media = CMPXMedia::NewL((*iMPXMediaArray)[index]->Data());

    CleanupStack::PushL(media);

    iMPXMediaArray->AppendL(media);

    CleanupStack::Pop(media);

    return err;

    }

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

// CCommonTestClass::MpxMediaNewLStreamL()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::MpxMediaNewLStreamL(CStifItemParser& aItem)

    {

    FTRACE(FPrint(_L("CCommonTestClass::MpxMediaNewLStreamL testing CMPXMedia::NewL() begin")));

    iLog->Log(_L("CCommonTestClass::MpxMediaNewLStreamL testing CMPXMedia::NewL() begin"));

    TInt err=KErrNone;

    TUint index;

    // read in parameters

    if ( aItem.GetNextInt(index) )

        {

        iLog->Log(_L("Missing Parameter: index."));

        return KErrBadTestParameter;

        }

    if ( !iMPXMediaArray )

        {

        iLog->Log(_L("Error: MPXMediaArray not created."));

        return KErrBadTestParameter;

        }

    if ( index >= iMPXMediaArray->Count() )

        {

        iLog->Log(_L("Bad Parameter: index out of range."));

        return KErrBadTestParameter;

        }

    CBufBase* buffer = CBufFlat::NewL( 100 );

    CleanupStack::PushL( buffer );

    RBufWriteStream writeStream( *buffer );

    CleanupClosePushL( writeStream );

    (*iMPXMediaArray)[index]->ExternalizeL( writeStream );

    writeStream.CommitL();

    buffer->Compress();

    CleanupStack::PopAndDestroy( &writeStream );

    RBufReadStream readStream( *buffer );

    CleanupClosePushL( readStream );                

    CMPXMedia* media = CMPXMedia::NewL(readStream);

    CleanupStack::PushL(media);

    iMPXMediaArray->AppendL(media);

    CleanupStack::Pop(media);

    CleanupStack::PopAndDestroy( &readStream );

    CleanupStack::PopAndDestroy( buffer );

    return err;

    }

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

// CCommonTestClass::MpxMediaOperatorAssignment()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::MpxMediaOperatorAssignment(CStifItemParser& aItem)

    {

    FTRACE(FPrint(_L("CCommonTestClass::MpxMediaOperatorAssignment testing CMPXMedia::operator=() begin")));

    iLog->Log(_L("CCommonTestClass::MpxMediaOperatorAssignment testing CMPXMedia::operator=() begin"));

    TInt err=KErrNone;

    TUint index;

    // read in parameters

    if ( aItem.GetNextInt(index) )

        {

        iLog->Log(_L("Missing Parameter: index."));

        return KErrBadTestParameter;

        }

    if ( !iMPXMediaArray )

        {

        iLog->Log(_L("Error: MPXMediaArray not created."));

        return KErrBadTestParameter;

        }

    if ( index >= iMPXMediaArray->Count() )

        {

        iLog->Log(_L("Bad Parameter: index out of range."));

        return KErrBadTestParameter;

        }

    TRAP(err , media= CMPXMedia::NewL());

    CleanupStack::PushL(media);

    media->operator =(*(*iMPXMediaArray)[index]);

    TRAP(err , iMPXMediaArray->AppendL(media));

    CleanupStack::Pop(media);

    return err;

    }

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

// CCommonTestClass::MpxMediaSupportedIds()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::MpxMediaSupportedIds(CStifItemParser& aItem)

    {

    FTRACE(FPrint(_L("CCommonTestClass::MpxMediaSupportedIds testing CMPXMedia::SupportedIds() begin")));

    iLog->Log(_L("CCommonTestClass::MpxMediaSupportedIds testing CMPXMedia::SupportedIds() begin"));

    TInt err=KErrNone;

    TUint index;

    RArray<TInt> expectedSupportedIds;

    TInt id;

    // read in parameters

    if ( aItem.GetNextInt(index) )

        {

        iLog->Log(_L("Missing Parameter: index."));

        return KErrBadTestParameter;

        }

    if ( !iMPXMediaArray )

        {

        iLog->Log(_L("Error: MPXMediaArray not created."));

        return KErrBadTestParameter;

        }

    if ( index >= iMPXMediaArray->Count() )

        {

        iLog->Log(_L("Bad Parameter: index out of range."));

        return KErrBadTestParameter;

        }

    while ( aItem.GetNextInt(id) == KErrNone )

        {

        expectedSupportedIds.Append(id);

        }

    TArray<TInt> supportedIds = (*iMPXMediaArray)[index]->SupportedIds();

    // verify supported IDS

    if ( supportedIds.Count() == expectedSupportedIds.Count() )

        {

        for (TInt i=0; i<supportedIds.Count(); i++)

            {

            if ( expectedSupportedIds.Find(supportedIds[i]) == KErrNotFound )

                {

                iLog->Log(_L("Verification Failed: ContentID not Found = %d."), supportedIds[i]);

                err = KErrUnexpectedValue;

                }

            }

        }

    else

        {

        iLog->Log(_L("Verification Failed: count=%d, expected count=%d."), supportedIds.Count(), expectedSupportedIds.Count());

        err = KErrUnexpectedValue;

        }

    return err;

    }

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

// CCommonTestClass::MpxMediaAttributes()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::MpxMediaAttributes(CStifItemParser& aItem)

    {

    FTRACE(FPrint(_L("CCommonTestClass::MpxMediaAttributes testing CMPXMedia::Attributes() begin")));

    iLog->Log(_L("CCommonTestClass::MpxMediaAttributes testing CMPXMedia::Attributes() begin"));

    TInt err=KErrNone;

    TUint mediaIndex;

    TUint attIndex;

    // read in parameters

    if ( aItem.GetNextInt(mediaIndex) )

        {

        iLog->Log(_L("Missing Parameter: Media index."));

        return KErrBadTestParameter;

        }

    if ( !iMPXMediaArray )

        {

        iLog->Log(_L("Error: MPXMediaArray not created."));

        return KErrBadTestParameter;

        }

    if ( mediaIndex >= iMPXMediaArray->Count() )

        {

        iLog->Log(_L("Bad Parameter: Media index out of range."));

        return KErrBadTestParameter;

        }

    if ( aItem.GetNextInt(attIndex) )

        {

        iLog->Log(_L("Missing Parameter: Attribute index."));

        return KErrBadTestParameter;

        }

    if ( attIndex >= iMPXAttArray.Count() )

        {

        iLog->Log(_L("Bad Parameter: Attribute index out of range."));

        return KErrBadTestParameter;

        }

    TArray<TMPXAttribute> attributes = (*iMPXMediaArray)[mediaIndex]->Attributes();

    // verify attributes

    TBool found = EFalse;

    for (TInt i=0; i<attributes.Count(); i++)

        {

        if ( iMPXAttArray[attIndex] == attributes[i] )

            {

            found = ETrue;

            }

        }

    if ( !found )

        {

        iLog->Log(_L("Verification Failed: Attribute not found - contentID=%d, attID=%d."), 

                iMPXAttArray[attIndex].ContentId(), iMPXAttArray[attIndex].AttributeId());

        err = KErrUnexpectedValue;

        }

    return err;

    }

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

// CCommonTestClass::MpxMediaSetTObjectValueL()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::MpxMediaSetTObjectValueL(CStifItemParser& aItem)

    {

    FTRACE(FPrint(_L("CCommonTestClass::MpxMediaSetTObjectValueL testing CMPXMedia::SetTObjectValueL() begin")));

    iLog->Log(_L("CCommonTestClass::MpxMediaSetTObjectValueL testing CMPXMedia::SetTObjectValueL() begin"));

    TInt err=KErrNone;

    TUint mediaIndex;

    TUint attIndex;

    TInt attValue;

    // read in parameters

    if ( aItem.GetNextInt(mediaIndex) )

        {

        iLog->Log(_L("Missing Parameter: Media index."));

        return KErrBadTestParameter;

        }

    if ( !iMPXMediaArray )

        {

        iLog->Log(_L("Error: MPXMediaArray not created."));

        return KErrBadTestParameter;

        }

    if ( mediaIndex >= iMPXMediaArray->Count() )

        {

        iLog->Log(_L("Bad Parameter: Media index out of range."));

        return KErrBadTestParameter;

        }

    if ( aItem.GetNextInt(attIndex) )

        {

        iLog->Log(_L("Missing Parameter: Attribute index."));

        return KErrBadTestParameter;

        }

    if ( attIndex >= iMPXAttArray.Count() )

        {

        iLog->Log(_L("Bad Parameter: Attribute index out of range."));

        return KErrBadTestParameter;

        }

    if ( aItem.GetNextInt(attValue) )

        {

        iLog->Log(_L("Missing Parameter: Attribute value."));

        return KErrBadTestParameter;

        }

    // set attribue

    (*iMPXMediaArray)[mediaIndex]->SetTObjectValueL(iMPXAttArray[attIndex], attValue);

    return err;

    }

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

// CCommonTestClass::MpxMediaSetCObjectValueL()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::MpxMediaSetCObjectValueL(CStifItemParser& aItem)

    {

    FTRACE(FPrint(_L("CCommonTestClass::MpxMediaSetCObjectValueL testing CMPXMedia::SetCObjectValueL() begin")));

    iLog->Log(_L("CCommonTestClass::MpxMediaSetCObjectValueL testing CMPXMedia::SetCObjectValueL() begin"));

    TInt err=KErrNone;

    TUint mediaIndex;

    TUint attIndex;

    TPtrC className;

    // read in parameters

    if ( aItem.GetNextInt(mediaIndex) )

        {

        iLog->Log(_L("Missing Parameter: Media index."));

        return KErrBadTestParameter;

        }

    if ( !iMPXMediaArray )

        {

        iLog->Log(_L("Error: MPXMediaArray not created."));

        return KErrBadTestParameter;

        }

    if ( mediaIndex >= iMPXMediaArray->Count() )

        {

        iLog->Log(_L("Bad Parameter: Media index out of range."));

        return KErrBadTestParameter;

        }

    if ( aItem.GetNextInt(attIndex) )

        {

        iLog->Log(_L("Missing Parameter: Attribute index."));

        return KErrBadTestParameter;

        }

    if ( attIndex >= iMPXAttArray.Count() )

        {

        iLog->Log(_L("Bad Parameter: Attribute index out of range."));

        return KErrBadTestParameter;

        }

    if ( aItem.GetNextString(className) )

        {

        iLog->Log(_L("Missing Parameter: Class name."));

        return KErrBadTestParameter;

        }

    // set class object

    if ( className == _L("CMPXMedia") )

        {

        CMPXMedia* media = CMPXMedia::NewL();

        CleanupStack::PushL(media);

        (*iMPXMediaArray)[mediaIndex]->SetCObjectValueL(iMPXAttArray[attIndex], media);

        CleanupStack::PopAndDestroy(media);

        }

    else if ( className == _L("CMPXMediaArray") )

        {

        CMPXMediaArray* media = CMPXMediaArray::NewL();

        CleanupStack::PushL(media);

        (*iMPXMediaArray)[mediaIndex]->SetCObjectValueL(iMPXAttArray[attIndex], media);

        CleanupStack::PopAndDestroy(media);

        }

    else if ( className == _L("CMPXCollectionPath") )

        {

        CMPXCollectionPath* media = CMPXCollectionPath::NewL();

        CleanupStack::PushL(media);

        (*iMPXMediaArray)[mediaIndex]->SetCObjectValueL(iMPXAttArray[attIndex], media);

        CleanupStack::PopAndDestroy(media);

        }

    else

        {

        iLog->Log(_L("Bad Parameter: Invalid class name."));

        return KErrBadTestParameter;

        }

    return err;

    }

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

// CCommonTestClass::MpxMediaSetNoNewLCObjectL()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::MpxMediaSetNoNewLCObjectL(CStifItemParser& aItem)

    {

    FTRACE(FPrint(_L("CCommonTestClass::MpxMediaSetNoNewLCObjectL testing CMPXMedia::SetNoNewLCObjectL() begin")));

    iLog->Log(_L("CCommonTestClass::MpxMediaSetNoNewLCObjectL testing CMPXMedia::SetNoNewLCObjectL() begin"));

    TInt err=KErrNone;

    TUint mediaIndex;

    TUint attIndex;

    TPtrC className;

    // read in parameters

    if ( aItem.GetNextInt(mediaIndex) )

        {

        iLog->Log(_L("Missing Parameter: Media index."));

        return KErrBadTestParameter;

        }

    if ( !iMPXMediaArray )

        {

        iLog->Log(_L("Error: MPXMediaArray not created."));

        return KErrBadTestParameter;

        }

    if ( mediaIndex >= iMPXMediaArray->Count() )

        {

        iLog->Log(_L("Bad Parameter: Media index out of range."));

        return KErrBadTestParameter;

        }

    if ( aItem.GetNextInt(attIndex) )

        {

        iLog->Log(_L("Missing Parameter: Attribute index."));

        return KErrBadTestParameter;

        }

    if ( attIndex >= iMPXAttArray.Count() )

        {

        iLog->Log(_L("Bad Parameter: Attribute index out of range."));

        return KErrBadTestParameter;

        }

    if ( aItem.GetNextString(className) )

        {

        iLog->Log(_L("Missing Parameter: Class name."));

        return KErrBadTestParameter;

        }

    // set class object

    if ( className == _L("CMPXMedia") )

        {

        CMPXMedia* media = CMPXMedia::NewL();

        CleanupStack::PushL(media);