/*

* Copyright (c) 2005-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 "hashtestutils.h"

#include <utf.h>

TBool gInOOMTest=EFalse;

RTest test(_L("Hash Tests"));

const TInt KMaxHashSize = 64; // Hash size in bytes

void Hex(HBufC8& aString)

	{

	TPtr8 ptr=aString.Des();

	if (aString.Length()%2)

		{

		ptr.SetLength(0);

		return;

		}

	TInt i;

	for (i=0;i<aString.Length();i+=2)

		{

		TUint8 tmp;

		tmp=(TUint8)(aString[i]-(aString[i]>'9'?('A'-10):'0'));

		tmp*=16;

		tmp|=(TUint8)(aString[i+1]-(aString[i+1]>'9'?('A'-10):'0'));

		ptr[i/2]=tmp;

		}

	ptr.SetLength(aString.Length()/2);

	}

void Spin()

{//	Pointless function to print a dot

	if (gInOOMTest)

		{

		static TInt count=0;

		if (count++==100)

			{

			test.Printf(_L("o"));

			count=0;

			}

		return;

		}

	test.Printf(_L("."));

}

void FunctionalityTestL(CMessageDigest* aMD)

	{

	if (!gInOOMTest)

		test.Next(_L("Functionality test - original API"));

	const TInt maxbuffersize=1024;

	TInt buffersize;

	TInt increment;

	if (gInOOMTest)

		{

		buffersize=256;

		increment=6;

		}

	else

		{

		buffersize=maxbuffersize;

		increment=1;

		}

	TBool testSuccess = ETrue;

	TInt i = 0;

	TBuf8<maxbuffersize> buf(maxbuffersize);

	for (;i<buffersize;i++)

		{

		buf[i]=(TUint8)i;

		}

	for (i=0;i<buffersize;i+=increment)

		{

		TInt j;

		Spin();

		if (!gInOOMTest)

			{

			if (i>128)

				{

				increment=8;

				}

			}

		else

			{

			if (i>24)

				{

				increment=32;

				}

			}

		for (j=0;j<i;j+=16)

			{

			buf[0]=(TUint8)j;

			TPtrC8 ptr=buf.Left(i);

			TPtrC8 ptr2=buf.Left(j);

			TPtrC8 ptr3=buf.Mid(j,i-j);

			CMessageDigest* first=aMD->ReplicateL();

			CleanupStack::PushL(first);

			TPtrC8 firstFinal = first->Hash(ptr);

			aMD->Reset();

			aMD->Update(ptr);

			TPtrC8 aMDFinal = aMD->Final();

			CMessageDigest* second=aMD->ReplicateL();

			CleanupStack::PushL(second);

			second->Hash(ptr2);

			CMessageDigest* third=second->CopyL();

			CleanupStack::PushL(third);

			TPtrC8 secondFinal = second->Hash(ptr3);

			if (aMDFinal!=firstFinal)

				{

				testSuccess = EFalse;

				}

			if (firstFinal!=secondFinal)

				{

				testSuccess = EFalse;

				}

			TPtrC8 thirdFinal = third->Hash(ptr3);

			if (firstFinal!=thirdFinal)

				{

				testSuccess = EFalse;

				}

			CleanupStack::PopAndDestroy(3);		// first, second, third

			}

		}

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

//	Now test the new API - Update/Final functions	

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

	if (!gInOOMTest)

		test.Next(_L("\rFunctionality test - calls added API functions Final & Update"));

	for (i=0;i<buffersize;i++)

		{

		buf[i]=(TUint8)i;

		}

	for (i=0;i<buffersize;i+=increment)

		{

		TInt j;

		Spin();

		if (!gInOOMTest)

			{

			if (i>128)

				{

				increment=8;

				}

			}

		else

			{

			if (i>24)

				{

				increment=32;

				}

			}

		for (j=0;j<i;j+=16)

			{

			buf[0]=(TUint8)j;

			TPtrC8 ptr=buf.Left(i);

			TPtrC8 ptr2=buf.Left(j);

			TPtrC8 ptr3=buf.Mid(j,i-j);

			CMessageDigest* first=aMD->ReplicateL();

			CleanupStack::PushL(first);

			first->Update(ptr);

			aMD->Update(ptr);

			CMessageDigest* second=aMD->ReplicateL();

			CleanupStack::PushL(second);			

			second->Update(ptr2);

			CMessageDigest* third=second->CopyL();

			CleanupStack::PushL(third);

			third->Update(ptr3);

			second->Update(ptr3);

			TPtrC8 aMDFinal = aMD->Final();

			TPtrC8 firstFinal = first->Final();

			TPtrC8 secondFinal = second->Final();

			TPtrC8 thirdFinal = third->Final();

			if (aMDFinal!=firstFinal)

				{

				testSuccess = EFalse;

				}

			if (firstFinal!=secondFinal)

				{

				testSuccess = EFalse;

				}

			if (firstFinal!=thirdFinal)

				{

				testSuccess = EFalse;

				}

			CleanupStack::PopAndDestroy(3);		// first, second, third

			}

		}

	test.Printf(_L("\r\n"));

	if (!testSuccess)

		User::Leave(KErrGeneral);

	}

void VectorTestL(CMessageDigest* aMD,const TDesC& aFilename)

	{

	test.Next(_L("Test Vector tests - original API"));

	TBool finished=EFalse;

	TBool testSuccess = ETrue;

	//aFilename is a .dat file which contains the message and the corresponding digest

	CTestData* data = CTestData::NewL(aFilename);

	CleanupStack::PushL(data);

	while (!finished)

		{

		switch (data->Type())

			{

		case CTestData::EMessage:

			{

			break;

			}

		//This is added to read large input data from the files.

		case CTestData::EFileName:

			{

			CMessageDigest* md=aMD->ReplicateL();

			CleanupStack::PushL(md);

			//get the filename from the .dat file

			HBufC8* filename = (*data)[1];

			User::LeaveIfNull(filename);

			CleanupStack::PushL(filename);

			HBufC8* output= (*data)[2];

			User::LeaveIfNull(output);

			CleanupStack::PushL(output);

			Hex(*output);

			HBufC16* inputFileName = CnvUtfConverter::ConvertToUnicodeFromUtf8L(*filename);

			RFs fs;

			RFile file;

			CleanupClosePushL(fs);

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

			TDriveUnit sysDrive(fs.GetSystemDrive());

			TBuf<24> filePath (sysDrive.Name());

			filePath.Append(_L("\\thash\\"));

			User::LeaveIfError(fs.SetSessionPath(filePath));

			CleanupClosePushL(file);

			User::LeaveIfError(file.Open(fs,*inputFileName,EFileShareAny|EFileRead));

			// read into iFile

			TInt size=0;

			file.Size(size);

			HBufC8* fileContents=HBufC8::NewMaxL(size);

			TPtr8 ptr=fileContents->Des();

			User::LeaveIfError(file.Read(ptr));

			CleanupStack::PopAndDestroy(2, &fs);

			CleanupStack::PushL(fileContents);

			delete inputFileName;

			TPtrC8 digest = md->Hash(*fileContents);

			if (digest!=(*output))	

				{

				testSuccess = EFalse;

				}

			md->Reset();

			TPtrC8 digest2 = md->Hash(*fileContents);

			if (digest2!=(*output))	

				{

				testSuccess = EFalse;

				}

		//	Now try this in 2 half sections (just a quick check)

			md->Reset();

			TInt inputLen = fileContents->Length();

			if (inputLen > 1)

				{

				TInt leftHandLen = inputLen/2;

				TPtrC8 left = fileContents->Left(leftHandLen);

				TPtrC8 right = fileContents->Right(inputLen - leftHandLen);

				TPtrC8 halfDigest = md->Hash(left);

				if (halfDigest.Size()==0)	//	Unnecessary test, but removes

					User::Leave(KErrAbort);	//	a warning about not using halfDigest

				TPtrC8 wholeDigest = md->Hash(right);

				if (wholeDigest!=(*output))	

					{

					testSuccess = EFalse;

					}			

				}

			md->Reset();

			if (md->Final(*fileContents)!=(*output))

				{

				testSuccess = EFalse;

				}

		//	Now try this in 2 half sections (just a quick check)

			md->Reset();

			inputLen = fileContents->Length();

			if (inputLen > 1)

				{

				TInt leftHandLen = inputLen/2;

				TPtrC8 left = fileContents->Left(leftHandLen);

				TPtrC8 right = fileContents->Right(inputLen - leftHandLen);

				md->Update(left);

				TPtrC8 wholeDigest = md->Final(right);

				if (wholeDigest!=(*output))	

					{

					testSuccess = EFalse;

					}			

				}

			CleanupStack::PopAndDestroy(4, md);//md,filename,output,fileContents

			break;

			}

		case CTestData::EData:

			{

			CMessageDigest* md=aMD->ReplicateL();

			CleanupStack::PushL(md);

			HBufC8* input = (*data)[0];

			User::LeaveIfNull(input);

		    CleanupStack::PushL(input);

			HBufC8* output= (*data)[1];

			User::LeaveIfNull(output);

			CleanupStack::PushL(output);

			Hex(*input);

			Hex(*output);

            //call the Hash function of the Algorithm.

			TPtrC8 digest = md->Hash(*input);

			//Compare the digest generated with the output(digest) expected.

			if (digest!=(*output))	

				{

				testSuccess = EFalse;

				}

			//check the Reset() function.

			md->Reset();

			TPtrC8 digest2 = md->Hash(*input);

			if (digest2!=(*output))	

				{

				testSuccess = EFalse;

				}

		//	Now try this in 2 half sections (just a quick check)

			md->Reset();

			TInt inputLen = input->Length();

			if (inputLen > 1)

				{

				TInt leftHandLen = inputLen/2;

				TPtrC8 left = input->Left(leftHandLen);

				TPtrC8 right = input->Right(inputLen - leftHandLen);

				TPtrC8 halfDigest = md->Hash(left);

				if (halfDigest.Size()==0)	//	Unnecessary test, but removes

					User::Leave(KErrAbort);	//	a warning about not using halfDigest

				TPtrC8 wholeDigest = md->Hash(right);

				if (wholeDigest!=(*output))	

					{

					testSuccess = EFalse;

					}			

				}

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

//	Now test the new API - Update/Final functions	

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

			md->Reset();

			if (md->Final(*input)!=(*output))

				{

				testSuccess = EFalse;

				}

		//	Now try this in 2 half sections (just a quick check)

			md->Reset();

			inputLen = input->Length();

			if (inputLen > 1)

				{

				TInt leftHandLen = inputLen/2;

				TPtrC8 left = input->Left(leftHandLen);

				TPtrC8 right = input->Right(inputLen - leftHandLen);

				md->Update(left);

				TPtrC8 wholeDigest = md->Final(right);

				if (wholeDigest!=(*output))	

					{

					testSuccess = EFalse;

					}			

				}

			CleanupStack::PopAndDestroy(3);

			break;

			}

		case CTestData::EFinished:

			finished=ETrue;

			break;

		default:

			test.Printf(_L("Error in data file\r\n"));

			break;

			}

		};

	CleanupStack::PopAndDestroy(data);

	if (!testSuccess)

		User::Leave(KErrGeneral);

	}

void OOMTestL(CMessageDigest* aMD)

	{

	test.Next(_L("Out of memory test"));

	TInt err = KErrNoMemory;

	TInt nextFailure=0;

	gInOOMTest=ETrue;

	while (err!=KErrNone)

		{

		__UHEAP_MARK;

		__UHEAP_FAILNEXT(nextFailure);

		TRAP(err,FunctionalityTestL(aMD));		

		__UHEAP_MARKEND;

		nextFailure++;

		}

	__UHEAP_RESET;

	gInOOMTest=EFalse;

	}

void HMACVectorTestL(CMessageDigest* aMD,const TDesC& aFilename)

	{

	test.Next(_L("HMAC Test Vector tests"));

	CTestData* data = CTestData::NewL(aFilename);

	CleanupStack::PushL(data);

	TBool finished=EFalse;

	TBool testSuccess = ETrue;

	while (!finished)

		{

		switch (data->Type())

			{

		case CTestData::EMessage:

			{

			break;

			}

		case CTestData::EFileName:

			{

			//get the filename from the .dat file

			HBufC8* filename = (*data)[1];

			User::LeaveIfNull(filename);

			CleanupStack::PushL(filename);

			HBufC8* key= (*data)[2];

			User::LeaveIfNull(key);

			CleanupStack::PushL(key);

			HBufC16* inputFileName = CnvUtfConverter::ConvertToUnicodeFromUtf8L(*filename);

			HBufC8* output = (*data)[3];

			User::LeaveIfNull(output);

			CleanupStack::PushL(output);

			Hex(*key);

			Hex(*output);

			RFs fs;

			RFile file;

			CleanupClosePushL(fs);

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

			TDriveUnit sysDrive(fs.GetSystemDrive());

			TBuf<24> filePath (sysDrive.Name());

			filePath.Append(_L("\\thash\\"));

			User::LeaveIfError(fs.SetSessionPath(filePath));

			CleanupClosePushL(file);

			User::LeaveIfError(file.Open(fs,*inputFileName,EFileShareAny|EFileRead));

			// read into iFile

			TInt size=0;

			file.Size(size);

			HBufC8* fileContents=HBufC8::NewMaxL(size);

			TPtr8 ptr=fileContents->Des();

			User::LeaveIfError(file.Read(ptr));

			CleanupStack::PopAndDestroy(2, &fs);