/*

* Copyright (c) 2002 - 2007 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:  Base class for all test cases class member functions

*

*/

// [INCLUDE FILES] - do not remove

#include <tz.h>

#include <e32math.h>

#include <Stiftestinterface.h>

#include <SettingServerClient.h>

#include "AsyncTestCaseBase.h"

#include "messagestoreclientserver.h"

const TInt KExecutionTimeout = 30*1000000;   //30 seconds timelimit for each test case

//Class RDebugSession

TInt RDebugSession::Connect()

    {

#ifdef _DEBUG

    return CreateSession( KMsgStoreServerName, TVersion(KMsgStoreMajorVersion, KMsgStoreMinorVersion, KMsgStoreBuild), 3 );

#endif    

    }

void RDebugSession::Close()

    {

#ifdef _DEBUG

    RSessionBase::Close();  //basecall

#endif    

    }

void RDebugSession::SendBackupRestoreEventL( TUint aEvent )

    {

#ifdef _DEBUG

    User::LeaveIfError( SendReceive( EMsgStoreCmdInjectBackupRestoreEvent, TIpcArgs( aEvent ) ) );

#else

    User::Leave(KErrNotSupported);

#endif    

    }

void RDebugSession::SendPointSecEventL( TBool aLock )

    {

#ifdef _DEBUG

    User::LeaveIfError( SendReceive( EMsgStoreCmdInjectPointSecEvent, TIpcArgs( aLock ) ) );

#else

    User::Leave(KErrNotSupported);

#endif    

    }

void RDebugSession::SimulateLowDiskSpaceL( TUint aLatency )

    {

#ifdef _DEBUG

    User::LeaveIfError( SendReceive( EMsgStoreCmdSimulateLowDiskSpace, TIpcArgs( aLatency ) ) );

#else

    User::Leave(KErrNotSupported);

#endif    

    }    

TInt RDebugSession::GetEncryptionStateL()

    {

#ifdef _DEBUG

    TPckgBuf<TInt> resultPckg(0);

    User::LeaveIfError( SendReceive( EMsgStoreCmdGetEncryptionState, TIpcArgs( &resultPckg ) ) );

    return resultPckg();

#else

    User::Leave(KErrNotSupported);

#endif    

    }

void RDebugSession:: ShutdownServerL()

    {

#ifdef _DEBUG

    User::LeaveIfError( SendReceive( EMsgStoreCmdShutdownServer ) );

#else

    User::Leave(KErrNotSupported);

#endif    

    }

//Class CYieldHelper

CYieldHelper* CYieldHelper::NewL()

    {

    CYieldHelper* self = new(ELeave) CYieldHelper();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

CYieldHelper::CYieldHelper() : CTimer( EPriorityIdle )

    {

    }

void CYieldHelper::ConstructL()

    {

    CTimer::ConstructL();

    iYieldWait = new(ELeave) CActiveSchedulerWait();

    CActiveScheduler::Add(this);

    }

CYieldHelper::~CYieldHelper()

    {

    delete iYieldWait;

    }

void CYieldHelper::Yield( TInt aMicroSeconds )

    {

    After( aMicroSeconds );

    iYieldWait->Start(); 

    }

void CYieldHelper::DoCancel()

    {

    //DO Nothing

    }

void CYieldHelper::RunL()

    {

    if( iYieldWait->IsStarted() )

        {

        // Stop the nested active scheduler (flow-of-control will pick up immediately following the

        // call to iWait.Start().

        iYieldWait->AsyncStop();

        } // end if

    }

//Class CAsyncTestCaseBase

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

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

// Constructor

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

CAsyncTestCaseBase::CAsyncTestCaseBase( CStifLogger* aLog ) 

: CTimer( CActive::EPriorityStandard ), iLog( aLog ), iCaseId(1)  

    {

    // Construct and install active scheduler

    CActiveScheduler* iActiveScheduler = new CActiveScheduler;

    CActiveScheduler::Replace( iActiveScheduler );

    }

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

// Destructor

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

CAsyncTestCaseBase::~CAsyncTestCaseBase()

    {

    Cancel();

    iMessages.ResetAndDestroy();

    delete iMsgStore;

    delete iActiveScheduler;

    delete iYieldHelper;

    }

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

// 2nd phase constructor

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

void CAsyncTestCaseBase::ConstructL()

    {

    CTimer::ConstructL();

    CActiveScheduler::Add(this);  

    //Construct the MsgStore client session

    iMsgStore = CMsgStore::NewL();

    iYieldHelper = CYieldHelper::NewL();

    iState = EStateInit;

    iResult = KErrNone;

    CTimer::After(0);

    }

//stop the execution

void CAsyncTestCaseBase::Stop()

    {

    TRAP_IGNORE( AfterTestL() );

    _LIT( KStop, "Ending test cases... iResult=%d" );

    iLog->Log( KStop, iResult );

    CActiveScheduler::Stop();

    }

void CAsyncTestCaseBase::BeforeTestL()

    {

    _LIT( KBeforeTestLEnter, ">> BeforeTestL" );

    iLog->Log( KBeforeTestLEnter );

    iMsgStore->WipeEverythingL();

    _LIT( KBeforeTestLExit, "<< BeforeTestL" );

    iLog->Log( KBeforeTestLExit );

    }

void CAsyncTestCaseBase::AfterTestL()

    {

    _LIT( KAfterTestLEnter, ">> AfterTestL" );

    iLog->Log( KAfterTestLEnter );

    delete iMsgStore;

    iMsgStore = NULL;

    _LIT( KAfterTestLExit, "<< AfterTestL" );

    iLog->Log( KAfterTestLExit );

    }

//From CTimer

void CAsyncTestCaseBase::RunL()

    {

    if ( iStatus == KErrNone )

        {

        if ( iState == EStateInit )

            {

            BeforeTestL();

            TBool done = EFalse;

            TRAP( iResult, done = ExecuteL() );

            if( iResult == KErrNone )

                {

                if ( done )

                    {

                    iState = EStateDone;

                    Stop();

                    }

                else

                    {

                    iState = EStateExecute;

                    CTimer::After( KExecutionTimeout );

                    }

                }

            else

                {

                iState = EStateDone;

                Stop();

                }

            }

        else if ( iState == EStateExecute )

            {

            //Timer has expired, error out

            iState = EStateDone;

            iResult = KErrTimedOut;

            Stop();

            }

        }

    else if ( iStatus != KErrCancel )

        {

        iState = EStateDone;

        iResult = KErrCorrupt;

        Stop();

        }

    }

TInt CAsyncTestCaseBase::RunError(TInt aError)

    {

    //log the error

    iResult = aError;

    return aError;

    }

void CAsyncTestCaseBase::DoCancel()

    {

    CTimer::DoCancel(); 

    }

void CAsyncTestCaseBase::LogHeader( const TDesC& aTestType )

    {

    _LIT(KDivider, "==============================================================");

    iLog->Log( KDivider );

    iLog->Log( _L("Executing %S Test Cases"), &aTestType );

    iLog->Log( KDivider );

    }

void CAsyncTestCaseBase::CheckCondition( const TDesC& aCondition, TBool aPassed,  TBool aLog  )

    {

    if( aPassed )

        {

        if ( aLog )

            {

            iLog->Log( _L("  PASSED!  Condition: %S"), &aCondition );

            }

        }

    else

        {

        iLog->Log( _L(  "*** FAILED!  Condition: %S"), &aCondition );     

        User::Panic( aCondition, 1 );

        } // end if

    }

void CAsyncTestCaseBase::ComparePropertiesL( const CMsgStorePropertyContainer& aProperties1, const CMsgStorePropertyContainer& aProperties2 )

    {

    iLog->Log( _L("  >> ComparePropertiesL") );

    TBool passed = (aProperties1.PropertyCount() == aProperties2.PropertyCount());

    for( TUint index1 = 0; index1 < aProperties1.PropertyCount(); index1++ )

        {

        TUint index2;

        const TPtrC8 property1Name( aProperties1.PropertyNameL(index1) );

        TBool matched = EFalse;

        if( aProperties2.FindProperty( property1Name, index2 ) )

            {

            TMsgStorePropertyValueType value1 = aProperties1.PropertyTypeL( index1 );

            TMsgStorePropertyValueType value2 = aProperties2.PropertyTypeL( index2 );

            // Found

            if( value1 != value2 )

                {

                iLog->Log( _L("type mismatch") );

                }

            else

                {

                switch( aProperties1.PropertyTypeL( index1 ) )

                    {

                    case EMsgStoreTypeBool:

                        {

                        const TBool property1Value = aProperties1.PropertyValueBoolL(index1);

                        const TBool property2Value = aProperties2.PropertyValueBoolL(index2);

                        if( property1Value == property2Value )

                            {

                            matched = ETrue;

                            }

                        else

                            {

                            iLog->Log( _L("  property %S value mismatch"), &property1Name );                                                         

                            iLog->Log( _L("  expected %i"), &property1Value );                                                            

                            iLog->Log( _L("  found %i"), &property2Value );                                                           

                            }                                   

                        break;

                        }

                    case EMsgStoreTypeUint32:

                        {

                        const TUint32 property1Value = aProperties1.PropertyValueUint32L(index1);

                        const TUint32 property2Value = aProperties2.PropertyValueUint32L(index2);

                        if( property1Value == property2Value )

                            {

                            matched = ETrue;

                            }

                        else

                            {

                            iLog->Log( _L("  property %S value mismatch"), &property1Name );                                                         

                            iLog->Log( _L("  expected %i"), &property1Value );                                                            

                            iLog->Log( _L("  found %i"), &property2Value );                                                           

                            }                                   

                        break;

                        }

                    case EMsgStoreTypeDes:

                        {

                        const TPtrC property1Value( aProperties1.PropertyValueDesL(index1) );

                        const TPtrC property2Value( aProperties2.PropertyValueDesL(index2) );           

                        if( property1Value.Compare( property2Value ) == 0 )

                            {

                            matched = ETrue;

                            }

                        else

                            {

                            iLog->Log( _L("  property %S value mismatch"), &property1Name );                                                         

                            iLog->Log( _L("  expected %S"), &property1Value );                                                            

                            iLog->Log( _L("  found %S"), &property2Value );                                                           

                            }                                   

                        break;

                        }

                    case EMsgStoreTypeDes8:

                        {

                        const TPtrC8 property1Value( aProperties1.PropertyValueDes8L(index1) );

                        const TPtrC8 property2Value( aProperties2.PropertyValueDes8L(index2) );         

                        if( property1Value.Compare( property2Value ) == 0 )

                            {

                            matched = ETrue;

                            }

                        else

                            {

                            iLog->Log( _L("  property %S value mismatch"), &property1Name );                                                         

                            iLog->Log( _L("  expected %S"), &property1Value );                                                           

                            iLog->Log( _L("  found %S"), &property2Value );                                                          

                            }

                        break;

                        }

                    case EMsgStoreTypeContainer:

                        {

                        CMsgStorePropertyContainer* property1Value = aProperties1.PropertyValueContainerL(index1);

                        CMsgStorePropertyContainer* property2Value = aProperties2.PropertyValueContainerL(index2);

                        ComparePropertiesL( *property1Value, *property2Value );                                                                 

                        matched = ETrue;

                        delete property1Value;

                        delete property2Value;

                        break;

                        }                           

                    case EMsgStoreTypeTime:

                        {

                        TTime time1, time2;

                        aProperties1.PropertyValueTimeL( index1, time1 );

                        aProperties2.PropertyValueTimeL( index2, time2 );

                        if ( time1 == time2 )

                            {

                            matched = ETrue;

                            }

                        break;

                        }

                    case EMsgStoreTypeAddress:

                        {

                        RMsgStoreAddress addr1, addr2;

                        aProperties1.PropertyValueAddressL( index1, addr1 );

                        aProperties2.PropertyValueAddressL( index2, addr2 );

                        if ( addr1.iEmailAddress == addr2.iEmailAddress && addr1.iDisplayName == addr2.iDisplayName )

                            {

                            matched = ETrue;

                            }

                        addr1.Close();

                        addr2.Close();

                        break;

                        }

                    } // end switch

                } // end if

            }

        else

            {

            iLog->Log( _L("  property %S not found"), &property1Name );                  

            }

        passed = passed && matched;

        } // end for            

    TBuf<30> text;

    text.Format( _L("compare %i properties"), aProperties1.PropertyCount() );

    CheckCondition( text, passed );

    iLog->Log( _L("  << ComparePropertiesL") );

    }

TUint CAsyncTestCaseBase::TestAddIntegerPropertyL( CMsgStorePropertyContainer& aProperties, const TDesC8& aName, TUint32 aValue, TBool aUseAddOrUpdate )

    {

    TUint countBefore = aProperties.PropertyCount();

    TUint index;

    if( aUseAddOrUpdate )

        {

        index = aProperties.AddOrUpdatePropertyL( aName, aValue );          

        }

    else

        {

        index = aProperties.AddPropertyL( aName, aValue );  

        } // end if

    TRAPD( des8Result, aProperties.PropertyValueDes8L( index ) );

    TRAPD( desResult, aProperties.PropertyValueDesL( index ) );

    TRAPD( containerResult, aProperties.PropertyValueContainerL( index ) );

    TRAPD( boolResult, aProperties.PropertyValueBoolL( index ) );

    TBool passed = (aProperties.PropertyCount() == (countBefore+1) &&

                    aProperties.PropertyNameL( index ).Compare( aName ) == 0 &&

                    aProperties.PropertyTypeL( index ) == EMsgStoreTypeUint32 &&                        

                    aProperties.PropertyValueUint32L( index ) == aValue &&

                    des8Result == KErrArgument &&

                    desResult == KErrArgument &&

                    containerResult == KErrArgument &&

                    boolResult == KErrArgument );

    CheckCondition( _L("add integer property"), passed );

    return index;

    } 

TUint CAsyncTestCaseBase::TestAddBoolPropertyL( CMsgStorePropertyContainer& aProperties, const TDesC8& aName, TBool aValue, TBool aUseAddOrUpdate )

    {

    TUint countBefore = aProperties.PropertyCount();

    TUint index;

    if( aUseAddOrUpdate )

        {

        index = aProperties.AddOrUpdatePropertyL( aName, aValue );          

        }

    else

        {

        index = aProperties.AddPropertyL( aName, aValue );  

        } // end if

    TRAPD( des8Result, aProperties.PropertyValueDes8L( index ) );

    TRAPD( desResult, aProperties.PropertyValueDesL( index ) );

    TRAPD( containerResult, aProperties.PropertyValueContainerL( index ) );

    TRAPD( integerResult, aProperties.PropertyValueUint32L( index ) );

    TBool passed = (aProperties.PropertyCount() == (countBefore+1) &&

                    aProperties.PropertyNameL( index ).Compare( aName ) == 0 &&

                    aProperties.PropertyTypeL( index ) == EMsgStoreTypeBool &&

                    aProperties.PropertyValueBoolL( index ) == aValue &&

                    des8Result == KErrArgument &&

                    desResult == KErrArgument &&

                    containerResult == KErrArgument &&

                    integerResult == KErrArgument );

    CheckCondition( _L("add bool property"), passed );

    return index;