diff -r 000000000000 -r 72b543305e3a mobilemessaging/smsmtm/test/src/T_SmsCancel.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mobilemessaging/smsmtm/test/src/T_SmsCancel.cpp Thu Dec 17 08:44:11 2009 +0200 @@ -0,0 +1,385 @@ +// Copyright (c) 1999-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 +#include +#include +#include +#include +#include "T_SmsCancel.h" + +#define KSmsScript _L("sms.script") + +CSmsCancelTest::~CSmsCancelTest() + { + if (iSmsTest.iMsvSession) + { + iSmsTest.iMsvSession->RemoveObserver(*this); + } + iSocket.Close(); + iSocketServ.Close(); + } + +CSmsCancelTest::CSmsCancelTest(CSmsTestUtils& aSmsTest, const TDesC& aScriptFile, TInt& aCurrentTest) +: CSmsTestBase(aSmsTest, aScriptFile, aCurrentTest), iState(EStateWaiting) + { + } + +void CSmsCancelTest::RunAutoL() + { + + iSmsTest.TestStart(++iNextTest, _L("Cancel Sending")); + TestCancelSendingL(); + User::LeaveIfError(iStatus.Int()); + iSmsTest.TestFinish(iNextTest, KErrNone); + + iSmsTest.TestStart(++iNextTest, _L("Cancel Sending after Scheduling")); + TestCancelSendingAfterScheduleL(); + User::LeaveIfError(iStatus.Int()); + iSmsTest.TestFinish(iNextTest, KErrNone); + + iSmsTest.TestStart(++iNextTest); + TestCancelReadScL(); + User::LeaveIfError(iStatus.Int()); + iSmsTest.TestFinish(iNextTest, KErrNone); + + iSmsTest.TestStart(++iNextTest); + TestCancelWriteScL(); + User::LeaveIfError(iStatus.Int()); + iSmsTest.TestFinish(iNextTest, KErrNone); + + iSmsTest.TestStart(++iNextTest); + TestCancelReadSimParamsL(); + User::LeaveIfError(iStatus.Int()); + iSmsTest.TestFinish(iNextTest, KErrNone); + + iSmsTest.TestStart(++iNextTest); + TestCancelEnumerateL(); + User::LeaveIfError(iStatus.Int()); + iSmsTest.TestFinish(iNextTest, KErrNone); + } + +void CSmsCancelTest::ConstructL() + { + iSmsTest.SetLogToFile(); + + iSelection = new (ELeave) CMsvEntrySelection(); + + iSmsTest.iMsvSession->AddObserverL(*this); + + CActiveScheduler::Add(this); + + 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 CSmsCancelTest::HandleSessionEventL(TMsvSessionEvent aEvent, TAny* aArg1, TAny* /*aArg2*/, TAny* /*aArg3*/) + { + CMsvEntrySelection* entries = NULL; + + switch (aEvent) + { + case EMsvEntriesCreated: + case EMsvEntriesChanged: + case EMsvEntriesMoved: + entries = STATIC_CAST(CMsvEntrySelection*, aArg1); + break; + default: + return; + } + + if (!IsActive()) + return; + + switch (iState) + { + case EStateSending: + { + iSmsTest.DisplaySendingStatesL(*entries); + CancelIfSendingL(*entries); + + TInt error = KErrNone; + + if (iSmsTest.SendingCompleteL(*iSelection, error) && !iOperation && iStatus == KRequestPending) + { + TRequestStatus* status = &iStatus; + User::RequestComplete(status, error); + } + break; + } + default: + break; + } + } + +void CSmsCancelTest::CancelIfSendingL(const CMsvEntrySelection& aSelection) + { + const TInt count = aSelection.Count(); + + for (TInt i = 0; i < count; i++) + { + TRAPD(err, iSmsTest.SetEntryL(aSelection[i])); + + if (!err) + { + TMsvEntry entry = iSmsTest.Entry(); + + if (entry.SendingState() == KMsvSendStateSending) + { + if (iOperation) + { + iOperation->Cancel(); + return; + } + else + { + entry.SetSendingState(KMsvSendStateSuspended); + TRAP(err, iSmsTest.ChangeEntryL(entry)); //ignore error + + if (err) + { + iSmsTest.Printf(_L("Error Cancelling Entry %d: On ChangeEntryL()\n"), aSelection[i]); + } //end if + } //end if + } //end if + } + else + { + iSmsTest.Printf(_L("Error Cancelling Entry %d: On SetEntryL()\n"), aSelection[i]); + } + } + } + +void CSmsCancelTest::ShowMenuL() + { + iSmsTest.ResetMenu(); + + iSmsTest.AppendToMenuL(_L("Test Cancel Sending")); + iSmsTest.AppendToMenuL(_L("Test Cancel Scheduling")); + + TInt result = iSmsTest.DisplayMenu(_L("SMS Cancel Test")); + + if (result <= 0) + return; + + switch (result) + { + case 1: + TestCancelSendingL(); + break; + case 2: + TestCancelSendingAfterScheduleL(); + break; + default: + User::Leave(KErrArgument); + break; + } + + ShowMenuL(); + } + +void CSmsCancelTest::RunL() + { + if (iOperation) + iSmsTest.SetProgressL(*iOperation); + + switch (iState) + { + case EStateScheduling: + DoRunSchedulingL(); + break; + case EStateSending: + DoRunSendingL(); + break; + default: + { + break; + } + } + + delete iOperation; + iOperation = NULL; + } + +void CSmsCancelTest::DoCancel() + { + if (iOperation) + { + iOperation->Cancel(); + iSmsTest.Printf(_L("Operation Cancelled!\n")); + } + else + { + iSmsTest.Printf(_L("No operation to cancel!\n")); + } + + delete iOperation; + iOperation = NULL; + } + +void CSmsCancelTest::DoRunSchedulingL() + { + if (iStatus == KErrNone) + iStatus = iSmsTest.iProgress.iError; + + iSmsTest.Printf(_L("Scheduling completed with error %d\n"), iStatus); + + TBool sent = EFalse; + + if (iStatus == KErrNone) + { + iSmsTest.DisplaySendingStatesL(*iSelection); + TInt error = KErrNone; + sent = iSmsTest.SendingCompleteL(*iSelection, error); + iStatus = error; + } + + if (!sent) + { + iStatus = KRequestPending; + SetActive(); + iState = EStateSending; + } + else + { + CActiveScheduler::Stop(); + iState = EStateWaiting; + iSmsTest.Printf(_L("Scheduling completed with error %d\n"), iStatus); + + if (!iSmsTest.RunAuto()) + { + iSmsTest.Test().Printf(_L("\nPress any key to continue...\n")); + iSmsTest.Test().Getch(); + } + } + } + +void CSmsCancelTest::DoRunSendingL() + { + CActiveScheduler::Stop(); + + if (!iOperation) //scheduled + { + TTimeIntervalMicroSeconds32 wait = 5000000; + iSmsTest.Printf(_L("\nWaiting %d seconds for SMSS to complete...\n\n"), wait.Int() / 1000000); + User::After(wait); + } + + if (iStatus == KErrNone) + iStatus = iSmsTest.iProgress.iError; + + iState = EStateWaiting; + iSmsTest.Printf(_L("Sending completed with error %d\n"), iStatus); + + if (iStatus == KErrCancel) + { + iSmsTest.Printf(_L("Error %d is expected and OK\n"), iStatus); + iStatus = KErrNone; + } + + iSmsTest.Printf(_L("Final Sending States of Messages:\n\n"), iStatus); + iSmsTest.DisplaySendingStatesL(*iSelection); + + if (!iSmsTest.RunAuto()) + { + iSmsTest.Test().Printf(_L("\nPress any key to continue...\n")); + iSmsTest.Test().Getch(); + } + } + +RTest test(_L("SchSms Test")); + + +LOCAL_C void doMainL() + { + CActiveScheduler* iScheduler = new (ELeave) CActiveScheduler; + CleanupStack::PushL(iScheduler); + CActiveScheduler::Install( iScheduler ); + + CSmsTestUtils* smsTest = CSmsTestUtils::NewL(test); + CleanupStack::PushL(smsTest); + TInt nextTest = 0; + + smsTest->NotifySaPhoneOnL(); + + CSmsCancelTest* cancelTest = CSmsCancelTest::NewLC(*smsTest, KSmsScript, nextTest); + + smsTest->WaitForInitializeL(); + + cancelTest->StartL(); + + CleanupStack::PopAndDestroy(3); //SmsTest, iScheduler + } + + +GLDEF_C TInt E32Main() + { + __UHEAP_MARK; + test.Start(_L("Setup")); + CTrapCleanup* theCleanup = CTrapCleanup::New(); + TRAPD(ret,doMainL()); + test(ret==KErrNone); + delete theCleanup; + test.Console()->SetPos(0, 13); + test.End(); + test.Close(); + __UHEAP_MARKEND; + return(KErrNone); + } + +CSmsCancelTest* CSmsCancelTest::NewLC(CSmsTestUtils& aSmsTest, const TDesC& aScriptFile, TInt& aCurrentTest) + { + CSmsCancelTest* self = new (ELeave) CSmsCancelTest(aSmsTest, aScriptFile, aCurrentTest); + CleanupStack::PushL(self); + self->ConstructL(); + return self; + } + +void CSmsCancelTest::TestCancelReadScL() + { + } + +void CSmsCancelTest::TestCancelWriteScL() + { + } + +void CSmsCancelTest::TestCancelReadSimParamsL() + { + } + +void CSmsCancelTest::TestCancelEnumerateL() + { + } + +void CSmsCancelTest::TestCancelSendingL() + { + DoTestSendingL(iScriptFile); + iState = EStateSending; + CActiveScheduler::Start(); + } + +void CSmsCancelTest::TestCancelSendingAfterScheduleL() + { + DoTestSchedulingL(iScriptFile); + iState = EStateScheduling; + CActiveScheduler::Start(); + }