diff -r 000000000000 -r 2e3d3ce01487 commonappservices/alarmservertest/TestMultipleAlarmsSuite/src/TestCreateCalEntriesStep.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/commonappservices/alarmservertest/TestMultipleAlarmsSuite/src/TestCreateCalEntriesStep.cpp Tue Feb 02 10:12:00 2010 +0200 @@ -0,0 +1,481 @@ +// 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: +// Contains implementation of CTestCreateCalEntriesStep class +// +// + +/** + @file + @internalTechnology +*/ + +// User Include +#include "TestCreateCalEntriesStep.h" +#include "ProgressCallBack.h" + +// System Includes +#include +#include + +/** +Constructor. Sets the test step name. Testserver reference passed to make use +of TEF's method of sharing data between test steps +@internalTechnology +@test +*/ +CTestCreateCalEntriesStep::CTestCreateCalEntriesStep(CTestMultipleAlarmsServer& aTestServer) +: CTestBaseStep(aTestServer) + { + //Call base class method to set human readable name for test step + SetTestStepName(KTestCreateCalEntriesStep); + } + +/** +Call back to destroy the pointer array +@param aPtr Pointer to the pointer array +@internalTechnology +@test +*/ +LOCAL_C void DestroyPointerArray(TAny* aPtr) + { + RPointerArray* pointerArray = static_cast*> (aPtr); + pointerArray->ResetAndDestroy(); + pointerArray->Close(); + } + +/** +Base class pure virtual. +@return EPass or EFail indicating the result of the test step. +@internalTechnology +@test +*/ +TVerdict CTestCreateCalEntriesStep::doTestStepL() + { + CActiveScheduler* sched = new(ELeave) CActiveScheduler; + CActiveScheduler::Install(sched); + + TRAPD(error, CreateCalEntriesL()); + PrintIfError(KCreateEntriesError(), error); + + delete sched; + return TestStepResult(); + } + +/** +Creates the calendar entries +@internalTechnology +@test +*/ +void CTestCreateCalEntriesStep::CreateCalEntriesL() + { + TInt numOfEntries = 0; + TPtrC subsections; + + CCalSession* calSession = CreateAndInitializeCalSessionL(ETrue); + CleanupStack::PushL(calSession); + CCalEntryView* calEntryView = CreateEntryViewL(calSession); + CleanupStack::PushL(calEntryView); + + ReadIntsFromConfig(ConfigSection(), &KIniNumOfEntries(), &numOfEntries, NULL); + ReadStringsFromConfig(ConfigSection(), &KIniSubsections(), &subsections, NULL); + if(numOfEntries <= 0) + { + IniProblem(); + } + else + { + RPointerArray entryArray; + CleanupStack::PushL(TCleanupItem(DestroyPointerArray, &entryArray)); + + // Fill the array with entries + if(subsections.Compare(KYes) == KErrNone) + { + FillCalEntriesFromSubSectionsL(entryArray, numOfEntries); + } + else + { + FillCalEntriesAtWillL(entryArray, numOfEntries); + } + + // Store the entries + TInt actualNumOfEntries; + calEntryView->StoreL(entryArray, actualNumOfEntries); + // Check result + CompareAndPrintResult(numOfEntries, actualNumOfEntries); + CleanupStack::PopAndDestroy(&entryArray); + } + CleanupStack::PopAndDestroy(2, calSession); // calEntryView and calSession + } + +/** +Constructs the sub-section name +@param aSubSectionName The descriptor which is to hold the sub-sec name +@param aSubSectionNo The sub section number +@internalTechnology +@test +*/ +void CTestCreateCalEntriesStep::GetSubSectionName(HBufC*& aSubSectionName, const TInt& aSubSectionNo) + { + aSubSectionName->Des().Copy(ConfigSection()); + aSubSectionName->Des().Append(KDot); + aSubSectionName->Des().Append(KEntry); + aSubSectionName->Des().AppendNum(aSubSectionNo); + } + + +/** +Reads the ini sub-sections, initializes the calendar entries and fills the pointer +array passed as parameter +@param aEntryArray Pointer array to be filled with the entries +@param aNumOfEntries No. of entries to be created, so as to loop through the +ini sub-sections +@internalTechnology +@test +*/ +void CTestCreateCalEntriesStep::FillCalEntriesFromSubSectionsL(RPointerArray& aEntryArray, const TInt& aNumOfEntries) + { + TPtrC typeOfEntry; + TPtrC gUId; + TPtrC alarmMessage; + TInt alarmMinsFromNow = 0; + + TTime now; + now.HomeTime(); + + // Create a HBufC enough to hold the 'sub-section' name + // which looks like ".entry<#>" + HBufC* sectionName = HBufC::NewLC(ConfigSection().Length() + KEntry().Length() + 4); + for(TInt sub = 1; sub <= aNumOfEntries; ++sub) + { + GetSubSectionName(sectionName, sub); + if(GetCalEntryDetails(*sectionName, typeOfEntry, gUId, alarmMessage, alarmMinsFromNow)) + { + CCalEntry* entry = CreateCalEntryL(GetEntryTypeL(typeOfEntry), gUId, alarmMessage); + CleanupStack::PushL(entry); + if(entry != NULL) + { + aEntryArray.AppendL(entry); + } + // The memory pointed to by entry will be destroyed when this + // array is destroyed, which is already in the CleanupStack + CleanupStack::Pop(entry); + + // Set alarm + SetCalTimesL(entry, now, alarmMinsFromNow); + CCalAlarm* calAlarm = CreateCalAlarmL(*sectionName, alarmMinsFromNow); + CleanupStack::PushL(calAlarm); + + entry->SetAlarmL(calAlarm); + + CleanupStack::PopAndDestroy(calAlarm); + } + else + { + IniProblem(); + // We still dont return as other sub-sections might be proper. + // The test step result will be EFail though + } + } + CleanupStack::PopAndDestroy(sectionName); + } + +/** +Creates a set of test entries. Can be used to create a large no. of +entries arbitrarily without having to take the pain of mentioning the +details of all the entries in the ini file. +@param aEntryArray Pointer array to be filled with the entries +@param aNumOfEntries No. of entries to be created, so as to loop through the +ini sub-sections +@internalTechnology +@test +*/ +void CTestCreateCalEntriesStep::FillCalEntriesAtWillL(RPointerArray& aEntryArray, const TInt& aNumOfEntries) + { + _LIT(KTestGUId, "testguid%D@test.com"); + _LIT(KTestMessage, "testentry%D"); + + CCalEntry::TType typeOfEntry; + TBuf<30> gUId; + TBuf<15> alarmMessage; + TInt alarmMinsFromNow = 1; + + // In this case, same calalarm will be used by all the entries + CCalAlarm* calAlarm = CreateCalAlarmL(ConfigSection(), alarmMinsFromNow); + CleanupStack::PushL(calAlarm); + + TTime now; + now.HomeTime(); + + for(TInt num = 1; num <= aNumOfEntries; ++num) + { + // typeofentry will alternate between the 5 types of entries + typeOfEntry = static_cast(num % CCalEntry::EAnniv); + + gUId.Format(KTestGUId, num); + alarmMessage.Format(KTestMessage, num); + + CCalEntry* entry = CreateCalEntryL(typeOfEntry, gUId, alarmMessage); + CleanupStack::PushL(entry); + aEntryArray.AppendL(entry); + + // The memory pointed to by entry will be destroyed when the + // array is destroyed, which is already in the CleanupStack + CleanupStack::Pop(entry); + + SetCalTimesL(entry, now, alarmMinsFromNow); + + entry->SetAlarmL(calAlarm); + + } + CleanupStack::PopAndDestroy(calAlarm); + } + +/** +Reads the specified values from ini +@param aSectionName The section name to read from +@param aTypeOfEntry Will hold the type of entry (appt/entry/todo/event) +@param aGUId Will hold the GUID of the entry +@param aAlarmMessage Will hold the message associated with the alarm +@param aAlarmMinsFromNow Will hold the minutes from now, when the alarm has to +expire +@internalTechnology +@test +*/ +TBool CTestCreateCalEntriesStep::GetCalEntryDetails(const TDesC& aSectionName, TPtrC& aTypeOfEntry, TPtrC& aGUId, TPtrC& aAlarmMessage, TInt& aAlarmMinsFromNow) + { + if(ReadStringsFromConfig(aSectionName, &KIniTypeOfEntry(), &aTypeOfEntry, + &KIniGUId(), &aGUId, + &KIniAlarmMessage(), &aAlarmMessage, NULL) + && ReadIntsFromConfig(aSectionName, &KIniAlarmMinsFromNow(), &aAlarmMinsFromNow, NULL)) + { + return ETrue; + } + return EFalse; + } + +/** +Creates a calendar entry +@param aTypeOfEntry The type of entry +@param aGUId The GUID of the entry +@param aAlarmMessage The Summary of the entry +@internalTechnology +@test +*/ +CCalEntry* CTestCreateCalEntriesStep::CreateCalEntryL(const CCalEntry::TType& aTypeOfEntry, const TDesC& aGUId, const TDesC& aAlarmMessage) + { + HBufC8* gUID8 = HBufC8::NewLC(aGUId.Length()); + gUID8->Des().Copy(aGUId); + CCalEntry* entry = CCalEntry::NewL(aTypeOfEntry, gUID8, CCalEntry::EMethodNone, 0); + CleanupStack::Pop(gUID8); + CleanupStack::PushL(entry); + + // The summary will be displayed when alarm is playing. + // This summary is considered as the one that uniquely identifies the + // entry/alarm for the purpose of this testing. Hence the message of + // each entry in the ini file must be unique. + entry->SetSummaryL(aAlarmMessage); + + CleanupStack::Pop(entry); + return entry; + } + +/** +Sets the start and end time of the entry and the alarm, all relative to the +current time, so that the alarms are imminent ones +@param aEntry Reference to a pointer to the entry +@param aNow The time value, on which the calculation is to be based upon +@param aAlarmMinsFromNow The number of minutes after which we desire the alarm +to expire. For example if aAlarmMinsFromNow = 1, then start time of the entry will +be calculated as 2 minutes from NOW and alarm offset will be 1 minute before +the start time +@internalTechnology +@test +*/ +void CTestCreateCalEntriesStep::SetCalTimesL(CCalEntry*& aEntry, const TTime aNow, const TInt& aAlarmMinsFromNow) + { + iCalStartTime.SetTimeLocalL(aNow + TTimeIntervalMinutes(2 * aAlarmMinsFromNow)); + if(aEntry->EntryTypeL() == CCalEntry::ETodo) + { + iCalEndTime = iCalStartTime; + } + else + { + iCalEndTime.SetTimeLocalL(iCalStartTime.TimeLocalL() + TTimeIntervalHours(1)); + } + + aEntry->SetStartAndEndTimeL(iCalStartTime, iCalEndTime); + } + +/** +Creates the cal-alarm +@param aSectionName Section name in the ini +@param aAlarmMinsFromNow The number of minutes after which we desire the alarm +to expire. +@return Pointer to the cal-alarm +@internalTechnology +@test +*/ +CCalAlarm* CTestCreateCalEntriesStep::CreateCalAlarmL(const TDesC& aSectionName, const TInt& aAlarmMinsFromNow) + { + TPtrC aAlarmSoundName; + CCalAlarm* calAlarm = CCalAlarm::NewL(); + CleanupStack::PushL(calAlarm); + calAlarm->SetTimeOffset(aAlarmMinsFromNow); + + if(ReadStringsFromConfig(aSectionName, &KIniAlarmSoundName(), &aAlarmSoundName, NULL)) + { + calAlarm->SetAlarmSoundNameL(aAlarmSoundName); + } + + SetAlarmContentL(aSectionName, calAlarm); + + CleanupStack::Pop(calAlarm); + return calAlarm; + } + +/** +Attaches the associated data for the alarm if require ini field exists, +else simply returns +@param aSectionName Section name in the ini +@param aCalAlarm Reference to a pointer to the CalAlarm +@internalTechnology +@test +*/ +void CTestCreateCalEntriesStep::SetAlarmContentL(const TDesC& aSectionName, CCalAlarm*& aCalAlarm) + { + TPtrC typeOfAD; + if(!ReadStringsFromConfig(aSectionName, &KIniTypeOfAD(), &typeOfAD, NULL)) + {// No associated data to be attached + return; + } + else + { + INFO_PRINTF1(_L("Attaching associated data...")); + DoSetAlarmContentL(typeOfAD, aSectionName, aCalAlarm); + } + } + +/** +Attaches the associated data for the alarm +If the type of AD is URL, it attaches the URL value passed from the ini +If it is MIME, then it expects a filename from the ini file, from which data will +be read into a descriptor and attached with the alarm +@param aTypeOfAD Type of associated data, can be either url or mime +@param aSectionName Section name in the ini +@param aCalAlarm Reference to a pointer to the CalAlarm +@internalTechnology +@test +*/ +void CTestCreateCalEntriesStep::DoSetAlarmContentL(const TPtrC& aTypeOfAD, const TDesC& aSectionName, CCalAlarm*& aCalAlarm) + { + TPtrC mimeType; + if(!ReadStringsFromConfig(aSectionName, &KIniContentType(), &mimeType, NULL)) + { + IniProblem(); + return; + }; + // Convert read MIME type from unicode to 8-bit data. + HBufC8* mimeType8 = HBufC8::NewL(mimeType.Length()); + mimeType8->Des().Copy(mimeType); + CleanupStack::PushL(mimeType8); + + HBufC8* content8 = NULL; + CCalContent::TDisposition disposition = CCalContent::EDispositionUnknown; + if(aTypeOfAD.Compare(KIniUrl) == 0) + { + TPtrC url; + if(!ReadStringsFromConfig(aSectionName, &KIniUrl(), &url, NULL)) + { + CleanupStack::PopAndDestroy(mimeType8); + IniProblem(); + return; + }; + // Convert read url from unicode to 8-bit data. + content8 = HBufC8::NewL(url.Length()); + content8->Des().Copy(url); + disposition = CCalContent::EDispositionUrl; + } + else if(aTypeOfAD.Compare(KIniMime) == KErrNone) + { + TPtrC fileName; + if(!ReadStringsFromConfig(aSectionName, &KIniFileName(), &fileName, NULL)) + { + CleanupStack::PopAndDestroy(mimeType8); + IniProblem(); + return; + }; + GetAlarmContentFromFileL(fileName, content8); + disposition = CCalContent::EDispositionInline; + } + CleanupStack::PushL(content8); + + CCalContent* alarmAction = CCalContent::NewL(); + CleanupStack::PushL(alarmAction); + alarmAction->SetContentL(content8, mimeType8, disposition); //Takes ownership of content8 & mimeType8 + CleanupStack::Pop(alarmAction); + CleanupStack::Pop(content8); + CleanupStack::Pop(mimeType8); + + aCalAlarm->SetAlarmAction(alarmAction); // Takes ownership of alarmAction + } + +/** +Returns the appropriate enumeration based on the entry type string passed +@param aTypeString The entry type string +@return The appropriate enumeration +@internalTechnology +@test +*/ +CCalEntry::TType CTestCreateCalEntriesStep::GetEntryTypeL(const TDesC& aTypeString) + { + CCalEntry::TType entryType = CCalEntry::EAppt; + HBufC* typeBuf = aTypeString.AllocL(); + typeBuf->Des().LowerCase(); + if(typeBuf->Des().Compare(KTodo) == KErrNone) + { + entryType = CCalEntry::ETodo; + } + else if(typeBuf->Des().Compare(KEvent) == KErrNone) + { + entryType = CCalEntry::EEvent; + } + else if(typeBuf->Des().Compare(KReminder) == KErrNone) + { + entryType = CCalEntry::EReminder; + } + else if(typeBuf->Des().Compare(KAnniversary) == KErrNone) + { + entryType = CCalEntry::EAnniv; + } + delete typeBuf; + return entryType; + } + +/** +Compares the no. of entries we tried to create with that of the actual +entries created and prints the result +@param aTriedNum The no. of entries we tried to create +@param aActualNum The no. of successful entries actually created +@internalTechnology +@test +*/ +void CTestCreateCalEntriesStep::CompareAndPrintResult(const TInt& aTriedNum, const TInt& aActualNum) + { + INFO_PRINTF3(_L("Num of entries tried to create = %D, actually created = %D"), aTriedNum, aActualNum); + if(aTriedNum != aActualNum) + { + INFO_PRINTF1(_L("Could not create one or more entries...Failing the test")); + SetTestStepResult(EFail); + } + }