/*

 * 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);

 	}