1 // Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Symbian Foundation License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // e32test\buffer\t_des.cpp

    15 // Overview:

    16 // Test methods of the TDes template class.

    17 // API Information:

    18 // TDes

    19 // Details:

    20 // - Test assigning TPtrs in various ways and confirm results are as expected.

    21 // - Test locating in reverse on an empty TPtr, verify it returns KErrNoFound.

    22 // - For TBuf, TBuf8 and TBuf16 objects: 

    23 // - Construct a default TBuf object and verify Length and MaxLength values are

    24 // as expected.

    25 // - Construct a TBuf object with length and verify Length and MaxLength values 

    26 // are as expected.

    27 // - Construct a TBuf object over a string, verify Length and MaxLength values 

    28 // are as expected. Verify the string data is correct.

    29 // - Construct a TBuf object over a descriptor, verify Length and MaxLength values 

    30 // are as expected. Verify the data is correct.

    31 // - Construct a TBuf object over a buffer, verify Length and MaxLength values 

    32 // are as expected. Verify the data is correct.

    33 // - Construct a TBuf object and assign a string to it, verify Length and MaxLength 

    34 // values are as expected. Verify the data is correct.

    35 // - Construct a TBuf object and assign a descriptor to it, verify Length and MaxLength 

    36 // values are as expected. Verify the data is correct.

    37 // - Construct a TBuf object and assign a buffer to it, verify Length and MaxLength 

    38 // values are as expected. Verify the data is correct.

    39 // - Check the available user heap space and check for memory leaks by comparing it to 

    40 // the initial value.

    41 // - For TPtrC, TPtrC8 and TPtrC16 objects: 

    42 // - Verify the invariant for a null pointer descriptor

    43 // - Construct a TPtrC object over a constant string, verify Length and string data 

    44 // are correct.

    45 // - Construct a TPtrC object over a constant descriptor, verify Length and data are 

    46 // correct.

    47 // - Construct a TPtrC object over a constant buffer with length, verify Length and 

    48 // data are correct.

    49 // - Check the available user heap space and check for memory leaks by comparing it to 

    50 // the initial value.

    51 // - For TPtr, TPtr8 and TPtr16 objects: 

    52 // - Verify the invariant for a null pointer descriptor

    53 // - Construct a TPtr object over a buffer with length and maxlength, verify Length,

    54 // MaxLength and data are correct.

    55 // - Construct a TPtr object over a buffer with maxlength, verify Length, MaxLength 

    56 // and Ptr are correct.

    57 // - Construct a TPtr object and assign a string to it. Verify Length, MaxLength and

    58 // the string data are correct.

    59 // - Construct a TPtr object and assign a buffer to it. Verify Length, MaxLength and

    60 // the data are correct.

    61 // - Construct a TPtr object and assign a descriptor to it. Verify Length, MaxLength

    62 // and the data are correct.

    63 // - Check the available user heap space and check for memory leaks by comparing it to 

    64 // the initial value.

    65 // - Verify the TPtr copy constructor by setting and checking a text string.

    66 // - For TBufC, TBufC8 and TBufC16 objects: 

    67 // - Construct a default TBufC object. Verify default Length is as expected.

    68 // - Construct a TBufC object over a string, verify Length and data are correct.

    69 // - Construct a TBufC object over a TBufC, verify Length and data are correct.

    70 // - Construct a TBufC object and assign a string to it, verify Length and data 

    71 // are correct.

    72 // - Construct a TBufC object and assign a descriptor to it, verify Length and data 

    73 // are correct.

    74 // - Construct a TBufC object and assign a TBufC to it, verify Length and data 

    75 // are correct.

    76 // - Check the available user heap space and check for memory leaks by comparing it to 

    77 // the initial value.

    78 // - For HBufC, HBufC8 and HBufC16 objects: 

    79 // - Create a new descriptor using the New() method, verify non-NULL return value.

    80 // - Construct a HBufC object and assign a string to it, verify Length and data 

    81 // are correct.

    82 // - Construct a HBufC object and assign a descriptor to it, verify Length and data 

    83 // are correct.

    84 // - Construct a HBufC object and assign a HBufC to it, verify Length and data 

    85 // are correct.

    86 // - Construct a HBufC object and call ReAlloc method, verify Length and data are 

    87 // correct.

    88 // - Check the available user heap space and check for memory leaks by comparing it to 

    89 // the initial value.

    90 // - Test ASCII destination with Unicode source. Verify string results are as expected.

    91 // - For TLitC, TLitC8 and TLitC16 objects: 

    92 // - Verify member operators.

    93 // - Assign and validate literal values

    94 // - For TBuf, TBuf8 and TBuf16 objects, test TDes derived objects that return TPtrs.

    95 // - Extract and verify the left portion of the descriptor (LeftTPtr).

    96 // - Extract and verify the right portion of the descriptor (RightTPtr).

    97 // - Extract and verify the middle portion of the descriptor (MidTPtr).

    98 // - For TPtr, TPtr8 and TPtr16 objects, test TDes derived objects that return TPtrs.

    99 // - Extract and verify the left portion of the descriptor (LeftTPtr).

   100 // - Extract and verify the right portion of the descriptor (RightTPtr).

   101 // - Extract and verify the middle portion of the descriptor (MidTPtr).

   102 // Platforms/Drives/Compatibility:

   103 // All 

   104 // Assumptions/Requirement/Pre-requisites:

   105 // Failures and causes:

   106 // Base Port information:

   107 // 

   108 //

   109 

   110 #include <e32test.h>

   111 

   112 LOCAL_D RTest test(_L("T_DES"));

   113 

   114 template<class T,class S, class L, class R>	

   115 class TestTDes

   116 	{

   117 public:

   118 	TestTDes(); 		// Test class constructor.

   119 	void Test1();

   120 	void Test2();

   121 	void Test3();

   122 	void Test4();

   123 	void Test5();

   124 	void Test6();

   125 	void Test7();

   126 	void Test8();

   127 	void Test9();

   128 	void Test10();

   129 	void Test11();

   130 	void Test12();

   131 	void Test13();

   132 	void Test14();

   133 	void Test15();

   134 	void Test16();

   135 	void Test17();

   136 	void Test18();

   137 	void TestA();

   138 	void TestB();

   139 	void TestC();

   140 	void TestD();

   141 	void TestE();

   142 	void TestF();

   143 	void TestG();

   144 	void TestH();

   145 	void TestI();

   146 	void TestJ();

   147 	void TestK();

   148 	void TestL();

   149 	void TestM();

   150 	void TestN();

   151 	void TestO();

   152 	void TestP();

   153 	void test_TPtrC(); 	// Test TPtrC classes

   154 	void test_TPtr();	// Test TPtr classes

   155 	void test_TBuf();	// Test TBuf classes

   156 	void test_TBufC();	// Test TBufC classes

   157 	void test_HBufC();	// Test HBufC classes

   158 	void test_TBufReturningModifiable();

   159 	void test_TPtrReturningModifiable();

   160 	void test_TDesReturningModifiable(const T& a, R& b);

   161 	void testHeapSpace(TInt);

   162 	};

   163 

   164 template <class T, class S, class L, class R>

   165 GLDEF_C TestTDes<T,S,L,R>::TestTDes()

   166 //

   167 //	Constructor

   168 //

   169 	{}

   170 

   171 template <class T,class S,class L,class R>

   172 GLDEF_C void TestTDes<T,S,L,R>::testHeapSpace(TInt startAvail)

   173 //

   174 //	Test no memory leakage has occured

   175 //

   176 	{

   177 

   178 	test.Next(_L("Testing for memory leaks"));

   179 	TInt endAvail,temp;

   180 	endAvail=User::Available(temp);

   181 	test(endAvail==startAvail);

   182 	}

   183 

   184 template <class T, class S, class L, class R>

   185 GLDEF_C void TestTDes<T,S,L,R>::Test1()

   186 //

   187 //	Constructs a view over a constant string

   188 //

   189 	{

   190 

   191 	T a(_TL("ABc"));

   192 	a.__DbgTestInvariant();

   193 	test(a.Length()==3);

   194 	test(*a.Ptr()=='A');

   195 	test(*(a.Ptr()+1)=='B');

   196 	test(*(a.Ptr()+2)=='c');

   197 	}

   198 

   199 template<class T, class S, class L, class R>

   200 GLDEF_C void TestTDes<T,S,L,R>::Test2()

   201 //

   202 //	Constructs a view over a descriptor

   203 //

   204 	{

   205 

   206 	T aDes(_TL("ABc"));

   207 	aDes.__DbgTestInvariant();

   208 	T b(aDes);

   209 	b.__DbgTestInvariant();

   210 	test(b.Length()==aDes.Length());

   211 	test(*b.Ptr()==*aDes.Ptr());

   212 	test(*(b.Ptr()+1)==*(aDes.Ptr()+1));

   213 	test(*(b.Ptr()+2)==*(aDes.Ptr()+2));

   214 	}

   215 

   216 template<class T, class S, class L, class R>

   217 GLDEF_C void TestTDes<T,S,L,R>::Test3()

   218 //

   219 //	Constructs a view over a length specified buffer

   220 //

   221 	{

   222 

   223 	S* aBuf = _TL("ABCDEF");

   224 	T aDes(aBuf,6);

   225 	aDes.__DbgTestInvariant();

   226 	test(aDes.Length()==6);

   227 	for(S count=0; count<aDes.Length(); count++)

   228 		test(*(aDes.Ptr()+count)==('A' + count));

   229 	test(aDes.Ptr()==aBuf);

   230 	}

   231 

   232 template<class T, class S, class L, class R>

   233 GLDEF_C void TestTDes<T,S,L,R>::Test4()

   234 //

   235 //	Constructs a r/w view over a buffer with length & maxlength

   236 //

   237 	{

   238 

   239 	S* aBuf;

   240 	aBuf=_TL("LMNOPQ");

   241 	T aDesW(aBuf,6,0x0A);

   242 	aDesW.__DbgTestInvariant();

   243 	test(aDesW.Length()==6);

   244 	for(S count=0; count<aDesW.Length(); count++)

   245 		test(*(aDesW.Ptr()+count)==('L' + count));

   246 	test(aDesW.Ptr()==aBuf);

   247 	test(aDesW.MaxLength()==0x0A);

   248 	}

   249 

   250 template<class T, class S, class L, class R>

   251 GLDEF_C void TestTDes<T,S,L,R>::Test5()

   252 //

   253 //	Constructs a r/w view over a buffer with maxlength

   254 //

   255 	{

   256 

   257 	S* aBuf;

   258 	aBuf=_TL("ZYXWVU");

   259 	T aDesW(aBuf,0x06);

   260 	aDesW.__DbgTestInvariant();

   261 	test(aDesW.Length()==0);

   262 	test(aDesW.MaxLength()==0x06);

   263 	test(aDesW.Ptr()==aBuf);

   264 	}

   265 

   266 template<class T, class S, class L, class R>

   267 GLDEF_C void TestTDes<T,S,L,R>::Test6()

   268 //

   269 //	Constructs a r/w view over a LcbBase with maxlength

   270 //

   271 	{

   272 	// Cant use yet, see calling function

   273 	}

   274 

   275 template<class T, class S, class L, class R>

   276 GLDEF_C void TestTDes<T,S,L,R>::Test7()

   277 //

   278 //	Constructs a default TBuf view 

   279 //

   280 	{

   281 

   282 	T aBuf;

   283 	aBuf.__DbgTestInvariant();

   284 	test(aBuf.Length()==0);

   285 	test(aBuf.MaxLength()==0x40);

   286 	}

   287 

   288 template<class T, class S, class L, class R>

   289 GLDEF_C void TestTDes<T,S,L,R>::Test8()

   290 //

   291 //	Constructs a TBuf view with length

   292 //

   293 	{

   294 

   295 	T aBuf(10);

   296 	aBuf.__DbgTestInvariant();

   297 	test(aBuf.Length()==10);

   298 	test(aBuf.MaxLength()==0x40);

   299 	}

   300 

   301 template<class T, class S, class L, class R>

   302 GLDEF_C void TestTDes<T,S,L,R>::Test9()

   303 //

   304 //	Constructs a TBuf view over a string

   305 //

   306 	{

   307 

   308 	T aBuf(_TL("ABCDEF"));

   309 	aBuf.__DbgTestInvariant();

   310 	test(aBuf.Length()==6);

   311 	test(aBuf.MaxLength()==0x40);

   312 	for(S count=0;count<aBuf.Length();count++)

   313 		test(*(aBuf.Ptr()+count)==('A' + count));

   314 	}

   315 

   316 template<class T, class S, class L, class R>

   317 GLDEF_C void TestTDes<T,S,L,R>::Test10()

   318 //

   319 //	Constructs a TBuf view over a descriptor

   320 //

   321 	{

   322 

   323 	R aDesR(_TL("ABCDEF"));

   324 	aDesR.__DbgTestInvariant();

   325 	T aBuf(aDesR);

   326 	aBuf.__DbgTestInvariant();

   327 	test(aBuf.MaxLength()==0x40);

   328 	test(aBuf.Length()==aDesR.Length());

   329 	test(aBuf.Length()==6);

   330 	for(S count=0;count<aBuf.Length();count++)

   331 		{

   332 		test(*(aBuf.Ptr()+count)==('A' + count));

   333 		test(*(aBuf.Ptr()+count)==*(aDesR.Ptr()+count));

   334 		}

   335 	}

   336 

   337 template<class T, class S, class L, class R>

   338 GLDEF_C void TestTDes<T,S,L,R>::Test11()

   339 //

   340 //	Constructs a TBuf view over a buffer

   341 //

   342 	{

   343 

   344 	T aBuf(_TL("ABCDEF"));

   345 	aBuf.__DbgTestInvariant();

   346 	T bBuf(aBuf);

   347 	bBuf.__DbgTestInvariant();

   348 	test(bBuf.MaxLength()==aBuf.MaxLength());

   349 	test(bBuf.MaxLength()==0x40);

   350 	test(bBuf.Length()==aBuf.Length());

   351 	test(bBuf.Length()==6);

   352 	for(S count=0;count<bBuf.Length();count++)

   353 		{

   354 		test(*(bBuf.Ptr()+count)==('A' + count));

   355 		test(*(bBuf.Ptr()+count)==*(aBuf.Ptr()+count));

   356 		}

   357 	}

   358 

   359 template<class T,class S,class L,class R>

   360 GLDEF_C void TestTDes<T,S,L,R>::Test12()

   361 //

   362 //	Exercise the default TBufC constructor

   363 //

   364 	{

   365 

   366 	T buf;

   367 	buf.__DbgTestInvariant();

   368 	test(buf.Length()==0);

   369 	}

   370 

   371 template<class T,class S,class L,class R>

   372 GLDEF_C void TestTDes<T,S,L,R>::Test13()

   373 //

   374 //	Constructor over a string

   375 //

   376 	{

   377 

   378 	S* pString=(_TL("12"));

   379 	T buf(pString);

   380 	buf.__DbgTestInvariant();

   381 	test(buf.Length()==2);

   382 	test(*(buf.Ptr())=='1');

   383 	test(*(buf.Ptr()+1)=='2');

   384 	}

   385 

   386 template<class T,class S,class L,class R>

   387 GLDEF_C void TestTDes<T,S,L,R>::Test14()

   388 //

   389 //	Constructor over a TDesC (TPtrC)

   390 //

   391 	{

   392 

   393 	R des(_TL("Test 14"));

   394 	des.__DbgTestInvariant();

   395 	T buf(des);

   396 	buf.__DbgTestInvariant();

   397 	test(buf.Length()==7);

   398 	test(buf.Length()==des.Length());

   399 	test(*(buf.Ptr())=='T');

   400 	test(*(buf.Ptr()+1)=='e');

   401 	test(*(buf.Ptr()+2)=='s');

   402 	test(*(buf.Ptr()+3)=='t');

   403 	test(*(buf.Ptr()+4)==' ');

   404 	test(*(buf.Ptr()+5)=='1');

   405 	test(*(buf.Ptr()+6)=='4');

   406 	}

   407 

   408 

   409 template<class T,class S,class L,class R>

   410 GLDEF_C void TestTDes<T,S,L,R>::Test15()

   411 //

   412 //	Constructor over a TBufC

   413 //

   414 	{

   415 

   416 	T oldBuf(_TL("Test  15"));

   417 	oldBuf.__DbgTestInvariant();

   418 	T newBuf(oldBuf);

   419 	newBuf.__DbgTestInvariant();

   420 	test(newBuf.Length()==8);

   421 	test(newBuf.Length()==oldBuf.Length());

   422 	test(*(newBuf.Ptr())=='T');

   423 	test(*(newBuf.Ptr()+1)=='e');

   424 	test(*(newBuf.Ptr()+2)=='s');

   425 	test(*(newBuf.Ptr()+3)=='t');

   426 	test(*(newBuf.Ptr()+4)==' ');

   427 	test(*(newBuf.Ptr()+5)==' ');

   428 	test(*(newBuf.Ptr()+6)=='1');

   429 	test(*(newBuf.Ptr()+7)=='5');

   430 	}

   431 

   432 template<class T,class S,class L,class R>

   433 GLDEF_C void TestTDes<T,S,L,R>::Test16()

   434 //

   435 //	New operator - without leave

   436 //

   437 	{

   438 

   439 	T* pBuf=T::New(0x40);

   440 	test(pBuf!=NULL);

   441 	pBuf->__DbgTestInvariant();

   442 	User::Free(pBuf);

   443 	}

   444 

   445 template<class T,class S,class L,class R>

   446 GLDEF_C void TestTDes<T,S,L,R>::Test17()

   447 //

   448 //	NewL operator - forcing a leave

   449 //

   450 	{

   451 

   452 /*

   453 

   454     Reinstate if some method is found of forcing alloc fail

   455     This test no longer works due to heap growing functionality of E32 057

   456 

   457 	T* pBuf;

   458 	TInt temp;

   459 	TInt available=User::Available(temp);

   460 	TAny* pDummy=User::Alloc(available);

   461 	TRAPD(ret,pBuf=T::NewL(0x40))

   462 	test(ret==KErrNoMemory);

   463 	User::Free(pDummy);

   464 */

   465 	}

   466 

   467 template<class T,class S,class L,class R>

   468 GLDEF_C void TestTDes<T,S,L,R>::Test18()

   469 //

   470 //	NewL operator - forcing success

   471 //

   472 	{

   473 

   474 	T* pBuf=NULL;

   475 	TRAPD(ret,pBuf=T::NewL(0x40))

   476 	test(ret==0);

   477 	test(pBuf!=NULL);

   478 	pBuf->__DbgTestInvariant();

   479 	User::Free(pBuf);

   480 	}

   481 

   482 template<class T, class S, class L, class R>

   483 GLDEF_C void TestTDes<T,S,L,R>::TestA()

   484 //

   485 //	String Assignment

   486 //

   487 	{

   488 

   489     S myBuf[7];

   490     Mem::Copy(myBuf,_TL("ABCDEF"),7*sizeof(S));

   491 	T aDes(myBuf,0x06,0x06);

   492 	aDes=_TL("ZYXWVU");

   493 	aDes.__DbgTestInvariant();

   494 	test(aDes.Length()==6);

   495 	test(aDes.MaxLength()==0x06);

   496 	S count=0;

   497 	for(;count<aDes.Length(); count++)

   498 		{

   499 		test(*(aDes.Ptr()+count)==('Z'-count));

   500 		}	

   501 	aDes=_TL("123");

   502 	aDes.__DbgTestInvariant();

   503 	test(aDes.Length()==3);

   504 	test(aDes.MaxLength()==0x06);

   505 	for(count=0; count<aDes.Length(); count++)

   506 		{

   507 		test(*(aDes.Ptr()+count)==('1'+count));

   508 		}	

   509 	}

   510 

   511 

   512 template<class T, class S, class L, class R>

   513 GLDEF_C void TestTDes<T,S,L,R>::TestB()

   514 //	DesW Assignment

   515 	{

   516 	S aBuf[11];

   517 	S bBuf[11];

   518 	

   519     Mem::Copy(aBuf,_TL("ZYXWVUTSRQ"),11*sizeof(S));

   520     Mem::Copy(bBuf,_TL("ABCDEFGHIJ"),11*sizeof(S));

   521 	T aDes(aBuf,0x0A,0x0A);	

   522 	T bDes(bBuf,0x0A);

   523 	bDes=aDes;

   524 	aDes.__DbgTestInvariant();

   525  	bDes.__DbgTestInvariant();

   526 	test(aDes.Length()==bDes.Length());

   527 	test(aDes.MaxLength()==0x0A);

   528 	test(bDes.MaxLength()==0x0A);		

   529 	for(S count=0; count<bDes.Length(); count++)

   530 		{

   531 		test(*(aDes.Ptr()+count)==*(bDes.Ptr()+count));

   532 		}

   533 	}

   534 

   535 

   536 

   537 template<class T, class S, class L, class R>

   538 GLDEF_C void TestTDes<T,S,L,R>::TestC()

   539 //	DesC Assignment

   540 	{

   541 	S aBuf[11];

   542 	R aDesR(_TL("1234567890"));	

   543     Mem::Copy(aBuf,_TL("ABCDEFGHIJ"),11*sizeof(S));

   544 	T aDes(aBuf,0x0A,0x0A);

   545 	aDes=aDesR;

   546 	aDes.__DbgTestInvariant();

   547 	test(aDes.Length()==aDesR.Length());

   548 	test(aDes.MaxLength()==0x0A);

   549 	for(S count=0; count<aDes.Length(); count++)

   550 		{

   551 		test(*(aDes.Ptr()+count)==*(aDesR.Ptr()+count));

   552 		}

   553 	}

   554 

   555 

   556 template<class T, class S, class L, class R>

   557 GLDEF_C void TestTDes<T,S,L,R>::TestD()

   558 //	TBuf string Assignment

   559 	{

   560 	T aBuf;

   561 	aBuf=(_TL("ABCDEF"));

   562 	aBuf.__DbgTestInvariant();

   563 	test(aBuf.Length()==6);

   564 	test(aBuf.MaxLength()==0x40);

   565 	for(S count=0; count<aBuf.Length(); count++)

   566 		{

   567 		test(*(aBuf.Ptr()+count)==('A'+count));

   568 		}

   569 	}

   570 

   571 

   572 template<class T, class S, class L, class R>

   573 GLDEF_C void TestTDes<T,S,L,R>::TestE()

   574 //	TBuf descriptor Assignment

   575 	{

   576 	R aDesR(_TL("ABCDEF"));

   577 	T aBuf;

   578 	aBuf=aDesR;

   579 	aBuf.__DbgTestInvariant();

   580 	test(aBuf.MaxLength()==0x40);

   581 	test(aBuf.Length()==aDesR.Length());

   582 	test(aBuf.Length()==6);

   583 	for(S count=0;count<aBuf.Length();count++)

   584 		{

   585 		test(*(aBuf.Ptr()+count)==('A' + count));

   586 		test(*(aBuf.Ptr()+count)==*(aDesR.Ptr()+count));

   587 		}

   588 	}

   589 

   590 

   591 template<class T, class S, class L, class R>

   592 GLDEF_C void TestTDes<T,S,L,R>::TestF()

   593 //	TBuf buffer Assignment

   594 	{

   595 	T aBuf(_TL("ABCDEF"));

   596 	T bBuf;

   597 	bBuf=aBuf;

   598 	bBuf.__DbgTestInvariant();

   599 	test(bBuf.MaxLength()==aBuf.MaxLength());

   600 	test(bBuf.MaxLength()==0x40);

   601 	test(bBuf.Length()==aBuf.Length());

   602 	test(bBuf.Length()==6);

   603 	for(S count=0;count<bBuf.Length();count++)

   604 		{

   605 		test(*(bBuf.Ptr()+count)==('A' + count));

   606 		test(*(bBuf.Ptr()+count)==*(aBuf.Ptr()+count));

   607 		}

   608  	}

   609 	 

   610 

   611 template<class T, class S, class L, class R>

   612 GLDEF_C void TestTDes<T,S,L,R>::TestG()

   613 //	TBufC string assignment test

   614 	{

   615 	S* pString=_TL("TestG");

   616 	T buf;

   617 

   618 	test(buf.Length()==0);

   619 	buf=pString;

   620 	buf.__DbgTestInvariant();

   621 	test(buf.Length()==5);

   622 	test(*(buf.Ptr())=='T');

   623 	test(*(buf.Ptr()+1)=='e');

   624 	test(*(buf.Ptr()+2)=='s');

   625 	test(*(buf.Ptr()+3)=='t');

   626 	test(*(buf.Ptr()+4)=='G');

   627 	}

   628 

   629 

   630 template<class T, class S, class L, class R>

   631 GLDEF_C void TestTDes<T,S,L,R>::TestH()

   632 //	TBufC descriptor assignment

   633 	{

   634 	R des(_TL("TestH"));

   635 	T buf;

   636 

   637 	test(buf.Length()==0);

   638 	buf=des;

   639 	buf.__DbgTestInvariant();

   640 	test(buf.Length()==5);

   641 	test(buf.Length()==des.Length());

   642 	test(*(buf.Ptr())=='T');

   643 	test(*(buf.Ptr()+1)=='e');

   644 	test(*(buf.Ptr()+2)=='s');

   645 	test(*(buf.Ptr()+3)=='t');

   646 	test(*(buf.Ptr()+4)=='H');

   647 	}

   648 

   649 template<class T, class S, class L, class R>

   650 GLDEF_C void TestTDes<T,S,L,R>::TestI()

   651 //	TBufC TBufC assignment

   652 	{

   653 	T oldBuf(_TL("TEsti"));

   654 	T newBuf;

   655 

   656 	test(newBuf.Length()==0);

   657 	newBuf=oldBuf;

   658 	newBuf.__DbgTestInvariant();

   659 	test(newBuf.Length()==5);

   660 	test(newBuf.Length()==oldBuf.Length());

   661 	test(*(newBuf.Ptr())=='T');

   662 	test(*(newBuf.Ptr()+1)=='E');

   663 	test(*(newBuf.Ptr()+2)=='s');

   664 	test(*(newBuf.Ptr()+3)=='t');

   665 	test(*(newBuf.Ptr()+4)=='i');

   666 	}

   667 

   668 template<class T,class S,class L,class R>

   669 GLDEF_C void TestTDes<T,S,L,R>::TestJ()

   670 //

   671 //	HBufC string assignment

   672 //

   673 	{

   674 

   675 	S* pString=_TL("tEStJ");

   676 	T* pBuf=NULL;

   677 	TRAPD(ret,pBuf=T::NewL(0x40))

   678 	test(ret==0);

   679 	test(pBuf!=NULL);

   680 	*pBuf=pString;

   681 	pBuf->__DbgTestInvariant();

   682 	test(pBuf->Length()==5);

   683 	test(*(pBuf->Ptr())=='t');

   684 	test(*(pBuf->Ptr()+1)=='E');	

   685 	test(*(pBuf->Ptr()+2)=='S');	

   686 	test(*(pBuf->Ptr()+3)=='t');	

   687 	test(*(pBuf->Ptr()+4)=='J');	

   688 	User::Free(pBuf);

   689 	}

   690 

   691 template<class T,class S,class L,class R>

   692 GLDEF_C void TestTDes<T,S,L,R>::TestK()

   693 //

   694 //	HBufC descriptor assignment

   695 //

   696 	{

   697 

   698 	R des(_TL("TestK"));

   699 	T* pBuf=NULL;

   700 	TRAPD(ret,pBuf=T::NewL(0x40))

   701 	test(ret==0);

   702 	test(pBuf!=NULL);

   703 	*pBuf=des;

   704 	pBuf->__DbgTestInvariant();

   705 	test(pBuf->Length()==5);

   706 	test(pBuf->Length()==des.Length());

   707 	test(*(pBuf->Ptr())=='T');

   708 	test(*(pBuf->Ptr()+1)=='e');	

   709 	test(*(pBuf->Ptr()+2)=='s');	

   710 	test(*(pBuf->Ptr()+3)=='t');	

   711 	test(*(pBuf->Ptr()+4)=='K');	

   712 	User::Free(pBuf);

   713 	}

   714 

   715 template<class T,class S,class L,class R>

   716 GLDEF_C void TestTDes<T,S,L,R>::TestL()

   717 //

   718 //	HBufC HBufC assignment

   719 //

   720 	{

   721 

   722 	S* pString=_TL("testl");

   723 	T* pOldBuf=NULL;

   724 	T* pNewBuf=NULL;

   725 	TRAPD(ret,pOldBuf=T::NewL(0x40))

   726 	test(ret==0);

   727 	TRAP(ret,pNewBuf=T::NewL(0x40))

   728 	test(ret==0);

   729 	test(pNewBuf!=NULL);

   730 	test(pOldBuf!=NULL);

   731 	*pOldBuf=pString;

   732 	*pNewBuf=*pOldBuf;

   733 	pOldBuf->__DbgTestInvariant();

   734 	pNewBuf->__DbgTestInvariant();

   735 	test(pNewBuf->Length()==5);

   736 	test(pOldBuf->Length()==pNewBuf->Length());

   737 	test(*(pNewBuf->Ptr())=='t');

   738 	test(*(pNewBuf->Ptr()+1)=='e');	

   739 	test(*(pNewBuf->Ptr()+2)=='s');	

   740 	test(*(pNewBuf->Ptr()+3)=='t');	

   741 	test(*(pNewBuf->Ptr()+4)=='l');	

   742 	User::Free(pOldBuf);

   743 	User::Free(pNewBuf);

   744 //

   745 	TRAP(ret,pOldBuf=T::NewMaxL(0x40))

   746 	test(ret==0);

   747 	TRAP(ret,pNewBuf=T::NewMaxL(0x40))

   748 	test(ret==0);

   749 	test(pNewBuf!=NULL);

   750 	test(pOldBuf!=NULL);

   751 	pOldBuf->__DbgTestInvariant();

   752 	pNewBuf->__DbgTestInvariant();

   753 	test(pNewBuf->Length()==0x40);

   754 	test(pOldBuf->Length()==0x40);

   755 	pNewBuf->Des().Zero();

   756 	pOldBuf->Des().Zero();

   757 	pOldBuf->__DbgTestInvariant();

   758 	pNewBuf->__DbgTestInvariant();

   759 	test(pNewBuf->Length()==0);

   760 	test(pOldBuf->Length()==0);

   761 	*pOldBuf=pString;

   762 	*pNewBuf=*pOldBuf;

   763 	pOldBuf->__DbgTestInvariant();

   764 	pNewBuf->__DbgTestInvariant();

   765 	test(pNewBuf->Length()==5);

   766 	test(pOldBuf->Length()==pNewBuf->Length());

   767 	test(*(pNewBuf->Ptr())=='t');

   768 	test(*(pNewBuf->Ptr()+1)=='e');	

   769 	test(*(pNewBuf->Ptr()+2)=='s');	

   770 	test(*(pNewBuf->Ptr()+3)=='t');	

   771 	test(*(pNewBuf->Ptr()+4)=='l');	

   772 	User::Free(pOldBuf);

   773 	User::Free(pNewBuf);

   774 	}

   775 

   776 template<class T,class S,class L,class R>

   777 GLDEF_C void TestTDes<T,S,L,R>::TestM()

   778 //

   779 //	HBufC ReAlloc

   780 //

   781 	{

   782 

   783 	S* pString=_TL("TESTM");

   784 	T* pBuf;

   785 	pBuf=T::NewL(0x40);

   786 	*pBuf=pString;

   787 	pBuf->ReAlloc(0x40);

   788 	test(pBuf!=NULL);

   789 	pBuf->__DbgTestInvariant();

   790 	test(pBuf->Length()==5);

   791 	test(*(pBuf->Ptr())=='T');

   792 	test(*(pBuf->Ptr()+1)=='E');	

   793 	test(*(pBuf->Ptr()+2)=='S');	

   794 	test(*(pBuf->Ptr()+3)=='T');	

   795 	test(*(pBuf->Ptr()+4)=='M');	

   796 	User::Free(pBuf);

   797 	}

   798 

   799 template<class T,class S,class L,class R>

   800 GLDEF_C void TestTDes<T,S,L,R>::TestN()

   801 //

   802 //	HBufC ReAllocL - forcing a leave

   803 //

   804 	{

   805 

   806 /*

   807 

   808     Reinstate if some method is found of forcing alloc fail

   809     This test no longer works due to heap growing functionality of E32 057

   810 

   811 	S* pString=_TL("tEStJ");

   812 	T* pBuf;

   813 	TInt available, temp;

   814 	TAny* pDummy;

   815 	pBuf=T::NewL(0x40);

   816 	test(pBuf!=NULL);

   817 	*pBuf=pString;

   818 	available=User::Available(temp);

   819 	pDummy=User::Alloc(available);

   820 	TRAPD(ret,pBuf->ReAllocL(0x50))

   821 	test(ret==KErrNoMemory);

   822 	User::Free(pDummy);

   823 	User::Free(pBuf);

   824 */

   825 	}

   826 

   827 template<class T,class S,class L,class R>

   828 GLDEF_C void TestTDes<T,S,L,R>::TestO()

   829 //	HBufC ReAllocL - forcing success

   830 	{

   831 

   832 	S* pString=_TL("tEStJ");

   833 	T* pBuf;

   834 	pBuf=T::NewL(0x40);

   835 	test(pBuf!=0);

   836 	*pBuf=pString;

   837 	TRAPD(ret,pBuf->ReAllocL(0x40))

   838 	test(ret==0);

   839 	test(pBuf!=NULL);

   840 	pBuf->__DbgTestInvariant();

   841 	test(pBuf->Length()==5);

   842 	test(*(pBuf->Ptr())=='t');

   843 	test(*(pBuf->Ptr()+1)=='E');	

   844 	test(*(pBuf->Ptr()+2)=='S');	

   845 	test(*(pBuf->Ptr()+3)=='t');	

   846 	test(*(pBuf->Ptr()+4)=='J');	

   847 	User::Free(pBuf);

   848 	}

   849 

   850 template<class T,class S,class L,class R>

   851 GLDEF_C void TestTDes<T,S,L,R>::TestP()

   852 //	Invariant for null pointer descriptor

   853 //	Added to reproduce DEF023302

   854 	{

   855 	T p(NULL, 0);

   856 	p.__DbgTestInvariant();

   857 	}

   858 

   859 GLDEF_C void TestCopy16()

   860 //	Test TPtr16 copy constructor

   861 	{

   862     TBuf16<0x20> buf(_S16("Paddington Station"));

   863 	TPtr16 ptr1((TText16*)buf.Ptr(),buf.Length(),buf.MaxLength());

   864 	ptr1.__DbgTestInvariant();

   865 	TPtr16 ptr2(ptr1);

   866 	ptr2.__DbgTestInvariant();

   867 	ptr2[11]='B';

   868 	ptr2[12]='e';

   869 	ptr2[13]='a';

   870 	ptr2[14]='r';

   871 	ptr2[15]=' ';

   872 	ptr1.SetLength(15);

   873 	ptr2.Append(_L16(" acid"));

   874 	test(ptr1==_L16("Paddington Bear"));

   875 	test(ptr2==_L16("Paddington Bear on acid"));

   876 	}

   877 

   878 GLDEF_C void Test16To8()

   879 //	Test ASCII dest with Unicode source

   880 	{

   881     TBuf8<0x20> buf(_S8("Paddington Station"));

   882 	TPtr8 ptr1((TText8*)buf.Ptr(),buf.Length(),buf.MaxLength());

   883 	ptr1.__DbgTestInvariant();

   884 	TPtr8 ptr2(ptr1);

   885 	ptr2.__DbgTestInvariant();

   886 	ptr2[11]='B';

   887 	ptr2[12]='e';

   888 	ptr2[13]='a';

   889 	ptr2[14]='r';

   890 	ptr2[15]=' ';

   891 	ptr1.SetLength(15);

   892 	ptr1.__DbgTestInvariant();

   893 	ptr2.Append(_L16(" acid"));

   894 	ptr2.__DbgTestInvariant();

   895 	test(ptr1==_L8("Paddington Bear"));

   896 	test(ptr2==_L8("Paddington Bear on acid"));

   897 	}

   898 

   899 

   900 GLDEF_C void TestCopy8()

   901 //	Test TPtr8 copy constructor

   902 	{

   903     TBuf8<0x20> buf(_S8("Paddington Station"));

   904 	TPtr8 ptr1((TText8*)buf.Ptr(),buf.Length(),buf.MaxLength());

   905 	TPtr8 ptr2(ptr1);

   906 	ptr2[11]='B';

   907 	ptr2[12]='e';

   908 	ptr2[13]='a';

   909 	ptr2[14]='r';

   910 	ptr2[15]=' ';

   911 	ptr1.SetLength(15);

   912 	ptr2.Append(_L8(" acid"));

   913 	ptr1.__DbgTestInvariant();

   914 	ptr2.__DbgTestInvariant();

   915 	test(ptr1==_L8("Paddington Bear"));

   916 	test(ptr2==_L8("Paddington Bear on acid"));

   917 	}

   918 

   919 GLDEF_C void TestCopy()

   920 //	Test TPtr copy constructor

   921 	{

   922     TBuf<0x20> buf(_S("Paddington Station"));

   923 	TPtr ptr1((TText*)buf.Ptr(),buf.Length(),buf.MaxLength());

   924 	TPtr ptr2(ptr1);

   925 	ptr2[11]='B';

   926 	ptr2[12]='e';

   927 	ptr2[13]='a';

   928 	ptr2[14]='r';

   929 	ptr2[15]=' ';

   930 	ptr1.SetLength(15);

   931 	ptr2.Append(_L(" acid"));

   932 	ptr1.__DbgTestInvariant();

   933 	ptr2.__DbgTestInvariant();

   934 	test(ptr1==_L("Paddington Bear"));

   935 	test(ptr2==_L("Paddington Bear on acid"));

   936 	}

   937 

   938 template<class T, class S, class L, class R>

   939 GLDEF_C void TestTDes<T,S,L,R>::test_TPtrC()

   940 //

   941 // Test the TDesC class special member functions

   942 //

   943 	{

   944 

   945  	test.Start(_L("Invariant for null pointer descriptor"));

   946  	TestP();

   947 	test.Next(_L("R/O view over constant string"));

   948 	Test1();

   949 	test.Next(_L("R/O view over constant descriptor"));

   950 	Test2();

   951 	test.Next(_L("R/O view over constant buffer with length"));

   952 	Test3();

   953 	}

   954 

   955 template<class T, class S, class L, class R>

   956 GLDEF_C void TestTDes<T,S,L,R>::test_TPtr()

   957 //

   958 //	Test the TPtr class special member functions

   959 //

   960 	{

   961 

   962  	test.Start(_L("Invariant for null pointer descriptor"));

   963  	TestP();

   964 	test.Next(_L("R/W view over buffer with length & maxlength"));

   965 	Test4();

   966 	test.Next(_L("R/W view over buffer with maxlength"));

   967 	Test5();

   968 //	Skipped the following test because Colly hasn't

   969 //	written the templates yet for the TBufC8 & 16 classes

   970 //	test.Next(_L("R/W view over LcbBase with maxlength"));

   971 //	Test6();

   972 	test.Next(_L("String assignment"));

   973 	TestA();

   974 	test.Next(_L("DesW assignment"));

   975 	TestB();

   976 	test.Next(_L("DesC assignment"));

   977 	TestC();

   978 	}

   979 

   980 template<class T, class S, class L, class R>

   981 GLDEF_C void TestTDes<T,S,L,R>::test_TBuf()

   982 //

   983 // Test the TBuf class special member functions

   984 //

   985 	{

   986 

   987 	test.Start(_L("TBuf default view, no params"));

   988 	Test7();

   989 	test.Next(_L("TBuf view with a length"));

   990 	Test8();

   991 	test.Next(_L("TBuf view over a string"));

   992 	Test9();

   993 	test.Next(_L("TBuf view over a descriptor"));

   994 	Test10();

   995 	test.Next(_L("TBuf view over a buffer"));

   996 	Test11();

   997 	test.Next(_L("String assignment"));

   998 	TestD();

   999 	test.Next(_L("Descriptor assignment"));

  1000 	TestE();

  1001 	test.Next(_L("Buffer assignment"));

  1002 	TestF();

  1003 	}

  1004 

  1005 template<class T,class S,class L,class R>

  1006 GLDEF_C void TestTDes<T,S,L,R>::test_TBufC()

  1007 //

  1008 // Test the TBufC class methods

  1009 //

  1010 	{

  1011 

  1012 	test.Start(_L("Default constructor"));

  1013 	Test12();

  1014 	test.Next(_L("With a string"));

  1015 	Test13();

  1016 	test.Next(_L("With a Descriptor (TPtrC)"));

  1017 	Test14();

  1018 	test.Next(_L("With a TBufC"));

  1019 	Test15();

  1020 	test.Next(_L("String assignment"));

  1021 	TestG();

  1022 	test.Next(_L("Descriptor assignment (TPtrC)"));

  1023 	TestH();

  1024 	test.Next(_L("TBufC assignment"));

  1025 	TestI();

  1026 	}

  1027 

  1028 template<class T,class S,class L,class R>

  1029 GLDEF_C void TestTDes<T,S,L,R>::test_HBufC()

  1030 //

  1031 //	Test the HBufC class methods.

  1032 //

  1033 	{

  1034 

  1035 	test.Start(_L("New"));

  1036 	Test16();

  1037 	test.Next(_L("NewL - forcing a leave"));

  1038 	Test17();

  1039 	test.Next(_L("NewL - showing success"));

  1040 	Test18();

  1041 	test.Next(_L("String assignment"));

  1042 	TestJ();

  1043 	test.Next(_L("Descriptor assignment"));

  1044 	TestK();

  1045 	test.Next(_L("HBufC assignment"));

  1046 	TestL();

  1047 	test.Next(_L("ReAlloc"));

  1048 	TestM();

  1049 	test.Next(_L("ReAllocL - forcing a leave"));

  1050 	TestN();

  1051 	test.Next(_L("ReAllocL - showing success"));

  1052 	TestO();

  1053 	}

  1054 

  1055 template<class T,class S,class L,class R>

  1056 GLDEF_C void TestTDes<T,S,L,R>::test_TBufReturningModifiable()

  1057 	{

  1058 	T a;

  1059 	R b(0,0);

  1060 	a.Copy(_TL("abcdefg"));

  1061 	test_TDesReturningModifiable(a,b);

  1062 	}

  1063 

  1064 template<class T,class S,class L,class R>

  1065 GLDEF_C void TestTDes<T,S,L,R>::test_TPtrReturningModifiable()

  1066 	{

  1067 	S* aBuf;

  1068 	aBuf=_TL("abcdefg");

  1069 	T a(aBuf,7,7);

  1070 	R b(0,0);

  1071 	test_TDesReturningModifiable(a,b);

  1072 	}

  1073 

  1074 template<class T,class S,class L,class R>

  1075 GLDEF_C void TestTDes<T,S,L,R>::test_TDesReturningModifiable(const T& a, R& b)

  1076 	{

  1077 	test.Start(_L("Test TDes derived objects that return TPtrs"));

  1078 

  1079 	test.Next(_L("LeftTPtr"));

  1080 	b.Set(a.LeftTPtr(3));

  1081 	b.__DbgTestInvariant();

  1082 	test(b == a.Left(3));

  1083 

  1084 	b.Set(a.LeftTPtr(0));

  1085 	b.__DbgTestInvariant();

  1086 	test(b == a.Left(0));

  1087 

  1088 	b.Set(a.LeftTPtr(7));

  1089 	b.__DbgTestInvariant();

  1090 	test(b == a.Left(7));

  1091 

  1092 	b = a.LeftTPtr(42);

  1093 	b.__DbgTestInvariant();

  1094 	test(b == a.Left(7));

  1095 

  1096 	test.Next(_L("RightTPtr"));

  1097 	b.Set(a.RightTPtr(5));

  1098 	b.__DbgTestInvariant();

  1099 	test(b == a.Right(5));

  1100 

  1101 	b.Set(a.RightTPtr(7));

  1102 	b.__DbgTestInvariant();

  1103 	test(b == a.Right(7));

  1104 

  1105 	b.Set(a.RightTPtr(0));

  1106 	b.__DbgTestInvariant();

  1107 	test(b == a.Right(0));

  1108 

  1109 	b.Set(a.RightTPtr(42));

  1110 	b.__DbgTestInvariant();

  1111 	test(b == a.Right(42));

  1112 

  1113 	test.Next(_L("MidTPtr"));

  1114 	b.Set(a.MidTPtr(5));

  1115 	b.__DbgTestInvariant();

  1116 	test(b == a.Mid(5));

  1117 

  1118 	b.Set(a.MidTPtr(7));

  1119 	b.__DbgTestInvariant();

  1120 	test(b == a.Mid(7));

  1121 

  1122 	b.Set(a.MidTPtr(0));

  1123 	b.__DbgTestInvariant();

  1124 	test(b == a.Mid(0));

  1125 

  1126 	test.Next(_L("MidTPtr (2 parms)"));

  1127 	b.Set(a.MidTPtr(4,3));

  1128 	b.__DbgTestInvariant();

  1129 	test(b == a.Mid(4,3));

  1130 	test(b == a.Mid(4));

  1131 

  1132 	b.Set(a.MidTPtr(0,0));

  1133 	b.__DbgTestInvariant();

  1134 	test(b == a.Mid(0,0));