/*

* Copyright (c) 2009 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:  This file contains testclass implementation.*

*/

// [INCLUDE FILES] - do not remove

#include <e32svr.h>

#include <StifParser.h>

#include <Stiftestinterface.h>

#include <centralrepository.h>

#include "VCXTestLog.h"

#include "VCXScheduledDownloadTest.h"

#include "VCXScheduledDownloadTester.h"

#include "VCXTestCommon.h"

// CONSTANTS

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

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

// CVCXScheduledDownloadTest::Delete

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

// Called from destructor. 

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

//

void CVCXScheduledDownloadTest::Delete() 

    {

    delete iTester;

    iTester = NULL;

    delete iTestCommon;

    iTestCommon = NULL;

    iFs.Close();

    }

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

// CVCXScheduledDownloadTest::RunMethodL

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

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

//

TInt CVCXScheduledDownloadTest::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( "Create", CVCXScheduledDownloadTest::CreateL ),

        ENTRY( "RemoveAllMedias", CVCXScheduledDownloadTest::RemoveAllMediasL ),

        ENTRY( "RemoveAllSchedules", CVCXScheduledDownloadTest::RemoveAllSchedulesL ),

        ENTRY( "RemoveVideo", CVCXScheduledDownloadTest::RemoveVideoL ),

        ENTRY( "Download", CVCXScheduledDownloadTest::DownloadL ),

        ENTRY( "CancelDownload", CVCXScheduledDownloadTest::CancelDownloadL ),

        ENTRY( "WaitForMessages", CVCXScheduledDownloadTest::WaitForMessagesL ),

        ENTRY( "CoolDown", CVCXScheduledDownloadTest::CoolDown ),

        ENTRY( "CheckVideoCount", CVCXScheduledDownloadTest::CheckVideoCount ),

        ENTRY( "CheckMinimumVideoCount", CVCXScheduledDownloadTest::CheckMinimumVideoCount ),

        ENTRY( "CheckMaximumVideoCount", CVCXScheduledDownloadTest::CheckMaximumVideoCount ),

        ENTRY( "CheckError", CVCXScheduledDownloadTest::CheckError ),

        ENTRY( "SetPreferredMemory", CVCXScheduledDownloadTest::SetPreferredMemoryL ),

        // [test cases entries] - Do not remove

        };

    const TInt count = sizeof( KFunctions ) / 

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

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

// CVCXScheduledDownloadTest::CreateL

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

//

TInt CVCXScheduledDownloadTest::CreateL( CStifItemParser& aItem )

    {

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

    // Print to UI

    _LIT( KVCXScheduledDownloadTest, "VCXScheduledDownloadTest" );

    _LIT( KWhere, "In CreateL" );

    TestModuleIf().Printf( 0, KVCXScheduledDownloadTest, KWhere );

    // Print to log file

    iLog->Log( KWhere );

    aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);

    User::LeaveIfError( iFs.Connect() );

    TRAPD( err, iTester = CVCXScheduledDownloadTester::NewL( this ) );

    if( err != KErrNone )

        {

        VCXLOGLO2("CVCXScheduledDownloadTest:: error: %d", err);

        }

    iTestCommon = CVCXTestCommon::NewL();

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

    return err;

    }

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

// CVCXScheduledDownloadTest::RemoveAllMediasL

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

//

TInt CVCXScheduledDownloadTest::RemoveAllMediasL( CStifItemParser& aItem )

    {

    VCXLOGLO1(">>>CVCXScheduledDownloadTest::RemoveAllMediasL");

    // Print to UI

    _LIT( KVCXScheduledDownloadTest, "VCXScheduledDownloadTest" );

    _LIT( KWhere, "In RemoveAllMediasL" );

    TestModuleIf().Printf( 0, KVCXScheduledDownloadTest, KWhere );

    // Print to log file

    iLog->Log( KWhere );

    aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);

    TRAPD( err, iTester->RemoveAllMediasL() );

    if( err != KErrNone )

        {

        VCXLOGLO2("CVCXScheduledDownloadTest:: error: %d", err);

        }

    VCXLOGLO1("<<<CVCXScheduledDownloadTest::RemoveAllMediasL");

    return err;

    }

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

// CVCXScheduledDownloadTest::RemoveAllSchedulesL

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

//

TInt CVCXScheduledDownloadTest::RemoveAllSchedulesL( CStifItemParser& aItem )

    {

    VCXLOGLO1(">>>CVCXScheduledDownloadTest::RemoveAllSchedulesL");

    // Print to UI

    _LIT( KVCXScheduledDownloadTest, "VCXScheduledDownloadTest" );

    _LIT( KWhere, "In RemoveAllSchedulesL" );

    TestModuleIf().Printf( 0, KVCXScheduledDownloadTest, KWhere );

    // Print to log file

    iLog->Log( KWhere );

    aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);

    TRAPD( err, iTester->RemoveAllSchedulesL() );

    if( err != KErrNone )

        {

        VCXLOGLO2("CVCXScheduledDownloadTest:: error: %d", err);

        }

    VCXLOGLO1("<<<CVCXScheduledDownloadTest::RemoveAllSchedulesL");

    return err;

    }

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

// CVCXScheduledDownloadTest::RemoveVideoL

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

//

TInt CVCXScheduledDownloadTest::RemoveVideoL( CStifItemParser& aItem )

    {

    VCXLOGLO1(">>>CVCXScheduledDownloadTest::RemoveAllMediasL");

    // Print to UI

    _LIT( KVCXScheduledDownloadTest, "VCXScheduledDownloadTest" );

    _LIT( KWhere, "In RemoveVideoL" );

    TestModuleIf().Printf( 0, KVCXScheduledDownloadTest, KWhere );

    // Print to log file

    iLog->Log( KWhere );

    aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);

    TInt index;

    User::LeaveIfError( aItem.GetNextInt( index ) );

    TRAPD( err, iTester->RemoveVideoL( index ) );

    if( err != KErrNone )

        {

        VCXLOGLO2("CVCXScheduledDownloadTest:: error: %d", err);

        }

    VCXLOGLO1("<<<CVCXScheduledDownloadTest::RemoveAllMediasL");

    return err;

    }

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

// CVCXScheduledDownloadTest::DownloadL

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

//

TInt CVCXScheduledDownloadTest::DownloadL( CStifItemParser& aItem )

    {

    VCXLOGLO1(">>>CVCXScheduledDownloadTest::DownloadL");

    // Print to UI

    _LIT( KVCXScheduledDownloadTest, "VCXScheduledDownloadTest" );

    _LIT( KWhere, "In DownloadL" );

    TestModuleIf().Printf( 0, KVCXScheduledDownloadTest, KWhere );

    // Print to log file

    iLog->Log( KWhere );

    aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);

    TUint32 iapId(0);

    TPtrC iapName;

    User::LeaveIfError( aItem.GetNextString( iapName ) );

    VCXLOGLO2("CVCXMyVideosCollectionPluginTest:: iapName: %S", &iapName);

    User::LeaveIfError( iTestCommon->GetIapIdL( iapName, iapId ) );

    VCXLOGLO2("CVCXMyVideosCollectionPluginTest:: iapId: %d", iapId);

    TPtrC url;

    User::LeaveIfError( aItem.GetNextString( url ) );

    TPtrC userName;

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

        {

        VCXLOGLO2("CVCXMyVideosCollectionPluginTest:: userName: %S", &userName);

        }

    else

        {

        userName.Set( _L("") );

        }

    TPtrC password;

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

        {

        VCXLOGLO2("CVCXMyVideosCollectionPluginTest:: password: %S", &password);

        }

    else

        {

        password.Set( _L("") );

        }

    TRAPD( err, iTester->DownloadL( url, iapId, userName, password ) );

    VCXLOGLO1("<<<CVCXScheduledDownloadTest::DownloadL");

    return err;

    }

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

// CVCXScheduledDownloadTest::CancelDownloadL

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

//

TInt CVCXScheduledDownloadTest::CancelDownloadL( CStifItemParser& aItem )

    {

    VCXLOGLO1(">>>CVCXScheduledDownloadTest::CancelDownloadL");

    // Print to UI

    _LIT( KVCXScheduledDownloadTest, "VCXScheduledDownloadTest" );

    _LIT( KWhere, "In CancelDownloadL" );

    TestModuleIf().Printf( 0, KVCXScheduledDownloadTest, KWhere );

    // Print to log file

    iLog->Log( KWhere );

    aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);

    TInt index;

    User::LeaveIfError( aItem.GetNextInt( index ) );

    TRAPD( err, iTester->CancelDownloadL( index ) );

    if( err != KErrNone )

        {

        VCXLOGLO2("CVCXScheduledDownloadTest:: error: %d", err);

        }

    VCXLOGLO1("<<<CVCXScheduledDownloadTest::CancelDownloadL");

    return err;

    }

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

// CVCXScheduledDownloadTest::WaitForMessagesL

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

//

TInt CVCXScheduledDownloadTest::WaitForMessagesL( CStifItemParser& aItem )

    {

    VCXLOGLO1(">>>CVCXScheduledDownloadTest::WaitForMessagesL");

    // Print to UI

    _LIT( KVCXScheduledDownloadTest, "VCXScheduledDownloadTest" );

    _LIT( KWhere, "In WaitForMessagesL" );

    TestModuleIf().Printf( 0, KVCXScheduledDownloadTest, KWhere );

    // Print to log file

    iLog->Log( KWhere );

    aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);

    RArray<TInt32> messages;

    TInt timeoutSeconds(0);

    User::LeaveIfError( aItem.GetNextInt( timeoutSeconds ) );

    TInt msg;

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

        {

        messages.Append( msg );

        }

    TInt err( KErrArgument );

    if( messages.Count() > 0 )

        {

        TRAP( err, iTester->WaitForVideoEventsL( timeoutSeconds, messages ) );

        }

    VCXLOGLO1("<<<CVCXScheduledDownloadTest::WaitForMessagesL");

    return err;

    }

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

// CVCXScheduledDownloadTest::CoolDown

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

//

TInt CVCXScheduledDownloadTest::CoolDown( CStifItemParser& aItem )

    {

    VCXLOGLO1(">>>CVCXScheduledDownloadTest::CoolDown");

    // Print to UI

    _LIT( KVCXScheduledDownloadTest, "VCXScheduledDownloadTest" );

    _LIT( KWhere, "In CoolDown" );

    TestModuleIf().Printf( 0, KVCXScheduledDownloadTest, KWhere );

    // Print to log file

    iLog->Log( KWhere );

    aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);

    iTester->CoolDown();

    VCXLOGLO1("<<<CVCXScheduledDownloadTest::CoolDown");

    return KErrNone;

    }

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

// CVCXScheduledDownloadTest::CheckVideoCount

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

//

TInt CVCXScheduledDownloadTest::CheckVideoCount( CStifItemParser& aItem )

    {

    VCXLOGLO1(">>>CVCXScheduledDownloadTest::CheckVideoCount");    

    // Print to UI

    _LIT( KVCXScheduledDownloadTest, "VCXScheduledDownloadTest" );

    _LIT( KWhere, "In CheckVideoCount" );

    TestModuleIf().Printf( 0, KVCXScheduledDownloadTest, KWhere );

    // Print to log file

    iLog->Log( KWhere );

    aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);

    TInt expectedCount;

    User::LeaveIfError( aItem.GetNextInt( expectedCount ) );

    TInt err( KErrNone );

    TRAP( err, iTester->RefreshL() );

    if( err == KErrNone && iTester->VideoCount() != expectedCount )

        {

        err = KErrCorrupt;

        }

    VCXLOGLO1("<<<CVCXScheduledDownloadTest::CheckVideoCount");

    return err;

    }

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

// CVCXScheduledDownloadTest::CheckMinimumVideoCount

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

//

TInt CVCXScheduledDownloadTest::CheckMinimumVideoCount( CStifItemParser& aItem )

    {

    VCXLOGLO1(">>>CVCXScheduledDownloadTest::CheckMinimumVideoCount");    

    // Print to UI

    _LIT( KVCXScheduledDownloadTest, "VCXScheduledDownloadTest" );

    _LIT( KWhere, "In CheckMinimumVideoCount" );

    TestModuleIf().Printf( 0, KVCXScheduledDownloadTest, KWhere );

    // Print to log file

    iLog->Log( KWhere );

    aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);

    TInt expectedCount;

    User::LeaveIfError( aItem.GetNextInt( expectedCount ) );

    TInt err( KErrNone );

    TRAP( err, iTester->RefreshL() );

    if( err == KErrNone && iTester->VideoCount() < expectedCount )

        {

        err = KErrCorrupt;

        }

    VCXLOGLO1("<<<CVCXScheduledDownloadTest::CheckMinimumVideoCount");

    return err;

    }

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

// CVCXScheduledDownloadTest::CheckMaximumVideoCount

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

//

TInt CVCXScheduledDownloadTest::CheckMaximumVideoCount( CStifItemParser& aItem )

    {

    VCXLOGLO1(">>>CVCXScheduledDownloadTest::CheckMaximumVideoCount");    

    // Print to UI

    _LIT( KVCXScheduledDownloadTest, "VCXScheduledDownloadTest" );

    _LIT( KWhere, "In CheckMaximumVideoCount" );

    TestModuleIf().Printf( 0, KVCXScheduledDownloadTest, KWhere );

    // Print to log file

    iLog->Log( KWhere );

    aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);

    TInt expectedCount;

    User::LeaveIfError( aItem.GetNextInt( expectedCount ) );

    TInt err( KErrNone );

    TRAP( err, iTester->RefreshL() );

    if( err == KErrNone && iTester->VideoCount() > expectedCount )

        {

        err = KErrCorrupt;

        }

    VCXLOGLO1("<<<CVCXScheduledDownloadTest::CheckMaximumVideoCount");

    return err;

    }

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

// CVCXScheduledDownloadTest::CheckError

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

//

TInt CVCXScheduledDownloadTest::CheckError( CStifItemParser& aItem )

    {

    VCXLOGLO1(">>>CVCXScheduledDownloadTest::CheckError");    

    // Print to UI

    _LIT( KVCXScheduledDownloadTest, "VCXScheduledDownloadTest" );

    _LIT( KWhere, "In CheckError" );

    TestModuleIf().Printf( 0, KVCXScheduledDownloadTest, KWhere );

    // Print to log file

    iLog->Log( KWhere );

    aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);

    TInt err = iTester->GetLastError();

    VCXLOGLO1("<<<CVCXScheduledDownloadTest::CheckError");

    return err;

    }

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

// CVCXScheduledDownloadTest::SetPreferredMemoryL

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

//

TInt CVCXScheduledDownloadTest::SetPreferredMemoryL( CStifItemParser& aItem )

    {

    VCXLOGLO1(">>>CVCXScheduledDownloadTest::SetPreferredMemoryL ---------->");

    // Print to UI

    _LIT( KVCXMyVideosCollectionPluginTest, "VCXScheduledDownloadTest" );

    _LIT( KWhere, "In SetPreferredMemoryL" );

    TestModuleIf().Printf( 0, KVCXMyVideosCollectionPluginTest, KWhere );

    // Print to log file

    iLog->Log( KWhere );

    aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);

    aItem.SetParsingType( CStifItemParser::EQuoteStyleParsing );

    TInt drive(0);

    User::LeaveIfError( GetDriveParam( aItem, drive ) );

    // These were defined in CVcxMyVideosDownloadUtil::PreferredMemoryDesL()

    const TInt KVcxCenRepUid = 0x102750E2; // same as KIptvCenRepUid in CIptvUtil.h

    const TInt KVcxCenRepPreferredMemoryKey = 0x01; // same as KIptvCenRepPreferredMemoryKey in CIptvUtil.h

    TUid uid;

    uid.iUid = KVcxCenRepUid;

    CRepository* cenRep = CRepository::NewLC( uid );

    User::LeaveIfError( cenRep->Set( KVcxCenRepPreferredMemoryKey, drive ) );

    CleanupStack::PopAndDestroy( cenRep );

    VCXLOGLO1("<<<CVCXScheduledDownloadTest::SetPreferredMemoryL <----------");

    return KErrNone;

    }

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

// CVCXScheduledDownloadTest::GetDriveParam

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

//

TInt CVCXScheduledDownloadTest::GetDriveParam( CStifItemParser& aItem, TInt& aDrive )

    {

    aItem.SetParsingType( CStifItemParser::EQuoteStyleParsing );

    TPtrC driveLetter;

    TInt err = aItem.GetNextString( driveLetter );

    if( err == KErrNone )

        {

        if( driveLetter == _L("anydrive") )

            {

            aDrive = -1;

            }

        else

            {

            err = iFs.CharToDrive( driveLetter[0], aDrive );

            VCXLOGLO3("CVCXScheduledDownloadTest:: drive: %S = %d", &driveLetter, aDrive );

            }

        }

    return err;

    }