/*

* 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:   ?Description*

*/

// [INCLUDE FILES] - do not remove

#include <e32svr.h>

#include <StifParser.h>

#include <Stiftestinterface.h>

#include "videoscheduler_apitest.h"

#include <S32MEM.H>

#include <ipvideo/CCseSchedulerAPI.h>

#include <ipvideo/CCseScheduledProgram.h>

#include "vcxtestlog.h"

// EXTERNAL DATA STRUCTURES

//extern  ?external_data;

// EXTERNAL FUNCTION PROTOTYPES

//extern ?external_function( ?arg_type,?arg_type );

// CONSTANTS

//const ?type ?constant_var = ?constant;

// MACROS

//#define ?macro ?macro_def

// LOCAL CONSTANTS AND MACROS

//const ?type ?constant_var = ?constant;

//#define ?macro_name ?macro_def

// MODULE DATA STRUCTURES

//enum ?declaration

//typedef ?declaration

// LOCAL FUNCTION PROTOTYPES

//?type ?function_name( ?arg_type, ?arg_type );

// FORWARD DECLARATIONS

//class ?FORWARD_CLASSNAME;

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

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

// ?function_name ?description.

// ?description

// Returns: ?value_1: ?description

//          ?value_n: ?description_line1

//                    ?description_line2

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

//

/*

?type ?function_name(

    ?arg_type arg,  // ?description

    ?arg_type arg)  // ?description

    {

    ?code  // ?comment

    // ?comment

    ?code

    }

*/

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

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

// CVideoScheduler_ApiTest::Delete

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

// Called from destructor.

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

//

void CVideoScheduler_ApiTest::Delete()

    {

    if( iApi )

        {

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

            {

            iApi->RemoveSchedule( iAddedProgramIds[i] );

            }

        }

    delete iApi;

    iApi = NULL;

    delete iProgram;

    iProgram = NULL;

    delete iExternalizeBuff;

    iExternalizeBuff = NULL;

    iAddedProgramIds.Close();

    }

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

// CVideoScheduler_ApiTest::RunMethodL

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

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

//

TInt CVideoScheduler_ApiTest::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( "API_NewL", CVideoScheduler_ApiTest::API_NewL ),

        ENTRY( "API_AddSchedule", CVideoScheduler_ApiTest::API_AddScheduleL ),

        ENTRY( "API_RemoveSchedule", CVideoScheduler_ApiTest::API_RemoveScheduleL ),

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

        ENTRY( "API_GetSchedule", CVideoScheduler_ApiTest::API_GetScheduleL ),

        ENTRY( "API_GetSchedulesByAppUid", CVideoScheduler_ApiTest::API_GetSchedulesByAppUidL ),

        ENTRY( "API_GetOverlappingSchedules", CVideoScheduler_ApiTest::API_GetOverlappingSchedulesL ),

        ENTRY( "API_GetSchedulesByPluginUid", CVideoScheduler_ApiTest::API_GetSchedulesByPluginUidL ),

        ENTRY( "API_GetSchedulesByType", CVideoScheduler_ApiTest::API_GetSchedulesByTypeL ),

        ENTRY( "API_GetSchedulesByTime", CVideoScheduler_ApiTest::API_GetSchedulesByTimeL ),

        ENTRY( "Program_NewL", CVideoScheduler_ApiTest::Program_NewL ),

        ENTRY( "Program_NewLFromProgram", CVideoScheduler_ApiTest::Program_NewLFromProgramL ),

        ENTRY( "Program_Externalize", CVideoScheduler_ApiTest::Program_ExternalizeLL ),

        ENTRY( "Program_Internalize", CVideoScheduler_ApiTest::Program_InternalizeLL ),

        ENTRY( "Program_ExternalizeLength", CVideoScheduler_ApiTest::Program_ExternalizeLengthL ),

        ENTRY( "Program_SetPluginType", CVideoScheduler_ApiTest::Program_SetPluginTypeL ),

        ENTRY( "Program_SetName", CVideoScheduler_ApiTest::Program_SetNameL ),

        ENTRY( "Program_SetStartTime", CVideoScheduler_ApiTest::Program_SetStartTimeL ),

        ENTRY( "Program_SetEndTime", CVideoScheduler_ApiTest::Program_SetEndTimeL ),

        ENTRY( "Program_SetAppUid", CVideoScheduler_ApiTest::Program_SetAppUidL ),

        ENTRY( "Program_SetPluginUid", CVideoScheduler_ApiTest::Program_SetPluginUidL ),

        ENTRY( "Program_SetApplicationData", CVideoScheduler_ApiTest::Program_SetApplicationDataLL ),

        ENTRY( "Program_SetDbIdentifier", CVideoScheduler_ApiTest::Program_SetDbIdentifierL ),

        ENTRY( "Program_SetScheduleType", CVideoScheduler_ApiTest::Program_SetScheduleTypeL ),

        ENTRY( "Program_PluginType", CVideoScheduler_ApiTest::Program_PluginTypeL ),

        ENTRY( "Program_Name", CVideoScheduler_ApiTest::Program_NameL ),

        ENTRY( "Program_StartTime", CVideoScheduler_ApiTest::Program_StartTimeL ),

        ENTRY( "Program_EndTime", CVideoScheduler_ApiTest::Program_EndTimeL ),

        ENTRY( "Program_AppUid", CVideoScheduler_ApiTest::Program_AppUidL ),

        ENTRY( "Program_PluginUid", CVideoScheduler_ApiTest::Program_PluginUidL ),

        ENTRY( "Program_ApplicationData", CVideoScheduler_ApiTest::Program_ApplicationDataL ),

        ENTRY( "Program_DbIdentifier", CVideoScheduler_ApiTest::Program_DbIdentifierL ),

        ENTRY( "Program_ScheduleType", CVideoScheduler_ApiTest::Program_ScheduleTypeL ),

        ENTRY( "Program_DebugDump", CVideoScheduler_ApiTest::Program_DebugDumpL ),

        ENTRY( "Program_SetToFuture", CVideoScheduler_ApiTest::Program_SetToFutureL ),

        // [test cases entries] - Do not remove

        };

    const TInt count = sizeof( KFunctions ) /

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

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

// CVideoScheduler_ApiTest::LogMethod

// Generate log from current method

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

//

void CVideoScheduler_ApiTest::LogMethod( TPtrC aMethod )

    {

    // Print to UI

    TBuf< 64 > buffer;

    buffer.Format( KLogLocation, &aMethod );

    TestModuleIf().Printf( 0, KTestModuleName, buffer );

    // Print to log file

    iLog->Log( buffer );

    }

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

// CVideoScheduler_ApiTest::API_NewL

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

//

TInt CVideoScheduler_ApiTest::API_NewL( CStifItemParser& aItem )

    {

    LogMethod(_L("API_NewL"));

    TInt err( KErrNone );

    iApi = CCseSchedulerApi::NewL();

    TInt createProgram( 1 );

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

        {

        createProgram = 1;

        }

    if( createProgram == 1 )

        {

        iProgram = CCseScheduledProgram::NewL();

        RPointerArray<CCseScheduledProgram> programs;    

        err = iApi->GetSchedulesByAppUid( 0x020202, programs );

        if( err == KErrNone )

            {

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

                {

                iApi->RemoveSchedule( programs[i]->DbIdentifier() );

                }

            }

        programs.ResetAndDestroy();

        }

    return err;

    }

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

// CVideoScheduler_ApiTest::API_AddScheduleL

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

//

TInt CVideoScheduler_ApiTest::API_AddScheduleL( CStifItemParser& /*aItem*/ )

    {

    LogMethod(_L("API_AddSchedule"));

    VCXLOGLO1("CVideoScheduler_ApiTest::API_AddScheduleL ------>");

    TInt err( KErrNone );

    err = iApi->AddSchedule( *iProgram );

    VCXLOGLO2("CVideoScheduler_ApiTest::API_AddScheduleL: DBID after: %d", iProgram->DbIdentifier() );

    iAddedProgramIds.Append( iProgram->DbIdentifier() );

    return err;

    }

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

// CVideoScheduler_ApiTest::API_RemoveScheduleL

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

//

TInt CVideoScheduler_ApiTest::API_RemoveScheduleL( CStifItemParser& aItem )

    {

    VCXLOGLO1("CVideoScheduler_ApiTest::API_RemoveScheduleL ------>");

    LogMethod(_L("API_RemoveScheduleL"));

    TInt err( KErrNone );

    VCXLOGLO2("CVideoScheduler_ApiTest::API_RemoveScheduleL: DBID: %d", iProgram->DbIdentifier() );

    TUint32 id = iProgram->DbIdentifier();

    err = iApi->RemoveSchedule( id );

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

        {

        if( iAddedProgramIds[i] == id )

            {

            iAddedProgramIds.Remove( i );

            break;

            }

        }    

    return err;

    }

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

// CVideoScheduler_ApiTest::RemoveAllSchedulesL

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

//

TInt CVideoScheduler_ApiTest::RemoveAllSchedulesL( CStifItemParser& /*aItem*/ )

    {

    VCXLOGLO1("CVideoScheduler_ApiTest::RemoveAllSchedulesL ------>");

    LogMethod(_L("RemoveAllSchedulesL"));

    TInt err( KErrNone );

    while( iAddedProgramIds.Count() )

        {

        VCXLOGLO2("CVideoScheduler_ApiTest::RemoveAllSchedulesL -- remove ID %d", iAddedProgramIds[0]);

        err = iApi->RemoveSchedule( iAddedProgramIds[0] );

        iAddedProgramIds.Remove( 0 );

        if( err != KErrNone )

            {

            VCXLOGLO2("CVideoScheduler_ApiTest::RemoveAllSchedulesL -- Failed: %d", err);

            }

        }

    VCXLOGLO2("CVideoScheduler_ApiTest::RemoveAllSchedulesL <------ %d", err);

    return err;

    }

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

// CVideoScheduler_ApiTest::API_GetScheduleL

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

//

TInt CVideoScheduler_ApiTest::API_GetScheduleL( CStifItemParser& /*aItem*/ )

    {

    VCXLOGLO1("CVideoScheduler_ApiTest::API_GetScheduleL ------>");

    LogMethod(_L("API_GetScheduleL"));

    TInt err( KErrNone );

    CCseScheduledProgram* program = CCseScheduledProgram::NewL();

    CleanupStack::PushL( program );

    err = iApi->GetSchedule( iProgram->DbIdentifier(), program );

    if( err == KErrNone )

        {

        if( !program )

            {

            VCXLOGLO1("CVideoScheduler_ApiTest::API_GetScheduleL: Error, program is NULL.");

            err = KErrCorrupt;

            }

        else

            {

            err = ComparePrograms( *program, *iProgram );

            }

        }

    CleanupStack::PopAndDestroy( program );

    return err;

    }

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

// CVideoScheduler_ApiTest::API_GetSchedulesByAppUidL

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

//

TInt CVideoScheduler_ApiTest::API_GetSchedulesByAppUidL( CStifItemParser& aItem )

    {

    VCXLOGLO1("CVideoScheduler_ApiTest::API_GetSchedulesByAppUidL ------>");

    LogMethod(_L("API_GetSchedulesByAppUidL"));

    TInt err( KErrNone );

    TInt appUid( 0 );

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

    TInt expectedCount(0);

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

    RPointerArray<CCseScheduledProgram> programs;    

    err = iApi->GetSchedulesByAppUid( appUid, programs );

    if( err == KErrNone )

        {

        if( programs.Count() != expectedCount )

            {

            err = KErrCorrupt;

            }

        else 

        if( programs.Count() > 0 )

            {

            delete iProgram;

            iProgram = NULL;

            iProgram = programs[0];

            programs.Remove( 0 );

            }

        }

    programs.ResetAndDestroy();

    return err;

    }

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

// CVideoScheduler_ApiTest::API_GetOverlappingSchedulesL

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

//

TInt CVideoScheduler_ApiTest::API_GetOverlappingSchedulesL( CStifItemParser& aItem )

    {

    VCXLOGLO1("CVideoScheduler_ApiTest::API_GetOverlappingSchedulesL ------>");

    LogMethod(_L("API_GetOverlappingSchedulesL"));

    TInt err( KErrNone );

    TInt expectedCount(0);

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

    RPointerArray<CCseScheduledProgram> programs;

    err = iApi->GetOverlappingSchedules( *iProgram, programs );

    if( err == KErrNone )

        {

        if( programs.Count() != expectedCount )

            {

            err = KErrCorrupt;

            }

        else 

        if( programs.Count() > 0 )

            {

            delete iProgram;

            iProgram = NULL;

            iProgram = programs[0];

            programs.Remove( 0 );

            }

        }

    programs.ResetAndDestroy();

    return err;

    }

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

// CVideoScheduler_ApiTest::API_GetSchedulesByPluginUidL

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

//

TInt CVideoScheduler_ApiTest::API_GetSchedulesByPluginUidL( CStifItemParser& aItem )

    {

    VCXLOGLO1("CVideoScheduler_ApiTest::API_GetSchedulesByPluginUidL ------>");

    LogMethod(_L("API_GetSchedulesByPluginUidL"));

    TInt err( KErrNone );

    TInt pluginUid( 0 );

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

    TInt expectedCount(0);

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

    RPointerArray<CCseScheduledProgram> programs;

    err = iApi->GetSchedulesByPluginUid( pluginUid, programs );

    if( err == KErrNone )

        {

        if( programs.Count() != expectedCount )

            {

            err = KErrCorrupt;

            }

        else 

        if( programs.Count() > 0 )

            {

            delete iProgram;

            iProgram = NULL;

            iProgram = programs[0];

            programs.Remove( 0 );

            }

        }    

    programs.ResetAndDestroy();

    return err;

    }

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

// CVideoScheduler_ApiTest::API_GetSchedulesByTypeL

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

//

TInt CVideoScheduler_ApiTest::API_GetSchedulesByTypeL( CStifItemParser& aItem )

    {

    VCXLOGLO1("CVideoScheduler_ApiTest::API_GetSchedulesByTypeL ------>");

    LogMethod(_L("API_GetSchedulesByTypeL"));

    TInt err( KErrNone );

    TInt type(0);

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

    TInt expectedCount(0);

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

    RPointerArray<CCseScheduledProgram> programs;

    err = iApi->GetSchedulesByType( type, programs );

    if( err == KErrNone )

        {

        VCXLOGLO2("CVideoScheduler_ApiTest::API_GetSchedulesByTypeL count:    %d", programs.Count());

        VCXLOGLO2("CVideoScheduler_ApiTest::API_GetSchedulesByTypeL expected: %d", expectedCount);

        if( programs.Count() != expectedCount )

            {

            err = KErrCorrupt;

            }

        else 

        if( programs.Count() > 0 )

            {

            delete iProgram;

            iProgram = NULL;

            iProgram = programs[0];

            programs.Remove( 0 );

            }        

        }

    programs.ResetAndDestroy();

    return err;

    }

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

// CVideoScheduler_ApiTest::API_GetSchedulesByTimeL

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

//

TInt CVideoScheduler_ApiTest::API_GetSchedulesByTimeL( CStifItemParser& aItem )

    {

    VCXLOGLO1("CVideoScheduler_ApiTest::API_GetSchedulesByTimeL ------>");

    LogMethod(_L("API_GetSchedulesByTimeL"));

    TInt err( KErrNone );

    TInt intervalStart( 0 );

    TInt intervalEnd( 0 );

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

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

    TTime startTime( 0 );

    TTime endTime( 0 );

    startTime.UniversalTime();

    endTime.UniversalTime();

    startTime += TTimeIntervalSeconds( intervalStart );