--- /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 <calalarm.h>
+#include <calcontent.h>
+
+/**
+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<CCalEntry>* pointerArray = static_cast<RPointerArray<CCalEntry>*> (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<CCalEntry> 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<CCalEntry>& 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 "<section-name>.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<CCalEntry>& 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<CCalEntry::TType>(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);
+		}
+	}