diff -r 000000000000 -r bde4ae8d615e os/persistentdata/traceservices/commsdebugutility/TE_commsdebugutility/src/step_024_xx.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/os/persistentdata/traceservices/commsdebugutility/TE_commsdebugutility/src/step_024_xx.cpp	Fri Jun 15 03:10:57 2012 +0200
@@ -0,0 +1,1233 @@
+// Copyright (c) 2003-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:
+// This contains Flogger Unit Test Case 024.xx
+
+// EPOC includes
+#include <e32base.h>
+
+
+// Test system includes
+#include "teststepcomsdbg.h"
+#include "TestMessage.h"
+#include "step_024_xx.h"
+
+#include <comms-infras/commsdebugutility.h>
+
+
+const TInt KFiveSeconds = 5000000;
+const TInt KMaxConnection = 500; ///< specify a lot of connections for the connection stress test 
+const TInt KTimeBetConnection = 100000; //Some time between connection
+const TInt KDelayToCheckWrite = 10000000; //Give some time for the flogger to write the message before checking. Replaces KTimeToLog which is normally used.
+
+
+/**
+* Function  Name : CFloggerTest024_01
+* Input parameters : None
+* Output parameters : None
+* Description : This is the constructor
+*/
+
+
+CFloggerTest024_01::CFloggerTest024_01()
+	{
+	// Store the name of this test case
+	SetTestStepName(_L("step_024_01"));
+	}
+
+
+/**
+* Function  Name :~ CFloggerTest024_01
+* Input parameters : None
+* Output parameters : None
+* Description : This is the Destructor
+*/
+
+
+CFloggerTest024_01::~CFloggerTest024_01()
+	{
+	}
+
+
+/**
+* Function  Name	: doTestStepL
+* Input parameters	: None
+* Output parameters : TVerdict 
+* Description		: This function returns weather the test case 024_01 has 
+* 					  passed or failed
+
+*/
+
+
+TVerdict CFloggerTest024_01::doTestStepL( )
+	{
+
+	INFO_PRINTF1(_L("Step 024.01 called "));
+	if ( executeStepL() == KErrNone  )
+		SetTestStepResult(EPass);
+
+	else
+		SetTestStepResult(EFail);
+
+	
+	return TestStepResult();
+	}
+
+
+/**
+* Function  Name		: executeStepL
+* Input parameters		: None
+* Output parameters		: TInt 
+* Description 			: This function sets the subsystem and component name
+* 						  checks weather they are set in the log file correctly
+
+					  
+*/
+
+
+TInt CFloggerTest024_01::executeStepL()
+	{
+	return DoTestWrite();
+	}
+	
+/**
+* Function  Name		: executeStepL
+* Input parameters		: None
+* Output parameters		: TInt 
+* Description 			: This function sets the subsystem and component name
+* 						  checks weather they are set in the log file correctly
+
+					  
+*/
+
+
+TInt CFloggerTest024_01::executeStepL(TBool)
+	{
+	return KErrGeneral;
+	}
+/**
+* Function  Name		: DoTestWriteL
+* Input parameters		: None
+* Output parameters		: TInt 
+* Description 			: This function checks the weather test data was written
+* 						  in to the log file by DoTestWriteL() or not.
+					  
+*/
+
+
+TInt CFloggerTest024_01::DoTestWrite()
+	{
+	TPtrC8 ptrSubSystem;
+	TPtrC8 ptrComponent;
+	ptrSubSystem.Set(_L8("SubSystem"));
+	ptrComponent.Set(_L8("Component"));
+
+	_LIT8(KTestMessage1 ,"TC NO 24: This is test message before sleep");
+	_LIT8(KTestMessage2 ,"TC NO 24: This is test message After sleep");
+
+	TInt ret = KErrGeneral;
+	RFileLogger theFlogger;
+
+	ret = theFlogger.Connect();
+	if (ret == KErrNone)
+		{
+		ret = theFlogger.SetLogTags(ptrSubSystem, ptrComponent);
+		if (ret == KErrNone)
+			{
+			ret = theFlogger.ClearLog();
+			if (ret == KErrNone)
+				{
+				theFlogger.Write(KTestMessage1); //Write the test descriptor before sleep
+				User::After(KFiveSeconds); // Call After() function
+				theFlogger.Write(KTestMessage2); //Write the test descriptor after sleep
+				User::After(KFiveSeconds);
+
+				TRAPD(r, ret = DoTestCheckWriteL()); // Check whether the message is present in log
+			
+				
+				if (r != KErrNone)
+					ret = r;
+				}
+			}
+		}
+	if (ret == KErrNone)
+		theFlogger.__DbgShutDownServer();
+	theFlogger.Close();
+	return ret;
+	}
+
+
+/**
+* Function  Name		: DoTestCheckWriteL
+* Input parameters		: None
+* Output parameters		: TInt 
+* Description 			: This function checks the weather test data was written
+* 						  in to the log file by DoTestWriteL() or not.
+					  
+*/
+
+
+TInt CFloggerTest024_01::DoTestCheckWriteL()
+	{
+	RFile theFile;
+
+	_LIT(KTestString,"Time");
+
+	HBufC8 * hBuffer;
+	TInt listfilesize;
+	RFs iFileSystem; //For file operation create a file system
+	TBuf8<256> testData; //To hold the test descriptor
+
+	User::LeaveIfError(iFileSystem.Connect());
+	
+	//Open the file in the read mode
+	User::LeaveIfError(theFile.Open(iFileSystem, KFloggerOutputFile, EFileWrite|EFileShareAny)); 
+	CleanupClosePushL(theFile);
+	
+	User::LeaveIfError(theFile.Size(listfilesize)); //Size of the file
+	
+	hBuffer = HBufC8::New(listfilesize); //Allocate the buffer
+	CleanupStack::PushL(hBuffer);
+	TPtr8 ptrString = hBuffer->Des();  ; //To hold the buffer
+
+	// Read from position 0: start of file
+	User::LeaveIfError(theFile.Read(ptrString));
+	
+	testData.Copy(KTestString); //Copy the test string to be tested
+
+	TPtrC8 ptrTmpBuffer = ptrString.Right(listfilesize); //Copy of the orginal buffer read from the file
+	TInt charCount1 = 0;
+	TInt charCount2 = 0;
+	TInt lineCount = 0;
+	TInt tmpCount = 0;
+	
+	charCount1 = ptrString.Find(testData);
+	while(charCount1 != KErrNotFound)
+		{
+		lineCount++; //Increment the line count since we just found another one
+		charCount2 = charCount2 + charCount1 + KSampleTimeLine().Length(); //the the number of char's present in the line which
+										// is constant for the line starting with "#Time" in the log file
+
+		tmpCount = listfilesize - charCount2; // Remaining string after the "Time" is read
+		TPtrC8 strTmp = ptrString.Right(tmpCount);
+		charCount1 = strTmp.Find(testData);
+		if (charCount1 == 0) //Since the Time is found at the zeroth position count1 will contain 0
+			charCount1 = charCount1 + 4; // Charecter count of Time is 4
+		ptrString = ptrTmpBuffer.Right(listfilesize); // Get back the orginal buffer 
+		}
+
+	CleanupStack::PopAndDestroy(hBuffer);
+	CleanupStack::PopAndDestroy();	//theFile
+
+	// we expect to find the word "TIME" 10 times (or more) - 5 during each delay.
+	if ((lineCount >= 10) && (lineCount <= 12))
+		return KErrNone;
+	else
+		return KErrGeneral;
+
+
+
+	}
+
+
+
+
+
+
+_LIT8(KTestStringWithPunctuation1,"                                                 /===-_---~~~~~~~~~------____"); _LIT8(KTestStringWithPunctuation26,"    `~/  )` ) ,/|                 ~-_~>--<_/-__       __-~ _/ ");
+_LIT8(KTestStringWithPunctuation2,"                 -==\\\\                         `//~\\\\   ~~~~`---.___.-~~"); _LIT8(KTestStringWithPunctuation27,"   ;'( ')/ ,)(                              ~~~~~~~~~~ ");
+_LIT8(KTestStringWithPunctuation3,"       __--~~~  ,-/-==\\\\                        | |   `\\        ,'"); _LIT8(KTestStringWithPunctuation19,"                  \\_|      /        _)   ;  ),   __--~~");
+_LIT8(KTestStringWithPunctuation4,"  .'        /       |   \\\\                   /' /        \\   /'");              _LIT8(KTestStringWithPunctuation21,"                  |0  0 _/) )-~     | |__>--<__|      |");
+_LIT8(KTestStringWithPunctuation5,"/-'~    ~~~~~---__  |     ~-/~         ( )   /'        _--~`");                    _LIT8(KTestStringWithPunctuation20,"                   {\\__--_/}    / \\\\_>- )<__\\      \\");
+_LIT8(KTestStringWithPunctuation6,"                    '~~--_/      _-~/-  / \\   '-~ \\");                           _LIT8(KTestStringWithPunctuation22,"                 o o _//        /-~_>---<__-~      /");
+_LIT8(KTestStringWithPunctuation15,"                                                |===-~___                _,-'");  _LIT8(KTestStringWithPunctuation24,"            ( ( '))          |__>--<__|    |                 /' _---_~\\");
+_LIT8(KTestStringWithPunctuation16,"             ______-==|                         | |  \\\\           _-~`");       _LIT8(KTestStringWithPunctuation23,"                ,/|           /__>--<__/     _-~");
+_LIT8(KTestStringWithPunctuation17,"    _-~       /'    |  \\\\                      / /      \\      /");           _LIT8(KTestStringWithPunctuation25,"        ,/,'//( (             \\__>--<__\\    \\            /'  //        ||");
+_LIT8(KTestStringWithPunctuation18," /  ____  /         |    \\`\\.__/-~~ ~ \\ _ _/'  /          \\/'");
+_LIT8(KTestStringWithPunctuationExpected1,"         `-)) )) (           |__>--<__|    |               /'  /     ~\\`\\");
+_LIT8(KTestStringWithPunctuationExpected2,"                 o o _//        /-~_>---<__-~      /");
+_LIT8(KTestStringWithPunctuationExpected3,"    `~/  )` ) ,/|                 ~-_~>--<_/-__       __-~ _/ ");
+
+
+
+/**
+* CFloggerTest024_02 - test static write with string with beeps, tabs, nulls, CR's, LFs in the tags
+* doTestStep returns whether test case passed or failed.
+*/ 
+
+
+
+
+CFloggerTest024_02::CFloggerTest024_02()
+	{
+	// Store the name of this test case
+	SetTestStepName(_L("step_024_02"));
+	}
+
+
+
+
+CFloggerTest024_02::~CFloggerTest024_02()
+	{
+	}
+
+
+
+
+TVerdict CFloggerTest024_02::doTestStepL( )
+	{
+	if ( executeStepL() == KErrNone  )
+		SetTestStepResult(EPass);
+
+	else
+		SetTestStepResult(EFail);
+
+	
+	return TestStepResult();
+	}
+
+
+TInt CFloggerTest024_02::executeStepL(TBool)
+	{
+	return KErrGeneral;
+	}
+
+TInt CFloggerTest024_02::executeStepL()
+	{
+	TInt ret;
+	
+	// clear the old log messages
+	RFileLogger flogger;
+	ret = flogger.Connect();
+	
+	if ( ret == KErrNone )
+		{
+		flogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
+		flogger.ClearLog();
+		flogger.Close();
+		
+		RFileLogger::Write(KSubsysTagWithEscapeChars8, KCompTagWithEscapeChars8,KTestMessage8);
+		
+		User::After(KTimeToLog);
+		
+		TRAPD(r, ret = DoTestCheckWriteL());
+		if (r != KErrNone)
+			ret = r;
+		}
+		
+	
+	return ret;		
+
+	}
+
+
+TInt CFloggerTest024_02::DoTestCheckWriteL()
+	{
+	RFile logFile;
+	HBufC8* hBuffer;
+	TInt listfilesize,returnCode;
+	RFs fileSystem; //For file operation create a file system
+	TInt numSuccessful = 0;
+
+	User::LeaveIfError(fileSystem.Connect());
+	
+	//Open the file in the read mode
+	User::LeaveIfError(logFile.Open(fileSystem,KFloggerOutputFile,EFileRead));
+
+	CleanupClosePushL(logFile);
+
+	User::LeaveIfError(logFile.Size(listfilesize)); //Size of the file
+	
+	hBuffer = HBufC8::New(listfilesize); //Allocate the buffer
+	CleanupStack::PushL(hBuffer);
+
+	TPtr8 ptrString = hBuffer->Des();  ; //To access the buffer
+
+	// Read from position 0: start of file
+	User::LeaveIfError(returnCode = logFile.Read(ptrString));
+	
+	// flogger should not have logged
+	returnCode = ptrString.Find(KTestMessage8);
+	
+	if (returnCode == KErrNotFound)
+		{
+		numSuccessful++;
+		}
+
+
+	CleanupStack::PopAndDestroy(hBuffer);
+	CleanupStack::PopAndDestroy();	//logFile
+	if (numSuccessful == 1)
+		return KErrNone;
+	else
+		return KErrUnknown;
+	}
+
+
+
+
+/**
+* CFloggerTest024_03 - test static write with string with punctuation and spaces in the data
+* doTestStep returns whether test case passed or failed.
+*/ 
+
+_LIT8(KTestStringWithPunctuation8,"                  / /~ ,_/       / /__>---<__/      |  ");
+_LIT8(KTestStringWithPunctuation14,"  ' ') '( (/");
+_LIT8(KTestStringWithPunctuation9,"                 (^(~          /~_>---<__-      _-~");
+_LIT8(KTestStringWithPunctuation7,"                   /'   (_/  _-~  | |__>--<__|      | ");
+_LIT8(KTestStringWithPunctuation11,"         `-)) )) (           |__>--<__|    |               /'  /     ~\\`\\");
+_LIT8(KTestStringWithPunctuation12,"      ,( ( ((, ))              ~-__>--<_~-_  ~--____---~' _/'/        /'");
+_LIT8(KTestStringWithPunctuation10,"             ,//('(          |__>--<__|     /                  .----_ ");
+_LIT8(KTestStringWithPunctuation13,"  ._-~//( )/ )) `                    ~~-'_/_/ /~~~~~~~__--~ ");
+
+
+CFloggerTest024_03::CFloggerTest024_03()
+	{
+	// Store the name of this test case
+	SetTestStepName(_L("step_024_03"));
+	}
+
+
+
+
+CFloggerTest024_03::~CFloggerTest024_03()
+	{
+	}
+
+
+
+
+TVerdict CFloggerTest024_03::doTestStepL( )
+	{
+	if ( executeStepL() == KErrNone  )
+		SetTestStepResult(EPass);
+
+	else
+		SetTestStepResult(EFail);
+
+	
+	return TestStepResult();
+	}
+
+
+TInt CFloggerTest024_03::executeStepL(TBool)
+	{
+	return KErrGeneral;
+	}
+
+TInt CFloggerTest024_03::executeStepL()
+	{
+	TInt ret;
+	
+	// clear the old log messages
+	RFileLogger flogger;
+	ret = flogger.Connect();
+	
+	if ( ret == KErrNone )
+		{
+		flogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
+		flogger.ClearLog();
+		flogger.Close();
+		
+		RFileLogger::Write(KStdSubsysTag8, KStdCompTag8,KTestStringWithPunctuation1);
+		RFileLogger::Write(KStdSubsysTag8, KStdCompTag8,KTestStringWithPunctuation15);
+		RFileLogger::Write(KStdSubsysTag8, KStdCompTag8,KTestStringWithPunctuation2);
+		RFileLogger::Write(KStdSubsysTag8, KStdCompTag8,KTestStringWithPunctuation16);
+		RFileLogger::Write(KStdSubsysTag8, KStdCompTag8,KTestStringWithPunctuation3);
+		RFileLogger::Write(KStdSubsysTag8, KStdCompTag8,KTestStringWithPunctuation17);
+		RFileLogger::Write(KStdSubsysTag8, KStdCompTag8,KTestStringWithPunctuation4);
+		RFileLogger::Write(KStdSubsysTag8, KStdCompTag8,KTestStringWithPunctuation18);
+		RFileLogger::Write(KStdSubsysTag8, KStdCompTag8,KTestStringWithPunctuation5);
+		RFileLogger::Write(KStdSubsysTag8, KStdCompTag8,KTestStringWithPunctuation19);
+		RFileLogger::Write(KStdSubsysTag8, KStdCompTag8,KTestStringWithPunctuation6);
+		RFileLogger::Write(KStdSubsysTag8, KStdCompTag8,KTestStringWithPunctuation20);
+		RFileLogger::Write(KStdSubsysTag8, KStdCompTag8,KTestStringWithPunctuation7);
+		RFileLogger::Write(KStdSubsysTag8, KStdCompTag8,KTestStringWithPunctuation21);
+		RFileLogger::Write(KStdSubsysTag8, KStdCompTag8,KTestStringWithPunctuation8);
+		RFileLogger::Write(KStdSubsysTag8, KStdCompTag8,KTestStringWithPunctuation22);
+		RFileLogger::Write(KStdSubsysTag8, KStdCompTag8,KTestStringWithPunctuation9);
+		RFileLogger::Write(KStdSubsysTag8, KStdCompTag8,KTestStringWithPunctuation23);
+		RFileLogger::Write(KStdSubsysTag8, KStdCompTag8,KTestStringWithPunctuation10);
+		RFileLogger::Write(KStdSubsysTag8, KStdCompTag8,KTestStringWithPunctuation24);
+		RFileLogger::Write(KStdSubsysTag8, KStdCompTag8,KTestStringWithPunctuation11);
+		RFileLogger::Write(KStdSubsysTag8, KStdCompTag8,KTestStringWithPunctuation25);
+		RFileLogger::Write(KStdSubsysTag8, KStdCompTag8,KTestStringWithPunctuation12);
+		RFileLogger::Write(KStdSubsysTag8, KStdCompTag8,KTestStringWithPunctuation26);
+		RFileLogger::Write(KStdSubsysTag8, KStdCompTag8,KTestStringWithPunctuation13);
+		RFileLogger::Write(KStdSubsysTag8, KStdCompTag8,KTestStringWithPunctuation27);
+		RFileLogger::Write(KStdSubsysTag8, KStdCompTag8,KTestStringWithPunctuation14);
+		
+		User::After(KTimeToLog);
+		
+		TRAPD(r, ret = DoTestCheckWriteL());
+		if (r != KErrNone)
+			ret = r;
+		}
+		
+	
+	return ret;		
+
+	}
+
+
+TInt CFloggerTest024_03::DoTestCheckWriteL()
+	{
+	RFile logFile;
+	HBufC8* hBuffer;
+	TInt listfilesize,returnCode;
+	RFs fileSystem; //For file operation create a file system
+	TInt numSuccessful = 0;
+
+	User::LeaveIfError(fileSystem.Connect());
+	
+	//Open the file in the read mode
+	User::LeaveIfError(logFile.Open(fileSystem,KFloggerOutputFile,EFileRead));
+
+	CleanupClosePushL(logFile);
+
+	User::LeaveIfError(logFile.Size(listfilesize)); //Size of the file
+	
+	hBuffer = HBufC8::New(listfilesize); //Allocate the buffer
+	CleanupStack::PushL(hBuffer);
+
+	TPtr8 ptrString = hBuffer->Des();  ; //To access the buffer
+
+	// Read from position 0: start of file
+	User::LeaveIfError(returnCode = logFile.Read(ptrString));
+	
+	// check that flogger logged the punctuation/spaces correctly by checking three samples
+	returnCode = ptrString.Find(KTestStringWithPunctuationExpected1);
+	
+	if (returnCode > 0)
+		{
+		numSuccessful++;
+		}
+		
+	returnCode = ptrString.Find(KTestStringWithPunctuationExpected2);
+	
+	if (returnCode > 0)
+		{
+		numSuccessful++;
+		}
+		
+	returnCode = ptrString.Find(KTestStringWithPunctuationExpected3);
+	
+	if (returnCode > 0)
+		{
+		numSuccessful++;
+		}
+
+
+	CleanupStack::PopAndDestroy(hBuffer);
+	CleanupStack::PopAndDestroy();	//logFile
+	if (numSuccessful == 3)
+		return KErrNone;
+	else
+		return KErrUnknown;
+	}
+
+
+
+
+/**
+* CFloggerTest024_04 - test static write with data string with beeps, tabs, nulls, CR's, LFs in it
+* doTestStep returns whether test case passed or failed.
+*/ 
+
+CFloggerTest024_04::CFloggerTest024_04()
+	{
+	// Store the name of this test case
+	SetTestStepName(_L("step_024_04"));
+	}
+
+
+
+
+CFloggerTest024_04::~CFloggerTest024_04()
+	{
+	}
+
+
+
+
+TVerdict CFloggerTest024_04::doTestStepL( )
+	{
+	if ( executeStepL() == KErrNone  )
+		SetTestStepResult(EPass);
+
+	else
+		SetTestStepResult(EFail);
+
+	
+	return TestStepResult();
+	}
+
+
+TInt CFloggerTest024_04::executeStepL(TBool)
+	{
+	return KErrGeneral;
+	}
+
+TInt CFloggerTest024_04::executeStepL()
+	{
+	TInt ret;
+	
+	// clear the old log messages
+	RFileLogger flogger;
+	ret = flogger.Connect();
+	
+	if ( ret == KErrNone )
+		{
+		flogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
+		flogger.ClearLog();
+		flogger.Close();
+		
+		RFileLogger::Write(KStdSubsysTag8, KStdCompTag8,KTestMessageWithEscapeChars8);
+		
+		User::After(KTimeToLog);
+		
+		TRAPD(r, ret = DoTestCheckWriteL());
+		if (r != KErrNone)
+			ret = r;
+		}
+		
+	
+	return ret;		
+
+	}
+
+
+TInt CFloggerTest024_04::DoTestCheckWriteL()
+	{
+	RFile logFile;
+	HBufC8* hBuffer;
+	TInt listfilesize,returnCode;
+	RFs fileSystem; //For file operation create a file system
+	TInt numSuccessful = 0;
+
+	User::LeaveIfError(fileSystem.Connect());
+	
+	//Open the file in the read mode
+	User::LeaveIfError(logFile.Open(fileSystem,KFloggerOutputFile,EFileRead));
+
+	CleanupClosePushL(logFile);
+
+	User::LeaveIfError(logFile.Size(listfilesize)); //Size of the file
+	
+	hBuffer = HBufC8::New(listfilesize); //Allocate the buffer
+	CleanupStack::PushL(hBuffer);
+
+	TPtr8 ptrString = hBuffer->Des();  ; //To access the buffer
+
+	// Read from position 0: start of file
+	User::LeaveIfError(returnCode = logFile.Read(ptrString));
+	
+	// flogger will have logged the string exactly as it was sent. The CR/LF will not
+	// cause a line feed because they are not adjacent
+	returnCode = ptrString.Find(KTestMessageWithEscapeChars8);
+	
+	if (returnCode > 0)
+		{
+		numSuccessful++;
+		}
+
+
+	CleanupStack::PopAndDestroy(hBuffer);
+	CleanupStack::PopAndDestroy();	//logFile
+	if (numSuccessful == 1)
+		return KErrNone;
+	else
+		return KErrUnknown;
+	}
+
+
+
+
+
+/**
+* CFloggerTest024_05 - test static write with data string with char 255, nulls, and escapes in it
+* doTestStep returns whether test case passed or failed.
+*/ 
+
+CFloggerTest024_05::CFloggerTest024_05()
+	{
+	// Store the name of this test case
+	SetTestStepName(_L("step_024_05"));
+	}
+
+
+
+
+CFloggerTest024_05::~CFloggerTest024_05()
+	{
+	}
+
+
+
+
+TVerdict CFloggerTest024_05::doTestStepL( )
+	{
+	if ( executeStepL() == KErrNone  )
+		SetTestStepResult(EPass);
+
+	else
+		SetTestStepResult(EFail);
+
+	
+	return TestStepResult();
+	}
+
+TInt CFloggerTest024_05::executeStepL(TBool)
+	{
+	return KErrGeneral;
+	}
+
+
+TInt CFloggerTest024_05::executeStepL()
+	{
+	TInt ret;
+	
+	// clear the old log messages
+	RFileLogger flogger;
+	ret = flogger.Connect();
+	
+	if ( ret == KErrNone )
+		{
+		flogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
+		flogger.ClearLog();
+		flogger.Close();
+		
+		RFileLogger::Write(KStdSubsysTag8, KStdCompTag8,K2ndTestMessageWithEscapeChars8);
+		
+		User::After(KTimeToLog);
+		
+		TRAPD(r, ret = DoTestCheckWriteL());
+		if (r != KErrNone)
+			ret = r;
+		}
+		
+	
+	return ret;		
+
+	}
+
+
+TInt CFloggerTest024_05::DoTestCheckWriteL()
+	{
+	RFile logFile;
+	HBufC8* hBuffer;
+	TInt listfilesize,returnCode;
+	RFs fileSystem; //For file operation create a file system
+	TInt numSuccessful = 0;
+
+	User::LeaveIfError(fileSystem.Connect());
+	
+	//Open the file in the read mode
+	User::LeaveIfError(logFile.Open(fileSystem,KFloggerOutputFile,EFileRead));
+
+	CleanupClosePushL(logFile);
+
+	User::LeaveIfError(logFile.Size(listfilesize)); //Size of the file
+	
+	hBuffer = HBufC8::New(listfilesize); //Allocate the buffer
+	CleanupStack::PushL(hBuffer);
+
+	TPtr8 ptrString = hBuffer->Des();  ; //To access the buffer
+
+	// Read from position 0: start of file
+	User::LeaveIfError(returnCode = logFile.Read(ptrString));
+	
+	// flogger will have logged the string exactly as it was sent. The CR/LF will not
+	// cause a line feed because they are not adjacent
+	returnCode = ptrString.Find(K2ndTestMessageWithEscapeChars8);
+	
+	if (returnCode > 0)
+		{
+		numSuccessful++;
+		}
+
+
+	CleanupStack::PopAndDestroy(hBuffer);
+	CleanupStack::PopAndDestroy();	//logFile
+	if (numSuccessful == 1)
+		return KErrNone;
+	else
+		return KErrUnknown;
+	}
+
+
+
+/**
+* CFloggerTest024_06 - test static write with empty data string
+* doTestStep returns whether test case passed or failed.
+*/ 
+
+CFloggerTest024_06::CFloggerTest024_06()
+	{
+	// Store the name of this test case
+	SetTestStepName(_L("step_024_06"));
+	}
+
+
+
+
+CFloggerTest024_06::~CFloggerTest024_06()
+	{
+	}
+
+
+
+
+TVerdict CFloggerTest024_06::doTestStepL( )
+	{
+	if ( executeStepL() == KErrNone  )
+		SetTestStepResult(EPass);
+
+	else
+		SetTestStepResult(EFail);
+
+	
+	return TestStepResult();
+	}
+
+
+TInt CFloggerTest024_06::executeStepL(TBool)
+	{
+	return KErrGeneral;
+	}
+
+TInt CFloggerTest024_06::executeStepL()
+	{
+	TInt ret;
+	
+	// clear the old log messages
+	RFileLogger flogger;
+	ret = flogger.Connect();
+	
+	if ( ret == KErrNone )
+		{
+		flogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
+		flogger.ClearLog();
+		flogger.Close();
+		
+		RFileLogger::Write(KStdSubsysTag8, KStdCompTag8,KNullDesC8);
+		
+		User::After(KTimeToLog);
+		
+		TRAPD(r, ret = DoTestCheckWriteL());
+		if (r != KErrNone)
+			ret = r;
+		}
+		
+	
+	return ret;		
+
+	}
+
+
+TInt CFloggerTest024_06::DoTestCheckWriteL()
+	{
+	RFile logFile;
+	HBufC8* hBuffer;
+	TInt listfilesize,returnCode;
+	RFs fileSystem; //For file operation create a file system
+	TInt numSuccessful = 0;
+
+	User::LeaveIfError(fileSystem.Connect());
+	
+	//Open the file in the read mode
+	User::LeaveIfError(logFile.Open(fileSystem,KFloggerOutputFile,EFileRead));
+
+	CleanupClosePushL(logFile);
+
+	User::LeaveIfError(logFile.Size(listfilesize)); //Size of the file
+	
+	hBuffer = HBufC8::New(listfilesize); //Allocate the buffer
+	CleanupStack::PushL(hBuffer);
+
+	TPtr8 ptrString = hBuffer->Des();  ; //To access the buffer
+
+	// Read from position 0: start of file
+	User::LeaveIfError(returnCode = logFile.Read(ptrString));
+	
+	// not much to check since flogger won't have written much other than
+	// the tags
+	returnCode = ptrString.Find(KStdCompTag8);
+	
+	if (returnCode > 0)
+		{
+		numSuccessful++;
+		}
+
+
+	CleanupStack::PopAndDestroy(hBuffer);
+	CleanupStack::PopAndDestroy();	//logFile
+	if (numSuccessful == 1)
+		return KErrNone;
+	else
+		return KErrUnknown;
+	}
+
+
+CFloggerTest024_07::CFloggerTest024_07()
+	{
+	// Store the name of this test case
+	SetTestStepName(_L("step_024_07"));
+	}
+
+
+/**
+* Function  Name :~ CFloggerTest024_07
+* Input parameters : None
+* Output parameters : None
+* Description : This is the Destructor
+*/ 
+
+
+CFloggerTest024_07::~CFloggerTest024_07()
+	{
+	}
+
+
+/**
+* Function  Name	: doTestStepL
+* Input parameters	: None
+* Output parameters : TVerdict 
+* Description		: This function returns whether the test case 024_07 has 
+* 					  passed or failed
+
+*/
+
+
+TVerdict CFloggerTest024_07::doTestStepL( )
+	{
+	INFO_PRINTF1(_L("Step 027.13 called "));
+	if ( executeStepL() == KErrNone  )
+		SetTestStepResult(EPass);
+
+	else
+		SetTestStepResult(EFail);
+
+	INFO_PRINTF1(_L("leaving Step 027.13"));
+	User::After(KTimeForDisplay);
+
+	
+	return TestStepResult();
+	}
+
+/**
+* Function  Name		: executeStepL
+* Input parameters		: None
+* Output parameters		: TInt 
+* Description 			: This function checks for the flogger connection for 500 times
+
+*/
+
+
+TInt CFloggerTest024_07::executeStepL(TBool)
+	{
+	return KErrGeneral;
+	}
+
+/**
+* Function  Name		: executeStepL
+* Input parameters		: None
+* Output parameters		: TInt 
+* Description 			: This function checks for the flogger connection for 500 times
+
+*/
+
+
+TInt CFloggerTest024_07::executeStepL()
+	{
+	TInt ret = KErrNone;
+	ret = connectionTest();
+	if (ret == KErrNone)
+		{
+		TRAPD(r, ret = DoTestCheckWriteL());
+		if ( r != KErrNone)
+				ret = r;
+		}
+	return ret;
+	}
+
+
+TInt CFloggerTest024_07::connectionTest()
+	{
+	
+	_LIT8(KTestMessage,"TC 24_15: The flogger connection has been connected %d");
+	TPtrC8 ptrSubSystem;
+	TPtrC8 ptrComponent;
+	ptrSubSystem.Set(_L8("SubSystem"));
+	ptrComponent.Set(_L8("Component"));
+	TInt res = KErrNone;
+	RFileLogger flogger[KMaxConnection];
+
+	for(TInt i= 0; i<KMaxConnection; i++)
+		{
+		res = flogger[i].Connect();
+		if (res == KErrNone)
+			{
+			res = flogger[i].SetLogTags(ptrSubSystem, ptrComponent);
+			if (res == KErrNone)	
+				{
+				if (i == 0)
+					flogger[0].ClearLog();	// Clear previous test cases messages
+				flogger[i].WriteFormat(KTestMessage, i);
+				}
+			else
+				return KErrGeneral;
+			}
+		
+		else
+			{
+			INFO_PRINTF2(_L("Flogger connection failed for connection at -> %d "), i);
+			return KErrGeneral;
+			}
+	User::After(KTimeBetConnection);
+		}
+
+	for(TInt j= 0; j<KMaxConnection; j++)
+		flogger[j].Close();
+
+	User::After(KDelayToCheckWrite);
+	
+	return KErrNone;
+
+	}
+
+TInt CFloggerTest024_07::DoTestCheckWriteL()
+	{
+	User::After(KTimeToLog);
+	RFile theFile;
+	HBufC8 * hBuffer;
+	TInt listfilesize;
+	TInt returnCode;
+	RFs fileSystem; //For file operation create a file system	
+	_LIT(KLogFile,"c:\\logs\\log.txt"); // the log file path
+
+	TBuf8<256> testData; //To hold the test descriptor
+
+	_LIT8(KTestMessage,"TC 24_15: The flogger connection has been connected %d");
+	
+
+	User::LeaveIfError(fileSystem.Connect());
+	
+	//Open the file in the read mode
+	User::LeaveIfError(theFile.Open(fileSystem,KLogFile,EFileRead)); 
+
+	CleanupClosePushL(theFile);	
+	
+	User::LeaveIfError(returnCode = theFile.Size(listfilesize)); //Size of the file
+	hBuffer = HBufC8::New(listfilesize); //Allocate the buffer
+	CleanupStack::PushL(hBuffer);
+	TPtr8 ptrString = hBuffer->Des();  ; //To hold the buffer
+
+	// Read from position 0: start of file
+	returnCode = theFile.Read(ptrString);
+	
+	for(TInt i =0; i<KMaxConnection; i++)
+	{
+	testData.Format(KTestMessage, i);
+	returnCode = ptrString.Find(testData); //find the test descriptor in the buffer read
+												//from the file
+	if (returnCode > 0)
+		continue;
+	else
+		User::Leave(KErrGeneral);
+	}
+
+	CleanupStack::PopAndDestroy(hBuffer);
+	CleanupStack::PopAndDestroy(); // For theFile object
+	if (returnCode > 0)
+		return KErrNone;
+	else 
+		return KErrGeneral;
+	}
+
+
+/**
+* 024_08: Test that flogger handles date changes
+*/ 
+
+
+CFloggerTest024_08::CFloggerTest024_08()
+	{
+	// Store the name of this test case
+	SetTestStepName(_L("step_024_08"));
+	}
+
+
+
+
+CFloggerTest024_08::~CFloggerTest024_08()
+	{
+	}
+
+
+
+
+TVerdict CFloggerTest024_08::doTestStepL( )
+	{
+	if ( executeStepL() == KErrNone  )
+		SetTestStepResult(EPass);
+
+	else
+		SetTestStepResult(EFail);
+
+	User::After(KTimeForDisplay);
+
+	
+	return TestStepResult();
+	}
+
+
+TInt CFloggerTest024_08::executeStepL(TBool)
+	{
+	return KErrGeneral;
+	}
+
+TInt CFloggerTest024_08::executeStepL()
+	{
+	TInt ret ;
+	RFileLogger theFlogger; 
+	
+	//Just to clear the old log message
+	ret = theFlogger.Connect(); 
+	if ( ret == KErrNone)
+		ret = theFlogger.SetLogTags(KStdSubsysTag8, KStdCompTag8);
+		if ( ret == KErrNone)
+			ret = theFlogger.ClearLog();
+			if ( ret == KErrNone)
+				theFlogger.Close();
+
+	// perform test. write some data, roll the date to 0 the following day. write more data.
+	if ( ret == KErrNone)
+		{
+		RFileLogger ::Write(KStdSubsysTag16, KStdCompTag16,EFileLoggingModeAppend, KTestMessage);
+		
+		TTime time;
+		time.HomeTime();
+		TInt item;
+		TDateTime dateTime(time.DateTime());
+		dateTime.SetHour(0);
+		dateTime.SetMinute(0);
+		dateTime.SetSecond(0);
+		item = dateTime.Day();
+		if ((dateTime.SetDay(++item) != KErrNone))
+			{
+			dateTime.SetDay(0);
+			item = dateTime.Month();
+			if (item == EDecember)
+				{
+				dateTime.SetMonth(EJanuary);
+				item = dateTime.Year();
+				dateTime.SetYear(item++);
+				}
+			else
+				{
+				dateTime.SetMonth(TMonth(item++));
+				}
+			}
+		time = TTime(dateTime);
+	
+		User::SetHomeTime(time);
+		TTime currentMicrosecs;
+		currentMicrosecs.HomeTime();
+
+		RFileLogger ::Write(KStdSubsysTag16, KStdCompTag16,EFileLoggingModeAppend, KTestMessage);
+		User::After(KTimeToLog);
+		TRAPD(r, ret = DoTestCheckWriteL());
+		if (r != KErrNone)
+			ret = r;
+
+		}
+	return ret;
+
+	}
+
+
+
+/**
+* This function checks whether test data was written
+* 						  in to the log file .				  
+*/
+
+
+TInt CFloggerTest024_08::DoTestCheckWriteL()
+	{
+	RFile theFile;
+	HBufC8 * hBuffer;
+	TInt listfilesize,returnCode;
+	RFs fileSystem; //For file operation create a file system
+	TBuf8<256> testData; //To hold the test descriptor
+	TInt numSuccessful = 0;
+
+
+	_LIT8(KOOMError, "#Logs may be lost out of memory!!");
+	
+	User::LeaveIfError(fileSystem.Connect());
+	
+	//Open the file in the read mode
+	User::LeaveIfError(theFile.Open(fileSystem,KFloggerOutputFile,EFileRead)); 
+
+	CleanupClosePushL(theFile);
+
+	User::LeaveIfError(theFile.Size(listfilesize)); //Size of the file
+	
+	hBuffer = HBufC8::New(listfilesize); //Allocate the buffer
+	CleanupStack::PushL(hBuffer);
+
+	TPtr8 ptrString = hBuffer->Des();  ; //To hold the buffer
+
+	// Read from position 0: start of file
+	User::LeaveIfError(returnCode = theFile.Read(ptrString));
+	
+	testData.Copy(KTestMessage); //Copy the test descriptor
+	returnCode = ptrString.Find(testData); //find the test descriptor in the buffer read
+											//from the file
+	if (returnCode > 0)
+		{
+		numSuccessful++;
+		}
+											
+	// We expect to see the string "date change"
+	testData.Copy(KDateChangeMessage); //Copy the test descriptor
+	returnCode = ptrString.Find(testData); //find the test descriptor in the buffer read
+
+	if (returnCode > 0)
+		{
+		numSuccessful++;
+		}
+
+
+	if (returnCode == KErrNotFound)
+		{
+		returnCode = ptrString.Find(KOOMError);
+		if (returnCode > 0)
+			User::Leave(KErrNoMemory);
+		}
+
+
+	
+	CleanupStack::PopAndDestroy(hBuffer);
+	CleanupStack::PopAndDestroy();	//theFile
+	if (numSuccessful == 2)
+		return KErrNone;
+	else 
+		return KErrNotFound;
+	}
+
+
+
+