/*

* 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 FILES

#include <e32svr.h>

#include <StifParser.h>

#include <Stiftestinterface.h>

#include "VCXVodContentApiTest.h"

#include "VCXTestLog.h"

#include "CIptvVodContentClient.h"

#include "CIptvVodContentCategoryBriefDetails.h"

#include "CIptvVodContentContentBriefDetails.h"

#include "CIptvVodContentContentFullDetails.h"

#include "CIptvUtil.h"

#include "CIptvTestTimer.h"

#include "CIptvTestUtilities.h"

#include "CIptvTestEcgUpdateInfo.h"

#include "TIptvRssSearchQuery.h"

#include <CentralRepository.h>

#include <f32file.h>

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

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

// CIptvVodContentApiTest::Delete

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

// Called from destructor.

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

//

void CIptvVodContentApiTest::Delete()

    {

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

    DeAllocateResources();

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

    }

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

// CIptvVodContentApiTest::RunMethodL

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

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

//

TInt CIptvVodContentApiTest::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( "EnableVerifying", CIptvVodContentApiTest::EnableVerifying ),

        ENTRY( "Verify", CIptvVodContentApiTest::Verify ),

        ENTRY( "DeleteEpgDb", CIptvVodContentApiTest::DeleteEpgDb ),

        ENTRY( "Create", CIptvVodContentApiTest::CreateL ),

        ENTRY( "GetEcgList", CIptvVodContentApiTest::GetEcgList ),

        ENTRY( "EcgCategoryList", CIptvVodContentApiTest::EcgCategoryList ),

        ENTRY( "EcgEcgAllList", CIptvVodContentApiTest::EcgEcgAllList ),

        ENTRY( "CategoryDetails", CIptvVodContentApiTest::CategoryDetails ),

        ENTRY( "ParentCategory", CIptvVodContentApiTest::ParentCategory ),

        ENTRY( "ContentDetailsList", CIptvVodContentApiTest::ContentDetailsList ),

        ENTRY( "VerifyAllCategoryContent", CIptvVodContentApiTest::VerifyAllCategoryContentL ),

        ENTRY( "UpdateEcg", CIptvVodContentApiTest::UpdateEcg ),

        ENTRY( "SetTestCaseTimeOut", CIptvVodContentApiTest::SetTestCaseTimeOut ),

        ENTRY( "SelectIap", CIptvVodContentApiTest::SelectIapL ),

        ENTRY( "GetUpdateTime", CIptvVodContentApiTest::GetUpdateTimeL ),

        ENTRY( "SetSpecialAction", CIptvVodContentApiTest::SetSpecialAction ),

        ENTRY( "DisableThumbnails", CIptvVodContentApiTest::DisableThumbnails ),

        ENTRY( "EnableThumbnails", CIptvVodContentApiTest::EnableThumbnails ),

        ENTRY( "SetParentalControlAge", CIptvVodContentApiTest::SetParentalControlAge ),

        ENTRY( "Search", CIptvVodContentApiTest::Search ),

        ENTRY( "CancelSearch", CIptvVodContentApiTest::CancelSearch ),

        ENTRY( "CancelUpdate", CIptvVodContentApiTest::CancelUpdate ),

        ENTRY( "SetLastPosition", CIptvVodContentApiTest::SetLastPosition ),

        ENTRY( "UpdateAvailable", CIptvVodContentApiTest::UpdateAvailableL ),

        ENTRY( "CategoryCount", CIptvVodContentApiTest::CategoryCountL ),

        ENTRY( "ContentCount", CIptvVodContentApiTest::ContentCountL ),

        ENTRY( "SetMsgWhichToSignal", CIptvVodContentApiTest::SetMsgWhichToSignal ),

        ENTRY( "IgnoreMsg", CIptvVodContentApiTest::IgnoreMsg ),

        ENTRY( "Destroy", CIptvVodContentApiTest::Destroy ),

        };

    const TInt count = sizeof( KFunctions ) /

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

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

// CIptvVodContentApiTest::CreateL

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

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

//

TInt CIptvVodContentApiTest::CreateL( CStifItemParser& aItem )

    {

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

    // Print to UI

    _LIT( KIptvVodContentApiTest, "IptvVodContentApiTest" );

    _LIT( KCreateL, "In CreateL" );

    TestModuleIf().Printf( 0, KIptvVodContentApiTest, KCreateL );

    // Print to log file

    iLog->Log( KCreateL );

    //Script parameters:

    // service id, must be >0

    TPtrC serviceName;

    iMsgWhichToSignal = -1;

    iIgnoreMsg = KIptvTestNoSignal;

    TInt testCaseStatus = KErrNone;

    aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);

    if(aItem.GetNextString(serviceName) != KErrNone)

        {

        VCXLOGLO1("Can't read testcase parameter, serviceName/number !!!");

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

        iLog->Log( _L("**** FAIL ***** Can't read testcase parameter!!!") );

        return KErrGeneral;

        }

    VCXLOGLO2("serviceName/orderNumber: %S", &serviceName);

    TInt timeoutValue;

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

        {

        iTimeoutMinutes = timeoutValue;

        }

    else

        {

        iTimeoutMinutes = 4;

        }

    testCaseStatus = CreateInstance(serviceName);

    iRetryCount = 0;

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

    return testCaseStatus;

    }

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

// CIptvVodContentApiTest::DeleteEpgDb();

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

//

TInt CIptvVodContentApiTest::DeleteEpgDb( CStifItemParser& /* aItem */ )

    {

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

    RFs fs;

    fs.Connect();

    CFileMan* fileMan = CFileMan::NewL(fs);

    TBuf<512> path;

//  CIptvUtil::GetPathL(fs, EIptvPathMyVideos, path, EDriveC);

//  fileMan->RmDir(path);

    CIptvUtil::GetPathL(fs, EIptvPathEcg, path, EDriveC);

    fileMan->RmDir(path);

//  CIptvUtil::GetPathL(fs, EIptvPathMyVideos, path, EDriveE);

//  fileMan->RmDir(path);

    CIptvUtil::GetPathL(fs, EIptvPathEcg, path, EDriveE);

    fileMan->RmDir(path);

    delete fileMan;

    fs.Close();

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

    return KErrNone;

    }

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

// CIptvVodContentApiTest::GetEcgList();

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

//

TInt CIptvVodContentApiTest::GetEcgList( CStifItemParser& aItem )

    {

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

    // Print to UI

    _LIT( KIptvVodContentApiTest, "IptvVodContentApiTest" );

    _LIT( KGetEcgList, "In GetEcgList" );

    TestModuleIf().Printf( 0, KIptvVodContentApiTest, KGetEcgList );

    // Print to log file

    iLog->Log( KGetEcgList );

    //Script parameters

    TPtrC  searchStringPtr;

    TInt categoryId = 0;

    TInt from =0;

    TInt amount = 0;

    TInt testCaseStatus = KErrNone;

    TBool isParametersValid = TRUE;

    aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);

   //Script parameters

    if(aItem.GetNextInt(categoryId) != KErrNone)

        {

        isParametersValid = FALSE;

        }

    if(aItem.GetNextString(searchStringPtr) != KErrNone)

        {

        isParametersValid = FALSE;

        }

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

        {

        //check validity

        if(from<0)

            {

            isParametersValid = FALSE;

            }

        }

    else

        {

        isParametersValid = FALSE;

        }

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

        {

        //check validity

        if(amount<0)

            {

            isParametersValid = FALSE;

            }

        }

    else

        {

        isParametersValid = FALSE;

        }

    TBuf<256> searchString(searchStringPtr);

    if(!searchString.Compare(_L("\"\"")) )

        {

        searchString = _L("");

        }

    TUint32 categoryId32 = categoryId;

    if(categoryId == KIptvTestSearchCategoryId)

        {

        categoryId32 = KIptvRssSearchCategoryId;

        }

    VCXLOGLO2("categoryId: %d", categoryId32);

    VCXLOGLO2("searchString: %S", &searchString);

    VCXLOGLO2("from: %d", from);

    VCXLOGLO2("amount: %d", amount);

    if(!isParametersValid)

        {

        VCXLOGLO1("Error in testparameters");

        iLog->Log(_L("Error in testparameters"));

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

        return KErrGeneral;

        }

    //TestGetEcgList(TIptvCategoryId aCategoryId, TDesC& aSearchString, TUint32 aFrom, TUint32 aAmount)

    //testCaseStatus = TestGetEcgList(categoryId, searchString, from,amount);

    testCaseStatus = TestGetEcgList(categoryId32, searchString, from,amount);

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

    return testCaseStatus;

    }

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

// CIptvVodContentApiTest::EnableVerifying();

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

//

TInt CIptvVodContentApiTest::EnableVerifying( CStifItemParser& aItem )

    {

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

    // Print to UI

    _LIT( KIptvVodContentApiTest, "IptvVodContentApiTest" );

    _LIT( KEnableVerifying , "In EnableVerifying" );

    TestModuleIf().Printf( 0, KIptvVodContentApiTest, KEnableVerifying );

    // Print to log file

    iLog->Log( KEnableVerifying );

    //Script parameters

    TInt result = KErrNone;

    TPtrC caseId;

    TInt countNumber = -1;

    TBool isParametersValid = ETrue;

   //Script parameters

    if(aItem.GetNextString(caseId) != KErrNone)

        {

        isParametersValid = EFalse;

        }

    TInt appendInt = 0;

    TBool append = EFalse;

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

        {

        append = static_cast<TBool>(appendInt);

        }

   aItem.GetNextInt(countNumber);

   if(!isParametersValid)

        {

        VCXLOGLO1("Error in testparameters");

        iLog->Log(_L("Error in testparameters"));

        result = KErrGeneral;

        }

    else

        {

        iCaseId = caseId;

        if(countNumber >= 0)

            {

            iCaseId.AppendNum(countNumber);

            }

        iIptvTestUtilities->CreateVerifyData(iCaseId, append);

        }

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

    return result;

    }

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

// CIptvVodContentApiTest::Verify();

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

//

TInt CIptvVodContentApiTest::Verify( CStifItemParser& aItem )

    {

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

    // Print to UI

    _LIT( KIptvVodContentApiTest, "IptvVodContentApiTest" );

    _LIT( KVerify , "In Verify" );

    TestModuleIf().Printf( 0, KIptvVodContentApiTest, KVerify  );

    // Print to log file

    iLog->Log( KVerify  );

    TInt paramCount = 0;

    TPtrC caseId;

    TInt error = KErrNone;

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

        {

        paramCount++;

        VCXLOGLO2("Verifying: %S.", &caseId);

        CIptvTestVerifyData::TVerifyResult verifyResult;

        error = iIptvTestUtilities->VerifyData(caseId, verifyResult);

        if(verifyResult != CIptvTestVerifyData::EVerifyOk)

	    	{

	    	VCXLOGLO3("Verify failed, VerifyResult: %d, err: %d", verifyResult, error);

	    	TestModuleIf().Printf( 0, _L("Verify failed"), _L("") );

	    	error = verifyResult;

	    	}

	    else

	    	{

			VCXLOGLO1("Data verified succesfully.");

	    	}

        }

    if(paramCount == 0)

        {

        error = KErrGeneral;

        VCXLOGLO1("Test case logic error, no CaseId(s) defined for verification..");

        }

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

    return error;

    }

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

// CIptvVodContentApiTest::EcgCategoryList

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

//

TInt CIptvVodContentApiTest::EcgCategoryList( CStifItemParser& aItem )

    {

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

    // Print to UI

    _LIT( KIptvVodContentApiTest, "IptvVodContentApiTest" );

    _LIT( KEcgCategoryList, "In EcgCategoryList" );

    TestModuleIf().Printf( 0, KIptvVodContentApiTest, KEcgCategoryList );

    // Print to log file

    iLog->Log( KEcgCategoryList );

    //Script parameters

    //use KIptvVodContentCategoryRootId

    TInt parentCategoryId = 0;

    TInt testCaseStatus = KErrNone;

    TBool isParametersValid = TRUE;

    if(aItem.GetNextInt(parentCategoryId) != KErrNone)

        {

        isParametersValid = FALSE;

        }

    VCXLOGLO2("parentCategoryId: %d", parentCategoryId);

    if(!isParametersValid)

        {

        VCXLOGLO1("Error in testparameters");

        iLog->Log(_L("Error in testparameters"));

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

        return KErrGeneral;

        }

    TUint32 parentCategoryId32 = parentCategoryId;

    if(parentCategoryId == KIptvTestSearchCategoryId)

        {

        parentCategoryId32 = KIptvRssSearchCategoryId;

        }

    //rv = TestGetEcgCategoryList(TIptvCategoryId aParentCategoryId);

    testCaseStatus = TestGetEcgCategoryList( parentCategoryId32 );

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

    return testCaseStatus;

    }

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

// CIptvVodContentApiTest::EcgEcgAllList

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

//

TInt CIptvVodContentApiTest::EcgEcgAllList( CStifItemParser& aItem )

    {

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

    // Print to UI

    _LIT( KIptvVodContentApiTest, "IptvVodContentApiTest" );

    _LIT( KEcgEcgAllList, "In EcgEcgAllList" );

    TestModuleIf().Printf( 0, KIptvVodContentApiTest, KEcgEcgAllList );

    // Print to log file

    iLog->Log( KEcgEcgAllList );

    TInt testCaseStatus = KErrNone;

    TPtrC searchStringPtr;

    TInt from = 0;

    TInt amount = 0;

    TBool isParametersValid = TRUE;

    aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);

    //Script parameters

    if(aItem.GetNextString(searchStringPtr)==KErrNone)

        {

        //check string content

        }

    else

        {

        //isParametersValid = FALSE;

        }

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

        {

        //check validity

        if(from<0)

            {

            isParametersValid = FALSE;

            }

        }

    else

        {

        isParametersValid = FALSE;

        }

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

        {

        //check validity

        if(amount<0)

            {

            isParametersValid = FALSE;

            }

        }

    else

        {

        isParametersValid = FALSE;

        }

    TBuf<2560> searchString(searchStringPtr);