/*

 * Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved.

 * This component and the accompanying materials are made available

 * under the terms of the License "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: 

 * test tool step implementation

 *

 */

 /**

  @file

 */

 #include <e32std.h>

 #include "ttesttoolstep.h"

 _LIT8(KLabel,"label");

 const TChar KCarriageReturn = '\r';

 const TChar KLineReturn = '\n';

 const TChar KDelemeter = ':';

 HBufC8* ParseOutputFileLC(const TPtrC& aFileName);

 TInt ReadWordL(const TDesC8& aBuffer, TInt& aPos, TPtrC8& aLine);

 void ConstuctExpectedArrayL(RPointerArray<HBufC>& aArray, const TDesC8& aBuffer,TBool aCheck, TBool aException = EFalse);

 void ResetAndDestroyHBufCList(TAny* aList);

 //

 // CTestToolListCertStep

 //

 CTestToolListCertStep::~CTestToolListCertStep()

 	{

 	}

 CTestToolListCertStep::CTestToolListCertStep()

 	{

 	// Call base class method to set up the human readable name for logging

 	SetTestStepName(KTestToolListCertStep);

 	}

 /**

  * Override of base class virtual. Prepares for the test run of Filetokens

  * @return TVerdict code

  */

 TVerdict CTestToolListCertStep::doTestStepPreambleL()

 	{

 	_LIT(KActualOutput, "actualoutput");

 	GetStringFromConfig(ConfigSection(), KActualOutput, iActualOutput);	

 	// construct name of the cert

 	if (GetStringFromConfig(ConfigSection(), KExpectedOwner, iExpectedOwner))

 		{

 		iOwnerExist = 1;	

 		}

 	if (!GetIntFromConfig(ConfigSection(), KExpectedListStore, iListStoreExist))

 		{

 		iListStoreExist = 0;	

 		}

 	if(!GetIntFromConfig(ConfigSection(), KStore, iExpectedStore))

 		{

 		iExpectedStore = -1;

 		}

 	if(!GetIntFromConfig(ConfigSection(), KExpectedNumLabel, iExpectedNumLabel))

 		{

 		iExpectedNumLabel = 1;

 		}

 	if (GetStringFromConfig(ConfigSection(), KExpectedLabel1, iExpectedLabel1))

 		{

 		iLabel1Exist = 1;		

 		}

 	if (GetStringFromConfig(ConfigSection(), KExpectedLabel2, iExpectedLabel2))

 		{

 		iLabel2Exist = 1;		

 		}

 	return TestStepResult();

 	}

 /**

  * Override of base class pure virtual

  * Demonstrates reading configuration parameters from an ini file section

  * @return TVerdict code

  */

 TVerdict CTestToolListCertStep::doTestStepL()

 	{

 	if (TestStepResult() != EPass)

 		{

 		return TestStepResult();

 		}

 	CActiveScheduler* sched = NULL;

 	sched = new (ELeave) CActiveScheduler;

 	CleanupStack::PushL(sched);

 	CActiveScheduler::Install(sched);	

 	CTestToolEngine* activeEngine = CTestToolEngine::NewLC();

 	if (iLabel1Exist && !iLabel2Exist)

 		{

 		iVerdict = activeEngine->ListCerts(iExpectedLabel1, iExpectedNumLabel);

 		}

 	else if (iLabel2Exist && iLabel1Exist)

 		{

 		iVerdict = activeEngine->ListCerts(iExpectedLabel1, iExpectedLabel2, iExpectedNumLabel);

 		}

 	else

 		{

 		RPointerArray<HBufC> CertList;

 		CleanupStack::PushL(TCleanupItem(ResetAndDestroyHBufCList, &CertList));

 		HBufC8* fileContents = ParseOutputFileLC(iActualOutput);

 		if (iListStoreExist)

 			{

 			_LIT8(KLabel1, "label:");

 			TLex8 lex(*fileContents);

 			while(!lex.Eos())

                 {

                 TPtrC8 token = lex.NextToken();

                 if(token.CompareF(KLabel1) == KErrNone)

                 	{

                 	TInt offset = lex.Offset();

                 	TChar c = lex.Get();

                 	while(c != KCarriageReturn && c != KLineReturn)

                 		{

                 		c = lex.Get();

                 		} 

                 	TInt end = lex.Offset();

                 	TPtrC8 newtoken;

                 	TInt tokenLen = end-offset-1;

 					newtoken.Set(&fileContents->Des()[offset], tokenLen);

                 	HBufC* tmp = HBufC::NewLC(tokenLen);

                 	tmp->Des().Copy(newtoken);

                 	tmp->Des().Trim();

                 	CertList.Append(tmp);

                 	CleanupStack::Pop(tmp);

                 	}

                 }

 			CleanupStack::PopAndDestroy(fileContents);

 			iVerdict = activeEngine->ListStore(CertList);

 			}

 		else

 			{

 			ConstuctExpectedArrayL(CertList, fileContents->Des(), ETrue);

 			CleanupStack::PopAndDestroy(fileContents);

 			if (iOwnerExist)

 				{

 				iVerdict = activeEngine->ListCerts(CertList, iExpectedOwner);

 				}

 			else if (iExpectedStore != -1)

 				{

 				iVerdict = activeEngine->ListCerts(CertList, iExpectedStore);

 				}

 			else

 				{

 				iVerdict = activeEngine->ListCerts(CertList);	

 				}

 			}

 		CleanupStack::PopAndDestroy(&CertList);

 		}

 	CleanupStack::PopAndDestroy(2, sched);

 	if (iVerdict == EFail)

 		{

 		INFO_PRINTF1(_L("Expected Certificate does not Exist"));

 		}

 	SetTestStepResult(iVerdict);

 	return TestStepResult();

 	}

 /**

  * Override of base class virtual

  * @return TVerdict code

  */

 TVerdict CTestToolListCertStep::doTestStepPostambleL()

 	{

 	CActiveScheduler::Install(NULL);

 	return TestStepResult();

 	}

 //

 // CTestToolGetTrustAppsStep

 //

 CTestToolGetTrustAppsStep::~CTestToolGetTrustAppsStep()

 	{

 	iApps.ResetAndDestroy();

 	}

 CTestToolGetTrustAppsStep::CTestToolGetTrustAppsStep()

 	{

 	// Call base class method to set up the human readable name for logging

 	SetTestStepName(KTestToolGetTrustAppsStep);

 	}

 /**

  * Override of base class virtual. Prepares for the test run of Filetokens

  * @return TVerdict code

  */

 TVerdict CTestToolGetTrustAppsStep::doTestStepPreambleL()

 	{

 	_LIT(KNumApps, "numapps"); // this specifies how many commands to read

 	_LIT(KAppsBase, "apps"); // + number (0-based) = file to check for

 	if (!GetStringFromConfig(ConfigSection(), KExpectedLabel1, iExpectedLabel))

 		{

 		INFO_PRINTF1(_L("label name is missing"));

 		SetTestStepResult(EFail);

 		}

 	TInt numApps = 0;

 	if (GetIntFromConfig(ConfigSection(), KNumApps, numApps) && numApps!=0)

 		{

 		TPtrC appName;

 		for (TInt i=0; i<numApps; i++)

 			{

 			// construct name of the key

 			const TInt KKeyBufSize=64;

 			TBuf<KKeyBufSize> keyBuf(KAppsBase);

 			keyBuf.AppendNum(i);

 			if (GetStringFromConfig(ConfigSection(), keyBuf, appName))

 				{			

 				HBufC* apps = appName.AllocLC();

 				iApps.AppendL(apps);

 				CleanupStack::Pop(apps);								

 				}

 			else

 				{

 				SetTestStepResult(EFail);

 				// the string must exist, otherwise the config is invalid

 				ERR_PRINTF2(_L("Missing apps name for key '%S'"), &keyBuf);

 				}

 			}

 		}

 	return TestStepResult();

 	}

 /**

  * Override of base class pure virtual

  * Demonstrates reading configuration parameters from an ini file section

  * @return TVerdict code

  */

 TVerdict CTestToolGetTrustAppsStep::doTestStepL()

 	{

 	if (TestStepResult() != EPass)

 		{

 		return TestStepResult();

 		}

 	CActiveScheduler* sched = NULL;

 	sched = new (ELeave) CActiveScheduler;

 	CleanupStack::PushL(sched);

 	CActiveScheduler::Install(sched);	

 	CTestToolEngine* activeEngine = CTestToolEngine::NewLC();

 	iVerdict = activeEngine->CheckApps(iApps, iExpectedLabel);

 	CleanupStack::PopAndDestroy(2, sched);

 	if (iVerdict == EFail)

 		{

 		INFO_PRINTF1(_L("Certificate is not trusted for the applicaion"));

 		}

 	SetTestStepResult(iVerdict);

 	return TestStepResult();

 	}

 /**

  * Override of base class virtual

  * @return TVerdict code

  */

 TVerdict CTestToolGetTrustAppsStep::doTestStepPostambleL()

 	{

 	CActiveScheduler::Install(NULL);

 	return TestStepResult();

 	}

 //

 // CTestToolListKeyStep

 //

 CTestToolListKeyStep::~CTestToolListKeyStep()

 	{

 	}

 CTestToolListKeyStep::CTestToolListKeyStep()

 	{

 	// Call base class method to set up the human readable name for logging

 	SetTestStepName(KTestToolListKeyStep);

 	}

 /**

  * Override of base class virtual. Prepares for the test run of Filetokens

  * @return TVerdict code

  */

 TVerdict CTestToolListKeyStep::doTestStepPreambleL()

 	{

 	// construct name of the key

 	GetStringFromConfig(ConfigSection(), KActualOutput, iActualOutput);	

 	if (!GetIntFromConfig(ConfigSection(), KExpectedListStore, iListStoreExist))

 		{

 		iListStoreExist = 0;	

 		}

 	if(!GetIntFromConfig(ConfigSection(), KStore, iExpectedStore))

 		{

 		iExpectedStore = -1;

 		}

 	if(!GetIntFromConfig(ConfigSection(), KExpectedNumLabel, iExpectedNumLabel))

 		{

 		iExpectedNumLabel = 1;

 		}

 	if (GetStringFromConfig(ConfigSection(), KExpectedLabel1, iExpectedLabel1))

 		{

 		iLabel1Exist = 1;		

 		}

 	if (GetStringFromConfig(ConfigSection(), KExpectedLabel2, iExpectedLabel2))

 		{

 		iLabel2Exist = 1;		

 		}

 	return TestStepResult();

 	}

 /**

  * Override of base class pure virtual

  * Demonstrates reading configuration parameters from an ini file section

  * @return TVerdict code

  */

 TVerdict CTestToolListKeyStep::doTestStepL()

 	{

 	if (TestStepResult() != EPass)

 		{

 		return TestStepResult();

 		}

 	CActiveScheduler* sched = NULL;

 	sched = new (ELeave) CActiveScheduler;

 	CleanupStack::PushL(sched);

 	CActiveScheduler::Install(sched);	

 	CTestToolEngine* activeEngine = CTestToolEngine::NewLC();

 	if (iLabel1Exist && !iLabel2Exist)

 		{

 		iVerdict = activeEngine->ListKeys(iExpectedLabel1, iExpectedNumLabel);

 		}

 	else if (iLabel2Exist && iLabel1Exist)

 		{

 		iVerdict = activeEngine->ListKeys(iExpectedLabel1, iExpectedLabel2, iExpectedNumLabel);

 		}

 	else

 		{

 		RPointerArray<HBufC> KeyList;

 		CleanupStack::PushL(TCleanupItem(ResetAndDestroyHBufCList, &KeyList));

 		HBufC8* fileContents = ParseOutputFileLC(iActualOutput);

 		if (iListStoreExist)

 			{

 			_LIT8(KLabel1, "label:");

 			TLex8 lex(*fileContents);

 			while(!lex.Eos())

                 {

                 TPtrC8 token = lex.NextToken();

                 if(token.CompareF(KLabel1) == KErrNone)

                 	{

                 	TInt offset = lex.Offset();

                 	TChar c = lex.Get();

                 	while(c != KCarriageReturn && c != KLineReturn)

                 		{

                 		c = lex.Get();

                 		} 

                 	TInt end = lex.Offset();

                 	TPtrC8 newtoken;

                 	TInt tokenLen = end-offset-1;

 					newtoken.Set(&fileContents->Des()[offset], tokenLen);

                 	HBufC* tmp = HBufC::NewLC(tokenLen);

                 	tmp->Des().Copy(newtoken);

                 	tmp->Des().Trim();

                 	KeyList.Append(tmp);

                 	CleanupStack::Pop(tmp);

                 	}

                 }

 			CleanupStack::PopAndDestroy(fileContents);

 			iVerdict = activeEngine->ListStoreKey(KeyList);

 			}

 		else

 			{

 			ConstuctExpectedArrayL(KeyList, fileContents->Des(), EFalse);

 			CleanupStack::PopAndDestroy(fileContents);

 			if (iExpectedStore != -1)

 				{

 				iVerdict = activeEngine->ListKeys(KeyList, iExpectedStore);

 				}

 			else

 				{

 				iVerdict = activeEngine->ListKeys(KeyList);	

 				}

 			}

 		CleanupStack::PopAndDestroy(&KeyList); 

 		}

 	CleanupStack::PopAndDestroy(2, sched);

 	if (iVerdict == EFail)

 		{

 		INFO_PRINTF1(_L("Expected Keys do not Exist"));

 		}

 	SetTestStepResult(iVerdict);

 	return TestStepResult();

 	}

 /**

  * Override of base class virtual

  * @return TVerdict code

  */

 TVerdict CTestToolListKeyStep::doTestStepPostambleL()

 	{

 	CActiveScheduler::Install(NULL);

 	return TestStepResult();

 	}

 //

 // CTestToolGetPolicyStep

 //

 CTestToolGetPolicyStep::~CTestToolGetPolicyStep()

 	{

 	}

 CTestToolGetPolicyStep::CTestToolGetPolicyStep()

 	{

 	// Call base class method to set up the human readable name for logging

 	SetTestStepName(KTestToolGetPolicyStep);

 	}

 /**

  * Override of base class virtual. Prepares for the test run of Filetokens

  * @return TVerdict code

  */

 TVerdict CTestToolGetPolicyStep::doTestStepPreambleL()

 	{

 	// construct name of the key

 	if (GetStringFromConfig(ConfigSection(), KExpectedLabel1, iExpectedLabel))

 		{

 		iLabelExist = 1;		

 		}

 	if (!GetStringFromConfig(ConfigSection(), KExpectedUser, iExpectedUser))

 		{

 		INFO_PRINTF1(_L("policy user name is missing"));

 		SetTestStepResult(EFail);

 		}

 	if (!GetIntFromConfig(ConfigSection(), KExpectedUserExist, iExpectedUserExist))

 		{

 		iExpectedUserExist = 0;

 		}

 	return TestStepResult();

 	}

 /**

  * Override of base class pure virtual

  * Demonstrates reading configuration parameters from an ini file section

  * @return TVerdict code

  */

 TVerdict CTestToolGetPolicyStep::doTestStepL()

 	{

 	if (TestStepResult() != EPass)

 		{

 		return TestStepResult();

 		}

 	CActiveScheduler* sched = NULL;

 	sched = new (ELeave) CActiveScheduler;

 	CleanupStack::PushL(sched);

 	CActiveScheduler::Install(sched);	

 	CTestToolEngine* activeEngine = CTestToolEngine::NewLC();

     if (iLabelExist)

 		{

 		iVerdict = activeEngine->GetPolicy(iExpectedLabel, iExpectedUser, iExpectedUserExist);

 		}

 	CleanupStack::PopAndDestroy(2, sched);

 	if (iVerdict == EFail)

 		{

 		INFO_PRINTF1(_L("Exptected Keys are not Exist"));

 		}

 	SetTestStepResult(iVerdict);

 	return TestStepResult();

 	}

 /**

  * Override of base class virtual

  * @return TVerdict code

  */

 TVerdict CTestToolGetPolicyStep::doTestStepPostambleL()

 	{

 	CActiveScheduler::Install(NULL);

 	return TestStepResult();

 	}

 //

 // CTestToolParseFileStep

 //

 CTestToolParseFileStep::~CTestToolParseFileStep()

 	{

 	iArgs.ResetAndDestroy();

 	}

 CTestToolParseFileStep::CTestToolParseFileStep()

 	{

 	// Call base class method to set up the human readable name for logging

 	SetTestStepName(KTestToolParseFileStep);

 	}

 /**

  * Override of base class virtual. Prepares for the test run of Filetokens

  * @return TVerdict code

  */

 TVerdict CTestToolParseFileStep::doTestStepPreambleL()

 	{

 	_LIT(KNumLines, "numlines"); // this specifies how many commands to read

 	_LIT(KLineBase, "line"); // + number (0-based) = file to check for

 	TInt numlines = 0;

 	if (GetIntFromConfig(ConfigSection(), KNumLines, numlines) && numlines!=0)

 		{

 		TPtrC lineContent;

 		for (TInt i=0; i<numlines; i++)

 			{

 			// construct name of the key

 			const TInt KKeyBufSize=64;

 			TBuf<KKeyBufSize> keyBuf(KLineBase);

 			keyBuf.AppendNum(i);

 			if (GetStringFromConfig(ConfigSection(), keyBuf, lineContent))

 				{			

 				HBufC* line = lineContent.AllocLC();

 				line->Des().Trim();

 				iArgs.AppendL(line);

 				CleanupStack::Pop(line);								

 				}

 			else

 				{

 				SetTestStepResult(EFail);

 				// the string must exist, otherwise the config is invalid

 				ERR_PRINTF2(_L("Missing apps name for key '%S'"), &keyBuf);

 				}

 			}

 		}

 	if (!GetStringFromConfig(ConfigSection(), KActualOutput, iActualOutput))

 			{

 			INFO_PRINTF1(_L("actual output filename is missing"));

 			SetTestStepResult(EFail);	

 			}

 	if (numlines == 0)

 		{

 		if (!GetStringFromConfig(ConfigSection(), KExpectedError, iExpectedError))

 			{

 			INFO_PRINTF1(_L("error value is missing"));

 			SetTestStepResult(EFail);

 			}

 		}

 	return TestStepResult();

 	}

 /**

  * Override of base class pure virtual

  * Demonstrates reading configuration parameters from an ini file section

  * @return TVerdict code

  */

 TVerdict CTestToolParseFileStep::doTestStepL()

 	{

 	if (TestStepResult() != EPass)

 		{

 		return TestStepResult();

 		}

 	if (iArgs.Count() == 0)

 		{

 		HBufC8* fileContents = ParseOutputFileLC(iActualOutput);

 		HBufC8* actualError = GetErrorFromOutputFileLC(*fileContents);

 		if (actualError == NULL)

 			{

 			INFO_PRINTF1(_L("Failed to parse the output File"));

 			SetTestStepResult(EFail);

 			}

 		HBufC* actual16 = HBufC::NewLC(actualError->Length());

 		actual16->Des().Copy(*actualError);

 		if (iExpectedError.CompareF(*actual16) != KErrNone)

 			{

 			INFO_PRINTF1(_L("Expected Error is Different from Actual"));

 			SetTestStepResult(EFail);

 			}

 		CleanupStack::PopAndDestroy(3, fileContents); //actual16, actualError, fileContents

 		}

 	else

 		{

 		HBufC8* fileContents = ParseOutputFileLC(iActualOutput);

 		RPointerArray<HBufC> actualoutput;

 		CleanupStack::PushL(TCleanupItem(ResetAndDestroyHBufCList, &actualoutput));

 		ConstuctExpectedArrayL(actualoutput, fileContents->Des(), EFalse, ETrue);

 		TBool result = EFalse;

 		for (TInt i = 0; i < iArgs.Count(); i++)

 			{

 			result = EFalse;

 			for (TInt j = 5; j < actualoutput.Count(); j++)

 				{

 				if (iArgs[i]->Des().CompareF(actualoutput[j]->Des()) == KErrNone)

 					{

 					result = ETrue;

 					break;

 					}

 				}

 			if (!result)

 				{

 				break;

 				}

 			}

 		if (!result)

 			{

 			INFO_PRINTF1(_L("expected output and actual output is not matching"));

 			SetTestStepResult(EFail);

 			}

 		CleanupStack::PopAndDestroy(2, fileContents); // fileContents ,actualoutput

 		}

 	return TestStepResult();

 	}

 HBufC8* CTestToolParseFileStep::GetErrorFromOutputFileLC(const TDesC8& aBuffer)

 	{

 	_LIT8(KOutput, "output");

 	TInt readPos = 0;

 	TPtrC8 wordContents;

 	HBufC8* wordBuf = NULL;

 	while (!ReadWordL(aBuffer, readPos, wordContents))

 		{

 		wordBuf = wordContents.AllocLC();

 		wordBuf->Des().Trim();

 		if (wordBuf->Des().CompareF(KOutput) == KErrNone)

 			{

 			readPos+=1;

 			if (!ReadWordL(aBuffer, readPos, wordContents))

 				{

 				CleanupStack::PopAndDestroy(wordBuf);

 				wordBuf = wordContents.AllocLC();

 				wordBuf->Des().Trim();

 				break;

 				}

 			}

 		CleanupStack::PopAndDestroy(wordBuf);

 		}

 	return wordBuf;		

 	}

 /**

  * Override of base class virtual

  * @return TVerdict code

  */

 TVerdict CTestToolParseFileStep::doTestStepPostambleL()

 	{

 	CActiveScheduler::Install(NULL);

 	return TestStepResult();

 	}

 //

 // global public methods

 //

 // Reads the words from the Buffer either ended with : or \n 

 // if the word is "label", then read the next word and add to the array 

 // if the word is not label read upto the end of the line then go to next loop

 // if exception is on , reads the entire line

 void ConstuctExpectedArrayL(RPointerArray<HBufC>& aArray, const TDesC8& aBuffer,TBool aCheck, TBool aException)

 	{

 	TInt readPos = 0;

 	TPtrC8 wordContents;

 	TInt bufferLength = aBuffer.Length();

 	while (!ReadWordL(aBuffer, readPos, wordContents))

 		{

 		HBufC8* wordBuf = wordContents.AllocLC();

 		wordBuf->Des().Trim();

 		if (aException)

 			{

 			HBufC* currentLabel = HBufC::NewLC(wordBuf->Length());

 			currentLabel->Des().Copy(*wordBuf);

 			currentLabel->Des().Trim();

 			aArray.AppendL(currentLabel);

 			CleanupStack::Pop(currentLabel);			

 			}

 		else if (wordBuf->Des().CompareF(KLabel) == KErrNone)

 			{

 			if (!ReadWordL(aBuffer, readPos, wordContents))

 				{

 				TPtrC8 word;

 				TInt len = wordContents.Length();

 				// aCheck is on for reading the certool output file,because the output will be like this

 				// label: abc      format:.... ,  so we need to exclude format

 				if (aCheck) // certdetails 

 					{

 					len = len - 6;	

 					}		

 				word.Set(wordContents.Ptr(), len);

 				HBufC* currentLabel = HBufC::NewLC(word.Length());

 				currentLabel->Des().Copy(word);

 				currentLabel->Des().Trim();

 				aArray.AppendL(currentLabel);

 				CleanupStack::Pop(currentLabel);			

 				}

 			else

 				{

 				break;

 				}

 			}

 		else

 			{

 			readPos--;

 			while (readPos < bufferLength)

 				{

 				TChar c = aBuffer[readPos];

 				if (c == KCarriageReturn || c == KLineReturn) 

 					{

 					readPos += 1;

 					break;

 					}	

 				readPos++;

 				}	

 			}

 		CleanupStack::PopAndDestroy(wordBuf);

 		}

 	}

 // Reads the output file and return into the buffer.

 HBufC8* ParseOutputFileLC(const TPtrC& aFileName)

 	{

 	RFs fs;

 	RFile file;

 	User::LeaveIfError(fs.Connect());

 	CleanupClosePushL(fs);

 	User::LeaveIfError(file.Open(fs, aFileName, EFileRead));

 	CleanupClosePushL(file);

 	TInt fSize;

 	file.Size(fSize);

 	HBufC8* fileContents = HBufC8::NewLC(fSize);

 	TPtr8 ptr(fileContents->Des());

 	ptr.SetLength(fSize);

 	// create file stream and Read the content from the file

 	RFileReadStream inputFileStream(file);

     CleanupClosePushL(inputFileStream);

 	inputFileStream.ReadL(ptr, fSize);

 	CleanupStack::PopAndDestroy(&inputFileStream);

 	CleanupStack::Pop(fileContents);

 	CleanupStack::PopAndDestroy(2, &fs);

 	CleanupStack::PushL(fileContents);

 	return fileContents;

 	}

 // Reads the words from the aBuffer either ended with : or \n or \r

 TInt ReadWordL(const TDesC8& aBuffer, TInt& aPos, TPtrC8& aLine)

 	{

 	TBool endOfBuffer = EFalse;

 	TInt bufferLength = aBuffer.Length();

 	if ( aPos > bufferLength || aPos < 0 )

 		{	

 		return ETrue; // End of buffer

 		}

 	TInt endPos = aPos;

 	// find the position of the next delimeter		

 	endPos = aPos;	

 	while (endPos < bufferLength)

 		{

 		TChar c = aBuffer[endPos];

 		if (c == KCarriageReturn || c == KLineReturn || c == KDelemeter) 

 			{

 			// exception when comes like c:\filename

 			if ((bufferLength > (endPos + 1)) && aBuffer[endPos+1] != '\\')

 				{

 				break;	

 				}		

 			}	

 		endPos++;

 		}

 	if (endPos != aPos)	

 		{

 		TInt tokenLen = endPos - aPos;

 		aLine.Set(&aBuffer[aPos], tokenLen);

 		endPos += 1;

 		}

 	else if (endPos == bufferLength)

 		{

 		return ETrue; // End of buffer

 		}

 	else

 		{

 		endPos++;	

 		}

 	aPos = endPos;

 	return endOfBuffer;

 	}

 void ResetAndDestroyHBufCList(TAny* aList)

 	{

 	RPointerArray<HBufC>* list = static_cast<RPointerArray<HBufC>*>(aList);

 	list->ResetAndDestroy();

 	list->Close();

 	}

 //

 // CTestToolGetTrustStep

 //

 CTestToolGetTrustStep::~CTestToolGetTrustStep()

 	{

 	}

 CTestToolGetTrustStep::CTestToolGetTrustStep()

 	{

 	// Call base class method to set up the human readable name for logging

 	SetTestStepName(KTestToolGetTrustStep);

 	}

 /**

  * Override of base class virtual. Prepares for the test run of Filetokens

  * @return TVerdict code

  */

 TVerdict CTestToolGetTrustStep::doTestStepPreambleL()

 	{

 	if (!GetStringFromConfig(ConfigSection(), KExpectedLabel1, iExpectedLabel))

 		{

 		INFO_PRINTF1(_L("label name is missing"));

 		SetTestStepResult(EFail);

 		}

 	if (!GetIntFromConfig(ConfigSection(), KExpectedTrust, iExpectedTrust))

 		{

 		INFO_PRINTF1(_L("Expected trust is missing"));

 		SetTestStepResult(EFail);

 		}

 	return TestStepResult();

 	}

 /**

  * Override of base class pure virtual

  * Demonstrates reading configuration parameters from an ini file section

  * @return TVerdict code

  */

 TVerdict CTestToolGetTrustStep::doTestStepL()

 	{

 	if (TestStepResult() != EPass)

 		{

 		return TestStepResult();

 		}

 	CActiveScheduler* sched = NULL;

 	sched = new (ELeave) CActiveScheduler;

 	CleanupStack::PushL(sched);

 	CActiveScheduler::Install(sched);	

 	CTestToolEngine* activeEngine = CTestToolEngine::NewLC();

 	iVerdict = activeEngine->CheckTrust(iExpectedLabel,iExpectedTrust);

 	CleanupStack::PopAndDestroy(2, sched);

 	if (iVerdict == EFail)

 		{

 		INFO_PRINTF1(_L("Certificate is not trusted for the applicaion"));

 		}

 	SetTestStepResult(iVerdict);

 	return TestStepResult();

 	}

 /**

  * Override of base class virtual

  * @return TVerdict code

  */

 TVerdict CTestToolGetTrustStep::doTestStepPostambleL()

 	{

 	CActiveScheduler::Install(NULL);

 	return TestStepResult();

 	}

 CTestToolCheckFileStep::CTestToolCheckFileStep()

 	{}

 CTestToolCheckFileStep::~CTestToolCheckFileStep()

 	{}

 TVerdict CTestToolCheckFileStep::doTestStepPreambleL()

 	{

 	if (!GetStringFromConfig(ConfigSection(), KFileName,iFileName))

 		{

 		INFO_PRINTF1(_L("file name is missing"));

 		SetTestStepResult(EFail);

 		}

 	if (!GetStringFromConfig(ConfigSection(), KCheckType,iCheckType))

 		{

 		INFO_PRINTF1(_L("chek type for file is missing"));

 		SetTestStepResult(EFail);

 		}

 	return TestStepResult();

 	}

 TVerdict CTestToolCheckFileStep::doTestStepPostambleL()

 	{

 	return TestStepResult();

 	}

 TVerdict CTestToolCheckFileStep::doTestStepL()

 	{

 	if (TestStepResult() != EPass)

 		{

 		return TestStepResult();

 		}

 	RFs fs;

 	User::LeaveIfError(fs.Connect());

 	CleanupClosePushL(fs);

 	RFile file;

 	CleanupClosePushL(file);

 	TInt error = file.Open(fs,iFileName,EFileRead);

 	if( ( iCheckType.Compare(_L("present")) == 0 && error == KErrNone ) || 	

 		( iCheckType.Compare(_L("absent")) == 0 && error == KErrNotFound )

 		)

 		{

 		SetTestStepResult(EPass);

 		}

 	else

 		{

 		SetTestStepResult(EFail);

 		}

 	CleanupStack::PopAndDestroy(2,&fs); // file

 	return TestStepResult();

 	}

 // End of file