/*
* Copyright (c) 2001-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: 
* Implementation for testing sequence object encoding/decoding
*
*/


#include "testsequence.h"
#include "tasn1normaltest.h"
#include <asn1enc.h>
#include <asn1dec.h>
#include <e32math.h>
#include <e32cons.h>

#include <bigint.h>

CTestSequence* CTestSequence::NewL(CASN1NormalTest &aASN1Action)
	{
	CTestSequence* test = new (ELeave) CTestSequence(aASN1Action);
	return test;
	}

CTestSequence::CTestSequence(CASN1NormalTest &aASN1Action) : CTestBase(aASN1Action)
	{
	};


void CTestSequence::GetName(TDes& aBuf)
	{
	aBuf.Copy(_L("Test Sequence"));
	}

void CTestSequence::FillParameterArray(void)
	{
	iParameters->Append(CTestParameter::EInt);
	iParameters->Append(CTestParameter::EInt);
	}


TBool CTestSequence::PerformTest(CConsoleBase& aConsole, const TInt &aTestDepth, const TInt &aTestSize, const TInt &aTestNumber, const TInt &aTotalTests)
	{
	iObjectsEncoded = 1;
	CASN1EncBase* encoder = MakeSequenceEncoderLC(aTestDepth, 0, aTestSize);
	
	// Prepare a buffer
	TInt totalLength = encoder->LengthDER();
	HBufC8* buf = HBufC8::NewMaxLC(totalLength);
	TPtr8 tBuf = buf->Des();
	
	// Write into the buffer
	TUint writeLength = 0;
	encoder->WriteDERL(tBuf, writeLength);

	// Check number of objects in buffer reads OK and matches what we hoped
	TInt objectsRead = ReadAndCountL(tBuf);
	if (objectsRead != iObjectsEncoded)
		{
		aConsole.Write(_L("ERROR! Encoded sequence object count mismatch\n"));
		iASN1Action.ReportProgressL(KErrASN1EncodingError, aTestNumber, aTotalTests);
		CleanupStack::PopAndDestroy(2); // buf, encoder
		return(EFalse);
		}
	else
		{	
		iASN1Action.ReportProgressL(KErrNone, aTestNumber, aTotalTests);
		CleanupStack::PopAndDestroy(2); // buf, encoder
		return(ETrue);
		}
	}


CASN1EncSequence* CTestSequence::MakeSequenceEncoderLC(TInt aMaxDepth, 
													   TInt aMinSize, 
													   TInt aMaxSize)
	{
	__ASSERT_ALWAYS(aMaxDepth > 0, User::Leave(KErrArgument));
	__ASSERT_ALWAYS(aMinSize >= 0, User::Leave(KErrArgument));
	__ASSERT_ALWAYS(aMinSize <= aMaxSize, User::Leave(KErrArgument));

	CASN1EncSequence* encoder = CASN1EncSequence::NewLC();

	TUint targetSize = aMinSize + (Math::Random() % (aMaxSize + 1 - aMinSize));
	TUint size = 0;
	while (size < targetSize)
		{
		const TInt KMaxChildType = 3;
		const TInt childTypes = aMaxDepth > 1 ? KMaxChildType + 1 : KMaxChildType;
		const TInt childType = (Math::Random() >> 5) % childTypes;
		CASN1EncBase* child = 0;
		CASN1EncSequence* seqEnc = 0;
		switch (childType)
			{
			case 0:
				child = CASN1EncInt::NewLC(Math::Random());
				break;
			case 1:
				{
				RInteger i = RInteger::NewRandomL(1234, TInteger::EAllBitsRandom);
				CleanupStack::PushL(i);
				CASN1EncBigInt* encInt = CASN1EncBigInt::NewLC(i);
				CleanupStack::Pop(); // encInt
				CleanupStack::PopAndDestroy(&i); // a deep copy of the info is taken
				CleanupStack::PushL(encInt);
				child = encInt;
				break;
				}
				case 2:
				child = CASN1EncNull::NewLC();
				break;
			case KMaxChildType:
				// last case must be for next-level sequence encoder
				seqEnc = MakeSequenceEncoderLC(aMaxDepth - 1, aMinSize, aMaxSize);
				child = seqEnc;
				break;
			default:
				User::Leave(KErrNotSupported);
				break;
			}
		
		if (child)
			{
			encoder->AddChildL(child);
			CleanupStack::Pop(); // child
			++iObjectsEncoded;
			++size;

			// If we've just added a sequence, want to test ability to add things to a sequence
			// *that is itself a child*, to check size changes propagate upwards to parent
			if (seqEnc)
				{
				child = CASN1EncInt::NewLC(Math::Random());

				seqEnc->AddChildL(child);
				CleanupStack::Pop(); // child
				++iObjectsEncoded;
				seqEnc = 0;
				}
			}
		}
	
	return encoder;
	}


TInt CTestSequence::ReadAndCountL(const TDesC8& aBuf)
	{
	TInt result = 1;
	
	TASN1DecGeneric decoder(aBuf);
	decoder.InitL();

	TInt bufLength = aBuf.Length();
	TInt readLength = decoder.LengthDER();

	__ASSERT_ALWAYS(bufLength >= readLength, User::Leave(KErrCorrupt));
	if (bufLength > readLength)
		{
		// Read the remainder of this buffer too
		result += ReadAndCountL(aBuf.Mid(readLength));
		}

	if (decoder.Encoding()[0] & 0x20		// Tagged as constructed
		&& decoder.LengthDERContent() > 0) 
		{
		// Read objects from inside the sequence too
		result += ReadAndCountL(decoder.GetContentDER());
		}

	return result;
	}

TBool CTestSequence::PerformTestsL(CConsoleBase& aConsole)
	{
	// Keep these two coprime to maximise combinations
	const TInt KMaxSize = 11;
	const TInt KMaxDepth = 10;
	CTestParameter* test;
	TInt totalTests, currentTest=0;
	TInt maxDepth;
	TInt maxSize;

	if(!CountTests(totalTests)) return(EFalse);

	for(TInt pos = 0; pos < iValues->Count(); pos++)
		{
		test = (*iValues)[pos];
		switch(test->GetType())
			{
			case CTestParameter::EInt :
				{
				CIntTestParameter *intTest = REINTERPRET_CAST(CIntTestParameter*, test);

				// Get the encoder and decoder
				maxDepth = intTest->Value();
				test = (*iValues)[++pos];
				if(test->GetType() != CTestParameter::EInt)
					{
					User::Leave(KErrNotSupported);
					}
				intTest = REINTERPRET_CAST(CIntTestParameter*, test);
				maxSize = intTest->Value();
				if(!PerformTest(aConsole, maxDepth, maxSize, currentTest, totalTests))
					{
					return(EFalse);
					}
				currentTest++;
				break;
				}
			case CTestParameter::ERandom :
				{
				CRandomTestParameter *randomTest = REINTERPRET_CAST(CRandomTestParameter*, test);
				// Get the encoder and decoder

				for(TInt test = 0; test <= randomTest->Interations(); test++)
					{

					// Get the encoder and decoder
					maxDepth = (test % KMaxDepth) + 1;
					maxSize = test % KMaxSize;

					currentTest++;
					// Don't do the too-big combinations (too slow)
					if (maxDepth +  maxSize > 14) continue;
					if(!PerformTest(aConsole, maxDepth, maxSize, currentTest, totalTests))
						{
						return(EFalse);
						}
					}
				break;
				}
			default:
				{
				return EFalse;
				}
			}
		}
	iASN1Action.ReportProgressL(KErrNone, totalTests, totalTests);
	return(ETrue);
	}