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

//

#include <bautils.h>

#include "t_logutil2.h"

//Define "TheTest" variable used in the test cpp files

extern RTest TheTest;

_LIT(KHelperExeName, "t_LogHiCapHelper.exe");

//======================================================================================================

#ifdef LOGGING_ENABLED

void Log::New()

	{

	_LIT(KNewLogText, "===== NEW LOG =====");

	//

	RFileLogger logger;

	TInt ret=logger.Connect();

	if	(ret==KErrNone)

		{

		logger.CreateLog(KLogFolder, KLogFileName, EFileLoggingModeOverwrite);

		logger.Write(KNewLogText);

		}

	logger.Close();

	}

void Log::Write(const TDesC& aText)

	{

	PruneLogFile();

	RFileLogger logger;

	TInt ret=logger.Connect();

	if (ret==KErrNone)

		{

		logger.SetDateAndTime(EFalse,EFalse);

		logger.CreateLog(KLogFolder, KLogFileName,EFileLoggingModeAppend);

		TBuf<KLogEngLogBufferSize> buf;

		TTime now;

		now.HomeTime();

		TDateTime dateTime;

		dateTime = now.DateTime();

		buf.Format(KTimeFormat,dateTime.Hour(),dateTime.Minute(),dateTime.Second(),dateTime.MicroSecond());

		buf.AppendFormat(KTextFormat,&aText);

		logger.Write(buf);

		}

	logger.Close();

	}

void Log::WriteFormat(TRefByValue<const TDesC> aFmt, ...)

	{

	VA_LIST list;

	VA_START(list,aFmt);

	PruneLogFile();

	TBuf<2*KLogEngLogBufferSize> buf;

	buf.SetMax();

	buf.FillZ();

	TTime now;

	now.HomeTime();

	TDateTime dateTime;

	dateTime = now.DateTime();

	buf.Format(KTimeFormat,dateTime.Hour(),dateTime.Minute(),dateTime.Second(),dateTime.MicroSecond());

	buf.AppendFormatList(aFmt, list );

	RFileLogger logger;

	TInt ret=logger.Connect();

	if (ret==KErrNone)

		{

		logger.SetDateAndTime(EFalse,EFalse);

		logger.CreateLog(KLogFolder, KLogFileName,EFileLoggingModeAppend);

		logger.Write(buf);

		}

	logger.Close();

	}

void Log::PruneLogFile()

  	{

	const TInt KMaxLogSize = 1024 * 500;

	_LIT(KDriveLetter, "C:\\Logs\\");

	//

	TFileName fileName(KDriveLetter);

	fileName.Append(KLogFolder);

	fileName.Append(KLogFileName);

	//

	RFs fsSession;

	if	(fsSession.Connect() == KErrNone)

		{

		TEntry entry;

		if	(fsSession.Entry(fileName, entry) == KErrNone)

			{

			// Check size and delete if its too big

			if	(entry.iSize >= KMaxLogSize)

				fsSession.Delete(fileName); // ignore error

			}

		}

	fsSession.Close();

	}

#endif

// Globals 

GLDEF_D CTrapCleanup* theCleanup;

GLDEF_D CActiveScheduler *testScheduler;

GLDEF_D RFs theFs;

GLDEF_D TFileName theLogName;

GLDEF_D RFile theLog;

GLDEF_D RLogTestSession theLogServ;

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

// CTestActive

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

CTestActive::CTestActive(TInt aPriority)

:	CActive(aPriority)

	{

	CActiveScheduler::Add(this);

	iDelayTime=0;

	}

CTestActive::~CTestActive()

	{

	Cancel();

	}

void CTestActive::DoCancel()

	{

	TRequestStatus* s=&iStatus;

	User::RequestComplete(s, KErrNone);

	}

void CTestActive::StartL()

	{

	iDelayCompletion=EFalse;

	iDelayTime=0;

	iStatus = KRequestPending;

	SetActive();

	}

void CTestActive::StartL(TInt aDelay)

	{

	iDelayCompletion=ETrue;

	iDelayTime=aDelay;

	iStatus = KRequestPending;

	SetActive();

	}

void CTestActive::RunL() 

	{

	if(iDelayCompletion && iDelayTime)

		{

		// Wait for events in other threads to have a go....

		User::After(iDelayTime);

		iDelayTime=0;

		iStoredStatus=iStatus;

		SetActive();

		TRequestStatus* s=&iStatus;

		User::RequestComplete(s, KErrNone);

		}

	else

		{

		if(iDelayCompletion)

			iStatus=iStoredStatus;

		LOGTEXT("CTestActive::RunL() - Stopping the scheduler");

		CActiveScheduler::Stop();

		}

	}

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

// CTestTimer

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

CTestTimer::CTestTimer()

: CTimer(EPriorityLow)

	{}

void CTestTimer::RunL()

	{

	LOGTEXT("CTestTimer::RunL() - Stopping the scheduler");

	CActiveScheduler::Stop();

	}

CTestTimer* CTestTimer::NewL()

	{

	CTestTimer* self = new(ELeave) CTestTimer();

	CleanupStack::PushL(self);

	self->ConstructL(); // CTimer

	CActiveScheduler::Add(self);

	CleanupStack::Pop();

	return self;

	}

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

// TestUtils

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

void TestUtils::Initialize(const TDesC& aName)

	{

	TheTest.Title();

	TheTest.Printf(_L("%S\r\n"), &aName);

    User::RenameThread(aName);

	}

TBool TestUtils::FileExists(const TDesC& aFile)

	{

	TEntry entry;

	return theFs.Entry(aFile, entry) == KErrNone;

	}

//Loads t_loghihelper process and passes for execution to t_loghihelper "aCommandLineArg" command line.

//t_loghihelper will run, execute the command and die, returning the result of the command execution.

//TestUtils::ExecuteRemoteL() will leave if error and return the result of the remote cmd execution to the caller.

TInt TestUtils::ExecuteRemoteL(const TDesC& aCommandLineArg)

	{

	RProcess process;

	LEAVE_IF_ERROR(process.Create(KHelperExeName, aCommandLineArg));

	TRequestStatus status;

	process.Logon(status);

	process.Resume();

	User::WaitForRequest(status);

	TInt exitReason = process.ExitReason();

	process.Close();

	LEAVE_IF_ERROR(exitReason);

	return exitReason;

	}

//Runs t_loghihelper. t_loghihelper will execute the "delete LogEng database" command.

//The "delete LogEng database" is a complex operation. The request is sent via the backup server

//which will send a request to the LogEng server to release the LogEng database file locks and close the file.

//After that the database will be deleted. 

//In the same call the LogEng server will restarted and the LogEng server will re-create the database during the 

//server startup.

//

//If "aCloseBeforeDelete" flag is false, then the database wil be only deleted.

//The default value of "aCloseBeforeDelete" is true: the database will be closed, deleted and re-created.

//But some of the LogEng tests create a CBaBackupSessionWrapper object and call CloseFileL() with the logeng

//database name as a parameter. In this case, if another process, as t_loghicaphelper for example, attempts

//to call CloseFileL() with the same file name as a parameter, then the caller will get KErrServerBusy error.

//See how CBaBackupSessionWrapper::CloseFileL() is implemented on the server side.

void TestUtils::DeleteDatabaseL(TBool aCloseBeforeDelete)

	{

    _LIT(KCmdLine1, "-delete_db1");

    _LIT(KCmdLine2, "-delete_db2");

    (void)ExecuteRemoteL(aCloseBeforeDelete ? KCmdLine1 : KCmdLine2);

	}

//Runs t_loghihelper. t_loghihelper will check and return whether the LogEng database is open or not.  

TBool TestUtils::IsDatabaseOpenL()

	{

	_LIT(KCmdLine, "-db_is_open");

	TInt result = ExecuteRemoteL(KCmdLine);

	return result != 0;

	}

//Runs t_loghihelper. t_loghihelper will add an event type to the LogEng database.  

void TestUtils::AddEventTypeL()

	{

	_LIT(KCmdLine, "-add_event_type");

	(void)ExecuteRemoteL(KCmdLine);

	}

//Runs t_loghihelper. t_loghihelper will add an event to the LogEng database.  

TInt TestUtils::AddEventL()

	{

	_LIT(KCmdLine, "-add_event");

	return ExecuteRemoteL(KCmdLine);		

	}

//Runs t_loghihelper. t_loghihelper will add events to the LogEng database.  

void TestUtils::AddViewTestEventsL()

	{

	_LIT(KCmdLine, "-add_view_test_events");

	(void)ExecuteRemoteL(KCmdLine);

	}

//Runs t_loghihelper. t_loghihelper will return the size of the LogEng database.  

TInt TestUtils::DatabaseSizeL()

	{

	_LIT(KCmdLine, "-db_size");

	return ExecuteRemoteL(KCmdLine);		

	}	

//Runs t_loghihelper. t_loghihelper will replace the LogEng database with a corrupted database (for testing purposes).

//The LogEng server will be stopped before that. The function can be used only in debug mode.

#ifdef _DEBUG

void TestUtils::CopyCorruptDbL()

	{

	_LIT(KCmdLine, "-copy_corrupt");

	(void)ExecuteRemoteL(KCmdLine);

	}

//Runs t_loghihelper. t_loghihelper will replace the LogEng database with a corrupted database (for testing purposes).

//The LogEng server will be stopped before that. The function can be used only in debug mode.

void  TestUtils::CopyCorruptDamagedDbL()

	{

	_LIT(KCmdLine, "-copy_corrupt_damaged");

	(void)ExecuteRemoteL(KCmdLine);

	}

//Runs t_loghihelper. t_loghihelper will replace the LogEng database with an old format database 

//(no SimId column, phone number length is different). The LogEng server will be stopped before that.

//The function can be used only in debug mode.

void TestUtils::CopyOldDbL()

	{

	_LIT(KCmdLine, "-copy_old");

	(void)ExecuteRemoteL(KCmdLine);

	}

#else //_DEBUG

void TestUtils::CopyCorruptDbL()

	{

	TheTest.Printf(_L("TestUtils::CopyCorruptDbL() has a meaningfull implementation in debug builds only.\n"));

	}

void TestUtils::CopyCorruptDamagedDbL()

	{

	TheTest.Printf(_L("TestUtils::CopyCorruptDamagedDbL() has a meaningfull implementation in debug builds only.\n"));

	}

void TestUtils::CopyOldDbL()

	{

	TheTest.Printf(_L("TestUtils::CopyOldDbL() has a meaningfull implementation in debug builds only.\n"));

	}

#endif//_DEBUG

//Runs t_loghihelper. t_loghihelper will re-create the LogEng database and check whether LogEng client can connect to the server.   

void TestUtils::TestInvalidSchemaL()

	{

	_LIT(KCmdLine, "-invalid_schema");

	(void)ExecuteRemoteL(KCmdLine);

	}

//Runs t_loghihelper. t_loghihelper checks whether the phone number mathcing is enabled.   

TBool TestUtils::MatchingEnabledL()

	{

	_LIT(KCmdLine, "-is_matching_enabled");

	return ExecuteRemoteL(KCmdLine) != 0;

	}

//Creates HBufC object and puts it on the cleanup stack.

//The buffer will be filled with (' ' + pos) characters, where pos is the character position in the buffer. 

HBufC* TestUtils::CreateBufLC(TInt aLength)

	{

	HBufC* buf = HBufC::NewLC(aLength);

	TPtr ptr = buf->Des();

	for(TInt pos=0;pos<aLength;++pos)

		{

		ptr.Append(TChar(' ' + pos));

		}

	return buf;

	}

//Returns whether the two filters are equal or not.

TBool TestUtils::FiltersEqual(const CLogFilter& aFilter1, const CLogFilter& aFilter2)

	{

	return aFilter1.EventType() == aFilter2.EventType() &&

		   aFilter1.RemoteParty() == aFilter2.RemoteParty() &&

		   aFilter1.Direction() == aFilter2.Direction() &&

		   aFilter1.DurationType() == aFilter2.DurationType() &&

		   aFilter1.Status() == aFilter2.Status() &&

		   aFilter1.Contact() == aFilter2.Contact() &&

		   aFilter1.Number() == aFilter2.Number() 

#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	

		   &&

		   aFilter1.SimId() == aFilter2.SimId()

#endif		   

		   ;

	}

//Creates HBufC8 object and puts it on the cleanup stack.

//The buffer will be filled with (' ' + pos % (0xff - 32)) characters, where pos is the character position in the buffer. 

HBufC8* TestUtils::CreateBuf8LC(TInt aLength)

	{

	HBufC8* buf = HBufC8::NewLC(aLength);

	TPtr8 ptr = buf->Des();

	for(TInt pos=0;pos<aLength;++pos)

		{

		ptr.Append(TChar(' ' + pos % (0xff - 32)));

		}

	return buf;

	}

//Returns whether the two events are equal or not.

TBool TestUtils::EventsEqual(const CLogEvent& aEvent1, const CLogEvent& aEvent2)

	{

	return 	aEvent1.Id() == aEvent2.Id() &&

			aEvent1.EventType() == aEvent2.EventType() &&

			aEvent1.RemoteParty() == aEvent2.RemoteParty() &&

			aEvent1.Direction() == aEvent2.Direction() &&

			aEvent1.Time() == aEvent2.Time() &&

			aEvent1.DurationType() == aEvent2.DurationType() &&

			aEvent1.Duration() == aEvent2.Duration() &&

			aEvent1.Status() == aEvent2.Status() &&

			aEvent1.Subject() == aEvent2.Subject() &&

			aEvent1.Number() == aEvent2.Number() &&

			aEvent1.Contact() == aEvent2.Contact() &&

			aEvent1.Link() == aEvent2.Link() &&

			aEvent1.Description() == aEvent2.Description() &&

			aEvent1.Data() == aEvent2.Data() 

#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM	

			&& 

			aEvent1.SimId() == aEvent2.SimId()

#endif			

			; 

	}

//Returns whether the two event types are equal or not.

TBool TestUtils::TypesEqual(const CLogEventType& aType1, const CLogEventType& aType2)

	{

	return	aType1.Uid() == aType2.Uid() &&

			aType1.Description() == aType2.Description() &&

			aType1.LoggingEnabled() == aType2.LoggingEnabled();

	}

//Waits for a key to be pressed.

TBool TestUtils::WaitForKeyL(TTimeIntervalMicroSeconds32 aDelay, TKeyCode& aKeyCode)

	{

	TEST(TheTest.Console() != NULL);

	// Create timer

	CTestTimer* timer = CTestTimer::NewL();

	CleanupStack::PushL(timer);

	timer->After(aDelay);

	CTestActive* wait = new(ELeave)CTestActive;

	CleanupStack::PushL(wait);

	wait->StartL();

	// Wait for key press

	TheTest.Console()->Read(wait->iStatus);

	CActiveScheduler::Start();

	// If timer still active a key was pressed

	TBool keyPressed = timer->IsActive();

	if (keyPressed)

		{

		// Get the key pressed

		aKeyCode = TheTest.Console()->KeyCode();

		// Cancel timer

		timer->Cancel();

		}

	else

		{

		// Cancel wait for character

		TheTest.Console()->ReadCancel();

		User::WaitForRequest(wait->iStatus);

		}

	CleanupStack::PopAndDestroy(2); // wait, timer

	return keyPressed;

	}

//Used for LogEng server side heap failure testing.

#ifdef _DEBUG

void TestUtils::SetLogServHeapFailureL(RHeap::TAllocFail aType, TInt aRate)

	{

	//this function doesn't have any effect on UREL builds 

 	//get rid of warnings in release builds

 	aType = aType;

 	aRate = aRate;

	if (!theLogServ.Handle())

	    LEAVE_IF_ERROR(theLogServ.Connect());

	TIpcArgs  ipcArgs(aType,aRate) ;

	LEAVE_IF_ERROR(theLogServ.Send(ELogSetHeapFail, ipcArgs));

	}

#else

void TestUtils::SetLogServHeapFailureL(RHeap::TAllocFail, TInt)

	{

	}

#endif//_DEBUG

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

// CLogViewChangeObserver

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

CLogViewChangeObserver* CLogViewChangeObserver::NewLC()

	{

	CLogViewChangeObserver* self = new(ELeave) CLogViewChangeObserver();

	CleanupStack::PushL(self);

	return self;

	}

CLogViewChangeObserver::~CLogViewChangeObserver()

	{

	Cancel();

	delete iChanges;

	}

CLogViewChangeObserver::CLogViewChangeObserver()

:	CActive(EPriorityStandard)

	{

	CActiveScheduler::Add(this);

	}

CLogChangeDefinition* CLogViewChangeObserver::WaitForChangesLC(TStopType aType, TInt aCount)

	{

	__ASSERT_ALWAYS(!iSchedulerStarted, User::Invariant());

	Reset();

	//

	iExpectedChangeCount = aCount;

	iType = aType;

	if	(aType != EStopOnChanges)

		SetActive();

	//

	iSchedulerStarted = ETrue;

	CActiveScheduler::Start();

	iSchedulerStarted = EFalse;

	//

	CLogChangeDefinition* ret = iChanges;

	TEST(iChanges != NULL);

	iChanges = NULL;

	CleanupStack::PushL(ret);

	return ret;

	}

CLogChangeDefinition* CLogViewChangeObserver::WaitForChangesLC(TCallBack aCallBack, TStopType aType, TInt aCount)

	{

	iHaveCallBack = ETrue;

	iCallBack = aCallBack;

	return WaitForChangesLC(aType, aCount);

	}

void CLogViewChangeObserver::HandleLogViewChangeEventAddedL(TLogId aId, TInt aViewIndex, TInt aChangeIndex, TInt aTotalChangeCount)

	{

	AddChangeL(ELogChangeTypeEventAdded, aId, aViewIndex);

	if	(aChangeIndex == aTotalChangeCount-1)

		CheckForSchedulerStop();

	}

void CLogViewChangeObserver::HandleLogViewChangeEventChangedL(TLogId aId, TInt aViewIndex, TInt aChangeIndex, TInt aTotalChangeCount)

	{

	AddChangeL(ELogChangeTypeEventChanged, aId, aViewIndex);

	if	(aChangeIndex == aTotalChangeCount-1)

		CheckForSchedulerStop();

	}

void CLogViewChangeObserver::HandleLogViewChangeEventDeletedL(TLogId aId, TInt aViewIndex, TInt aChangeIndex, TInt aTotalChangeCount)

	{

	AddChangeL(ELogChangeTypeEventDeleted, aId, aViewIndex);

	if	(aChangeIndex == aTotalChangeCount-1)

		CheckForSchedulerStop();

	}

void CLogViewChangeObserver::RunL()

	{

	__ASSERT_ALWAYS(iType == EStopOnRunL || iType == EStopOnBoth, User::Invariant());

	iHaveFinishedOperation = ETrue;

	CheckForSchedulerStop();

	}

void CLogViewChangeObserver::DoCancel()

	{

	TRequestStatus* s=&iStatus;

	User::RequestComplete(s, KErrCancel);

	}

void CLogViewChangeObserver::Reset()

	{

	iExpectedChangeCount = 0;

	iHaveFinishedOperation = EFalse;

	iHaveObtainedChanges = EFalse;

	iSchedulerStarted = EFalse;

	iType = EStopOnChanges;

	delete iChanges;

	iChanges = NULL;

	}

void CLogViewChangeObserver::CheckForSchedulerStop()

	{

	if(iSchedulerStarted)

		{

		if	(iHaveCallBack)

			{

			iCallBack.CallBack();

			iCallBack.iFunction = NULL;

			iCallBack.iPtr = NULL;

			iHaveCallBack = EFalse;

			}

		//

		TBool stopScheduler = EFalse;

		switch(iType)

			{

		case EStopOnChanges:

			stopScheduler = iHaveObtainedChanges;

			break;

		case EStopOnRunL:

			stopScheduler = iHaveFinishedOperation;

			break;

		case EStopOnBoth:

			stopScheduler = (iHaveObtainedChanges && iHaveFinishedOperation);

			break;

		case EStopOnCount:

			if	(iChanges)

				{

				TEST(iChanges->Count() <= iExpectedChangeCount);

				stopScheduler = (iChanges->Count() == iExpectedChangeCount);

				}

		case EDontStopScheduler:

			break;

			}

		if	(stopScheduler)

			{

			LOGTEXT("CLogViewChangeObserver::CheckForSchedulerStop() - Stopping the scheduler");

			CActiveScheduler::Stop();

			}

		}

	}

void CLogViewChangeObserver::AddChangeL(TLogDatabaseChangeType aType, TLogId aId, TInt aViewIndex)

	{

	CLogChangeDefinition* changes;

	if	(iChanges)

		changes = iChanges;

	else

		{

		changes = CLogChangeDefinition::NewL();

		CleanupStack::PushL(changes);

		}

	//

	changes->AddL(aId, aType, aViewIndex);

	//

	if	(!iChanges)

		{

		delete iChanges;

		iChanges = changes;

		CleanupStack::Pop(changes);

		}

	//

	iHaveObtainedChanges = ETrue;

	}

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

// CLogViewChangeObserverErrorTest

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

CLogViewChangeObserverErrorTest* CLogViewChangeObserverErrorTest::NewLC()

	{

	CLogViewChangeObserverErrorTest* self = new(ELeave) CLogViewChangeObserverErrorTest();

	CleanupStack::PushL(self);

	return self;

	}	

CLogViewChangeObserverErrorTest::CLogViewChangeObserverErrorTest()

	{}

void CLogViewChangeObserverErrorTest::HandleLogViewChangeEventAddedL(TLogId aId, TInt aViewIndex, TInt aChangeIndex, TInt aTotalChangeCount)

	{

  	// DEF108741L - the error condition tested here is that a leave is dealt with 

  	// gracefully without any panics.

 	// Add a new event to the log

	AddChangeL(ELogChangeTypeEventAdded, aId, aViewIndex);

	if	(aChangeIndex == aTotalChangeCount-1)

		CheckForSchedulerStop();

	// In the test case for DEF108741L this method will be effectively

	// invoked 3 times. This code forces a leave on the middle event to 

	// ensure that the leave is dealt with and the rest of the test 

	// completes successfully.

	if (aId == 1)

		{	

		LEAVE(KErrGeneral);

		} 

	}

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

// CLogSchedulerTimer

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

CLogSchedulerTimer* CLogSchedulerTimer::NewLC()

	{

	CLogSchedulerTimer* self = new(ELeave) CLogSchedulerTimer();

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CLogSchedulerTimer::~CLogSchedulerTimer()

	{

	Cancel();

	}

CLogSchedulerTimer::CLogSchedulerTimer()

:	CTimer(0)

	{

	CActiveScheduler::Add(this);

	}

void CLogSchedulerTimer::ConstructL()

	{

	CTimer::ConstructL();

	}

void CLogSchedulerTimer::Wait(TTimeIntervalMicroSeconds32 aTime)

	{

	After(aTime);

	CActiveScheduler::Start();

	}

void CLogSchedulerTimer::RunL()

	{

	LOGTEXT("CLogSchedulerTimer::RunL() - Stopping the scheduler");

	CActiveScheduler::Stop();

	}

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

// CLogChangeNotifier

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

CLogChangeNotifier* CLogChangeNotifier::NewL()

	{

	CLogChangeNotifier* self = new(ELeave)CLogChangeNotifier();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CLogChangeNotifier::~CLogChangeNotifier()

	{

	Cancel();

	delete iClient;

	}

CLogChangeNotifier::CLogChangeNotifier()

: CActive(EPriorityStandard)

	{

	CActiveScheduler::Add(this);

	}

void CLogChangeNotifier::ConstructL()

	{

	iClient = CLogClient::NewL(theFs);

	iStart.UniversalTime();

	iClient->NotifyChange(10000000, iStatus);

	SetActive();

	}

void CLogChangeNotifier::RunL()

	{

	TTime now;

	now.UniversalTime();

	TTimeIntervalSeconds seconds;

	now.SecondsFrom(iStart, seconds);

	TBuf<256> buf;

 	const TInt error = iStatus.Int();

 	if (error == KErrServerTerminated)

 		{

 		buf.Format(_L("KErrServerTerminated"));

		User::InfoPrint(buf);

		return;

 		}

	buf.Format(_L("%d seconds"), seconds.Int());

	User::InfoPrint(buf);

	iStart.UniversalTime();

	iClient->NotifyChange(10000000, iStatus);

	SetActive();

	}

void CLogChangeNotifier::DoCancel()

	{

	iClient->NotifyChangeCancel();	

	}

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

// Global

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

void SetupSchedulerL()

	{

	testScheduler = new (ELeave) CActiveScheduler;

	CleanupStack::PushL( testScheduler );

	CActiveScheduler::Install( testScheduler );

	}

void CloseScheduler()

	{

    CleanupStack::PopAndDestroy(); // Scheduler

    testScheduler = NULL;

	}

static void CreateLogL()

    {

    LEAVE_IF_ERROR(theFs.Connect());

    theLogName.Copy(RProcess().FileName());

    TInt start = theLogName.LocateReverse('\\');

    TInt end = theLogName.LocateReverse('.');

    theLogName = theLogName.Mid(start + 1, end - start - 1);

    // create the log filename

    theLogName.Insert(0, _L("C:\\"));

#if defined(__WINS__)

    theLogName.Append(_L(".WINS."));

#else

    theLogName.Append(_L(".MARM."));

#endif

#if defined(_UNICODE)

    theLogName.Append(_L("UNICODE."));

#else

    theLogName.Append(_L("ASCII."));

#endif

#if defined(_DEBUG)

    theLogName.Append(_L("DEB."));

#else

    theLogName.Append(_L("REL."));

#endif

    theLogName.Append(_L("LOG"));

    // create the logfile

    LEAVE_IF_ERROR(theLog.Replace(theFs, theLogName, EFileWrite|EFileShareExclusive));

    TBuf8<256> text;

    text.Copy(theLogName);

    theLog.Write(text);

    theLog.Write(_L8("\nTest results\n"));

    }

static void CloseLog()

    {

    theLog.Write(_L8("Tests completed\n"));

    TheTest.Printf(_L("Results saved in %S\n"), &theLogName);

    theLog.Close();

    theFs.Close();

    }

void DeleteDataFile(const TDesC& aFullName)

	{

	RFs fsSession;

	TInt err = fsSession.Connect();

	if(err == KErrNone)

		{

		TEntry entry;

		if(fsSession.Entry(aFullName, entry) == KErrNone)

			{

			TheTest.Printf(_L("Deleting \"%S\" file.\n"), &aFullName);

			err = fsSession.SetAtt(aFullName, 0, KEntryAttReadOnly);

			if(err != KErrNone) 

				{

				TheTest.Printf(_L("Error %d changing \"%S\" file attributes.\n"), err, &aFullName);

				}

			err = fsSession.Delete(aFullName);

			if(err != KErrNone) 

				{

				TheTest.Printf(_L("Error %d deleting \"%S\" file.\n"), err, &aFullName);

				}

			}

		fsSession.Close();

		}

	else

		{

		TheTest.Printf(_L("Error %d connecting file session. File: %S.\n"), err, &aFullName);

		}

	}

static void Cleanup(void*)

	{

	TRAP_IGNORE(TestUtils::DeleteDatabaseL());

	::DeleteDataFile(theLogName);

	}

static void DoMainL()

	{

	::SetupSchedulerL();

	TCleanupItem cleanup(&Cleanup, NULL);

	CleanupStack::PushL(cleanup);

	CreateLogL();

	::doTestsL();

	CloseLog();

    CleanupStack::PopAndDestroy();//cleanup

	::CloseScheduler();

	}

TInt E32Main()

	{	

	__UHEAP_MARK;

	theCleanup = CTrapCleanup::New();

    if(!theCleanup)

       {

       _LIT(KLogHiCapHelperPanic, "LogTestPanic");

        User::Panic(KLogHiCapHelperPanic, KErrNoMemory);

       }

	TRAPD(err, ::DoMainL());	

	TEST2(err, KErrNone);

	delete theCleanup;	

	TheTest.Console()->SetPos(0, 13);

	TheTest.End();

	TheTest.Close();

	__UHEAP_MARKEND;

	return KErrNone;

	}