diff -r 4697dfb2d7ad -r 238255e8b033 messagingappbase/smsmtm/test/src/T_SmsSendRecv.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/messagingappbase/smsmtm/test/src/T_SmsSendRecv.cpp Fri Apr 16 14:56:15 2010 +0300 @@ -0,0 +1,1205 @@ +// Copyright (c) 2000-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: +// GT Messaging Test Harness T_SmsSendRecv +// Test Harness: T_SmsSendRecv +// Component: SMS +// Owner: AA +// Brief Description: Sends and waits to receive SMS messages specified in sendrecv.script +// Detailed Description: As Above +// Input Files REQUIRED: +// :\msgtest\sms\defaults.script +// :\msgtest\sms\sendrecv.script +// Intermediate Files Produced: None +// Output files produced: :\msglogs\T_SmsSendRecv...log +// Building Instructions: +// cd \msg\smcm +// bldmake bldfiles +// abld test build +// Running Instructions: +// All Platforms: +// 1. Build T_DB test harness from COMMDB component: +// cd \commdb\group +// bldmake bldfiles +// abld test build t_db +// 2. Run T_DB and select the your modem (probably GSM Mobile Phone) +// 3. Build the test utilities: +// cd \msg\testutils\group\ +// bldmake bldfiles +// abld test build +// 4. Edit \epoc32\wins\c\msgtest\sms\defaults.script. Replace the telephone number ("Recipients") with your mobile's number. You may also need to change the service centre ("SC") number (the default is for Vodafone UK). +// WINS Only: +// 1. Run T_DB.exe (if it has not already been run) and select your modem (GSM mobile phone). +// 2. \epoc32\release\wins\\T_SmsSendRecv.exe can be used at the command prompt or executable can be run from Windows Explorer. +// Platform other than WINS: +// 1. Copy \epoc32\release\\\T_SmsSendRecv.exe onto the other platform (or onto the CF card) +// 2. Copy \epoc32\release\\\T_DB.exe onto the other platform (or onto the CF card) +// 3. Copy \epoc32\release\\\MsvTestUtils.DLL into :\system\libs on the other platform (or onto the CF card) +// 4. Copy \epoc32\release\\\SmsTestUtils.DLL into :\system\libs on the other platform (or onto the CF card) +// 5. Copy \epoc32\wins\c\msgtest\sms\sendrecv.script and defaults.script into :\msgtest\sms on the other platform (or onto the CF card) +// 6. Run T_DB.exe on the other platform (if it has not already been run) and select your modem (GSM mobile phone). +// 7. Run T_SmsSendRecv.exe on the other platform. +// +// + +#include "T_SmsSendRecv.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +RTest test(_L("T_SmsSendRecv Testrig")); +CTrapCleanup* theCleanup; + +const TInt KTestDescriptionLength = 15; + +LOCAL_C void doMainL() + { + CActiveScheduler* scheduler = new (ELeave) CActiveScheduler; + CleanupStack::PushL(scheduler); + CActiveScheduler::Install( scheduler ); + + CSmsTestUtils* smsTest = CSmsTestUtils::NewL(test); + CleanupStack::PushL(smsTest); + TInt nextTest = 0; + + smsTest->NotifySaPhoneOnL(); + + CSmsSendRecvTest* recvTest = CSmsSendRecvTest::NewLC(*smsTest, KSendRecvScript, nextTest); + + smsTest->WaitForInitializeL(); + + recvTest->StartL(); + + CleanupStack::PopAndDestroy(3); //SmsTest, scheduler + } + +GLDEF_C TInt E32Main() + { + __UHEAP_MARK; + test.Start(_L("Setup")); + theCleanup = CTrapCleanup::New(); + TRAPD(ret,doMainL()); + test(ret==KErrNone); + delete theCleanup; + test.Console()->SetPos(0, 13); + test.End(); + test.Close(); + __UHEAP_MARKEND; + return(KErrNone); + } + +CEntryObserver* CEntryObserver::NewL(CSmsTestUtils& aTestUtils, const TInt& aCurrentMessageNum) + { + CEntryObserver* self = new (ELeave) CEntryObserver(aTestUtils, aCurrentMessageNum); + CleanupStack::PushL(self); + self->iReceived = new (ELeave) CMsvEntrySelection(); + CleanupStack::Pop(self); + return self; + } + +CEntryObserver::CEntryObserver(CSmsTestUtils& aTestUtils, const TInt& aCurrentMessageNum) +: CBase(), iCurrentMessageNum(aCurrentMessageNum), iSmsTest(aTestUtils) + { + } + + +CEntryObserver::~CEntryObserver() +/** + destructor + */ + { + delete iReceived; + } + +void CEntryObserver::CheckReceivedMessageL(TMsvId aId) +/** + Checks received message + + @param aId A message Id + */ + { + // Restore SMS settings + iSmsTest.SetEntryL(iSmsTest.iSmsServiceId); + + CSmsAccount* account = CSmsAccount::NewLC(); + account->LoadSettingsL(*iSmsTest.iServiceSettings); + CleanupStack::PopAndDestroy(account); + + iSmsTest.Printf(_L("Check last received message...\n")); + + iSmsTest.DisplayMessageL(aId); + iSmsTest.SetEntryL(aId); + + CSmsHeader* header = iSmsTest.GetHeaderLC(aId); + + if (header->Type() == CSmsPDU::ESmsDeliver) + { + CSmsDeliver& pdu = header->Deliver(); + + TBool found = EFalse; + TInt destination, originator, is16Bit; + destination = originator = is16Bit = 0; + if (pdu.UserDataPresent()) + { + const CSmsUserData& userData = pdu.UserData(); + TInt count = userData.NumInformationElements(); + iSmsTest.Printf(_L("\tPdu contains %d information elements\n"), count); + while (!found && count--) + { + CSmsInformationElement& nextIE=userData.InformationElement(count); + switch(nextIE.Identifier()) + { + case CSmsInformationElement::ESmsIEIApplicationPortAddressing8Bit: + case CSmsInformationElement::ESmsIEIApplicationPortAddressing16Bit: + { + pdu.ApplicationPortAddressing(destination, originator, &is16Bit); + found = ETrue; + break; + } + default: + break; + } + } + } + else + iSmsTest.Printf(_L("\tPdu contains NO user data header\n")); + + if (found) + iSmsTest.Printf(_L("\tApplication Port Addressing: Dest %d, Origin %d, is16Bit %d\n"), destination, originator, is16Bit); + else + iSmsTest.Printf(_L("\tApplication Port Addressing: Not Found\n")); + } + + //Check the description + const TMsvEntry& entry = iSmsTest.Entry(); + + if (entry.iBioType == 0) + { + //Test description + TInt descriptionLength = iSmsTest.iServiceSettings->DescriptionLength(); + HBufC* buf = HBufC::NewLC(descriptionLength); + TPtr desc = buf->Des(); + User::LeaveIfError(TSmsUtilities::GetDescription(header->Message(), desc, descriptionLength)); + + iSmsTest.Printf(_L("\tiDescription=\"%S\" desc=\"%S\"\n"), &entry.iDescription, &desc); + iSmsTest(desc.CompareF(entry.iDescription) == 0); + + if (header->Type() == CSmsPDU::ESmsStatusReport) + { + iSmsTest.ReadResourceStringL(KSmsResourceFile, R_TYPE_STATUS_REPORT, desc); + iSmsTest.Printf(_L("\tiDescription=\"%S\" Res=\"%S\"\n"), &entry.iDescription, &desc); + iSmsTest(desc.CompareF(entry.iDescription) == 0); + } + CleanupStack::PopAndDestroy(buf); + } + + + CleanupStack::PopAndDestroy(header); + } + + +void CEntryObserver::HandleEntryEventL(TMsvEntryEvent aEvent, TAny* aArg1, TAny* /*aArg2*/, TAny* /*aArg3*/) +/** + Handles entry event, used by MMsvEntryObserver + + @param aEvent Msv entry event + @param aArg1 Argument 1 + @param aArg2 Argument 2 + @param aArg3 Argument 3 + */ + { + if (aEvent == EMsvNewChildren && iCurrentMessageNum > -1) + { + CMsvEntrySelection* msgs = (CMsvEntrySelection*)aArg1; + + TInt count = msgs->Count(); + + TInt msgRecv = 0; + + while (count--) + { + TMsvId id = (*msgs)[count]; + + CheckReceivedMessageL(id); + CSmsHeader* header = iSmsTest.GetHeaderLC(id); + + if (header->Type() == CSmsPDU::ESmsDeliver) + { + iReceived->AppendL(id); + msgRecv++; + } + + CleanupStack::PopAndDestroy(header); + } + + if (msgRecv) + iSmsTest.Printf(_L("%d Messages Received in inbox\n"), msgRecv); + } + } + +CSmsSendRecvTest::~CSmsSendRecvTest() +/** + destructor + */ + { + delete iEntryObserver; + delete iEntryForObserver; + delete iWatchers; + + iSocket.Close(); + iSocketServ.Close(); + } + +TBool CSmsSendRecvTest::WatchersAlreadyRunningL() +/** + Checks if the watchers are already running + */ + { + RSocketServ server; + RSocket socket; + + User::LeaveIfError(server.Connect()); + CleanupClosePushL(server); + + // test if it's there... + TProtocolDesc protoInfo; + TProtocolName protocolname; + protocolname.Copy(KSmsDatagram); + User::LeaveIfError(server.FindProtocol(protocolname,protoInfo)); + + User::LeaveIfError(socket.Open(server, + protoInfo.iAddrFamily, + protoInfo.iSockType, + protoInfo.iProtocol)); + CleanupClosePushL(socket); + + TSmsAddr addr; + addr.SetSmsAddrFamily(ESmsAddrRecvAny); + TInt err = socket.Bind(addr); + + CleanupStack::Pop(2); //server, socket + socket.CancelAll(); + socket.Close(); +// server.Close(); + return (err == KErrAlreadyExists); + } + +void CSmsSendRecvTest::StartWatcherL() +/** + Starts the watcher if it is not running + */ + { + iSmsTest.Test().Next(_L("Start the Watcher")); + + if (WatchersAlreadyRunningL()) + { + iSmsTest.Printf(_L("Watchers are already running\n")); + return; + } + + iWatchers = CTestUtilsWatcherStarter::NewL(); + + TTimeIntervalMicroSeconds32 wait = KWaitForWatchersToStart; + while (wait.Int() > 0) + { + iSmsTest.Printf(_L("Waiting %d secs for watchers to start...\n"), wait.Int() / 1000000); + wait = wait.Int() - KWaitForWatchersToStartDisplayInterval.Int(); + User::After(KWaitForWatchersToStartDisplayInterval); + } + } + +CSmsSendRecvTest* CSmsSendRecvTest::NewLC(CSmsTestUtils& aSmsTest, const TDesC& aScriptFile, TInt& aNextTest) + { + CSmsSendRecvTest* self = new (ELeave) CSmsSendRecvTest(aSmsTest, aScriptFile, aNextTest); + CleanupStack::PushL(self); + self->ConstructL(); + return self; + } + + +void CSmsSendRecvTest::TestSendingL() +/** + Tests sending: Creates messages as defined in the script file + */ + { + iSmsTest.Test().Next(_L("Sending")); + + TTime now; + now.HomeTime(); + now += (TTimeIntervalSeconds) 5; + + iSelection->Reset(); + + iSmsTest.DeleteSmsMessagesL(KMsvGlobalOutBoxIndexEntryId); + + TBool read = EFalse; + iSmsTest.Printf(_L("Creating msgs in outbox from script: %S\n"), &iScriptFile); + TRAPD(err, read = iSmsTest.ReadScriptL(iScriptFile, KMsvGlobalOutBoxIndexEntryId, *iSelection, now)); + + iSmsTest.Test()(!err && read); + + iSmsTest.Printf(_L("Send and Receive %d messages...\n"), iSelection->Count()); + + TInt count = iSelection->Count(); + iTotal = 0; + iSent = 0; + while (count--) + { + iTotal += CountRecipientsL(iSelection->At(count)); + } + + iCurrentMessageNum = -1; + } + +TInt CSmsSendRecvTest::CountRecipientsL(TMsvId aId) +/** + Counts the number receipients in aId + + @param aId A message Id + */ + { + CSmsHeader* header = iSmsTest.GetHeaderLC(aId); + const TInt count = header->Recipients().Count(); + CleanupStack::PopAndDestroy(header); + return count; + } + +TBool CSmsSendRecvTest::SendNextMessageL() +/** + Sends the next message + */ + { + iCurrentMessageNum++; + const TInt count = iSelection->Count(); + + if (iCurrentMessageNum < count) + { + iSmsTest.Printf(_L("Sending message %d of %d\n"), iCurrentMessageNum + 1, count); + + delete iOperation; + iOperation = NULL; + + CMsvEntrySelection* sel = new (ELeave) CMsvEntrySelection(); + CleanupStack::PushL(sel); + const TMsvId id = iSelection->At(iCurrentMessageNum); + + TInt replace_msg_one_index = GetIndexOfSectionL(_L("ReplaceTypeSMSOne")); + TInt replace_msg_two_index = GetIndexOfSectionL(_L("ReplaceTypeSMSTwo")); + TInt msg_indication_index = GetIndexOfSectionL(_L("SMSMessageIndication")); + + TInt vCalendar_index = GetIndexOfSectionL(_L("WAP:vCalendar")); + // storing the id of vCalender message , to use it to test for replying bio messages + if(vCalendar_index != KErrNotFound && vCalendar_index == (iCurrentMessageNum+1)) + iMsgVCalenderIndex = iCurrentMessageNum; + + if(replace_msg_one_index != KErrNotFound && replace_msg_one_index == (iCurrentMessageNum+1)) + SendReplaceTypeMessageL(); + + if(replace_msg_two_index != KErrNotFound && replace_msg_two_index == (iCurrentMessageNum+1)) + { + SendReplaceTypeMessageL(); + iSmsTest.Printf(_L("This Message replaces previous Replace Type Message")); + } + + if(msg_indication_index != KErrNotFound && msg_indication_index == (iCurrentMessageNum+1)) + SendMessageIndicationL(); + + iSmsTest.DisplayMessageL(id); + sel->AppendL(id); + iSent += CountRecipientsL(id); + iSmsTest.SetEntryL(KMsvGlobalOutBoxIndexEntryId); + iOperation = MsvEntry().CopyL(*sel, iSmsTest.iSmsServiceId, iStatus); + CleanupStack::PopAndDestroy(); //sel + + iState = EStateSending; + SetActive(); + CActiveScheduler::Start(); + return ETrue; + } + + return EFalse; + } + +TInt CSmsSendRecvTest::GetIndexOfSectionL(const TDesC& aSectionName) +/** + * Returns back the index of the section + */ + { + CScriptFile* script = CScriptFile::NewLC(iSmsTest, KSmsComponent); + script->ReadScriptL(KSendRecvScript); + + TInt index = KErrNotFound; + TInt count = iSelection->Count(); + + for (TInt i = 0; i <= count; i++) //order important + { + CScriptSection& tempsection = *script->Sections()[i]; + if (tempsection.SectionName().CompareF(aSectionName) == 0) + index = i; + } + + CleanupStack::PopAndDestroy(script); + + return index; + } + +void CSmsSendRecvTest::SendReplaceTypeMessageL() +/** + * Handles the replace type sms messages in sendrecv.script + */ + { + iSmsTest.Printf(_L("\nSend Replace Type Message\n")); + const TMsvId id = iSelection->At(iCurrentMessageNum); + CSmsHeader* header = iSmsTest.GetHeaderLC(id); + CSmsSubmit& submit = header->Submit(); + submit.SetPIDType(TSmsProtocolIdentifier::ESmsPIDShortMessageType); + submit.SetShortMessageType(TSmsProtocolIdentifier::ESmsReplaceShortMessageType1); + StoreMessageL(id, *header); + CleanupStack::PopAndDestroy(header); + } + +void CSmsSendRecvTest::SendMessageIndicationL(TUint8 aMessageType, TUint8 aMessageCount) +/** + * Sends an SMS message with Special SMS Message Indication set in the user data header. + * + * @param aMessageType The type of the Special SMS Message Indication + * @param aMessageCount The number of "messages" waiting + */ + { + iSmsTest.Printf(_L("\nSendMessageIndicationL\n")); + const TMsvId id = iSelection->At(iCurrentMessageNum); + CSmsHeader* header = iSmsTest.GetHeaderLC(id); + TBuf8<2> data; + data.SetLength(2); + + data[0] = aMessageType; + data[1] = aMessageCount; + + header->Submit().UserData().AddInformationElementL(CSmsInformationElement::ESmsIEISpecialSMSMessageIndication, data); + StoreMessageL(id, *header); + CleanupStack::PopAndDestroy(header); + } + +void CSmsSendRecvTest::StoreMessageL(TMsvId aId, const CSmsHeader& aHeader) +/** + * Stores the header against a message + * + * @param aId ID of the message + * @param aHeader The CSmsHeader to store against the message + */ + { + iSmsTest.SetEntryL(aId); + CMsvStore* store = iSmsTest.EditStoreL(); + CleanupStack::PushL(store); + aHeader.StoreL(*store); + store->StoreBodyTextL(*iSmsTest.iRichText); + store->CommitL(); + CleanupStack::PopAndDestroy(store); + } + +void CSmsSendRecvTest::TestWaitForReceiveL() +/** + Waits to receive message + */ + { + iSmsTest.Test().Next(_L("Waiting to receive message")); + iState = EStateWaitingToReceive; + TRequestStatus* status = &iStatus; + User::RequestComplete(status, KErrNone); + SetActive(); + } + +CSmsSendRecvTest::CSmsSendRecvTest(CSmsTestUtils& aSmsTest, const TDesC& aScriptFile, TInt& aNextTest) +: CSmsTestBase(aSmsTest, aScriptFile, aNextTest), iCurrentMessageNum(-1), iState(EStateWaiting) +/** + Constructor + */ + { + TBuf<256> command; + User::CommandLine(command); + + command.Trim(); + iParse = (command.FindF(KParseAfterReceive) != KErrNotFound); + iSaveToFile = (command.FindF(KSaveAfterReceive) != KErrNotFound); + iTestBifs = (command.FindF(KTestBifs) != KErrNotFound); + iWaitForever = (command.FindF(KWaitForever) != KErrNotFound); + + iMsgVCalenderIndex = KErrNotFound; + // check to see if we want to run EMS tests + if (command.FindF(KRunEmsTests) != KErrNotFound) + { + iScriptFile = KSendRecvEmsScript; + } + } + +void CSmsSendRecvTest::RunAutoL() +/** + Runs tests in sequence, checks iStatus + */ + { + iSmsTest.TestStart(++iNextTest, _L("Start Watcher")); + StartWatcherL(); + User::LeaveIfError(iStatus.Int()); + iSmsTest.TestFinish(iNextTest, KErrNone); + + if (!WatchersAlreadyRunningL()) + { + iSmsTest.Printf(_L("WARNING: NBS Watcher has not started yet\n")); + } + + if (!iSmsTest.iSmokeTest && iTestBifs) + { + iSmsTest.TestStart(++iNextTest, _L("Add Remove Bifs")); + TestBifsL(); + User::LeaveIfError(iStatus.Int()); + iSmsTest.TestFinish(iNextTest, KErrNone); + } + + if (!WatchersAlreadyRunningL()) + { + iSmsTest.Printf(_L("WARNING: NBS Watcher has not started yet\n")); + } + + // Change the description length to be shorter then the default - actual + // value is not important only that it is different to the default of + // KSmsDescriptionLength (32). + + iSmsTest.Printf(_L("\nChanging the description length to %d\n"), KTestDescriptionLength); + + // Restore settings first... + CSmsAccount* account = CSmsAccount::NewLC(); + account->LoadSettingsL(*iSmsTest.iServiceSettings); + + // Set the description length to 1 + iSmsTest.iServiceSettings->SetDescriptionLength(KTestDescriptionLength); + + // Store the sms settings + account->SaveSettingsL(*iSmsTest.iServiceSettings); + CleanupStack::PopAndDestroy(account); + + // Ok, now start real tests... + + iSmsTest.TestStart(++iNextTest, _L("Read Script")); + TestSendingL(); + User::LeaveIfError(iStatus.Int()); + iSmsTest.TestFinish(iNextTest, KErrNone); + + FOREVER + { + iSmsTest.TestStart(++iNextTest, _L("Send Message")); + TBool sendNext = SendNextMessageL(); + if (sendNext) + { + User::LeaveIfError(iStatus.Int()); + iSmsTest.TestFinish(iNextTest, KErrNone); + } + else + { + iSmsTest.Printf(_L("No more messages to send!")); + iSmsTest.TestFinish(iNextTest, KErrNone); + // Testing Reply to Bio-Messages + TestReplyL(); + break; + } + } + + iSmsTest.TestStart(++iNextTest, _L("Wait to receive extra message(s)")); + WaitForExtraL(); + User::LeaveIfError(iStatus.Int()); + iSmsTest.TestFinish(iNextTest, KErrNone); + iSmsTest.Printf(_L("\nDisplay Final Log:\n")); + DisplayLogL(); + } + +void CSmsSendRecvTest::SetSmsSettingsL() + { + MsvEntry().SetEntryL(iSmsTest.iSmsServiceId); + +// Lets create sms settings to set it for reply + CSmsSettings* settings = CSmsSettings::NewL(); + CleanupStack::PushL(settings); + + settings->SetReplyQuoted(ETrue); + + CSmsAccount* account = CSmsAccount::NewLC(); + account->SaveSettingsL(*settings); + CleanupStack::PopAndDestroy(account); + + iSmsTest.iServiceSettings->CopyL(*settings); + CleanupStack::PopAndDestroy(); //settings + } + +// Now testing replying to received messages +void CSmsSendRecvTest::TestReplyL() + { + // Test cannot be performed as no vCalender message received in the inbox + if(iMsgVCalenderIndex == KErrNotFound) + return; + + iSmsTest.TestStart(++iNextTest, _L("CSmsClientMtm Reply")); + iSmsTest.Printf(_L("This test is to test Reply for bio-messages(vCalender)\n")); + + SetSmsSettingsL(); + + iSmsTest.InstantiateClientMtmsL(); + + const TMsvId id = iEntryObserver->ItemReceived(iMsgVCalenderIndex); + + if(id == KErrNotFound) + { + iSmsTest.TestFinish(iNextTest, KErrNotFound); + return; + } + iSmsTest.SetEntryL(id); + + Client().SwitchCurrentEntryL(id); // Lets point at the received message + Client().LoadMessageL(); + iSmsTest.Printf(_L("Display vCalender Message\n")); + iSmsTest.DisplayMessageL(id); + + TMsvPartList part=0; + CMsvOperationWait* wait = CMsvOperationWait::NewLC(); + // Replying the vCalender message + CMsvOperation* op=Client().ReplyL(KMsvDraftEntryId, part, wait->iStatus); + CleanupStack::PushL(op); + wait->Start(); + CActiveScheduler::Start(); + + TPckgBuf pkg; + pkg.Copy(op->ProgressL()); + TMsvId progress = pkg(); + + CleanupStack::PopAndDestroy(2); //op, wait + + CSmsHeader* header = iSmsTest.GetHeaderLC(progress); + + // extract the replying message + iSmsTest.SetEntryL(progress); + CMsvStore* store = iSmsTest.ReadStoreL(); + CleanupStack::PushL(store); + header->RestoreL(*store); + CleanupStack::PopAndDestroy(); //store + + const CSmsBufferBase& buffer = header->Message().Buffer(); + + // let's check to see if the reply message has any body in it + TInt bufLen=buffer.Length(); + CleanupStack::PopAndDestroy(); //header + + if (bufLen) + { + iSmsTest.Printf(_L("vCalender Reply Message having junk data\n")); + iSmsTest.TestFinish(iNextTest, KErrNotFound); + } + else + { + iSmsTest.Printf(_L("vCalender Reply Message is a Empty SMS message\n")); + Client().SwitchCurrentEntryL(progress); + Client().LoadMessageL(); + Client().Body().InsertL(0,_L("This is reply")); + Client().SaveMessageL(); + iSmsTest.TestFinish(iNextTest, KErrNone); + } + } + + +void CSmsSendRecvTest::ConstructL() + { + SetTestNameL(KSmsSendRecvTestName); + iSmsTest.SetLogToFile(); + + TBuf<256> command; + User::CommandLine(command); + + command.Trim(); + iSmsTest.Printf(_L("Command Line: \"%S\" (Parse %d, Save %d, Wait %d, Bifs %d)\n"), &command, iParse, iSaveToFile, iWaitForever, iTestBifs); + + iSelection = new (ELeave) CMsvEntrySelection(); + iTimer = CTestTimer::NewL(); + CActiveScheduler::Add(this); + + iSmsTest.SetCommDbServiceCenterFromScriptL(iScriptFile); + + iEntryObserver = CEntryObserver::NewL(iSmsTest, iCurrentMessageNum); + + iEntryForObserver = Session().GetEntryL(KMsvGlobalInBoxIndexEntryId); + iEntryForObserver->AddObserverL(*iEntryObserver); + + ClearLogL(); + + User::LeaveIfError(iSocketServ.Connect()); + TProtocolDesc protoinfo; + TProtocolName protocolname(KSmsDatagram); + User::LeaveIfError(iSocketServ.FindProtocol(protocolname,protoinfo)); + User::LeaveIfError(iSocket.Open(iSocketServ,protoinfo.iAddrFamily,protoinfo.iSockType,protoinfo.iProtocol)); + + TSmsAddr smsaddr; + smsaddr.SetSmsAddrFamily(ESmsAddrSendOnly); + User::LeaveIfError(iSocket.Bind(smsaddr)); + } + +void CSmsSendRecvTest::ShowMenuL() + { + iSmsTest.ResetMenu(); + + iSmsTest.AppendToMenuL(_L("Start")); + iSmsTest.AppendToMenuL(_L("Display Log")); + iSmsTest.AppendToMenuL(_L("Clear Log")); + iSmsTest.AppendToMenuL(_L("Navigate Message Store")); + + TInt result = iSmsTest.DisplayMenu(_L("SMS Send Receive Test")); + + if (result <= 0) + return; + + switch (result) + { + case 1: + RunAutoL(); + return; + case 2: + DisplayLogL(); + break; + case 3: + ClearLogL(); + break; + case 4: + iSmsTest.NavigateMessageStoreL(); + break; + default: + User::Leave(KErrArgument); + break; + } + + ShowMenuL(); + } + +void CSmsSendRecvTest::RunComplete() + { + if (!IsActive()) + CActiveScheduler::Stop(); + } + +void CSmsSendRecvTest::RunL() +/** + Handles completed async operations + */ + { + switch (iState) + { + case EStateSending: + { + DoRunSendingL(); + delete iOperation; + iOperation = NULL; + break; + } + case EStateWaitingToReceive: + { + DoRunWaitingToReceiveL(); + break; + } + case EStateWaitingToReceiveAnyExtra: + { + DoRunWaitForExtraL(); + break; + } + case EStateMessageReceived: + { + TestParseL(); + break; + } + case EStateParsing: + { + DoRunTestParseL(); + break; + } + default: + { + break; + } + } + + RunComplete(); + } + +TInt CSmsSendRecvTest::RunError(TInt aError) + { + aError = CSmsTestBase::RunError(aError); + RunComplete(); + return aError; + } + +void CSmsSendRecvTest::DoRunTestParseL() +/** + Checks status + */ + { + TBioProgress progress; + TBioProgressBuf progressBuf; + progressBuf.Copy(iOperation->ProgressL()); + progress = progressBuf(); + + if (iStatus == KErrNone) + iStatus = progress.iErrorCode; + + delete iOperation; + iOperation = NULL; + } + +void CSmsSendRecvTest::TestParseL() +/** + Parses BIO messages + */ + { + const TMsvId id = iEntryObserver->LastReceived(); + + iSmsTest.SetEntryL(id); + + if (iSaveToFile) + { + iSmsTest.Printf(_L("\tSaving BIO message to file\n")); + iSmsTest.SaveBodyToFileL(id); + } + + if (!iParse) + return; + + if (!iSmsTest.Entry().iBioType) + return; + + iState = EStateParsing; + + iSmsTest.Printf(_L("Parsing BIO message\n")); + + CMsvEntrySelection* sel = new (ELeave) CMsvEntrySelection(); + CleanupStack::PushL(sel); + + sel->AppendL(id); + + delete iOperation; + iOperation = NULL; + + iOperation = Session().TransferCommandL(*sel, KBiosMtmParse, KNullDesC8, iStatus); + SetActive(); + + CleanupStack::PopAndDestroy(sel); + } + +void CSmsSendRecvTest::DoCancel() + { + if (iOperation) + { + iOperation->Cancel(); + iSmsTest.Printf(_L("Operation Cancelled!\n")); + } + delete iOperation; + iOperation = NULL; + } + +void CSmsSendRecvTest::DoRunSendingL() +/** + Checks the status and displays the sending states + */ + { + if (iOperation) + iSmsTest.SetProgressL(*iOperation); + + TInt count = iSelection->Count(); + TBool wait = EFalse; + + while (iStatus == KErrNone && count--) + { + TRAPD(err, iSmsTest.SetEntryL(iSelection->At(count))); + + if (err == KErrNone) + { + TMsvEntry entry = MsvEntry().Entry(); + iSmsTest.SetEntryL(KMsvGlobalOutBoxIndexEntryId); + + TBuf<0x100> output; + TBuf<0x50> nowBuf; + + switch (entry.SendingState()) + { + case KMsvSendStateSending: + output.AppendFormat(_L("Message %d Sending with error %d\n"), entry.Id(), entry.iError); + wait = ETrue; + break; + case KMsvSendStateResend: + output.AppendFormat(_L("Message %d Resend with error %d at "), entry.Id(), entry.iError); + entry.iDate.FormatL(nowBuf, _L("%-B%:0%J%:1%T%:2%S%:3%+B")); + output.Append(nowBuf); + output.Append(_L("\n")); + wait = ETrue; + break; + case KMsvSendStateScheduled: + output.AppendFormat(_L("Message %d Scheduled at "), entry.Id()); entry.iDate.FormatL(nowBuf, _L("%-B%:0%J%:1%T%:2%S%:3%+B")); + entry.iDate.FormatL(nowBuf, _L("%-B%:0%J%:1%T%:2%S%:3%+B")); + output.Append(nowBuf); + output.Append(_L("\n")); + wait = ETrue; + break; + case KMsvSendStateFailed: + output.AppendFormat(_L("Message %d Failed with error %d\n"), entry.Id(), entry.iError); + if (entry.iError) + iStatus = entry.iError; + else + iStatus = KErrGeneral; + + break; + case KMsvSendStateWaiting: + output.AppendFormat(_L("Message %d Waiting with error %d\n"), entry.Id(), entry.iError); + wait = ETrue; + break; + case KMsvSendStateSent: + default: + break; + //nothing + } + + iSmsTest.Printf(output); + } + } + + if (wait) + { + iTimer->AfterReq(10000000, iStatus); + SetActive(); + iState = EStateSending; +// CActiveScheduler::Start(); + } + else + { + iSmsTest.Printf(_L("Sending completed with %d\n"), iStatus); + + if (iStatus == KErrNone) + { + TestWaitForReceiveL(); + } + else + { + iState = EStateWaiting; + } + } + } + +void CSmsSendRecvTest::WaitForExtraL() +/** + Waits for any extra messages to arrive + */ + { + iSmsTest.Printf(_L("Waiting for any extra to arrive...\n")); + iWaitForever = EFalse; + iCountWaits = 0; + iState = EStateWaitingToReceiveAnyExtra; + TRequestStatus* status = &iStatus; + User::RequestComplete(status, KErrNone); + SetActive(); + CActiveScheduler::Start(); + } + +void CSmsSendRecvTest::DoRunWaitForExtraL() +/** + Checks if it has received all messages sent + */ + { + iCountWaits++; + + TInt recvCount = iEntryObserver->Count(); + + if (recvCount > iSent) + { + iSmsTest.Printf(_L("Too many messages received:\nSent %d Rcvd %d\n"), iSent, recvCount); + iStatus = KErrOverflow; + } + else + DoWaitL(); + } + +void CSmsSendRecvTest::DoRunWaitingToReceiveL() +/** + Checks if it has received all messages sent + */ + { + iCountWaits++; + + const TInt recvCount = iEntryObserver->Count(); + + if (recvCount == iSent) + { + //Message received + if (!iSmsTest.AreMessagesSameTextL((*iSelection)[iCurrentMessageNum], iEntryObserver->Received(iSent - 1), ETrue)) + { + //Do something? + } + } + + if (recvCount > iSent) + { + iSmsTest.Printf(_L("Too many messages received:\nSent %d Rcvd %d\n"), iSent, recvCount); + iStatus = KErrOverflow; + } + else + { + if (iTotal == recvCount || recvCount == iSent) + { + if (iTotal == recvCount) + iSmsTest.Printf(_L("All Messages Received!!\n")); + + //Message received + iState = EStateMessageReceived; + iCountWaits = 0; + TRequestStatus* status = &iStatus; + User::RequestComplete(status, KErrNone); + SetActive(); + } + else + { + DoWaitL(); + } + } + } + +void CSmsSendRecvTest::DoWaitL() +/** + Waits to receive the messages sent + */ + { + TInt recvCount = iEntryObserver->Count(); + + TInt maxCount = KMaxWaitForMsg.Int() / KWaitForReceiveIteration.Int(); + TInt waitSecs = KWaitForReceiveIteration.Int() * (maxCount - iCountWaits) / 1000000; + + if (iWaitForever && iCountWaits <= 1) + { + iSmsTest.Printf(_L("Waiting forever to recv msg\n")); + } + else if (!iWaitForever) + { + iSmsTest.Printf(_L("Waiting %d secs to recv msg\n"), waitSecs); + } + + if (iWaitForever || iCountWaits < maxCount) + { + iTimer->AfterReq(KWaitForReceiveIteration, iStatus); + SetActive(); + } + else + { + if (iSent != recvCount) + { + iSmsTest.Printf(_L("Time Out: Message NOT Received\n")); + iStatus = KErrTimedOut; + } + } + } + +void CSmsSendRecvTest::TestBifsL() +/** + todo Comments + */ + { + iSmsTest.Printf(_L("Remove 2 Bifs if already exist\n")); + TestRemoveBifL(KTestBif1); + TestRemoveBifL(KTestBif2); + + //Test add bif + iSmsTest.Printf(_L("Test Add 2 Bifs\n")); + TestAddBifL(KTestBif1); + TestAddBifL(KTestBif2); + + //Test remove bif + iSmsTest.Printf(_L("Test Remove 2 Bifs\n")); + TestRemoveBifL(KTestBif1); + TestRemoveBifL(KTestBif2); + + //Test change bif + iSmsTest.Printf(_L("Test Change 2 Bifs\n")); + TestAddBifL(KTestBif1); + TestAddBifL(KTestBif2); + TestAddBifL(KTestBif1); + TestAddBifL(KTestBif2); + + //Test remove bif + iSmsTest.Printf(_L("Test Remove 2 Bifs\n")); + TestRemoveBifL(KTestBif1); + TestRemoveBifL(KTestBif2); + } + +void CSmsSendRecvTest::TestAddBifL(const TDesC& aBifName) +/** + Comments + */ + { + iSmsTest.Printf(_L("\tAdd BIF: %S\n"), &aBifName); + + RFs& fs = iSmsTest.FileSession(); + TInt err = fs.MkDir(KBifDir); + + if (err != KErrAlreadyExists) + User::LeaveIfError(err); + + TParse fileOut; + err = iSmsTest.ResolveFile(KSmsComponent, aBifName, fileOut); + + if (err) + { + iSmsTest.Printf(_L("Test BIF %S not found! Continuing without this test\n"), &aBifName); + return; + } + + CFileMan* fileMan = CFileMan::NewL(fs); + CleanupStack::PushL(fileMan); + + err = fileMan->Copy(fileOut.FullName(), KBifDir); + + if (err != KErrAlreadyExists) + User::LeaveIfError(err); + + CleanupStack::PopAndDestroy(fileMan); + + User::After(KBifWait); + } + +void CSmsSendRecvTest::TestRemoveBifL(const TDesC& aBifName) +/** + todo Comments + */ + { + iSmsTest.Printf(_L("\tRemove Bif: %S\n"), &aBifName); + + RFs& fs = iSmsTest.FileSession(); + TFileName fileName(KBifDir); + fileName.Append(aBifName); + + TInt err = fs.Delete(fileName); + + if (err) + { + iSmsTest.Printf(_L("\t\tfs.Delete() returned %d\n"), err); + + if (err != KErrNotFound && err != KErrPathNotFound) + User::Leave(err); + } + + User::After(KBifWait); + } +