// 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;
	}