/*

* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:

*

*/

// [INCLUDE FILES] - do not remove

#include <e32svr.h>

#include <StifParser.h>

#include <Stiftestinterface.h>

#include "UsbWatcherTest.h"

#include "testdebug.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

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

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

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

// CUsbWatcherTest::TestConstructL

// Construct here all test resources for test methods. 

// Called from ConstructL. 

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

void CUsbWatcherTest::TestConstructL()

    {

    TRACE_FUNC_ENTRY

    iStubber = CStubber::NewL();

    iWatcher = new ( ELeave ) RUsbWatcher();

    iCenRep = CRepository::NewL( KCRUidUsbWatcher );

    STIF_LOG( "Usb man initialization" );

    iUsbMan = new ( ELeave ) RUsb();

    User::LeaveIfError( iUsbMan -> Connect() );  

    User::LeaveIfError( BackupPersonalitySetting() );

    TRACE_FUNC_EXIT

    }

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

// CUsbWatcherTest::TestDelete

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

// Called from destructor. 

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

void CUsbWatcherTest::TestDelete() 

    {

    TRACE_FUNC_ENTRY

    if ( RestorePersonalitySetting() != KErrNone )

        STIF_LOG( "Warning: personality restore failed" );

    delete iWatcher;

    iWatcher = NULL;

    delete iCenRep;

    iCenRep = NULL;

    iUsbMan -> Close();

    delete iUsbMan;

    iUsbMan = NULL;

    delete iStubber;

    iStubber = NULL;

    TRACE_FUNC_EXIT

    }

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

// CUsbWatcherTest::TestBlocksInfoL

// Add new test block parameter entries below

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

void CUsbWatcherTest::TestBlocksInfoL()

    {

    TESTENTRY( "ExampleTestL", CUsbWatcherTest::ExampleTestL )

            {

            TESTPARAM( eGetString, eTestOption1 )

            TESTPARAM( eGetString, eTestOption2 )

            TESTPARAM( eGetInt, eTestIntOption1 )

            TESTPARAM( eGetChar, eTestCharOption1 )

            }

    TESTENTRY( "InitializationTest", CUsbWatcherTest::InitializationTestL )

            {

            TESTPARAM( eGetString, eTestOption1 )

            }

    TESTENTRY( "PersonalityManagementTest", CUsbWatcherTest::PersonalityManagementTestL )

            {

            TESTPARAM( eGetString, eTestOption1 )

            TESTPARAM( eGetString, eTestOption2 )

            }

    TESTENTRY( "PersonalitySwitchTest", CUsbWatcherTest::PersonalitySwitchTestL )

            {

            TESTPARAM( eGetString, eTestOption1 )

            }

    TESTENTRY( "BranchTest", CUsbWatcherTest::BranchTestL )

            {

            TESTPARAM( eGetString, eTestOption1 )

            }

    }

// Add test block methods implementation here

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

// CUsbWatcherTest::ExampleTestL

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

void CUsbWatcherTest::ExampleTestL( TUsbWatcherTestBlockParams& aParams, TUsbWatcherTestResult& aTestResult )

    {

    TRACE_FUNC_ENTRY

    //iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) );

    if ( !aParams.iTestOption1.Compare( _L( "API" ) ) )

        {

		TRACE_INFO( "Api test option: %S", &aParams.iTestOption1 )

		TRACE_INFO( "Api test sub-option: %S", &aParams.iTestOption2 )

		TRACE_INFO( "Api test int option: %d", aParams.iTestIntOption1 )

		TRACE_INFO( "Api test char option: %c", TText( aParams.iTestCharOption1 ) )

        }

    else if ( !aParams.iTestOption1.Compare( _L( "MODULE" ) ) )

        {

		TRACE_INFO( "Module test option: %S", &aParams.iTestOption1 )

		TRACE_INFO( "Module test sub-option: %S", &aParams.iTestOption2 )

		TRACE_INFO( "Module test int option: %d", aParams.iTestIntOption1 )

		TRACE_INFO( "Module test char option: %c", TText( aParams.iTestCharOption1 ) )

        }

    else if ( !aParams.iTestOption1.Compare( _L( "BRANCH" ) ) )

        {

		TRACE_INFO( "Branch test option: %S", &aParams.iTestOption1 )

		TRACE_INFO( "Branch test sub-option: %S", &aParams.iTestOption2 )

		TRACE_INFO( "Branch test int option: %d", aParams.iTestIntOption1 )

		TRACE_INFO( "Branch test char option: %c", TText( aParams.iTestCharOption1 ) )

        }

    else

        {

        TRACE( "Invalid test parameter" )

        TRACE_FUNC_EXIT

        User::Leave( KErrNotFound );

        }

    aTestResult = ETestCasePassed;

    TRACE_FUNC_EXIT

    }

// Add other member functions implementation here

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

// CUSBWatcherApiTest::InitializationTest

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

void CUsbWatcherTest::InitializationTestL( TUsbWatcherTestBlockParams& aParams, 

                                            TUsbWatcherTestResult& aTestResult )

    {

    TInt res;   

    TPtrC testOptionName( aParams.iTestOption1 );

    if ( !testOptionName.Compare( _L( "VERSION" ) ) )

        {

        TRACE( "Test option: VERSION" );

        TVersion returnedVersion;

        TVersion expectedVersion( KUsbWatcherSrvMajorVersionNumber,

                                KUsbWatcherSrvMinorVersionNumber,

                                KUsbWatcherSrvBuildVersionNumber );

        TRACE( "  >Version" );

        returnedVersion = iWatcher -> Version();

        TRACE( "  <Version" );

        if( expectedVersion.iMajor != returnedVersion.iMajor )

            User::Leave(KErrNotFound);

        if( expectedVersion.iMinor != returnedVersion.iMinor )

            User::Leave(KErrNotFound);

        if( expectedVersion.iBuild != returnedVersion.iBuild )

            User::Leave(KErrNotFound);

        }

    else if ( !testOptionName.Compare( _L( "SINGLE_CONN" ) ) )

        {

        TRACE( "Test option: SINGLE_CONN" );

        TRACE( ">Connect" );

        res = iWatcher -> Connect();

        TRACE( "  <Connect" );

        TRACE_INFO( "USB watcher connection value: %d, expected: %d", res, KErrNone );

        User::LeaveIfError( res );

        }

    else

        {

        TRACE( "Test option: not supported" );

        User::Leave( KErrNotFound );

        }

    aTestResult = ETestCasePassed;

    }

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

// CUSBWatcherApiTest::PersonalityManagementTest

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

void CUsbWatcherTest::PersonalityManagementTestL( TUsbWatcherTestBlockParams& aParams, 

                                                    TUsbWatcherTestResult& aTestResult )

    {

    TInt res;

    TInt newPersonalityId;

    TPtrC testOptionName( aParams.iTestOption2 );

    TPtrC usbPersonalityName( aParams.iTestOption1 );

    TInt currentPersonalityId;

    iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetPersonalityProperty, 0, 0, _L8( "stub" ) ) );

    res = iUsbMan -> GetCurrentPersonalityId( currentPersonalityId );

    if ( res != KErrNone )

        {

        TRACE_INFO( "GetCurrentPersonalityId failed with value: %d", res );

        User::Leave(res);

        }

    res = GetPersonalityIdFromString( usbPersonalityName, newPersonalityId );

    if ( res != KErrNone )

        {

        TRACE_INFO( "GetPersonalityIdFromString failed with value: %d", res );

        User::Leave(res);

        }

    TRACE( "  >Connect" );

    res = iWatcher -> Connect();

    TRACE( "  <Connect" );

    TRACE_INFO( "USB watcher connection value: %d, expected: %d", res, KErrNone );

    User::LeaveIfError( res );

    if ( !testOptionName.Compare( _L( "SET_PERSONALITY" ) ) && newPersonalityId == KUsbPersonalityIdPCSuiteMTP )

        {     

        TRequestStatus status;

        TInt setPersonalityId;

        if ( currentPersonalityId != newPersonalityId )

            {

            iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetDeviceState, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) );

            iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EDeviceStateNotification, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) );

            iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStopAsync, 0, 0, _L8( "stub" ) ) );

            iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) );

            iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EDeviceStateNotification, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) );

            iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EDeviceStateNotification, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) );

            }

        res = iUsbMan -> GetCurrentPersonalityId( currentPersonalityId );

        TRACE( "  >SetPersonality" );

        iWatcher -> SetPersonality( status, KUsbPersonalityIdMS, EFalse, EFalse );

        User::WaitForRequest( status );

        TRACE( "  <SetPersonality" );

        TRACE_INFO( "Set initial test personality value: %d", status.Int() );

        res = iCenRep -> Get( KUsbWatcherPersonality, setPersonalityId );

        TRACE_INFO( "Set initial test personality value: %d, personality ID: %d", status.Int(), setPersonalityId );

        User::LeaveIfError( status.Int() );

        if( KUsbPersonalityIdMS != setPersonalityId )

            User::Leave(KErrNotFound); 

        }

    else

        {

        TRequestStatus status;

        TInt setPersonalityId;

        if ( currentPersonalityId != newPersonalityId )

            {

            iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetDeviceState, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) );

            iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EDeviceStateNotification, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) );

            iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStopAsync, 0, 0, _L8( "stub" ) ) );

            iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) );

            }

        TRACE( "  >SetPersonality" );

        iWatcher -> SetPersonality( status, KUsbPersonalityIdPCSuiteMTP, EFalse, EFalse );

        User::WaitForRequest( status );        

        TRACE( "  <SetPersonality" );

        res = iCenRep -> Get( KUsbWatcherPersonality, setPersonalityId );

        TRACE_INFO( "Set initial test personality value: %d, personality ID: %d", status.Int(), setPersonalityId );

        User::LeaveIfError( status.Int() ); 

        if( KUsbPersonalityIdPCSuiteMTP != setPersonalityId )

            User::Leave(KErrNotFound);

        }

    if ( !testOptionName.Compare( _L( "SET_PERSONALITY" ) ) )

        {

        TRACE( "Test option: SET_PERSONALITY" );

        aTestResult = SetPersonalityTest( newPersonalityId, ETrue );

        }

    else if ( !testOptionName.Compare( _L( "CANCEL_SET_PERSONALITY" ) ) )

        {

        TRACE( "Test option: CANCEL_SET_PERSONALITY" );

        aTestResult = CancelSetPersonalityTest( newPersonalityId, ETrue );

        }

    else if ( !testOptionName.Compare( _L( "SET_PREVIOUS_PERSONALITY" ) ) )

        {

        TRACE( "Test option: SET_PREVIOUS_PERSONALITY" );

        aTestResult = SetPreviousPersonalityTest( newPersonalityId, ETrue );

        }

    else if ( !testOptionName.Compare( _L( "SET_PREVIOUS_PERSONALITY_ON_DISC" ) ) )

        {

        TRACE( "Test option: SET_PREVIOUS_PERSONALITY_ON_DISC" );

        aTestResult = SetPreviousPersonalityOnDiscTest( newPersonalityId, ETrue );

        }

    else if ( !testOptionName.Compare( _L( "SET_PREVIOUS_PERSONALITY_SYNC" ) ) )

        {

        TRACE( "Test option: SET_PREVIOUS_PERSONALITY_SYNC" );

        aTestResult = SetPreviousPersonalitySyncTest( newPersonalityId, ETrue );

        }

    else if ( !testOptionName.Compare( _L( "CANCEL_SET_PREVIOUS_PERSONALITY" ) ) )

        {

        TRACE( "Test option: CANCEL_SET_PREVIOUS_PERSONALITY" );

        aTestResult = CancelSetPreviousPersonalityTest( newPersonalityId, ETrue );

        }

    else if ( !testOptionName.Compare( _L( "SET_PERSONALITY_DISC" ) ) )

        {

        TRACE( "Test option: SET_PERSONALITY_DISC" );

        aTestResult = SetPersonalityTest( newPersonalityId, EFalse );

        }

    else if ( !testOptionName.Compare( _L( "CANCEL_SET_PERSONALITY_DISC" ) ) )

        {

        TRACE( "Test option: CANCEL_SET_PERSONALITY_DISC" );

        aTestResult = CancelSetPersonalityTest( newPersonalityId, EFalse );

        }

    else if ( !testOptionName.Compare( _L( "SET_PREVIOUS_PERSONALITY_DISC" ) ) )

        {

        TRACE( "Test option: SET_PREVIOUS_PERSONALITY_DISC" );

        aTestResult = SetPreviousPersonalityTest( newPersonalityId, EFalse );

        }

    else if ( !testOptionName.Compare( _L( "SET_PREVIOUS_PERSONALITY_ON_DISC_DISC" ) ) )

        {

        TRACE( "Test option: SET_PREVIOUS_PERSONALITY_ON_DISC_DISC" );

        aTestResult = SetPreviousPersonalityOnDiscTest( newPersonalityId, EFalse );

        }

    else if ( !testOptionName.Compare( _L( "SET_PREVIOUS_PERSONALITY_SYNC_DISC" ) ) )

        {

        TRACE( "Test option: SET_PREVIOUS_PERSONALITY_SYNC_DISC" );

        aTestResult = SetPreviousPersonalitySyncTest( newPersonalityId, EFalse );

        }

    else if ( !testOptionName.Compare( _L( "CANCEL_SET_PREVIOUS_PERSONALITY_DISC" ) ) )

        {

        TRACE( "Test option: CANCEL_SET_PREVIOUS_PERSONALITY_DISC" );

        aTestResult = CancelSetPreviousPersonalityTest( newPersonalityId, EFalse );

        }

    else if ( !testOptionName.Compare( _L( "SET_UNKNOWN_PERSONALITY" ) ) )

        {

        TRACE( "Test option: SET_UNKNOWN_PERSONALITY" );

        aTestResult = SetUnknownPersonalityTest();

        }

    else if ( !testOptionName.Compare( _L( "INTERRUPT_PERSONALITY_SET" ) ) )

        {

        TRACE( "Test option: INTERRUPT_PERSONALITY_SET" );

        aTestResult = InterruptPersonalitySetTest( newPersonalityId );

        }

    else

        {

        TRACE( "Test option: not supported" );

        User::Leave(KErrNotFound);

        }

    }

TUsbWatcherTestResult CUsbWatcherTest::SetPersonalityTest( TInt aNewPersonalityId, TBool aCableConnected )

    {

    TRequestStatus stat;

    TInt currentPersonalityId;

    TInt res;

    TRACE( "Checking test results:" );

    if ( aCableConnected )

        {

        iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetDeviceState, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) );

        iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStopAsync, 0, 0, _L8( "stub" ) ) );

        iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) );

        }

    TRACE( "  >SetPersonality" );

    iWatcher -> SetPersonality( stat, aNewPersonalityId, EFalse, EFalse );   

    User::WaitForRequest( stat );

    TRACE( "  <SetPersonality" );

    TRACE_INFO("Set personality request status: %d, expected %d", stat.Int(), KErrNone );

    res = iCenRep -> Get( KUsbWatcherPersonality, currentPersonalityId );

    TRACE_INFO("GetCurrentPersonalityId value: %d, expected %d", res, KErrNone );

    TRACE_INFO("Current personality ID: %d, expected: %d", currentPersonalityId, aNewPersonalityId );

    if ( stat.Int() != KErrNone || res != KErrNone || currentPersonalityId != aNewPersonalityId )

        return ETestCaseFailed;

    return ETestCasePassed;    

    }

TUsbWatcherTestResult CUsbWatcherTest::CancelSetPersonalityTest( TInt aNewPersonalityId, TBool aCableConnected )

    {

    TRequestStatus stat;

    TInt previousPersonalityId;

    TInt currentPersonalityId;

    TInt res;

    res = iCenRep -> Get( KUsbWatcherPersonality, previousPersonalityId );

    TRACE_INFO("GetCurrentPersonalityId value: %d, expected %d", res, KErrNone );

    TRACE_INFO("Original personality ID: %d", previousPersonalityId );

    if ( res != KErrNone )

        return ETestCaseFailed;

    TRACE( "Checking test results:" );

    if ( aCableConnected )

        {

        iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetDeviceState, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) );

        iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetDeviceState, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) );

        iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EDeviceStateNotification, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) );

        iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EDeviceStateNotification, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) );

        iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStopAsync, 0, 0, _L8( "stub" ) ) );

        iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) );

        iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetPersonalityProperty, 0, 0, _L8( "stub" ) ) );

        }

    TRACE( "  >SetPersonality" );

    iWatcher -> SetPersonality( stat, aNewPersonalityId, EFalse, EFalse );

    TRACE( "  >CancelSetPersonality" );

    iWatcher -> CancelSetPersonality();

    User::WaitForRequest( stat );

    TRACE( "  <CancelSetPersonality" );

    TRACE_INFO("Cancel set personality request status: %d", stat.Int() );

    res = iCenRep -> Get( KUsbWatcherPersonality, currentPersonalityId );

    TRACE_INFO("GetCurrentPersonalityId value: %d, expected %d", res, KErrNone );

    TRACE_INFO("Current personality ID: %d", currentPersonalityId );

    if ( aCableConnected )

        {

        if ( stat.Int() != KErrCancel || res != KErrNone || currentPersonalityId != previousPersonalityId )

            return ETestCaseFailed;

        }

    else

        {

        if ( stat.Int() != KErrNone || res != KErrNone || currentPersonalityId != aNewPersonalityId )

            return ETestCaseFailed;

        }

    return ETestCasePassed; 

    }

TUsbWatcherTestResult CUsbWatcherTest::SetPreviousPersonalityTest( TInt aNewPersonalityId, TBool aCableConnected )

    {

    TRequestStatus stat;

    TInt previousPersonalityId;

    TInt currentPersonalityId;

    TInt res;

    res = iCenRep -> Get( KUsbWatcherPersonality, previousPersonalityId );

    TRACE_INFO("GetCurrentPersonalityId value: %d, expected %d", res, KErrNone );

    TRACE_INFO("Original personality ID: %d", previousPersonalityId );

    if ( res != KErrNone )

        return ETestCaseFailed;

    TRACE( "  >SetPersonality" );

    iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetDeviceState, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) );

    iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EDeviceStateNotification, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) );

    iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStopAsync, 0, 0, _L8( "stub" ) ) );

    iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) );

    iWatcher -> SetPersonality( stat, aNewPersonalityId, EFalse, EFalse );

    User::WaitForRequest( stat );

    TRACE( "  <SetPersonality" );

    TRACE_INFO("Set personality request status: %d, expected %d", stat.Int(), KErrNone );

    res = iCenRep -> Get( KUsbWatcherPersonality, currentPersonalityId );

    TRACE_INFO("GetCurrentPersonalityId value: %d, expected %d", res, KErrNone );

    TRACE_INFO("Current personality ID: %d, expected: %d", currentPersonalityId, aNewPersonalityId );

    if ( stat.Int() != KErrNone || res != KErrNone || currentPersonalityId != aNewPersonalityId )

        return ETestCaseFailed;

    TRACE( "Checking test results:" );

    if ( aCableConnected )

        {

        iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetDeviceState, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) );

        iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EDeviceStateNotification, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) );

        iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStopAsync, 0, 0, _L8( "stub" ) ) );

        iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) );

        }

    TRACE( "  >SetPreviousPersonality" );

    iWatcher -> SetPreviousPersonality( stat );

    User::WaitForRequest( stat );

    TRACE( "  <SetPreviousPersonality" );

    TRACE_INFO("Set previous personality request status: %d, expected %d", stat.Int(), KErrNone );

    res = iCenRep -> Get( KUsbWatcherPersonality, currentPersonalityId );

    TRACE_INFO("GetCurrentPersonalityId value: %d, expected %d", res, KErrNone );

    TRACE_INFO("Current personality ID: %d, expected: %d", currentPersonalityId, previousPersonalityId );

    if ( stat.Int() != KErrNone || res != KErrNone || currentPersonalityId != previousPersonalityId )