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

// 

#include <s32mem.h>

#include <e32test.h>

#include <s32btree.h>

#include "UB_STD.H"

const TInt KTestCleanupStack=0x20;

const TInt KTestExpandSize=0x20;

const TInt KTestGranularity=0x02;

const TUint8 KMidTUint8=KMaxTUint8/2;

const TUint16 KMidTUint16=KMaxTUint16/2;

const TUint32 KMidTUint32=KMaxTUint32/2;

LOCAL_D CTrapCleanup* TheTrapCleanup;

LOCAL_D RTest test(_L("t_storconv"));

template <class T1,class T2>

void testCopyL(T1& aCopy,const T2& anOriginal)

	{

	CBufSeg* buf=0;

	TRAPD(r,buf=CBufSeg::NewL(KTestExpandSize));

	if (r!=KErrNone)

		test.Panic(_L("Allocating buffer"));

//

// Write anOriginal out to the buffer.

//

	RBufWriteStream out;

	out.Append(*buf);

	TRAP(r,out<<anOriginal);

	test(r==KErrNone);

	TRAP(r,out.CommitL());

	if (r!=KErrNone)

		test.Panic(_L("Committing write stream"));

//

// Read anOriginal in from the buffer.

//

	RBufReadStream in(*buf);

	TRAP(r,in>>aCopy);

	test(r==KErrNone);

//

// See if it's consumed the lot.

//

	TUint8 b;

	test(in.Source()->ReadL(&b,1)==0);

//

	delete buf;

	}

//

// Clone aDes using memory-based streams.

//

template <class T>

HBufC8* testClone_HBufC8L(const T& aDes,TInt aMaxLength)

	{

	CBufSeg* buf=0;

	TRAPD(r,buf=CBufSeg::NewL(KTestExpandSize));

	if (r!=KErrNone)

		test.Panic(_L("Allocating buffer"));

//

// Write anOriginal out to the buffer.

//

	RBufWriteStream out;

	out.Append(*buf);

	TRAP(r,out<<aDes);

	test(r==KErrNone);

	TRAP(r,out.CommitL());

	if (r!=KErrNone)

		test.Panic(_L("Committing write stream"));

//

// Read anOriginal in from the buffer.

//

	RBufReadStream in(*buf);

	HBufC8* clone=NULL;

	TRAP(r,clone=HBufC8::NewL(in,aMaxLength));

	if (aMaxLength<aDes.Length())

		test(r==KErrOverflow);

	else

		{

		test(r==KErrNone);

		test(clone!=NULL);

//

// See if it's consumed the lot.

//

		TUint8 b;

		test(in.Source()->ReadL(&b,1)==0);

		}

//

	delete buf;

	return clone;

	}

//

// Clone aDes using memory-based streams.

//

template <class T>

HBufC16* testClone_HBufC16L(const T& aDes,TInt aMaxLength)

	{

	CBufSeg* buf=0;

	TRAPD(r,buf=CBufSeg::NewL(KTestExpandSize));

	if (r!=KErrNone)

		test.Panic(_L("Allocating buffer"));

//

// Write anOriginal out to the buffer.

//

	RBufWriteStream out;

	out.Append(*buf);

	TRAP(r,out<<aDes);

	test(r==KErrNone);

	TRAP(r,out.CommitL());

	if (r!=KErrNone)

		test.Panic(_L("Committing write stream"));

//

// Read anOriginal in from the buffer.

//

	RBufReadStream in(*buf);

	HBufC16* clone=NULL;

	TRAP(r,clone=HBufC16::NewL(in,aMaxLength));

	if (aMaxLength<aDes.Length())

		test(r==KErrOverflow);

	else

		{

		test(r==KErrNone);

		test(clone!=NULL);

//

// See if it's consumed the lot.

//

		TUint8 b;

		test(in.Source()->ReadL(&b,1)==0);

		}

//

	delete buf;

	return clone;

	}

//

// Clone aDes exactly using memory-based streams.

//

template <class T>

HBufC8* testClone_HBufC8L(const T& aDes)

	{

	return testClone_HBufC8L(aDes,aDes.Length());

	}

//

// Clone aDes exactly using memory-based streams.

//

template <class T>

HBufC16* testClone_HBufC16L(const T& aDes)

	{

	return testClone_HBufC16L(aDes,aDes.Length());

	}

/**

@SYMTestCaseID          SYSLIB-STORE-CT-1207

@SYMTestCaseDesc	    Streaming signed integers test

@SYMTestPriority 	    High

@SYMTestActions  	    Tests for streaming 8,16,32,64 bit signed integers.

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void testIntL()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-STORE-CT-1207 Streaming TInt8 "));

	TInt8 int8=0;

	testCopyL(int8,TInt8(KMinTInt8));

	test(int8==KMinTInt8);

	testCopyL(int8,TInt8(KMinTInt8+1));

	test(int8==KMinTInt8+1);

	testCopyL(int8,TInt8(-2));

	test(int8==-2);

	testCopyL(int8,TInt8(-1));

	test(int8==-1);

	testCopyL(int8,TInt8(0));

	test(int8==0);

	testCopyL(int8,TInt8(1));

	test(int8==1);

	testCopyL(int8,TInt8(2));

	test(int8==2);

	testCopyL(int8,TInt8(KMaxTInt8-1));

	test(int8==KMaxTInt8-1);

	testCopyL(int8,TInt8(KMaxTInt8));

	test(int8==KMaxTInt8);

//

	test.Next(_L("Streaming TInt16"));

	TInt16 int16=0;

	testCopyL(int16,TInt16(KMinTInt16));

	test(int16==KMinTInt16);

	testCopyL(int16,TInt16(KMinTInt16+1));

	test(int16==KMinTInt16+1);

	testCopyL(int16,TInt16(-2));

	test(int16==-2);

	testCopyL(int16,TInt16(-1));

	test(int16==-1);

	testCopyL(int16,TInt16(0));

	test(int16==0);

	testCopyL(int16,TInt16(1));

	test(int16==1);

	testCopyL(int16,TInt16(2));

	test(int16==2);

	testCopyL(int16,TInt16(KMaxTInt16-1));

	test(int16==KMaxTInt16-1);

	testCopyL(int16,TInt16(KMaxTInt16));

	test(int16==KMaxTInt16);

//

	test.Next(_L("Streaming TInt32"));

	TInt32 int32=0;

	testCopyL(int32,TInt32(KMinTInt32));

	test(int32==KMinTInt32);

	testCopyL(int32,TInt32(KMinTInt32+1));

	test(int32==KMinTInt32+1);

	testCopyL(int32,TInt32(-2));

	test(int32==-2);

	testCopyL(int32,TInt32(-1));

	test(int32==-1);

	testCopyL(int32,TInt32(0));

	test(int32==0);

	testCopyL(int32,TInt32(1));

	test(int32==1);

	testCopyL(int32,TInt32(2));

	test(int32==2);

	testCopyL(int32,TInt32(KMaxTInt32-1));

	test(int32==KMaxTInt32-1);

	testCopyL(int32,TInt32(KMaxTInt32));

	test(int32==KMaxTInt32);

//

	test.Next(_L("Streaming TInt64"));

	TInt64 int64=0;

	testCopyL(int64,KMinTInt64);

	test(int64==KMinTInt64);

	testCopyL(int64,KMinTInt64+1);

	test(int64==KMinTInt64+1);

	testCopyL(int64,TInt64(-2));

	test(int64==-2);

	testCopyL(int64,TInt64(-1));

	test(int64==-1);

	testCopyL(int64,TInt64(0));

	test(int64==0);

	testCopyL(int64,TInt64(1));

	test(int64==1);

	testCopyL(int64,TInt64(2));

	test(int64==2);

	testCopyL(int64,KMaxTInt64-1);

	test(int64==KMaxTInt64-1);

	testCopyL(int64,KMaxTInt64);

	test(int64==KMaxTInt64);

	}

/**

@SYMTestCaseID          SYSLIB-STORE-CT-1208

@SYMTestCaseDesc	    Streaming unsigned integers test

@SYMTestPriority 	    High

@SYMTestActions  	    Tests for streaming 8,16,32 bit unsigned integers.

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void testUintL()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-STORE-CT-1208 Streaming TUint8 "));

   	TUint8 uint8=KMidTUint8;

	testCopyL(uint8,TUint8(0));

	test(uint8==0);

	testCopyL(uint8,TUint8(1));

	test(uint8==1);

	testCopyL(uint8,TUint8(KMidTUint8-2));

	test(uint8==KMidTUint8-2);

	testCopyL(uint8,TUint8(KMidTUint8-1));

	test(uint8==KMidTUint8-1);

	testCopyL(uint8,TUint8(KMidTUint8));

	test(uint8==KMidTUint8);

	testCopyL(uint8,TUint8(KMidTUint8+1));

	test(uint8==KMidTUint8+1);

	testCopyL(uint8,TUint8(KMidTUint8+2));

	test(uint8==KMidTUint8+2);

	testCopyL(uint8,TUint8(KMaxTUint8-1));

	test(uint8==KMaxTUint8-1);

	testCopyL(uint8,TUint8(KMaxTUint8));

	test(uint8==KMaxTUint8);

//

	test.Next(_L("Streaming TUint16"));

   	TUint16 uint16=KMidTUint16;

	testCopyL(uint16,TUint16(0));

	test(uint16==0);

	testCopyL(uint16,TUint16(1));

	test(uint16==1);

	testCopyL(uint16,TUint16(KMidTUint16-2));

	test(uint16==KMidTUint16-2);

	testCopyL(uint16,TUint16(KMidTUint16-1));

	test(uint16==KMidTUint16-1);

	testCopyL(uint16,TUint16(KMidTUint16));

	test(uint16==KMidTUint16);

	testCopyL(uint16,TUint16(KMidTUint16+1));

	test(uint16==KMidTUint16+1);

	testCopyL(uint16,TUint16(KMidTUint16+2));

	test(uint16==KMidTUint16+2);

	testCopyL(uint16,TUint16(KMaxTUint16-1));

	test(uint16==KMaxTUint16-1);

	testCopyL(uint16,TUint16(KMaxTUint16));

	test(uint16==KMaxTUint16);

//

	test.Next(_L("Streaming TUint32"));

   	TUint32 uint32=KMidTUint32;

	testCopyL(uint32,TUint32(0));

	test(uint32==0);

	testCopyL(uint32,TUint32(1));

	test(uint32==1);

	testCopyL(uint32,TUint32(KMidTUint32-2));

	test(uint32==KMidTUint32-2);

	testCopyL(uint32,TUint32(KMidTUint32-1));

	test(uint32==KMidTUint32-1);

	testCopyL(uint32,TUint32(KMidTUint32));

	test(uint32==KMidTUint32);

	testCopyL(uint32,TUint32(KMidTUint32+1));

	test(uint32==KMidTUint32+1);

	testCopyL(uint32,TUint32(KMidTUint32+2));

	test(uint32==KMidTUint32+2);

	testCopyL(uint32,TUint32(KMaxTUint32-1));

	test(uint32==KMaxTUint32-1);

	testCopyL(uint32,TUint32(KMaxTUint32));

	test(uint32==KMaxTUint32);

	}

/**

@SYMTestCaseID          SYSLIB-STORE-CT-1209

@SYMTestCaseDesc	    Streaming Real numbers test

@SYMTestPriority 	    High

@SYMTestActions  	    Tests for streaming TReal32,TReal64 bit unsigned integers.

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void testRealL()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-STORE-CT-1209 Streaming TReal32 "));

	TReal32 real32=TReal32(0);

	testCopyL(real32,TReal32(-31416.3));

	test(real32==TReal32(-31416.3));

	testCopyL(real32,TReal32(-0.0001));

	test(real32==TReal32(-0.0001));

	testCopyL(real32,TReal32(0));

	test(real32==TReal32(0));

	testCopyL(real32,TReal32(0.0001));

	test(real32==TReal32(0.0001));

	testCopyL(real32,TReal32(31416.3));

	test(real32==TReal32(31416.3));

//

	test.Next(_L("Streaming TReal64"));

	TReal64 real64=TReal64(0);

	testCopyL(real64,TReal64(-31416.3));

	test(real64==TReal64(-31416.3));

	testCopyL(real64,TReal64(-0.0001));

	test(real64==TReal64(-0.0001));

	testCopyL(real64,TReal64(0));

	test(real64==TReal64(0));

	testCopyL(real64,TReal64(0.0001));

	test(real64==TReal64(0.0001));

	testCopyL(real64,TReal64(31416.3));

	test(real64==TReal64(31416.3));

	}

/**

@SYMTestCaseID          SYSLIB-STORE-CT-1210

@SYMTestCaseDesc	    Streaming TPoint test

@SYMTestPriority 	    High

@SYMTestActions  	    Tests for copying two TPoint objects and test for integrity of copied object

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void testPointL()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-STORE-CT-1210 Streaming TPoint "));

	TPoint point=TPoint(0,0);

	testCopyL(point,TPoint(13,65));

	test(point==TPoint(13,65));

	testCopyL(point,TPoint(1,-1));

	test(point==TPoint(1,-1));

	testCopyL(point,TPoint(0,0));

	test(point==TPoint(0,0));

	testCopyL(point,TPoint(7,-666));

	test(point==TPoint(7,-666));

	testCopyL(point,TPoint(-13,-13));

	test(point==TPoint(-13,-13));

	testCopyL(point,TPoint(KMinTInt,KMaxTInt));

	test(point==TPoint(KMinTInt,KMaxTInt));

	}

/**

@SYMTestCaseID          SYSLIB-STORE-CT-1211

@SYMTestCaseDesc	    Streaming TSize objects test

@SYMTestPriority 	    High

@SYMTestActions  	    Tests for copying two TSize objects and test for integrity of copied object

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void testSizeL()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-STORE-CT-1211 Streaming TSize "));

	TSize point=TSize(0,0);

	testCopyL(point,TSize(13,65));

	test(point==TSize(13,65));

	testCopyL(point,TSize(1,-1));

	test(point==TSize(1,-1));

	testCopyL(point,TSize(0,0));

	test(point==TSize(0,0));

	testCopyL(point,TSize(7,-666));

	test(point==TSize(7,-666));

	testCopyL(point,TSize(-13,-13));

	test(point==TSize(-13,-13));

	testCopyL(point,TSize(KMinTInt,KMaxTInt));

	test(point==TSize(KMinTInt,KMaxTInt));

	}

/**

@SYMTestCaseID          SYSLIB-STORE-CT-1212

@SYMTestCaseDesc	    Streaming TRect objects test

@SYMTestPriority 	    High

@SYMTestActions  	    Tests for copying two TRect objects and test for integrity of copied object

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void testRectL()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-STORE-CT-1212 Streaming TRect"));

	TRect point=TRect(0,0,0,0);

	testCopyL(point,TRect(13,65,84,72));

	test(point==TRect(13,65,84,72));

	testCopyL(point,TRect(-13,-65,84,72));

	test(point==TRect(-13,-65,84,72));

	testCopyL(point,TRect(0,0,0,0));

	test(point==TRect(0,0,0,0));

	testCopyL(point,TRect(-1,1,1,-1));

	test(point==TRect(-1,1,1,-1));

	testCopyL(point,TRect(KMinTInt,KMinTInt,KMaxTInt,KMaxTInt));

	test(point==TRect(KMinTInt,KMinTInt,KMaxTInt,KMaxTInt));

	}

/**

@SYMTestCaseID          SYSLIB-STORE-CT-1213

@SYMTestCaseDesc	    Streaming descriptors tests

@SYMTestPriority 	    High

@SYMTestActions  	    Tests for copying TDes8,TDes16 descriptors

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void testDesL()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-STORE-CT-1213 Streaming TDes8 "));

  	TBuf8<0x100> des8,copy8;

	des8=_L8("test1");

	testCopyL(copy8,des8);

	test(copy8==des8);

	des8.Append(_L8(" add some more text"));

	testCopyL(copy8,des8);

	test(copy8==des8);

	des8.SetMax();

	des8.Fill('?');

	testCopyL(copy8,des8);

	test(copy8==des8);

	des8.Zero();

	testCopyL(copy8,des8);

	test(copy8==des8);

//

 	test.Next(_L("Streaming TDes16"));

  	TBuf16<0x100> des16,copy16;

	des16=_L16("test1");

	testCopyL(copy16,des16);

	test(copy16==des16);

	des16.Append(_L16(" add some more text"));

	testCopyL(copy16,des16);

	test(copy16==des16);

	des16.SetMax();

	des16.Fill('?');

	testCopyL(copy16,des16);

	test(copy16==des16);

	des16.Zero();

	testCopyL(copy16,des16);

	test(copy16==des16);

//

	test.Next(_L("Streaming out TDes8 and streaming in TDes16"));

	des8=_L8("test1");

	testCopyL(copy16,des8);

	copy8.Copy(copy16);

	test(copy8==des8);

	des8.Append(_L8(" add some more text"));

	testCopyL(copy16,des8);

	copy8.Copy(copy16);

	test(copy8==des8);

	des8.SetMax();

	des8.Fill('?');

	testCopyL(copy16,des8);

	copy8.Copy(copy16);

	test(copy8==des8);

	des8.Zero();

	testCopyL(copy16,des8);

	copy8.Copy(copy16);

	test(copy8==des8);

//

	test.Next(_L("Streaming out TDes16 and streaming in TDes8"));

	des16=_L16("test1");

	testCopyL(copy8,des16);

	copy16.Copy(copy8);

	test(copy16==des16);

	des16.Append(_L16(" add some more text"));

	testCopyL(copy8,des16);

	copy16.Copy(copy8);

	test(copy16==des16);

	des16.SetMax();

	des16.Fill('?');

	testCopyL(copy8,des16);

	copy16.Copy(copy8);

	test(copy16==des16);

	des16.Zero();

	testCopyL(copy8,des16);

	copy16.Copy(copy8);