1 // Copyright (c) 2008-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 "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Overview:

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

    16 // API Information:

    17 // LString16, LString8, LString 

    18 // Details :

    19 // - Create some 16 bit modifiable descriptors, 8 bit modifiable descriptors

    20 // of fixed length, Build-independent modifiable descriptors, initialize 

    21 // with different strings and check for

    22 // - Comparison operators,

    23 // - Property access methods,

    24 // - Fill & swap methods,

    25 // - Conversion methods,

    26 // - Comparison methods,

    27 // - Pattern Matching methods,

    28 // - Pattern Locating methods,

    29 // - Copying methods, 

    30 // - Find, FindC, FindF methods,

    31 // - Repeat, Trim, TrimLeft, TrimRight, Insert, Delete, Left,

    32 // Right, Mid methods,

    33 // - Formatting methods,

    34 // - Replace methods are as expected.

    35 // - Construct some descriptors with buffer length, string and buffer reference and

    36 // verify that they are created successfully.

    37 // - Test assignment operators and comparison operators for different descriptors.

    38 // - Initialize some descriptors and check descriptors' maximum length, length and 

    39 // size are as expected. 

    40 // - Check Fill and Swap methods are as expected.

    41 // - Test Fold, Collate, LowerCase, UpperCase methods are as expected.

    42 // - Test Comparison methods are as expected.

    43 // - Test pattern matching for simple string, wild cards with collated comparison. Verify that the 

    44 // return value is KErrNotFound when pattern doesn't match.

    45 // - Check Locating methods by searching character in forward and backward direction and 

    46 // verify the return value is KErrNotFound when unavailable character is searched.

    47 // - Check copying strings and converting those into lower and upper case strings are

    48 // as expected.

    49 // - Check Find methods by searching string and verify the return value is KErrNotFound when 

    50 // unavailable string is searched.

    51 // - Check Repeat, Trim, Insert and Delete methods are as expected.

    52 // - Check the formatting operations are as expected.

    53 // - Check integer to decimal character representation is as expected.

    54 // - Check integer to character representation with different number system is as expected.

    55 // - Check string formatting with variable parameter list is as expected

    56 // - Check Replace method by replacing string at different places in a string is as expected.

    57 // - Check the conversion of real numbers, extended precision real numbers into string

    58 // format is as expected.

    59 // - Check Format and FormatList methods are as expected.

    60 // - Check Format of TReal is as expected.

    61 // - Check the non-leaving and leaving descriptors overflow handlers are as expected. 

    62 // Platforms/Drives/Compatibility:

    63 // All 

    64 // Assumptions/Requirement/Pre-requisites:

    65 // Failures and causes:

    66 // Base Port information:

    67 // 

    68 //

    69 

    70 #include <e32test.h>

    71 #include <e32math.h>

    72 #include <hal.h>

    73 #include <hal_data.h>

    74 #include <hal_data.h>

    75 #include <e32svr.h>

    76 #include <estring.h>

    77 

    78 #ifdef __VC32__

    79     // Solve compilation problem caused by non-English locale

    80     #pragma setlocale("english")

    81 #endif

    82 

    83 LOCAL_D RTest test(_L("T_LSFORMAT"));

    84 

    85 #pragma warning(disable: 4127) // disabling warning "conditional expression is constant"

    86 #pragma warning(disable: 4310) // disabling warning "cast truncates constant value"

    87 

    88 #undef _TL

    89 #define _TL(a) DESTEMPLATE((S*)RTest::String(sizeof(S),(TText8*)a,(TText16*)L ## a)) 

    90 #undef _TS

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

    92 

    93 template<class T,class S,class DESTEMPLATE>	

    94 class TestLString

    95 	{

    96 public:

    97 	TestLString(TInt aLength); // Test class constructor.

    98 	void Test1L();   // Tests all functions of the class with auto extension

    99 	void Test2();   // Tests all constructors.

   100 	void Test3();	// Tests all assignment operators

   101 	void Test4();	// Tests all comparison operators

   102 	void Test7();	// Tests all conversion 

   103 	void Test8();	// Tests all comparison

   104 	void Test9();	// Tests all matching

   105 	void Test10();	// Tests all locating

   106 	void Test11L();	// Tests all Copying

   107 	void Test12();	// Tests all finding

   108 	void Test13L();	// Tests all basic like ops

   109 	void Test14L();  // Tests all formating with auto extension 

   110 	void Test15L();  // Tests all replacing with auto extension 

   111 	void test_TBufL(); // Test all classes

   112 protected:

   113 	void Test14_ReorderedParameterFormatting(TInt aDummyParameter, ...);

   114 	void Test14_ReorderedParameterFormattingL(TInt aDummyParameter, ...);

   115 private:

   116 	TInt iMaxBufLength;

   117 	};

   118 

   119 template<class T>

   120 void TestEq(const T& a, const T& b, TInt aLine)

   121 	{

   122 	if (a!=b)

   123 		{

   124 		LString16 buf(256);

   125 		test.Printf(_L("LINE %d:\n"),aLine);

   126 		buf.CopyL(a);

   127 		test.Printf(_L("a=%S\n"),&buf);

   128 		buf.CopyL(b);

   129 		test.Printf(_L("b=%S\n"),&buf);

   130 		test(0);

   131 		}

   132 	}

   133 

   134 

   135 #define TESTEQ(a,b)	TestEq<T>((a),(b),__LINE__)

   136 

   137 template <class T,class S,class DESTEMPLATE>

   138 GLDEF_C TestLString<T,S,DESTEMPLATE>::TestLString(TInt aLength)

   139 // Constructor.

   140 	: iMaxBufLength(aLength)

   141 	{}

   142 

   143 /**

   144 @SYMTestCaseID SYSLIB-EUSERHL-UT-4011

   145 @SYMTestCaseDesc Tests LString Auto-extending functions 

   146 @SYMTestPriority High

   147 @SYMTestActions Creates LString objects and uses the auto-extending LString 

   148 				functions to manipulate the strings.

   149 				Verifies that the LStrings are auto-extended as expected.

   150 @SYMTestExpectedResults The LString objects should be auto-extended as required to

   151 				contain any new data.

   152 @SYMREQ	10372-3

   153 */

   154 template <class T,class S,class DESTEMPLATE>

   155 GLDEF_C void TestLString<T,S,DESTEMPLATE>::Test1L()

   156 	{

   157 	

   158 	test.Start(_L ("@SYMTestCaseID:SYSLIB-EUSERHL-UT-4011"));

   159 	

   160 	test.Next(_L("Extending Methods"));

   161 

   162 	T a(1);

   163 	T b(1);

   164 

   165 	test(a.Length()==0);

   166 	test(a.MaxLength() >=1);

   167 

   168 	test.Next(_L("Setting a bigger length "));

   169 	a.SetLengthL(10);

   170 	test(a.Length()== 10);

   171 	test(a.MaxLength() >= 10);

   172 

   173 	test.Next(_L("operator+ with memory extension "));

   174 	test(b.MaxLength() >=1);

   175 	b += a;

   176 	test(b.Length()== 10);

   177 	test(b.MaxLength() >= 10);

   178 	

   179 	TChar c('A');

   180 	test(b.MaxLength() >=1);

   181 	b += c;

   182 	test(b.Length()== 11);

   183 	test(b.MaxLength() >= 10);

   184 

   185 	test.Next(_L("Filling past current size "));

   186 	a.FillL(' ', 20);

   187 	test(a.Length()== 20);

   188 	test(a.MaxLength() >= 20);

   189 

   190 	test.Next(_L("Append filling past current size "));

   191 	a.AppendFillL(' ', 10);

   192 	test(a.Length()== 30);

   193 	test(a.MaxLength() >= 30);

   194 

   195 	test.Next(_L("Zeroing past current size "));

   196 	a.FillZL(40);

   197 	test(a.Length()== 40);

   198 	test(a.MaxLength() >= 40);

   199 

   200 	test.Next(_L("Entended Copying"));

   201 	a.CopyL(b);

   202 	test(a == b);

   203 

   204 	a.CopyL(_TL("AB"));

   205 	test(a == _TL("AB"));

   206 

   207 	a.CopyFL(b);

   208 	

   209 	T d(b);

   210 	d.Fold();

   211 	test(a == d);

   212 

   213 	a.CopyFL(_TL("AB"));

   214 	test(a == _TL("ab"));

   215 

   216 	a.CopyCL(b);

   217 

   218 	d = b;

   219 	d.Collate();

   220 	test(a == d);

   221 

   222 	a.CopyCL(_TL("AB"));

   223 	test(a == _TL("ab"));

   224 

   225 	a.CopyLCL(b);

   226 

   227 	d = b;

   228 	d.LowerCase();

   229 	test(a == d);

   230 

   231 	a.CopyLCL(_TL("AB"));

   232 	test(a == _TL("ab"));

   233 

   234 	a.CopyUCL(b);

   235 

   236 	d = b;

   237 	d.UpperCase();

   238 	test(a == d);

   239 

   240 	a.CopyUCL(_TL("AB"));

   241 	test(a == _TL("AB"));

   242 

   243 	a.CopyCPL(b);

   244 

   245 	d = b;

   246 	d.Capitalize();

   247 	test(a == d);	

   248 	

   249 	a.CopyCPL(_TL("AB"));

   250 	test(a == _TL("Ab"));

   251 

   252 	test.Next(_L("Basic like ops"));

   253 

   254 	a.Zero();

   255 	b=_TL("AA");

   256 	a.InsertL(0,b);

   257 	test(a == b);

   258 

   259 	test.Next(_L("Formating"));

   260 	a.JustifyL(_TL("AB"),10,ELeft,' ');

   261 	test(a == _TL("AB        "));

   262 	

   263 	a.JustifyL(b,10,ELeft,' ');

   264 	test(a == _TL("AA        "));

   265 

   266 	b.FillL('A',2);

   267 	test(b == _TL("AA"));

   268 

   269 	a.Zero();

   270 	a.AppendJustifyL(_TL("AB"),10,ELeft,' ');

   271 	test(a == _TL("AB        "));

   272 	

   273 	a.AppendJustifyL(b,10,ELeft,' ');

   274 	test(a == _TL("AB        AA        "));

   275 		

   276 	DESTEMPLATE des(b);

   277 	a.Zero();

   278 	a.AppendJustifyL(des,2,10,ELeft,' ');

   279 	test(a == _TL("AA        "));

   280 	

   281 	a.AppendJustifyL(des,2,KDefaultJustifyWidth ,ELeft,' ');

   282 	test(a == _TL("AA        AA"));

   283 	

   284 	a.Zero();

   285 	a.AppendJustifyL(des,10,ELeft,' ');

   286 	test(a == _TL("AA        "));

   287 	

   288 	a.AppendJustifyL(des,KDefaultJustifyWidth ,ELeft,' ');

   289 	test(a == _TL("AA        AA"));

   290 	

   291 	a.Zero();

   292 	a.AppendJustifyL(b.PtrZL(),10,ELeft,' ');

   293 	test(a == _TL("AA        "));

   294 	

   295 	a.AppendJustifyL(b.PtrZL(),KDefaultJustifyWidth,ELeft,' ');

   296 	test(a == _TL("AA        AA"));

   297 	

   298 	a.AppendJustifyL(b.PtrZL(),2,KDefaultJustifyWidth,ELeft,' ');

   299 	test(a == _TL("AA        AAAA"));

   300 	

   301 	a.Zero();

   302 	a.AppendJustifyL(b.PtrZL(),2,10,ELeft,' ');

   303 	test(a == _TL("AA        "));

   304 	

   305 	a.AppendJustifyL(b.PtrZL(),2,5,ELeft,' ');

   306 	test(a == _TL("AA        AA   "));

   307 

   308 	TInt v1=10;

   309 	a.NumL(v1);

   310 	test(a == _TL("10"));

   311 	a.AppendNumL(v1);

   312 	test(a == _TL("1010"));

   313 

   314 	TInt v2=10;

   315 	a.NumL((TUint)v2,EHex);

   316 	test(a == _TL("a"));

   317 	a.AppendNumL((TUint)v2,EHex);

   318 	test(a == _TL("aa"));

   319 

   320 	a.NumUCL((TUint)v2,EHex);

   321 	test(a == _TL("A"));

   322 	a.AppendNumUCL((TUint)v2,EHex);

   323 	test(a == _TL("AA"));

   324 	

   325 	a.NumFixedWidthL((TUint)v2,EHex,1);

   326 	test(a == _TL("a"));

   327 	a.AppendNumFixedWidthL((TUint)v2,EHex,1);

   328 	test(a == _TL("aa"));

   329 	

   330 	a.NumFixedWidthUCL((TUint)v2,EHex,1);

   331 	test(a == _TL("A"));

   332 	a.AppendNumFixedWidthUCL((TUint)v2,EHex,1);

   333 	test(a == _TL("AA"));

   334 

   335 	TReal v3=10.0;

   336 	TRealFormat ff;

   337 	ff.iType=KRealFormatFixed;

   338 	ff.iWidth=10;

   339 	ff.iPlaces=2;

   340 	ff.iPoint='.';

   341 	ff.iTriad=',';

   342 	ff.iTriLen=3;

   343 	a.NumL(v3,ff);

   344 	test(a == _TL("10.00"));

   345 	

   346 	a.AppendNumL(v3,ff);

   347 	test(a == _TL("10.0010.00"));

   348 	

   349 	a.FormatL(_TL("%d"),12);

   350 	test(a == _TL("12"));

   351 	

   352 	a.AppendFormatL(_TL("%d"),12);

   353 	test(a == _TL("1212"));

   354 

   355 	b=_TL("%d");

   356 	a.FormatL(b,12);

   357 	test(a == _TL("12"));

   358 	a.AppendFormatL(b,12);

   359 	test(a == _TL("1212"));

   360 	//*/

   361 	

   362 	test.Next(_L("Replacing"));

   363 	a=_TL("AAC");

   364 	b=_TL("B");

   365 	a.ReplaceL(1,1,b);

   366 	test(a == _TL("ABC"));

   367 	

   368 	test.End();

   369 	}

   370 

   371 

   372 

   373 /**

   374 @SYMTestCaseID SYSLIB-EUSERHL-UT-4012

   375 @SYMTestCaseDesc Tests all LString Constructors

   376 @SYMTestPriority High

   377 @SYMTestActions Creates LString objects using the different constructors.

   378 				Verifies that length and contents are as expected

   379 @SYMTestExpectedResults LString objects should be created with the correct 

   380 				Length and contents

   381 @SYMREQ	10372

   382 */

   383 template <class T,class S,class DESTEMPLATE>

   384 GLDEF_C void TestLString<T,S,DESTEMPLATE>::Test2()

   385 // Tests all constructors.

   386 	{

   387 	

   388 	test.Start (_L ("@SYMTestCaseID:SYSLIB-EUSERHL-UT-4012"));

   389 	

   390 	test.Next(_L("Default"));

   391 	

   392 	T a(iMaxBufLength);

   393 	test(a.MaxLength() >=iMaxBufLength);

   394 	test(a.Length()==0);

   395 

   396 	test.Next(_L("By string"));

   397 	T c(iMaxBufLength);

   398 	c = _TL("AB");

   399 	test(c.Length()==2);

   400 	test(c[0]=='A');

   401 	test(c[1]=='B');

   402 

   403 	test.Next(_L("By buffer reference"));

   404 	T d(iMaxBufLength);

   405 	d = c;

   406 	test(d.Length()==2);

   407 	test(d[0]=='A');

   408 	test(d[1]=='B');

   409 	

   410 	test.End();

   411 	}

   412 

   413 /**

   414 @SYMTestCaseID SYSLIB-EUSERHL-UT-4013

   415 @SYMTestCaseDesc Tests all LString Assignment operators

   416 @SYMTestPriority High

   417 @SYMTestActions Creates LString objects and uses the different assignment 

   418 				operators to change the string contents

   419 				Verifies that length and contents are as expected

   420 @SYMTestExpectedResults LString data should be assigned as expected

   421 @SYMREQ	10372

   422 */

   423 template <class T,class S,class DESTEMPLATE>

   424 GLDEF_C void TestLString<T,S,DESTEMPLATE>::Test3()

   425 // Tests all assignment operators

   426 	{

   427 	

   428 	test.Start (_L ("@SYMTestCaseID:SYSLIB-EUSERHL-UT-4013"));

   429 	

   430 	test.Next(_L("By String"));

   431 	

   432 	T a;

   433 	a=_TL("AB");

   434 	a+=_TL("CD");

   435 	test(a.Length()==4);

   436 	test(a==_TL("ABCD"));

   437 

   438 	test.Next(_L("By buffer"));

   439 	T b;

   440 	b=a;

   441 	b+=a;

   442 	test(b.Length()==8);

   443 	test(b==_TL("ABCDABCD"));

   444 //	

   445 	test.End();

   446 	}

   447 

   448 /**

   449 @SYMTestCaseID SYSLIB-EUSERHL-UT-4014

   450 @SYMTestCaseDesc Tests all LString comparison operators

   451 @SYMTestPriority High

   452 @SYMTestActions Creates LString objects and uses the different comparison 

   453 				operators to compare string contents against other strings 

   454 				Verifies that comparison operators work as expected

   455 @SYMTestExpectedResults LString data comparison should work as expected

   456 @SYMREQ	10372

   457 */

   458 template <class T,class S,class DESTEMPLATE>

   459 GLDEF_C void TestLString<T,S,DESTEMPLATE>::Test4()

   460 // Test all comparison operators

   461 	{

   462 	

   463 	test.Start (_L ("@SYMTestCaseID:SYSLIB-EUSERHL-UT-4014"));

   464 	

   465 	test.Next(_L("By NULL string"));

   466 	

   467 	T a;

   468 	test(a==_TL(""));		// NULL strings

   469 	test(!(a!=_TL("")));

   470 	test(a<=_TL(""));

   471 	test(a>=_TL(""));

   472 	test(!(a<_TL("")));

   473 	test(!(a>_TL("")));

   474 	test(_TL("")==a);

   475 	test(!(_TL("")!=a));

   476 	test(_TL("")<=a);

   477 	test(_TL("")>=a);

   478 	test(!(_TL("")<a));

   479 	test(!(_TL("")>a));

   480 

   481 	test.Next(_L("By string or buffer"));

   482 	a=_TL("abc");

   483 	test(a==_TL("abc"));		// ==

   484 	test(!(a==_TL("xyz")));

   485 	test(!(a==_TL("aa")));

   486 	test(_TL("abc")==a);

   487 	test(!(_TL("xyz")==a));

   488 	test(!(_TL("aa")==a));

   489 	test(a!=_TL("xyz"));		// !=

   490 	test(!(a!=_TL("abc")));

   491 	test(a!=_TL("aa"));

   492 	test(_TL("xyz")!=a);

   493 	test(!(_TL("abc")!=a));

   494 	test(_TL("aa")!=a);

   495 	test(a<_TL("x"));			// <

   496 	test(!(a<_TL("abc")));

   497 	test(!(a<_TL("aa")));

   498 	test(_TL("aa")<a);

   499 	test(!(_TL("abc")<a));

   500 	test(!(_TL("xyz")<a));

   501 	test(a>_TL("aa"));			// >

   502 	test(!(a>_TL("abc")));

   503 	test(!(a>_TL("xyz")));

   504 	test(_TL("xyz")>a);

   505 	test(!(_TL("abc")>a));

   506 	test(!(_TL("aa")>a));

   507 	test(a>=_TL("abc"));		// >=

   508 	test(!(a>=_TL("xyz")));

   509 	test(a>=_TL("aa"));

   510 	test(_TL("abc")>=a);

   511 	test(!(_TL("aaa")>=a));

   512 	test(_TL("xyz")>=a);

   513 	test(a<=_TL("abc"));		// <=

   514 	test(!(a<=_TL("aa")));

   515 	test(a<=_TL("xyz"));

   516 	test(_TL("abc")<=a);

   517 	test(!(_TL("xyz")<=a));

   518 	test(_TL("aa")<=a);

   519 

   520 	test.Next(_L("By special characters"));

   521 	a=_TL("!@#$%^&*()");

   522 	test(a==_TL("!@#$%^&*()"));

   523 	

   524 	test.End();	

   525 	}

   526 

   527 /**

   528 @SYMTestCaseID SYSLIB-EUSERHL-UT-4015

   529 @SYMTestCaseDesc Tests all LString conversion methods

   530 @SYMTestPriority High

   531 @SYMTestActions Creates LString objects and uses the different conversion 

   532 				methods to fold, collate and change case.

   533 				Verifies that conversion methods work as expected.

   534 @SYMTestExpectedResults LString data conversion methods should work as expected

   535 @SYMREQ	10372

   536 */

   537 template <class T,class S,class DESTEMPLATE>

   538 GLDEF_C void TestLString<T,S,DESTEMPLATE>::Test7()

   539 // Conversion operators

   540 	{

   541 	

   542 	test.Start (_L ("@SYMTestCaseID:SYSLIB-EUSERHL-UT-4015"));

   543 	

   544 	test.Next(_L("Fold, collate ..."));

   545 	

   546 	T a;

   547 	T b;

   548 	a=_TL("abc AbC");

   549 	b=_TL("ABC ABC");

   550 	a.Fold();

   551 	b.Fold();

   552 	test(a==b);

   553 	a=_TL("abc AbC");

   554 	b=_TL("ABC ABC");

   555 	a.Collate();

   556 	b.Collate();

   557 	test(a==b);

   558 	a.LowerCase();

   559 	test(a==_TL("abc abc"));

   560 	a.Capitalize();

   561 	test(a==_TL("Abc abc"));

   562 	a.UpperCase();

   563 	test(a==_TL("ABC ABC"));

   564 	

   565 	test.End();

   566 	}

   567 

   568 /**

   569 @SYMTestCaseID SYSLIB-EUSERHL-UT-4016

   570 @SYMTestCaseDesc Tests LString Compare() method

   571 @SYMTestPriority High

   572 @SYMTestActions Creates LString objects and uses the Compare()

   573 				method to compare string contents against other strings 

   574 				Verifies that comparison method works as expected

   575 @SYMTestExpectedResults LString Compare() method should return a positive 

   576 				value if this LString is greater than the specified descriptor. 

   577 				Negative if this LString is less than the specified descriptor. 

   578 				Zero if both descriptors have the same length and the their 

   579 				contents are the same.

   580 @SYMREQ	10372

   581 */

   582 template <class T,class S,class DESTEMPLATE>

   583 GLDEF_C void TestLString<T,S,DESTEMPLATE>::Test8()

   584 // Comparison

   585 	{

   586 	

   587 	test.Start (_L ("@SYMTestCaseID:SYSLIB-EUSERHL-UT-4016"));

   588 	

   589 	test.Next(_L("By string"));

   590 	

   591 	T a(iMaxBufLength);

   592 	a=_TL("abc AbC");

   593 	test(a.Compare(_TL("abc AbC"))==0);

   594 	test(a.CompareF(_TL("ABC aBc"))==0);

   595 	test(a.Compare(_TL("xyz"))!=0);

   596 	test(a.CompareC(_TL("xyz"))!=0);

   597 	test(a.CompareF(_TL("xyz"))!=0);

   598 

   599 	test.Next(_L("By buffer"));

   600 	T b;

   601 	T c;

   602 	a=_TL("abc AbC");

   603 	b=_TL("abc AbC");

   604 	c=_TL("xyz");

   605 	test(a.Compare(b)==0);

   606 	test(a.Compare(c)!=0);

   607 	b=_TL("ABC aBc");

   608 	test(a.CompareC(c)!=0);

   609 	test(a.CompareF(b)==0);

   610 	test(a.CompareF(c)!=0);

   611 

   612 	test.End();

   613 	}

   614 

   615 /**

   616 @SYMTestCaseID SYSLIB-EUSERHL-UT-4017

   617 @SYMTestCaseDesc Tests LString MatchX() methods

   618 @SYMTestPriority High

   619 @SYMTestActions Creates LString objects and uses the MatchX()

   620 				methods to compare string contents against other strings 

   621 				Verifies that MatchX methods work as expected

   622 @SYMTestExpectedResults LString MatchX() methods should compare string 

   623 				contents and return the index of the first match, 

   624 				or KErrNotFound if there is no match.

   625 @SYMREQ	10372

   626 */

   627 template <class T,class S,class DESTEMPLATE>

   628 GLDEF_C void TestLString<T,S,DESTEMPLATE>::Test9()

   629 // Matching (need to test explicit result as error KErrNotFound = KMaxTUint

   630 // 			 and so registers as TRUE. (test parameter is TUint) )

   631 	{

   632 	

   633 	test.Start (_L ("@SYMTestCaseID:SYSLIB-EUSERHL-UT-4017"));

   634 	

   635 	test.Next(_L("By string"));

   636 	

   637 	T a(iMaxBufLength);

   638 	a=_TL("abc AbC");

   639 	test(a.Match(_TL("abc AbC"))==0);

   640 	test(a.MatchC(_TL("ABC aBc"))==0);

   641 	test(a.MatchF(_TL("ABC aBc"))==0);

   642 	test(a.Match(_TL("xyz"))==KErrNotFound);

   643 	test(a.MatchC(_TL("xyz"))==KErrNotFound);

   644 	test(a.MatchF(_TL("xyz"))==KErrNotFound);

   645 

   646 	test.Next(_L("By buffer"));

   647 	T b;

   648 	T c;

   649 	a=_TL("abc AbC");

   650 	b=_TL("abc AbC");

   651 	c=_TL("xyz");

   652 	test(a.Match(b)==0);

   653 	test(a.Match(c)==KErrNotFound);

   654 	b=_TL("ABC aBc");

   655 	test(a.MatchC(b)==0);

   656 	test(a.MatchC(c)==KErrNotFound);

   657 	test(a.MatchF(b)==0);

   658 	test(a.MatchF(c)==KErrNotFound);

   659 

   660 	test.Next(_L("Wildcards"));

   661 	a=_TL("abcxyz");

   662 	test(a.Match(_TL("abc*"))==0);

   663 	test(a.Match(_TL("abw*"))==KErrNotFound);

   664 	a=_TL("abcdefg");

   665 	test(a.Match(_TL("a*fg"))==0);

   666 	test(a.Match(_TL("a*f"))==KErrNotFound);

   667 	test(a.Match(_TL("abc*fgh"))==KErrNotFound);

   668 	a=_TL("abcdef");

   669 	test(a.Match(_TL("abc?ef"))==0);

   670 	test(a.Match(_TL("abc?xf"))==KErrNotFound);

   671 

   672 	a=_TL("a(01)");

   673 	test(a.Match(_TL("*(01)"))==1);

   674 	test(a.Match(_TL("?(01)"))==0);

   675 	test(a.Match(_TL("?(*)"))==0);

   676 	test(a.Match(_TL("?(**)"))==0);

   677 

   678 	test(a.Match(_TL("?(\?\?)"))==0);

   679 	test(a.Match(_TL("*(*)"))>=0);

   680 	test(a.Match(_TL("*(0?)"))>=0);

   681 	test(a.Match(_TL("a(\?\?)"))==0);

   682 	test(a.Match(_TL("*(\?\?)"))>=0);

   683 

   684 	test.Next(_L("wild cards with collated comparison"));

   685 	a = _TL("abcdefghijkl");

   686 	test(a.MatchC(_TL("abc*")) == 0);

   687 	test(a.MatchC(_TL("abc")) == KErrNotFound);

   688 	test(a.MatchC(_TL("xyz")) == KErrNotFound);

   689 	test(a.MatchC(_TL("*def")) == KErrNotFound);

   690 	test(a.MatchC(_TL("*def*")) == 3);

   691 	test(a.MatchC(_TL("*d?f*")) == 3);

   692 	test(a.MatchC(_TL("a*kl")) == 0);

   693 	test(a.MatchC(_TL("*e*?l")) == 4);

   694 	test(a.MatchC(_TL("abc*dEf*")) == 0);

   695 	

   696 	T candidate(_TL(""));

   697 	T search(_TL("**"));

   698 	

   699 	test(candidate.MatchC(search) == 0);

   700 	

   701 	candidate = _TL("");

   702 	search = _TL("*");

   703 	test(candidate.MatchC(search) == 0);

   704 	

   705 	candidate = _TL("abcd");

   706 	search = _TL("*abc*cd");

   707 	test(candidate.MatchC(search) == KErrNotFound);

   708    	

   709 	if (sizeof(S) == 2)

   710 		{

   711 		test.Next(_L("Unicode MatchC and FindC treat base+accent as equal to composed character"));

   712 		LString16 p = _L("te\x302te");

   713 		test(p.MatchC(_L("t\xeate")) == 0);

   714 		test(p.FindC(_L("t\xeate")) == 0);

   715 		}

   716 

   717 	test.End();

   718 	}

   719 

   720 

   721 /**

   722 @SYMTestCaseID SYSLIB-EUSERHL-UT-4018

   723 @SYMTestCaseDesc Tests LString Locate() methods

   724 @SYMTestPriority High

   725 @SYMTestActions Creates LString objects and uses the LocateX()

   726 				methods to search for a character within the LString

   727 				Verifies that LocateX() methods works as expected

   728 @SYMTestExpectedResults LString LocateX() method should return offset 

   729 				of the character position from the beginning of the data or 

   730 				KErrNotFound if no matching character can be found.

   731 @SYMREQ	10372

   732 */

   733 template <class T,class S,class DESTEMPLATE>

   734 GLDEF_C void TestLString<T,S,DESTEMPLATE>::Test10()

   735 // Locating

   736 	{

   737 	

   738 	test.Start (_L ("@SYMTestCaseID:SYSLIB-EUSERHL-UT-4018"));

   739 	

   740 	T a(iMaxBufLength);

   741 	TChar b;

   742 

   743 	test.Next(_L("First Char"));

   744 	

   745 	b='a';

   746 	a=_TL("axaxa");

   747 	test(a.Locate(b)==0);

   748 	test(a.LocateF(b)==0);

   749 	test(a.LocateReverse(b)==4);

   750 	test(a.LocateReverseF(b)==4);

   751 

   752 	test.Next(_L("Middle Char"));

   753 	a=_TL("xaxa");

   754 	test(a.Locate(b)==1);

   755 	test(a.LocateF(b)==1);

   756 	a=_TL("axax");

   757 	test(a.LocateReverse(b)==2);

   758 	test(a.LocateReverseF(b)==2);

   759 

   760 	test.Next(_L("Last Char"));

   761 	a=_TL("xxa");

   762 	test(a.Locate(b)==2);

   763 	test(a.LocateF(b)==2);

   764 	a=_TL("axx");

   765 	test(a.LocateReverse(b)==0);

   766 	test(a.LocateReverseF(b)==0);

   767 

   768 	test.Next(_L("Test for failure of locate"));

   769 	a=_TL("xxx");

   770 	test(a.Locate(b)==KErrNotFound);

   771 	test(a.LocateF(b)==KErrNotFound);

   772 	test(a.LocateReverse(b)==KErrNotFound);

   773 	test(a.LocateReverseF(b)==KErrNotFound);

   774 

   775 	test.End();

   776 	}

   777 	

   778 	

   779 /**

   780 @SYMTestCaseID SYSLIB-EUSERHL-UT-4019

   781 @SYMTestCaseDesc Tests LString CopyX() methods

   782 @SYMTestPriority High

   783 @SYMTestActions Creates LString objects and uses the CopyX()

   784 				methods to copy data into the strings.

   785 				Verifies that the length and contents of the LString 

   786 				are as expefcted

   787 @SYMTestExpectedResults LString CopyX() methods should copy data into 

   788 				LString as expected

   789 @SYMREQ	10372

   790 */

   791 template <class T,class S,class DESTEMPLATE>

   792 GLDEF_C void TestLString<T,S,DESTEMPLATE>::Test11L()

   793 // Copying

   794 	{

   795 	

   796 	test.Start (_L ("@SYMTestCaseID:SYSLIB-EUSERHL-UT-4019"));

   797 	

   798 	test.Next(_L("By String"));

   799 	

   800 	T a(iMaxBufLength);

   801 	T b(iMaxBufLength);

   802 		

   803 	a.CopyL(_TL("abc"));

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

   805 	test(a==_TL("abc"));

   806 	a.CopyFL(_TL("abc"));

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

   808 	b.CopyFL(_TL("ABC"));

   809 	test(a==b);

   810 	a.CopyLCL(_TL("AbC"));

   811 	test(a==_TL("abc"));

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

   813 	a.CopyCL(_TL("abc"));

   814 	b.CopyCL(_TL("ABC"));

   815 	test(a==b);

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

   817 	a.CopyCPL(_TL("abc"));

   818 	test(a==_TL("Abc"));

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

   820 	a.CopyUCL(_TL("aBc"));

   821 	test(a==_TL("ABC"));

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

   823 

   824 	test.Next(_L("By buffer"));

   825 	b=_TL("abc");

   826 	a.CopyL(b);

   827 	test(a==_TL("abc"));

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

   829 	a=_TL("");

   830 	a.CopyFL(b);

   831 	b.CopyFL(_TL("ABC"));

   832 	test(a==b);

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

   834 	a=_TL("");

   835 	b=_TL("AbC");

   836 	a.CopyLCL(b);

   837 	test(a==_TL("abc"));

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

   839 	a=_TL("");

   840 	b=_TL("abC");

   841 	a.CopyCL(b);

   842 	b.CopyCL(_TL("ABC"));

   843 	test(a==b);

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

   845 	a=_TL("");

   846 	b=_TL("abC");

   847 	a.CopyCPL(b);

   848 	test(a==_TL("Abc"));

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

   850 	a=_TL("");

   851 	b=_TL("aBc");

   852 	a.CopyUCL(b);

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

   854 	test(a==_TL("ABC"));

   855 

   856 	test.End();

   857 	}

   858 

   859 

   860 /**

   861 @SYMTestCaseID SYSLIB-EUSERHL-UT-4020

   862 @SYMTestCaseDesc Tests LString FindX() methods

   863 @SYMTestPriority High

   864 @SYMTestActions Creates LString objects and uses the FindX()

   865 				methods to find substrings.

   866 				Verifies that the index of the substring returned is as expected

   867 @SYMTestExpectedResults LString FindX() methods should return the index of the first 

   868 				character of the substring if it exists in the LString otherwise

   869 				return KErrNotFound.

   870 @SYMREQ	10372

   871 */

   872 template <class T,class S,class DESTEMPLATE>

   873 GLDEF_C void TestLString<T,S,DESTEMPLATE>::Test12()

   874 // Finding

   875 	{

   876 	

   877 	test.Start (_L ("@SYMTestCaseID:SYSLIB-EUSERHL-UT-4020"));

   878 	

   879 	test.Next(_L("By String"));

   880 	

   881 	T a(iMaxBufLength);

   882 	T b(iMaxBufLength);

   883 	

   884 	a=_TL("abccef");

   885 	test(a.Find(_TL(""))==0);

   886 	test(a.Find(_TL("abc"))==0);

   887 	test(a.Find(_TL("cce"))==2);

   888 	test(a.Find(_TL("cef"))==3);

   889 	test(a.Find(_TL("efg"))==KErrNotFound);

   890 	test(a.Find(_TL("xxx"))==KErrNotFound);

   891 	test(a.FindF(_TL(""))==0);

   892 	test(a.FindF(_TL("AbC"))==0);

   893 	test(a.FindF(_TL("CcE"))==2);

   894 	test(a.FindF(_TL("CeF"))==3);

   895 	test(a.FindF(_TL("efg"))==KErrNotFound);

   896 	test(a.FindF(_TL("xxx"))==KErrNotFound);

   897 	test(a.FindC(_TL(""))==0);

   898 	test(a.FindC(_TL("aBc"))==0);

   899 	test(a.FindC(_TL("cce"))==2);

   900 	test(a.FindC(_TL("cEf"))==3);

   901 	test(a.FindC(_TL("efg"))==KErrNotFound);

   902 	test(a.FindC(_TL("xxx"))==KErrNotFound);

   903 

   904 	test.Next(_L("By buffer"));

   905 	test(a.Find(b)==0);

   906 	test(a.FindF(b)==0);

   907 	test(a.FindC(b)==0);

   908 	b=_TL("xxx");

   909 	test(a.Find(b)==KErrNotFound);

   910 	test(a.FindF(b)==KErrNotFound);

   911 	test(a.FindC(b)==KErrNotFound);

   912 	b=_TL("efg");

   913 	test(a.Find(b)==KErrNotFound);

   914 	test(a.FindF(b)==KErrNotFound);

   915 	test(a.FindC(b)==KErrNotFound);

   916 	b=_TL("abc");

   917 	test(a.Find(b)==0);

   918 	b=_TL("cce");

   919 	test(a.Find(b)==2);

   920 	b=_TL("cef");

   921 	test(a.Find(b)==3);

   922 	b=_TL("AbC");

   923 	test(a.FindF(b)==0);

   924 	b=_TL("CcE");

   925 	test(a.FindF(b)==2);

   926 	b=_TL("CeF");

   927 	test(a.FindF(b)==3);

   928 	b=_TL("aBc");

   929 	test(a.FindC(b)==0);

   930 	b=_TL("cCe");

   931 	test(a.FindC(b)==2);

   932 	b=_TL("cEf");

   933 	test(a.FindC(b)==3);

   934 

   935 	test.End();

   936 	}

   937 

   938 

   939 /**

   940 @SYMTestCaseID SYSLIB-EUSERHL-UT-4021

   941 @SYMTestCaseDesc Tests LString modification methods

   942 @SYMTestPriority High

   943 @SYMTestActions Creates LString objects and uses the Repeat(),

   944 				TrimX(), InsertL(), Delete(), Left(), Right() and Mid() methods

   945 				to modify the string.

   946 				Verifies that the LString is modified as expected

   947 @SYMTestExpectedResults LString modification methods should modify the LString 

   948 				data as expected.

   949 @SYMREQ	10372

   950 */

   951 template <class T,class S,class DESTEMPLATE>

   952 GLDEF_C void TestLString<T,S,DESTEMPLATE>::Test13L()

   953 // Basic like ops

   954 	{

   955 	

   956 	test.Start (_L ("@SYMTestCaseID:SYSLIB-EUSERHL-UT-4021"));

   957 	

   958 	test.Next(_L("Repeat, trim, insert and delete"));

   959 	

   960 	T a(iMaxBufLength);

   961 	T b(iMaxBufLength);

   962 	TInt max=a.MaxLength(); 

   963 	b=_TL("abc");

   964 	a.Repeat(_TL("abc"));

   965 	test(a==_TL(""));

   966 	a.Repeat(b);

   967 	test(a==_TL(""));

   968 	for (TInt j=1;j<max;j++) // ?? Cannot SetLength = MaxLength

   969 		{

   970 		a.SetLengthL(j);

   971 		a.Repeat(_TL("abc"));

   972         TInt i;

   973 		for (i=0;i<j;i++)

   974 			test(a[i]==b[i%3]);

   975 		a=_TL("");

   976 		a.SetLengthL(j);

   977 		a.Repeat(b);

   978 		for (i=0;i<j;i++)

   979 			test(a[i]==b[i%3]);

   980 		a=_TL("");

   981 		}

   982 	a=_TL("\t\n  ab \t\n ");

   983 	a.TrimLeft();

   984 	test(a==_TL("ab \t\n "));

   985 	test(a.Length()==6);

   986 	a=_TL("\t\n  ab \t\n ");

   987 	a.TrimRight();

   988 	test(a==_TL("\t\n  ab"));

   989 	test(a.Length()==6);

   990 	a=_TL(" \t\n ab \t \n");

   991 	a.Trim();

   992 	test(a==_TL("ab"));

   993 	a.Trim();

   994 	test(a==_TL("ab"));

   995 	a=_TL("abc");

   996 	b=_TL("123");

   997 	a.InsertL(1,b);

   998 	test(a==_TL("a123bc"));

   999 	test(a.Length()==6);

  1000 	b=_TL("");

  1001 	a.InsertL(4,b);

  1002 	test(a==_TL("a123bc"));

  1003 	test(a.Length()==6);

  1004 	a.InsertL(0,b);

  1005 	test(a==_TL("a123bc"));

  1006 	test(a.Length()==6);

  1007 	a.Delete(1,3);

  1008 	test(a==_TL("abc"));

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

  1010 	a.Delete(0,3);

  1011 	test(a==_TL(""));

  1012 	test(a.Length()==0);

  1013 

  1014 	test.Next(_L("TrimAll"));

  1015 	a=_TL("");

  1016 	a.TrimAll();

  1017 	test(a==_TL(""));

  1018 	a=_TL(" ");

  1019 	a.TrimAll();

  1020 	test(a==_TL(""));

  1021 	a=_TL("   ");

  1022 	a.TrimAll();

  1023 	test(a==_TL(""));

  1024 	a=_TL("    ab cd  ef    g");

  1025 	a.TrimAll();

  1026 	test(a==_TL("ab cd ef g"));

  1027 	a=_TL("abcdef");

  1028 	a.TrimAll();

  1029 	test(a==_TL("abcdef"));

  1030 	a=_TL("a  b\t cd\t\tef");

  1031 	a.TrimAll();

  1032 	test(a==_TL("a b\tcd\tef"));

  1033 	a=_TL("abcdef \t ghijk");

  1034 	a.TrimAll();

  1035 	test(a==_TL("abcdef ghijk"));

  1036 	a=_TL("abcdef g");

  1037 	a.TrimAll();

  1038 	test(a==_TL("abcdef g"));

  1039 	a=_TL("ab  cd  ef  gh  ij");

  1040 	a.TrimAll();

  1041 	test(a==_TL("ab cd ef gh ij"));

  1042 	a=_TL("a        b          c     defg h     i  jk l     mno pqr stu  vw   xyz");

  1043 	a.TrimAll();

  1044 	test(a==_TL("a b c defg h i jk l mno pqr stu vw xyz"));

  1045 

  1046 	test.Next(_L("Right, Left and Mid"));

  1047 	a=_TL("abcdef");

  1048 	b = a.Left(3);

  1049 	test(b==_TL("abc"));

  1050 	test(b.Length()==3);

  1051 	b = a.Right(3);

  1052 	test(b==_TL("def"));

  1053 	b = a.Mid(2);

  1054 	test(b==_TL("cdef"));

  1055 	test(b.Length()==4);

  1056 	b = a.Left(2);

  1057 	test(b==_TL("ab"));

  1058 	test(b.Length()==2);

  1059 	b = a.Right(2);

  1060 	test(b==_TL("ef"));

  1061 	b = a.Mid(2,1);

  1062 	test(b==_TL("c"));

  1063 	test(b.Length()==1);

  1064 	b = a.Left(6);

  1065 	test(b==_TL("abcdef"));

  1066 	test(b.Length()==6);

  1067 	b=_TL("");

  1068 	b.SetLengthL(4);

  1069 	b = a.Right(6);

  1070 	test(b==_TL("abcdef"));

  1071 	test(b.Length()==6);

  1072 	a = a.Left(6);

  1073 	test(a==_TL("abcdef"));

  1074 	b=_TL("");

  1075 	b = a.Mid(0,6);

  1076 	test(b==_TL("abcdef")); 

  1077 	test.End();

  1078 	}

  1079 

  1080 /**

  1081 @SYMTestCaseID SYSLIB-EUSERHL-UT-4022

  1082 @SYMTestCaseDesc Tests LString formatting methods

  1083 @SYMTestPriority High

  1084 @SYMTestActions Creates LString objects and uses the LString formatting methods

  1085 				to format the string.

  1086 				Verifies that the LString is formatted as expected

  1087 @SYMTestExpectedResults LString formatting methods should fromta the LString as expected

  1088 @SYMREQ	10372

  1089 */

  1090 template <class T,class S,class DESTEMPLATE>

  1091 GLDEF_C void TestLString<T,S,DESTEMPLATE>::Test14L()

  1092 // Formating operations

  1093 	{

  1094 	

  1095 	test.Start (_L ("@SYMTestCaseID:SYSLIB-EUSERHL-UT-4022"));

  1096 	

  1097 	test.Next(_L("Justify"));

  1098 	//---------------------------Apepend+Justify-----------------------------------

  1099 	T a(1);

  1100 	T b(1);

  1101 	T d(1);

  1102 

  1103 	TInt aWidth;

  1104 	TChar c;

  1105 	a=_TL("wxyz");

  1106 	b=_TL("abc");

  1107 	d=_TL("linearisation");

  1108 	const S* pD=_TS("299792458");

  1109 	c='x';

  1110 	aWidth=KDefaultJustifyWidth; // Left justified, Default width

  1111 	a.JustifyL(b,aWidth,ELeft,c);

  1112 	test(a==b);

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

  1114 	a.AppendJustifyL(b,aWidth,ELeft,c);

  1115 	test(a==_TL("abcabc"));

  1116 	test(a.Length()==6);

  1117 	aWidth=1;	// Width < String length

  1118 	a.JustifyL(b,aWidth,ELeft,c);

  1119 	test(a==_TL("a"));

  1120 	test(a.Length()==1);

  1121 	a.AppendJustifyL(b,aWidth,ELeft,c);

  1122 	test(a==_TL("aa"));

  1123 	test(a.Length()==2);

  1124 	aWidth=5; // Width > String length

  1125 	a.JustifyL(b,aWidth,ELeft,c);

  1126 	test(a==_TL("abcxx"));

  1127 	test(a.Length()==5);

  1128 	a.AppendJustifyL(b,aWidth,ELeft,c);

  1129 	test(a==_TL("abcxxabcxx"));

  1130 	test(a.Length()==10);

  1131 

  1132 	aWidth=KDefaultJustifyWidth; // Right justified, Default width

  1133 	a.JustifyL(b,aWidth,ERight,c);

  1134 	test(a==b);

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