/*

* 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:  MPXCollectionPath testing implementation (mpxcollectionpath.h)

*

*/

#include <s32mem.h>

#include <mpxcollectionpath.h>

#include "commontestclass.h"

// Begin MPXCollectionPath testing implementation mpxcollectionpath.h================================

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

// CCommonTestClass::MpxItemIdConst()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::MpxItemIdConst(CStifItemParser& aItem)

    {

    FTRACE(FPrint(_L("CCommonTestClass::MpxItemIdConst testing TMPXItemId::TMPXItemId() begin")));

    iLog->Log(_L("CCommonTestClass::MpxItemIdConst testing TMPXItemId::TMPXItemId() begin"));

    TInt err=KErrNone;

    TUint id1;

    TUint id2;

    TUint numParam=0;

    TMPXItemId item;

    // read in parameters

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

        {

        numParam++;

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

            {

            numParam++;

            }

        }

    switch (numParam)

        {

        case 1:

            item.iId1 = item.iId2 = id1;

            break;

        case 2:

            item.iId1 = id1;

            item.iId2 = id2;

            break;

        }

    iMPXItemIdArray.Append(item);

    return err;

    }

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

// CCommonTestClass::MpxItemIdReset()

// Returns: Symbian OS errors.

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

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

    {

    FTRACE(FPrint(_L("CCommonTestClass::MpxItemIdReset begin")));

    iLog->Log(_L("CCommonTestClass::MpxItemIdReset begin"));

    TInt err=KErrNone;

    iMPXItemIdArray.Reset();

    return err;

    }

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

// CCommonTestClass::MpxCollPathNewL()

// Returns: Symbian OS errors.

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

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

    {

    FTRACE(FPrint(_L("CCommonTestClass::MpxCollPathNewL testing CMPXCollectionPath::NewL() begin")));

    iLog->Log(_L("CCommonTestClass::MpxCollPathNewL testing CMPXCollectionPath::NewL() begin"));

    TInt err=KErrNone;

    if ( iMPXCollectionPath )

        {

        delete iMPXCollectionPath;

        iMPXCollectionPath = NULL;

        }

    iMPXCollectionPath = CMPXCollectionPath::NewL();

    return err;

    }

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

// CCommonTestClass::MpxCollPathNewLPathL()

// Returns: Symbian OS errors.

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

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

    {

    FTRACE(FPrint(_L("CCommonTestClass::MpxCollPathNewLPathL testing CMPXCollectionPath::NewL() begin")));

    iLog->Log(_L("CCommonTestClass::MpxCollPathNewLPathL testing CMPXCollectionPath::NewL() begin"));

    TInt err=KErrNone;

    if ( !iMPXCollectionPath )

        {

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

        return KErrBadTestParameter;

        }

    CMPXCollectionPath* path = CMPXCollectionPath::NewL(*iMPXCollectionPath);

    // Verification

    if ( path->Levels() != iMPXCollectionPath->Levels() )

        {

        iLog->Log(_L("Verification Failed: new num levels=%d, old num levels=%d."), 

                path->Levels(), iMPXCollectionPath->Levels());

        err = KErrUnexpectedValue;

        }

    if ( path->Count() != iMPXCollectionPath->Count() )

        {

        iLog->Log(_L("Verification Failed: new Count=%d, old Count=%d."), 

                path->Count(), iMPXCollectionPath->Count());

        err = KErrUnexpectedValue;

        }

    delete path;

    return err;

    }

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

// CCommonTestClass::MpxCollPathNewLStreamL()

// Returns: Symbian OS errors.

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

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

    {

    FTRACE(FPrint(_L("CCommonTestClass::MpxCollPathNewLPathL testing CMPXCollectionPath::NewL() begin")));

    iLog->Log(_L("CCommonTestClass::MpxCollPathNewLPathL testing CMPXCollectionPath::NewL() begin"));

    TInt err=KErrNone;

    if ( !iMPXCollectionPath )

        {

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

        return KErrBadTestParameter;

        }

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

    CleanupStack::PushL( buffer );

    RBufWriteStream writeStream( *buffer );

    CleanupClosePushL( writeStream );

    iMPXCollectionPath->ExternalizeL( writeStream );

    writeStream.CommitL();

    buffer->Compress();

    CleanupStack::PopAndDestroy( &writeStream );

    RBufReadStream readStream( *buffer );

    CleanupClosePushL( readStream );                

    CMPXCollectionPath* path = CMPXCollectionPath::NewL(readStream);

    // Verification

    if ( path->Levels() != iMPXCollectionPath->Levels() )

        {

        iLog->Log(_L("Verification Failed: new num levels=%d, old num levels=%d."), 

                path->Levels(), iMPXCollectionPath->Levels());

        err = KErrUnexpectedValue;

        }

    if ( path->Count() != iMPXCollectionPath->Count() )

        {

        iLog->Log(_L("Verification Failed: new Count=%d, old Count=%d."), 

                path->Count(), iMPXCollectionPath->Count());

        err = KErrUnexpectedValue;

        }

    CleanupStack::PopAndDestroy( &readStream );

    CleanupStack::PopAndDestroy( buffer );

    return err;

    }

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

// CCommonTestClass::MpxCollPathAppendLIdL()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::MpxCollPathAppendLIdL(CStifItemParser& aItem)

    {

    FTRACE(FPrint(_L("CCommonTestClass::MpxCollPathAppendLIdL testing CMPXCollectionPath::AppendL() begin")));

    iLog->Log(_L("CCommonTestClass::MpxCollPathAppendLIdL testing CMPXCollectionPath::AppendL() begin"));

    TInt err=KErrNone;

    TUint itemId;

    // read in parameters

    if ( aItem.GetNextInt(itemId) )

        {

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

        return KErrBadTestParameter;

        }

    // if first time, generate TUid and use that value to append.

    if ( iMPXCollectionPath->Levels() == 0 )

        {

        iCollectionPathUid.Uid(itemId);

        itemId = iCollectionPathUid.iUid;

        }

    TMPXItemId item(itemId);

    iMPXCollectionPath->AppendL(item);

    return err;

    }

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

// CCommonTestClass::MpxCollPathAppendLIdsL()

// Returns: Symbian OS errors.

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

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

    {

    FTRACE(FPrint(_L("CCommonTestClass::MpxCollPathAppendLIdsL testing CMPXCollectionPath::AppendL() begin")));

    iLog->Log(_L("CCommonTestClass::MpxCollPathAppendLIdsL testing CMPXCollectionPath::AppendL() begin"));

    TInt err=KErrNone;

    iMPXCollectionPath->AppendL(iMPXItemIdArray.Array());

    return err;

    }

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

// CCommonTestClass::MpxCollPathLevels()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::MpxCollPathLevels(CStifItemParser& aItem)

    {

    FTRACE(FPrint(_L("CCommonTestClass::MpxCollPathLevels testing CMPXCollectionPath::Levels() begin")));

    iLog->Log(_L("CCommonTestClass::MpxCollPathLevels testing CMPXCollectionPath::Levels() begin"));

    TInt err=KErrNone;

    TUint expectedLevels;

    // read in parameters

    if ( aItem.GetNextInt(expectedLevels) )

        {

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

        return KErrBadTestParameter;

        }

    TInt levels = iMPXCollectionPath->Levels();

    // Verification

    if ( levels != expectedLevels )

        {

        iLog->Log(_L("Verification Failed: levels=%d, expectedLevels=%d."), levels, expectedLevels);

        err = KErrUnexpectedValue;

        }

    return err;

    }

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

// CCommonTestClass::MpxCollPathBack()

// Returns: Symbian OS errors.

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

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

    {

    FTRACE(FPrint(_L("CCommonTestClass::MpxCollPathBack testing CMPXCollectionPath::Back() begin")));

    iLog->Log(_L("CCommonTestClass::MpxCollPathBack testing CMPXCollectionPath::Back() begin"));

    TInt err=KErrNone;

    iMPXCollectionPath->Back();

    return err;

    }

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

// CCommonTestClass::MpxCollPathReset()

// Returns: Symbian OS errors.

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

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

    {

    FTRACE(FPrint(_L("CCommonTestClass::MpxCollPathReset testing CMPXCollectionPath::Reset() begin")));

    iLog->Log(_L("CCommonTestClass::MpxCollPathReset testing CMPXCollectionPath::Reset() begin"));

    TInt err=KErrNone;

    iMPXCollectionPath->Reset();

    return err;

    }

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

// CCommonTestClass::MpxCollPathIndex()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::MpxCollPathIndex(CStifItemParser& aItem)

    {

    FTRACE(FPrint(_L("CCommonTestClass::MpxCollPathIndex testing CMPXCollectionPath::Index() begin")));

    iLog->Log(_L("CCommonTestClass::MpxCollPathIndex testing CMPXCollectionPath::Index() begin"));

    TInt err=KErrNone;

    TUint expectedIndex;

    // read in parameters

    if ( aItem.GetNextInt(expectedIndex) )

        {

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

        return KErrBadTestParameter;

        }

    TInt index = iMPXCollectionPath->Index();

    // Verification

    if ( index != expectedIndex )

        {

        iLog->Log(_L("Verification Failed: index=%d, expectedIndex=%d."), index, expectedIndex);

        err = KErrUnexpectedValue;

        }

    return err;

    }

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

// CCommonTestClass::MpxCollPathOperatorPlus()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::MpxCollPathOperatorPlus(CStifItemParser& aItem)

    {

    FTRACE(FPrint(_L("CCommonTestClass::MpxCollPathOperatorPlus testing CMPXCollectionPath::Operator++() begin")));

    iLog->Log(_L("CCommonTestClass::MpxCollPathOperatorPlus testing CMPXCollectionPath::Operator++() begin"));

    TInt err=KErrNone;

    TUint expectedResult;

    // read in parameters

    if ( aItem.GetNextInt(expectedResult) )

        {

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

        return KErrBadTestParameter;

        }

    TBool result = iMPXCollectionPath->operator ++();

    // Verification

    if ( result != expectedResult )

        {

        iLog->Log(_L("Verification Failed: result=%d, expectedResult=%d."), result, expectedResult);

        err = KErrUnexpectedValue;

        }

    return err;

    }

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

// CCommonTestClass::MpxCollPathOperatorMinus()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::MpxCollPathOperatorMinus(CStifItemParser& aItem)

    {

    FTRACE(FPrint(_L("CCommonTestClass::MpxCollPathOperatorMinus testing CMPXCollectionPath::Operator--() begin")));

    iLog->Log(_L("CCommonTestClass::MpxCollPathOperatorMinus testing CMPXCollectionPath::Operator--() begin"));

    TInt err=KErrNone;

    TUint expectedResult;

    // read in parameters

    if ( aItem.GetNextInt(expectedResult) )

        {

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

        return KErrBadTestParameter;

        }

    TBool result = iMPXCollectionPath->operator --();

    // Verification

    if ( result != expectedResult )

        {

        iLog->Log(_L("Verification Failed: result=%d, expectedResult=%d."), result, expectedResult);

        err = KErrUnexpectedValue;

        }

    return err;

    }

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

// CCommonTestClass::MpxCollPathSetToFirst()

// Returns: Symbian OS errors.

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

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

    {

    FTRACE(FPrint(_L("CCommonTestClass::MpxCollPathSetToFirst testing CMPXCollectionPath::SetToFirst() begin")));

    iLog->Log(_L("CCommonTestClass::MpxCollPathSetToFirst testing CMPXCollectionPath::SetToFirst() begin"));

    TInt err=KErrNone;

    iMPXCollectionPath->SetToFirst();

    return err;

    }

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

// CCommonTestClass::MpxCollPathSetToLast()

// Returns: Symbian OS errors.

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

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

    {

    FTRACE(FPrint(_L("CCommonTestClass::MpxCollPathSetToLast testing CMPXCollectionPath::SetToLast() begin")));

    iLog->Log(_L("CCommonTestClass::MpxCollPathSetToLast testing CMPXCollectionPath::SetToLast() begin"));

    TInt err=KErrNone;

    iMPXCollectionPath->SetToLast();

    return err;

    }

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

// CCommonTestClass::MpxCollPathSetIndex()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::MpxCollPathSetIndex(CStifItemParser& aItem)

    {

    FTRACE(FPrint(_L("CCommonTestClass::MpxCollPathSetIndex testing CMPXCollectionPath::Set() begin")));

    iLog->Log(_L("CCommonTestClass::MpxCollPathSetIndex testing CMPXCollectionPath::Set() begin"));

    TInt err=KErrNone;

    TInt index;

    // read in parameters

    if ( aItem.GetNextInt(index) )

        {

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

        return KErrBadTestParameter;

        }

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

        {

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

        return KErrBadTestParameter;

        }

    iMPXCollectionPath->Set(index);

    return err;

    }

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

// CCommonTestClass::MpxCollPathSetId()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::MpxCollPathSetId(CStifItemParser& aItem)

    {

    FTRACE(FPrint(_L("CCommonTestClass::MpxCollPathSetId testing CMPXCollectionPath::Set() begin")));

    iLog->Log(_L("CCommonTestClass::MpxCollPathSetId testing CMPXCollectionPath::Set() begin"));

    TInt err=KErrNone;

    TUint itemId;

    // read in parameters

    if ( aItem.GetNextInt(itemId) )

        {

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

        return KErrBadTestParameter;

        }

    TMPXItemId id(itemId);

    iMPXCollectionPath->Set(id);

    return err;

    }

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

// CCommonTestClass::MpxCollPathSetMode()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::MpxCollPathSetMode(CStifItemParser& aItem)

    {

    FTRACE(FPrint(_L("CCommonTestClass::MpxCollPathSetMode testing CMPXCollectionPath::Set() begin")));

    iLog->Log(_L("CCommonTestClass::MpxCollPathSetMode testing CMPXCollectionPath::Set() begin"));

    TInt err=KErrNone;

    TUint mode;

    // read in parameters

    if ( aItem.GetNextInt(mode) )

        {

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

        return KErrBadTestParameter;

        }

    iMPXCollectionPath->Set(static_cast<TMPXOpenMode>(mode));

    return err;

    }

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

// CCommonTestClass::MpxCollPathSetLAttrsL()

// Returns: Symbian OS errors.

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

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

    {

    FTRACE(FPrint(_L("CCommonTestClass::MpxCollPathSetLAttrsL testing CMPXCollectionPath::SetL() begin")));

    iLog->Log(_L("CCommonTestClass::MpxCollPathSetLAttrsL testing CMPXCollectionPath::SetL() begin"));

    TInt err=KErrNone;

    iMPXCollectionPath->SetL(iMPXAttArray.Array());

    return err;

    }

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

// CCommonTestClass::MpxCollPathOpenNextMode()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::MpxCollPathOpenNextMode(CStifItemParser& aItem)

    {

    FTRACE(FPrint(_L("CCommonTestClass::MpxCollPathOpenNextMode testing CMPXCollectionPath::OpenNextMode() begin")));

    iLog->Log(_L("CCommonTestClass::MpxCollPathOpenNextMode testing CMPXCollectionPath::OpenNextMode() begin"));

    TInt err=KErrNone;

    TUint expectedMode;

    // read in parameters

    if ( aItem.GetNextInt(expectedMode) )

        {

        iLog->Log(_L("Missing Parameter: Expected open mode."));

        return KErrBadTestParameter;

        }

    TMPXOpenMode mode = iMPXCollectionPath->OpenNextMode();

    // Verification

    if ( mode != expectedMode )

        {

        iLog->Log(_L("Verification Failed: mode=%d, expectedMode=%d."), mode, expectedMode);

        err = KErrUnexpectedValue;

        }

    return err;

    }

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

// CCommonTestClass::MpxCollPathOpenPreviousMode()

// Returns: Symbian OS errors.

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

TInt CCommonTestClass::MpxCollPathOpenPreviousMode(CStifItemParser& aItem)

    {

    FTRACE(FPrint(_L("CCommonTestClass::MpxCollPathOpenPreviousMode testing CMPXCollectionPath::OpenPreviousMode() begin")));

    iLog->Log(_L("CCommonTestClass::MpxCollPathOpenPreviousMode testing CMPXCollectionPath::OpenPreviousMode() begin"));

    TInt err=KErrNone;

    TUint expectedMode;

    // read in parameters

    if ( aItem.GetNextInt(expectedMode) )

        {

        iLog->Log(_L("Missing Parameter: Expected open mode."));

        return KErrBadTestParameter;

        }

    TMPXOpenMode mode = iMPXCollectionPath->OpenPreviousMode();

    // Verification

    if ( mode != expectedMode )

        {

        iLog->Log(_L("Verification Failed: mode=%d, expectedMode=%d."), mode, expectedMode);

        err = KErrUnexpectedValue;

        }

    return err;

    }