/*

* 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 the License "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:   Test module for IptvVodContentClient*

*/

#include "VCXVodContentApiTest.h"

#include "VCXTestLog.h"

#include "CIptvTestTimer.h"

#include "CIptvMyVideosGlobalFileId.h"

#include "CIptvTestUtilities.h"

#include "CIptvTestEcgUpdateInfo.h"

#include "CIptvMediaContent.h"

#include <mmf/common/mmfcontrollerpluginresolver.h>

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

// CIptvVodContentApiTest::TestGetEcgList

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

//

TInt CIptvVodContentApiTest::TestGetEcgList(TIptvCategoryId aCategoryId, TDesC& aSearchString, TUint32 aFrom, TUint32 aAmount)

    {

    VCXLOGLO1(">>>CIptvVodContentApiTest::TestGetEcgList");

    TInt testCaseStatus(KErrNone);

    if(!iIptvVodContenClient)

        {

        VCXLOGLO1("No iIptvVodContenClient instance, error in testlogic");

        iLog->Log(_L("*** FAIL *** No iIptvVodContenClient instance, error in testlogic"));

        VCXLOGLO1("<<<CIptvVodContentApiTest::TestGetEcgList");

        return KErrGeneral;

        }

    RPointerArray<CIptvVodContentContentBriefDetails> data;

    CleanupResetAndDestroyPushL(data);

    TUint32 totalAmount = 0;

    TRAPD(err, testCaseStatus = iIptvVodContenClient->GetEcgListL(aCategoryId, aSearchString, aFrom, aAmount, totalAmount, data));

    if(err != KErrNone)

        {

        VCXLOGLO2("* FAIL * GetEcgListL caused a leave: %d.", err);

        testCaseStatus = err;

        }

    else

    if(testCaseStatus != KErrNone)

        {

        VCXLOGLO2("* FAIL * GetEcgListL returned an error: %d.", testCaseStatus);

        }

    else

        {

        VCXLOGLO2("totalAmount = %d", totalAmount);

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

            {

             PrintVodContentBriefDetails(*(data[i]));

            }

        }

    CleanupStack::PopAndDestroy(&data);

    VCXLOGLO1("<<<CIptvVodContentApiTest::TestGetEcgList");

    return testCaseStatus;

    }

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

// CIptvVodContentApiTest::TestGetEcgCategoryList

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

//

TInt CIptvVodContentApiTest::TestGetEcgCategoryList(TIptvCategoryId aParentCategoryId)

    {

    VCXLOGLO1(">>>CIptvVodContentApiTest::TestGetEcgCategoryList");

    TInt testCaseStatus(KErrNone);

    if(!iIptvVodContenClient)

        {

        VCXLOGLO1("No iIptvVodContenClient instance, error in testlogic");

        iLog->Log(_L("*** FAIL *** No iIptvVodContenClient instance, error in testlogic"));

        VCXLOGLO1("<<<CIptvVodContentApiTest::TestGetEcgList");

        return KErrGeneral;

        }

    RPointerArray<CIptvVodContentCategoryBriefDetails> data;

    CleanupResetAndDestroyPushL(data);

    TRAPD(err, testCaseStatus = iIptvVodContenClient->GetEcgCategoryListL(aParentCategoryId, data));

    if(err != KErrNone)

        {

        VCXLOGLO2("* FAIL * GetEcgCategoryListL caused a leave: %d.", err);

        testCaseStatus = err;

        }

    else

    if(testCaseStatus != KErrNone)

        {

        VCXLOGLO2("* FAIL * GetEcgCategoryListL returned an error: %d.", testCaseStatus);

        }

    else

        {

        TInt count = data.Count();

        for (TInt i = 0; i < count; i++)

            {

            PrintVodContentCategoryBriefDetails(*(data[i]));

            }

        }

    CleanupStack::PopAndDestroy(&data);

    VCXLOGLO1("<<<CIptvVodContentApiTest::TestGetEcgCategoryList");

    return testCaseStatus;

    }

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

// CIptvVodContentApiTest::TestGetEcgCategoryDetails

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

//

TInt CIptvVodContentApiTest::TestGetEcgCategoryDetails(TIptvCategoryId aCategoryId)

    {

    VCXLOGLO1(">>>CIptvVodContentApiTest::TestGetCategoryDetails");

    TInt testCaseStatus(KErrNone);

    if(!iIptvVodContenClient)

        {

        VCXLOGLO1("No iIptvVodContenClient instance, error in testlogic");

        iLog->Log(_L("*** FAIL *** No iIptvVodContenClient instance, error in testlogic"));

        VCXLOGLO1("<<<CIptvVodContentApiTest::TestGetEcgList");

        return KErrGeneral;

        }

    CIptvVodContentCategoryBriefDetails* data = CIptvVodContentCategoryBriefDetails::NewL();

    CleanupStack::PushL(data);

    // GetCategoryDetailsL is not supported for search category

    if( aCategoryId != KIptvRssSearchCategoryId )

        {

        TRAPD(err, testCaseStatus = iIptvVodContenClient->GetCategoryDetailsL(aCategoryId, *data));

        if(err != KErrNone)

            {

            VCXLOGLO2("* FAIL * GetCategoryDetailsL caused a leave: %d.", err);

            testCaseStatus = err;

            }

        else

        if(testCaseStatus != KErrNone)

            {

            VCXLOGLO2("* FAIL * GetCategoryDetailsL returned an error: %d.", testCaseStatus);

            }

        else

            {

            PrintVodContentCategoryBriefDetails(*data);

            }

        }

    CleanupStack::PopAndDestroy(data);

    VCXLOGLO1("<<<CIptvVodContentApiTest::TestGetCategoryDetails");

    return testCaseStatus;

    }

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

// CIptvVodContentApiTest::TestGetEcgAllList

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

//

TInt CIptvVodContentApiTest::TestGetEcgAllList(TDesC& aSearchString, TUint32 aFrom, TUint32 aAmount)

    {

    VCXLOGLO1(">>>CIptvVodContentApiTest::TestGetEcgAllList");

    TInt testCaseStatus(KErrNone);

    if(!iIptvVodContenClient)

        {

        VCXLOGLO1("No iIptvVodContenClient instance, error in testlogic");

        iLog->Log(_L("*** FAIL *** No iIptvVodContenClient instance, error in testlogic"));

        VCXLOGLO1("<<<CIptvVodContentApiTest::TestGetEcgList");

        return KErrGeneral;

        }

    RPointerArray<CIptvVodContentContentBriefDetails> data;

    CleanupResetAndDestroyPushL(data);

    TUint32 total=0;

    TRAPD(err, testCaseStatus = iIptvVodContenClient->GetEcgAllListL(aSearchString, aFrom, aAmount, total, data));

    if(err != KErrNone)

        {

        VCXLOGLO2("* FAIL * GetEcgAllListL caused a leave: %d.", err);

        testCaseStatus = err;

        }

    else

    if(testCaseStatus != KErrNone)

        {

        VCXLOGLO2("* FAIL * GetEcgAllListL returned an error: %d.", testCaseStatus);

        }

    else

        {

        VCXLOGLO2("totalAmount = %d", total);

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

            {

            if(!(data[i]))

                {

                VCXLOGLO2("data at %d is NULL!", i);

                testCaseStatus = KErrCorrupt;

                }

            else

                {

                PrintVodContentBriefDetails(*(data[i]));

                }

            }

        }

    CleanupStack::PopAndDestroy(&data);

    VCXLOGLO1("<<<CIptvVodContentApiTest::TestGetEcgAllList");

    return testCaseStatus;

    }

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

// CIptvVodContentApiTest::TestGetParentCategory

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

//

TInt CIptvVodContentApiTest::TestGetParentCategory(TIptvCategoryId aParentCategoryId)

    {

    VCXLOGLO2(">>>CIptvVodContentApiTest::TestGetParentCategory: aParentCategoryId = %d",aParentCategoryId );

    TInt testCaseStatus(KErrNone);

    TInt rv = KErrNone;

    TIptvCategoryId parent = 0;

    if(!iIptvVodContenClient)

        {

        VCXLOGLO1("No iIptvVodContenClient instance, error in testlogic");

        iLog->Log(_L("*** FAIL *** No iIptvVodContenClient instance, error in testlogic"));

        VCXLOGLO1("<<<CIptvVodContentApiTest::TestGetEcgList");

        return KErrGeneral;

        }

    RPointerArray<CIptvVodContentCategoryBriefDetails> data;

    CleanupResetAndDestroyPushL(data);

    VCXLOGLO2("Getting category list for: %d.", aParentCategoryId);

    TRAPD(err, testCaseStatus = iIptvVodContenClient->GetEcgCategoryListL(aParentCategoryId, data));

    if(err != KErrNone)

        {

        VCXLOGLO2("* FAIL * GetEcgCategoryListL caused a leave: %d.", err);

        testCaseStatus = err;

        CleanupStack::PopAndDestroy(&data);

        VCXLOGLO1("<<<CIptvVodContentApiTest::TestGetParentCategory");

        return err;

        }

    if(testCaseStatus != KErrNone)

        {

        VCXLOGLO2("* FAIL * GetEcgCategoryListL returned an error: %d.", testCaseStatus);

        CleanupStack::PopAndDestroy(&data);

        VCXLOGLO1("<<<CIptvVodContentApiTest::TestGetParentCategory");

        return err;

        }

    TInt count = data.Count();

    for (TInt i = 0; i < count; i++)

        {

        VCXLOGLO2("categoryid = %d", data[i]->iCategoryId);

        TRAP(err, rv = iIptvVodContenClient->GetParentCategoryL(data[i]->iCategoryId, parent));

        VCXLOGLO2("Parent = %d", parent);

        if(err != KErrNone)

            {

            VCXLOGLO2("* FAIL * GetParentCategoryL caused a leave: %d.", err);

            testCaseStatus = err;

            break;

            }

        if(rv != KErrNone)

            {

            VCXLOGLO2("CIptvVodContentApiTest::TestGetParentCategory: GetParentCategoryL returned an error: %d", rv);

            testCaseStatus = rv;

            break;

            }

        if(parent != aParentCategoryId)

            {

            VCXLOGLO1("CIptvVodContentApiTest::TestGetParentCategory: ParentCategory id doesn't match");

            testCaseStatus = KErrGeneral;

            break;

            }

        }

    CleanupStack::PopAndDestroy(&data);

    if(count == 0)

        {

        VCXLOGLO1("No Categories found!!!");

        }

    VCXLOGLO1("<<<CIptvVodContentApiTest::TestGetParentCategory");

    return testCaseStatus;

    }

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

// CIptvVodContentApiTest::TestVerifyAllCategoryContentL

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

//

TInt CIptvVodContentApiTest::TestVerifyAllCategoryContentL(TIptvCategoryId aParentCategoryId)

    {

    // KIptvVodContentCategoryRootId

    VCXLOGLO2(">>>CIptvVodContentApiTest::TestVerifyAllCategoryContentL: aParentCategoryId = %d",aParentCategoryId );

    TInt testCaseStatus(KErrNone);

    if(!iIptvVodContenClient)

        {

        VCXLOGLO1("No iIptvVodContenClient instance, error in testlogic");

        iLog->Log(_L("*** FAIL *** No iIptvVodContenClient instance, error in testlogic"));

        VCXLOGLO1("<<<CIptvVodContentApiTest::TestVerifyAllCategoryContentL");

        return KErrGeneral;

        }

    RPointerArray<CIptvVodContentCategoryBriefDetails> categoryList;

    CleanupResetAndDestroyPushL(categoryList);

    testCaseStatus = iIptvVodContenClient->GetEcgCategoryListL(aParentCategoryId, categoryList);

    if(testCaseStatus != KErrNone)

        {

        VCXLOGLO2("* FAIL * GetEcgCategoryListL returned an error: %d.", testCaseStatus);

        CleanupStack::PopAndDestroy(&categoryList);

        VCXLOGLO1("<<<CIptvVodContentApiTest::TestVerifyAllCategoryContentL");

        return testCaseStatus;

        }

    TInt count = categoryList.Count();

    for (TInt i = 0; i < count; i++)

        {

        VCXLOGLO2("categoryid = %d", categoryList[i]->iCategoryId);

        PrintVodContentCategoryBriefDetails( *categoryList[i] );

        testCaseStatus = TestGetEcgCategoryDetails(categoryList[i]->iCategoryId);

        if(testCaseStatus != KErrNone) break;

        RPointerArray<CIptvVodContentContentBriefDetails> ecgList;

        CleanupResetAndDestroyPushL(ecgList);

        TUint32 totalAmount = 0;

        TBuf<10> searchString(_L("") );

        testCaseStatus = iIptvVodContenClient->GetEcgListL(categoryList[i]->iCategoryId, searchString, 0, 0, totalAmount, ecgList);

        if(testCaseStatus != KErrNone)

            {

            VCXLOGLO2("* FAIL * GetEcgListL returned an error: %d.", testCaseStatus);

            CleanupStack::PopAndDestroy(&ecgList);

            break;

            }

        VCXLOGLO2("totalAmount = %d", totalAmount);

        for (TInt e = 0; e < ecgList.Count(); e++)

            {

            PrintVodContentBriefDetails(*(ecgList[e]));

            CIptvVodContentContentFullDetails* contentDetails = CIptvVodContentContentFullDetails::NewL();

            CleanupStack::PushL(contentDetails);

            testCaseStatus = iIptvVodContenClient->GetContentDetailsL(ecgList[e]->iContentId, *contentDetails);

            if(testCaseStatus != KErrNone)

                {

                VCXLOGLO2("* FAIL * GetContentDetailsL returned an error: %d.", testCaseStatus);

                CleanupStack::PopAndDestroy(contentDetails);

                CleanupStack::PopAndDestroy(&ecgList);

                i = 100000;

                break;

                }

            PrintVodContentFullDetails(ecgList[e]->iContentId, *contentDetails);

            CleanupStack::PopAndDestroy(contentDetails);

            }

        CleanupStack::PopAndDestroy(&ecgList);

        }

    CleanupStack::PopAndDestroy(&categoryList);

    if(count == 0)

        {

        VCXLOGLO1("No Categories found!!!");

        }

    VCXLOGLO1("<<<CIptvVodContentApiTest::TestVerifyAllCategoryContentL");

    return testCaseStatus;

    }

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

// CIptvVodContentApiTest::TestGetContentDetailsList

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

//

TInt CIptvVodContentApiTest::TestGetContentDetailsList(TIptvContentId aContentId)

    {

    VCXLOGLO1(">>>CIptvVodContentApiTest::TestGetContentDetailsList");

    TInt testCaseStatus(KErrNone);

    if(!iIptvVodContenClient)

        {

        VCXLOGLO1("No iIptvVodContenClient instance, error in testlogic");

        iLog->Log(_L("*** FAIL *** No iIptvVodContenClient instance, error in testlogic"));

        VCXLOGLO1("<<<CIptvVodContentApiTest::TestGetEcgList");

        return KErrGeneral;

        }

    CIptvVodContentContentFullDetails* contentDetails = CIptvVodContentContentFullDetails::NewL();

    CleanupStack::PushL(contentDetails);

    TRAPD(err, testCaseStatus = iIptvVodContenClient->GetContentDetailsL(aContentId, *contentDetails));

    if(err != KErrNone)

        {

        VCXLOGLO2("* FAIL * GetContentDetailsL caused a leave: %d.", err);

        testCaseStatus = err;

        }

    else

    if(testCaseStatus != KErrNone)

        {

        VCXLOGLO2("* FAIL * GetContentDetailsL returned an error: %d.", testCaseStatus);

        }

    else

        {

        PrintVodContentFullDetails(aContentId, *contentDetails);

        }

    CleanupStack::PopAndDestroy(contentDetails);

    VCXLOGLO1("<<<CIptvVodContentApiTest::TestGetContentDetailsList");

    return testCaseStatus;

    }

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

// CIptvVodContentApiTest::TestUpdateEcg

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

//

TInt CIptvVodContentApiTest::TestUpdateEcg( )

    {

    VCXLOGLO1(">>>CIptvVodContentApiTest::TestUpdateEcg");

     TInt testCaseStatus(KErrNone);

    if(!iIptvVodContenClient)

        {

        VCXLOGLO1("No iIptvVodContenClient instance, error in testlogic");

        iLog->Log(_L("*** FAIL *** No iIptvVodContenClient instance, error in testlogic"));

        VCXLOGLO1("<<<CIptvVodContentApiTest::TestGetEcgList");

        return KErrGeneral;

        }

     TRAPD(err, testCaseStatus = iIptvVodContenClient->UpdateEcgL( ));

    if(err != KErrNone)

        {

        VCXLOGLO2("* FAIL * UpdateEcgL caused a leave: %d.", err);

        testCaseStatus = err;

        }

    else

    if(testCaseStatus != KErrNone)

        {

        VCXLOGLO2("* FAIL * UpdateEcgL returned an error: %d.", testCaseStatus);

        }

    else

        {

        iIptvTestEcgUpdateInfo->EcgUpdateStart(iServiceId, iIapId);

        }

     VCXLOGLO1("<<<CIptvVodContentApiTest::TestUpdateEcg");

     return testCaseStatus;

    }

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

// CIptvVodContentApiTest::TestCategoryCount

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

//

TInt CIptvVodContentApiTest::TestCategoryCountL( TInt aExpectedCount )

    {

    // KIptvVodContentCategoryRootId

    VCXLOGLO1(">>>CIptvVodContentApiTest::TestCategoryCountL");

    TInt err( KErrNone );

    if( !iIptvVodContenClient )

        {

        err = KErrNotReady;

        VCXLOGLO1("No iIptvVodContenClient instance, error in testlogic");

        iLog->Log(_L("*** FAIL *** No iIptvVodContenClient instance, error in testlogic"));

        }

    RPointerArray<CIptvVodContentCategoryBriefDetails> categoryList;

    CleanupResetAndDestroyPushL( categoryList );

    err = iIptvVodContenClient->GetEcgCategoryListL( 0 /* all categories */, categoryList );

    if( err!= KErrNone )

        {

        VCXLOGLO2("* FAIL * GetEcgCategoryListL returned an error: %d.", err);

        }

    else

        {

        if( categoryList.Count() != aExpectedCount )

            {

            VCXLOGLO3("* FAIL * Count of categories (%d) is not expected (%d).", categoryList.Count(), aExpectedCount );

            }

        }

    CleanupStack::PopAndDestroy( &categoryList );

    VCXLOGLO1("<<<CIptvVodContentApiTest::TestCategoryCountL");

    return err;

    }

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

// CIptvVodContentApiTest::TestContentCount

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

//

TInt CIptvVodContentApiTest::TestContentCountL( TInt aExpectedCount )