// Copyright (c) 1997-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:

//

#ifndef __CALTESTLIB_H__

#define __CALTESTLIB_H__

#include <badesca.h>

#include <e32base.h>

#include <hal.h>

#include <f32file.h>

#include <e32test.h>

#include <calprogresscallback.h>

#include <calentry.h>

#include <coreappstest/testserver.h>

#include <caldataexchange.h>

#include <asclisession.h>

#include <asshdalarm.h>

class CCalSession;

class CCalEntry;

class CCalEntryView;

class CCalInstance;

class CCalInstanceView;

class CCalIter;

_LIT8(KDefaultTimeZone, "Europe/London");

_LIT(KCalTestLibMutex, "CalTestLib_GlobalMutex");

class CCalDataExchange;

class CSetTimezone : public CActive

	{

public:

	static CSetTimezone* NewL(const TDesC8& aZoneId, RPIMTestServer* aPIMTestServer);

	~CSetTimezone();

	void Start();

	// from CActive

	void RunL();

	void DoCancel();

private:

	void ConstructL(const TDesC8& aZoneId, RPIMTestServer* aPIMTestServer);

	CSetTimezone();

	RPIMTestServer* iPIMTestServer; // Not owned

	HBufC8* iZoneId;

	TInt8 iStep;

	};

/**  This is the Calendar Test Library class for Unit testing

@internalComponent

@test

*/

class CCalTestLibrary : public CBase, public MCalProgressCallBack

	{

public:

// Implementation of MCalProgressCallBack interface

	void Progress(TInt /*aPercentageCompleted*/);

	void Completed(TInt /*aError*/);

	TBool NotifyProgress();

// Constructor / Destructor

	// In its destructor, the current opened calendar file will be closed and deleted

	IMPORT_C ~CCalTestLibrary();

	// To be used by most of test code, if it does not contains any asynchronous task. 

	// Use the following functions to create an object. It will start the alarm console alert server.

	IMPORT_C static CCalTestLibrary* NewL(TBool aDelFileFlag=ETrue);

	IMPORT_C static CCalTestLibrary* NewLC(TBool aDelFileFlag=ETrue);	

// File handling

	// Return a file handle.

	IMPORT_C RFs& FileSession();

	// Create a calendar file. It leaves if the file exists.

	IMPORT_C void CreateFileL(const TDesC& aFileName);

	// Create a calendar file. It will overwrite the existing file.

	IMPORT_C void ReplaceFileL(const TDesC& aFileName);

	// Open a calendar file.

	IMPORT_C void OpenFileL(const TDesC& aFileName, TBool aDelFileFlag=EFalse);

	// Delete either a file which is in server's private directory by default or any other file in public directory.

	IMPORT_C void DeleteFileL(const TDesC& aFileName, TBool aIsCalFile = ETrue);

	// Used to append the file to the delete list

	IMPORT_C void RegisterCalFileL(const TDesC& aFileName);

// Session and Views handling

	// To be used by both synchronous  and asynchronous test.

	IMPORT_C CCalSession& GetSession();

	// The following functions cause index building.

	// They should be used by asynchronous test. 

	// There is no guarantee that the views are ready to use when the function returns. 

	// The test code should use the call back function to be notified when the building index is completed.

	IMPORT_C CCalEntryView& AsynCGetEntryViewL();

	IMPORT_C CCalInstanceView& AsynCGetInstanceViewL();

	// The following functions cause index building.

	// They should be used by synchronous test. 

	// The views are ready to be used when the function returns.

	// Those two functions can be called as many times as you like.

	IMPORT_C CCalEntryView& SynCGetEntryViewL();

	IMPORT_C CCalInstanceView& SynCGetInstanceViewL();	

	// Delete entry and instance views

	IMPORT_C void DeleteViews();

// Entry handling

	// Create a GS entry. The uid of the entry will be filled with some random letters if aUid is NULL, otherwise, it use the uid specified.

	IMPORT_C CCalEntry* CreateCalEntryL(CCalEntry::TType aType, HBufC8*& aUid);

	// Set start and end time according to the type of the entry. It will set an random time its start\end time if it is not specified.

	IMPORT_C static void SetEntryStartAndEndTimeL(CCalEntry* entry, const TTime& aStartTime=Time::NullTTime(), const TTime& aEndTime=Time::NullTTime(), TInt aYear = 2000);

	// Fill the descriptor with some random letters.

	IMPORT_C void RandomText(TDes& aText, TBool aPossibleNulDes = EFalse);

	IMPORT_C void RandomText8(TDes8& aText,TBool aPossibleNulDes = EFalse);

	IMPORT_C void CleanDatabaseL();

	IMPORT_C CCalIter& GetIterL();

// Provide access to test server for time setting and file operations

	IMPORT_C RPIMTestServer& PIMTestServer();

// Useful utility functions

	IMPORT_C void StoreEntryL(const CCalEntry& aEntry);

	IMPORT_C void FetchAllInstancesL(RPointerArray<CCalInstance>& aInstances);

	IMPORT_C void OutputInstanceDataL(const RPointerArray<CCalInstance>& aInstances);

	/* Import / Export utility functions */

	IMPORT_C void CreateTestFileL(const TDesC8& aVCalData, const TDesC& aFileName);	

	IMPORT_C void ImportL(const TDesC& aImportVCalendarFile, RPointerArray<CCalEntry>& aEntriesImported);

	IMPORT_C void ImportL(const TDesC8& aVCalendar, RPointerArray<CCalEntry>& aEntriesImported);

	IMPORT_C void ExportL(const TDesC& aExportVCalendarFile, RPointerArray<CCalEntry>& aEntriesExported);

	IMPORT_C CCalDataExchange& DataExchangeL();

	IMPORT_C CTestRegister& TestRegister();

	IMPORT_C void SetTimeZoneL(const TDesC8& aZoneName);

	//Used for closing the agenda serve

	IMPORT_C void CloseAgendaServer();

	IMPORT_C static void WaitForAgendaServerClose();

//Used for reconnecting the agnda server after it has been closed

	IMPORT_C void ConnectAgendaServerL();

#if __WINS__	

	IMPORT_C static void StartAlarmServerL();	

#endif	

	IMPORT_C TBool WaitForAlarmEvent(TAlarmId aAlarmId, TAlarmChangeEvent aExpectedEvent, TAlarmState aExpectedState, TInt aTimeout);

protected:

// Constructor

	// To be used by derived classes.

	IMPORT_C CCalTestLibrary(TBool aDelFileFlag=ETrue);

	// BaseConstructL(), which starts the alarm console alert server, should be called in the constructor of the derived class.

	// Typically, it is the case that the test contains some asynchronous behaviour.	

	IMPORT_C void BaseConstructL();

private:

// No copy constructor and assignment operator

	CCalTestLibrary(CCalTestLibrary& );

	CCalTestLibrary& operator = (const CCalTestLibrary& );

	void OpenCalendarSessionL(TBool aRefCountExists=ETrue);

	void CloseCalendarSession(TBool aWaitForAgendaToClose=ETrue);

public:

	IMPORT_C void __dbgClearTzClientCacheL(TBool aRestartCaching);	

private:

// Member data

	RPIMTestServer		iPIMTestServer;

	CCalSession*		iSession;

	CCalInstanceView*	iInstanceView;

	CCalEntryView*		iEntryView;

	CCalIter*			iIter;

	CCalDataExchange*	iDataExchange;

	CTestRegister*		iTestRegister;

	TInt64				iSeed;

	RFs					iFs;

	RChunk				iChunk;

	TInt*				iRefCount;

	TInt				iCompletedError;

	CDesCArray*			iFilesToDel;

	TBool				iDelFileFlag;

	RMutex				iChunkMutex;

	RASCliSession		iAlarmServer;

	};

/** Template class for cleanup that needs ResetAndDestroy or Reset to be called

@internalComponent

@test

@code

To be used in the following way:

	// array to store the loaded instances

	RPointerArray<CCalInstance> instanceArray;

	CleanupResetAndDestroyPushL(instanceArray);

	iTestLibrary->SynCGetInstanceViewL().FindInstanceL(instanceArray, CalCommon::EIncludeAll, timeRange);

	CleanupStack::PopAndDestroy(&instanceArray);

@endcode

*/

template<class T> class CleanupResetAndDestroy

	{

public:

	static inline void PushL(T& aRef);

private:

	static void ResetAndDestroy(TAny* aPtr);

	};

// CleanupResetAndDestroy

template <class T> inline void CleanupResetAndDestroy<T>::PushL(T& aRef)

	{

	CleanupStack::PushL(TCleanupItem(&ResetAndDestroy, &aRef));

	}

template <class T> void CleanupResetAndDestroy<T>::ResetAndDestroy(TAny *aPtr)

	{

	(static_cast<T*>(aPtr))->ResetAndDestroy();

	}

template <class T> inline void CleanupResetAndDestroyPushL(T& aRef)

	{

	CleanupResetAndDestroy<T>::PushL(aRef);

	}	

/** Performance timer measurement class

@internalComponent

@test

@code

To be used in the following way:

	static RTest test(_L("The test"));

	<snip>

	TPerformanceTimer timer(test);

	timer.Start();

	<blah blah>

	timer.Stop();

	test.Printf(_L("Done\n"));	

	// printout the time it took to do <blah blah>

	timer.PrintOut();

@endcode	

*/

class TPerformanceTimer

	{

public:

	IMPORT_C TPerformanceTimer(RTest& aTest);

	IMPORT_C void Start();

	IMPORT_C void Stop();

	IMPORT_C void PrintOut() const;

	IMPORT_C TTimeIntervalMicroSeconds32 ElapsedTime() const;

private:

	RTest& iTest;

	TUint iStartTickCount;

	TUint iEndTickCount;

	};

#endif