diff -r 000000000000 -r 8e480a14352b messagingfw/scheduledsendmtm/test/unit/src/t_schsend.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/messagingfw/scheduledsendmtm/test/unit/src/t_schsend.cpp Mon Jan 18 20:36:02 2010 +0200 @@ -0,0 +1,1087 @@ +// 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 "t_schsend.h" + +#include +#include +#include +#include +#include +#include +#include +#include + +RTest& operator<<(RTest& aTest, TTime t); + +CTrapCleanup* theCleanup; +//_LIT(KSmsResourceFile, "z:\\System\\Data\\SMSS.RSC"); + +//Horrible hack because nmake thinks &myFun is illegal but GCC needs the & sign + +#ifdef __WINS__ +#define PFUN +#else +#define PFUN & +#endif + +void doMainL(RTest& aTest) + { + CActiveScheduler* scheduler = new (ELeave) CActiveScheduler; + CleanupStack::PushL(scheduler); + CActiveScheduler::Install( scheduler ); + + CSchSendTest* schSendTest = CSchSendTest::NewL(aTest); + CleanupStack::PushL(schSendTest); + + schSendTest->StartL(); + + CleanupStack::PopAndDestroy(2); //schSendTest, iScheduler + + aTest.Printf(_L("\nWaiting 3 seconds before closing...\n")); + User::After(3000000); + } + +GLDEF_C TInt E32Main() + { + RTest test(_L("Scheduled Sending Test Harness")); + __UHEAP_MARK; + test.Title(); + test.Start(_L("Scheduled Sending Test Harness")); + theCleanup = CTrapCleanup::New(); + test(theCleanup !=NULL); + TRAPD(error,doMainL(test)); + test(error==KErrNone); + delete theCleanup; + test.Printf(_L("Completed with return code %d"),error); + test.End(); + test.Close(); + __UHEAP_MARKEND; + return KErrNone; + } + +CSchSendTest* CSchSendTest::NewL(RTest& aTest) + { + CSchSendTest* self = new (ELeave) CSchSendTest(aTest); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(); //self + return self; + } + +CSchSendTest::CSchSendTest(RTest& aTest) +: CSchSendTestUtils(aTest) + { + } + +void CSchSendTest::TestPackageL() + { + TMsvSchedulePackage pkg; + pkg.iCommandId = 100000; + pkg.iId = 123456; + + TestPackageL(pkg); + + pkg.iCommandId = 20000; + pkg.iPollProgress = 1000000; + + TestPackageL(pkg); + + pkg.iParameter.Append(_L8("Hello")); + + TestPackageL(pkg); + + pkg.iParameter.Fill('a'); + + TestPackageL(pkg); + } + +void CSchSendTest::TestPackageL(const TMsvSchedulePackage& aPackage) + { + TTaskInfo info; + TMsvSchedulePackage pkg; + HBufC* buf = NULL; + + aPackage.PackLC(info, buf); + pkg.UnpackL(info, *buf); + AssertL(aPackage == pkg); + CleanupStack::PopAndDestroy(buf); + } + +void CSchSendTest::RunAutoL() + { + // Two groups of tests + TestSendErrorActionsL(); + TestOffPeakTimesL(); + + // Individual tests + + AssertL(DoTest(PFUN CSchSendTest::TestPackageL, _L("Schedule Package"))); + AssertL(DoTest(PFUN TestSysAgentActionsL, _L("Sys Agent Actions"))); + AssertL(DoTest(PFUN TestScheduleSettingsL, _L("Schedule Settings"))); + AssertL(DoTest(PFUN TestSchedulingMessagesL, _L("Scheduling Messages"))); + AssertL(DoTest(PFUN TestSchedulingOldMessagesL, _L("Scheduling Old Messages"))); + AssertL(DoTest(PFUN TestSchedulingMessagesTwiceL, _L("Scheduling Messages Twice"))); + AssertL(DoTest(PFUN TestReschedulingMessagesL, _L("ReScheduling Messages"))); + AssertL(DoTest(PFUN TestReschedulingNonScheduledMessagesL, _L("ReScheduling Non Scheduled Messages"))); + AssertL(DoTest(PFUN TestDeletingMessagesL, _L("Deleting Messages"))); + AssertL(DoTest(PFUN TestDeletingNonScheduledMessagesL, _L("Deleting Non Scheduled Messages"))); + + AssertL(DoTest(PFUN TestSchedulingOffPeakMessagesL, _L("Off Peak Messages"))); + + //AssertL(DoTest(PFUN TestCheckScheduleL, _L("CheckScheduleL"))); + + AssertL(HeapTest(PFUN TestSysAgentActionsL, _L("Sys Agent Actions"))); + AssertL(HeapTest(PFUN TestSchedulingMessagesL, _L("Scheduling Messages"))); + AssertL(HeapTest(PFUN TestSchedulingOffPeakMessagesL, _L("Off Peak Messages"))); + AssertL(HeapTest(PFUN TestSchedulingOldMessagesL, _L("Scheduling Old Messages"))); + AssertL(HeapTest(PFUN TestSchedulingMessagesTwiceL, _L("Scheduling Messages Twice"))); + AssertL(HeapTest(PFUN TestReschedulingMessagesL, _L("ReScheduling Messages"))); + AssertL(HeapTest(PFUN TestReschedulingNonScheduledMessagesL, _L("ReScheduling Non Scheduled Messages"))); + AssertL(HeapTest(PFUN TestDeletingMessagesL, _L("Deleting Messages"))); + AssertL(HeapTest(PFUN TestDeletingNonScheduledMessagesL, _L("Deleting Non Scheduled Messages"))); + + } + + +void CSchSendTest::TestSendErrorActionsL() + { +/* + Public functions of TMsvSendErrorAction: + + Tested Function + ------- --------------------------------------------------------------------- + Yes TMsvSendErrorAction(); + Yes void InternalizeL(RReadStream& aReadStream); + Yes void ExternalizeL(RWriRTestream& aWriRTestream) const; + Yes void Reset(); + Yes void SetMaxRetries(const TInt16 aMaxRetries); + Yes TInt16 MaxRetries() const; + + Public functions of CMsvSendErrorActions: + + Tested Function + ------- --------------------------------------------------------------------- + Yes static CMsvSendErrorActions* NewL(); + Yes void AddSendErrorActionL(const TMsvSendErrorAction& aAction); + Yes const TInt RemoveSendErrorAction(const TInt aError); + Yes const TInt GetSendErrorAction(const TInt aError, TMsvSendErrorAction& aAction) const; + Yes void StoreL(CMsvStore& aStore) const; + Yes void RestoreL(CMsvStore& aStore); + void RestoreFromResourceL(TResourceReader& aReader); + Yes void SetErrorsL(const CArrayFixFlat& aActions); + // but broken + Yes const CArrayFixFlat& Errors() const; + Yes const TMsvSendErrorAction& Default() const; + Yes void SetDefault(const TMsvSendErrorAction& aAction); + +*/ + + AssertL(DoTest(PFUN TestSendErrorActions1L, _L("TestSendErrorActions1"))); + AssertL(DoTest(PFUN TestDefaultL, _L("TestDefault"))); + AssertL(DoTest(PFUN TestSendErrorActions3L, _L("TestSendErrorActions3"))); + AssertL(DoTest(PFUN TestErrorsL, _L("TestErrors"))); + AssertL(DoTest(PFUN TestStoringL, _L("TestStoring"))); + AssertL(DoTest(PFUN TestRemovingL, _L("TestRemoving"))); + //AssertL(DoTest(PFUN TestSendErrorActions4L, _L("TestSendErrorActions4"))); + + } + +void CSchSendTest::TestOffPeakTimesL() + { +/* + Public functions of TMsvOffPeakTime: + + Tested Function + ------- --------------------------------------------------------------------- + Yes TMsvOffPeakTime(); + Yes TMsvOffPeakTime(const TDay aDay, const TInt aHour, const TInt aMinute, const TTimeIntervalMinutes aValidityPeriod); + Yes void ExternalizeL (RWriRTestream &) const; + Yes void InternalizeL (RReadStream &); + Yes void Reset(); + Yes const TDay Day() const; + Yes void SetDay(const TDay aDay); + Yes const TInt Hour() const; + Yes void SetHour(const TInt aHour); + Yes const TInt Minute() const; + Yes void SetMinute(const TInt aMinute); + Yes const TTimeIntervalMinutes ValidityPeriod() const; + Yes void SetValidityPeriod(const TTimeIntervalMinutes aValidityPeriod); + Yes const TTime NextTimeInclusive(const TTime& aFromTime) const; + + + Public functions of CMsvOffPeakTimes: + + Tested Function + ------- --------------------------------------------------------------------- + Yes CMsvOffPeakTimes(); + Yes void StoreL(CMsvStore& aStore) const; + Yes void RestoreL(CMsvStore& aStore); + const TInt GetNextOffPeakTime(const TTime& aFromTime, TMsvOffPeakTime& aNext, TTime& aNextTime) const; + // This last one tested by TestReschedulingMessagesL() +*/ + + AssertL(DoTest(PFUN TestOffPeakTimes1L, _L("TestOffPeakTimes1L"))); + AssertL(DoTest(PFUN TestOffPeakTimes3L, _L("TestOffPeakTimes3L"))); + + } + +void CSchSendTest::TestSendErrorActions1L() + { +// --- Testing TMsvSendErrorAction --- + + iRTest.Next(_L("TestSendErrorActions1L()")); + + TMsvSendErrorAction action1, action2; + + action1.iAction = ESendActionRetryLater; + action1.iRetries = ESendRetriesFixed; + action1.iRetrySpacing = ESendRetrySpacingStatic; + action1.iError = KErrNotFound; + action1.SetMaxRetries(10); + + action2 = action1; + + AssertL(action1==action2); + + action1.SetMaxRetries(1); + AssertL(action1.MaxRetries() == 1); + + action1.SetMaxRetries(200); + AssertL(action1.MaxRetries() == 200); + + action1.Reset(); + TMsvSendErrorAction action3; + + AssertL(action1==action3); + } + + +void CSchSendTest::TestSendErrorActions3L() + { + TMsvSendErrorAction action1, action2; + action1.iAction = ESendActionRetryLater; + action1.iRetries = ESendRetriesFixed; + action1.iRetrySpacing = ESendRetrySpacingStatic; + action1.iError = KErrNotFound; + action1.SetMaxRetries(10); + action1.Reset(); + AssertL(action1==action2); + } + +void CSchSendTest::TestDefaultL() + { + + CMsvSendErrorActions* actions = CMsvSendErrorActions::NewL(); + CleanupStack::PushL(actions); + + TMsvSendErrorAction action1, action2; + + action1.iAction = ESendActionRetryLater; + action1.iRetries = ESendRetriesFixed; + action1.iRetrySpacing = ESendRetrySpacingStatic; + action1.iError = KErrNotFound; + action1.SetMaxRetries(10); + + actions->SetDefault(action1); + action2 = actions->Default(); + + AssertL(action2 == action1); + + CleanupStack::PopAndDestroy(); // actions + + } + +void CSchSendTest::TestSendErrorActions5L() + { + + CMsvSendErrorActions* actions = CMsvSendErrorActions::NewL(); + CleanupStack::PushL(actions); + + TMsvSendErrorAction action1, action2, action3; + + action1.iError = KErrGeneral; + action2.iError = KErrNotSupported; + + actions->AddSendErrorActionL(action1); + actions->AddSendErrorActionL(action2); + + TInt error = actions->GetSendErrorAction(KErrNotSupported, action3); + + AssertL(error == KErrNone); + AssertL(action3 == action2); + + error = actions->GetSendErrorAction(KErrGeneral, action3); + + AssertL(action3 == action1); + + error = actions->GetSendErrorAction(KErrNotFound, action3); + AssertL(error == KErrNotFound); + + CleanupStack::PopAndDestroy(); // actions + } + +void CSchSendTest::TestErrorsL() + { + CMsvSendErrorActions* actions = CMsvSendErrorActions::NewL(); + CleanupStack::PushL(actions); + + CArrayFixFlat* actionArray1 = new (ELeave) CArrayFixFlat(20); + CleanupStack::PushL(actionArray1); + TMsvSendErrorAction test1, test2; + test1.iError = KErrAbort; + test2.iError = KErrTooBig; + + TInt offSet = _FOFF(TMsvSendErrorAction, iError); + TKeyArrayFix key(offSet, ECmpTInt); + + actionArray1->InsertIsqL(test1, key); + actionArray1->InsertIsqL(test2, key); + + actions->SetErrorsL(*actionArray1); + const CArrayFixFlat& actionArray2 = actions->Errors(); + + AssertL(actionArray1->Count()==actionArray2.Count()); + for(int i = 0; i < actionArray1->Count(); i++) + { + // VC can't find my operator== if I do this the obvious one-line way + TMsvSendErrorAction one = (*actionArray1)[i]; + TMsvSendErrorAction two = actionArray2[i]; + AssertL(one==two); + } + CleanupStack::PopAndDestroy(2); // actions, actionArray1 + } + +void CSchSendTest::TestStoringL() + { + CMsvSendErrorActions* actions = CMsvSendErrorActions::NewL(); + CleanupStack::PushL(actions); + + CMsvSendErrorActions* actions2 = CMsvSendErrorActions::NewL(); + CleanupStack::PushL(actions2); + + // access sms account settings + CSmsAccount* account = CSmsAccount::NewLC(); + + CMsvScheduleSettings* scheduleSettings = CMsvScheduleSettings::NewL(); + CleanupStack::PushL(scheduleSettings); + CMsvOffPeakTimes* offPeakTimes = new(ELeave) CMsvOffPeakTimes; + CleanupStack::PushL(offPeakTimes); + CMsvSendErrorActions* errorActions = CMsvSendErrorActions::NewL(); + CleanupStack::PushL(errorActions); + CMsvSysAgentActions* sysAgentActions = new (ELeave) CMsvSysAgentActions(); + CleanupStack::PushL(sysAgentActions); + + // read existing settings + TRAPD(ignor, account->LoadSettingsL(*scheduleSettings, *offPeakTimes, *errorActions, *sysAgentActions)); + + // write + account->SaveSettingsL(*scheduleSettings, *offPeakTimes, *actions, *sysAgentActions); + + // read + account->LoadSettingsL(*scheduleSettings, *offPeakTimes, *actions2, *sysAgentActions); + + // restore settings + account->SaveSettingsL(*scheduleSettings, *offPeakTimes, *errorActions, *sysAgentActions); + CleanupStack::PopAndDestroy(4, scheduleSettings); // sysAgentActions, errorActions, offPeakTimes, scheduleSettings + + AssertL(*actions==*actions2); + + CleanupStack::PopAndDestroy(3); //actions, actions2, entry/account + } + +void CSchSendTest::TestRemovingL() + { + TMsvSendErrorAction a1, a2, a3; + a1.iError = -3; + a2.iError = -4; + a3.iError = -5; + CMsvSendErrorActions* actions1 = CMsvSendErrorActions::NewL(); + CleanupStack::PushL(actions1); + CMsvSendErrorActions* actions2 = CMsvSendErrorActions::NewL(); + CleanupStack::PushL(actions2); + + actions1->AddSendErrorActionL(a1); + actions1->AddSendErrorActionL(a2); + actions1->AddSendErrorActionL(a3); + + actions2->AddSendErrorActionL(a1); + actions2->AddSendErrorActionL(a3); + + actions1->RemoveSendErrorAction(-4); + + AssertL(*actions1==*actions2); + + CleanupStack::PopAndDestroy(2); //actions1 and 2 + } + +/*void CSchSendTest::TestSendErrorActions4L() + { +// --- Reading CMsvSendErrorActions from a resource file --- + + iRTest.Next(_L("TestSendErrorActions4L")); + + CMsvSendErrorActions* actions = CMsvSendErrorActions::NewL(); + CleanupStack::PushL(actions); + + TFileName fileName; + TParse parse; + parse.Set(KSmsResourceFile, &fileName, 0); + fileName=parse.FullName(); + BaflUtils::NearestLanguageFile(iFs, fileName); + RResourceFile iResourceFile; + iResourceFile.OpenL(iFs, fileName); + + TResourceReader reader; + HBufC8* rBuf = iResourceFile.AllocReadLC(ERROR_ACTIONS); + reader.SetBuffer(rBuf); + + actions->RestoreFromResourceL(reader); + + iResourceFile.Close(); + CleanupStack::PopAndDestroy(2); //actions, rBuf + } */ + + + +void CSchSendTest::TestOffPeakTimes1L() + { + iRTest.Next(_L("TestOffPeakTimes1L")); + + + //Make an off peak time + TInt hour = 10; + TInt min = 10; + TDay day = EMonday; + TTimeIntervalMinutes valPrd = 5*60; + + TMsvOffPeakTime offPeak; + offPeak.SetHour(hour); + offPeak.SetMinute(min); + offPeak.SetDay(day); +// offPeak.SetValidityPeriod(-1); PASSED OK + offPeak.SetValidityPeriod(valPrd); + + //Check that it worked + AssertL(offPeak.Hour() == hour); + AssertL(offPeak.Minute() == min); + AssertL(offPeak.Day() == day); + AssertL(offPeak.ValidityPeriod() == valPrd); + + + TTime now; + now.HomeTime(); + TTime nextTime = now; + nextTime = offPeak.NextTimeInclusive(now); + + TBuf<30> dateString; + now.FormatL(dateString,(_L("%D%M%Y%/0%1%/1%2%/2%3%/3 %-B%:0%J%:1%T%:2%S%.%*C4%:3%+B"))); + Printf(_L("Now: ")); + Printf(dateString); + Printf(_L("\n")); + + nextTime.FormatL(dateString,(_L("%D%M%Y%/0%1%/1%2%/2%3%/3 %-B%:0%J%:1%T%:2%S%.%*C4%:3%+B"))); + Printf(_L("Next Time: ")); + Printf(dateString); + Printf(_L("\n")); + + AssertL(StartsAt(offPeak, nextTime)); + + TTime fourHoursAgo = now - (TTimeIntervalHours) 4; + TDateTime dtFourHoursAgo = fourHoursAgo.DateTime(); + + hour = dtFourHoursAgo.Hour(); + min = dtFourHoursAgo.Minute(); + day = fourHoursAgo.DayNoInWeek(); + valPrd = 8*60; // valid for eight hours + + TMsvOffPeakTime nowIsOffPeak(day, hour, min, valPrd); + nextTime = nowIsOffPeak.NextTimeInclusive(now); + + Printf(_L("Now: ")); + iRTest<AppendL(offPeak1); + + offPeak2.SetDay(EWednesday); + offPeak2.SetHour(20); + offPeak2.SetMinute(30); + offPeak2.SetValidityPeriod(10); + + offPeakTimes1->AppendL(offPeak2); + + // access sms account settings + CSmsAccount* account = CSmsAccount::NewLC(); + + CMsvScheduleSettings* scheduleSettings = CMsvScheduleSettings::NewL(); + CleanupStack::PushL(scheduleSettings); + CMsvOffPeakTimes* offPeakTimes = new(ELeave) CMsvOffPeakTimes; + CleanupStack::PushL(offPeakTimes); + CMsvSendErrorActions* errorActions = CMsvSendErrorActions::NewL(); + CleanupStack::PushL(errorActions); + CMsvSysAgentActions* sysAgentActions = new (ELeave) CMsvSysAgentActions(); + CleanupStack::PushL(sysAgentActions); + + // read existing settings + TRAPD(ignor, account->LoadSettingsL(*scheduleSettings, *offPeakTimes, *errorActions, *sysAgentActions)); + + // write + account->SaveSettingsL(*scheduleSettings, *offPeakTimes1, *errorActions, *sysAgentActions); + + // read + account->LoadSettingsL(*scheduleSettings, *offPeakTimes2, *errorActions, *sysAgentActions); + + // restore settings + account->SaveSettingsL(*scheduleSettings, *offPeakTimes, *errorActions, *sysAgentActions); + CleanupStack::PopAndDestroy(4, scheduleSettings); + + AssertL(offPeakTimes1->Count()==offPeakTimes2->Count()); + for(int i = 0; i < offPeakTimes1->Count(); i++) + AssertL((*offPeakTimes1)[i]==(*offPeakTimes2)[i]); + + CleanupStack::PopAndDestroy(3, offPeakTimes1); // offPeakTimes1, offPeakTimes2, entry/account + } + + + + +void CSchSendTest::TestScheduleSettingsL() + { +/* + Public functions of CMsvScheduleSettings: + + Tested Function + ------- --------------------------------------------------------------------- + Yes void StoreL(CMsvStore&) const; + Yes void RestoreL(CMsvStore&); + Yes void Reset(); + Yes void SetSendExe(const TDesC&); + Yes const TDesC& SendExe() const; + Yes void SetPriority(const TInt); + Yes const TInt Priority() const; + Yes void SetValidityPeriod(const TTimeIntervalMinutes&); + Yes const TTimeIntervalMinutes& ValidityPeriod() const; + Yes void SetIntervalType(const TIntervalType); + Yes const TIntervalType IntervalType() const; + Yes void SetLongInterval(const TTimeIntervalSeconds&); + Yes const TTimeIntervalSeconds& LongInterval() const; + Yes void SetShortInterval(const TTimeIntervalSeconds&); + Yes const TTimeIntervalSeconds& ShortInterval() const; + Yes const CArrayFixFlat& VariableIntervals() const; + Yes void SetVariableIntervalsL(const CArrayFixFlat&); + Yes const TTimeIntervalSeconds& Latency() const; + Yes void SetLatency(const TTimeIntervalSeconds&); +*/ + iRTest.Next(_L("Schedule Settings Test - CMsvScheduleSettings")); + + CMsvScheduleSettings* settings1 = CMsvScheduleSettings::NewL(); + CleanupStack::PushL(settings1); + + CMsvScheduleSettings* settings2 = CMsvScheduleSettings::NewL(); + CleanupStack::PushL(settings2); + + settings1->SetIntervalType(EDaily); + settings1->SetLatency(6); + settings1->SetLongInterval(6); + settings1->SetShortInterval(6); + settings1->SetValidityPeriod(6); + settings1->SetPriority(1); + CArrayFixFlat* times = new (ELeave) CArrayFixFlat(20); + CleanupStack::PushL(times); + times->AppendL(6); + times->AppendL(6); + times->AppendL(6); + settings1->SetVariableIntervalsL(*times); + + // access sms account settings + CSmsAccount* account = CSmsAccount::NewLC(); + + CMsvScheduleSettings* scheduleSettings = CMsvScheduleSettings::NewL(); + CleanupStack::PushL(scheduleSettings); + CMsvOffPeakTimes* offPeakTimes = new(ELeave) CMsvOffPeakTimes; + CleanupStack::PushL(offPeakTimes); + CMsvSendErrorActions* errorActions = CMsvSendErrorActions::NewL(); + CleanupStack::PushL(errorActions); + CMsvSysAgentActions* sysAgentActions = new (ELeave) CMsvSysAgentActions(); + CleanupStack::PushL(sysAgentActions); + + // read existing settings + TRAPD(ignor, account->LoadSettingsL(*scheduleSettings, *offPeakTimes, *errorActions, *sysAgentActions)); + + // write + account->SaveSettingsL(*settings1, *offPeakTimes, *errorActions, *sysAgentActions); + + // read + account->LoadSettingsL(*settings2, *offPeakTimes, *errorActions, *sysAgentActions); + + // restore settings + account->SaveSettingsL(*scheduleSettings, *offPeakTimes, *errorActions, *sysAgentActions); + CleanupStack::PopAndDestroy(4, scheduleSettings); + +// Not doing anything? +// CMsvScheduleSettings* aDefaultSettings = CMsvScheduleSettings::NewL(); +// CleanupStack::PushL(aDefaultSettings); +// aSettings2->Reset(); + +// AssertL(*aDefaultSettings==*aSettings2); + + CleanupStack::PopAndDestroy(4, settings1); // settings1, settings2, times, entry/account + } + +void CSchSendTest::TestSysAgentActionsL() + { + CMsvSysAgentActions* actions = new (ELeave) CMsvSysAgentActions(); + CleanupStack::PushL(actions); + CleanupStack::PopAndDestroy(actions); + } + +void CSchSendTest::TestSchedulingMessagesL() + { + + //make a message and schedule it in 1 second + TMsvEntry entry; + TTime t; + t.HomeTime(); +// t += TTimeIntervalSeconds(2); + TMsvId testMessage = CreateMessageLC(entry, KMsvGlobalInBoxIndexEntryId, t); + + iRTest.Printf(_L("Message created at ")); + iRTest << t; + + iSelection->ResizeL(0); + iSelection->AppendL(testMessage); + + iMsvEntry->SetEntryL(testMessage); + AssertL(iMsvEntry->Entry().SendingState() == 0); + TTime t2 = TestL(EScheduleAllL, *iSelection).iTime; + + iRTest.Printf(_L("Message scheduled at ")); + iRTest << t2; + //Test that the time is still the same + + //check that it worked + + iMsvEntry->SetEntryL(testMessage); + iRTest.Printf(_L("Message iDate ")); + iRTest << iMsvEntry->Entry().iDate; + + AssertL(CompareRoundedTimes(iMsvEntry->Entry().iDate, t2)); + + const TInt sendState = iMsvEntry->Entry().SendingState(); + AssertL(sendState == KMsvSendStateSent); + + CleanupStack::PopAndDestroy();//testMessage + } + +void CSchSendTest::TestSchedulingOldMessagesL() + { + //Make a message and schedule it yesterday + TMsvEntry entry; + TTime t; + t.HomeTime(); + t -= TTimeIntervalDays(1); + TMsvId testMessage = CreateMessageLC(entry, KMsvGlobalInBoxIndexEntryId, t); + + + iSelection->ResizeL(0); + iSelection->AppendL(testMessage); + + + TTime t2(TestL(EScheduleAllL, *iSelection, ETrue).iTime); + + //did it get scheduled? + + iMsvEntry->SetEntryL(testMessage); + AssertL(iMsvEntry->Entry().SendingState() == KMsvSendStateScheduled); + + TTime now; + now.HomeTime(); + + //should be scheduled in the future + + iRTest << t2 << now; + AssertL(t2 > now); + + ChangeMessageTimeL(testMessage, t); + + CleanupStack::PopAndDestroy();//testMessage + } + +void CSchSendTest::TestSchedulingOffPeakMessagesL() + { + + //make a message and schedule it for off-peak + TMsvEntry entry; + TTime t; + t.HomeTime(); + t += TTimeIntervalSeconds(1); + iRTest.Printf(_L("Trying to schedule at")); + iRTest<ResizeL(0); + iSelection->AppendL(testMessage); + + iSchTestActive->TransferCommandSyncL(ESetNowOffPeak, *iSelection, ETrue); + + ChangeMessageTimeL(testMessage, t); + TTime t2 = TestL(EScheduleAllL, *iSelection, ETrue).iTime; + ChangeMessageTimeL(testMessage, t); + + iMsvEntry->SetEntryL(testMessage); + TMsvEntry resultingEntry = iMsvEntry->Entry(); + AssertL(resultingEntry.SendingState() == KMsvSendStateScheduled); + + TTime now; + now.HomeTime(); + + AssertL(DiffInMins(t2, now) < 5); // About now + + iSchTestActive->TransferCommandSyncL(ESetNowNotOffPeak, *iSelection, ETrue); + + t2 = TestL(EScheduleAllL, *iSelection, ETrue).iTime; + + + AssertL(DiffInMins(t2, now) > (60 * 22)); // Tomorrow sometime + + iSchTestActive->TransferCommandSyncL(ESetFirstOffPeakBest, *iSelection, ETrue); + + t2 = TestL(EScheduleAllL, *iSelection, ETrue).iTime; + + AssertL(DiffInMins(t2, now) > (60 * 22)); // Tomorrow sometime + + iSchTestActive->TransferCommandSyncL(ESetLastOffPeakBest, *iSelection, ETrue); + t2 = TestL(EScheduleAllL, *iSelection, ETrue).iTime; + + AssertL(DiffInMins(t2, now) > (60 * 22)); // Tomorrow sometime + + //Tidy up after ourselves! + iSchTestActive->TransferCommandSyncL(EDeleteScheduleL, *iSelection, ETrue); + + CleanupStack::PopAndDestroy();//testMessage + } + + +void CSchSendTest::TestReschedulingMessagesL() + { + //Make a message and schedule it in 1 second + TMsvEntry entry; + TTime t; + t.HomeTime(); + t += TTimeIntervalSeconds(4); + TMsvId testMessage = CreateMessageLC(entry, KMsvGlobalInBoxIndexEntryId, t); + + + iSelection->ResizeL(0); + iSelection->AppendL(testMessage); + + iSchTestActive->TransferCommandSyncL(EScheduleAllL, *iSelection, ETrue); + + //Set the retry time + iSchTestActive->TransferCommandSyncL(ESetRetryImmediately, *iSelection, ETrue); + + //Reschedule the message + + TTime t2 = TestL(EReScheduleAllL, *iSelection, ETrue).iTime; + + //Still scheduled? + + iMsvEntry->SetEntryL(testMessage); + AssertL(iMsvEntry->Entry().SendingState() == KMsvSendStateResend); + + //Check the time is in KShortInterval seconds from t + + TTime test = t + TTimeIntervalSeconds(KShortInterval); + iRTest.Printf(_L("KShortInterval seconds different ")); + iRTest<TransferCommandSyncL(ESetRetryLater, *iSelection, ETrue); + t2 = TestL(EReScheduleAllL, *iSelection, ETrue).iTime; + + test = t + TTimeIntervalSeconds(KLongInterval); + iRTest.Printf(_L("KLongInterval seconds different")); + iRTest<< t2 << test; + AssertL(DiffInSecs(test,t2)< 5); + + iSchTestActive->TransferCommandSyncL(ESetNoRetry, *iSelection, ETrue); + iSchTestActive->TransferCommandSyncL(EReScheduleAllL, *iSelection, ETrue); + + iSchTestActive->TransferCommandSyncL(ESetRetryVariable, *iSelection, ETrue); + t2 = TestL(EReScheduleAllL, *iSelection, ETrue).iTime; + + test = t + TTimeIntervalSeconds(KFirstInterval); + iRTest.Printf(_L("KFirstInterval seconds different")); + iRTest<< t2 << test; + AssertL(DiffInSecs(test, t2) < 5); + + t2 = TestL(EReScheduleAllL, *iSelection, ETrue).iTime; + + test = t + TTimeIntervalSeconds(KSecondInterval); + iRTest.Printf(_L("KSecondInterval seconds different")); + iRTest<TransferCommandSyncL(EDeleteScheduleL, *iSelection, ETrue); + + CleanupStack::PopAndDestroy();//testMessage + } + +void CSchSendTest::TestReschedulingNonScheduledMessagesL() + { + //Make a message and schedule it in 1 second + TMsvEntry entry; + TTime t; + t.HomeTime(); + t += TTimeIntervalSeconds(1); + TMsvId testMessage = CreateMessageLC(entry, KMsvGlobalInBoxIndexEntryId, t); + + iSelection->Reset(); + iSelection->AppendL(testMessage); + + //Reschedule the message + + iSchTestActive->TransferCommandSyncL(EReScheduleAllL, *iSelection, ETrue); + + //Are we scheduled now? + + iMsvEntry->SetEntryL(testMessage); + AssertL(iMsvEntry->Entry().SendingState() == KMsvSendStateResend); + + //Tidy up. + iSchTestActive->TransferCommandSyncL(EDeleteScheduleL, *iSelection, ETrue); + + CleanupStack::PopAndDestroy();//testMessage + } + +void CSchSendTest::TestSchedulingMessagesTwiceL() + { + //make a message + TMsvEntry entry; + TTime t; + t.HomeTime(); + t += TTimeIntervalSeconds(1); + TMsvId testMessage = CreateMessageLC(entry, KMsvGlobalInBoxIndexEntryId, t); + + + //schedule it for real soon now + iSelection->Reset(); + iSelection->AppendL(testMessage); + + iSchTestActive->TransferCommandSyncL(EScheduleAllL, *iSelection, ETrue); + + //schedule it for tomorrow too + t += TTimeIntervalDays(1); + ChangeMessageTimeL(testMessage, t); + + //TTime t2 = TestL(EScheduleAllL, *iSelection, ETrue)); + + //assert message scheduled. + + iMsvEntry->SetEntryL(testMessage); + AssertL(iMsvEntry->Entry().SendingState() == KMsvSendStateScheduled); + + //look for the message + + TTime now; + now.HomeTime(); + + //check its time is tomorrow +// AssertL(DiffInMins(t2,now) > (23*60)); + + //Get rid of it + iSchTestActive->TransferCommandSyncL(EDeleteScheduleL, *iSelection, ETrue); + + CleanupStack::PopAndDestroy();//testMessage + } + + +void CSchSendTest::TestDeletingMessagesL() + { + //make a message and schedule it for tomorrow + TMsvEntry entry; + TTime t; + t.HomeTime(); + t += TTimeIntervalDays(1); + iSelection->Reset(); + + TMsvId testMessage1 = CreateMessageLC(entry, KMsvGlobalInBoxIndexEntryId, t); + iSelection->AppendL(testMessage1); + TMsvId testMessage2 = CreateMessageLC(entry, KMsvGlobalInBoxIndexEntryId, t); + iSelection->AppendL(testMessage2); + TMsvId testMessage3 = CreateMessageLC(entry, KMsvGlobalInBoxIndexEntryId, t); + iSelection->AppendL(testMessage3); + + TInt schCountOld, schCountNew; + TInt schSize; + DisplayAllSchedulesL(schCountOld, schSize); + + iSchTestActive->TransferCommandSyncL(EScheduleAllL, *iSelection, ETrue); + + //delete the schedule + + iSchTestActive->TransferCommandSyncL(EDeleteScheduleL, *iSelection, ETrue); + + DisplayAllSchedulesL(schCountNew, schSize); + +// AssertL (schCountNew <= schCountOld); + + //deleted message should now be suspended + + iMsvEntry->SetEntryL(testMessage1); + AssertL (iMsvEntry->Entry().SendingState()==KMsvSendStateSuspended); + iMsvEntry->SetEntryL(testMessage2); + AssertL (iMsvEntry->Entry().SendingState()==KMsvSendStateSuspended); + iMsvEntry->SetEntryL(testMessage3); + AssertL (iMsvEntry->Entry().SendingState()==KMsvSendStateSuspended); + + CleanupStack::PopAndDestroy(3);//testMessages + } + +void CSchSendTest::TestDeletingNonScheduledMessagesL() + { + //make a message but don't schedule it + TMsvEntry entry; + TTime t; + t.HomeTime(); + t += TTimeIntervalDays(1); + TMsvId testMessage = CreateMessageLC(entry, KMsvGlobalInBoxIndexEntryId, t); + + //delete the message from the scheduler + iSelection->ResizeL(0); + iSelection->AppendL(testMessage); + + iSchTestActive->TransferCommandSyncL(EDeleteScheduleL, *iSelection, ETrue); + + //deleted message should now be suspended + + iMsvEntry->SetEntryL(testMessage); + AssertL (iMsvEntry->Entry().SendingState()==KMsvSendStateSuspended); + + CleanupStack::PopAndDestroy();//testMessage + } + +void CSchSendTest::TestCheckScheduleL() + { + //make a message and schedule it at T1 + TMsvEntry entry; + TTime t1; + t1.HomeTime(); + t1 += TTimeIntervalHours(1); + TMsvId testMessage = CreateMessageLC(entry, KMsvGlobalInBoxIndexEntryId, t1); + + iSchTestActive->TransferCommandSyncL(EScheduleAllL, *iSelection, ETrue); + + //change the date in the message to T2 + + TTime t2 = t1 + TTimeIntervalHours(1); + ChangeMessageTimeL(testMessage, t2); + + //check the schedule + iSchTestActive->TransferCommandSyncL(ECheckScheduleL, *iSelection, ETrue); + + //the date should now be T1 + + iMsvEntry->SetEntryL(testMessage); + //TMsvEntry newEntry = iMsvEntry->Entry(); + + //AssertL(newEntry.iDate == t1); // not implemented yet + + CleanupStack::PopAndDestroy();//testMessage + } + +// leaves unless the test leaves with KErrNoMemory for every memory failure +const TSchSendTestProgress& CSchSendTest::TestL(TSchSendTestOperation aOp, + CMsvEntrySelection& aSel, + TBool aBool /*= EFalse*/) + { + TInt error = KErrNone; + if (iHeapTest) + { + iSchTestActive->TransferCommandSyncL(ESetIncrementalHeapFailure, *iSelection, ETrue); + do + { + + TRAP(error, + iSchTestActive->TransferCommandSyncL(aOp, aSel, aBool); + ); + + } while(error == KErrNoMemory); + + iSchTestActive->TransferCommandSyncL(ENoIncrementalHeapFailure, *iSelection, ETrue); + + User::LeaveIfError(error); + return iSchTestActive->Progress(); + } + else + { + return iSchTestActive->TransferCommandSyncL(aOp, aSel, aBool); + } + } + +// Returns true if the test does not leave +// Also if the test leaves with KErrNone, but that would be pathological. + +// Logs the test start/finish messages +TBool CSchSendTest::DoTest(void (CSchSendTest::*aTest)(), TPtrC aText) + { + TestStart(++iCurrentTest, aText); + TRAPD(err, (this->*aTest)()); + TestFinish(iCurrentTest, err); + return (err == KErrNone); + } + +TBool CSchSendTest::HeapTest(void (CSchSendTest::*aTest)(), TPtrC aText) + { + TestStart(++iCurrentTest, aText); +// WriteComment(aText); + iHeapTest = ETrue; + TRAPD(err, (this->*aTest)()); + TestFinish(iCurrentTest, err); + iHeapTest = EFalse; + return (err == KErrNone); + } +