diff -r 000000000000 -r e686773b3f54 phonebookengines/contactsmodel/tsrc/Integration/TestImpExvCard/src/TestCompareCntFiles.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/phonebookengines/contactsmodel/tsrc/Integration/TestImpExvCard/src/TestCompareCntFiles.cpp Tue Feb 02 10:12:17 2010 +0200 @@ -0,0 +1,421 @@ +// 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(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 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 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 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 fieldList; + CleanupClosePushL(fieldList); + iExportObj->TokenizeStringL(iFieldToVerify, fieldList); + + TInt count = fieldList.Count(); + TBuf8 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 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(); + } +