/*

* 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();

		}

	}

}