// Copyright (c) 2004-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:

// EtelPacketTestAuthenticationAndDNS.cpp

// This is the cpp file for Packet Data Context Data Structure

// File created 03-11-2004

// 

//

// Symbian OS includes

#include <e32base.h>

#include <etelpckt.h>

#include <etelutils.h>

#include <pcktcs.h>

#include "Te_EtelPacketTestStepBase.h"

#include "testdef.h"

#include "Te_etelpckt_defs.h"

#include "Te_EtelPacketTestPCO_IE.h"

CEtelPacketTestPCO_IE::CEtelPacketTestPCO_IE()

{

	// store the name of this test case

	SetTestStepName(_L("PCO_IE"));

}

// destructor

CEtelPacketTestPCO_IE::~CEtelPacketTestPCO_IE()

{

}

enum TVerdict CEtelPacketTestPCO_IE::doTestStepL( void )

/**

 * Test step AuthorizationData

 * 

 */

{

	TInt ret;

	//	---------------------------------------------------

	//	TEST CASE 1 - Construction

	//	---------------------------------------------------

	const TInt KZero=0;

	const TInt KMinimumBufferSize = 1;

	const TInt KSmallBuffer=20;

	//	Create Item

	const TUint16 XId=1;

	const TUint16 YId=10;

	RPacketContext::TPcoId pcoIdX(XId);

	RPacketContext::TPcoId pcoIdY(YId);

	//	Create Item Buffers

	const TInt KAppendableBufferSize=3;

	//	BufferX

	TBuf8<KAppendableBufferSize> appendableBufferX(_L8("xxx"));	

	appendableBufferX.SetLength(KAppendableBufferSize);

	TPtr8 appendablePtrX(const_cast<TUint8*>(appendableBufferX.Ptr()),appendableBufferX.Length(),appendableBufferX.Length());

	//	BufferY

	TBuf8<KAppendableBufferSize> appendableBufferY(_L8("yyy"));	

	appendableBufferY.SetLength(KAppendableBufferSize);

	TPtr8 appendablePtrY(const_cast<TUint8*>(appendableBufferY.Ptr()),appendableBufferY.Length(),appendableBufferY.Length());

	//	Create Buffer for TLV struct

	TBuf8<KSmallBuffer> smallBuffer;		//	MaxLength = 20

	smallBuffer.SetLength(smallBuffer.MaxLength());

	smallBuffer.FillZ();

	TPtr8 smallPtr(smallBuffer.LeftTPtr(smallBuffer.MaxLength()));

	smallPtr.SetLength(0);

	//	Create Zero length buffer

	TPtr8 zeroSizePtr=smallPtr.LeftTPtr(KZero);

	TTlvStruct<RPacketContext::TPcoId,RPacketContext::TPcoItemDataLength> zeroTLV(zeroSizePtr,KZero);

	//	Create TLV struct with size=20

	TTlvStruct<RPacketContext::TPcoId,RPacketContext::TPcoItemDataLength> smallTLV(smallPtr,KZero);	

	//	---------------------------------------------------

	//	TEST CASE 2 - AppendItemL

	//	---------------------------------------------------

	//	Append an Item to zero length Tlv

	ret=zeroTLV.AppendItemL(pcoIdX,appendablePtrX);

	TEST(ret==KErrOverflow);

	//	Append a larger buffer 

	const TInt KLargeBuffer=30;

	TBuf8<KLargeBuffer> largeBuffer(_L8("xxxxxxxxx"));	

	largeBuffer.SetLength(KLargeBuffer);

	TPtr8 largePtr(const_cast<TUint8*>(largeBuffer.Ptr()),largeBuffer.Length(),largeBuffer.Length());

	//	Append

	ret=smallTLV.AppendItemL(pcoIdX,largePtr);

	TEST(ret==KErrOverflow);

	//	Append 3 Items	-  X + Y + X

	ret=smallTLV.AppendItemL(pcoIdX,appendablePtrX);

	TEST(ret==KErrNone);

	ret=smallTLV.AppendItemL(pcoIdY,appendablePtrY);

	TEST(ret==KErrNone);

	ret=smallTLV.AppendItemL(pcoIdX,appendablePtrX);

	TEST(ret==KErrNone);

	//	Overflow the buffer

	ret=smallTLV.AppendItemL(pcoIdY,appendablePtrY);

	TEST(ret==KErrOverflow);

	//	---------------------------------------------------

	//	TEST CASE 3 - NextItemL

	//	Buffer contains = XYX

	//	---------------------------------------------------

	//	Construct TPtr8 buffers for retrieval

	//	Buffer large enough to handle data

	const TInt KBigEnoughBuf=5;

	TBuf8<KBigEnoughBuf> bigEnoughBuf;

	bigEnoughBuf.SetLength(0);

	TPtr8 bigEnoughPtr(const_cast<TUint8*>(bigEnoughBuf.Ptr()),bigEnoughBuf.Length(),bigEnoughBuf.MaxLength());

	//	Buffer too small to hold data

	const TInt KTooSmallBuf=2;

	TBuf8<KTooSmallBuf> tooSmallBuf;

	tooSmallBuf.SetLength(0);

	TPtr8 tooSmallPtr(const_cast<TUint8*>(tooSmallBuf.Ptr()),tooSmallBuf.Length(),tooSmallBuf.MaxLength());

	//	Get Next Item from zero length TLV

	ret=zeroTLV.NextItemL(pcoIdY,bigEnoughPtr);

	TEST(ret==KErrNotFound);

	//	Create Item Z	

	smallTLV.ResetCursorPos();

	const TUint16 ZId=2;

	RPacketContext::TPcoId pcoIdZ(ZId);

	//	Get a non existant item	

	TInt err(KErrNone);

	TInt leaveErr(KErrNone);

	TRAP(leaveErr,err=smallTLV.NextItemL(pcoIdZ,bigEnoughPtr));

	TEST(leaveErr==KErrNone && err==KErrNotFound);

	//	Get an existing item in bigEnoughBuffer

	ret=smallTLV.NextItemL(pcoIdX,bigEnoughPtr);

	TEST(ret==KErrNone);

	TEST(bigEnoughPtr==appendablePtrX);

	//	Get last item 

	ret=smallTLV.NextItemL(pcoIdX,bigEnoughPtr);

	TEST(ret==KErrNone);

	TEST(bigEnoughPtr==appendablePtrX);

	//	Cursor should be at end, try to get item before cursor

	ret=smallTLV.NextItemL(pcoIdY,bigEnoughPtr);

	TEST(ret==KErrNotFound);

	//	reset cursor

	smallTLV.ResetCursorPos();

	//	get item

	ret=smallTLV.NextItemL(pcoIdY,bigEnoughPtr);

	TEST(ret==KErrNone);

	TEST(bigEnoughPtr==appendablePtrY);

	//	---------------------------------------------------

	//	TEST CASE 4 - RemoveNextItemL

	//	Buffer contains = XYX

	//	---------------------------------------------------

	//	remove item form zero length TLV

	ret=zeroTLV.RemoveNextItemL(pcoIdX);

	TEST(ret==KErrNotFound);

	//	reset cursor

	smallTLV.ResetCursorPos();

	//	remove pcoIdX

	ret=smallTLV.RemoveNextItemL(pcoIdX);

	TEST(ret==KErrNone);

	//	remove pcoIdX

	ret=smallTLV.RemoveNextItemL(pcoIdX);

	TEST(ret==KErrNone);

	ret=smallTLV.AppendItemL(pcoIdZ,appendablePtrX);

	TEST(ret==KErrNone);

	ret=smallTLV.AnyNextItemL(pcoIdY,bigEnoughPtr);

	TEST(ret==KErrNone);

	TEST(pcoIdY.Id()==YId);	

	TEST(bigEnoughPtr==appendablePtrY);

	ret=smallTLV.AnyNextItemL(pcoIdZ,bigEnoughPtr);

	TEST(ret==KErrNone);

	TEST(pcoIdZ.Id()==ZId);	

	TEST(bigEnoughPtr==appendablePtrX);

	// 	remove pcoIdY

	ret=smallTLV.RemoveNextItemL(pcoIdY);

	TEST(ret==KErrNotFound);

	//	reset cursor

	smallTLV.ResetCursorPos();

	ret=smallTLV.RemoveNextItemL(pcoIdX);

	TEST(ret==KErrNotFound);

	ret=smallTLV.RemoveNextItemL(pcoIdY);

	TEST(ret==KErrNone);

	ret=smallTLV.RemoveNextItemL(pcoIdZ);

	TEST(ret==KErrNone);

	//	---------------------------------------------------

	//	TEST CASE 4 - AnyNextItemL

	//	Buffer is Empty

	//	---------------------------------------------------

	//	Get any next item from zero length TLV

	ret=zeroTLV.AnyNextItemL(pcoIdY,bigEnoughPtr);

	TEST(ret==KErrNotFound);

	ret=smallTLV.AnyNextItemL(pcoIdY,tooSmallPtr);

	TEST(ret==KErrNotFound);

	//	Append Item

	ret=smallTLV.AppendItemL(pcoIdX,appendablePtrX);

	TEST(ret==KErrNone);

	//	Get item after appending an existing item

	ret=smallTLV.NextItemL(pcoIdX,bigEnoughPtr);

	TEST(ret==KErrNone);

	TEST(bigEnoughPtr==appendablePtrX);

	ret=smallTLV.AppendItemL(pcoIdY,appendablePtrY);

	TEST(ret==KErrNone);

	ret=smallTLV.AppendItemL(pcoIdX,appendablePtrX);

	TEST(ret==KErrNone);

	//	Searching for item while cursor at end of buffer

	ret=smallTLV.AnyNextItemL(pcoIdY,bigEnoughPtr);

	TEST(ret==KErrNone);

	TEST(pcoIdY.Id()==YId);	

	TEST(bigEnoughPtr==appendablePtrY);

	//	Reset cursor

	smallTLV.ResetCursorPos();

	//	Get item into tooSmallbuf

	ret=smallTLV.AnyNextItemL(pcoIdX,tooSmallPtr);

	TEST(ret==KErrNone);

	//	Reset cursor

	smallTLV.ResetCursorPos();

	//	Get 3 items

	ret=smallTLV.AnyNextItemL(pcoIdX,bigEnoughPtr);

	TEST(ret==KErrNone);

	TEST(pcoIdX.Id()==XId);	

	TEST(bigEnoughPtr==appendablePtrX);

	//	second item

	ret=smallTLV.AnyNextItemL(pcoIdY,bigEnoughPtr);

	TEST(ret==KErrNone);

	TEST(pcoIdY.Id()==YId);	

	TEST(bigEnoughPtr==appendablePtrY);

	//	third item

	ret=smallTLV.AnyNextItemL(pcoIdX,bigEnoughPtr);

	TEST(ret==KErrNone);

	TEST(pcoIdX.Id()==XId);	

	TEST(bigEnoughPtr==appendablePtrX);

	//	try get item at end of buffer

	ret=smallTLV.AnyNextItemL(pcoIdY,bigEnoughPtr);

	TEST(ret==KErrNotFound);

	//	---------------------------------------------------

	//	TEST CASE 5 - Random pattern of calls

	//	Buffer contains XYX

	//	---------------------------------------------------

	//	Clear Buffer

	//	reset cursor

	smallTLV.ResetCursorPos();

	//	remove pcoIdX

	ret=smallTLV.RemoveNextItemL(pcoIdX);

	TEST(ret== KErrNone);

	// 	remove pcoIdY

	ret=smallTLV.RemoveNextItemL(pcoIdY);

	TEST(ret== KErrNone);

	//	remove pcoIdX

	ret=smallTLV.RemoveNextItemL(pcoIdX);

	TEST(ret== KErrNone);	

	//  Buffer is Empty

	//	Append Item

	ret=smallTLV.AppendItemL(pcoIdX,appendablePtrX);

	TEST(ret==KErrNone);

	// 	remove pcoIdX after appending pcoIdX

	ret=smallTLV.RemoveNextItemL(pcoIdX);

	TEST(ret==KErrNone);

	//	Append Item

	ret=smallTLV.AppendItemL(pcoIdY,appendablePtrY);

	TEST(ret==KErrNone);

	//	try get any item after adding pcoIdY

	ret=smallTLV.AnyNextItemL(pcoIdY,bigEnoughPtr);

	TEST(ret==KErrNone);

	TEST(pcoIdY.Id()==YId);	

	TEST(bigEnoughPtr==appendablePtrY);

	//	reset cursor

	//	Buffer contains Y

	smallTLV.ResetCursorPos();

	//	get item

	ret=smallTLV.AnyNextItemL(pcoIdY,bigEnoughPtr);

	TEST(ret==KErrNone);

	TEST(pcoIdY.Id()==YId);

	//	Get item pcoIdY

	ret=smallTLV.NextItemL(pcoIdY,bigEnoughPtr);

	TEST(ret==KErrNotFound);

	// 	remove pcoIdX

	ret=smallTLV.RemoveNextItemL(pcoIdX);

	TEST(ret==KErrNotFound);

	//	---------------------------------------------------

	//	Test CASE 6 - TPcoId

	//	---------------------------------------------------

	const TUint16 KFirstPcoId=257;

	const TUint16 KSecondPcoId=0x103;

	const TUint16 KSecondPcoIdFlipped=0x301;

	const TInt KTwoByte=0xFFFE;

	const TInt KTwoByteFlipped=0xFEFF;

	const TInt16 KIDSize=sizeof(TUint16);

	//	Create  PCO_ID's

	RPacketContext::TPcoId firstId(KFirstPcoId);

	//	---------------------------------------------------

	//	-- ExternalizeL

	//	---------------------------------------------------

	//	-- to buffer large enough to hold value

	//	-- Memory to contain ID - 4 bytes

	TInt bigExternalizedBuff(KZero);

	//	Create TPtr to the first byte

	TPtr8 bigExternalizedPtr(reinterpret_cast<TUint8*>(&bigExternalizedBuff),sizeof(TInt),sizeof(TInt));

	firstId.ExternalizeL(bigExternalizedPtr);

	TEST(bigExternalizedBuff==KFirstPcoId);

	//	-- to buffer to small to hold value

	//	-- Memory to contain ID - 1 byte

	TUint8 smallExternalizedBuff(KZero);

	//	Create TPtr to the first byte

	TPtr8 smallExternalizedPtr(static_cast<TUint8*>(&smallExternalizedBuff),sizeof(TUint8),sizeof(TUint8));

	//	Externalize to a pointer with size less than needed.

	TRAP(err,firstId.ExternalizeL(smallExternalizedPtr));

	TEST(err==KErrOverflow);

	//	-- InternalizeL

	//	-- Try internalize a 

	TRAP(err,firstId.InternalizeL(smallExternalizedPtr));

	TEST(err==KErrUnderflow);

	bigExternalizedBuff=KTwoByte;

	firstId.InternalizeL(bigExternalizedPtr);

	TEST(firstId.Id()== KTwoByteFlipped);

	//	-- SerializedLength

	TUint16 size=firstId.SerializedLength();

	TEST(size==KIDSize);

	//	-- SetId	

	RPacketContext::TPcoId secondId(0);

	secondId.SetId(KSecondPcoId);

	TEST(secondId.Id()==KSecondPcoId);

	//	Check with Externalize

	secondId.ExternalizeL(bigExternalizedPtr);

	TEST(bigExternalizedBuff==KSecondPcoIdFlipped);

	//	-- IsEqual

	firstId.SetId(KSecondPcoId);

	secondId.SetId(KSecondPcoId);

	TBool result=firstId.IsEqual(secondId);

	TEST(result);

	secondId.SetId(KFirstPcoId);

	result=firstId.IsEqual(secondId);

	TEST(!result);

	//	---------------------------------------------------

	//	Test CASE 7 - NextItemL and RemoveNextItemL using a 

	//  0 length item

	//	Buffer is empty

	//	---------------------------------------------------

	// Create Buffer A with 0 length

	const TUint16 AId=3;

	RPacketContext::TPcoId pcoIdA(AId);

	TBuf8<KMinimumBufferSize> appendableBufferA;

	appendableBufferA.SetLength(KZero);

	TPtr8 appendablePtrA(const_cast<TUint8*>(appendableBufferA.Ptr()),appendableBufferA.Length(),appendableBufferA.Length());	

	// reset cursor

	smallTLV.ResetCursorPos();

	// Append 0 length item to TLV struct

	ret=smallTLV.AppendItemL(pcoIdA, appendablePtrA);

	TEST(ret==KErrNone);

	// Try to read back 0 length item

	// Will fail with KErrNotFound if unsuccessful

	ret=smallTLV.NextItemL(pcoIdA, bigEnoughPtr);

	TEST(ret==KErrNone);

	TEST(bigEnoughPtr==appendablePtrA);

	//	reset cursor

	smallTLV.ResetCursorPos();

	// Finally remove item with 0 length

	// Will fail with KErrNotFound if unsuccessful

	ret=smallTLV.RemoveNextItemL(pcoIdA);

	TEST(ret==KErrNone);

	return TestStepResult();

}