/*
* 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 );
    // Print to log file
    iLog->Log( KWhere );

    if( iMode == KVcxConnUtilTestModeSubscriber )
        {
        User::Leave( KErrNotSupported );
        }
    TesterExeAliveL();

    aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);

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

    // Set the cmd.
    User::LeaveIfError( CVCXTestCommon::SetPSProperty( KVCXConnUtilTestPScategory,
            KVCXConnUtilTestExePsKeyCmd + iPSKeyBase, EVcxConnUtilCommandDisconnect ) );

    iTesterGetAckResponseSubscriber->WaitChangeL();

    VCXLOGLO2("<<<CVCXConnUtilTest::DisconnectL (%S)", &iName);
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CVCXMyVideosCollectionPluginTest::CheckPropertyL
// -----------------------------------------------------------------------------
//
TInt CVCXConnUtilTest::CheckPropertyL( CStifItemParser& aItem )
    {
    VCXLOGLO2(">>>CVCXConnUtilTest::CheckPropertyL (%S)", &iName);
    // Print to UI
    _LIT( KVCXConnUtilTest, "CVCXConnUtilTest" );
    _LIT( KWhere, "In CheckPropertyL" );
    TestModuleIf().Printf( 0, KVCXConnUtilTest, KWhere );
    // Print to log file
    iLog->Log( KWhere );

    aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);

    TInt property;
    User::LeaveIfError( aItem.GetNextInt( property ) );

    TInt intValue(0);
    TBuf<256> stringValue;
    stringValue.Zero();

    TBuf<256> propertyName;
    GetPropertyNameL( property, propertyName );

    VCXLOGLO2("CVCXConnUtilTest:: check %S", &propertyName);

    switch( property )
        {
        case EVCxPSConnectionStatus:
            {
            User::LeaveIfError( iConnectionStatusSubscriber->Get( intValue ) );
            break;
            }

        case EVCxPSIapId:
            {
            User::LeaveIfError( iIapIdSubscriber->Get( intValue ) );
            break;
            }

        case EVCxPSSnapId:
            {
            User::LeaveIfError( iSnapIdSubscriber->Get( intValue ) );
            break;
            }

        case EVCxPSMasterExists:
            {
            User::LeaveIfError( iMasterExistsSubscriber->Get( intValue ) );
            break;
            }

        case EVCxPSNbrConnInstances:
            {
            User::LeaveIfError( iNbrConnInstancesSubscriber->Get( intValue ) );
            break;
            }

        case EVCxPSRoamingRequestStatus:
            {
            User::LeaveIfError( iRoamingRequestStatusSubscriber->Get( intValue ) );
            break;
            }

        case EVCxPSNbrRoamResp:
            {
            User::LeaveIfError( iNbrRoamRespSubscriber->Get( intValue ) );
            break;
            }

        case EVCxPSNbRoamAccepted:
            {
            User::LeaveIfError( iNbRoamAcceptedSubscriber->Get( intValue ) );
            break;
            }

        default:
            {
            User::Leave( KErrArgument );
            }
            break;
        }

    TInt err(KErrNone);
    TInt expectedValue(0);
    if( aItem.GetNextInt( expectedValue ) != KErrNone )
        {
        err = KErrArgument;
        }
    else
    if( err == KErrNone && intValue != expectedValue )
        {
        VCXLOGLO3("CVCXConnUtilTest:: mismatch: %d, expected: %d", intValue, expectedValue );
        err = KErrCorrupt;
        }

    VCXLOGLO2("<<<CVCXConnUtilTest::CheckPropertyL (%S)", &iName);
    return err;
    }

// -----------------------------------------------------------------------------
// CVCXMyVideosCollectionPluginTest::PrintConnUtilDetails
// -----------------------------------------------------------------------------
//
TInt CVCXConnUtilTest::PrintConnUtilDetails( CStifItemParser& /* aItem */ )
    {
    VCXLOGLO2(">>>CVCXConnUtilTest::PrintConnUtilDetails (%S)", &iName);

    TInt connectionStatus( 0 );
    TInt iapId( 0 );
    TInt snapId( 0 );
    TInt masterExists( 0 );
    TInt nbrConnInstances( 0 );
    TInt roamingRequestStatus( 0 );
    TInt nbrRoamResp( 0 );
    TInt nbrRoamAccepted( 0 );
    TInt err( KErrNone );

    err = iConnectionStatusSubscriber->Get( connectionStatus );
    if( err != KErrNone ) VCXLOGLO2("CVCXConnUtilTest:: err: %d getting PS iConnectionStatusSubscriber", err);

    err = iIapIdSubscriber->Get( iapId );
    if( err != KErrNone ) VCXLOGLO2("CVCXConnUtilTest:: err: %d getting PS iIapIdSubscriber", err);

    err = iSnapIdSubscriber->Get( snapId );
    if( err != KErrNone ) VCXLOGLO2("CVCXConnUtilTest:: err: %d getting PS iSnapIdSubscriber", err);

    err = iMasterExistsSubscriber->Get( masterExists );
    if( err != KErrNone ) VCXLOGLO2("CVCXConnUtilTest:: err: %d getting PS iMasterExistsSubscriber", err);

    err = iNbrConnInstancesSubscriber->Get( nbrConnInstances );
    if( err != KErrNone ) VCXLOGLO2("CVCXConnUtilTest:: err: %d getting PS iNbrConnInstancesSubscriber", err);

    err = iRoamingRequestStatusSubscriber->Get( roamingRequestStatus );
    if( err != KErrNone ) VCXLOGLO2("CVCXConnUtilTest:: err: %d getting PS iRoamingRequestStatusSubscriber", err);

    err = iNbrRoamRespSubscriber->Get( nbrRoamResp );
    if( err != KErrNone ) VCXLOGLO2("CVCXConnUtilTest:: err: %d getting PS iNbrRoamRespSubscriber", err);

    err = iNbRoamAcceptedSubscriber->Get( nbrRoamAccepted );
    if( err != KErrNone ) VCXLOGLO2("CVCXConnUtilTest:: err: %d getting PS iNbRoamAcceptedSubscriber", err);

    TBuf<256> statusStr;
    TRAP_IGNORE( GetConnectionStatusL( connectionStatus, statusStr ) );

    VCXLOGLO3("CVCXConnUtilTest:: status: %S (%d)", &statusStr, connectionStatus);
    VCXLOGLO2("CVCXConnUtilTest:: iapId: %d", iapId);
    VCXLOGLO2("CVCXConnUtilTest:: snapId: %d", snapId);
    VCXLOGLO2("CVCXConnUtilTest:: masterExists: %d", masterExists);
    VCXLOGLO2("CVCXConnUtilTest:: nbrConnInstances: %d", nbrConnInstances);
    VCXLOGLO2("CVCXConnUtilTest:: roamingRequestStatus: %d", roamingRequestStatus);
    VCXLOGLO2("CVCXConnUtilTest:: nbrRoamResp: %d", nbrRoamResp);
    VCXLOGLO2("CVCXConnUtilTest:: nbrRoamAccepted: %d", nbrRoamAccepted);

    VCXLOGLO2("<<<CVCXConnUtilTest::PrintConnUtilDetails (%S)", &iName);
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CVCXMyVideosCollectionPluginTest::SetRoamingAllowedL
// -----------------------------------------------------------------------------
//
TInt CVCXConnUtilTest::SetRoamingAllowedL( CStifItemParser& aItem )
    {
    VCXLOGLO2(">>>CVCXConnUtilTest::SetRoamingAllowedL (%S)", &iName);
    // Print to UI
    _LIT( KVCXConnUtilTest, "CVCXConnUtilTest" );
    _LIT( KWhere, "In SetRoamingAllowedL" );
    TestModuleIf().Printf( 0, KVCXConnUtilTest, KWhere );
    // Print to log file
    iLog->Log( KWhere );

    if( iMode == KVcxConnUtilTestModeSubscriber )
        {
        User::Leave( KErrNotSupported );
        }
    TesterExeAliveL();

    aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);

    TInt temp;
    User::LeaveIfError( aItem.GetNextInt( temp ) );

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

    // Set value.
    User::LeaveIfError( CVCXTestCommon::SetPSProperty( KVCXConnUtilTestPScategory,
            KVCXConnUtilTestExePsKeyCmdIntParam1 + iPSKeyBase, temp ) );

    // Set the cmd.
    User::LeaveIfError( CVCXTestCommon::SetPSProperty( KVCXConnUtilTestPScategory,
            KVCXConnUtilTestExePsKeyCmd + iPSKeyBase, EVcxConnUtilCommandSetRoamingAllowed ) );

    iTesterGetAckResponseSubscriber->WaitChangeL();

    VCXLOGLO2("<<<CVCXConnUtilTest::SetRoamingAllowedL (%S)", &iName);
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CVCXMyVideosCollectionPluginTest::SetLeaveAtRoamingRequestL
// -----------------------------------------------------------------------------
//
TInt CVCXConnUtilTest::SetLeaveAtRoamingRequestL( CStifItemParser& aItem )
    {
    VCXLOGLO2(">>>CVCXConnUtilTest::SetLeaveAtRoamingRequestL (%S)", &iName);
    // Print to UI
    _LIT( KVCXConnUtilTest, "CVCXConnUtilTest" );
    _LIT( KWhere, "In SetLeaveAtRoamingRequestL" );
    TestModuleIf().Printf( 0, KVCXConnUtilTest, KWhere );
    // Print to log file
    iLog->Log( KWhere );

    if( iMode == KVcxConnUtilTestModeSubscriber )
        {
        User::Leave( KErrNotSupported );
        }
    TesterExeAliveL();

    aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);

    TInt temp;
    User::LeaveIfError( aItem.GetNextInt( temp ) );

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

    // Set value.
    User::LeaveIfError( CVCXTestCommon::SetPSProperty( KVCXConnUtilTestPScategory,
            KVCXConnUtilTestExePsKeyCmdIntParam1 + iPSKeyBase, temp ) );

    // Set the cmd.
    User::LeaveIfError( CVCXTestCommon::SetPSProperty( KVCXConnUtilTestPScategory,
            KVCXConnUtilTestExePsKeyCmd + iPSKeyBase, EVcxConnUtilCommandSetRoamingLeaveAtRoamingRequest ) );

    iTesterGetAckResponseSubscriber->WaitChangeL();

    VCXLOGLO2("<<<CVCXConnUtilTest::SetLeaveAtRoamingRequestL (%S)", &iName);
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CVCXMyVideosCollectionPluginTest::SetDelayBeforeRoamingRequest
// -----------------------------------------------------------------------------
//
TInt CVCXConnUtilTest::SetDelayBeforeRoamingRequestL( CStifItemParser& aItem )
    {
    VCXLOGLO2(">>>CVCXConnUtilTest::SetDelayBeforeRoamingRequestL (%S)", &iName);
    // Print to UI
    _LIT( KVCXConnUtilTest, "CVCXConnUtilTest" );
    _LIT( KWhere, "In SetDelayBeforeRoamingRequestL" );
    TestModuleIf().Printf( 0, KVCXConnUtilTest, KWhere );
    // Print to log file
    iLog->Log( KWhere );

    if( iMode == KVcxConnUtilTestModeSubscriber )
        {
        User::Leave( KErrNotSupported );
        }
    TesterExeAliveL();

    aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);

    TInt seconds(0);
    User::LeaveIfError( aItem.GetNextInt( seconds ) );

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

    // Set value.
    User::LeaveIfError( CVCXTestCommon::SetPSProperty( KVCXConnUtilTestPScategory,
            KVCXConnUtilTestExePsKeyCmdIntParam1 + iPSKeyBase, seconds ) );

    // Set the cmd.
    User::LeaveIfError( CVCXTestCommon::SetPSProperty( KVCXConnUtilTestPScategory,
            KVCXConnUtilTestExePsKeyCmd + iPSKeyBase, EVcxConnUtilCommandSetDelayBeforeRoamingRequest ) );

    iTesterGetAckResponseSubscriber->WaitChangeL();

    VCXLOGLO2("<<<CVCXConnUtilTest::SetDelayBeforeRoamingRequestL (%S)", &iName);
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CVCXMyVideosCollectionPluginTest::AddWaitedProperty
// -----------------------------------------------------------------------------
//
TInt CVCXConnUtilTest::AddWaitedPropertyL( CStifItemParser& aItem )
    {
    VCXLOGLO2(">>>CVCXConnUtilTest::AddWaitedPropertyL (%S)", &iName);
    // Print to UI
    _LIT( KVCXConnUtilTest, "CVCXConnUtilTest" );
    _LIT( KWhere, "In AddWaitedPropertyL" );
    TestModuleIf().Printf( 0, KVCXConnUtilTest, KWhere );
    // Print to log file
    iLog->Log( KWhere );

    if( iMode == KVcxConnUtilTestModeConnectivity )
        {
        User::Leave( KErrNotSupported );
        }

    aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);

    TInt property( -1 );
    User::LeaveIfError( aItem.GetNextInt( property ) );

    TBuf<256> propertyName;
    GetPropertyNameL( property, propertyName );

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

    if( property == EVCxPSConnectionStatus )
        {
        TBuf<256> connStr;
        GetConnectionStatusL( value, connStr );
        VCXLOGLO3("CVCXConnUtilTest:: %S = %S", &propertyName, &connStr);
        }
    else
        {
        VCXLOGLO3("CVCXConnUtilTest:: %S = %d", &propertyName, value);
        }

    TVcxConnTestPSProperty prop( property, value );
    iWaitedPSChanges.Append( prop );

    VCXLOGLO2("<<<CVCXConnUtilTest::AddWaitedPropertyL (%S)", &iName);
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CVCXMyVideosCollectionPluginTest::AddNotAllowedPropertyL
// -----------------------------------------------------------------------------
//
TInt CVCXConnUtilTest::AddNotAllowedPropertyL( CStifItemParser& aItem )
    {
    VCXLOGLO2(">>>CVCXConnUtilTest::AddNotAllowedPropertyL (%S)", &iName);
    // Print to UI
    _LIT( KVCXConnUtilTest, "CVCXConnUtilTest" );
    _LIT( KWhere, "In AddNotAllowedPropertyL" );
    TestModuleIf().Printf( 0, KVCXConnUtilTest, KWhere );
    // Print to log file
    iLog->Log( KWhere );

    if( iMode == KVcxConnUtilTestModeConnectivity )
        {
        User::Leave( KErrNotSupported );
        }

    aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);

    TInt property( -1 );
    User::LeaveIfError( aItem.GetNextInt( property ) );

    TBuf<256> propertyName;
    GetPropertyNameL( property, propertyName );

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

    if( property == EVCxPSConnectionStatus )
        {
        TBuf<256> connStr;
        GetConnectionStatusL( value, connStr );
        VCXLOGLO3("CVCXConnUtilTest:: %S = %S", &propertyName, &connStr);
        }
    else
        {
        VCXLOGLO3("CVCXConnUtilTest:: %S = %d", &propertyName, value);
        }

    TVcxConnTestPSProperty prop( property, value );
    iNotAllowedPSChanges.Append( prop );

    VCXLOGLO2("<<<CVCXConnUtilTest::AddNotAllowedPropertyL (%S)", &iName);
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CVCXMyVideosCollectionPluginTest::ResetWaitedProperties
// -----------------------------------------------------------------------------
//
TInt CVCXConnUtilTest::ResetWaitedPropertiesL( CStifItemParser& aItem )
    {
    VCXLOGLO2(">>>CVCXConnUtilTest::ResetWaitedPropertiesL (%S)", &iName);
    // Print to UI
    _LIT( KVCXConnUtilTest, "CVCXConnUtilTest" );
    _LIT( KWhere, "In ResetWaitedPropertiesL" );
    TestModuleIf().Printf( 0, KVCXConnUtilTest, KWhere );
    // Print to log file
    iLog->Log( KWhere );

    if( iMode == KVcxConnUtilTestModeConnectivity )
        {
        User::Leave( KErrNotSupported );
        }

    iWaitedPSChanges.Reset();
    iWaitingForEmptyPropertyQueue = EFalse;
    iNotAllowedPSChanges.Reset();

    aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);
    VCXLOGLO2("<<<CVCXConnUtilTest::ResetWaitedPropertiesL (%S)", &iName);
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CVCXMyVideosCollectionPluginTest::WaitForPropertyQueueL
// -----------------------------------------------------------------------------
//
TInt CVCXConnUtilTest::WaitForPropertyQueueL( CStifItemParser& aItem )
    {
    VCXLOGLO2(">>>CVCXConnUtilTest::WaitForPropertyQueueL (%S)", &iName);
    // Print to UI
    _LIT( KVCXConnUtilTest, "CVCXConnUtilTest" );
    _LIT( KWhere, "In WaitForPropertyQueueL" );
    TestModuleIf().Printf( 0, KVCXConnUtilTest, KWhere );
    // Print to log file
    iLog->Log( KWhere );

    if( iMode == KVcxConnUtilTestModeConnectivity )
        {
        User::Leave( KErrNotSupported );
        }
    TesterExeAliveL();

    iWaitingForEmptyPropertyQueue = ETrue;

    // Timer is started always again when we correct property changes.
    const TInt KTimeoutMinute = 60 * 1000000;
    iTimeoutTimer->CancelTimer();
    iTimeoutTimer->After( KTimeoutMinute * 1 );

    aItem.SetParsingType(CStifItemParser::EQuoteStyleParsing);
    VCXLOGLO2("<<<CVCXConnUtilTest::WaitForPropertyQueueL (%S)", &iName);
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CVCXConnUtilTest::ValueChangedL
// -----------------------------------------------------------------------------
//
void CVCXConnUtilTest::ValueChangedL( const TUid& aUid, const TUint32& aKey, const TInt&  aValue )
    {
    VCXLOGLO2(">>>CVCXConnUtilTest::ValueChangedL (%S)", &iName);

    if( aUid == KVcxConnUtilPScategory )
        {
        TBuf<256> pName;
        GetPropertyNameL( aKey, pName );
        if( aKey == EVCxPSConnectionStatus )
            {
            TBuf<256> connStr;
            GetConnectionStatusL( aValue, connStr );
            VCXLOGLO4("CVCXConnUtilTest::ValueChanged: %S = %S (%S) ----->", &pName, &connStr, &iName);

            _LIT( KVCXConnUtilTest, "S:" );
            TestModuleIf().Printf( 0, KVCXConnUtilTest, connStr );
            }
        else
            {
            VCXLOGLO4("CVCXConnUtilTest::ValueChanged: %S = %d (%S) ----->", &pName, aValue, &iName);
            }

        TBool found = EFalse;
        for( TInt i = iWaitedPSChanges.Count() - 1; i >= 0; i-- )
            {
            if( iWaitedPSChanges[i].iProperty == aKey && iWaitedPSChanges[i].iIntegerValue == aValue )
                {
                iWaitedPSChanges.Remove( i );
                found = ETrue;
                break;
                }
            }

        if( !found )
            {
            VCXLOGLO1("CVCXConnUtilTest:: The key was not found from wait queue.");

            // Check not allowed property changes.
            for( TInt i = iNotAllowedPSChanges.Count() - 1; i >= 0; i-- )
                {
                if( iNotAllowedPSChanges[i].iProperty == aKey && iNotAllowedPSChanges[i].iIntegerValue == aValue )
                    {
                    VCXLOGLO1("CVCXConnUtilTest:: Property change is not allowed. Error! SIGNAL.");
                    iNotAllowedPSChanges.Remove( i );
                    Signal( KErrCorrupt );
                    break;
                    }
                }
            }
        else
            {
            VCXLOGLO1("CVCXConnUtilTest:: Key found and removed from wait queue.");

            // Restart timer.
            const TInt KTimeoutMinute = 60 * 1000000;
            iTimeoutTimer->CancelTimer();
            iTimeoutTimer->After( KTimeoutMinute * 1 );

            if( iWaitedPSChanges.Count() == 0 )
                {
                if( iWaitingForEmptyPropertyQueue )
                    {
                    iWaitingForEmptyPropertyQueue = EFalse;
                    VCXLOGLO1("CVCXConnUtilTest:: Property queue empty, SIGNAL.");
                    iTimeoutTimer->CancelTimer();
                    Signal();
                    }
                }
            }

        if( iWaitedPSChanges.Count() == 0 )
            {
            iNotAllowedPSChanges.Reset();
            }
        }

    TInt err( KErrNone );

    if( aUid == KVCXConnUtilTestPScategory )
        {
        if( aKey == KVCXConnUtilTestExeGlobalTesterCount )
            {
            iTesterCountChangedAlready = ETrue;
            VCXLOGLO1("CVCXConnUtilTest:: KVCXConnUtilTestExeGlobalTesterCount changed.");
            }
        
        if( aKey == KVCXConnUtilTestExePsKeyResponseAck + iPSKeyBase )
            {
            VCXLOGLO3("CVCXConnUtilTest:: received KVCXConnUtilTestExePsKeyResponseAck, value: %d (%S) ----->", aValue, &iName);
            }

        if( aKey == KVCXConnUtilTestExePsKeyResponseCmd + iPSKeyBase )
            {
            VCXLOGLO2("CVCXConnUtilTest:: received KVCXConnUtilTestExePsKeyResponseCmd (%S) ----->", &iName);

            TInt cmd( aValue );
            
            TInt response( 0 );
            
            CVCXTestCommon::GetPSProperty( KVCXConnUtilTestPScategory,
                    KVCXConnUtilTestExePsKeyResponseParam + iPSKeyBase, response );

            CVCXTestCommon::GetPSProperty( KVCXConnUtilTestPScategory,
                    KVCXConnUtilTestExePsKeyResponseError + iPSKeyBase, err );
            
            if( cmd == EVcxConnUtilCommandDisconnect )
                {
                VCXLOGLO3("CVCXConnUtilTest:: response for EVcxConnUtilCommandDisconnect, error: %d (%S) ----->", err, &iName);
                }
            
            if( cmd == EVcxConnUtilCommandGetIap )
                {
                if( response == 0 )
                    {
                    VCXLOGLO1("CVCXConnUtilTest:: response for EVcxConnUtilCommandGetIap, IAP is 0, error!");
                    err = KErrGeneral;
                    }
                else
                    {
                    VCXLOGLO2("CVCXConnUtilTest:: response for EVcxConnUtilCommandGetIap returned IAP: %d", response);
                    }
                }
            
            if( cmd == EVcxConnUtilCommandGetWapIdForIap )
                {
                VCXLOGLO2("CVCXConnUtilTest:: response for EVcxConnUtilCommandGetWapIdForIap returned: %d", response);
                }            

            Signal( err );
            }
        }

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

// -----------------------------------------------------------------------------
// CVCXConnUtilTest::ValueChangedL
// -----------------------------------------------------------------------------
//
void CVCXConnUtilTest::ValueChangedL( const TUid& aUid, const TUint32& aKey, const TDesC& aValue )
    {
    VCXLOGLO2(">>>CVCXConnUtilTest::ValueChangedL (%S)", &iName);

    if( aUid == KVcxConnUtilPScategory )
        {
        TBuf<256> pName;
        GetPropertyNameL( aKey, pName );
        VCXLOGLO3("CVCXConnUtilTest::ValueChanged: %S = %S", &pName, &aValue);

        TBool found = EFalse;
        for( TInt i = iWaitedPSChanges.Count() - 1; i >= 0; i-- )
            {
            if( iWaitedPSChanges[i].iProperty == aKey && iWaitedPSChanges[i].iStringValue.Compare( aValue ) == 0 )
                {
                iWaitedPSChanges.Remove( i );
                found = ETrue;
                break;
                }
            }

        if( !found )
            {
            VCXLOGLO1("CVCXConnUtilTest:: The key was not found from wait queue.");

            // Check not allowed property changes.
            for( TInt i = iNotAllowedPSChanges.Count() - 1; i >= 0; i-- )
                {
                if( iNotAllowedPSChanges[i].iProperty == aKey && iWaitedPSChanges[i].iStringValue.Compare( aValue ) )
                    {
                    VCXLOGLO1("CVCXConnUtilTest:: Property change is not allowed. Error!");
                    iNotAllowedPSChanges.Remove( i );
                    Signal( KErrCorrupt );
                    break;
                    }
                }
            }
        else
            {
            VCXLOGLO1("CVCXConnUtilTest:: Key found and removed from wait queue.");

            const TInt KTimeoutMinute = 60 * 1000000;
            iTimeoutTimer->CancelTimer();
            iTimeoutTimer->After( KTimeoutMinute * 1 );

            if( iWaitedPSChanges.Count() == 0 )
                {
                if( iWaitingForEmptyPropertyQueue )
                    {
                    iWaitingForEmptyPropertyQueue = EFalse;
                    VCXLOGLO1("CVCXConnUtilTest:: Property queue empty, SIGNAL.");
                    iTimeoutTimer->CancelTimer();
                    Signal();
                    }
                }
            }

        if( iWaitedPSChanges.Count() == 0 )
            {
            iNotAllowedPSChanges.Reset();
            }
        }

    if( aUid == KVCXConnUtilTestPScategory )
        {

        }

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

// -----------------------------------------------------------------------------
// CVCXConnUtilTest::TimerComplete
// -----------------------------------------------------------------------------
//
void CVCXConnUtilTest::TimerComplete( TInt aTimerId, TInt aError )
    {
    VCXLOGLO3(">>>CVCXConnUtilTest::TimerComplete, err: %d (%S)", aError, &iName);

    if( aError == KErrNone && aTimerId == KTimeoutTimerId && iWaitingForEmptyPropertyQueue )
        {
        if( iWaitedPSChanges.Count() > 0 )
            {
            VCXLOGLO1("CVCXConnUtilTest:: ---- TIMEOUT --- when waiting P&S changes ----->");

            _LIT( KVCXConnUtilTest, "CVCXConnUtilTest" );
            _LIT( KWhere, "TIMEOUT!" );
            TestModuleIf().Printf( 0, KVCXConnUtilTest, KWhere );

            Signal( KErrTimedOut );
            }
        else
            {
            VCXLOGLO1("CVCXConnUtilTest:: Timed out but property queue empty. Signal ok.");
            Signal( KErrNone );
            }
        }

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

// -----------------------------------------------------------------------------
// CVCXConnUtilTest::GetConnectionStatusL
// -----------------------------------------------------------------------------
//
void CVCXConnUtilTest::GetConnectionStatusL( TInt aConnectionStatus, TDes& aStatusString )
    {
    switch( aConnectionStatus )
        {
        case EVCxNotConnected:
            {
            aStatusString.Copy( _L("EVCxNotConnected") );
            }
            break;

        case EVCxConnecting:
            {
            aStatusString.Copy( _L("EVCxConnecting") );
            }
            break;

        case EVCxConnected:
            {
            aStatusString.Copy( _L("EVCxConnected") );
            }
            break;

        case EVCxDisconnecting:
            {
            aStatusString.Copy( _L("EVCxDisconnecting") );
            }
            break;

        case EVCxRoamingRequest:
            {
            aStatusString.Copy( _L("EVCxRoamingRequest") );
            }
            break;

        case EVCxRoamingAccepted:
            {
            aStatusString.Copy( _L("EVCxRoamingAccepted") );
            }
            break;

        case EVCxError:
            {
            aStatusString.Copy( _L("EVCxError") );
            }
            break;

        default:
            {
            VCXLOGLO2("CVCXConnUtilTest:: state %d is UKNOWN!", aConnectionStatus);
            User::Leave( KErrArgument );
            }
            break;
        }
    }

// -----------------------------------------------------------------------------
// CVCXConnUtilTest::TesterExeAliveL
// -----------------------------------------------------------------------------
//
void CVCXConnUtilTest::TesterExeAliveL()
    {
    if( iProcess.ExitType() != EExitPending || iProcess.ExitReason() != KErrNone )
        {
        VCXLOGLO2("CVCXConnUtilTest:: ERROR: Tester process has terminated! (%S)", &iName);
        VCXLOGLO2("CVCXConnUtilTest:: Exit type: %d", iProcess.ExitType());
        VCXLOGLO2("CVCXConnUtilTest:: Exit reason: %d", iProcess.ExitReason());
        TExitCategoryName exitCatName = iProcess.ExitCategory();
        VCXLOGLO2("CVCXConnUtilTest:: Exit category: %S", &exitCatName);
        User::Leave( KErrGeneral );
        }
    }

// -----------------------------------------------------------------------------
// CVCXConnUtilTest::GetPropertyNameL
// -----------------------------------------------------------------------------
//
void CVCXConnUtilTest::GetPropertyNameL( TInt aProperty, TDes& aPropertyName )
    {
    switch( aProperty )
        {
        case EVCxPSConnectionStatus:
            {
            aPropertyName.Copy( _L("EVCxPSConnectionStatus") );
            break;
            }

        case EVCxPSIapId:
            {
            aPropertyName.Copy( _L("EVCxPSIapId") );
            break;
            }

        case EVCxPSSnapId:
            {
            aPropertyName.Copy( _L("EVCxPSSnapId") );
            break;
            }

        case EVCxPSMasterExists:
            {
            aPropertyName.Copy( _L("EVCxPSMasterExists") );
            break;
            }

        case EVCxPSNbrConnInstances:
            {
            aPropertyName.Copy( _L("EVCxPSNbrConnInstances") );
            break;
            }

        case EVCxPSRoamingRequestStatus:
            {
            aPropertyName.Copy( _L("EVCxPSRoamingRequestStatus") );
            break;
            }

        case EVCxPSNbrRoamResp:
            {
            aPropertyName.Copy( _L("EVCxPSNbrRoamResp") );
            break;
            }

        case EVCxPSNbRoamAccepted:
            {
            aPropertyName.Copy( _L("EVCxPSNbRoamAccepted") );
            break;
            }

        default:
            {
            VCXLOGLO2("CVCXConnUtilTest:: Unknown property: %d!", aProperty);
            User::Leave( KErrArgument );
            }
            break;
        }
    }

// ========================== OTHER EXPORTED FUNCTIONS =========================
// None

//  [End of File] - Do not remove