// 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 "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 of test CWSPDecodeTest

// 

//

#include "cwspdecodetest.h"

#include <wspdummyconstants.h>

CWSPDecodeTest* CWSPDecodeTest::NewLC(CIpuTestHarness* aTestHarness)

	{

	CWSPDecodeTest* self = new(ELeave)CWSPDecodeTest(aTestHarness);

	CleanupStack::PushL(self);

	return self;

	}

CWSPDecodeTest::CWSPDecodeTest(CIpuTestHarness* aTestHarness):

	iTestHarness(aTestHarness)

	{}

CWSPDecodeTest::~CWSPDecodeTest()

	{}

void CWSPDecodeTest::DoTestsL()

	{

	VarTypesTestL();

	LengthValsTestL();

	StringTestL();

	TokensTestL();

	IntegersTestL();

	LongIntTestL();

	UintVarsTestL();

	VersionTestL();

	DateTestL();

	SegmenterTestL();

	}

//* VarTypes */

TBool CWSPDecodeTest::VarType(TPtrC8 aBuf, TWspPrimitiveDecoder::TWspHeaderType aShouldBeType)

	{

	TWspPrimitiveDecoder dec(aBuf);

	TWspPrimitiveDecoder::TWspHeaderType type=dec.VarType();

	TBool bSuccess  = EFalse;

	if (type == aShouldBeType)

		bSuccess = ETrue;

	TBuf8<25> typeStr;

	switch (aShouldBeType)

	{

	case TWspPrimitiveDecoder::ENotSet:

		typeStr.Copy(_L("ENotSet"));

		break;

	case TWspPrimitiveDecoder::ELengthVal:

		typeStr.Copy(_L("ELengthVal"));

		break;

	case TWspPrimitiveDecoder::EQuotedString:

		typeStr.Copy(_L("EQuotedString"));

		break;	

	case TWspPrimitiveDecoder::EString:

		typeStr.Copy(_L("EString"));

		break;

	case TWspPrimitiveDecoder::E7BitVal:

		typeStr.Copy(_L("E7BitVal"));

		break;

	}

	return bSuccess;

	}

void CWSPDecodeTest::VarTypesTestL()

	{

	_LIT(KTestText, "WSP Decode: VarTypes");

	iTestHarness->StartTestL(KTestText);

	TRAPD(error, TestVarTypesL());

	iTestHarness->EndTest(error);

	User::LeaveIfError(error);

	}

void CWSPDecodeTest::TestVarTypesL()

	{

	const TUint8 KToken[] = {0x81};

	const TUint8 KString1[] = {'a', 'b', 'c', 0x00};

	const TUint8 KString2[] = {0x33};

	const TUint8 KLen0[] = {0x00};

	const TUint8 KLen1[] = {0x01};

	const TUint8 KLen2[] = {0x1F};

	TBuf8<255> buf;

	buf.Copy(KToken, sizeof(KToken));

	if (!VarType(buf, TWspPrimitiveDecoder::E7BitVal))

		User::Leave(KErrGeneral);

	buf.Copy(KString1, sizeof(KString1));

	if (!VarType(buf, TWspPrimitiveDecoder::EString))

		User::Leave(KErrGeneral);

	buf.Copy(KString2, sizeof(KString2));

	if (!VarType(buf, TWspPrimitiveDecoder::EString))

		User::Leave(KErrGeneral);

	buf.Copy(KLen0, sizeof(KLen0));

	if (!VarType(buf, TWspPrimitiveDecoder::ELengthVal))

		User::Leave(KErrGeneral);

	buf.Copy(KLen1, sizeof(KLen1));

	if (!VarType(buf, TWspPrimitiveDecoder::ELengthVal))

		User::Leave(KErrGeneral);

	buf.Copy(KLen2, sizeof(KLen2));

	if (!VarType(buf, TWspPrimitiveDecoder::ELengthVal))

		User::Leave(KErrGeneral);

	}

//* LenVal */

TBool CWSPDecodeTest::LenVal(TPtrC8 aBuf, TInt aShouldBeVal)

	{

	TBool success  = EFalse;

	TWspPrimitiveDecoder dec(aBuf);	

	TInt len;

	success = dec.LengthVal(len);

	if (success == KErrCorrupt)

		return ETrue;

	return len == aShouldBeVal && !(success < KErrNone);

	}

void CWSPDecodeTest::LengthValsTestL()

	{

	_LIT(KTestText, "WSP Decode: LengthVals");

	iTestHarness->StartTestL(KTestText);

	TRAPD(error, TestLengthValsL());

	iTestHarness->EndTest(error);

	User::LeaveIfError(error);

	}

void CWSPDecodeTest::TestLengthValsL()

	{

	const TUint8 KLen0[] = {0x00};

	const TUint8 KLen1[] = {0x01};

	const TUint8 KLen26[] = {0x1A};

	const TUint8 KLenUintVAR17680[] = {0x1F, 0x81,0x8A,0x10};

	const TUint8 KLenUintVARCorrupt[] = {0x1F, 0x81,0x8A,0x80};

	TBuf8<255> buf;

	buf.Copy(KLen0, sizeof(KLen0));

	if (!LenVal(buf, 0))

		User::Leave(KErrGeneral);

	buf.Copy(KLen1, sizeof(KLen1));

	if (!LenVal(buf, 1))

		User::Leave(KErrGeneral);

	buf.Copy(KLen26, sizeof(KLen26));

	if (!LenVal(buf, 0x1A))

		User::Leave(KErrGeneral);

	buf.Copy(KLenUintVAR17680, sizeof(KLenUintVAR17680));

	if (!LenVal(buf, 17680))

		User::Leave(KErrGeneral);

	buf.Copy(KLenUintVARCorrupt, sizeof(KLenUintVARCorrupt));

	if (!LenVal(buf, -1))

		User::Leave(KErrGeneral);

	}

//* String */

TBool CWSPDecodeTest::String(TPtrC8 aBuf, TPtrC8 aShouldBe, TInt /*aErr*/)

	{

	TBool success  = EFalse;

	TWspPrimitiveDecoder dec(aBuf);

	TPtrC8 str;

	success = dec.String(str);

	if (success < KErrNone)

		return success;

	if (str != aShouldBe)

		success = EFalse;

	// Copy to 16 bits

	return success;

	}

void CWSPDecodeTest::StringTestL()

	{

	_LIT(KTestText, "WSP Decode: String");

	iTestHarness->StartTestL(KTestText);

	TRAPD(error, TestStringL());

	iTestHarness->EndTest(error);

	User::LeaveIfError(error);

	}

void CWSPDecodeTest::TestStringL()

	{

	const TUint8 KStringHello[] = {'H','e','l','l','o',0x00};

	const TUint8 KStringEmpty[] = {0x00};

	const TUint8 KStringNotAString[] = {0x1A};

	const TUint8 KStringCorruptNoZero[] = {'H','e','l','l','o'};

	const TUint8 KStringbye[] = {'b','y','e',0x00};

	TBuf8<255> buf;

	buf.Copy(KStringHello, sizeof(KStringHello));

	if (!String(buf, _L8("Hello")))

		User::Leave(KErrGeneral);

	buf.Copy(KStringEmpty, sizeof(KStringEmpty));

	if (!String(buf, _L8(""),KErrCorrupt))

		User::Leave(KErrGeneral);

	buf.Copy(KStringNotAString, sizeof(KStringNotAString));

	if (!String(buf, _L8(""), KErrCorrupt))

		User::Leave(KErrGeneral);

	buf.Copy(KStringCorruptNoZero, sizeof(KStringCorruptNoZero));

	if (!String(buf, _L8(""), KErrCorrupt))

		User::Leave(KErrGeneral);

	buf.Copy(KStringbye, sizeof(KStringbye));

	if (!String(buf, _L8("bye")))

		User::Leave(KErrGeneral);

	}

//* Tokens */

TBool CWSPDecodeTest::Token(TPtrC8 aBuf, TUint8 aShouldBe, TInt aErr)

	{

	TInt success;

	TWspPrimitiveDecoder dec(aBuf);

	TUint8 val;

	success = dec.Val7Bit(val);

	if (success < KErrNone && success == aErr)

		return ETrue;

	return val == aShouldBe;

	}

void CWSPDecodeTest::TokensTestL()

	{

	_LIT(KTestText, "WSP Decode: Tokens");

	iTestHarness->StartTestL(KTestText);

	TRAPD(error, TestTokensL());

	iTestHarness->EndTest(error);

	User::LeaveIfError(error);

	}

void CWSPDecodeTest::TestTokensL()

	{

	const TUint8 KToken0[] = {0x80};

	const TUint8 KToken1[] = {0x81};

	const TUint8 KToken1A[] = {0x9A};

	const TUint8 KToken38[] = {0xB8};

	const TUint8 KTokenCorruptLen[] = {0x01};

	TBuf8<255> buf;

	buf.Copy(KToken0, sizeof(KToken0));

	if (!Token(buf, 0))

		User::Leave(KErrGeneral);

	buf.Copy(KToken1, sizeof(KToken1));

	if (!Token(buf, 1))

		User::Leave(KErrGeneral);

	buf.Copy(KToken1A, sizeof(KToken1A));

	if (!Token(buf, 0x1A))

		User::Leave(KErrGeneral);

	buf.Copy(KToken38, sizeof(KToken38));

	if (!Token(buf, 0x38))

		User::Leave(KErrGeneral);

	buf.Copy(KTokenCorruptLen, sizeof(KTokenCorruptLen));

	if (!Token(buf, 1))

		User::Leave(KErrGeneral);

	}

//* Integers */

TBool CWSPDecodeTest::Integer(TPtrC8 aBuf, TUint32 aShouldBe, TInt aErr)

	{

	TInt success;

	TWspPrimitiveDecoder dec(aBuf);

	TUint32 val;

	success = dec.Integer(val);

	if (success < KErrNone && success == aErr)

		return success;

	return val == aShouldBe;

	}

void CWSPDecodeTest::IntegersTestL()

	{

	_LIT(KTestText, "WSP Decode: Integers");

	iTestHarness->StartTestL(KTestText);

	TRAPD(error, TestIntegersL());

	iTestHarness->EndTest(error);

	User::LeaveIfError(error);

	}

void CWSPDecodeTest::TestIntegersL()

	{

	const TUint8 KInt0[] = {0x80};

	const TUint8 KInt1[] = {0x81};

	const TUint8 KIntA[] = {0x8A};

	const TUint8 KInt38[] = {0xB8};

	const TUint8 KIntLong4321[] = {0x02, 0x43,0x21};

	const TUint8 KIntLongABCDEF[] = {0x03, 0xAB,0xCD,0xEF};

	const TUint8 KIntCorrupt[] = {0x01};

	TBuf8<255> buf;

	buf.Copy(KInt0, sizeof(KInt0));

	if (!Integer(buf, 0))

		User::Leave(KErrGeneral);

	buf.Copy(KInt1, sizeof(KIntA));

	if (!Integer(buf, 1))

		User::Leave(KErrGeneral);

	buf.Copy(KIntA, sizeof(KIntA));

	if (!Integer(buf, 0x0A))

		User::Leave(KErrGeneral);

	buf.Copy(KInt38, sizeof(KInt38));

	if (!Integer(buf, 0x38))

		User::Leave(KErrGeneral);

	buf.Copy(KIntLong4321, sizeof(KIntLong4321));

	if (!Integer(buf, 0x4321))

		User::Leave(KErrGeneral);

	buf.Copy(KIntLongABCDEF, sizeof(KIntLongABCDEF));

	if (!Integer(buf, 0xABCDEF))

		User::Leave(KErrGeneral);

	buf.Copy(KIntCorrupt, sizeof(KIntCorrupt));

	if (!Integer(buf,0, KErrCorrupt))

		User::Leave(KErrGeneral);

	}

//* LongInt */

TBool CWSPDecodeTest::LongInt(TPtrC8 aBuf, TUint32 aShouldBe, TInt aErr)

	{

	TInt success;

	TWspPrimitiveDecoder dec(aBuf);

	TUint32 val;

	success = dec.LongInt(val);

	if (success < KErrNone && success == aErr)

		return ETrue;

	return val == aShouldBe;

	}

void CWSPDecodeTest::LongIntTestL()

	{

	_LIT(KTestText, "WSP Decode: LongInt");

	iTestHarness->StartTestL(KTestText);

	TRAPD(error, TestLongIntL());

	iTestHarness->EndTest(error);

	User::LeaveIfError(error);

	}

void CWSPDecodeTest::TestLongIntL()

	{

	const TUint8 KIntLong0[] = {0x01, 0x00};

	const TUint8 KIntLong4321[] = {0x02, 0x43,0x21};

	const TUint8 KIntLongABCDEF[] = {0x03, 0xAB,0xCD,0xEF};

	const TUint8 KIntLongABCDEF112233[] = {0x06, 0xAB,0xCD,0xEF, 0x11,0x22,0x33};

	const TUint8 KIntTooLong110009ABCDEF112233[] = {0x0A, 0x11,0x00, 0x09, 0xAB,0xCD,0xEF, 0x11,0x22,0x33};

	const TUint8 KIntCorrupt[] = {0x01};

	TBuf8<255> buf;

	buf.Copy(KIntLong0, sizeof(KIntLong0));

	if (!LongInt(buf, 0))

		User::Leave(KErrGeneral);

	buf.Copy(KIntLong4321, sizeof(KIntLong4321));

	if (!LongInt(buf, 0x4321))

		User::Leave(KErrGeneral);

	buf.Copy(KIntLongABCDEF, sizeof(KIntLongABCDEF));

	if (!LongInt(buf, 0xABCDEF))

		User::Leave(KErrGeneral);

	buf.Copy(KIntLongABCDEF112233, sizeof(KIntLongABCDEF112233));

	if (!LongInt(buf, 0xEF112233))

		User::Leave(KErrGeneral);

	buf.Copy(KIntTooLong110009ABCDEF112233, sizeof(KIntTooLong110009ABCDEF112233));

	if (!LongInt(buf, 0x09ABCDEF, KErrCorrupt))

		User::Leave(KErrGeneral);

	buf.Copy(KIntCorrupt, sizeof(KIntCorrupt));

	if (!LongInt(buf, 0, KErrCorrupt))

		User::Leave(KErrGeneral);

	}

//* UintVar */

TBool CWSPDecodeTest::UintVar(TPtrC8 aBuf, TUint32 aShouldBe, TInt aErr)

	{

	TInt success;

	TWspPrimitiveDecoder dec(aBuf);

	TUint32 val;

	success = dec.UintVar(val);

	if (success < KErrNone && success == aErr)

		return ETrue;

	return val == aShouldBe;

	}

void CWSPDecodeTest::UintVarsTestL()

	{

	_LIT(KTestText, "WSP Decode: UintVars");

	iTestHarness->StartTestL(KTestText);

	TRAPD(error, TestUintVarsL());

	iTestHarness->EndTest(error);

	User::LeaveIfError(error);

	}

void CWSPDecodeTest::TestUintVarsL()

	{

	const TUint8 KUint0[] = {0x00};

	const TUint8 KUint1[] = {0x01};

	const TUint8 KUintA[] = {0x80,0x0A};

	const TUint8 KUintFA[] = {0x81,0x7A};

	const TUint8 KLenUintVAR4510[] = {0x81, 0x8A, 0x10};

	const TUint8 KLenUintVARCorrupt[] = {0x8F, 0x81,0x8A,0x80,0x88};

	const TUint8 KIntLongACorrupt[] = {0xF3, 0xAB,0xCD,0xEF};

	TBuf8<255> buf;

	buf.Copy(KUint0, sizeof(KUint0));

	if (!UintVar(buf, 0))

		User::Leave(KErrGeneral);

	buf.Copy(KUint1, sizeof(KUint1));

	if (!UintVar(buf, 1))

		User::Leave(KErrGeneral);

	buf.Copy(KUintA, sizeof(KUintA));

	if (!UintVar(buf, 0x0A))

		User::Leave(KErrGeneral);

	buf.Copy(KUintFA, sizeof(KUintFA));

	if (!UintVar(buf, 0xFA))

		User::Leave(KErrGeneral);

	buf.Copy(KLenUintVAR4510, sizeof(KLenUintVAR4510));

	if (!UintVar(buf, 0x4510))

		User::Leave(KErrGeneral);

	buf.Copy(KLenUintVARCorrupt, sizeof(KLenUintVARCorrupt));

	if (!UintVar(buf, 0, KErrCorrupt))

		User::Leave(KErrGeneral);

	buf.Copy(KIntLongACorrupt, sizeof(KIntLongACorrupt));

	if (!UintVar(buf, 0, KErrCorrupt))

		User::Leave(KErrGeneral);

	}

//* VersionL */

TBool CWSPDecodeTest::VersionL(RStringPool aPool, TPtrC8 aBuf, TPtrC8 aShouldBe, TInt aErr)

	{

	TInt success;

	TWspPrimitiveDecoder dec(aBuf);

	TBool retVal = EFalse;

	RStringF val;

	success = dec.VersionL(aPool,val);

	CleanupClosePushL(val);

	if (success < KErrNone && success == aErr)

		retVal = ETrue;

	else

		{

		RStringF should = aPool.OpenFStringL(aShouldBe);

		retVal = val == should;

		should.Close();

		}

	CleanupStack::PopAndDestroy(&val);

	return retVal;

	}