/*
* 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;
	}