--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/persistentstorage/store/TSTRM/t_storconv.cpp Fri Jan 22 11:06:30 2010 +0200
@@ -0,0 +1,1285 @@
+// Copyright (c) 1998-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:
+//
+
+#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);
+ test(copy16==des16);
+ }
+
+/**
+@SYMTestCaseID SYSLIB-STORE-CT-1214
+@SYMTestCaseDesc Streaming HBufC test
+@SYMTestPriority High
+@SYMTestActions Tests by cloning and check for the integrity of the cloned object.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ REQ0000
+*/
+LOCAL_C void testHBufCL()
+ {
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-STORE-CT-1214 Streaming HBufC8 "));
+ TBuf8<0x100> des8,copy8;
+ HBufC8* buf8;
+ des8=_L8("test1");
+ buf8=testClone_HBufC8L(des8);
+ test(*buf8==des8);
+ User::Free(buf8);
+ des8.Append(_L8(" add some more text"));
+ buf8=testClone_HBufC8L(des8);
+ test(*buf8==des8);
+ User::Free(buf8);
+ des8.SetMax();
+ des8.Fill('?');
+ buf8=testClone_HBufC8L(des8);
+ test(*buf8==des8);
+ User::Free(buf8);
+ des8.Zero();
+ buf8=testClone_HBufC8L(des8);
+ test(*buf8==des8);
+ User::Free(buf8);
+//
+ test.Next(_L("Streaming HBufC16"));
+ TBuf16<0x100> des16,copy16;
+ HBufC16* buf16;
+ des16=_L16("test1");
+ buf16=testClone_HBufC16L(des16);
+ test(*buf16==des16);
+ User::Free(buf16);
+ des16.Append(_L16(" add some more text"));
+ buf16=testClone_HBufC16L(des16);
+ test(*buf16==des16);
+ User::Free(buf16);
+ des16.SetMax();
+ des16.Fill('?');
+ buf16=testClone_HBufC16L(des16);
+ test(*buf16==des16);
+ User::Free(buf16);
+ des16.Zero();
+ buf16=testClone_HBufC16L(des16);
+ test(*buf16==des16);
+ User::Free(buf16);
+//
+ test.Next(_L("Streaming out TDes8 and streaming in HBufC16"));
+ des8=_L8("test1");
+ buf16=testClone_HBufC16L(des8);
+ copy8.Copy(*buf16);
+ test(copy8==des8);
+ User::Free(buf16);
+ des8.Append(_L8(" add some more text"));
+ buf16=testClone_HBufC16L(des8);
+ copy8.Copy(*buf16);
+ test(copy8==des8);
+ User::Free(buf16);
+ des8.SetMax();
+ des8.Fill('?');
+ buf16=testClone_HBufC16L(des8);
+ copy8.Copy(*buf16);
+ test(copy8==des8);
+ User::Free(buf16);
+ des8.Zero();
+ buf16=testClone_HBufC16L(des8);
+ copy8.Copy(*buf16);
+ test(copy8==des8);
+ User::Free(buf16);
+//
+ test.Next(_L("Streaming out TDes16 and streaming in HBufC8"));
+ des16=_L16("test1");
+ buf8=testClone_HBufC8L(des16);
+ copy16.Copy(*buf8);
+ test(copy16==des16);
+ User::Free(buf8);
+ des16.Append(_L16(" add some more text"));
+ buf8=testClone_HBufC8L(des16);
+ copy16.Copy(*buf8);
+ test(copy16==des16);
+ User::Free(buf8);
+ des16.SetMax();
+ des16.Fill('?');
+ buf8=testClone_HBufC8L(des16);
+ copy16.Copy(*buf8);
+ test(copy16==des16);
+ User::Free(buf8);
+ des16.Zero();
+ buf8=testClone_HBufC8L(des16);
+ copy16.Copy(*buf8);
+ test(copy16==des16);
+ User::Free(buf8);
+//
+ test.Next(_L("Overflowing and over-allocating HBufC8"));
+ des8.SetMax();
+ buf8=testClone_HBufC8L(des8,0x80);
+ test(buf8==NULL);
+ buf8=testClone_HBufC8L(des8,0x200);
+ test(buf8!=NULL);
+ test(User::AllocLen(buf8)==sizeof(TBufC8<0x100>));
+ User::Free(buf8);
+//
+ test.Next(_L("Overflowing and over-allocating HBufC16"));
+ des16.SetMax();
+ buf16=testClone_HBufC16L(des16,0x80);
+ test(buf16==NULL);
+ buf16=testClone_HBufC16L(des16,0x200);
+ test(buf16!=NULL);
+ test(User::AllocLen(buf16)==sizeof(TBufC16<0x100>));
+ User::Free(buf16);
+}
+
+//
+// Compare two buffers.
+//
+TBool operator==(const CBufBase& aBuf,const CBufBase& anotherBuf)
+ {
+ TInt s=aBuf.Size();
+ if (s!=anotherBuf.Size())
+ return EFalse;
+//
+ for (TInt i=0;i<s;)
+ {
+ TPtr8 p1=((CBufBase&)aBuf).Ptr(i);
+ TPtr8 p2=((CBufBase&)anotherBuf).Ptr(i);
+ TInt n=Min(p1.Size(),p2.Size());
+ if (Mem::Compare(p1.Ptr(),n,p2.Ptr(),n)!=0)
+ return EFalse;
+//
+ i+=n;
+ }
+ return ETrue;
+ }
+
+/**
+@SYMTestCaseID SYSLIB-STORE-CT-1215
+@SYMTestCaseDesc Streaming CBufFlat,CBufSeg buffers test
+@SYMTestPriority High
+@SYMTestActions Attempt for copying two buffer objects
+@SYMTestExpectedResults Test must not fail
+@SYMREQ REQ0000
+*/
+LOCAL_C void testBufL()
+ {
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-STORE-CT-1215 Streaming CBufFlat "));
+ const TText8* data=_S8("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ");
+ CBufBase* bufOrg=CBufFlat::NewL(36);
+ CleanupStack::PushL(bufOrg);
+ CBufBase* buf=CBufFlat::NewL(36);
+ CleanupStack::PushL(buf);
+ bufOrg->InsertL(0,data,36);
+ testCopyL(*buf,*bufOrg);
+ test(*buf==*bufOrg);
+ buf->Delete(0,10);
+ testCopyL(*buf,*bufOrg);
+ test(*buf==*bufOrg);
+ buf->Delete(0,10);
+ buf->InsertL(26,data,10);
+ testCopyL(*buf,*bufOrg);
+ test(*buf==*bufOrg);
+ buf->InsertL(0,data+10,26);
+ testCopyL(*buf,*bufOrg);
+ test(*buf==*bufOrg);
+ CleanupStack::PopAndDestroy(2);
+//
+ test.Next(_L("Streaming CBufSeg"));
+ bufOrg=CBufSeg::NewL(7);
+ CleanupStack::PushL(bufOrg);
+ buf=CBufSeg::NewL(11);
+ CleanupStack::PushL(buf);
+ bufOrg->InsertL(0,data,36);
+ testCopyL(*buf,*bufOrg);
+ test(*buf==*bufOrg);
+ buf->Delete(0,10);
+ testCopyL(*buf,*bufOrg);
+ test(*buf==*bufOrg);
+ buf->Delete(0,10);
+ buf->InsertL(26,data,10);
+ testCopyL(*buf,*bufOrg);
+ test(*buf==*bufOrg);
+ testCopyL(*buf,*bufOrg);
+ test(*buf==*bufOrg);
+ CleanupStack::PopAndDestroy(2);
+ }
+
+template <class T>
+TBool operator==(const CArrayFix<T>& anArray,const CArrayFix<T>& anotherArray);
+#if defined(__GCC32__)
+template <class T>
+inline TBool operator==(const CArrayFixFlat<T>& anArray,const CArrayFixFlat<T>& anotherArray)
+ {return (const CArrayFix<T>&)anArray==(const CArrayFix<T>&)anotherArray;}
+#endif
+
+//
+// Compare two arrays.
+//
+template <class T>
+TBool operator==(const CArrayFix<T>& anArray,const CArrayFix<T>& anotherArray)
+ {
+ TInt n=anArray.Count();
+ if (n!=anotherArray.Count())
+ return EFalse;
+//
+ for (TInt i=0;i<n;i++)
+ {
+ if (anArray[i]!=anotherArray[i])
+ return EFalse;
+ }
+ return ETrue;
+ }
+
+/**
+@SYMTestCaseID SYSLIB-STORE-CT-1216
+@SYMTestCaseDesc Streaming fixed arrays test
+@SYMTestPriority High
+@SYMTestActions Tests by copying two fixed array objects.Tests for the integrity of the data.
+@SYMTestExpectedResults Test must not fail
+@SYMREQ REQ0000
+*/
+LOCAL_C void testArrayFixL()
+ {
+//* test.Next(_L("Streaming CArrayFix<TUint32>"));
+//#pragma message ( __FILE__ " : 'testArrayFix()' not entirely implemented")
+//
+ test.Next(_L(" @SYMTestCaseID:SYSLIB-STORE-CT-1216 Streaming CArrayFix<TDes> "));
+ TBuf<16> des[]={_L("aa"),_L("bbbb"),_L("cccccc")};
+ CArrayFixFlat< TBuf<16> >* fixDesOrg=new(ELeave) CArrayFixFlat< TBuf<16> >(KTestGranularity);
+ CleanupStack::PushL(fixDesOrg);
+ CArrayFixFlat< TBuf<16> >* fixDes=new(ELeave) CArrayFixFlat< TBuf<16> >(KTestGranularity);
+ CleanupStack::PushL(fixDes);
+ fixDesOrg->AppendL(des+1,2);
+ testCopyL(*fixDes,*fixDesOrg);
+ test(*fixDes==*fixDesOrg);
+ fixDesOrg->InsertL(0,des[0]);
+ testCopyL(*fixDes,*fixDesOrg);
+ test(*fixDes==*fixDesOrg);
+ CleanupStack::PopAndDestroy(2);
+ }
+
+/**
+@SYMTestCaseID PDS-STORE-CT-4011
+@SYMTestCaseDesc Test for US_SHARE.CPP file. RShareReadStream.
+@SYMTestPriority High
+@SYMTestActions Test for creating and opening, read, write functions in RShareReadStream.
+@SYMTestExpectedResults Creation and opening must not fail.
+ Written data, and read data should be equal.
+@SYMDEF DEF135804
+*/
+LOCAL_C void testFileL()
+ {
+
+ _LIT8(KTestString, "Test String test");
+ test.Next(_L("PDS-STORE-CT-4011 testUS_SHARE_FileL"));
+
+ HBufC8* rwbuf = HBufC8::NewLC(1024*10);
+ HBufC8* buf = HBufC8::NewLC(1024);
+ TPtr8 des = buf->Des();
+ TDesBuf tdb;
+ TPtr8 des2 = rwbuf->Des();
+ tdb.Set( des2 );
+
+ TStreamExchange se(&tdb);
+
+ RShareWriteStream wstream(se);
+ wstream.Open(se);
+ wstream.WriteL(KTestString);
+ wstream.CommitL();
+ wstream.Close();
+
+ RShareReadStream rstream(se);
+ rstream.Open(se);
+ rstream.ReadL(des, buf->Length());
+ rstream.Close();
+
+ test( des.Compare(KTestString) );
+
+ CleanupStack::PopAndDestroy(2, rwbuf);
+
+ }
+
+/**
+@SYMTestCaseID PDS-STORE-CT-4012
+@SYMTestCaseDesc Test for US_SHARE.CPP file. RShareBuf.
+@SYMTestPriority High
+@SYMTestActions Writing, reading and seeking in RShareBuf
+@SYMTestExpectedResults Written data and read data (after seek to the beggining of the bufer)
+ should equal. Read, write and seek operation must not fail.
+@SYMDEF DEF135804
+*/
+class RShareBufTest : public RShareBuf
+ {
+ public:
+ TInt DoReadL(TAny* aPtr,TInt aMaxLength){return RShareBuf::DoReadL(aPtr, aMaxLength);}
+ TInt DoReadL(TDes8& aDes,TInt aMaxLength,TRequestStatus& aStatus){return RShareBuf::DoReadL(aDes, aMaxLength, aStatus);}
+ TStreamTransfer DoReadL(MStreamInput& anInput,TStreamTransfer aTransfer){return RShareBuf::DoReadL(anInput, aTransfer);}
+ void DoWriteL(const TAny* aPtr,TInt aLength){RShareBuf::DoWriteL(aPtr, aLength);}
+ TInt DoWriteL(const TDesC8& aDes,TInt aMaxLength,TRequestStatus& aStatus){return RShareBuf::DoWriteL(aDes,aMaxLength, aStatus);}
+ TStreamTransfer DoWriteL(MStreamOutput& anOutput,TStreamTransfer aTransfer){return RShareBuf::DoWriteL(anOutput, aTransfer);}
+ TStreamPos DoSeekL(TMark aMark,TStreamLocation aLocation,TInt anOffset){return RShareBuf::DoSeekL(aMark,aLocation,anOffset);}
+ };
+
+LOCAL_C void testFileRShareBufL()
+{
+ _LIT8(KTestString, "Test String test very long to have something to seek for");
+ HBufC8* rwbuf = HBufC8::NewLC(1024*10);
+ HBufC8* buf = HBufC8::NewLC(1024);
+ TDesBuf tdb;
+ TPtr8 des2 = rwbuf->Des();
+ tdb.Set( des2 );
+
+ TStreamExchange se(&tdb);
+
+ test.Next(_L("PDS-STORE-CT-4012 RShareBuf tests"));
+ RShareBufTest rsb;
+ rsb.Release();
+ rsb.Open(se, RShareBuf::ERead|RShareBuf::EWrite);
+ rsb.WriteL(KTestString().Ptr(), KTestString().Length());
+ TInt dupa = rsb.SizeL();
+
+ TStreamPos spos = rsb.DoSeekL(RShareBuf::ERead, EStreamBeginning, 20);
+ test(spos.Offset() == 20);
+ spos = rsb.DoSeekL(RShareBuf::ERead, EStreamMark, 5);
+ test(spos.Offset()== 25);
+ spos = rsb.DoSeekL(RShareBuf::EWrite, EStreamEnd, -5);
+ test(spos.Offset()==rsb.SizeL()-5 );
+
+ TUint8* tempBuf = new TUint8[1024];
+ CleanupStack::PushL(tempBuf);
+ test(tempBuf != NULL);
+ for(TInt i=0;i<1024;i++)
+ tempBuf[i]=0;
+
+ spos = rsb.DoSeekL(RShareBuf::ERead, EStreamBeginning, 0);
+ test(spos.Offset() == 0);
+ TInt bytesread = rsb.DoReadL((void*)tempBuf, rsb.SizeL());
+ test(bytesread == rsb.SizeL());
+ buf->Des().Copy(tempBuf);
+ test(buf->Des().Compare(KTestString)==0);
+
+ spos = rsb.DoSeekL(RShareBuf::EWrite, EStreamBeginning, 0);
+ test(spos.Offset() == 0);
+
+ TRequestStatus status;
+ rsb.DoWriteL(KTestString(), KTestString().Length(), status);
+ User::WaitForRequest(status);
+ test(status == KErrNone);
+
+ buf->Des().Zero();
+ TPtr8 pbuf2 = buf->Des();
+
+ spos = rsb.DoSeekL(RShareBuf::ERead, EStreamBeginning, 0);
+ test(spos.Offset() == 0);
+ bytesread = rsb.ReadL(pbuf2, buf->Des().MaxLength(), status);
+ test(bytesread == buf->Des().MaxLength());
+ User::WaitForRequest(status);
+ test(status == KErrNone);
+ test(buf->Des().Compare(KTestString)==0);
+
+ /**
+ * Unable to test those functions:
+ * TStreamTransfer DoWriteL(MStreamOutput& anOutput,TStreamTransfer aTransfer)
+ * TStreamTransfer DoReadL(MStreamInput& anInput,TStreamTransfer aTransfer);
+ * because all MStreamOutput/MStreamInput derived class are not exported
+ * thus it can't be used outside theis DLL
+ */
+
+ rsb.Close();
+ CleanupStack::PopAndDestroy(3, rwbuf);
+}
+
+/**
+@SYMTestCaseID PDS-STORE-CT-4013
+@SYMTestCaseDesc Test for US_HOST.CPP file. TStreamExchange and TStreamMark.
+@SYMTestPriority High
+@SYMTestActions Read and write on TStreamExchange. Reading and writing on TStreamMark.
+@SYMTestExpectedResults Read and write operation should not leave.
+@SYMDEF DEF135804
+*/
+LOCAL_C void testTStreamExchangeAndMarkL()
+{
+ test.Next(_L("PDS-STORE-CT-4013 testTStreamExchangeAndMarkL"));
+ _LIT8(KTestString, "Test String test very long to have something to seek for");
+ HBufC8* rwbuf = HBufC8::NewLC(1024*10);
+ HBufC8* buf = HBufC8::NewLC(1024);
+ TDesBuf tdb;
+ TPtr8 des2 = rwbuf->Des();
+ tdb.Set( des2 );
+ TStreamExchange se(&tdb);
+ RShareBufTest rsb;
+ rsb.Open(se, RShareBuf::ERead|RShareBuf::EWrite);
+ test( se.HostL() == &tdb );
+
+ TStreamMark sm(0);
+ TInt bytesprocessed;
+ sm.WriteL(se, KTestString().Ptr(),KTestString().Length() );
+ TRequestStatus rstatus;
+
+ TStreamMark sm2(0);
+ bytesprocessed = sm2.WriteL(se, KTestString(), KTestString().Length(), rstatus);
+ test (bytesprocessed == KTestString().Length());
+ User::WaitForRequest(rstatus);
+ test(rstatus == KErrNone);
+
+ TStreamMark sm3(0);
+ TPtr8 des = buf->Des();
+ bytesprocessed = sm3.ReadL(se, des, des.MaxLength(), rstatus);
+ RDebug::Printf("Written: %d, Length: %d",bytesprocessed,des.MaxLength());
+ test (bytesprocessed == des.MaxLength());
+ User::WaitForRequest(rstatus);
+ test(rstatus == KErrNone);
+
+ TStreamMark sm4(0);
+ buf->Des().Zero();
+ des.Set(buf->Des());
+ bytesprocessed = sm4.ReadL(se, des, rstatus);
+ RDebug::Printf("Written: %d, Length: %d",bytesprocessed,des.MaxLength());
+ test (bytesprocessed == des.MaxLength());
+ sm4.ExtractL(se);
+ User::WaitForRequest(rstatus);
+ test(rstatus == KErrNone);
+
+ TStreamMark sm5(0);
+ bytesprocessed = sm5.WriteL(se, KTestString(), rstatus);
+ RDebug::Printf("Written: %d, Length: %d",bytesprocessed,KTestString().Length());
+ test (bytesprocessed == KTestString().Length());
+ User::WaitForRequest(rstatus);
+ test(rstatus == KErrNone);
+ sm5.ExtractL(se);
+
+ rsb.Close();
+ CleanupStack::PopAndDestroy(2, rwbuf);
+}
+
+const TInt KMinTestHeapSize = 0x10000;
+const TInt KMaxTestHeapSize = 0x100000;
+
+/**
+ * Helper function for PDS-STORE-CT-4014
+ */
+LOCAL_C void DoTBtreeKeyPanicL(TInt aCase)
+ {
+ //those will panic, and should be tested if they will panic
+ switch(aCase)
+ {
+ case 0:
+ {
+ TBtreeKey key27(0,ECmpTUint);
+ }
+ case 1:
+ {
+ TBtreeKey key23(0,ECmpTInt);
+ }
+ case 2:
+ {
+ TBtreeKey key9(0,ECmpCollated);
+ }
+ case 3:
+ {
+ TBtreeKey key6(0,ECmpFolded);
+ }
+ case 4:
+ {
+ TBtreeKey key3(0,ECmpNormal);
+ }
+ case 5:
+ {
+ TBtreeKey key91(0,ECmpCollated,10);
+ }
+ case 6:
+ {
+ TBtreeKey key61(0,ECmpFolded,10);
+ }
+ case 7:
+ {
+ TBtreeKey key31(0,ECmpNormal,10);
+ }
+ }
+ }
+/**
+ * Helper function for PDS-STORE-CT-4014
+ */
+LOCAL_C TInt DoPanicingThread(TAny* aTestCase)
+ {
+ User::SetJustInTime(EFalse); // disable debugger panic handling
+ TInt tcase = *((TInt*)aTestCase);
+ TRAP_IGNORE(DoTBtreeKeyPanicL(tcase));
+ return 0;
+ }
+
+/**
+@SYMTestCaseID PDS-STORE-CT-4014
+@SYMTestCaseDesc Test for UB_KEY.CPP file. TBtreeKey constructors, comparators, function Between().
+@SYMTestPriority High
+@SYMTestActions Create instance of TBtreeKey using all available constructors with
+ all possible parameters. Run comparation and between functions.
+@SYMTestExpectedResults Objects must be created properly. Comparators must return proper values.
+ MBtreeKey Between function, not fully implemented. See comments inside test.
+@SYMDEF DEF135804
+*/
+LOCAL_C void testMBtreeKeyL()
+{
+ test.Next(_L("PDS-STORE-CT-4014 MBtreeKey Constructors"));
+ TBtreeKey key;
+ TBtreeKey key_1(0);
+ TBtreeKey key2(0, ECmpTInt16);
+ //cmp text
+
+ for(TInt i=0;i<8;i++)
+ {
+ RThread thread;
+ TInt tcase = i;
+ TRequestStatus rst;
+ TFileName name;
+ name.Copy(_L("MyPanic "));
+ name.AppendNum(i);
+ TInt err = thread.Create(name, DoPanicingThread, KDefaultStackSize, KMinTestHeapSize, KMaxTestHeapSize, &tcase, EOwnerThread);
+ test(err == KErrNone);
+ TRequestStatus status;
+ thread.Logon(status);
+ test(status.Int() == KRequestPending);
+ thread.Resume();
+ User::WaitForRequest(status);
+ User::SetJustInTime(ETrue); // enable debugger panic handling
+ test(thread.ExitType() == EExitPanic);
+ test(thread.ExitReason() == EInvalidKeyComparison );
+ RDebug::Printf("Thread %d paniced as design with correct panic code", i);
+ }
+
+ test.Next(_L("MBtreeKey Comparators"));
+ //prepare 8bit descriptor
+ TBuf8<50> textKey1;
+ TBuf8<50> textKey2;
+ textKey1.Copy(_L(" Ala ma kota"));
+ textKey2.Copy(_L(" Ala ma kota"));
+ TUint8* ptr = const_cast<TUint8*>(textKey1.PtrZ());
+ *ptr = textKey1.Length();
+ ptr = const_cast<TUint8*>(textKey2.PtrZ());
+ *ptr = textKey2.Length();
+
+ //prepare 16bit descriptor
+ TBuf16<50> text16Key1;
+ TBuf16<50> text16Key2;
+ text16Key1.Copy(_L(" Ala ma kota"));
+ text16Key2.Copy(_L(" Ala ma kota"));
+ TUint16* ptr16 = const_cast<TUint16*>(text16Key1.PtrZ());
+ *ptr16 = text16Key1.Length();
+ ptr16 = const_cast<TUint16*>(text16Key2.PtrZ());
+ *ptr16 = text16Key2.Length();
+
+
+ TBtreeKey key4(0,ECmpNormal8);
+ test(key4.Compare(textKey1.PtrZ(),textKey2.PtrZ()) == 0);
+ TBtreeKey key4_1(0,ECmpNormal8,13);
+ test(key4_1.Compare(textKey1.PtrZ(),textKey2.PtrZ()) == 0);
+
+ TBtreeKey key5(0,ECmpNormal16);
+ test(key5.Compare(text16Key1.PtrZ(),text16Key2.PtrZ()) == 0);
+ TBtreeKey key5_1(0,ECmpNormal16,13);
+ test(key5_1.Compare(text16Key1.PtrZ(),text16Key2.PtrZ()) == 0);
+
+ TBtreeKey key7(0,ECmpFolded8);
+ test(key7.Compare(textKey1.PtrZ(),textKey2.PtrZ()) == 0);
+ TBtreeKey key7_1(0,ECmpFolded8,13);
+ test(key7_1.Compare(textKey1.PtrZ(),textKey2.PtrZ()) == 0);
+
+ TBtreeKey key8(0,ECmpFolded16);
+ test(key8.Compare(text16Key1.PtrZ(),text16Key2.PtrZ()) == 0);
+ TBtreeKey key8_1(0,ECmpFolded16,13);
+ test(key8_1.Compare(text16Key1.PtrZ(),text16Key2.PtrZ()) == 0);
+
+ TBtreeKey key10(0,ECmpCollated8);
+ test(key10.Compare(textKey1.PtrZ(),textKey2.PtrZ()) == 0);
+ TBtreeKey key10_1(0,ECmpCollated8,13);
+ test(key10_1.Compare(textKey1.PtrZ(),textKey2.PtrZ()) == 0);
+
+ TBtreeKey key11(0,ECmpCollated16);
+ test(key11.Compare(text16Key1.PtrZ(),text16Key2.PtrZ()) == 0);
+ TBtreeKey key11_1(0,ECmpCollated16,13);
+ test(key11_1.Compare(text16Key1.PtrZ(),text16Key2.PtrZ()) == 0);
+
+ //cmp numeric
+ TInt8 int8_1 = 123;
+ TInt8 int8_2 = 123;
+ TInt16 int16_1 = 32000;
+ TInt16 int16_2 = 32000;
+ TInt32 int32_1 = 2147480000;
+ TInt32 int32_2 = 2147480000;
+ TInt64 int64_1 = 9223372036854770000;
+ TInt64 int64_2 = 9223372036854770000;
+
+ TBtreeKey key20(0,ECmpTInt8);
+ test( key20.Compare(&int8_1, &int8_2)==0);
+ TBtreeKey key21(0,ECmpTInt16);
+ test( key21.Compare(&int16_1, &int16_2)==0);
+ TBtreeKey key22(0,ECmpTInt32);
+ test( key22.Compare(&int32_1, &int32_2)==0);
+
+ TBtreeKey key24(0,ECmpTUint8);
+ test( key24.Compare(&int8_1, &int8_2)==0);
+ TBtreeKey key25(0,ECmpTUint16);
+ test( key25.Compare(&int16_1, &int16_2)==0);
+ TBtreeKey key26(0,ECmpTUint32);
+ test( key26.Compare(&int32_1, &int32_2)==0);
+ TBtreeKey key28(0,ECmpTInt64);
+ test( key28.Compare(&int64_1, &int64_2)==0);
+
+ //one is bigger
+ int32_1+=4;
+ int64_1+=54;
+ test( key22.Compare(&int32_1, &int32_2)==1);
+ test( key22.Compare(&int32_2, &int32_1)==-1);
+ test( key26.Compare(&int32_1, &int32_2)==1);
+ test( key26.Compare(&int32_2, &int32_1)==-1);
+ test( key28.Compare(&int64_1, &int64_2)==1);
+ test( key28.Compare(&int64_2, &int64_1)==-1);
+
+ //prepare second 16bit descriptor to be greater than first one
+ text16Key2.Copy(_L(" Ala mb kotb"));
+ ptr16 = const_cast<TUint16*>(text16Key2.PtrZ());
+ *ptr16 = text16Key2.Length();
+
+ //prepare second 8bit descriptor to be greater than first one
+ textKey2.Copy(_L(" Ala mb kotb"));
+ ptr = const_cast<TUint8*>(textKey2.PtrZ());
+ *ptr = textKey2.Length();
+
+ //testing Between function
+ TBtreePivot pivot;
+
+ test.Next(_L("MBtreeKey Between function, not fully implemented. See comments."));
+ /**
+ * For all tests bellow we should made tests if
+ * pivot > textKey1 && pivot < textKey2
+ * but function between is not properly implemented yet
+ * then we don't check result
+ */
+
+ //TBtreeKey key4(0,ECmpNormal8);
+ key4.Between(textKey1.PtrZ(),textKey2.PtrZ(),pivot);
+ //TBtreeKey key4_1(0,ECmpNormal8,13);
+ key4_1.Between(textKey1.PtrZ(),textKey2.PtrZ(),pivot);
+
+ //TBtreeKey key5(0,ECmpNormal16);
+ key5.Between(text16Key1.PtrZ(),text16Key2.PtrZ(),pivot);
+ //TBtreeKey key5_1(0,ECmpNormal16,13);
+ key5_1.Between(text16Key1.PtrZ(),text16Key2.PtrZ(),pivot);
+
+ //TBtreeKey key7(0,ECmpFolded8);
+ key7.Between(textKey1.PtrZ(),textKey2.PtrZ(),pivot);
+ //TBtreeKey key7_1(0,ECmpFolded8,13);
+ key7_1.Between(textKey1.PtrZ(),textKey2.PtrZ(),pivot);
+
+ //TBtreeKey key8(0,ECmpFolded16);
+ key8.Between(text16Key1.PtrZ(),text16Key2.PtrZ(),pivot);
+ //TBtreeKey key8_1(0,ECmpFolded16,13);
+ key8_1.Between(text16Key1.PtrZ(),text16Key2.PtrZ(),pivot);
+
+ //TBtreeKey key10(0,ECmpCollated8);
+ key10.Between(textKey1.PtrZ(),textKey2.PtrZ(),pivot);
+ //TBtreeKey key10_1(0,ECmpCollated8,13);
+ key10_1.Between(textKey1.PtrZ(),textKey2.PtrZ(),pivot);
+
+ //TBtreeKey key11(0,ECmpCollated16);
+ key11.Between(text16Key1.PtrZ(),text16Key2.PtrZ(),pivot);
+ //TBtreeKey key11_1(0,ECmpCollated16,13);
+ key11_1.Between(text16Key1.PtrZ(),text16Key2.PtrZ(),pivot);
+
+ //TBtreeKey key20(0,ECmpTInt8);
+ key20.Between(&int8_1, &int8_2,pivot);
+ //TBtreeKey key21(0,ECmpTInt16);
+ key21.Between(&int16_1, &int16_2,pivot);
+ //TBtreeKey key22(0,ECmpTInt32);
+ key22.Between(&int32_1, &int32_2,pivot);
+
+ //TBtreeKey key24(0,ECmpTUint8);
+ key24.Between(&int8_1, &int8_2,pivot);
+ //TBtreeKey key25(0,ECmpTUint16);
+ key25.Between(&int16_1, &int16_2,pivot);
+ //TBtreeKey key26(0,ECmpTUint32);
+ key26.Between(&int32_1, &int32_2,pivot);
+ //TBtreeKey key28(0,ECmpTInt64);
+ key28.Between(&int64_1, &int64_2,pivot);
+
+}
+
+//
+// Initialise the cleanup stack.
+//
+LOCAL_C void setupCleanup()
+ {
+ TheTrapCleanup=CTrapCleanup::New();
+ test(TheTrapCleanup!=NULL);
+ TRAPD(r,\
+ {\
+ for (TInt i=KTestCleanupStack;i>0;i--)\
+ CleanupStack::PushL((TAny*)1);\
+ test(r==KErrNone);\
+ CleanupStack::Pop(KTestCleanupStack);\
+ });
+ test(r==KErrNone);
+ }
+
+//
+// Test streaming conversions.
+//
+GLDEF_C TInt E32Main()
+ {
+ test.Title();
+ setupCleanup();
+ __UHEAP_MARK;
+//
+ test.Start(_L("Test streaming conversions"));
+ TRAPD(r,testIntL());
+ test(r==KErrNone);
+ TRAP(r,testUintL());
+ test(r==KErrNone);
+ TRAP(r,testRealL());
+ test(r==KErrNone);
+ TRAP(r,testDesL());
+ test(r==KErrNone);
+ TRAP(r,testHBufCL());
+ test(r==KErrNone);
+ TRAP(r,testBufL());
+ test(r==KErrNone);
+ TRAP(r,testArrayFixL());
+ test(r==KErrNone);
+ TRAP(r,testPointL());
+ test(r==KErrNone);
+ TRAP(r,testSizeL());
+ test(r==KErrNone);
+ TRAP(r,testRectL());
+ test(r==KErrNone);
+ //
+ TRAP(r,testFileL());
+ test(r==KErrNone);
+ TRAP(r,testFileRShareBufL());
+ test(r==KErrNone);
+ TRAP(r,testTStreamExchangeAndMarkL());
+ test(r==KErrNone);
+ TRAP(r,testMBtreeKeyL());
+ test(r==KErrNone);
+ test.End();
+//
+ __UHEAP_MARKEND;
+ delete TheTrapCleanup;
+ test.Close();
+ return 0;
+ }
+