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

 // Overview:

 // Test methods of the LString16, LString8, LString template class.

 // The test cases below are template based allowing the same code to 

 // be used for testing both LString16 and LString8 classes.

 // Appropriate LString and buffer types are passed as the template

 // parameters in the call to each test case.

 // API Information:

 // LString16, LString8, LString.

 // Details:

 // For LString8, LString16 and LString objects:

 // - Test the Create and CreateMax methods by verifying the return value of

 // KErrNone, the initial length and max length. Perform basic write and read

 // operations and verify the results.

 // - Test the CreateL and CreateMaxL methods by verifying the return value of 

 // KErrNone. Also force a heap error and verify return value of KErrNoMemory.

 // - Test the Create(const TDesC_& aDesc) and Create(const TDesCX_ aDesc, 

 // TInt aMaxLength) methods by verifying the return value of KErrNone. Verify

 // initial length, max length and initialisation.

 // - Test the CreateL(const TDesC_& aDesc) and CreateMaxL(const TDesCX_ aDesc, 

 // TInt aMaxLength) methods by verifying the return value of KErrNone. Also 

 // force a heap error and verify return value of KErrNoMemory.

 // - Test the Swap method by creating two initialised objects, calling Swap 

 // and confirming the results as expected.

 // - Test the Assign method by performing an assign from a variety of sources

 // and verifying the results are as expected.

 // - Test the ReAlloc method in a variety of scenarios that decrease memory, 

 // increase memory and zero-length memory. Verify that the results are as

 // expected.

 // - Test the ReAllocL by verifying the return value of KErrNone. Also force 

 // a heap error and verify return value of KErrNoMemory. Verify that the

 // object is the same as before the failed ReAllocL call.

 // - Test the CleanupClosePushL method via CleanupStack::PopAndDestroy().

 // - Force the CleanupClosePushL to leave to check cleanup of LString.

 // Platforms/Drives/Compatibility:

 // All 

 // Assumptions/Requirement/Pre-requisites:

 // Failures and causes:

 // Base Port information:

 // 

 //

 #include <e32base.h>

 #include <e32math.h>

 #include <e32test.h>

 #include <euserhl.h>

 #include <u32std.h>

 #include <f32file.h>

 #include <s32mem.h>

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

 /* This macro generates a TTEXT* from the string passed in.  

  * The TTEXT type is a template parameter defined for the calling function

  * and an appropriate 8 or 16 bit string variant is created by this macro

  */

 #undef _TS

 #define _TS(a) ((const TTEXT*)RTest::String(sizeof(TTEXT),(TText8*)a,(TText16*)L ## a))

 /* This macro generates a CHAR* from the string passed in.  

  * The CHAR type is a template parameter defined for the calling function

  * and an appropriate 8(char)or 16(wchar_t) bit string variant is created by this macro

  */

 #undef _CS

 #define _CS(a) ((const CHAR*)RTest::String(sizeof(TTEXT),(TText8*)a,(TText16*)L ## a))

 /**

 @SYMTestCaseID SYSLIB-EUSERHL-UT-4001

 @SYMTestCaseDesc Tests constructors of LString classes

 @SYMTestPriority High

 @SYMTestActions Creates LString objects using the different 

 				constructors. 

 @SYMTestExpectedResults All constructors create object object as expected

 @SYMREQ	10372

 */

 template<class LSTRING, class TBUF, class TTEXT, class HBUF, class CHAR >

 LOCAL_C void TestConstructors(LSTRING*)

 {

 	test.Next (_L ("@SYMTestCaseID:SYSLIB-EUSERHL-UT-4001"));

 	test.Next(_L("LString_(const TDesC& aDes) constructor"));

 	const TBUF des (_TS("123456"));

 	const LSTRING lStr(des);

 	test(lStr.Length() == 6);

 	test(lStr.MaxLength() >= 6);

 	test.Next(_L("LString_(const LString16& aDes) constructor"));

 	LSTRING lStr1(lStr);

 	test(lStr1.Length() == 6);

 	test(lStr1.MaxLength() >= 6);

 	test.Next(_L("LString_(const TUInt16* aString) constructor"));

 	LSTRING lStr2(lStr1.PtrZL());

 	test(lStr2.Length() == 6);

 	test(lStr2.MaxLength() >= 6);

 	test.Next(_L("LString_(HBufC_* aHBuf) constructor"));

 	HBUF* hBuf = HBUF::NewMax(12);	//Create LString as EBufCPtr

 	LSTRING lStr3(hBuf);

 	test(lStr3.Length() == 12);

 	test(lStr3.MaxLength() >= 12);

 	hBuf = HBUF::NewMax(0);

 	LSTRING lStr4(hBuf);			//The length of aHBuf is zero

 	test(lStr4.Length() == 0);

 	hBuf = NULL;				//aHBuf is NULL

 	LSTRING lStr5((HBUF*)hBuf);

 	test(lStr5.Length() == 0);

 	test(lStr5.MaxLength() == 0);

 	test.Next(_L("LString_(TUInt16* aHeapCell, TInt aLength, TInt aMaxLength) constructor"));

 	TTEXT* heap = NULL;

 	heap = (TTEXT*)User::Alloc(24*(TInt)sizeof(TTEXT)); //Allocate 48 bytes for 24 long LString16

 	LSTRING lStr6(heap, 12,24);

 	test(lStr6.Length() == 12);		

 	test(lStr6.MaxLength() >= 24);		

 	test.Next(_L("LString_(TUint* aHeapCell, TInt aMaxLength ) method"));

 	heap = (TTEXT*)User::Alloc(24*(TInt)sizeof(TTEXT)); //Allocate 48 bytes for 24 long LString16

 	LSTRING lStr7(heap, 24);

 	test(lStr7.Length() == 0);		

 	test(lStr7.MaxLength() >= 24);		

 	test.Next(_L("LString_(char/wchar_t * aCharStr) constructor"));

 	LSTRING lStr8(_CS("0123456789"));

 	test(lStr8.Length() == 10);		

 	test(lStr8.MaxLength() >= 10);

 	LSTRING lStr9(_CS("01234567890"));

 	test(lStr9.Length() == 11);		

 	test(lStr9.MaxLength() >= 11);

 }

 /**

 Tests the following methods:

  - TInt Assign(const LString_& lStr);

  - TInt Assign(TUint* aHeapCell, TInt aMaxLength);

  - TInt Assign(TUint* aHeapCell, TInt aLength, TInt aMaxLength);

  - TInt Assign(HBufC& aHBuf);

  - LString(HBufC_&) constructor.

 */

 /**

 @SYMTestCaseID SYSLIB-EUSERHL-UT-4002

 @SYMTestCaseDesc Tests Assign methods of LString

 @SYMTestPriority High

 @SYMTestActions Creates LString objects and assigns data to the LString using 

 				the LString::Assign overloads.

 				Checks that the data is assigned as expected.

 				Creates LString objects from HBufC* and verifies that object

 				is created as expected

 @SYMTestExpectedResults LString objects are created and assigned as expected

 @SYMREQ	10372

 */

 template<class LSTRING, class TBUF, class TTEXT, class HBUF, class RBUF>	

 LOCAL_C void TestAssign(LSTRING*)

 {

 	test.Next (_L ("@SYMTestCaseID:SYSLIB-EUSERHL-UT-4002"));

 	TBUF des (_TS("123456"));

 	LSTRING lStr2(des);

 	TTEXT* heap = NULL;

 	RBUF buf;

 	test.Next(_L("Assign(const LString_& aLString) method"));

 	LSTRING lStr;

 	lStr.Assign(lStr2);

 	// the assignment clears lStr2 so the two strings should be unequal

 	test(lStr != lStr2);

 	test.Next(_L("Assign(TUint* aHeapCell, TInt aLength, TInt aMaxLength ) method"));

 	heap = (TTEXT*)User::Alloc(24*(TInt)sizeof(TTEXT)); //Allocate 48 bytes for 24 long LString16

 	lStr.Assign(heap, 12,24);

 	test(lStr.Length() == 12);		

 	test(lStr.MaxLength() >= 24);		

 	heap = NULL;

 	lStr.Assign(heap, 0,0);

 	test(lStr.Length() == 0);		

 	test(lStr.MaxLength() == 0);		

 	test.Next(_L("Assign(TUint* aHeapCell, TInt aMaxLength ) method"));

 	heap = (TTEXT*)User::Alloc(24*(TInt)sizeof(TTEXT)); //Allocate 48 bytes for 24 long LString16

 	lStr.Assign(heap, 24);

 	test(lStr.Length() == 0);		

 	test(lStr.MaxLength() >= 24);		

 	test.Next(_L("Assign(HBufC_* aHBuf) method"));

 	HBUF* hBuf = HBUF::NewMax(11);

 	lStr.Assign(hBuf);			//Create LString as EBufCPtr type

 	test(lStr.Length() == 11);

 	test(lStr.MaxLength() >= 11); //There could me more allocated memory - see HBufC8::Des()

 	HBUF* hBuf2 = HBUF::NewMax(5);

 	lStr = hBuf2;			//Create LString as EBufCPtr type

 	test(lStr.Length() == 5);

 	test(lStr.MaxLength() >= 5); //There could me more allocated memory - see HBufC8::Des()

 	test.Next(_L("Assign(const RBuf_& aRBuf) method"));

 	buf.Create(des);

 	lStr.Assign(buf);

 	// the assignment trasnfers buf so the two strings should be equal

 	test(lStr == des);

 	test(lStr != buf);

 }

 /**

 @SYMTestCaseID SYSLIB-EUSERHL-UT-4003

 @SYMTestCaseDesc Tests AppendL methods of LString

 @SYMTestPriority High

 @SYMTestActions Creates LString objects and uses AppendL methods to append 

 				data to the LString.

 				Checks that the data is appended as expected.

 @SYMTestExpectedResults LString objects are created and data appended as 

 				expected with the strings grouwing as necessary to accomodate 

 				the new data.

 @SYMREQ	10372

 */

 template<class LSTRING, class TBUF, class TTEXT, class CHAR>

 LOCAL_C void TestAppendL(LSTRING*)

 {

 	test.Next (_L ("@SYMTestCaseID:SYSLIB-EUSERHL-UT-4003"));

 	LSTRING lStr;

 	LSTRING lStr2;

 	TBUF des(_TS("123456"));

 	TBUF des2(_TS("123456A"));

 	test.Next(_L("AppendL(const TDesc_& aDes) method"));

 	lStr.AppendL(des);

 	test(lStr == des);

 	test.Next(_L("AppendL(const TUint16* aBuf, TInt aLength) method"));

 	lStr2 = des;

 	lStr.Reset();

 	lStr.AppendL(lStr2.PtrZL(),lStr2.Length());

 	test(lStr == des);

 	test.Next(_L("AppendL(TChar aChar) method"));

 	TChar c = 'A';

 	lStr = des;

 	lStr.AppendL(c);

 	test(lStr == des2);

 	test.Next(_L("ZeroTerminateL() method"));

 	lStr = des;

 	lStr.ZeroTerminateL();

 	test(lStr == des);

 	test.Next(_L("AppendL(char/wchar_t* aCharStr) method"));

 	LSTRING lStr3(_CS("0123456789"));

 	test(lStr3.Length() == 10);		

 	test(lStr3.MaxLength() >= 10);

 	LSTRING lStr4(_CS("01234567890"));

 	test(lStr4.Length() == 11);		

 	test(lStr4.MaxLength() >= 11);

 	lStr3.AppendL(_CS("0"),1);

 	test(lStr3 == lStr4);

 	lStr4.AppendL(_CS("0123456789"),10);

 	test(lStr4.Length() == 21);		

 	test(lStr4.MaxLength() >= 21);

 	test.Next(_L("operator + (char/wchar_t* aCharStr) method"));

 	LSTRING lStr5(_CS("0123456789"));

 	test(lStr5.Length() == 10);		

 	test(lStr5.MaxLength() >= 10);

 	LSTRING lStr6(_CS("01234567890"));

 	test(lStr6.Length() == 11);		

 	test(lStr6.MaxLength() >= 11);

 	lStr5+=_CS("0");

 	test(lStr5 == lStr6);

 	lStr6 +=_CS("0123456789");

 	test(lStr6.Length() == 21);		

 	test(lStr6.MaxLength() >= 21);

 }

 /**

 Tests the following methods. 

  - TInt ReAlloc(TInt aMaxLength);

 */

 /**

 @SYMTestCaseID SYSLIB-EUSERHL-UT-4004 

 @SYMTestCaseDesc Tests ReAlloc methods of LString

 @SYMTestPriority High

 @SYMTestActions Creates LString objects and uses ReAlloc to decrease,

 				increase and zero memory. Validates that length and 

 				maxlength are changed as expected 

 @SYMTestExpectedResults ReAlloc should change the length and maxLength 

 				of the LString data as expected

 @SYMREQ	10372

 */

 template<class LSTRING, class TBUF, class TTEXT, class HBUF>	

 LOCAL_C void TestReAllocL(LSTRING*)

 {

 	test.Next (_L ("@SYMTestCaseID:SYSLIB-EUSERHL-UT-4004"));

 	test.Next(_L("ReAlloc(TInt aMaxLength) method"));

 	TBUF des (_TS("0123456"));

 	//reallocate EPtr type - decrease memory

 	LSTRING lStr(des);

 	lStr.SetLengthL(3);

 	test(lStr.ReAlloc(3)==KErrNone);					//ReAlloc to EPtr

 	test(lStr.MaxLength()>=3);

 	test(lStr.Length()==3);

 	test(lStr[0] == (TTEXT)('0'));

 	test(lStr[2] == (TTEXT)('2'));

 	//reallocate EBufCPtr type - decrease memory

 	HBUF* hBuf = HBUF::NewMax(9);

 	*hBuf = _TS("012345678");

 	lStr.Assign(hBuf);						//Create as EBufCPtr

 	lStr.SetLengthL(5);

 	test(lStr.ReAlloc(5)==KErrNone);		//ReAlloc to EBufCPtr

 	test(lStr.MaxLength()>=5);//There could be more allocated memory - see HBufC8::Des()

 	test(lStr.Length()==5);

 	test(lStr[0] == (TTEXT)('0'));

 	test(lStr[4] == (TTEXT)('4'));

 	//reallocate EBufCPtr type - increase memory

 	hBuf = HBUF::NewMax(9);

 	*hBuf = _TS("012345678");

 	lStr.Assign(hBuf);						//Create as EBufCPtr

 	test(lStr.ReAlloc(15)==KErrNone);		//ReAlloc to EBufCPtr

 	test(lStr.MaxLength()>=15);//There could be more allocated memory - see HBufC8::Des()

 	test(lStr.Length()==9);

 	test(lStr[0] == (TTEXT)('0'));

 	test(lStr[8] == (TTEXT)('8'));

 	//reallocate EPtr type - to zero-length

 	lStr = des;

 	lStr.SetLengthL(0);

 	test(lStr.ReAlloc(0)==KErrNone);		//ReAlloc to EPtr

 	test(lStr.MaxLength()==0);

 	test(lStr.Length()==0);

 	//reallocate EBufCPtr type to zero-length

 	hBuf = HBUF::NewMax(9);

 	*hBuf = _TS("012345678");

 	lStr.Assign(hBuf);						//Create as EBufCPtr

 	lStr.SetLengthL(0);

 	test(lStr.ReAlloc(0)==KErrNone);		//ReAlloc to EPtr

 	test(lStr.MaxLength()==0);

 	test(lStr.Length()==0);

 	//reallocate from zero-length

 	lStr.Reset();						

 	test(lStr.ReAlloc(9)==KErrNone);		//ReAlloc to EPtr

 	test(lStr.MaxLength() >=9);

 	test(lStr.Length()==0);

 	//reallocate from zero-length to zero-length

 	lStr.Reset();							

 	test(lStr.ReAlloc(0)==KErrNone);		//ReAlloc to EPtr

 	test(lStr.Length() == 0);		

 	test(lStr.MaxLength() == 0);		

 }

 /**

 Tests the following methods. 

  - TInt ReAllocL(TInt aMaxLength);

 */

 /**

 @SYMTestCaseID SYSLIB-EUSERHL-UT-4005

 @SYMTestCaseDesc Tests Leaving variant ReAllocL of LString

 @SYMTestPriority High

 @SYMTestActions Creates LString objects and uses ReAllocL to 

 				increase memory under OOM conditions

 				Verifies that ReAllocL leaves with KErrNoMemory

 @SYMTestExpectedResults Calls to ReAllocL that increase memory should 

 				leave with KErrNoMemory under OOM conditions

 @SYMREQ	10372

 */

 template<class LSTRING, class TBUF, class TTEXT>	

 LOCAL_C void TestReAllocLeaving(LSTRING*)

 {

 	test.Next (_L ("@SYMTestCaseID:SYSLIB-EUSERHL-UT-4005"));

 	test.Next(_L("ReAllocL(TInt aMaxLength) method"));

 	TBUF des(_TS("01"));

 	LSTRING lStr(des);

 	TRAPD(ret, lStr.ReAllocL(6));	//ReAlloc buffer

 	test(KErrNone == ret);

 #if defined(_DEBUG)

 	__UHEAP_FAILNEXT(1);

 	TRAP(ret, lStr.ReAllocL(100));	//Realloc buffer. This should fail.

 	test(KErrNoMemory == ret);

 #endif //(_DEBUG)

 	test(lStr.MaxLength() >=6);		//Check LString is the same as before ... 

 	test(lStr.Length()==2);			//... ReAlloc that failed.

 	test(lStr[0] == (TTEXT)('0'));

 	test(lStr[1] == (TTEXT)('1'));

 }

 /**

 Tests the following methods. 

  - void SwapL(LString& aBuf);

  - void SwapL(TDes& aBuf);

 */

 /**

 @SYMTestCaseID SYSLIB-EUSERHL-UT-4006

 @SYMTestCaseDesc Tests SwapL methods of LString

 @SYMTestPriority High

 @SYMTestActions Creates LString objects and uses SwapL to 

 				swap string contents.

 				Verifies that contents are swapped and memory 

 				reallocated where necessary

 @SYMTestExpectedResults Calls to SwapL should swap string contents 

 				and buffer should be automatically reallocated to fit the new data.

 @SYMREQ	10372

 */

 template<class LSTRING, class TBUF, class TTEXT>

 LOCAL_C void TestSwapL(LSTRING*)

 {

 	test.Next (_L ("@SYMTestCaseID:SYSLIB-EUSERHL-UT-4006"));

 	LSTRING lStr1, lStr2;

 	TBUF des1(_TS("12"));

 	TBUF des2 (_TS("345678"));

 	TBUF des3 (_TS("12345678"));

 	TBUF swap_des = des2;

 	test.Next(_L("Swap(LString_& aLString) method"));

 	// assignment operation; implies deep copying

 	lStr1 = des1;

 	lStr2 = des2;

 	// swap LStrings with TDes

 	// lStr1 should grow to accommodate swap_des

 	lStr1.SwapL(swap_des);

 	test(lStr1==des2);

 	test(swap_des==des1);

 	// swap two LStrings

 	// lStr2 should grow to accommodate lStr1

 	lStr1 = des3;

 	lStr1.SwapL(lStr2);

 	test(lStr1==des2);

 	test(lStr2==des3);

 }

 /**

 Test assignemnt operator.

 */

 /**

 @SYMTestCaseID SYSLIB-EUSERHL-UT-4007

 @SYMTestCaseDesc Tests Assignment operator for LString

 @SYMTestPriority High

 @SYMTestActions Creates LString objects and uses assignment to 

 				change string contents.

 				Verifies that contents are swapped and memory 

 				reallocated where necessary

 @SYMTestExpectedResults Assignment operator should change string contents

 				and buffer should be automatically reallocated to fit the new data.

 @SYMREQ	10372

 */

 template<class LSTRING, class TBUF, class TBUFC, class TTEXT, class CHAR>

 LOCAL_C void TestAssignmentOperatorL()

 {

 	test.Next (_L ("@SYMTestCaseID:SYSLIB-EUSERHL-UT-4007"));	

 	test.Next(_L("Assignment operator"));

 	TBUF tdes(_TS("Modifiable descriptor"));

 	TBUFC tdesc(_TS("Non-modifiable descriptor"));

 	LSTRING lStr(32);

 	LSTRING lStr2(32);

 	lStr2.CopyL(_TS("Buffer descriptor"), 17);

 	lStr = tdesc;	test(lStr == tdesc);

 	lStr = tdes;	test(lStr == tdes);

 	lStr = lStr2;	test(lStr == lStr2);

 	LSTRING lStr3(tdes);

 	lStr = lStr3.PtrZL(); test(lStr == tdes);

 	test.Next(_L("operator=(char/wchar_t* aCharStr) method"));

 	LSTRING lStr4(_CS("123456"));

 	LSTRING lStr5 = _CS("123456");

 	test(lStr4 == lStr5);

 	LSTRING lStr6;

 	lStr6 =  _CS("123456");

 	test(lStr4 == lStr6);

 	}

 /** 

 Test Capacity growth and compression

 */

 /**

 @SYMTestCaseID SYSLIB-EUSERHL-UT-4008

 @SYMTestCaseDesc Tests capacity growth and compression for LString

 @SYMTestPriority High

 @SYMTestActions Creates an LString object then calls SetMaxLength and Compress

 				to increase or decrease underlying buffer size.

 				Tests that Length and Maxlength are modified as expected 

 @SYMTestExpectedResults SetMaxLength and Compress should  resize the underlying

 				buffer as expected.

 @SYMREQ	10372

 */

 template<class LSTRING, class TBUF, class TTEXT> 

 LOCAL_C void TestCapacityChangesL(LSTRING*)

 {

 	test.Next (_L ("@SYMTestCaseID:SYSLIB-EUSERHL-UT-4008"));

 	test.Next(_L("Test capacity growth and compression on LString"));

 	LSTRING lStr(_TS("0123456"));

 	test(lStr.Length()==7);

 	test(lStr.MaxLength() >=7);

  	lStr.SetMaxLengthL(10);

 	test(lStr.Length()==7);

 	test(lStr.MaxLength() >=10);

  	lStr.SetMaxLengthL(6);

 	test(lStr.Length()==6);

 	test(lStr.MaxLength() >=6);

  	lStr.SetMaxLengthL(10);

 	test(lStr.Length()==6);

 	test(lStr.MaxLength() >=10);

 	//Call the same thing again to check the condition

 	//that required length is already set

  	lStr.SetMaxLengthL(10);

 	test(lStr.Length()==6);

 	test(lStr.MaxLength() >=10);

  	lStr.Compress();

  	test(lStr.Length()==6);

 	test(lStr.MaxLength() >= 6);

 	//Call the same thing again to check the condition

 	//that the string is already compressed

  	lStr.Compress();

  	test(lStr.Length()==6);

 	test(lStr.MaxLength() >= 6);

 	lStr.ReserveFreeCapacityL(15);

  	test(lStr.Length()==6);

 	test(lStr.MaxLength() >= 32);

 	lStr.Reset();

  	test(lStr.Length()==0);

 	test(lStr.MaxLength() == 0);

 }

 /** 

 Test copying from 16bit to 8bit and vice versa

 */

 /**

 @SYMTestCaseID SYSLIB-EUSERHL-UT-4009

 @SYMTestCaseDesc Tests Copying between 8 and 16 bit LString variants

 @SYMTestPriority High

 @SYMTestActions Creates an LString8 and LString16 object and uses the cross-variant 

 				Copy functions to copy data between the variants.

 @SYMTestExpectedResults Data is successfully copied between the variants.

 @SYMREQ	10372

 */

 LOCAL_C void TestCrossCopyingL()

 	{

 	test.Next (_L ("@SYMTestCaseID:SYSLIB-EUSERHL-UT-4009"));

 	test.Next(_L("Test cross copying on LString"));

 	LString8 lStr8("0123");

 	LString16 lStr16(L"01234567");

 	LString8 targetStr8;

 	LString16 targetStr16;

 	targetStr8.CopyL(lStr16);

 	targetStr16.CopyL(lStr8);

 	}	

 /** 

 Test creating an LString from a stream

 */

 /**

 @SYMTestCaseID SYSLIB-EUSERHL-UT-4010

 @SYMTestCaseDesc Tests Creating an LString from a stream

 @SYMTestPriority High

 @SYMTestActions Creates a in-memory stream and writes some data to it.

 				Creates an LString from a readstream and verifies that the

 				contents of the LString match the data written to the stream.

 @SYMTestExpectedResults The LString contents should match the data written 

 				to the stream.

 @SYMREQ	10372

 */

 template<class LSTRING, class TTEXT>

 LOCAL_C void TestReadFromStreamL()

 	{

 	test.Next (_L ("@SYMTestCaseID:SYSLIB-EUSERHL-UT-4010"));

 	test.Next(_L("Test creating LString from a stream"));

 	RFs fs;

 	fs.Connect() OR_LEAVE;

 	LSTRING outString = _TS("This is a test string written to a stream");

 	//Create a buffer to contain the stream

 	CBufFlat* buf = CBufFlat::NewL(outString.MaxLength());

 	//Create a write stream

 	RBufWriteStream outStream;

 	outStream.Open(*buf);

 	//write some data to the stream

 	outStream << outString;

 	outStream.CommitL();

 	//Open a readstream

 	RBufReadStream inStream;	

 	inStream.Open(*buf);

 	//Create an LString from the stream

 	LSTRING inString;

 	inString.CreateL(inStream,outString.Length());	

 	test(inString == outString);

 	delete buf;	

 	}

 /** 

 Test support for [wide]character strings.

 APIs that modify data.

 */

 /**

 @SYMTestCaseID BASESRVCS-EUSERHL-UT-4068

 @SYMTestCaseDesc Test the APIs provided to support wchar_t and char strings

 @SYMTestPriority High

 @SYMTestActions 1)Construct LString object from the supplied null terminated 

 				character string.

 				2)Assign new string to the constructed LString object

 				3)Appends data onto the end of this LString object's data.

 				The length of this descriptor is incremented to reflect the new content.

 				4)Copy new data into the LString object, replacing any existing

 				data, and expanding its heap buffer to accommodate if necessary.

 				5)Insert contents into the LString

 				6)Replace data to the end of the LString object and justify it.

 				7)Append data of specified length, to the end of the LString object.

 				8)Justify data, to the end of the LString object.

 				9)Appends data onto the end of this descriptor's data and justifies it.

 @SYMTestExpectedResults The LString contents should match the data expected after the operation.

 @SYMREQ	10372

 */

 template<class LSTRING, class TTEXT, class CHAR>

 LOCAL_C void TestCharacterStringSupport_Modifiers(LSTRING*)

 	{

 	test.Next (_L ("@SYMTestCaseID:BASESRVCS-EUSERHL-UT-4068"));

 	// 1. test Constructor 

 	// Constructs LString object from the supplied null terminated 

 	// character string

 	test.Next(_L("LString_(char/wchar_t * aCharStr) constructor"));

 	LSTRING lStr(_CS("0123456789"));

 	test(lStr.Length() == 10);		

 	test(lStr.MaxLength() >= 10);

 	test(lStr.Compare(_CS("0123456789")) == 0 );

 	// try strings ending with 0

 	LSTRING lStr1(_CS("01234567890"));

 	test(lStr1.Length() == 11);		

 	test(lStr1.MaxLength() >= 11);

 	test(lStr1.Compare(_CS("01234567890")) == 0 );

 	// 2. test '=' operator

 	LSTRING lTestStr;

 	// Assign new string to the constructed LString object

 	test.Next(_L("LString_ operator '=' "));

 	lTestStr = _CS("Try a New String");

 	test(lTestStr.Compare(_CS("Try a New String")) == 0 );

 	test(lTestStr.Length() == 16);		

 	test(lTestStr.MaxLength() >= 16);

 	// 3. test '+=' operator

 	// Appends data onto the end of this LString object's data.

 	// The length of this descriptor is incremented to reflect the new content.

 	test.Next(_L("LString_ operator '+=' "));

 	lTestStr += _CS("!!!");

 	test(lTestStr.Compare(_CS("Try a New String!!!")) == 0 );

 	test(lTestStr.Length() == 19);		

 	test(lTestStr.MaxLength() >= 19);

 	// 4.Test "Copy()" Variants

 	LSTRING lTestStr1;

 	LSTRING lTestStr2;

 	// Copy new data into the LString object, replacing any existing

 	// data, and expanding its heap buffer to accommodate if necessary.

 	test.Next(_L("LString_ CopyL "));

 	lTestStr1.CopyL(_TS("Try a New String"));

 	test(lTestStr1.Compare(_TS("Try a New String")) == 0 );

 	test(lTestStr1.Length() == 16);		

 	test(lTestStr1.MaxLength() >= 16);

 	// Copy folded(normalized) content

 	test.Next(_L("LString_ CopyFL "));

 	lTestStr1.CopyFL(_CS("Some RaNDom STRING"));

 	lTestStr2.CopyFL(_CS("SOME RaNDom string"));

 	test(lTestStr1.Compare(lTestStr2) == 0);

 	// Copy contents in Lower case

 	test.Next(_L("LString_ CopyLCL "));

 	lTestStr1.CopyLCL(_CS("SOME STRING IN UPPER CASE"));

 	test(lTestStr1 == _CS("some string in upper case"));

 	// Copy contents in Upper case

 	test.Next(_L("LString_ CopyUCL "));

 	lTestStr1.CopyUCL(_CS("some string in lower case"));

 	test(lTestStr1 == _CS("SOME STRING IN LOWER CASE"));

 	// Copy Capitalized contents

 	test.Next(_L("LString_ CopyCPL "));

 	lTestStr1.CopyCPL(_CS("some string in lower case"));

 	test(lTestStr1 == _CS("Some string in lower case"));

 	// 5. Test Insert()

 	LSTRING lTestStr3;

 	// Insert contents into a string

 	test.Next(_L("LString_ InsertL "));

 	lTestStr3 = _CS("Some Content Can Be Into This String");

 	lTestStr3.InsertL(20,_CS("Inserted "));

 	test(lTestStr3 == _CS("Some Content Can Be Inserted Into This String"));

 	// 6. Test Replace()

 	LSTRING lTestStr4;

 	// Replace contents form the string

 	test.Next(_L("LString_ ReplaceL "));

 	lTestStr4 = _CS("Some Content Can Be Decalper");

 	lTestStr4.ReplaceL(20,8,_CS("Replaced"));

 	test(lTestStr4 == _CS("Some Content Can Be Replaced"));

 	// 7. Test Append()

 	LSTRING lTestStr5;

 	//Append data of specified length, to the end of the LString object.	

 	test.Next(_L("LString_ AppendL(src,length)"));

 	lTestStr5.CopyL( _CS("Try appending "));

 	lTestStr5.AppendL(_CS("Try appending some more"),3);

 	test(lTestStr5 == _CS("Try appending Try"));

 	//Append data , to the end of the LString object.	

 	test.Next(_L("LString_ AppendL(src)"));

 	lTestStr5.CopyL( _CS("Try appending "));

 	lTestStr5.AppendL(_CS("Try appending some more"));

 	test(lTestStr5 == _CS("Try appending Try appending some more"));

 	// 8. Test Justify()

 	LSTRING lTestStr6;

 	//Copy data into this descriptor and justifies it, replacing any existing data	

 	test.Next(_L("LString_ JustifyL "));

 	lTestStr6.CopyL(_CS("Justified"));

 	lTestStr6.JustifyL(_CS("Just"),9,ERight,*(_TS("x")));

 	test(lTestStr6 == _CS("xxxxxJust"));

 	// 9. Test AppendJustify variants

 	LSTRING lTestStr7;

 	// Append data to the end of the LString object and justify it.

 	test.Next(_L("LString_ AppendJustifyL(const char*,TInt aLength,TInt aWidth,TAlign anAlignment,TChar aFill)"));

 	lTestStr7.CopyL(_CS("One "));

 	lTestStr7.AppendJustifyL(_CS("Two "),KDefaultJustifyWidth,ERight,*(_TS("x")));

 	test(lTestStr7 == _TS("One Two "));

 	lTestStr7.CopyL(_CS("One "));

 	lTestStr7.AppendJustifyL(_CS("Two Three"),3,7,ERight,*(_TS("x")));

 	test(lTestStr7 == _CS("One xxxxTwo") );

 	// Append data to the end of the LString object and justify it.

 	test.Next(_L("LString_ AppendJustifyL(const char* aCharStr,TInt aWidth,TAlign anAlignment,TChar aFill)"));

 	lTestStr7.CopyL(_CS("One "));

 	lTestStr7.AppendJustifyL(_CS("Two Three"),KDefaultJustifyWidth,ERight,*(_TS("x")));

 	test(lTestStr7 == _TS("One Two Three"));

 	lTestStr7.CopyL(_CS("One "));

 	lTestStr7.AppendJustifyL(_CS("Two Three"),13,ERight,*(_TS("x")));

 	test(lTestStr7 == _CS("One xxxxTwo Three") );

 	}

 /** 

 Test support for [wide]character strings.

 APIs that do not modify any data.

 */

 /**

 @SYMTestCaseID BASESRVCS-EUSERHL-UT-4069

 @SYMTestCaseDesc Test the APIs provided to support wchar_t and char strings

 @SYMTestPriority High

 @SYMTestActions 1)Determine whether this descriptor's data is equal to the specified string's data.

 				2)Determine whether this descriptor's data is less than the specified string's data.

 				3)Determine whether this descriptor's data is less than or equal to the specified string's data.

 				4)Determine whether this descriptor's data is greater than the specified string's data.

 				5)Determine whether this descriptor's data is greater than or equal to the specified string's data.

 				6)Determine whether this descriptor's data is not equal to the specified string's data.

 				7)Compare this descriptor's data with the specified string's data.

 				8)Search this descriptor's data for a match with the match pattern supplied in the specified string's

 				9)Searches for the first occurrence of the specified data sequence within this descriptor

 @SYMTestExpectedResults The operation/comparision  must result in the desired output

 @SYMREQ	10372

 */

 template<class LSTRING,class TTEXT, class CHAR>

 LOCAL_C void TestCharacterStringSupport_NonModifiers(LSTRING*)

 	{

 	test.Next (_L ("@SYMTestCaseID:BASESRVCS-EUSERHL-UT-4069"));

 	// 1.test '==' operator

 	LSTRING lTestStr1;

 	lTestStr1.CopyL(_CS("Are they equal?? "));

 	test(lTestStr1 == _CS("Are they equal?? "));

 	lTestStr1.CopyL(_CS("12345670"));

 	test(lTestStr1 == _CS("12345670"));

 	// 2.test "<" operator

 	LSTRING lTestStr2;

 	lTestStr2.CopyL(_CS("ABCDEFGH"));

 	test(lTestStr2 < _CS("abcdefgh"));

 	lTestStr2.CopyL(_CS(" Is this is smaller"));

 	test(lTestStr2 < _CS("No, larger of the string is greater than the smaller one"));

 	// 3.test "<=" operator

 	LSTRING lTestStr3;

 	lTestStr3.CopyL(_CS("ABCDEFGH"));

 	test(lTestStr3 <= _CS("abcdefgh"));

 	lTestStr3.CopyL(_CS("equals"));

 	test(lTestStr3 <= _CS("equals"));

 	// 4.test ">" operator

 	LSTRING lTestStr4;

 	lTestStr4.CopyL(_CS("abcdefgh"));

 	test(lTestStr4 > _CS("ABCDEFGH"));

 	lTestStr4.CopyL(_CS("No, larger of the string is greater than the smaller one"));

 	test(lTestStr4 > _CS("Is this smaller??"));

 	// 5.test ">=" operator

 	LSTRING lTestStr5;

 	lTestStr5.CopyL(_CS("abcdefgh"));

 	test(lTestStr5 >= _CS("ABCDEFGH"));

 	lTestStr5.CopyL(_CS("equals"));

 	test(lTestStr5 >= _CS("equals"));

 	// 6.test "!="

 	LSTRING lTestStr6;

 	lTestStr6.CopyL(_CS("abcdefgh"));

 	test(lTestStr6 != _CS("ABCDEFGH"));

 	lTestStr6.CopyL(_CS("equals"));

 	test(!(lTestStr6 != _CS("equals")));

 	// 7.test Compare variants

 	LSTRING lTestStr7;

 	// Compare strict

 	lTestStr7.CopyL(_CS("abcdefgh"));

 	test(lTestStr7.Compare(_CS("ABCDEFGH")) > 0);	

 	lTestStr7.CopyL(_CS("ABCDEFGH"));

 	test(lTestStr7.Compare(_CS("abcdefgh")) < 0);

 	lTestStr5.CopyL(_CS("equals"));

 	test(lTestStr5.Compare( _CS("equals")) == 0);

 	// Compare foalded

 	lTestStr7.CopyL(_CS("abcdefgh"));

 	test(lTestStr7.CompareF(_CS("ABcDeFgH")) == 0);	

 	// 8.test Match variants

 	LSTRING lTestStr8;

 	// Match strict

 	lTestStr8.CopyL(_CS("abcdefghijklmnopqrstuvwxyz"));

 	test(lTestStr8.Match(_CS("*ijk*"))== 8);

 	test(lTestStr8.Match(_CS("*i?k*"))== 8);

 	test(lTestStr8.Match(_CS("ijk*"))== KErrNotFound);

 	// Match Folded

 	test(lTestStr8.MatchF(_CS("*IjK*"))== 8);

 	test(lTestStr8.MatchF(_CS("*I?k*"))== 8);

 	test(lTestStr8.MatchF(_CS("ijK*"))== KErrNotFound);

 	// 9.test Find variants

 	LSTRING lTestStr9;

 	// Find strict

 	lTestStr9.CopyL(_CS("abcdefghijklmnopqrstuvwxyz"));

 	test(lTestStr9.Find(_CS("abcde")) == 0);

 	test(lTestStr9.Find(_CS("cde")) == 2);

 	test(lTestStr9.Find(_CS("efg22")) == KErrNotFound);

 	test(lTestStr9.Find(_CS("efg22"),3) == 4);

 	// Find folded

 	test(lTestStr9.FindF(_CS("aBcDe")) == 0);

 	test(lTestStr9.FindF(_CS("cDe")) == 2);

 	test(lTestStr9.FindF(_CS("eFg22")) == KErrNotFound);

 	test(lTestStr9.FindF(_CS("efG22"),3) == 4);

 	}

 void RunTestsL()

 	{

 	LString8* r8=0;

 	LString16* r16=0;

 	// LString8 Tests

 	TestConstructors<LString8,TBuf8<11>,TText8, HBufC8, char>(r8);

 	TestSwapL<LString8,TBuf8<11>,TText8>(r8);

 	TestAssign<LString8,TBuf8<11>,TText8,HBufC8,RBuf8>(r8);

 	TestAppendL<LString8,TBuf8<11>,TText8, char>(r8);

 	TestReAllocL<LString8,TBuf8<11>,TText8,HBufC8>(r8);

 	TestReAllocLeaving<LString8,TBuf8<11>,TText8>(r8);

 	TestAssignmentOperatorL<LString8,TBuf8<32>,TBufC8<32>,TText8, char>();

 	TestCapacityChangesL<LString8,TBuf8<11>,TText8>(r8);

 	TestReadFromStreamL<LString8,TText8>();

 	TestCharacterStringSupport_Modifiers<LString8,TText8, char>(r8);

 	TestCharacterStringSupport_NonModifiers<LString8,TText8, char>(r8);

 	// LString16 Tests

 	TestConstructors<LString16,TBuf16<11>,TText16,HBufC16, wchar_t>(r16);

 	TestSwapL<LString16,TBuf16<11>,TText16>(r16);

 	TestAssign<LString16,TBuf16<11>,TText16,HBufC16,RBuf16>(r16);

 	TestAppendL<LString16,TBuf16<11>, TText16,wchar_t>(r16);

 	TestReAllocL<LString16,TBuf16<11>,TText16,HBufC16>(r16);

 	TestReAllocLeaving<LString16,TBuf16<11>,TText16>(r16);

 	TestAssignmentOperatorL<LString16,TBuf16<32>,TBufC16<32>,TText16,wchar_t>();

 	TestCapacityChangesL<LString16,TBuf16<11>,TText16>(r16);

 	TestReadFromStreamL<LString16,TText16>();

 	TestCharacterStringSupport_Modifiers<LString16,TText16, wchar_t>(r16);

 	TestCharacterStringSupport_NonModifiers<LString16,TText16, wchar_t>(r16);

 	TestCrossCopyingL();

 	}

 /** 

 Test arithmetric operator overloads

 */

 GLDEF_C TInt E32Main()

     {

 	CTrapCleanup* trapHandler=CTrapCleanup::New();

 	test(trapHandler!=NULL);

 	test.Title();

 	test.Start(_L("Testing LString8 & LString16 classes"));

 	__UHEAP_MARK;

 	TRAPD(err, RunTestsL());

 	__UHEAP_MARKEND;

 	test.End();

 	delete trapHandler;

 	return(err);

     }