diff -r 000000000000 -r 72b543305e3a mobilemessaging/smsmtm/clientmtm/test/src/smcmstepbase.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mobilemessaging/smsmtm/clientmtm/test/src/smcmstepbase.cpp Thu Dec 17 08:44:11 2009 +0200 @@ -0,0 +1,480 @@ +// Copyright (c) 2005-2009 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 "smcmstepbase.h" + +#include +#include +#include +#include +#include +#include "emstestutils.h" +#include +#include +#include + +RTest test( _L( "SMS Test" ) ); + +const TInt KOneHourSeconds = 3600; + +// @return - TVerdict +// Implementation of CTestStep base class virtual +// All common initialisation to derived classes is done in here. +TVerdict CSMCMStepBase::doTestStepPreambleL( ) + { + INFO_PRINTF1( _L( "CSMCMStepBase::doTestStepPreambleL()" ) ); + + ChangeLocale ( KUTC0 ); + + iScheduler = new( ELeave ) CActiveScheduler; + CActiveScheduler::Install( iScheduler ); + + // need this to open a server session + iDummyObserver = new( ELeave ) TMsvDummyObserver; + + // All the test steps will need an SMS Client MTM so we + // build it here + iSmsTestUtils = CSmsTestUtils::NewL( test ); + iSmsTestUtils->SetLogToFile( ); + iSmsTestUtils->InstantiateClientMtmsL( ); + + // Initialize mailbox + CSmsSettings* settings = CSmsSettings::NewL( ); + CleanupStack::PushL( settings ); + CSmsAccount* account = CSmsAccount::NewLC( ); + TRAPD(err,account->InitialiseDefaultSettingsL( *settings ) ); + if ( err != KErrNone ) + { + User::Leave( err ); + } + + CleanupStack::PopAndDestroy( account ); + CleanupStack::PopAndDestroy( settings ); + + // open the server session + iServerSession = CMsvSession::OpenSyncL( *iDummyObserver ); + + // create the Client MTM registry and get the Client MTM from it + iClientMtmRegistry = CClientMtmRegistry::NewL( *iServerSession ); + iSmsClientMtm = ( CSmsClientMtm* ) iClientMtmRegistry->NewMtmL( KUidMsgTypeSMS ); + + // create the root entry + iMsvEntry = CMsvEntry::NewL( *iServerSession, + KMsvRootIndexEntryId, + TMsvSelectionOrdering( ) ); + + TSmsUtilities::ServiceIdL( *iServerSession, + iSmsServiceId, + KUidMsgTypeSMS ); + + SetTestStepResult( EPass ); + + return TestStepResult( ); + } + +CSMCMStepBase::~CSMCMStepBase( ) + { + delete iSmsClientMtm; + delete iClientMtmRegistry; + + delete iDummyObserver; + delete iServerSession; + + delete iScheduler; + + } + +CSMCMStepBase::CSMCMStepBase( ) + { + + } + +void CSMCMStepBase::ChangeLocale( TInt aHours ) + { + User::SetUTCOffset( KOneHourSeconds * aHours ); + } + +TMsvId CSMCMStepBase::CreateEmailSmsMessageL( const TDesC& aEmailMessageData ) + { + RFs fs; + User::LeaveIfError( fs.Connect( ) ); + CleanupClosePushL( fs ); + + CSmsMessage* message = CSmsMessage::NewL( fs, + CSmsPDU::ESmsDeliver, + CSmsEditorBuffer::NewL( *iSmsTestUtils->iRichText ), + EFalse ); + CleanupStack::PushL( message ); + + CSmsBufferBase& buffer = message->Buffer( ); + buffer.Reset( ); + buffer.InsertL( 0, aEmailMessageData ); + + // Set the PID for email. + if( message->SmsPDU( ).ProtocolIdentifierPresent( ) ) + { + message->SmsPDU( ).SetPIDType( TSmsProtocolIdentifier::ESmsPIDTelematicInterworking ); + message->SmsPDU( ).SetTelematicDeviceIndicator( TSmsProtocolIdentifier::ESmsTelematicDevice ); + message->SmsPDU( ).SetTelematicDeviceType( TSmsProtocolIdentifier::ESmsInternetElectronicMail ); + + } + + // Create a new SMS header ( CSmsHeader takes ownership of message ) + CSmsHeader* header = CSmsHeader::NewL( message ); + CleanupStack::Pop( message ); + CleanupStack::PushL( header ); + + header->SetFromAddressL( KScriptItemRecipientsDef ); + header->Message( ).SetServiceCenterAddressL( KScriptItemSCDef ); + + // Set the entry data... + TMsvEntry entry; + entry.iType = KUidMsvMessageEntry; + entry.SetSendingState( KMsvSendStateNotApplicable ); + TSmsUtilities::PopulateMsgEntry( entry, + header->Message( ), + iSmsTestUtils->iSmsServiceId ); + + entry.iDate.UniversalTime( ); + + const CSmsEmailFields& fields = header->EmailFields( ); + // Set the details fiels to the address field. + if ( !fields.HasAddress( ) ) + { + SetTestStepResult( EFail ); + } + TInt count = fields.Addresses( ).MdcaCount( ); + entry.iDetails.Set( fields.Addresses( ).MdcaPoint( 0 ).Left( KSmsDetailsLength ) ); + + // Set the description to either the subject or the begining part of the + // body text. + HBufC* desBuffer = HBufC::NewLC( iSmsClientMtm->ServiceSettings( ).DescriptionLength( ) ); + TPtr description( desBuffer->Des( ) ); + if( fields.Subject( ).Length( ) > 0 ) + { + // There is a subject - use this as the description + description.Copy( fields.Subject( ).Left( description.MaxLength( ) ) ); + + } + else + { + // No subject - use the begining part of the body text. + CSmsBufferBase& body = header->Message( ).Buffer( ); + TInt length = body.Length( ); + HBufC* buf = HBufC::NewLC( length ); + TPtr ptr( buf->Des( ) ); + body.Extract( ptr, 0, length ); + + description.Copy( ptr.Left( description.MaxLength( ) ) ); + CleanupStack::PopAndDestroy( buf ); + + } + entry.iDescription.Set( description ); + + // Create the entry in the inbox. + iSmsTestUtils->SetEntryL( KMsvGlobalInBoxIndexEntryId ); + iSmsTestUtils->CreateEntryL( entry ); + iServerSession->CleanupEntryPushL( entry.Id( ) ); + + // Store the header... + iSmsTestUtils->SetEntryL( entry.Id( ) ); + CMsvStore* store = iSmsTestUtils->EditStoreL( ); + CleanupStack::PushL( store ); + + header->StoreL( *store ); + + // Store the body text + store->StoreBodyTextL( *iSmsTestUtils->iRichText ); + store->CommitL( ); + + entry.iSize = store->SizeL( ); + entry.SetReadOnly( ETrue ); + iSmsTestUtils->ChangeEntryL( entry ); + + CleanupStack::PopAndDestroy( store ); + iServerSession->CleanupEntryPop( ); + CleanupStack::PopAndDestroy( 3, &fs ); // fs, header, desBuffer + + return entry.Id( ); + + } + +TMsvId CSMCMStepBase::CreateMessageAndEntryL( const TDesC& aUserData, TMessageSettings aSettings ) + { + TMsvEntry entry; + entry.iType = KUidMsvMessageEntry; + entry.SetSendingState( KMsvSendStateUnknown ); + entry.iDetails.Set( _L( "Alias" ) ); + entry.iBioType = aSettings.iOriginalBioType; + + iSmsTestUtils->iRichText->Reset( ); + iSmsTestUtils->iRichText->InsertL( 0, aUserData ); + + CSmsHeader* header = NULL; + if ( aSettings.iOperation == EOperationNone || aSettings.iOperation == EOperationReply ) + { + header = CSmsHeader::NewL( aSettings.iOriginalSmsPDUType, + *iSmsTestUtils->iRichText ); + } + else // EOperationForward + { + header = CSmsHeader::NewL( CSmsMessage::NewL( iSmsTestUtils->FileSession(), + aSettings.iOriginalSmsPDUType, + CSmsEditorBuffer::NewL( *iSmsTestUtils->iRichText ) ) ); + } + + + CleanupStack::PushL( header ); + + // Add formating and a picture + CEmsFormatIE* format = CEmsFormatIE::NewL( ); + CleanupStack::PushL( format ); + format->SetStartPosition(10); + format->SetFormatLength(10); + format->SetBold( ETrue ); + header->Message( ).AddEMSInformationElementL( *format ); + CleanupStack::PopAndDestroy( format ); + + CEmsPictureIE* pic = EmsTestUtils::CreatePictureL( 0 ); + CleanupStack::PushL( pic ); + pic->SetStartPosition( 0 ); + header->Message().AddEMSInformationElementL( *pic ); + CleanupStack::PopAndDestroy(pic); + + header->SetFromAddressL( KScriptItemRecipientsDef ); + header->Message().SetServiceCenterAddressL( KScriptItemSCDef ); + + TTime now; + now.UniversalTime( ); + + iSmsTestUtils->CreateMessageL( aSettings.iOriginalBoxId, + entry, + *header, + *iSmsTestUtils->iRichText, + now ); + entry.SetReadOnly( ETrue ); + + CleanupStack::PopAndDestroy( header ); + + return entry.Id( ); + + } + +// Creates a random string of lenth aLen (is used to generate a random body) +HBufC* CSMCMStepBase::CreateRandomLC( TInt aLen ) const + { + HBufC* msg = HBufC::NewLC( aLen ); + TPtr msgPtr( msg->Des( ) ); + msgPtr.SetLength( aLen ); + + TUint16* ptr = &msgPtr[ 0 ]; + while( --aLen ) + { + // Create a random character between ASCII code 65 and 128 + *ptr++ = TUint16( Math::Random( ) % ( 128 - 65 ) +65 ); + } + + return msg; + } + +TMsvId CSMCMStepBase::PerformForwardOrReplyOperationL( TMessageOperation aOperation, + TMsvId aInFolder ) + { + TMsvPartList part = 0; + CMsvOperationWait* wait = CMsvOperationWait::NewLC( ); + wait->Start( ); + + CMsvOperation* operation = NULL; + + switch( aOperation ) + { + case EOperationReply: + operation = iSmsClientMtm->ReplyL( aInFolder, part, wait->iStatus ); + break; + case EOperationForward: + operation = iSmsClientMtm->ForwardL( aInFolder, part, wait->iStatus ); + break; + default: + User::Leave( KErrNotSupported ); + break; + + } + + + CleanupStack::PushL( operation ); + + CActiveScheduler::Start( ); // Wait for operation to complete + + if ( wait->iStatus.Int() != KErrNone) + { + SetTestStepResult( EFail ); + + } + + // Extract the TMsvId new message created using the operation + TPckgBuf< TMsvId > pkg; + pkg.Copy( operation->ProgressL( ) ); + TMsvId messageId = pkg( ); + + // Cleanup + CleanupStack::PopAndDestroy( 2, wait ); // operation, wait + + return( messageId ); + + } + + +TVerdict CSMCMStepBase::PerformTestL( TMsvId aOriginalMessageId, + const TDesC& aNewText, + const TMessageSettings& aSettings ) + { + // Lets point at the message which we'll forward + iSmsClientMtm->SwitchCurrentEntryL( aOriginalMessageId ); + + TMsvId responseMessageId = PerformForwardOrReplyOperationL( aSettings.iOperation, KMsvDraftEntryId ); + + // Load the newly created FORWARD message + iSmsClientMtm->SwitchCurrentEntryL( responseMessageId ); + iSmsClientMtm->LoadMessageL( ); + + // Add new part of message + iSmsClientMtm->Body( ).InsertL( 0, aNewText ); + iSmsClientMtm->SaveMessageL( ); + + TVerdict result = CompareMessagesL( aOriginalMessageId, responseMessageId, aSettings ); + + return result; + } + + +TVerdict CSMCMStepBase::CompareMessagesL( TMsvId aOriginalMessageId, + TMsvId aTargetMessageId, + const TMessageSettings& aSettings ) + { + __ASSERT_ALWAYS( aOriginalMessageId != aTargetMessageId, User::Panic( SMSTEST_PANIC, KSmsTestUtilsPanicCannotCompareSameIds ) ); + + TVerdict result = EPass; + // Load the Original Message + iSmsClientMtm->SwitchCurrentEntryL( aOriginalMessageId ); + iSmsClientMtm->LoadMessageL( ); + + TMsvEntry originalEntry = iSmsClientMtm->Entry( ).Entry( ); + + const CSmsHeader& originalHeader = iSmsClientMtm->SmsHeader( ); + + // copy original body text & description in a buffer to be used later + CSmsEditorBuffer* origBuffer = CSmsEditorBuffer::NewL( iSmsClientMtm->Body( ) ); + TInt length = origBuffer->Length( ); + TBufC< KMaxBodyLength > originalMessage; + + TPtr origMsgPtr( originalMessage.Des( ) ); + origBuffer->Extract( origMsgPtr, 0, length ); + + TBufC< CSmsBufferBase::EMaxBufLength > originalDescription; + TPtr origDescPtr( originalDescription.Des( ) ); + origDescPtr.Copy( originalEntry.iDescription ); + + // Load the Target message + iSmsClientMtm->SwitchCurrentEntryL( aTargetMessageId ); + iSmsClientMtm->LoadMessageL( ); + + TMsvEntry targetEntry = iSmsClientMtm->Entry( ).Entry( ); + + const CSmsHeader& targetHeader = iSmsClientMtm->SmsHeader( ); + + // Compare UTC Time of original and target messages + if ( originalEntry.iDate >= targetEntry.iDate ) + { + result = EFail; + + } + + // Applicable to both Forward and Reply + TBool originalTextIncluded = EFalse; + TMsvPartList partList = KMsvMessagePartBody; + if ( iSmsClientMtm->Find( originalMessage.Des( ), partList ) == KMsvMessagePartBody ) + { + originalTextIncluded = ETrue; + + } + if ( !iSmsTestUtils->AreMessagesSameTextL( originalEntry.Id(), + targetEntry.Id(), + ETrue ) ) + { + result = EFail; + } + + if ( aSettings.iOperation == EOperationReply ) + { + // nothing extra to do for a reply + } + + if ( aSettings.iOperation == EOperationForward ) + { + TUint stateOrig = originalEntry.SendingState( ); + TUint statetarg = targetEntry.SendingState( ); + if ( ( originalEntry.SendingState( ) != targetEntry.SendingState( ) ) || + ( originalEntry.iBioType != targetEntry.iBioType ) || + ( originalDescription != targetEntry.iDescription) ) + { + result = EFail; + + } + if ( !originalTextIncluded ) + { + INFO_PRINTF1( _L( "Comparison Failed - Forward messages expect original text to be included" ) ); + result = EFail; + + } + } + + return result; + + } + +void CSMCMStepBase::SetSettingsL( ) + { + CSmsSettings* settings = CSmsSettings::NewLC( ); + + CSmsAccount* account = CSmsAccount::NewLC( ); + account->InitialiseDefaultSettingsL( *settings ); + + settings->AddServiceCenterL( KScriptItemSC1, KScriptItemSC1Def ); + settings->AddServiceCenterL( KScriptItemSC2, KScriptItemSC2Def ); + settings->AddServiceCenterL( KScriptItemSC3, KScriptItemSC3Def ); + settings->SetDefaultServiceCenter( 2 ); + + settings->SetValidityPeriod( ESmsVPWeek ); + settings->SetReplyQuoted( ETrue ); + settings->SetRejectDuplicate( ETrue ); + settings->SetDelivery( ESmsDeliveryImmediately ); + settings->SetDeliveryReport( ETrue ); + settings->SetReplyPath( EFalse ); + settings->SetMessageConversion( ESmsConvPIDNone ); + settings->SetCanConcatenate( ETrue ); + settings->SetCharacterSet( TSmsDataCodingScheme::ESmsAlphabet8Bit ); + settings->SetValidityPeriodFormat( TSmsFirstOctet::ESmsVPFSemiOctet ); + settings->SetStatusReportHandling( CSmsSettings::EMoveReportToInboxVisible ); + settings->SetSpecialMessageHandling( CSmsSettings::EMoveReportToInboxVisible ); + + account->SaveSettingsL( *settings ); + + iSmsTestUtils->iServiceSettings->CopyL( *settings); + + CleanupStack::PopAndDestroy( 2, settings ); + + } + +