// Copyright (c) 2002-2010 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 t_logutil2_h

 #define t_logutil2_h

 #include <e32test.h>

 #include <s32file.h>

 #include <logcli.h>

 #include <logengdurations.h>

 #include <logengevents.h>

 #include <logwraplimits.h>

 #include <logfilterandeventconstants.hrh>

 #include <e32base.h>

 #include <f32file.h>

 #include <logviewchangeobserver.h>

 #include <logclientchangeobserver.h>

 #include "LogChangeDefinition.h"

 #include "LogServShared.h"

 #include "LogCliServShared.h"

 #include <babackup.h>

 #include "t_logservsession.h"

 #include "logcntdef.h"

 #include "t_logutil.h"

 #ifdef LOGGING_ENABLED

 #include <f32file.h>

 #include <flogger.h>

 _LIT(KLogFileName, "LogEng.txt");

 _LIT(KLogFolder,   "LogEng");

 _LIT(KTimeFormat, "%02d.%02d:%02d:%06d    ");

 _LIT(KTextFormat, "%S");

 const TInt KLogEngLogBufferSize = 256;

 class Log : public RFileLogger

 	{

 public:

 	static void New();

 	static void Write(const TDesC& aText);

 	static void WriteFormat(TRefByValue<const TDesC> aFmt, ...);

 private:

 	static void PruneLogFile();

   };

 #define LOGNEW							Log::New()

 #define LOGTEXT(AAA)					{ _LIT(KString, AAA); Log::Write(KString); }

 #define LOGTEXT2(AAA, BBB)				{ _LIT(KString, AAA); Log::WriteFormat(TRefByValue<const TDesC>(KString()), BBB); }

 #define LOGTEXT3(AAA, BBB, CCC)			{ _LIT(KString, AAA); Log::WriteFormat(TRefByValue<const TDesC>(KString()), BBB, CCC); }

 #define LOGTEXT4(AAA, BBB, CCC, DDD)	{ _LIT(KString, AAA); Log::WriteFormat(TRefByValue<const TDesC>(KString()), BBB, CCC, DDD); }

 #else//LOGGING_ENABLED

 #define LOGNEW

 #define LOGTEXT(AAA)

 #define LOGTEXT2(AAA, BBB)

 #define LOGTEXT3(AAA, BBB, CCC)

 #define LOGTEXT4(AAA, BBB, CCC, DDD)

 #endif//LOGGING_ENABLED

 // Globals 

 GLREF_D CTrapCleanup* theCleanup;

 GLREF_D CActiveScheduler *testScheduler;

 GLREF_D RFs theFs;

 GLREF_D TFileName theLogName;

 GLREF_D RFile theLog;

 GLREF_D RLogTestSession theLogServ;

 #define __FILE_FAILNEXT(err, iteration) theFs.SetErrorCondition(err, iteration)

 #define __FILE_RESET theFs.SetErrorCondition(KErrNone, 0)

 #if defined(_UNICODE)

 	_LIT(KLogDatabaseName,"c:\\private\\101f401d\\Logdbu.dat");

 #else

 	_LIT(KLogDatabaseName,"c:\\private\\101f401d\\Logdb.dat");

 #endif

 //**********************************

 // CTestActive

 //**********************************

 class CTestActive : public CActive

 	{

 public:

 	CTestActive(TInt aPriority = EPriorityIdle-100);

 	~CTestActive();

 	void StartL();

 	void StartL(TInt);

 protected:

 	void DoCancel();

 	void RunL();

 private:

 	TBool iDelayCompletion;

 	TRequestStatus iStoredStatus;

 	TInt iDelayTime;

 	};

 void doTestsL();

 //**********************************

 // CTestTimer

 //**********************************

 class CTestTimer : public CTimer

 	{

 public:

 	static CTestTimer* NewL();

 private:

 	CTestTimer();

 	void RunL();	

 	};

 //**********************************

 // TestUtils

 //**********************************

 class TestUtils

 	{

 public:

 	static void Initialize(const TDesC& aName);

 	static void DeleteDatabaseL(TBool aCloseBeforeDelete = ETrue);

 	static HBufC* CreateBufLC(TInt aLength);

 	static HBufC8* CreateBuf8LC(TInt aLength);

 	static TBool FiltersEqual(const CLogFilter& aFilter1, const CLogFilter& aFilter2);

 	static TBool EventsEqual(const CLogEvent& aEvent1, const CLogEvent& aEvent2);

 	static TBool TypesEqual(const CLogEventType& aType1, const CLogEventType& aType2);

 	static TBool WaitForKeyL(TTimeIntervalMicroSeconds32 aDelay, TKeyCode& aKeyCode);

 	static TBool FileExists(const TDesC& aFile);

 	static void SetLogServHeapFailureL(RHeap::TAllocFail aType, TInt aRate);

 	static TBool IsDatabaseOpenL();

 	static TInt DatabaseSizeL();

 	static TInt AddEventL();

 	static void AddViewTestEventsL();

 	static void AddEventTypeL();

 	static void CopyCorruptDbL();

 	static void CopyCorruptDamagedDbL();

 	static void CopyOldDbL();

 	static void TestInvalidSchemaL();

 	static TBool MatchingEnabledL();

 private:

 	// starts t_HiCapHelper.exe which has sufficient capability

     static TInt ExecuteRemoteL(const TDesC& aCommandLineArg);

 	};

 #define __LOGSERV_UHEAP_FAILNEXT(X) TestUtils::SetLogServHeapFailureL(RHeap::EFailNext, X)

 #define __LOGSERV_UHEAP_RESET TestUtils::SetLogServHeapFailureL(RHeap::ENone, 0)

 //**********************************

 // CLogViewChangeObserver

 //**********************************

 class CLogViewChangeObserver : public CActive, public MLogViewChangeObserver

 	{

 public:

 	enum TStopType

 		{

 		EStopOnChanges = 0,

 		EStopOnRunL,

 		EStopOnBoth,

 		EStopOnCount,

 		EDontStopScheduler

 		};

 public:

 	static CLogViewChangeObserver* NewLC();

 	~CLogViewChangeObserver();

 protected:

 	CLogViewChangeObserver();

 public:

 	inline void StartCollectingChanges() 

 		{ 

 		Reset(); 

 		iType = EDontStopScheduler; 

 		}

 	CLogChangeDefinition* WaitForChangesLC(TStopType aType = EStopOnChanges, TInt aCount = 0);

 	CLogChangeDefinition* WaitForChangesLC(TCallBack aCallBack, TStopType aType, TInt aCount = 0);

 	inline TBool HaveChanges() const 

 		{ 

 		return iChanges != NULL; 

 		}

 	inline const CLogChangeDefinition& Changes() const 

 		{ 

 		__ASSERT_ALWAYS(iChanges, User::Invariant()); 

 		return *iChanges; 

 		}

 	inline void SetActive() 

 		{ 

 		CActive::SetActive(); 

 		iStatus = KRequestPending; 

 		}

 	inline void ResetChanges() 

 		{ 

 		__ASSERT_ALWAYS(iChanges, User::Invariant()); 

 		iChanges->Reset(); 

 		}

 public:

 	void HandleLogViewChangeEventAddedL(TLogId aId,   TInt aViewIndex, TInt aChangeIndex, TInt aTotalChangeCount);

 	void HandleLogViewChangeEventChangedL(TLogId aId, TInt aViewIndex, TInt aChangeIndex, TInt aTotalChangeCount);

 	void HandleLogViewChangeEventDeletedL(TLogId aId, TInt aViewIndex, TInt aChangeIndex, TInt aTotalChangeCount);

 private:

 	void RunL();

 	void DoCancel();

 private:

 	void Reset();	 

 protected:

 	void CheckForSchedulerStop();

 	void AddChangeL(TLogDatabaseChangeType aType, TLogId aId, TInt aViewIndex);

 private:

 	TInt iExpectedChangeCount;

 	TBool iHaveFinishedOperation;

 	TBool iHaveObtainedChanges;

 	TBool iSchedulerStarted;

 	TStopType iType;

 	CLogChangeDefinition* iChanges;

 	TBool iHaveCallBack;

 	TCallBack iCallBack;

 	};

 //**********************************

 // CLogViewChangeObserverErrorTest

 //**********************************

 class CLogViewChangeObserverErrorTest : public  CLogViewChangeObserver 

 	{

 public:

 	static CLogViewChangeObserverErrorTest* NewLC();

 private:

 	CLogViewChangeObserverErrorTest();

 public:

 	void HandleLogViewChangeEventAddedL(TLogId aId,   TInt aViewIndex, TInt aChangeIndex, TInt aTotalChangeCount);

 	};

 //**********************************

 // CLogSchedulerTimer

 //**********************************

 class CLogSchedulerTimer : public CTimer

 	{

 public:

 	static CLogSchedulerTimer* NewLC();

 	~CLogSchedulerTimer();

 private:

 	CLogSchedulerTimer();

 	void ConstructL();

 public:

 	void Wait(TTimeIntervalMicroSeconds32 aTime);

 private:

 	void RunL();

 	};

 //**********************************

 // CLogChangeNotifier

 //**********************************

 class CLogChangeNotifier : public CActive

 	{

 public:

 	static CLogChangeNotifier* NewL();

 	~CLogChangeNotifier();

 	//

 private:

 	CLogChangeNotifier();

 	void ConstructL();

 	//

 	void RunL();

 	void DoCancel();

 	//

 private:

 	CLogClient* iClient;

 	TTime iStart;

 	};

 //**********************************

 // Global

 //**********************************

 void SetupSchedulerL();

 void CloseScheduler();

 void doMainL();

 TInt E32Main();

 void DeleteDataFile(const TDesC& aFullName);

 #endif//t_logutil2_h