/*

* 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 <commdb.h>

#include "mpxmediasettingsenginetest.h"

#include "MPSettEngPluginImplementationUIDs.hrh"

#include "MPSettingsModelForROP.h"

#include "vcxtestlog.h"

#include "IptvTestUtilALR.h"

#include "MPSettingsROPSettings.hrh"

#include "VCXTestCommon.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 ===============================

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

// CMPXMediaSettingsEngineTest::Delete

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

// Called from destructor. 

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

//

void CMPXMediaSettingsEngineTest::Delete() 

    {

    if( iModel )

        {

        delete iModel;

        iModel = NULL;

        }

    REComSession::FinalClose();

    if (iCommDb) 

        {

        delete iCommDb;

        iCommDb = NULL;

        }

    if( iVCXTestCommon )

        {

        delete iVCXTestCommon;

        iVCXTestCommon = NULL;

        }

    }

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

// CMPXMediaSettingsEngineTest::RunMethodL

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

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

//

TInt CMPXMediaSettingsEngineTest::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", CMPXMediaSettingsEngineTest::CreateL ),

        ENTRY( "ListImplementations", CMPXMediaSettingsEngineTest::ListImplementationsL ),

        ENTRY( "LoadSettings", CMPXMediaSettingsEngineTest::LoadSettingsLL ),

        ENTRY( "StoreSettings", CMPXMediaSettingsEngineTest::StoreSettingsLL ),

        ENTRY( "SetVideoContrast", CMPXMediaSettingsEngineTest::SetVideoContrastL ),

        ENTRY( "GetVideoContrast", CMPXMediaSettingsEngineTest::GetVideoContrastL ),

        ENTRY( "SetProxyMode", CMPXMediaSettingsEngineTest::SetProxyModeL ),

        ENTRY( "GetProxyMode", CMPXMediaSettingsEngineTest::GetProxyModeL ),

        ENTRY( "SetProxyHostName", CMPXMediaSettingsEngineTest::SetProxyHostNameLL ),

        ENTRY( "GetProxyHostName", CMPXMediaSettingsEngineTest::GetProxyHostNameL ),

        ENTRY( "SetProxyPort", CMPXMediaSettingsEngineTest::SetProxyPortL ),

        ENTRY( "GetProxyPort", CMPXMediaSettingsEngineTest::GetProxyPortL ),

        ENTRY( "SetDefaultAp", CMPXMediaSettingsEngineTest::SetDefaultApL ),

        ENTRY( "GetDefaultAp", CMPXMediaSettingsEngineTest::GetDefaultApL ),

        ENTRY( "SetBandwidthControlMode", CMPXMediaSettingsEngineTest::SetBandwidthControlModeL ),

        ENTRY( "GetBandwidthControlMode", CMPXMediaSettingsEngineTest::GetBandwidthControlModeL ),

        ENTRY( "SetMaxBandwidth", CMPXMediaSettingsEngineTest::SetMaxBandwidthL ),

        ENTRY( "GetMaxBandwidth", CMPXMediaSettingsEngineTest::GetMaxBandwidthL ),

        ENTRY( "SetConnectionTimeout", CMPXMediaSettingsEngineTest::SetConnectionTimeoutL ),

        ENTRY( "GetConnectionTimeout", CMPXMediaSettingsEngineTest::GetConnectionTimeoutL ),

        ENTRY( "SetServerTimeout", CMPXMediaSettingsEngineTest::SetServerTimeoutL ),

        ENTRY( "GetServerTimeout", CMPXMediaSettingsEngineTest::GetServerTimeoutL ),

        ENTRY( "SetMinUDPPort", CMPXMediaSettingsEngineTest::SetMinUDPPortL ),

        ENTRY( "GetMinUDPPort", CMPXMediaSettingsEngineTest::GetMinUDPPortL ),

        ENTRY( "SetMaxUDPPort", CMPXMediaSettingsEngineTest::SetMaxUDPPortL ),

        ENTRY( "GetMaxUDPPort", CMPXMediaSettingsEngineTest::GetMaxUDPPortL ),

        ENTRY( "GetControllerVersionInfo", CMPXMediaSettingsEngineTest::GetControllerVersionInfoL ),

        ENTRY( "GetControllerBuildDate", CMPXMediaSettingsEngineTest::GetControllerBuildDateL ),

        ENTRY( "GetControllerAdditionalInfo", CMPXMediaSettingsEngineTest::GetControllerAdditionalInfoL ),

        ENTRY( "SetDemandBwFactor", CMPXMediaSettingsEngineTest::SetDemandBwFactorL ),

        ENTRY( "GetDemandBwFactor", CMPXMediaSettingsEngineTest::GetDemandBwFactorL ),

        ENTRY( "SetSustainBandwidth", CMPXMediaSettingsEngineTest::SetSustainBandwidthL ),

        ENTRY( "GetSustainBandwidth", CMPXMediaSettingsEngineTest::GetSustainBandwidthL ),

        ENTRY( "GetSustainBwPresets", CMPXMediaSettingsEngineTest::GetSustainBwPresetsLL ),

        ENTRY( "GetMaxBwPresets", CMPXMediaSettingsEngineTest::GetMaxBwPresetsLL ),

        ENTRY( "SetAutoDisconTime", CMPXMediaSettingsEngineTest::SetAutoDisconTimeLL ),

        ENTRY( "AutoDisconTime", CMPXMediaSettingsEngineTest::AutoDisconTimeLL ),

        ENTRY( "SetVideoRepeat", CMPXMediaSettingsEngineTest::SetVideoRepeatLL ),

        ENTRY( "IsVideoRepeatOn", CMPXMediaSettingsEngineTest::IsVideoRepeatOnLL ),

        ENTRY( "SetDefaultView", CMPXMediaSettingsEngineTest::SetDefaultViewLL ),

        ENTRY( "IsDefaultViewOn", CMPXMediaSettingsEngineTest::IsDefaultViewOnLL ),

        ENTRY( "SetRockerKeys", CMPXMediaSettingsEngineTest::SetRockerKeysLL ),

        ENTRY( "ShowRockerKeys", CMPXMediaSettingsEngineTest::ShowRockerKeysLL ),

        ENTRY( "IsRockerKeysSupported", CMPXMediaSettingsEngineTest::IsRockerKeysSupportedLL ),

        //ADD NEW ENTRY HERE

        // [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 CMPXMediaSettingsEngineTest::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::LogMethod

// Generate log from current method

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

//

TInt CMPXMediaSettingsEngineTest::CreateL( CStifItemParser& aItem )

    {

    LogMethod(_L("CreateL"));

    VCXLOGLO1("--> CMPXMediaSettingsEngineTest::CreateL");

    TInt error( 0 );

    iVCXTestCommon = CVCXTestCommon::NewL();

    const TUid KSettingsModelForROPUid = {KMPSettEngImplUidROP};

    iModel = CMPSettingsModel::NewL(KSettingsModelForROPUid);

    iSettingsModel = static_cast<CMPSettingsModelForROP*>(iModel);

    VCXLOGLO2("<-- CMPXMediaSettingsEngineTest::CreateL return %d", error);

    return error;

    }

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

// CVideoScheduler_ApiTest::ListImplementationsL

// List implementations of mpsettingsmodel

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

//

TInt CMPXMediaSettingsEngineTest::ListImplementationsL( CStifItemParser& aItem )

    {

    LogMethod(_L("ListImplementationsL"));

    VCXLOGLO1("--> CMPXMediaSettingsEngineTest::ListImplementationsL");

    TInt error( 0 );

    RImplInfoPtrArray array;

    iSettingsModel->ListImplementationsL( array );

    TInt i( 0 );

    for( i = 0; i < array.Count(); i++ )

        {

        VCXLOGLO3("CMPXMediaSettingsEngineTest::ListImplementationsL, [%d] uid = %d", i, array[i]->ImplementationUid() );

        }

    VCXLOGLO2("<-- CMPXMediaSettingsEngineTest::ListImplementationsL return %d", error);

    return error;

    }

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

// CVideoScheduler_ApiTest::LogMethod

// Generate log from current method

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

//

TInt CMPXMediaSettingsEngineTest::LoadSettingsLL( CStifItemParser& aItem )

    {

    LogMethod(_L("LoadSettingsLL"));

    VCXLOGLO1("--> CMPXMediaSettingsEngineTest::LoadSettingsLL");

    TInt configVersion(0);

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

    TRAPD( error, iSettingsModel->LoadSettingsL( configVersion ) );

    if( error != KErrNone )

        {

        VCXLOGLO2("CMPXMediaSettingsEngineTest::LoadSettingsLL -- error after call: %d", error );

        return error;

        }

    VCXLOGLO1("<-- CMPXMediaSettingsEngineTest::LoadSettingsLL");

    return error;

    }

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

// CVideoScheduler_ApiTest::LogMethod

// Generate log from current method

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

//

TInt CMPXMediaSettingsEngineTest::StoreSettingsLL( CStifItemParser& /*aItem*/ )

    {

    LogMethod(_L("StoreSettingsLL"));

    VCXLOGLO1("--> CMPXMediaSettingsEngineTest::StoreSettingsLL");

    TRAPD( error, iSettingsModel->StoreSettingsL() );

    VCXLOGLO1("<-- CMPXMediaSettingsEngineTest::StoreSettingsLL");

    return error;

    }

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

// CVideoScheduler_ApiTest::LogMethod

// Generate log from current method

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

//

TInt CMPXMediaSettingsEngineTest::SetVideoContrastL( CStifItemParser& aItem )

    {

    LogMethod(_L("SetVideoContrastL"));

    VCXLOGLO1("--> CMPXMediaSettingsEngineTest::SetVideoContrastL");

    TInt error( 0 );

    TInt value(0);

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

    error = iSettingsModel->SetVideoContrast( value );

    VCXLOGLO2("CMPXMediaSettingsEngineTest::SetVideoContrastL -- error after call: %d", error );

    VCXLOGLO1("<-- CMPXMediaSettingsEngineTest::SetVideoContrastL");

    return error;

    }

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

// CVideoScheduler_ApiTest::LogMethod

// Generate log from current method

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

//

TInt CMPXMediaSettingsEngineTest::GetVideoContrastL( CStifItemParser& aItem )

    {

    LogMethod(_L("GetVideoContrastL"));

    VCXLOGLO1("--> CMPXMediaSettingsEngineTest::GetVideoContrastL");

    TInt error( 0 );

    TInt expectedValue(0);

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

    TInt value( 0 );

    error = iSettingsModel->GetVideoContrast( value );

    if( error != KErrNone )

        {

        VCXLOGLO2("CMPXMediaSettingsEngineTest::GetVideoContrastL -- error after call: %d", error );

        return error;

        }

    if( value != expectedValue )

        {

        VCXLOGLO3("CMPXMediaSettingsEngineTest::GetVideoContrastL -- value %d, expected value %d", value, expectedValue);

        error = KErrCorrupt;

        }

    VCXLOGLO1("<-- CMPXMediaSettingsEngineTest::GetVideoContrastL");

    return error;

    }

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

// CVideoScheduler_ApiTest::SetProxyModeL

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

//

TInt CMPXMediaSettingsEngineTest::SetProxyModeL( CStifItemParser& aItem )

    {

    LogMethod(_L("SetProxyModeL"));

    VCXLOGLO1("--> CMPXMediaSettingsEngineTest::SetProxyModeL");

    TInt error( 0 );

    TInt value(0);

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

    error = iSettingsModel->SetProxyMode( value );

    VCXLOGLO2("CMPXMediaSettingsEngineTest::SetProxyModeL -- error after call: %d", error );

    VCXLOGLO1("<-- CMPXMediaSettingsEngineTest::SetProxyModeL");

    return error;

    }

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

// CVideoScheduler_ApiTest::GetProxyModeL

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

//

TInt CMPXMediaSettingsEngineTest::GetProxyModeL ( CStifItemParser& aItem )

    {

    LogMethod(_L("GetProxyModeL"));

    VCXLOGLO1("--> CMPXMediaSettingsEngineTest::GetProxyModeL");

    TInt error( 0 );

    TInt expectedValue(0);

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

    TInt value( 0 );

    error = iSettingsModel->GetProxyMode( value );

    if( error != KErrNone )

        {

        VCXLOGLO2("CMPXMediaSettingsEngineTest::GetProxyModeL -- error after call: %d", error );

        return error;

        }

    if( value != expectedValue )

        {

        VCXLOGLO3("CMPXMediaSettingsEngineTest::GetProxyModeL -- value %d, expected value %d", value, expectedValue);

        error = KErrCorrupt;

        }

    VCXLOGLO1("<-- CMPXMediaSettingsEngineTest::GetProxyModeL");

    return error;

    }

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

// CVideoScheduler_ApiTest::SetProxyHostNameLL

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

//

TInt CMPXMediaSettingsEngineTest::SetProxyHostNameLL( CStifItemParser& aItem )

    {

    LogMethod(_L("SetProxyHostNameLL"));

    VCXLOGLO1("--> CMPXMediaSettingsEngineTest::SetProxyHostNameLL");

    TPtrC value;

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

    TRAPD( error, iSettingsModel->SetProxyHostNameL( value ) );

    VCXLOGLO2("CMPXMediaSettingsEngineTest::SetProxyHostNameLL -- error after call: %d", error );

    VCXLOGLO2("<-- CMPXMediaSettingsEngineTest::SetProxyHostNameLL return %d", error);

    return error;

    }

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

// CVideoScheduler_ApiTest::GetProxyHostNameL

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

//

TInt CMPXMediaSettingsEngineTest::GetProxyHostNameL( CStifItemParser& aItem )

    {

    LogMethod(_L("GetProxyHostNameL"));

    VCXLOGLO1("--> CMPXMediaSettingsEngineTest::GetProxyHostNameL");

    TPtrC expectedValue;

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

    TBuf<256> value;

    TRAPD( error, iSettingsModel->GetProxyHostName( value ) );

    if( error != KErrNone )

        {

        VCXLOGLO2("CMPXMediaSettingsEngineTest::GetProxyHostNameL -- error after call: %d", error );

        return error;

        }

    if( value.CompareC(expectedValue) )

        {

        VCXLOGLO3("CMPXMediaSettingsEngineTest::GetProxyHostNameL -- value %S, expected value %S", &value, &expectedValue);

        error = KErrCorrupt;

        }

    VCXLOGLO2("<-- CMPXMediaSettingsEngineTest::GetProxyHostNameL return %d", error);

    return error;

    }

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

// CVideoScheduler_ApiTest::SetProxyPortL

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

//

TInt CMPXMediaSettingsEngineTest::SetProxyPortL( CStifItemParser& aItem )

    {

    LogMethod(_L("SetProxyPortL"));

    VCXLOGLO1("--> CMPXMediaSettingsEngineTest::SetProxyPortL");

    TInt error( 0 );

    TInt value(0);

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

    error = iSettingsModel->SetProxyPort( value );

    VCXLOGLO2("CMPXMediaSettingsEngineTest::SetProxyPortL -- error after call: %d", error );

    VCXLOGLO2("<-- CMPXMediaSettingsEngineTest::SetProxyPortL return %d", error);

    return error;

    }

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

// CVideoScheduler_ApiTest::GetProxyPortL

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

//

TInt CMPXMediaSettingsEngineTest::GetProxyPortL( CStifItemParser& aItem )

    {

    LogMethod(_L("GetProxyPortL"));

    VCXLOGLO1("--> CMPXMediaSettingsEngineTest::GetProxyPortL");

    TInt error( 0 );

    TInt expectedValue(0);

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

    TInt value( 0 );

    error = iSettingsModel->GetProxyPort( value );

    if( error != KErrNone )

        {

        VCXLOGLO2("CMPXMediaSettingsEngineTest::GetProxyPortL -- error after call: %d", error );

        return error;

        }

    if( value != expectedValue )

        {

        VCXLOGLO3("CMPXMediaSettingsEngineTest::GetProxyPortL -- value %d, expected value %d", value, expectedValue);

        error = KErrCorrupt;

        }

    VCXLOGLO1("<-- CMPXMediaSettingsEngineTest::GetProxyPortL");    

    return error;

    }

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

// CVideoScheduler_ApiTest::SetDefaultApL

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

//

TInt CMPXMediaSettingsEngineTest::SetDefaultApL( CStifItemParser& aItem )

    {

    LogMethod(_L("SetDefaultApL"));

    VCXLOGLO1("--> CMPXMediaSettingsEngineTest::SetDefaultApL");

    TInt error( 0 );

    TPtrC iapName;

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

    TUint32 iapId( 0 );

    TBool iapFound = iVCXTestCommon->GetIapIdL( iapName, iapId );

    if( !iapFound )

        {

        VCXLOGLO2("CMPXMediaSettingsEngineTest::SetDefaultApL -- no IAP id found, using %d", KDefaultIapId );

        iapId = KDefaultIapId;

        }

    error = iSettingsModel->SetDefaultAp( iapId );

    VCXLOGLO2("CMPXMediaSettingsEngineTest::SetDefaultApL -- error after call: %d", error );

    VCXLOGLO2("<-- CMPXMediaSettingsEngineTest::SetDefaultApL return %d", error);

    return error;

    }

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

// CVideoScheduler_ApiTest::GetDefaultApL

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

//

TInt CMPXMediaSettingsEngineTest::GetDefaultApL( CStifItemParser& aItem )

    {

    LogMethod(_L("GetDefaultApL"));

    VCXLOGLO1("--> CMPXMediaSettingsEngineTest::GetDefaultApL");