/*

 * Copyright (c) 2003-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: 

 *

 */

 /**

  @file

 */

 #include <e32base.h>

 #include "t_keystore_actions.h"

 #include "t_keystore_defs.h"

 #include "t_input.h"

 const int KErrDifferent = -99999;

 /////////////////////////////////////////////////////////////////////////////////

 // CCompare

 /////////////////////////////////////////////////////////////////////////////////

 CTestAction* CCompare::NewL(RFs& aFs, 

 							CConsoleBase& aConsole, 

 							Output& aOut,

 							const TTestActionSpec& aTestActionSpec)

 {

 	CTestAction* self = CCompare::NewLC(aFs, aConsole, aOut, aTestActionSpec);

 	CleanupStack::Pop(self);

 	return self;

 }

 CTestAction* CCompare::NewLC(RFs& aFs,

 							CConsoleBase& aConsole, 

 							Output& aOut,

 							const TTestActionSpec& aTestActionSpec)

 {

 	CCompare* self = new (ELeave) CCompare(aFs, aConsole, aOut);

 	CleanupStack::PushL(self);

 	self->ConstructL(aTestActionSpec);

 	return self;

 }

 CCompare::~CCompare()

 {

 }

 CCompare::CCompare(RFs& aFs, CConsoleBase& aConsole, Output& aOut)

 :	CKeyStoreTestAction(aFs, aConsole, aOut)

 {

  	iState = EComparing;

 }

 void CCompare::ConstructL(const TTestActionSpec& aTestActionSpec)

 {

 	CKeyStoreTestAction::ConstructL(aTestActionSpec);

 	TInt err = KErrNone;

 	TInt pos = 0;

 	TDriveUnit sysDrive (RFs::GetSystemDrive());

 	TBuf<128> ramDrive (sysDrive.Name());

 	ramDrive.Append(_L("\\tkeystore\\data\\"));

 	iOriginalFile = ramDrive;

 	iNewFile = ramDrive;

 	TFileName buf;

 	buf.FillZ();

 	buf.Copy(Input::ParseElement(aTestActionSpec.iActionBody, 

 							KOriginalFile, 

 							KOriginalFileEnd, pos, err));	

 //	Now the filename itself

 	iOriginalFile.Append(buf);

 	buf.Copy(Input::ParseElement(aTestActionSpec.iActionBody, 

 							KNewFile, 

 							KNewFileEnd, pos, err));

 //	Now the filename itself

 	iNewFile.Append(buf);

 //	iExpectedResult = SetExpectedResultL(Input::ParseElement(aTestActionSpec.iActionResult, 

 //															KReturnStart, 

 //															KReturnEnd, pos, err));

 }

 void CCompare::PerformAction(TRequestStatus& aStatus)

 	{

 	switch (iState)

 		{

 	case EComparing:

 			{

 			TInt res = KErrNone;

 			TRAPD(err, res  = CompareFilesL());

 			if (KErrNone != err)

 				{

 				res = err;

 				}

 			iState = EFinished;

 			TRequestStatus *status = &aStatus;

 			User::RequestComplete(status, res);			

 			}

 			break;

 	case EFinished:

 			{

 			TRequestStatus* status = &aStatus;

 			User::RequestComplete(status, aStatus.Int());

 			if (aStatus == iExpectedResult)

 				{

 				iResult = ETrue;

 				}

 			else

 				{

 				iResult = EFalse;

 				}

 			iFinished = ETrue;

 			}

 			break;

 		}

 	}

 void CCompare::PerformCancel()

     {

     // nothing to cancel

     }

 void CCompare::Reset()

 {}

 void CCompare::DoReportAction()

 {

 	_LIT(KComparing, "Comparison in progress...");

 	iOut.writeString(KComparing);

 	TPtr theLabel(iLabel->Des());

 	iOut.writeString(theLabel);

 	iOut.writeNewLine();

 }

 // Bitwise comparison of iOriginalFile and iNewFile

 TInt CCompare::CompareFilesL()

 	{

 		TInt res = KErrNone;

 		RFs theFs;

 		CleanupClosePushL(theFs);

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

 		RFile original;

 		TInt r = original.Open(theFs, iOriginalFile, EFileRead);

 		User::LeaveIfError(r);

 		CleanupClosePushL(original);

 		RFile generated;

 		r = generated.Open(theFs, iNewFile, EFileRead);

 		User::LeaveIfError(r);

 		CleanupClosePushL(generated);

 		TInt pos1 = 0;

 		TInt pos2 = 0;

 		TBuf8<1> ptr1;

 		TBuf8<1> ptr2;

 		original.Read(pos1, ptr1);

 		generated.Read(pos2, ptr2);

 		while (ptr1.Length()!=0)

 			{

 			if (ptr1.Compare(ptr2) != 0)

 				{

 				res = KErrDifferent;				

 				pos = pos1;

 				break;

 				}

 			pos1++;

 			pos2++;

 			original.Read(pos1, ptr1);

 			generated.Read(pos2, ptr2);				

 			}

 		if ((res != KErrDifferent)&& (ptr2.Length()!=0))

 			{

 			 res = KErrDifferent;			

 			pos = pos1;

 			}

 		CleanupStack::PopAndDestroy(3, &theFs);

 		return res;

 	}

 void CCompare::DoCheckResult(TInt aError)

 {

 	if (iFinished)

 	{

 		if (aError == KErrNone)

 		{

 			_LIT(KSuccessful, "Key comparison successfully\n");

 			iConsole.Write(KSuccessful);

 			iOut.writeString(KSuccessful);

 			iOut.writeNewLine();

 			iOut.writeNewLine();

 		}

 		else

 		{

 			TBuf<256> msg;

 			_LIT(KFailedDetails, "First difference at offset %d  \n");			

 			msg.Format(KFailedDetails, pos);

 			if (aError!=iExpectedResult)

 			{

 				_LIT(KFailed, "!!!Key comparison failure!!!  Import or export problem...\n");

 				iConsole.Write(KFailed);

 				iOut.writeString(KFailed);

 				iOut.writeNewLine();				

 				iConsole.Write(msg);

 				iOut.writeString(msg);

 			}

 			else

 			{

 				_LIT(KFailed, "Key comparison failed, but expected\n");

 				iConsole.Write(KFailed);

 				iOut.writeString(KFailed);

 				iOut.writeNewLine();				

 				iConsole.Write(msg);

 				iOut.writeString(msg);

 			}

 			iOut.writeNewLine();

 			iOut.writeNewLine();

 		}

 	}

 }