/*

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

*

*/

#include "tperformancetest.h"

#include "symmetric.h"

#ifndef _FOO

_LIT(KPerfEFormat, "\tPerformance(encryption)\t%f");

_LIT(KPerfDFormat, "\tPerformance(decryption)\t%f");

_LIT(KTotalFormat, "\tPerformance(total)\t%f");

_LIT(KPerfThroughput, "\tThroughput (total)\t%f");

_LIT(KPerfThroughputAfterSetup, "\tThroughput after setup\t%f");

_LIT(KPerfEncryptorCreate, "\tPerformance(encryptor create)\t%f");

_LIT(KPerfDecryptorCreate, "\tPerformance(decryptor create)\t%f");

//_LIT(KDataSize,"\tData input size : %i B\r\n");

#endif

CTestAction* CPerformanceTest::NewL(RFs& aFs,

									   CConsoleBase& aConsole,

									   Output& aOut, 

									   const TTestActionSpec& aTestActionSpec)

	{

	CTestAction* self = CPerformanceTest::NewLC(aFs, aConsole,

		aOut, aTestActionSpec);

	CleanupStack::Pop();

	return self;

	}

CTestAction* CPerformanceTest::NewLC(RFs& aFs,

										CConsoleBase& aConsole,

										Output& aOut, 

										const TTestActionSpec& aTestActionSpec)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aTestActionSpec);

	return self;

	}

CPerformanceTest::~CPerformanceTest()

{

	delete iEncryptor;

	delete iDecryptor;

}

CPerformanceTest::CPerformanceTest(RFs& aFs, 

								 CConsoleBase& aConsole,

								 Output& aOut)

: CCryptoTestAction(aFs, aConsole, aOut)

{}

void CPerformanceTest::DoPerformPrerequisiteL()

{

#ifndef _FOO

	TInt err = KErrNone;

	TInt pos = 0;

	TPtrC8 vector = Input::ParseElement(*iBody, KVectorStart, KVectorEnd, pos, err);

	DoInputParseL(vector);

	CBlockTransformation* encryptor = 0;

	CBlockTransformation* decryptor = 0;

	switch (iCipherType)

	{

		case (EDESECB):

		{//	Time the length of time it takes to set up the key schedule,

		//	save it and add to encrypt time, to be consistent with old API

		//	for comparison purposes (old API does both set up and encrypt/decrypt

		//	in a single operation).

			TTime startTime;

			TTime endTime;

			TTimeIntervalSeconds diff(0);

			const TTimeIntervalSeconds iterationTime(iIterationTime);

			encryptor = CDESEncryptor::NewL(iKey->Des());

			iEncryptIterations = 0;

			startTime.UniversalTime();	

			while (diff < iterationTime)

				{

				encryptor->Reset();

				iEncryptIterations++;

				endTime.UniversalTime();

				endTime.SecondsFrom(startTime, diff);

				}

			endTime.UniversalTime();

			iEncryptorCreateTime = endTime.MicroSecondsFrom(startTime);

			delete encryptor;

			decryptor = CDESDecryptor::NewL(iKey->Des());

			diff = 0;

			iDecryptIterations = 0;

			startTime.UniversalTime();	

			while (diff < iterationTime)

				{

				decryptor->Reset();

				iDecryptIterations++;

				endTime.UniversalTime();

				endTime.SecondsFrom(startTime, diff);

				}

			endTime.UniversalTime();

			iDecryptorCreateTime = endTime.MicroSecondsFrom(startTime);

			delete decryptor;

			encryptor = CDESEncryptor::NewLC(iKey->Des());

			decryptor = CDESDecryptor::NewL(iKey->Des());

			CleanupStack::Pop(encryptor);

		}

		break;

		case(EDESCBC):

		{

			CBlockTransformation* desEncryptor = NULL;

			CBlockTransformation* desDecryptor = NULL;

			desEncryptor = CDESEncryptor::NewLC(iKey->Des());								

			encryptor = CModeCBCEncryptor::NewL(desEncryptor, iIV->Des());				

			TTime startTime;

			TTime endTime;

			TTimeIntervalSeconds diff(0);

			const TTimeIntervalSeconds iterationTime(iIterationTime);

			iEncryptIterations = 0;

			startTime.UniversalTime();

			while (diff < iterationTime)

				{

				iEncryptIterations++;

				encryptor->Reset();

				endTime.UniversalTime();

				endTime.SecondsFrom(startTime, diff);

				}

			endTime.UniversalTime();

			iEncryptorCreateTime = endTime.MicroSecondsFrom(startTime);

			CleanupStack::Pop(1);

			delete encryptor;

			desDecryptor = CDESDecryptor::NewLC(iKey->Des());

			decryptor = CModeCBCDecryptor::NewL(desDecryptor, iIV->Des());

			diff = 0;

			iDecryptIterations = 0;

			startTime.UniversalTime();

			while (diff < iterationTime)

				{

				decryptor->Reset();

				iDecryptIterations++;

				endTime.UniversalTime();

				endTime.SecondsFrom(startTime, diff);

				}

			endTime.UniversalTime();

			iDecryptorCreateTime = endTime.MicroSecondsFrom(startTime);

			CleanupStack::Pop(1);

			delete decryptor;				

			desEncryptor = CDESEncryptor::NewLC(iKey->Des());

			desDecryptor = CDESDecryptor::NewLC(iKey->Des());

			encryptor = CModeCBCEncryptor::NewL(desEncryptor, iIV->Des());

			CleanupStack::PushL(encryptor);

			decryptor = CModeCBCDecryptor::NewL(desDecryptor, iIV->Des());					

			CleanupStack::Pop(3);

		}

		break;

		case (E3DESECB):

		{

			encryptor = C3DESEncryptor::NewL(iKey->Des());

			TTime startTime;

			TTime endTime;

			TTimeIntervalSeconds diff(0);

			const TTimeIntervalSeconds iterationTime(iIterationTime);

			iEncryptIterations = 0;

			startTime.UniversalTime();	

			while (diff < iterationTime)

				{

				iEncryptIterations++;

				encryptor->Reset();

				endTime.UniversalTime();

				endTime.SecondsFrom(startTime, diff);

				}

			endTime.UniversalTime();

			iEncryptorCreateTime = endTime.MicroSecondsFrom(startTime);

			delete encryptor;

			diff = 0;

			iDecryptIterations = 0;

			decryptor = C3DESDecryptor::NewL(iKey->Des());

			startTime.UniversalTime();	

			while (diff < iterationTime)

				{

				decryptor->Reset();

				iDecryptIterations++;

				endTime.UniversalTime();

				endTime.SecondsFrom(startTime, diff);

				}

			endTime.UniversalTime();

			iDecryptorCreateTime = endTime.MicroSecondsFrom(startTime);

			delete decryptor;

			encryptor = C3DESEncryptor::NewLC(iKey->Des());

			decryptor = C3DESDecryptor::NewL(iKey->Des());

			CleanupStack::Pop(encryptor);

		}

		break;

		case (E3DESCBC):

		{

			CBlockTransformation* the3DESencryptor = NULL;

			CBlockTransformation* the3DESdecryptor = NULL;

			the3DESencryptor = C3DESEncryptor::NewL(iKey->Des());

			CleanupStack::PushL(the3DESencryptor);

			encryptor = CModeCBCEncryptor::NewL(the3DESencryptor, iIV->Des());

			TTime startTime;

			TTime endTime;

			TTimeIntervalSeconds diff(0);

			const TTimeIntervalSeconds iterationTime(iIterationTime);

			iEncryptIterations = 0;

			startTime.UniversalTime();	

			while (diff < iterationTime)

				{

				iEncryptIterations++;

				encryptor->Reset();

				endTime.UniversalTime();

				endTime.SecondsFrom(startTime, diff);

				}

			endTime.UniversalTime();

			iEncryptorCreateTime = endTime.MicroSecondsFrom(startTime);

			CleanupStack::Pop(1);

			delete encryptor;				

			the3DESdecryptor = C3DESDecryptor::NewLC(iKey->Des());

			decryptor = CModeCBCDecryptor::NewL(the3DESdecryptor, iIV->Des());		

			diff = 0;

			iDecryptIterations = 0;

			startTime.UniversalTime();	

			while (diff < iterationTime)

				{

				decryptor->Reset();

				iDecryptIterations++;

				endTime.UniversalTime();

				endTime.SecondsFrom(startTime, diff);

				}

			endTime.UniversalTime();

			iDecryptorCreateTime = endTime.MicroSecondsFrom(startTime);

			CleanupStack::Pop(1);

			delete decryptor;

			the3DESencryptor = C3DESEncryptor::NewLC(iKey->Des());

			the3DESdecryptor = C3DESDecryptor::NewLC(iKey->Des());

			encryptor = CModeCBCEncryptor::NewL(the3DESencryptor, iIV->Des());

			CleanupStack::PushL(encryptor);

			decryptor = CModeCBCDecryptor::NewL(the3DESdecryptor, iIV->Des());		

			CleanupStack::Pop(3);

		}

		break;

		case (EAESECB):

		{

			TTime startTime;

			TTime endTime;

			TTimeIntervalSeconds diff(0);

			const TTimeIntervalSeconds iterationTime(iIterationTime);

			iEncryptIterations = 0;

			encryptor = CAESEncryptor::NewL(iKey->Des());

			startTime.UniversalTime();

			while (diff < iterationTime)

				{

				iEncryptIterations++;

				encryptor->Reset();

				endTime.UniversalTime();

				endTime.SecondsFrom(startTime, diff);

				}

			endTime.UniversalTime();

			iEncryptorCreateTime = endTime.MicroSecondsFrom(startTime);

			delete encryptor;

			diff = 0;

			iDecryptIterations = 0;

			decryptor = CAESDecryptor::NewL(iKey->Des());

			startTime.UniversalTime();

			while (diff < iterationTime)

				{

				decryptor->Reset();

				iDecryptIterations++;

				endTime.UniversalTime();

				endTime.SecondsFrom(startTime, diff);

				}

			endTime.UniversalTime();

			iDecryptorCreateTime = endTime.MicroSecondsFrom(startTime);

			delete decryptor;

			encryptor = CAESEncryptor::NewLC(iKey->Des());

			decryptor = CAESDecryptor::NewL(iKey->Des());

			CleanupStack::Pop(encryptor);

		}

		break;	

		case (ERC2ECB):

		{

			TTime startTime;

			TTime endTime;

			TTimeIntervalSeconds diff(0);

			const TTimeIntervalSeconds iterationTime(iIterationTime);

			iEncryptIterations = 0;

			encryptor = CRC2Encryptor::NewL(iKey->Des(), iEffectiveKeyLen);

			startTime.UniversalTime();	

			while (diff < iterationTime)

				{

				iEncryptIterations++;

				encryptor->Reset();

				endTime.UniversalTime();

				endTime.SecondsFrom(startTime, diff);

				}

			endTime.UniversalTime();

			iEncryptorCreateTime = endTime.MicroSecondsFrom(startTime);

			delete encryptor;

			diff = 0;

			decryptor = CRC2Decryptor::NewL(iKey->Des(), iEffectiveKeyLen);

			iDecryptIterations = 0;

			startTime.UniversalTime();	

			while (diff < iterationTime)

				{

				decryptor->Reset();

				iDecryptIterations++;

				endTime.UniversalTime();

				endTime.SecondsFrom(startTime, diff);

				}

			endTime.UniversalTime();

			iDecryptorCreateTime = endTime.MicroSecondsFrom(startTime);

			delete decryptor;

			encryptor = CRC2Encryptor::NewLC(iKey->Des(), iEffectiveKeyLen);

			decryptor = CRC2Decryptor::NewL(iKey->Des(), iEffectiveKeyLen);

			CleanupStack::Pop(encryptor);

		}

		break;

		case (ERC2CBC):

		{

			CBlockTransformation* theRC2encryptor = NULL;

			CBlockTransformation* theRC2decryptor = NULL;

			theRC2encryptor = CRC2Encryptor::NewLC(iKey->Des(), iEffectiveKeyLen);

			encryptor = CModeCBCEncryptor::NewL(theRC2encryptor, iIV->Des());

			TTime startTime;

			TTime endTime;

			TTimeIntervalSeconds diff(0);

			const TTimeIntervalSeconds iterationTime(iIterationTime);

			iEncryptIterations = 0;

			startTime.UniversalTime();

			while (diff < iterationTime)

				{

				iEncryptIterations++;

				encryptor->Reset();

				endTime.UniversalTime();

				endTime.SecondsFrom(startTime, diff);

				}

			endTime.UniversalTime();

			iEncryptorCreateTime = endTime.MicroSecondsFrom(startTime);

			CleanupStack::Pop(1);

			delete encryptor;

			diff = 0;

			iDecryptIterations = 0;

			theRC2decryptor = CRC2Decryptor::NewLC(iKey->Des(), iEffectiveKeyLen);

			decryptor = CModeCBCDecryptor::NewL(theRC2decryptor, iIV->Des());		

			startTime.UniversalTime();

			while (diff < iterationTime)

				{

				decryptor->Reset();

				iDecryptIterations++;

				endTime.UniversalTime();

				endTime.SecondsFrom(startTime, diff);

				}

			endTime.UniversalTime();

			iDecryptorCreateTime = endTime.MicroSecondsFrom(startTime);

			CleanupStack::Pop(1);

			delete decryptor;

			theRC2encryptor = CRC2Encryptor::NewLC(iKey->Des(), iEffectiveKeyLen);

			theRC2decryptor = CRC2Decryptor::NewLC(iKey->Des(), iEffectiveKeyLen);

			encryptor = CModeCBCEncryptor::NewL(theRC2encryptor, iIV->Des());

			CleanupStack::PushL(encryptor);

			decryptor = CModeCBCDecryptor::NewL(theRC2decryptor, iIV->Des());		

			CleanupStack::Pop(3);

		}

		break;

		case (ERC4):

		{

			iEncryptor = CARC4::NewL(*iKey);

			TTime startTime;

			TTime endTime;

			TTimeIntervalSeconds diff(0);

			const TTimeIntervalSeconds iterationTime(iIterationTime);

			iEncryptIterations = 0;

			startTime.UniversalTime();	

			while (diff < iterationTime)

				{

				iEncryptIterations++;

				iEncryptor->Reset();

				endTime.UniversalTime();

				endTime.SecondsFrom(startTime, diff);

				}

			endTime.UniversalTime();

			iEncryptorCreateTime = endTime.MicroSecondsFrom(startTime);

			diff = 0;			

			iDecryptIterations = 0;

			iDecryptor = CARC4::NewL(*iKey);

			startTime.UniversalTime();	

			while (diff < iterationTime)

				{

				iDecryptor->Reset();

				iDecryptIterations++;

				endTime.UniversalTime();

				endTime.SecondsFrom(startTime, diff);

				}

			endTime.UniversalTime();

			iDecryptorCreateTime = endTime.MicroSecondsFrom(startTime);

		}

		break;

		case (ECipherNull):

		{

			iEncryptor = CNullCipher::NewL();

			TTime startTime;

			TTime endTime;

			TTimeIntervalSeconds diff(0);

			const TTimeIntervalSeconds iterationTime(iIterationTime);

			iEncryptIterations = 0;

			startTime.UniversalTime();	

			while (diff < iterationTime)

				{

				iEncryptIterations++;

				iEncryptor->Reset();

				endTime.UniversalTime();

				endTime.SecondsFrom(startTime, diff);

				}

			endTime.UniversalTime();

			iEncryptorCreateTime = endTime.MicroSecondsFrom(startTime);

			diff = 0;

			iDecryptIterations = 0;

			iDecryptor = CNullCipher::NewL();

			startTime.UniversalTime();	

			while (diff < iterationTime)

				{

				iDecryptor->Reset();

				iDecryptIterations++;

				endTime.UniversalTime();

				endTime.SecondsFrom(startTime, diff);

				}

			endTime.UniversalTime();

			iDecryptorCreateTime = endTime.MicroSecondsFrom(startTime);

		}

		break;

		default:

		{

			ASSERT(0);

			User::Leave(KErrNotSupported);

		}

	}

	if( encryptor && decryptor )

		{

		CleanupStack::PushL(encryptor);

		CleanupStack::PushL(decryptor);

		CPaddingSSLv3* ePadding = CPaddingSSLv3::NewLC(encryptor->BlockSize());

		iEncryptor = CBufferedEncryptor::NewL(encryptor, ePadding);	

		CleanupStack::Pop(ePadding);	

		CPaddingSSLv3* dPadding = CPaddingSSLv3::NewLC(decryptor->BlockSize());

		iDecryptor = CBufferedDecryptor::NewL(decryptor, dPadding);

		CleanupStack::Pop(dPadding);

		CleanupStack::Pop(decryptor);

		CleanupStack::Pop(encryptor);

		}

	// clear the default input and output fields and fill with random data

	// since for performance testing we do not care about validating

	// correct output

	delete iInput;	

	iInput = NULL;

	iInput = HBufC8::NewMaxL(iRandDataSize);

	TPtr8 tempPtr = iInput->Des();

	TRandom::Random(tempPtr);	

	TBuf<128> tempbuf;

	//tempbuf.Format(KDataSize, (iInput->Length()));

	iOut.writeString(tempbuf);	

	delete iOutput;

	iOutput = NULL;

	iOutput = HBufC8::NewMaxL(iRandDataSize);

	TPtr8 tempPtr2 = iOutput->Des();

	TRandom::Random(tempPtr2);