/*

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

 #include "t_input.h"

 #include "t_output.h"

 #include <bigint.h>

 #include <random.h>

 CTestAction* CBasicMathsFB::NewL(RFs& aFs, CConsoleBase& aConsole, 

 	Output& aOut, const TTestActionSpec& aTestActionSpec)

 	{

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

 		aOut, aTestActionSpec);

 	CleanupStack::Pop();

 	return self;

 	}

 CTestAction* CBasicMathsFB::NewLC(RFs& aFs, CConsoleBase& aConsole, 

 	Output& aOut, const TTestActionSpec& aTestActionSpec)

 	{

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

 	CleanupStack::PushL(self);

 	self->ConstructL(aTestActionSpec);

 	return self;

 	}

 CBasicMathsFB::~CBasicMathsFB()

 	{

 	delete iBody;

 	}

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

 	: CTestAction(aConsole, aOut), iFs(aFs)

 	{

 	}

 void CBasicMathsFB::ConstructL(const TTestActionSpec& aTestActionSpec)

 	{

 	CTestAction::ConstructL(aTestActionSpec);

 	iBody = HBufC8::NewL(aTestActionSpec.iActionBody.Length());

 	iBody->Des().Copy(aTestActionSpec.iActionBody);

 	//HBufC8* length = Input::ParseElementHexL(*iBody, _L8("<bits>"));

 	TUint bits = Input::ParseIntElement(*iBody, _L8("<bits>"), _L8("</bits>"));

 	// the final /7 gives the number of times we have to increment by 7 to get

 	// to that number of bytes and hence bits.

 	iIterations = ((bits+7)/8)/7 + 1;

 	}

 void CBasicMathsFB::DoPerformPrerequisite(TRequestStatus& aStatus)

 	{

 	TRequestStatus* status = &aStatus;

 	User::RequestComplete(status, KErrNone);

 	iActionState = CTestAction::EAction;

 	}

 void CBasicMathsFB::DoPerformPostrequisite(TRequestStatus& aStatus)

 	{

 	TRequestStatus* status = &aStatus;

 	iFinished = ETrue;

 	User::RequestComplete(status, KErrNone);

 	}

 void CBasicMathsFB::DoReportAction(void)

 	{

 	}

 void CBasicMathsFB::DoCheckResult(TInt)

 	{

 	}

 void CBasicMathsFB::PerformAction(TRequestStatus& aStatus)

 	{

 	__UHEAP_MARK;

 	TRequestStatus* status = &aStatus;

 	iResult = ETrue;

 	//min max values for NewRandomLC call

 	RInteger min = RInteger::NewL(10);

 	CleanupStack::PushL(min);

 	RInteger max = RInteger::NewL(100);

 	CleanupStack::PushL(max);

 	//Generate iIterations*7 byte random sequences we are using 7 as it's a generator

 	//mod 8.  Thus we'll cycle through every value (0-7) every 8 iterations.

 	//This gives us a better feeling that certain byte lengths (and thus bit

 	//lengths as the byte is chosen randomly) don't have errors.

 	for(TUint i=1; i<iIterations; i++)

 		{ 

 		HBufC8* buf = HBufC8::NewMaxLC(i*7);

 		TPtr8 ptr = buf->Des();

 		TRandom::RandomL(ptr);

 		//This is this iteration's random number

 		RInteger initial = RInteger::NewL(ptr);

 		CleanupStack::PushL(initial);

 		//get a number x | 10 < x < 100

 		RInteger crange = RInteger::NewRandomL(min, max);

 		CleanupStack::PushL(crange);

 		TUint range = crange.ConvertToLongL();

 		CleanupStack::PopAndDestroy(); //crange

 		AddSub(initial, range);

 		MulDiv(initial, range);

 		//GCD

 		CleanupStack::PopAndDestroy(); //initial

 		CleanupStack::PopAndDestroy();//buf

 		iConsole.Printf(_L("."));

 		}

 	//Test a single iteration where the initial random number is less than a

 	//word so the division and modulo routines that take words rather than

 	//TIntegers can run.

 	//do

 		{

 		//This is this iteration's random number

 		RInteger initial = RInteger::NewRandomL(31);

 		CleanupStack::PushL(initial);

 		//get a number x | 10 < x < 100

 		RInteger crange = RInteger::NewRandomL(min, max);

 		CleanupStack::PushL(crange);

 		TUint range = crange.ConvertToLongL();

 		CleanupStack::PopAndDestroy(&crange); //crange

 		AddSub(initial, range);

 		MulDiv(initial, range);

 		CleanupStack::PopAndDestroy(&initial); //initial

 		iConsole.Printf(_L("."));

 		} //while (0);

 	CleanupStack::PopAndDestroy();//max

 	CleanupStack::PopAndDestroy(); //min

 	MiscDivL();

 	User::RequestComplete(status, KErrNone);

 	iActionState = CTestAction::EPostrequisite;

 	__UHEAP_MARK;

 	}

 void CBasicMathsFB::AddSub(const TInteger& aInitial, TUint aRange)

 	{

 	__UHEAP_MARK;

 	//This is the copy we are going to do stuff to

 	RInteger a = RInteger::NewL(aInitial);

 	CleanupStack::PushL(a);

 	// compute a*aRange using doubling

 	TUint j=1;

 	for(; j<aRange; j++)

 		{

 		a += aInitial;

 		}

 	//b = a*aRange;

 	RInteger b = RInteger::NewL(a);

 	CleanupStack::PushL(b);

 	//compute (a*aRange)/aRange using subtraction

 	for(j=1; j<aRange; j++)

 		{

 		b -= aInitial;

 		}

 	// b should be the same as the initial value

 	if( b != aInitial )

 		{

 		iResult = EFalse;

 		iOut.writeString(_L("AddSub Failure:"));

 		iOut.writeNewLine();

 		}

 	RInteger c = RInteger::NewL(aInitial);

 	CleanupStack::PushL(c);

 	// compute a*aRange using normal multiplication

 	c *= aRange;

 	// c and a should now be the same

 	if( c != a )

 		{ 

 		iResult = EFalse;

 		}

 	RInteger d = RInteger::NewL(a);

 	CleanupStack::PushL(d);

 	//compute (a*aRange)/aRange using normal division

 	d /= aRange;

 	if( d != aInitial )

 		{

 		iResult = EFalse;

 		}

 	RInteger e = RInteger::NewL(a);

 	CleanupStack::PushL(e);

 	e %= aRange;

 	// (a*aRange)%aRange == 0

 	if( e != 0 )

 		{

 		iResult = EFalse;

 		}

 	CleanupStack::PopAndDestroy(5); //e,d,c,b,a

 	__UHEAP_MARKEND;

 	}

 void CBasicMathsFB::MulDiv(const TInteger& aInitial, TUint aRange)

 	{

 	__UHEAP_MARK;

 	//This is the copy we are going to do stuff to

 	RInteger a = RInteger::NewL(aInitial);

 	CleanupStack::PushL(a);

 	//compute a = aInitial^aRange using repeated multiplication

 	TUint j=1;

 	for(; j<aRange; j++)

 		{

 		a *= aInitial;

 		}

 	//b = a

 	RInteger b = RInteger::NewL(a);

 	CleanupStack::PushL(b);

 	//try to find aInitial by repeatedly dividing b by aInitial aRange times

 	for(j=1; j<aRange; j++)

 		{

 		TRAPD(res, b /= aInitial);

 		//the first time through aInitial is 0 so this is expected

 		if(res == KErrDivideByZero && aInitial.IsZero())

 			{

 			break;

 			}

 		else if(res == KErrDivideByZero && aInitial.NotZero())

 			{

 			iResult = EFalse;

 			}

 		else if(res != KErrNone)

 			{

 			User::Leave(res);

 			}

 		}

 	// b should be the same as the initial value

 	if( b != aInitial )

 		{

 		iResult = EFalse;

 		}

 	//tests division by something smaller than a word

 	if(aInitial.WordCount() <= 1)

 		{

 		RInteger dividend = RInteger::NewL(a);

 		CleanupStack::PushL(dividend);

 		for(j=1; j<aRange; j++)

 			{

 			RInteger quotient;

 			//try to find aInitial by repeatedly dividing dividend by aInitial aRange times 

 			TRAPD(res, quotient = dividend.DividedByL(aInitial.ConvertToLongL()));

 			//the first time through aInitial is 0 so this is expected

 			if(res == KErrDivideByZero && aInitial.IsZero())

 				{

 				break;

 				}

 			else if(res == KErrDivideByZero && aInitial.NotZero())

 				{

 				iResult = EFalse;

 				}

 			else if(res != KErrNone)

 				{

 				User::Leave(res);

 				}

 			dividend.Set(quotient);

 			}

 		if( dividend != aInitial )

 			{

 			iResult = EFalse;

 			}

 		TUint remainder=1;

 		TRAPD(res, remainder = a.ModuloL(aInitial.ConvertToLongL()));

 		//the first time through aInitial is 0

 		if(res != KErrDivideByZero && res != KErrNone)

 			{

 			User::Leave(res);

 			}

 		else if(res == KErrDivideByZero && aInitial.NotZero())

 			{

 			iResult = EFalse;

 			}

 		//else we have an expected divide by zero, ignore it.

 		if(remainder != 0)

 			{

 			iResult = EFalse;

 			}

 		CleanupStack::PopAndDestroy(&dividend);

 		}

 	RInteger c = RInteger::NewL(aRange);

 	CleanupStack::PushL(c);

 	RInteger d = aInitial.ExponentiateL(c);

 	CleanupStack::PushL(d);

 	// c and a should now be the same

 	if( d != a )

 		{ 

 		iResult = EFalse;

 		}

 	RInteger e = RInteger::NewL(a);

 	CleanupStack::PushL(e);

 	TRAPD(res, e %= aInitial);

 	//the first time through aInitial is 0

 	if(res != KErrDivideByZero && res != KErrNone)

 		{

 		User::Leave(res);

 		}

 	else if(res == KErrDivideByZero && aInitial.NotZero())

 		{

 		iResult = EFalse;

 		}

 	//else we have an expected divide by zero, ignore it.

 	// (aInitial^aRange)%aInitial == 0

 	if( e != 0 )

 		{

 		iResult = EFalse;

 		}

 	CleanupStack::PopAndDestroy(5);//e,d,c,b,a

 	__UHEAP_MARKEND;

 	}

 void CBasicMathsFB::MiscDivL()

 	{

 	__UHEAP_MARK;

 	TUint seed = 10;

 	TUint diviser = 2;

 	TInt dividendInt = 10;

 	RInteger dividend = RInteger::NewL(seed);

 	CleanupStack::PushL(dividend);

 	TInt longInt = dividend.ConvertToLongL();

 	// Test for inequality FALSE

 	TBool res0 = dividend != dividendInt;

 	if (res0)

 		{

 		iResult = EFalse;

 		}

 	// Test for inequality TRUE

 	res0 = dividend != TInt(diviser);

 	if (!res0)

 		{

 		iResult = EFalse;

 		}

 	// Test for equality TRUE

 	res0 = dividend >= dividend; 

 	if (!res0)

 		{

 		iResult = EFalse;

 		}

 	RInteger quotient;

 	CleanupStack::PushL(quotient);

 	// 10 / 2 = 5

 	TRAPD(res, quotient = dividend.DividedByL(diviser));

 	if (res != KErrNone)

 		{

 		User::Leave(res);

 		}

 	else if (quotient != (dividendInt/diviser))

 		{

 		iResult = EFalse;

 		}

 	// Test for greater value TRUE and equality FALSE

 	res0 = dividend >= quotient; 

 	if (!res0)

 		{

 		iResult = EFalse;

 		}

 	// Test for greater value FALSE and equality FALSE

 	res0 = quotient >= dividend; 

 	if (res0)

 		{

 		iResult = EFalse;

 		}

 	// 10 / 10 = 1

 	TRAPD(res1, dividend /= dividendInt);

 	if (res1 != KErrNone)

 		{

 		User::Leave(res);

 		}	

 	else if (dividend != (dividendInt/seed))

 		{

 		iResult = EFalse;

 		}

 	// 1 % 10 = 1 (dividend = 1, due to last step) 

 	TRAPD(res2, dividend %= dividendInt);

 	if (res2 != KErrNone)

 		{

 		User::Leave(res);

 		}	

 	else if (dividend != (dividendInt/seed))

 		{

 		iResult = EFalse;

 		}

 	// 1 x 1 = 1 (dividend = 1, due to last step)

 	RInteger squaredInt = dividend.SquaredL();

 	CleanupStack::PushL(squaredInt);

 	if ( squaredInt != (dividendInt/seed))

 		{

 		iResult = EFalse;

 		}

 	RInteger expSeed = RInteger::NewL(10);

 	CleanupStack::PushL(expSeed);

 	RInteger exponent = RInteger::NewL(3);

 	CleanupStack::PushL(exponent);

 	RInteger expResult;

 	CleanupStack::PushL(expResult);

 	TRAPD(res3, expResult = expSeed.ExponentiateL(exponent));

 		if (res3 != KErrNone)

 			{

 			User::Leave(res);

 			}

 		else if (expResult != (10*10*10))

 			{

 			iResult = EFalse;

 			}

 	CleanupStack::PopAndDestroy(6, &dividend); // dividend, quotient, squardInt, expSeed, exponent, expResult

 	__UHEAP_MARKEND;

 	}