/*

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

#include <centralrepository.h>

#include <mmf/common/mmfcontrollerpluginresolver.h> // CleanupResetAndDestroyPushL

#include <StifParser.h>

#include <Stiftestinterface.h>

#include "VCXConnUtilTest.h"

#include "VCXConnUtilTestCommon.h"

#include "VCXTestCommon.h"

#include "IptvTestUtilALR.h"

#include "VCXConnUtilTestSubscriber.h"

#include "CIptvTestTimer.h"

#include "CIptvTestActiveWait.h"

#include "VCXTestTimerWait.h"

#include "vcxconnectionutility.h"

#include "VCXTestLog.h"

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

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

// CVCXConnUtilTest::Delete

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

// Called from destructor.

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

//

void CVCXConnUtilTest::Delete()

    {

    VCXLOGLO2(">>>CVCXConnUtilTest::Delete (%S)", &iName);

    delete iTestCommon;

    iTestCommon = NULL;

    if( iConnectionStatusSubscriber )

        {

        iConnectionStatusSubscriber->EndWait();

        }

    delete iConnectionStatusSubscriber;

    iConnectionStatusSubscriber = NULL;

    if( iIapIdSubscriber )

        {

        iIapIdSubscriber->EndWait();

        }

    delete iIapIdSubscriber;

    iIapIdSubscriber = NULL;

    if( iSnapIdSubscriber )

        {

        iSnapIdSubscriber->EndWait();

        }

    delete iSnapIdSubscriber;

    iSnapIdSubscriber = NULL;

    if( iMasterExistsSubscriber )

        {

        iMasterExistsSubscriber->EndWait();

        }

    delete iMasterExistsSubscriber;

    iMasterExistsSubscriber = NULL;

    if( iNbrConnInstancesSubscriber )

        {

        iNbrConnInstancesSubscriber->EndWait();

        }

    delete iNbrConnInstancesSubscriber;

    iNbrConnInstancesSubscriber = NULL;

    if( iRoamingRequestStatusSubscriber )

        {

        iRoamingRequestStatusSubscriber->EndWait();

        }

    delete iRoamingRequestStatusSubscriber;

    iRoamingRequestStatusSubscriber = NULL;

    if( iNbrRoamRespSubscriber )

        {

        iNbrRoamRespSubscriber->EndWait();

        }

    delete iNbrRoamRespSubscriber;

    iNbrRoamRespSubscriber = NULL;

    if( iNbRoamAcceptedSubscriber )

        {

        iNbRoamAcceptedSubscriber->EndWait();

        }

    delete iNbRoamAcceptedSubscriber;

    iNbRoamAcceptedSubscriber = NULL;

    delete iTesterCountSubscriber;

    iTesterCountSubscriber = NULL;

    iWaitedPSChanges.Reset();

    iWaitedPSChanges.Close();

    iNotAllowedPSChanges.Reset();

    iNotAllowedPSChanges.Close();

    if( iTimeoutTimer )

        {

        iTimeoutTimer->CancelTimer();

        delete iTimeoutTimer;

        iTimeoutTimer = NULL;

        }

    delete iWait;

    iWait = NULL;

    if( !iShutdownCalled )

        {

        CStifItemParser* fakeParser = NULL;

        ShutdownTesterL( *fakeParser );

        }

    VCXLOGLO2("<<<CVCXConnUtilTest::Delete (%S)", &iName);

    }

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

// CVCXConnUtilTest::RunMethodL

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

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

//

TInt CVCXConnUtilTest::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( "PrepareCase", CVCXConnUtilTest::PrepareCaseL ),

        ENTRY( "ShutdownTester", CVCXConnUtilTest::ShutdownTesterL ),

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

        ENTRY( "GetIap", CVCXConnUtilTest::GetIapL ),

        ENTRY( "WapIdFromIapId", CVCXConnUtilTest::WapIdFromIapIdL ),

        ENTRY( "Disconnect", CVCXConnUtilTest::DisconnectL ),

        ENTRY( "CheckProperty", CVCXConnUtilTest::CheckPropertyL ),

        ENTRY( "SetRoamingAllowed", CVCXConnUtilTest::SetRoamingAllowedL ),

        ENTRY( "SetLeaveAtRoamingRequest", CVCXConnUtilTest::SetLeaveAtRoamingRequestL ),

        ENTRY( "SetDelayBeforeRoamingRequest", CVCXConnUtilTest::SetDelayBeforeRoamingRequestL ),

        ENTRY( "PrintConnUtilDetails", CVCXConnUtilTest::PrintConnUtilDetails ),

        ENTRY( "AddWaitedProperty", CVCXConnUtilTest::AddWaitedPropertyL ),

        ENTRY( "AddNotAllowedProperty", CVCXConnUtilTest::AddNotAllowedPropertyL ),

        ENTRY( "ResetWaitedProperties", CVCXConnUtilTest::ResetWaitedPropertiesL ),

        ENTRY( "WaitForPropertyQueue", CVCXConnUtilTest::WaitForPropertyQueueL ),

        };

    const TInt count = sizeof( KFunctions ) /

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

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

// CVCXMyVideosCollectionPluginTest::PrepareCaseL

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

//

TInt CVCXConnUtilTest::PrepareCaseL( CStifItemParser& /* aItem */ )

    {

    VCXLOGLO1(">>>CVCXConnUtilTest::PrepareCaseL");

    // Print to UI

    _LIT( KVCXConnUtilTest, "CVCXConnUtilTest" );

    _LIT( KWhere, "In PrepareCaseL" );

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

    // Print to log file

    iLog->Log( KWhere );

    TInt err = CVCXTestCommon::SetPSProperty( KVCXConnUtilTestPScategory, KVCXConnUtilTestExeGlobalShutdownKey, 1 );

    if( err != KErrNone )

        {

        VCXLOGLO2("CVCXConnUtilTest:: Could not read KVCXConnUtilTestExeGlobalShutdownKey from PS. err: %d", err);

        }

    VCXLOGLO1("<<<CVCXConnUtilTest::PrepareCaseL");

    return KErrNone;

    }

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

// CVCXMyVideosCollectionPluginTest::ShutdownTesterL

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

//

TInt CVCXConnUtilTest::ShutdownTesterL( CStifItemParser& /* aItem */ )

    {

    VCXLOGLO1(">>>CVCXConnUtilTest::ShutdownTesterL");

    // Print to UI

    _LIT( KVCXConnUtilTest, "CVCXConnUtilTest" );

    _LIT( KWhere, "In ShutdownTesterL" );

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

    // Print to log file

    iLog->Log( KWhere );

    iShutdownCalled = ETrue;

    // Stop listening P&S changes.

    delete iTesterGetAckResponseSubscriber;

    iTesterGetAckResponseSubscriber = NULL;

    delete iTesterResponseSubscriber;

    iTesterResponseSubscriber = NULL;

    // Tell tester exe to shutdown.

    VCXLOGLO1("CVCXConnUtilTest:: Setting cmd EVcxConnUtilCommandShutdown");

    CVCXTestCommon::SetPSProperty( KVCXConnUtilTestPScategory,

            KVCXConnUtilTestExePsKeyCmd + iPSKeyBase, EVcxConnUtilCommandShutdown );

    User::After( 3000000 );

    // Check the shutdown.

    VCXLOGLO2("CVCXConnUtilTest:: Exit type: %d", iProcess.ExitType());

    VCXLOGLO2("CVCXConnUtilTest:: Exit reason: %d", iProcess.ExitReason());

    TExitCategoryName exitCatName = iProcess.ExitCategory();

    VCXLOGLO2("CVCXConnUtilTest:: Exit category: %S", &exitCatName);

    TInt err = iProcess.ExitReason();

    if( err == KErrNone && iProcess.ExitType() != EExitKill && exitCatName.Length() == 0 )

        {

        VCXLOGLO1("CVCXConnUtilTest:: ERROR: No exit error, no panic but exit type is unusual or exe is stil running.");

        err = KErrGeneral;

        }

    VCXLOGLO1("<<<CVCXConnUtilTest::ShutdownTesterL");

    return err;

    }

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

// CVCXMyVideosCollectionPluginTest::CreateL

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

//

TInt CVCXConnUtilTest::CreateL( CStifItemParser& aItem )

    {

    // Print to UI

    _LIT( KVCXConnUtilTest, "CVCXConnUtilTest" );

    _LIT( KWhere, "In CreateL" );

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

    // Print to log file

    iLog->Log( KWhere );

    aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);

    TPtrC name;

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

        {

        iName = name;

        }

    else

        {

        iName = _L("DEFAULT");

        }

    VCXLOGLO2(">>>CVCXConnUtilTest::CreateL (%S) ----->", &iName);

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

        {

        iMode = KVcxConnUtilTestModeBoth;

        }

    iTestCommon = CVCXTestCommon::NewL();

    iWait = CIptvTestActiveWait::NewL();

    iTimeoutTimer = CIptvTestTimer::NewL( *this, KTimeoutTimerId );

    iPSKeyBase = 0;

    if( iMode == KVcxConnUtilTestModeBoth || iMode == KVcxConnUtilTestModeConnectivity )

        {

        CreateTesterProcessL();

        User::LeaveIfError( CVCXTestCommon::GetPSProperty( KVCXConnUtilTestPScategory, 

                KVCXConnUtilTestExeGlobalTesterCount, iPSKeyBase ) );

        iPSKeyBase = iPSKeyBase * 1000 + iProcess.Id();

        VCXLOGLO2("CVCXConnUtilTest:: iPSKeyBase: %d", iPSKeyBase);

        CVCXTestCommon::SetPSProperty( KVCXConnUtilTestPScategory,

                KVCXConnUtilTestExePsKeyCmd + iPSKeyBase, EVcxConnUtilCommandSetName );

        CVCXTestCommon::SetPSProperty( KVCXConnUtilTestPScategory,

                KVCXConnUtilTestExePsKeyCmdDescParam1 + iPSKeyBase, iName );

        // Start listening P&S for the tester responses.

        iTesterGetAckResponseSubscriber = CVCXConnUtilTestSubscriber::NewL( KVCXConnUtilTestPScategory,

                KVCXConnUtilTestExePsKeyResponseAck + iPSKeyBase, RProperty::EInt, this );

        iTesterGetAckResponseSubscriber->Start();

        VCXLOGLO2("CVCXConnUtilTestExeTester:: Listening P&S key KVCXConnUtilTestExePsKeyResponseAck: %d", KVCXConnUtilTestExePsKeyResponseAck + iPSKeyBase);

        iTesterResponseSubscriber = CVCXConnUtilTestSubscriber::NewL( KVCXConnUtilTestPScategory,

                KVCXConnUtilTestExePsKeyResponseCmd + iPSKeyBase, RProperty::EInt, this );

        iTesterResponseSubscriber->Start();

        VCXLOGLO2("CVCXConnUtilTestExeTester:: Listening P&S key KVCXConnUtilTestExePsKeyResponseCmd: %d", KVCXConnUtilTestExePsKeyResponseCmd + iPSKeyBase);

        }

    // Start listening P&S for connutil status changes.

    iConnectionStatusSubscriber = CVCXConnUtilTestSubscriber::NewL( KVcxConnUtilPScategory,

            EVCxPSConnectionStatus, RProperty::EInt, this );

    iIapIdSubscriber = CVCXConnUtilTestSubscriber::NewL( KVcxConnUtilPScategory,

            EVCxPSIapId, RProperty::EInt, this );

    iSnapIdSubscriber = CVCXConnUtilTestSubscriber::NewL( KVcxConnUtilPScategory,

            EVCxPSSnapId, RProperty::EInt, this );

    iMasterExistsSubscriber = CVCXConnUtilTestSubscriber::NewL( KVcxConnUtilPScategory,

            EVCxPSMasterExists, RProperty::EInt, this );

    iNbrConnInstancesSubscriber = CVCXConnUtilTestSubscriber::NewL( KVcxConnUtilPScategory,

            EVCxPSNbrConnInstances, RProperty::EInt, this );

    iRoamingRequestStatusSubscriber = CVCXConnUtilTestSubscriber::NewL( KVcxConnUtilPScategory,

            EVCxPSRoamingRequestStatus, RProperty::EInt, this );

    iNbrRoamRespSubscriber = CVCXConnUtilTestSubscriber::NewL( KVcxConnUtilPScategory,

            EVCxPSNbrRoamResp, RProperty::EInt, this );

    iNbRoamAcceptedSubscriber = CVCXConnUtilTestSubscriber::NewL( KVcxConnUtilPScategory,

            EVCxPSNbRoamAccepted, RProperty::EInt, this );

    if( iMode == KVcxConnUtilTestModeSubscriber || iMode == KVcxConnUtilTestModeBoth )

        {

        iConnectionStatusSubscriber->Start();

        iIapIdSubscriber->Start();

        iSnapIdSubscriber->Start();

        iMasterExistsSubscriber->Start();

        iNbrConnInstancesSubscriber->Start();

        iRoamingRequestStatusSubscriber->Start();

        iNbrRoamRespSubscriber->Start();

        iNbRoamAcceptedSubscriber->Start();

        }

    VCXLOGLO2("<<<CVCXConnUtilTest::CreateL (%S)", &iName);

    return KErrNone;

    }

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

// CVCXMyVideosCollectionPluginTest::CreateTesterProcessL

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

//

void CVCXConnUtilTest::CreateTesterProcessL()

    {

    VCXLOGLO2(">>>CVCXConnUtilTest::CreateTesterProcessL (%S)", &iName);

    // Define tester count P&S key before starting the exe.    

    TInt err = CVCXTestCommon::GetPSProperty( 

            KVCXConnUtilTestPScategory, KVCXConnUtilTestExeGlobalTesterCount, iPSKeyBase );

    if( err == KErrNotFound )

        {

        User::LeaveIfError( RProperty::Define( 

                KVCXConnUtilTestPScategory, KVCXConnUtilTestExeGlobalTesterCount, RProperty::EInt ) );

        VCXLOGLO1("CVCXConnUtilTest:: Defined KVCXConnUtilTestExeGlobalTesterCount");

        User::LeaveIfError( CVCXTestCommon::SetPSProperty( 

                KVCXConnUtilTestPScategory, KVCXConnUtilTestExeGlobalTesterCount, 1 ) );

        }

    else

    if( err != KErrNone ) 

        {

        VCXLOGLO2("CVCXConnUtilTest:: err getting tester count P&S: %d", err);

        User::Leave( err );

        }

    // Lets subscribe tester count for changes.

    iTesterCountSubscriber = CVCXConnUtilTestSubscriber::NewL( KVCXConnUtilTestPScategory,

                KVCXConnUtilTestExeGlobalTesterCount, RProperty::EInt, this );

    iTesterCountSubscriber->Start();

    VCXLOGLO1("CVCXConnUtilTestExeTester:: Listening P&S key KVCXConnUtilTestExeGlobalTesterCount");

    // Create the process.    

    User::LeaveIfError( iProcess.Create( _L("VCXConnUtilTestExe.exe"), _L("") ) );

    iProcess.Resume();       

    TesterExeAliveL();

    // Wait until tester count P&S key has been updated.

    if( !iTesterCountChangedAlready )

        {

        iTesterCountSubscriber->WaitChangeL();

        }

    // Not interested anymore.

    delete iTesterCountSubscriber;

    iTesterCountSubscriber = NULL;

    VCXLOGLO2("<<<CVCXConnUtilTest::CreateTesterProcessL (%S)", &iName);

    }

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

// CVCXMyVideosCollectionPluginTest::GetIapL

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

//

TInt CVCXConnUtilTest::GetIapL( CStifItemParser& aItem )

    {

    VCXLOGLO2(">>>CVCXConnUtilTest::GetIapL (%S)", &iName);

    // Print to UI

    _LIT( KVCXConnUtilTest, "CVCXConnUtilTest" );

    _LIT( KWhere, "In GetIapL" );

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

    // Print to log file

    iLog->Log( KWhere );

    if( iMode == KVcxConnUtilTestModeSubscriber )

        {

        User::Leave( KErrNotSupported );

        }

    TesterExeAliveL();

    aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);

    TPtrC destName;

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

    CIptvTestUtilALR* alrUtil = CIptvTestUtilALR::NewLC();

    TInt destId = alrUtil->GetDestinationIdL( destName );

    CleanupStack::PopAndDestroy( alrUtil );

    VCXLOGLO1("CVCXConnUtilTest:: Create cenrep.");

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

    VCXLOGLO1("CVCXConnUtilTest:: Set cenrep.");

    User::LeaveIfError( cenRep->Set( VCXTEST_KIptvCenRepUsedSnapIdKey, destId ) );

    CleanupStack::PopAndDestroy( cenRep );

    TInt isTimed(0);

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

        {

        isTimed = 0;

        }

    VCXLOGLO2("CVCXConnUtilTest:: Setting cmd EVcxConnUtilCommandGetIap (%S) ----->", &iName);

    // Silent call.

    User::LeaveIfError( CVCXTestCommon::SetPSProperty( KVCXConnUtilTestPScategory,

            KVCXConnUtilTestExePsKeyCmdIntParam1 + iPSKeyBase, 1 ) );

    // Is this timed call.

    User::LeaveIfError( CVCXTestCommon::SetPSProperty( KVCXConnUtilTestPScategory,

            KVCXConnUtilTestExePsKeyCmdIntParam2 + iPSKeyBase, isTimed ) );

    // Set the cmd.

    User::LeaveIfError( CVCXTestCommon::SetPSProperty( KVCXConnUtilTestPScategory,

            KVCXConnUtilTestExePsKeyCmd + iPSKeyBase, EVcxConnUtilCommandGetIap ) );

    iTesterGetAckResponseSubscriber->WaitChangeL();

    VCXLOGLO2("<<<CVCXConnUtilTest::GetIapL (%S)", &iName);

    return KErrNone;

    }

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

// CVCXMyVideosCollectionPluginTest::WapIdFromIapIdL

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

//

TInt CVCXConnUtilTest::WapIdFromIapIdL( CStifItemParser& aItem )

    {

    VCXLOGLO2(">>>CVCXConnUtilTest::WapIdFromIapIdL (%S)", &iName);

    // Print to UI

    _LIT( KVCXConnUtilTest, "CVCXConnUtilTest" );

    _LIT( KWhere, "In WapIdFromIapIdL" );

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

    // Print to log file

    iLog->Log( KWhere );

    TesterExeAliveL();

    aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);

    TPtrC iapName;

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

    VCXLOGLO3("CVCXConnUtilTest:: Iap name: %S (%S) ----->", &iapName, &iName);

    TUint32 iapId( 0 );

    TInt err( KErrNone );

    if( !iTestCommon->GetIapIdL( iapName, iapId ) )

        {

        VCXLOGLO2("CVCXConnUtilTest:: Iap not found, error! (%S) ----->", &iName);

        err = KErrNotFound;

        }

    else

        {

        VCXLOGLO2("CVCXConnUtilTest:: Setting cmd EVcxConnUtilCommandGetWapIdForIap (%S) ----->", &iName);

        // IAP ID

        User::LeaveIfError( CVCXTestCommon::SetPSProperty( KVCXConnUtilTestPScategory,

                KVCXConnUtilTestExePsKeyCmdIntParam1 + iPSKeyBase, iapId ) );

        // Set the cmd.

        User::LeaveIfError( CVCXTestCommon::SetPSProperty( KVCXConnUtilTestPScategory,

                KVCXConnUtilTestExePsKeyCmd + iPSKeyBase, EVcxConnUtilCommandGetWapIdForIap ) );

        iTesterGetAckResponseSubscriber->WaitChangeL();

        }

    VCXLOGLO2("<<<CVCXConnUtilTest::WapIdFromIapIdL (%S)", &iName);

    return err;

    }

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

// CVCXMyVideosCollectionPluginTest::DisconnectL

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

//

TInt CVCXConnUtilTest::DisconnectL( CStifItemParser& aItem )

    {

    VCXLOGLO2(">>>CVCXConnUtilTest::DisconnectL (%S)", &iName);

    // Print to UI

    _LIT( KVCXConnUtilTest, "CVCXConnUtilTest" );

    _LIT( KWhere, "In DisconnectL" );

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