// Copyright (c) 2006-2009 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 "TestCompareCntFiles.h"

// Class CTestCompareCntFiles - Opens import/export vcf and carries out the verification of the properties

CTestCompareCntFiles::CTestCompareCntFiles()

	{

	SetTestStepName(KTestCompareCntFiles);

	}

CTestCompareCntFiles::~CTestCompareCntFiles()

	{

	delete iExportObj;

	}

TVerdict CTestCompareCntFiles::doTestStepPreambleL()

/**

 * @return - TVerdict code

 * Override of base class virtual

 */

	{

	INFO_PRINTF1(_L("Start verifcation of import/export vcf files"));

	SetTestStepResult(EPass);

	return TestStepResult();

	}

TVerdict CTestCompareCntFiles::doTestStepL()

/**

 * @return - TVerdict code

 * Override of base class pure virtual

 */

	{

	// connect to file system

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

	TESTL(TestStepResult() == EPass);

	INFO_PRINTF1(_L("CTestCompareCntFiles::doTestStepL() start"));

	TESTL(GetStringFromConfig(ConfigSection(), KExportFile, iExportFilePath));

	GetStringFromConfig(ConfigSection(), KExpectedExportFile, iExpectedExportFilePath);

	GetStringFromConfig(ConfigSection(), KFieldToVerify, iFieldToVerify);

	GetStringFromConfig(ConfigSection(), KNoField, iNoField);

	// Create Utility class object, to use TokenizeStringL

	CTestStep* self = static_cast<CTestStep*>(this);

	iExportObj = new(ELeave) CContactsPBAPExportUtilityClass(self);

	TokenizeAndCompareL();

	TokenizeAndCheckNoFieldL();

	// Comparing two files

	TBool compareFile = EFalse;

	GetBoolFromConfig(ConfigSection(), KCompareFile, compareFile);

	if(compareFile)

		{

		TBool fileCompare = EFalse;

		// Call CompareWholeFileL to use the normal comparison of two files, ignoring the REV property

		fileCompare = CompareWholeFileL(iExpectedExportFilePath, iExportFilePath);

		if(!fileCompare)

			{

			SetTestStepResult(EFail);

			}

		}

	iFsSession.Close();

	INFO_PRINTF1(_L("CTestCompareCntFiles::doTestStepL() finish"));

	return TestStepResult();

	}

/** Compares 2 vcf fie

@param	aExpectedFile The expected vcf file

@param	aFile This is the vcf file produced, and will be compared against aExpectedFile

@param	aProperty This is the property we are interested in 

*/

void CTestCompareCntFiles::CompareFileL(const TDesC& aExpectedFile, const TDesC& aFile, TDes8& aProperty)

	{

	RFile fileExpected;

	RFile fileOutput;

	CleanupClosePushL(fileExpected);

	CleanupClosePushL(fileOutput);

	TInt err = KErrNone;

	err = fileExpected.Open(iFsSession, aExpectedFile, EFileRead);

	if (err != KErrNone)

		{

		ERR_PRINTF2(_L("Unable to open file: %S"), &aExpectedFile);

		SetTestStepResult(EFail);

		SetTestStepError(err);

		}

	err = fileOutput.Open(iFsSession, aFile, EFileRead);

	if (err != KErrNone)

		{

		ERR_PRINTF2(_L("Unable to open file: %S"), &aFile);

		SetTestStepResult(EFail);

		SetTestStepError(err);

		}

	RFileReadStream streamExpected(fileExpected);

	RFileReadStream streamOutput(fileOutput);

	CleanupClosePushL(streamExpected);

	CleanupClosePushL(streamOutput);

	TBuf8<0x80> bufExpected,bufOutput;

	TBool isProperty = EFalse;

	TBool isPropertyExpected = EFalse;

	TBool foundBothProperty = EFalse;

	TBool flag = EFalse;

	TInt err1 = KErrNone;

	do  // This do loop iterates through both files, until the end of file is found

		{

		do // This do loop iterates thorugh both files until both properties are found and compares them

			{

			foundBothProperty = EFalse;

			if (!isProperty)

				{

				TRAP(err, streamExpected.ReadL(bufExpected, KLinefeedChar));

				}

			if (!isPropertyExpected)

				{

				TRAP(err1, streamOutput.ReadL(bufOutput, KLinefeedChar));

				}

			if (err != KErrEof || err1 != KErrEof)

				{

				isProperty = IsPropertyPresent(bufExpected, aProperty); // checks if aProperty

				if(isProperty && err1 == KErrEof)

					{

					break;	

					}

				isPropertyExpected = IsPropertyPresent(bufOutput, aProperty); // checks if aProperty

				}

			else

				{

				break;

				}

			if ((isProperty) && (isPropertyExpected))

				{

				foundBothProperty = ETrue;

				flag = ETrue;

				}

			} while (!foundBothProperty); // exit 2nd do loop when both properties found

		// Exists 2nd do loop, so both properties are found

		if (err != KErrEof && err1 != KErrEof)

			{

			if(aProperty != KRevision)

				{

				CompareLinesL(bufExpected, bufOutput); // compares both properties	

				}

			else 

				{

				break;

				}

			}

		// After comparing, gets the next property parameters in vcs file, if we have not reached end of file

		TRAP(err, streamExpected.ReadL(bufExpected, KLinefeedChar));

		TRAP(err1, streamOutput.ReadL(bufOutput, KLinefeedChar));

		} while (err != KErrEof || err1 != KErrEof); // exits 2nd do loop when its reached the end of either file

	TBuf<KMaxLengthField> buf;

	buf.Copy(aProperty);

	TPtrC ptr(buf);

	if(flag)

		{

		INFO_PRINTF2(_L("Property: %S Exported properly"), &ptr);	

		}

	else

		{

		INFO_PRINTF2(_L("Property: %S not exported"), &ptr);

		SetTestStepResult(EFail);

		}

	CleanupStack::PopAndDestroy(4, &fileExpected);

	}

/** Checks if the line of data contains the property (aProperty) parameter

@param	aLine The line of data to check

@return	True or False indicating if property found in the line of data

*/

TBool CTestCompareCntFiles::IsPropertyPresent(const TDesC8& aLine, TDes8& aProperty)

	{

	TInt propertyLength = aProperty.Length();

	TBuf8<KMaxLengthField> propertyFromLine(aLine.Left(propertyLength));

	if (!propertyFromLine.Compare(aProperty))

		{

		return ETrue;

		}

	else

		{

		return EFalse;

		}

	}

/** Compares two lines of data

@param	aBufExpected The line of data to compare with aBufOutput

@param	aBufOutput The second line of data to compare to aBufExpected

*/

void CTestCompareCntFiles::CompareLinesL(const TDesC8& aBufExpected, const TDesC8& aBufOutput)

	{

	TESTL(!aBufExpected.Compare(aBufOutput));	

	}

/** Checks for any field that should have not been exported

@param	aFile The vcs file to open

*/

TBool CTestCompareCntFiles::CheckForNoFieldL(const TDesC& aFile, const TDesC& aProperty)

	{

	RFile fileOutput;

	CleanupClosePushL(fileOutput);

	TInt err = fileOutput.Open(iFsSession, aFile, EFileRead);

	if (err != KErrNone)

		{

		ERR_PRINTF2(_L("Unable to open file: %S"), &aFile);

		SetTestStepResult(EFail);

		SetTestStepError(err);

		}

	RFileReadStream streamOutput(fileOutput);

	CleanupClosePushL(streamOutput);

	TBuf8<0x80> bufOutput;

	TBool result;

	TBuf8<KMaxLengthField> noField;

	noField.Copy(aProperty);

	do

		{

		TRAP(err, streamOutput.ReadL(bufOutput, TChar(KLinefeedChar)));

		result = IsPropertyPresent(bufOutput, noField);

		if(result)

			{

			break;	

			}

		} while (err != KErrEof);

	CleanupStack::PopAndDestroy(2, &fileOutput);

	if(result)

		{

		return EFalse;	

		}

	else

		{

		return ETrue;

		}

	}

// Tokenize the property list taken from ini file and compare each of them with the expected one

void CTestCompareCntFiles::TokenizeAndCompareL()

	{

	RArray<TPtrC>	fieldList;

	CleanupClosePushL(fieldList);

	iExportObj->TokenizeStringL(iFieldToVerify, fieldList);

	TInt count = fieldList.Count();

	TBuf8<KMaxLengthField> property;

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

		{	

		property.Copy(fieldList[i]);

		CompareFileL(iExpectedExportFilePath, iExportFilePath, property);

		}

	CleanupStack::PopAndDestroy();

	fieldList.Close();

	}

// Tokenize the property list taken from ini file and check for non-existence of these properties in the exported file.

void CTestCompareCntFiles::TokenizeAndCheckNoFieldL()

	{

	TBool result = EFalse;

	RArray<TPtrC>	fieldList;

	CleanupClosePushL(fieldList);

	iExportObj->TokenizeStringL(iNoField, fieldList);

	TInt count = fieldList.Count();

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

		{	

		result = CheckForNoFieldL(iExportFilePath, fieldList[i]);

		if(result)

			{

			INFO_PRINTF1(_L("Success: Property not present in vCard"));

			}

		else

			{

			INFO_PRINTF1(_L("Error: Property present in vCard"));

			SetTestStepResult(EFail);

			break;

			}

		}

	CleanupStack::PopAndDestroy();

	fieldList.Close();	

	}

/** Compares two files, excluding the REV property, as it doesn't remain the same always

@param	aExpectedFile The expected vcf file

@param	aFile This is the vcf file produced, and will be compared against aExpectedFile

*/

TBool CTestCompareCntFiles::CompareWholeFileL(const TDesC& aExpectedFile, const TDesC& aFile)

	{

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

	CleanupClosePushL(iFsSession);

	RFile fileExpected;

	RFile fileOutput;

	CleanupClosePushL(fileExpected);

	CleanupClosePushL(fileOutput);

	TInt err;

	err = fileExpected.Open(iFsSession, aExpectedFile, EFileRead);

	if (err != KErrNone)

		{

		User::Leave(err);

		}

	err = fileOutput.Open(iFsSession, aFile, EFileWrite);

	if (err != KErrNone)

		{

		User::Leave(err);

		}

	RFileReadStream stream1(fileExpected);

	RFileReadStream stream2(fileOutput);

	CleanupClosePushL(stream1);

	CleanupClosePushL(stream2);

	TBuf8<0x80> bufO,bufC;

	TBool flag = ETrue;

	TInt line = 1;

	do

		{

		TRAP(err, stream1.ReadL(bufO, KLinefeedChar));

		if (err == KErrNone || err == KErrEof)

			TRAP(err, stream2.ReadL(bufC, KLinefeedChar));

		if (err != KErrNone && err != KErrEof)

			User::Leave(err);

		if (CompareLine(bufO, bufC) == EFalse)

			{

			flag = EFalse;

			break;

			}

		++line;

		}

	while (err != KErrEof);

	CleanupStack::PopAndDestroy(4, &fileExpected);

	CleanupStack::PopAndDestroy(&iFsSession);

    iFsSession.Close();

	if(flag)

		{

		return ETrue;		

		}

	else

		{

		return EFalse;

		}		

	}

/* Compare the corresponding lines of two files

@param	aLine1 Complete line of a file to compare

@param	aLine2 Corresponding line to compare in the second file

*/

TBool CTestCompareCntFiles::CompareLine(const TDesC8& aLine1, const TDesC8& aLine2)

	{

	_LIT8(KREV,"REV:");

	TBool ret = !aLine1.Compare(aLine2);

	if (!ret)

		{

		TBufC8<4> propertyRev(aLine1.Left(4));

		if(!propertyRev.Compare(KREV()))

			{

			return ETrue;	

			}

		}

	return ret;

	}

TVerdict CTestCompareCntFiles::doTestStepPostambleL()

/**

 * @return - TVerdict code

 * Override of base class virtual

 */

	{

	INFO_PRINTF1(_L("Completed verifcation of import/export vcf files"));

	return TestStepResult();

	}