--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/emailservices/emailstore/tsrc/message_store_test/src/AsyncTestCaseBase.cpp Thu Jan 07 12:38:38 2010 +0200
@@ -0,0 +1,1279 @@
+/*
+* 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;
+ }
+
+TUint CAsyncTestCaseBase::TestAddDes8PropertyL( CMsgStorePropertyContainer& aProperties, const TDesC8& aName, const TDesC8& 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( boolResult, aProperties.PropertyValueBoolL( index ) );
+ TRAPD( intResult, aProperties.PropertyValueUint32L( index ) );
+ TRAPD( desResult, aProperties.PropertyValueDesL( index ) );
+ TRAPD( containerResult, aProperties.PropertyValueContainerL( index ) );
+
+ TBool passed = (aProperties.PropertyCount() == (countBefore+1) &&
+ aProperties.PropertyNameL( index ).Compare( aName ) == 0 &&
+ aProperties.PropertyTypeL( index ) == EMsgStoreTypeDes8 &&
+ aProperties.PropertyValueDes8L( index ).Compare( aValue ) == 0 &&
+ intResult == KErrArgument &&
+ desResult == KErrArgument &&
+ containerResult == KErrArgument &&
+ boolResult == KErrArgument );
+
+ CheckCondition( _L("add des8 property"), passed );
+
+ return index;
+ }
+
+TUint CAsyncTestCaseBase::TestAddDesPropertyL( CMsgStorePropertyContainer& aProperties, const TDesC8& aName, const TDesC& 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( boolResult, aProperties.PropertyValueBoolL( index ) );
+ TRAPD( intResult, aProperties.PropertyValueUint32L( index ) );
+ TRAPD( des8Result, aProperties.PropertyValueDes8L( index ) );
+ TRAPD( containerResult, aProperties.PropertyValueContainerL( index ) );
+
+ TBool passed = (aProperties.PropertyCount() == (countBefore+1) &&
+ aProperties.PropertyNameL( index ).Compare( aName ) == 0 &&
+ aProperties.PropertyTypeL( index ) == EMsgStoreTypeDes &&
+ aProperties.PropertyValueDesL( index ).Compare( aValue ) == 0 &&
+ intResult == KErrArgument &&
+ des8Result == KErrArgument &&
+ containerResult == KErrArgument &&
+ boolResult == KErrArgument );
+
+ CheckCondition( _L("add des property"), passed );
+
+ return index;
+ }
+
+TUint CAsyncTestCaseBase::TestAddContainerPropertyL( CMsgStorePropertyContainer& aProperties, const TDesC8& aName, const CMsgStorePropertyContainer& aValue, TBool aUseAddOrUpdate )
+ {
+ TUint countBefore = aProperties.PropertyCount();
+
+ TUint index;
+ if( aUseAddOrUpdate )
+ {
+ index = aProperties.AddOrUpdatePropertyL( aName, aValue );
+ }
+ else
+ {
+ index = aProperties.AddPropertyL( aName, aValue );
+ } // end if
+
+ CMsgStorePropertyContainer* container = aProperties.PropertyValueContainerL( index );
+ ComparePropertiesL( aValue, *container );
+ delete container;
+
+ TRAPD( boolResult, aProperties.PropertyValueUint32L( index ) );
+ TRAPD( intResult, aProperties.PropertyValueUint32L( index ) );
+ TRAPD( des8Result, aProperties.PropertyValueDes8L( index ) );
+ TRAPD( desResult, aProperties.PropertyValueDesL( index ) );
+
+ TBool passed = (aProperties.PropertyCount() == (countBefore+1) &&
+ aProperties.PropertyNameL( index ).Compare( aName ) == 0 &&
+ aProperties.PropertyTypeL( index ) == EMsgStoreTypeContainer &&
+ desResult == KErrArgument &&
+ des8Result == KErrArgument &&
+ intResult == KErrArgument &&
+ boolResult == KErrArgument );
+
+ CheckCondition( _L("add container property"), passed );
+
+ return index;
+ }
+
+TUint CAsyncTestCaseBase::TestAddTimePropertyL( CMsgStorePropertyContainer& aProperties, const TDesC8& aName, const TTime& 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 ) );
+ TRAPD( boolResult, aProperties.PropertyValueBoolL( index ) );
+
+ TBool passed = (aProperties.PropertyCount() == (countBefore+1) &&
+ aProperties.PropertyNameL( index ).Compare( aName ) == 0 &&
+ aProperties.PropertyTypeL( index ) == EMsgStoreTypeTime &&
+ des8Result == KErrArgument &&
+ desResult == KErrArgument &&
+ containerResult == KErrArgument &&
+ integerResult == KErrArgument &&
+ boolResult == KErrArgument );
+
+ TTime time;
+ aProperties.PropertyValueTimeL( index, time );
+
+ passed = passed && time == aValue;
+
+ CheckCondition( _L("add time property"), passed );
+
+ return index;
+ }
+
+TUint CAsyncTestCaseBase::TestAddAddressPropertyL( CMsgStorePropertyContainer& aProperties, const TDesC8& aName, const RMsgStoreAddress& 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 ) );
+ TRAPD( boolResult, aProperties.PropertyValueBoolL( index ) );
+ TTime time;
+ TRAPD( timeResult, aProperties.PropertyValueTimeL( index, time ) );
+
+ TBool passed = (aProperties.PropertyCount() == (countBefore+1) &&
+ aProperties.PropertyNameL( index ).Compare( aName ) == 0 &&
+ aProperties.PropertyTypeL( index ) == EMsgStoreTypeAddress &&
+ des8Result == KErrArgument &&
+ desResult == KErrArgument &&
+ containerResult == KErrArgument &&
+ integerResult == KErrArgument &&
+ boolResult == KErrArgument &&
+ timeResult == KErrArgument );
+
+ RMsgStoreAddress address;
+ aProperties.PropertyValueAddressL( index, address );
+
+ iLog->Log( _L(" passed=%d"), passed );
+ iLog->Log( _L(" email addr=%S, disp name=%S"), &address.iEmailAddress, &address.iDisplayName);
+
+ passed = passed && (address.iEmailAddress == aValue.iEmailAddress) && (address.iDisplayName == aValue.iDisplayName);
+
+ address.Close();
+
+ CheckCondition( _L("add address property"), passed );
+
+ return index;
+ }
+
+void CAsyncTestCaseBase::TestRemovePropertyL( CMsgStorePropertyContainer& aProperties, TUint aIndex )
+ {
+ TUint countBefore = aProperties.PropertyCount();
+
+ TBuf8<500> oldName;
+ oldName.Copy( aProperties.PropertyNameL( aIndex ) );
+
+ aProperties.RemovePropertyL( aIndex );
+
+ TUint index;
+ TBool found = aProperties.FindProperty( oldName, index );
+
+ TBool passed = (!found &&
+ aProperties.PropertyCount() == (countBefore-1) );
+
+ CheckCondition( _L("remove property"), passed );
+ }
+
+void CAsyncTestCaseBase::TestUpdateDes8PropertyL( CMsgStorePropertyContainer& aProperties, TUint aIndex, const TDesC8& aNewValue, TBool aUseAddOrUpdate )
+ {
+ TUint countBefore = aProperties.PropertyCount();
+
+ TBuf8<500> oldName;
+ oldName.Copy( aProperties.PropertyNameL( aIndex ) );
+
+ if( aUseAddOrUpdate )
+ {
+ aProperties.AddOrUpdatePropertyL( aProperties.PropertyNameL(aIndex), aNewValue );
+ }
+ else
+ {
+ aProperties.UpdatePropertyL( aIndex, aNewValue );
+ } // end if
+
+ TRAPD( intResult, aProperties.PropertyValueUint32L( aIndex ) );
+ TRAPD( desResult, aProperties.PropertyValueDesL( aIndex ) );
+ TRAPD( containerResult, aProperties.PropertyValueContainerL( aIndex ) );
+ TRAPD( boolResult, aProperties.PropertyValueBoolL( aIndex ) );
+
+ TPtrC8 des8( aProperties.PropertyValueDes8L( aIndex ) );
+
+ TBool passed = (aProperties.PropertyCount() == countBefore &&
+ aProperties.PropertyNameL( aIndex ).Compare( oldName ) == 0 &&
+ aProperties.PropertyTypeL( aIndex ) == EMsgStoreTypeDes8 &&
+ des8.Compare( aNewValue ) == 0 &&
+ intResult == KErrArgument &&
+ desResult == KErrArgument &&
+ containerResult == KErrArgument &&
+ boolResult == KErrArgument );
+
+ CheckCondition( _L("update des8 property"), passed );
+ }
+
+void CAsyncTestCaseBase::TestUpdateDesPropertyL( CMsgStorePropertyContainer& aProperties, TUint aIndex, const TDesC& aNewValue, TBool aUseAddOrUpdate )
+ {
+ TUint countBefore = aProperties.PropertyCount();
+
+ TBuf8<500> oldName;
+ oldName.Copy( aProperties.PropertyNameL( aIndex ) );
+
+ if( aUseAddOrUpdate )
+ {
+ aProperties.AddOrUpdatePropertyL( aProperties.PropertyNameL(aIndex), aNewValue );
+ }
+ else
+ {
+ aProperties.UpdatePropertyL( aIndex, aNewValue );
+ } // end if
+
+ TRAPD( intResult, aProperties.PropertyValueUint32L( aIndex ) );
+ TRAPD( des8Result, aProperties.PropertyValueDes8L( aIndex ) );
+ TRAPD( containerResult, aProperties.PropertyValueContainerL( aIndex ) );
+ TRAPD( boolResult, aProperties.PropertyValueBoolL( aIndex ) );
+
+ TPtrC des( aProperties.PropertyValueDesL( aIndex ) );
+
+ TBool passed = (aProperties.PropertyCount() == countBefore &&
+ aProperties.PropertyNameL( aIndex ).Compare( oldName ) == 0 &&
+ aProperties.PropertyTypeL( aIndex ) == EMsgStoreTypeDes &&
+ des.Compare( aNewValue ) == 0 &&
+ intResult == KErrArgument &&
+ des8Result == KErrArgument &&
+ containerResult == KErrArgument &&
+ boolResult == KErrArgument );
+
+ CheckCondition( _L("update string(16) property"), passed );
+ }
+
+void CAsyncTestCaseBase::TestUpdateContainerPropertyL( CMsgStorePropertyContainer& aProperties, TUint aIndex, CMsgStorePropertyContainer& aNewValue, TBool aUseAddOrUpdate )
+ {
+ TUint countBefore = aProperties.PropertyCount();
+
+ TBuf8<500> oldName;
+ oldName.Copy( aProperties.PropertyNameL( aIndex ) );
+
+ if( aUseAddOrUpdate )
+ {
+ aProperties.AddOrUpdatePropertyL( aProperties.PropertyNameL(aIndex), aNewValue );
+ }
+ else
+ {
+ aProperties.UpdatePropertyL( aIndex, aNewValue );
+ } // end if
+
+ CMsgStorePropertyContainer* container = aProperties.PropertyValueContainerL( aIndex );
+ ComparePropertiesL( aNewValue, *container );
+ delete container;
+
+ TRAPD( intResult, aProperties.PropertyValueUint32L( aIndex ) );
+ TRAPD( des8Result, aProperties.PropertyValueDes8L( aIndex ) );
+ TRAPD( desResult, aProperties.PropertyValueDesL( aIndex ) );
+ TRAPD( boolResult, aProperties.PropertyValueBoolL( aIndex ) );
+
+ TBool passed = (aProperties.PropertyCount() == countBefore &&
+ aProperties.PropertyNameL( aIndex ).Compare( oldName ) == 0 &&
+ aProperties.PropertyTypeL( aIndex ) == EMsgStoreTypeContainer &&
+ intResult == KErrArgument &&
+ des8Result == KErrArgument &&
+ desResult == KErrArgument &&
+ boolResult == KErrArgument );
+
+ CheckCondition( _L("update container property"), passed );
+ }
+
+void CAsyncTestCaseBase::TestUpdateBoolPropertyL( CMsgStorePropertyContainer& aProperties, TUint aIndex, TBool aNewValue, TBool aUseAddOrUpdate )
+ {
+ TUint countBefore = aProperties.PropertyCount();
+
+ TBuf8<500> oldName;
+ oldName.Copy( aProperties.PropertyNameL( aIndex ) );
+
+ if( aUseAddOrUpdate )
+ {
+ aProperties.AddOrUpdatePropertyL( aProperties.PropertyNameL(aIndex), aNewValue );
+ }
+ else
+ {
+ aProperties.UpdatePropertyL( aIndex, aNewValue );
+ } // end if
+
+ TRAPD( intResult, aProperties.PropertyValueUint32L( aIndex ) );
+ TRAPD( des8Result, aProperties.PropertyValueDes8L( aIndex ) );
+ TRAPD( desResult, aProperties.PropertyValueDesL( aIndex ) );
+ TRAPD( containerResult, aProperties.PropertyValueContainerL( aIndex ) );
+
+ TBool passed = (aProperties.PropertyCount() == countBefore &&
+ aProperties.PropertyNameL( aIndex ).Compare( oldName ) == 0 &&
+ aProperties.PropertyTypeL( aIndex ) == EMsgStoreTypeBool &&
+ aProperties.PropertyValueBoolL( aIndex ) == aNewValue &&
+ des8Result == KErrArgument &&
+ desResult == KErrArgument &&
+ containerResult == KErrArgument &&
+ intResult == KErrArgument );
+
+ CheckCondition( _L("update bool property"), passed );
+ }
+
+void CAsyncTestCaseBase::TestUpdateIntegerPropertyL( CMsgStorePropertyContainer& aProperties, TUint aIndex, TUint32 aNewValue, TBool aUseAddOrUpdate )
+ {
+ TUint countBefore = aProperties.PropertyCount();
+
+ TBuf8<500> oldName;
+ oldName.Copy( aProperties.PropertyNameL( aIndex ) );
+
+ if( aUseAddOrUpdate )
+ {
+ aProperties.AddOrUpdatePropertyL( aProperties.PropertyNameL(aIndex), aNewValue );
+ }
+ else
+ {
+ aProperties.UpdatePropertyL( aIndex, aNewValue );
+ } // end if
+
+ TRAPD( des8Result, aProperties.PropertyValueDes8L( aIndex ) );
+ TRAPD( desResult, aProperties.PropertyValueDesL( aIndex ) );
+ TRAPD( containerResult, aProperties.PropertyValueContainerL( aIndex ) );
+ TRAPD( boolResult, aProperties.PropertyValueBoolL( aIndex ) );
+
+ TBool passed = (aProperties.PropertyCount() == countBefore &&
+ aProperties.PropertyNameL( aIndex ).Compare( oldName ) == 0 &&
+ aProperties.PropertyTypeL( aIndex ) == EMsgStoreTypeUint32 &&
+ aProperties.PropertyValueUint32L( aIndex ) == aNewValue &&
+ des8Result == KErrArgument &&
+ desResult == KErrArgument &&
+ containerResult == KErrArgument &&
+ boolResult == KErrArgument );
+
+ CheckCondition( _L("update integer property"), passed );
+ }
+
+void CAsyncTestCaseBase::TestUpdateTimePropertyL( CMsgStorePropertyContainer& aProperties, TUint aIndex, const TTime& aNewValue, TBool aUseAddOrUpdate )
+ {
+ TUint countBefore = aProperties.PropertyCount();
+
+ TBuf8<500> oldName;
+ oldName.Copy( aProperties.PropertyNameL( aIndex ) );
+
+ if( aUseAddOrUpdate )
+ {
+ aProperties.AddOrUpdatePropertyL( aProperties.PropertyNameL(aIndex), aNewValue );
+ }
+ else
+ {
+ aProperties.UpdatePropertyL( aIndex, aNewValue );
+ } // end if
+
+ TRAPD( des8Result, aProperties.PropertyValueDes8L( aIndex ) );
+ TRAPD( desResult, aProperties.PropertyValueDesL( aIndex ) );
+ TRAPD( containerResult, aProperties.PropertyValueContainerL( aIndex ) );
+ TRAPD( boolResult, aProperties.PropertyValueBoolL( aIndex ) );
+ TRAPD( intResult, aProperties.PropertyValueUint32L( aIndex ) );
+
+ TBool passed = (aProperties.PropertyCount() == countBefore &&
+ aProperties.PropertyNameL( aIndex ).Compare( oldName ) == 0 &&
+ aProperties.PropertyTypeL( aIndex ) == EMsgStoreTypeTime &&
+ des8Result == KErrArgument &&
+ desResult == KErrArgument &&
+ containerResult == KErrArgument &&
+ boolResult == KErrArgument &&
+ intResult == KErrArgument );
+
+ TTime time;
+ aProperties.PropertyValueTimeL( aIndex, time );
+
+ passed = passed && time == aNewValue;
+
+
+ CheckCondition( _L("update time property"), passed );
+ }
+
+
+void CAsyncTestCaseBase::TestUpdateAddressPropertyL( CMsgStorePropertyContainer& aProperties, TUint aIndex, const RMsgStoreAddress& aNewValue, TBool aUseAddOrUpdate )
+ {
+ TUint countBefore = aProperties.PropertyCount();
+
+ TBuf8<500> oldName;
+ oldName.Copy( aProperties.PropertyNameL( aIndex ) );
+
+ if( aUseAddOrUpdate )
+ {
+ aProperties.AddOrUpdatePropertyL( aProperties.PropertyNameL(aIndex), aNewValue );
+ }
+ else
+ {
+ aProperties.UpdatePropertyL( aIndex, aNewValue );
+ } // end if
+
+ TRAPD( des8Result, aProperties.PropertyValueDes8L( aIndex ) );
+ TRAPD( desResult, aProperties.PropertyValueDesL( aIndex ) );
+ TRAPD( containerResult, aProperties.PropertyValueContainerL( aIndex ) );
+ TRAPD( boolResult, aProperties.PropertyValueBoolL( aIndex ) );
+ TRAPD( intResult, aProperties.PropertyValueUint32L( aIndex ) );
+ TTime time;
+ TRAPD( timeResult, aProperties.PropertyValueTimeL( aIndex, time ) );
+
+ TBool passed = (aProperties.PropertyCount() == countBefore &&
+ aProperties.PropertyNameL( aIndex ).Compare( oldName ) == 0 &&
+ aProperties.PropertyTypeL( aIndex ) == EMsgStoreTypeAddress &&
+ des8Result == KErrArgument &&
+ desResult == KErrArgument &&
+ containerResult == KErrArgument &&
+ boolResult == KErrArgument &&
+ intResult == KErrArgument,
+ timeResult == KErrArgument );
+
+ RMsgStoreAddress address;
+ aProperties.PropertyValueAddressL( aIndex, address );
+
+ iLog->Log( _L(" email addr=%S, disp name=%S"), &address.iEmailAddress, &address.iDisplayName);
+
+ passed = passed && (address.iEmailAddress == aNewValue.iEmailAddress) && (address.iDisplayName == aNewValue.iDisplayName);
+
+ address.Close();
+
+ CheckCondition( _L("update address property"), passed );
+ }
+
+void CAsyncTestCaseBase::CopyDesToDes8( const TDesC& aDes, TDes8& aDes8 )
+ {
+ const TUint8* ptr = reinterpret_cast<const TUint8*>( aDes.Ptr() );
+
+ aDes8.Copy( ptr, aDes.Length() * 2 );
+ }
+
+void CAsyncTestCaseBase::SimulateLowDiskSpaceL( TUint aLatency )
+ {
+ RDebugSession session;
+ User::LeaveIfError( session.Connect() );
+ session.SimulateLowDiskSpaceL( aLatency );
+ session.Close();
+ }
+
+void CAsyncTestCaseBase::TriggerBackupRestoreEventL( TUint aEvent )
+ {
+ RDebugSession session;
+ User::LeaveIfError( session.Connect() );
+ session.SendBackupRestoreEventL( aEvent );
+ session.Close();
+ }
+
+void CAsyncTestCaseBase::TriggerPointSecEventL( TBool aLock )
+ {
+ RDebugSession session;
+ User::LeaveIfError( session.Connect() );
+ session.SendPointSecEventL( aLock );
+ session.Close();
+ }
+
+void CAsyncTestCaseBase::ShutdownServerL()
+ {
+ RDebugSession temp;
+ User::LeaveIfError( temp.Connect() );
+ temp.ShutdownServerL();
+ temp.Close();
+ }
+
+void CAsyncTestCaseBase::Yield( TInt aMicroSeconds )
+ {
+ iYieldHelper->Yield( aMicroSeconds );
+ }
+
+void CAsyncTestCaseBase::CreateRandomMessagesL( CMsgStoreMailBox* aMailBox, TMsgStoreId aFolderId, TInt aCount, TBool aKeepIds, TBool /* aLog */ )
+ {
+ iLog->Log( _L(" >> CreateRandomMessagesL, creating %d messages"), aCount );
+
+ TTime time;
+ time.HomeTime();
+ TInt64 seed = time.Int64();
+
+ CMsgStorePropertyContainer* properties = CMsgStorePropertyContainer::NewL();
+ CleanupStack::PushL( properties ); //+1
+
+ RMsgStoreAddress address;
+ CleanupClosePushL( address ); //+2
+
+ address.iDisplayName.Create( 50 );
+ address.iEmailAddress.Create( 50 );
+
+ TBuf<30> subject;
+ TBuf<50> realSubject;
+ TBuf<6> fname, lname;
+ TTime startTime;
+
+ if ( aKeepIds )
+ {
+ iMatches.Reset();
+ }
+
+ RTz timeZoneServer;
+ User::LeaveIfError( timeZoneServer.Connect() );
+ CleanupClosePushL( timeZoneServer ); //+3
+
+ for (TInt i = 0 ; i < aCount ; i++ )
+ {
+ TTime received;
+ received.HomeTime();
+ TTimeIntervalDays days( (i+1) % 9 );
+ TTimeIntervalHours hours( (i+1) %9 );
+ received -= days;
+ received += hours;
+
+ timeZoneServer.ConvertToUniversalTime( received );
+ properties->AddOrUpdatePropertyL( KMsgStorePropertyReceivedAt, received );
+
+ TUint32 flags = Math::Rand( seed );
+ properties->AddOrUpdatePropertyL( KMsgStorePropertyFlags, (TUint32) flags );
+
+ TUint32 size = Math::Rand( seed );
+ properties->AddOrUpdatePropertyL( KMsgStorePropertyMessageSizeOnServer, (TUint32) size );
+
+ if ( i == 0 || i % 9 == 0 )
+ {
+ CreateRandomString( subject, 30, seed );
+ CreateRandomString( fname, 6, seed );
+ CreateRandomString( lname, 6, seed );
+ }
+
+ realSubject.SetLength(0);
+ if ( i % 5 == 0 )
+ {
+ realSubject.Copy(_L("RE: "));
+ }
+ else if ( i % 10 == 0 )
+ {
+ realSubject.Copy(_L("RE: FWD:"));
+ }
+ else if ( i % 3 == 0 )
+ {
+ realSubject.Copy(_L("R&D:"));
+ }
+ realSubject.Append( subject );
+
+ properties->AddOrUpdatePropertyL( KMsgStorePropertySubject, realSubject );
+
+ if ( i % 10 > 0 )
+ {
+ //skip display name for every 10 messages
+ address.iDisplayName.Format( _L("%S %S"), &fname, &lname );
+ }
+ _LIT(KDomainName, "nokia.com");
+ address.iEmailAddress.Format( _L("%S.%S@%S"), &fname, &lname, &KDomainName);
+ properties->AddOrUpdatePropertyL( KMsgStorePropertyFrom, address );
+
+ properties->AddOrUpdatePropertyL( KMsgStorePropertyTo, address );
+
+ if ( i == aCount - 1 )
+ {
+ startTime.HomeTime();
+ }
+ CMsgStoreMessage* msg = aMailBox->CreateMessageL( aFolderId, *properties );
+ CleanupStack::PushL( msg );
+ msg->CommitL();
+
+ if ( i == aCount - 1 )
+ {
+ TTime endTime;
+ endTime.HomeTime();
+ // iLog->Log( _L(" PERFORMANCE: add messages #%d took %d ms"), aCount, (TInt) (endTime.MicroSecondsFrom( startTime ).Int64() / 1000) );
+ }
+
+#if 0
+ if ( aLog )
+ {
+ iLog->Log( _L(" msgId=%x, flags=%x, size=%d"), msg->Id(), flags, size);
+ iLog->Log( _L(" subject=%S"), &realSubject );
+ }
+ else if ( i % 10 == 9 )
+ {
+ iLog->Log( _L(" count=%d, msgId=%x"), i+1, msg->Id() );
+ }
+#endif
+
+ if ( aKeepIds )
+ {
+ iMatches.Append( msg->Id() );
+ }
+
+ CleanupStack::PopAndDestroy( msg );
+ }
+
+ CleanupStack::PopAndDestroy( 3 );
+
+ iLog->Log( _L(" << CreateRandomMessagesL") );
+ }
+
+void CAsyncTestCaseBase::CreateFileL( const TDesC& aName, TUint aTotalLength, TChar aFillChar, const TDesC& aString, TUint aOffset )
+ {
+ RFs fs;
+ User::LeaveIfError( fs.Connect() );
+ RFile file;
+ User::LeaveIfError( file.Replace( fs, aName, EFileWrite ) );
+
+ TUint currentLength = 0;
+
+ TBuf<1000> buf;
+
+ const TUint8* buf8Ptr = reinterpret_cast<const TUint8*>( buf.Ptr() );
+ TPtrC8 buf8( buf8Ptr, 2000 );
+
+ buf.Fill( aFillChar, 1000 );
+ while( currentLength < aOffset )
+ {
+ TUint amountToWrite = aOffset - currentLength;
+ if( amountToWrite > 1000 )
+ {
+ amountToWrite = 1000;
+ }
+
+ file.Write( buf8, amountToWrite*2 );
+
+ currentLength += amountToWrite;
+ }
+
+ buf.Copy( aString );
+ file.Write( buf8, aString.Length() * 2 );
+ currentLength += aString.Length();
+
+ buf.Fill( aFillChar, 1000 );
+ while( currentLength < aTotalLength )
+ {
+ TUint amountToWrite = aTotalLength - currentLength;
+ if( amountToWrite > 1000 )
+ {
+ amountToWrite = 1000;
+ }
+
+ file.Write( buf8, amountToWrite*2 );
+
+ currentLength += amountToWrite;
+ }
+
+ file.Close();
+ fs.Close();
+ }
+
+
+void CAsyncTestCaseBase::CreateRandomString( TDes& aString, TInt aLength, TInt64& aSeed )
+ {
+ aString.SetLength(0);
+ for ( TInt i = 0 ; i < aLength; i++ )
+ {
+ TUint val = static_cast<TUint>(Math::Rand( aSeed ));
+ val = ( val % 52 );
+ if ( val <= 25 )
+ {
+ val += 65;
+ }
+ else
+ {
+ val += ( 97 - 26 );
+ }
+ aString.Append( TChar(val) );
+ }
+ }
+
+void CAsyncTestCaseBase::SetMessageContentL( CMsgStoreMessage* aMessage, const TDesC8& aContent )
+ {
+ CMsgStorePropertyContainer* props = CMsgStorePropertyContainer::NewL();
+ CleanupStack::PushL( props );
+
+ CMsgStoreMessagePart* body = aMessage->AddChildPartL( *props );
+ CleanupStack::PushL( body );
+
+ CMsgStoreMessagePart* plainTextbody = body->AddChildPartL( *props );
+ CleanupStack::PushL( plainTextbody );
+
+ plainTextbody->ReplaceContentL( aContent );
+
+ CleanupStack::PopAndDestroy( plainTextbody );
+ CleanupStack::PopAndDestroy( body );
+ CleanupStack::PopAndDestroy( props );
+ }
+
+void CAsyncTestCaseBase::WaitForServerToTerminate()
+ {
+ TBool done = EFalse;
+
+ RDebugSession temp;
+
+ while( !done )
+ {
+ TInt err = temp.Connect();
+
+ if (err == KErrNone )
+ {
+ temp.Close();
+
+ // Still running. Wait.
+ Yield( 1000000 );
+ }
+ else
+ {
+ done = ETrue;
+ }
+
+ } // end if
+
+ temp.Close();
+ }
+