Mercurial Mercurial > oss > FCL > sf > os > textandloc / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
textrendering/texthandling/ttext/T_SCANDC.CPP
changeset 51 a7c938434754
parent 0 1fb32624e06b
child 55 336bee5c2d35
equal deleted inserted replaced
44:601ab138ba0b 51:a7c938434754 
     1 /*
 
     1 /*
 
     2 * Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
 
     2 * Copyright (c) 1997-2010 Nokia Corporation and/or its subsidiary(-ies).
 
     3 * All rights reserved.
 
     3 * All rights reserved.
 
     4 * This component and the accompanying materials are made available
 
     4 * This component and the accompanying materials are made available
 
     5 * under the terms of "Eclipse Public License v1.0"
 
     5 * under the terms of "Eclipse Public License v1.0"
 
     6 * which accompanies this distribution, and is available
 
     6 * which accompanies this distribution, and is available
 
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 
    14 * Description: 
    14 * Description: 
    15 *
 
    15 *
 
    16 */
 
    16 */
 
    17 
    17 
    18 
    18 
    19 #include <e32test.h>
 
       
    20 #include <txtetext.h>
 
    19 #include <txtetext.h>
 
       
    20 #include "T_SCANDC.h"
 
       
    21 
       
    22 LOCAL_D CTestStep *pTestStep = NULL;
 
       
    23 #define test(cond)											\
 
       
    24 	{														\
 
       
    25 	TBool __bb = (cond);									\
 
       
    26 	pTestStep->TEST(__bb);									\
 
       
    27 	if (!__bb)												\
 
       
    28 		{													\
 
       
    29 		pTestStep->ERR_PRINTF1(_L("ERROR: Test Failed"));	\
 
       
    30 		User::Leave(1);										\
 
       
    31 		}													\
 
       
    32 	}
 
       
    33 #undef INFO_PRINTF1
 
       
    34 #undef INFO_PRINTF2
 
       
    35 // copy from tefexportconst.h
 
       
    36 #define INFO_PRINTF1(p1)        pTestStep->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo, (p1))
 
       
    37 #define INFO_PRINTF2(p1, p2)    pTestStep->Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrInfo, (p1), (p2))
 
       
    38 
    21 
    39 
    22 #define UNUSED_VAR(a) a = a
 
    40 #define UNUSED_VAR(a) a = a
 
    23 
    41 
    24 LOCAL_D RTest test(_L("SCANNING OF TEXT DOCUMENTS"));
 
       
    25 LOCAL_D CTrapCleanup* TheTrapCleanup;
 
    42 LOCAL_D CTrapCleanup* TheTrapCleanup;
 
    26 
    43 
    27 template<class S,CEditableText::TDocumentStorage D>
 
    44 template<class S,CEditableText::TDocumentStorage D>
 
    28 class CTestScan : public CPlainText
 
    45 class CTestScan : public CPlainText
 
    29 	{
 
    46 	{
 
   196 //	Tests the CountWords method with different cases
 
   213 //	Tests the CountWords method with different cases
 
   197 //
 
   214 //
 
   198 	{
 
   215 	{
 
   199 	TBuf<64> temp;
 
   216 	TBuf<64> temp;
 
   200 	
   217 	
   201 	//test.Start(_L("0 words"));
 
   218 	//INFO_PRINTF1(_L("0 words"));
 
   202 	//iDocument->InsertL(0,buf.Ptr(),buf.Size());
 
   219 	//iDocument->InsertL(0,buf.Ptr(),buf.Size());
 
   203 	//DoCountWords(0);
 
   220 	//DoCountWords(0);
 
   204 	// This test has been removed since it is no longer feasible.
 
   221 	// This test has been removed since it is no longer feasible.
 
   205 	// The design currently inserts an end of document character
 
   222 	// The design currently inserts an end of document character
 
   206 	// as soon as the document is created, hence, there can not
 
   223 	// as soon as the document is created, hence, there can not
 
   207 	// be 0 words.
 
   224 	// be 0 words.
 
   208 	
   225 	
   209 	test.Start(_L("0 words, all delimiters"));
 
   226 	INFO_PRINTF1(_L("0 words, all delimiters"));
 
   210 	temp.Append(_L("   "));
 
   227 	temp.Append(_L("   "));
 
   211 	temp.Append(iDelimiter);
 
   228 	temp.Append(iDelimiter);
 
   212 	temp.Append(_L("   "));
 
   229 	temp.Append(_L("   "));
 
   213 	StoreTextL(temp);
 
   230 	StoreTextL(temp);
 
   214 	DoCountWords(0);
 
   231 	DoCountWords(0);
 
   215 	
   232 	
   216 	test.Next(_L("1 word, no delimiter"));
 
   233 	INFO_PRINTF1(_L("1 word, no delimiter"));
 
   217 	temp.Append(_L("This"));
 
   234 	temp.Append(_L("This"));
 
   218 	StoreTextL(temp);
 
   235 	StoreTextL(temp);
 
   219 	DoCountWords(1);
 
   236 	DoCountWords(1);
 
   220 
   237 
   221 	test.Next(_L("1 word, at start, no delimiter"));
 
   238 	INFO_PRINTF1(_L("1 word, at start, no delimiter"));
 
   222 	temp.Delete(0,temp.Size());
 
   239 	temp.Delete(0,temp.Size());
 
   223 	temp.Append(_L("THIS"));
 
   240 	temp.Append(_L("THIS"));
 
   224 	StoreTextL(temp);
 
   241 	StoreTextL(temp);
 
   225 	DoCountWords(1);
 
   242 	DoCountWords(1);
 
   226 
   243 
   227 	test.Next(_L("1 word, with delimiter"));
 
   244 	INFO_PRINTF1(_L("1 word, with delimiter"));
 
   228 	temp.Append(' ');
 
   245 	temp.Append(' ');
 
   229 	StoreTextL(temp);
 
   246 	StoreTextL(temp);
 
   230 	DoCountWords(1);
 
   247 	DoCountWords(1);
 
   231 
   248 
   232 	test.Next(_L("Many words, no delimiter"));
 
   249 	INFO_PRINTF1(_L("Many words, no delimiter"));
 
   233 	temp.Append(_L("  is a wonderful world"));
 
   250 	temp.Append(_L("  is a wonderful world"));
 
   234 	StoreTextL(temp);
 
   251 	StoreTextL(temp);
 
   235 	DoCountWords(5);
 
   252 	DoCountWords(5);
 
   236 
   253 
   237 	test.Next(_L("Many words with delimiter"));
 
   254 	INFO_PRINTF1(_L("Many words with delimiter"));
 
   238 	temp.Append(' ');
 
   255 	temp.Append(' ');
 
   239 	StoreTextL(temp);
 
   256 	StoreTextL(temp);
 
   240 	DoCountWords(5);
 
   257 	DoCountWords(5);
 
   241 
   258 
   242 	test.End();
 
   259 	
   243 	}
 
   260 	}
 
   244 
   261 
   245 
   262 
   246 template<class S,CEditableText::TDocumentStorage D>
 
   263 template<class S,CEditableText::TDocumentStorage D>
 
   247 GLDEF_C void CTestScan<S,D>::Test2bL()
 
   264 GLDEF_C void CTestScan<S,D>::Test2bL()
 
   252 	TBuf<64> buf;
 
   269 	TBuf<64> buf;
 
   253 	buf.Append(_L(" This  tEsT  TeXT"));
 
   270 	buf.Append(_L(" This  tEsT  TeXT"));
 
   254 	StoreTextL(buf);  
   271 	StoreTextL(buf);  
   255 
   272 
   256 	iCharsSkipped=iUnitCount=0;
 
   273 	iCharsSkipped=iUnitCount=0;
 
   257 	test.Start(_L("Forward scan"));
 
   274 	INFO_PRINTF1(_L("Forward scan"));
 
   258 
   275 
   259 	test.Next(_L("Stay at boundary:to unit start"));
 
   276 	INFO_PRINTF1(_L("Stay at boundary:to unit start"));
 
   260 	TUint flags=(CPlainText::EScanStayIfBoundary | CPlainText::EScanToUnitStart);
 
   277 	TUint flags=(CPlainText::EScanStayIfBoundary | CPlainText::EScanToUnitStart);
 
   261 	DoScanWords(8,flags,12,4);
 
   278 	DoScanWords(8,flags,12,4);
 
   262 	DoScanWords(7,flags,7,0);
 
   279 	DoScanWords(7,flags,7,0);
 
   263 	DoScanWords(6,flags,6,0);
 
   280 	DoScanWords(6,flags,6,0);
 
   264 	DoScanWords(5,flags,6,1);
 
   281 	DoScanWords(5,flags,6,1);
 
   265 		
   282 		
   266 	test.Next(_L("Stay at boundary:to unit end"));
 
   283 	INFO_PRINTF1(_L("Stay at boundary:to unit end"));
 
   267 	flags |= CPlainText::EScanToUnitEnd;
 
   284 	flags |= CPlainText::EScanToUnitEnd;
 
   268 	flags &=~CPlainText::EScanToUnitStart;
 
   285 	flags &=~CPlainText::EScanToUnitStart;
 
   269 	DoScanWords(8,flags,11,3);
 
   286 	DoScanWords(8,flags,11,3);
 
   270 	DoScanWords(7,flags,11,4);
 
   287 	DoScanWords(7,flags,11,4);
 
   271 	DoScanWords(6,flags,6,0);
 
   288 	DoScanWords(6,flags,6,0);
 
   272 	DoScanWords(5,flags,5,0);
 
   289 	DoScanWords(5,flags,5,0);
 
   273 
   290 
   274 	test.Next(_L("Stay at boundary:to unit start:join delimiters"));
 
   291 	INFO_PRINTF1(_L("Stay at boundary:to unit start:join delimiters"));
 
   275 	flags=(CPlainText::EScanStayIfBoundary|CPlainText::EScanToUnitStart|CPlainText::EScanJoinDelimiters);
 
   292 	flags=(CPlainText::EScanStayIfBoundary|CPlainText::EScanToUnitStart|CPlainText::EScanJoinDelimiters);
 
   276 	DoScanWords(8,flags,13,5);
 
   293 	DoScanWords(8,flags,13,5);
 
   277 	DoScanWords(7,flags,7,0);
 
   294 	DoScanWords(7,flags,7,0);
 
   278 	DoScanWords(6,flags,7,1);
 
   295 	DoScanWords(6,flags,7,1);
 
   279 	DoScanWords(5,flags,7,2);
 
   296 	DoScanWords(5,flags,7,2);
 
   280 	
   297 	
   281 	test.Next(_L("Stay at boundary:to unit end:join delimiters"));
 
   298 	INFO_PRINTF1(_L("Stay at boundary:to unit end:join delimiters"));
 
   282 	flags |= CPlainText::EScanToUnitEnd;
 
   299 	flags |= CPlainText::EScanToUnitEnd;
 
   283 	flags &=~CPlainText::EScanToUnitStart;
 
   300 	flags &=~CPlainText::EScanToUnitStart;
 
   284 	DoScanWords(8,flags,11,3);
 
   301 	DoScanWords(8,flags,11,3);
 
   285 	DoScanWords(7,flags,11,4);
 
   302 	DoScanWords(7,flags,11,4);
 
   286 	DoScanWords(6,flags,11,5);
 
   303 	DoScanWords(6,flags,11,5);
 
   287 	DoScanWords(5,flags,5,0);
 
   304 	DoScanWords(5,flags,5,0);
 
   288 
   305 
   289 	test.Next(_L("To unit start"));
 
   306 	INFO_PRINTF1(_L("To unit start"));
 
   290 	flags=CPlainText::EScanToUnitStart;
 
   307 	flags=CPlainText::EScanToUnitStart;
 
   291 	DoScanWords(8,flags,12,4);
 
   308 	DoScanWords(8,flags,12,4);
 
   292 	DoScanWords(7,flags,12,5);
 
   309 	DoScanWords(7,flags,12,5);
 
   293 	DoScanWords(6,flags,7,1);
 
   310 	DoScanWords(6,flags,7,1);
 
   294 	DoScanWords(5,flags,6,1);
 
   311 	DoScanWords(5,flags,6,1);
 
   295 	
   312 	
   296 	test.Next(_L("To unit end"));
 
   313 	INFO_PRINTF1(_L("To unit end"));
 
   297 	flags |= CPlainText::EScanToUnitEnd;
 
   314 	flags |= CPlainText::EScanToUnitEnd;
 
   298 	flags &=~CPlainText::EScanToUnitStart;
 
   315 	flags &=~CPlainText::EScanToUnitStart;
 
   299 	DoScanWords(8,flags,11,3);
 
   316 	DoScanWords(8,flags,11,3);
 
   300 	DoScanWords(7,flags,11,4);
 
   317 	DoScanWords(7,flags,11,4);
 
   301 	DoScanWords(6,flags,11,5);
 
   318 	DoScanWords(6,flags,11,5);
 
   302 	DoScanWords(5,flags,6,1);
 
   319 	DoScanWords(5,flags,6,1);
 
   303 
   320 
   304 	test.Next(_L("To unit start:join delimiters"));
 
   321 	INFO_PRINTF1(_L("To unit start:join delimiters"));
 
   305 	flags=(CPlainText::EScanToUnitStart|CPlainText::EScanJoinDelimiters);
 
   322 	flags=(CPlainText::EScanToUnitStart|CPlainText::EScanJoinDelimiters);
 
   306 	DoScanWords(8,flags,13,5);
 
   323 	DoScanWords(8,flags,13,5);
 
   307 	DoScanWords(7,flags,13,6);
 
   324 	DoScanWords(7,flags,13,6);
 
   308 	DoScanWords(6,flags,7,1);
 
   325 	DoScanWords(6,flags,7,1);
 
   309 	DoScanWords(5,flags,7,2);
 
   326 	DoScanWords(5,flags,7,2);
 
   310 
   327 
   311 	test.Next(_L("To unit end:join delimiters"));
 
   328 	INFO_PRINTF1(_L("To unit end:join delimiters"));
 
   312 	flags |= CPlainText::EScanToUnitEnd;
 
   329 	flags |= CPlainText::EScanToUnitEnd;
 
   313 	flags &=~CPlainText::EScanToUnitStart;
 
   330 	flags &=~CPlainText::EScanToUnitStart;
 
   314 	DoScanWords(8,flags,11,3);
 
   331 	DoScanWords(8,flags,11,3);
 
   315 	DoScanWords(7,flags,11,4);
 
   332 	DoScanWords(7,flags,11,4);
 
   316 	DoScanWords(6,flags,11,5);
 
   333 	DoScanWords(6,flags,11,5);
 
   317 	DoScanWords(5,flags,11,6);
 
   334 	DoScanWords(5,flags,11,6);
 
   318 	
   335 	
   319 	test.Next(_L("Backward scan"));
 
   336 	INFO_PRINTF1(_L("Backward scan"));
 
   320 	test.Next(_L("Stay at boundary:to unit start"));
 
   337 	INFO_PRINTF1(_L("Stay at boundary:to unit start"));
 
   321 	flags=(CPlainText::EScanBackwards|CPlainText::EScanStayIfBoundary|CPlainText::EScanToUnitStart);
 
   338 	flags=(CPlainText::EScanBackwards|CPlainText::EScanStayIfBoundary|CPlainText::EScanToUnitStart);
 
   322 	DoScanWords(9,flags,7,2);
 
   339 	DoScanWords(9,flags,7,2);
 
   323 	DoScanWords(10,flags,7,3);
 
   340 	DoScanWords(10,flags,7,3);
 
   324 	DoScanWords(11,flags,7,4);
 
   341 	DoScanWords(11,flags,7,4);
 
   325 	DoScanWords(12,flags,12,0);
 
   342 	DoScanWords(12,flags,12,0);
 
   326 	DoScanWords(13,flags,13,0);
 
   343 	DoScanWords(13,flags,13,0);
 
   327 	
   344 	
   328 	test.Next(_L("Stay at boundary:to unit end"));
 
   345 	INFO_PRINTF1(_L("Stay at boundary:to unit end"));
 
   329 	flags |= CPlainText::EScanToUnitEnd;
 
   346 	flags |= CPlainText::EScanToUnitEnd;
 
   330 	flags &=~CPlainText::EScanToUnitStart;
 
   347 	flags &=~CPlainText::EScanToUnitStart;
 
   331 	DoScanWords(9,flags,6,3);
 
   348 	DoScanWords(9,flags,6,3);
 
   332 	DoScanWords(10,flags,6,4);
 
   349 	DoScanWords(10,flags,6,4);
 
   333 	DoScanWords(11,flags,11,0);
 
   350 	DoScanWords(11,flags,11,0);
 
   334 	DoScanWords(12,flags,12,0);
 
   351 	DoScanWords(12,flags,12,0);
 
   335 	DoScanWords(13,flags,12,1);
 
   352 	DoScanWords(13,flags,12,1);
 
   336 
   353 
   337 	test.Next(_L("Stay at boundary:to unit start:join delimiters"));
 
   354 	INFO_PRINTF1(_L("Stay at boundary:to unit start:join delimiters"));
 
   338 	flags=CPlainText::EScanBackwards|CPlainText::EScanStayIfBoundary|CPlainText::EScanToUnitStart|CPlainText::EScanJoinDelimiters;
 
   355 	flags=CPlainText::EScanBackwards|CPlainText::EScanStayIfBoundary|CPlainText::EScanToUnitStart|CPlainText::EScanJoinDelimiters;
 
   339 	DoScanWords(9,flags,7,2);
 
   356 	DoScanWords(9,flags,7,2);
 
   340 	DoScanWords(10,flags,7,3);
 
   357 	DoScanWords(10,flags,7,3);
 
   341 	DoScanWords(11,flags,7,4);
 
   358 	DoScanWords(11,flags,7,4);
 
   342 	DoScanWords(12,flags,7,5);
 
   359 	DoScanWords(12,flags,7,5);
 
   343 	DoScanWords(13,flags,13,0);
 
   360 	DoScanWords(13,flags,13,0);
 
   344 
   361 
   345 	test.Next(_L("Stay at boundary:to unit end:join delimiters"));
 
   362 	INFO_PRINTF1(_L("Stay at boundary:to unit end:join delimiters"));
 
   346 	flags |= CPlainText::EScanToUnitEnd;
 
   363 	flags |= CPlainText::EScanToUnitEnd;
 
   347 	flags &=~CPlainText::EScanToUnitStart;
 
   364 	flags &=~CPlainText::EScanToUnitStart;
 
   348 	DoScanWords(9,flags,5,4);
 
   365 	DoScanWords(9,flags,5,4);
 
   349 	DoScanWords(10,flags,5,5);
 
   366 	DoScanWords(10,flags,5,5);
 
   350 	DoScanWords(11,flags,11,0);
 
   367 	DoScanWords(11,flags,11,0);
 
   351 	DoScanWords(12,flags,11,1);
 
   368 	DoScanWords(12,flags,11,1);
 
   352 	DoScanWords(13,flags,11,2);
 
   369 	DoScanWords(13,flags,11,2);
 
   353 	
   370 	
   354 	test.Next(_L("To unit start"));
 
   371 	INFO_PRINTF1(_L("To unit start"));
 
   355 	flags=CPlainText::EScanBackwards|CPlainText::EScanToUnitStart;
 
   372 	flags=CPlainText::EScanBackwards|CPlainText::EScanToUnitStart;
 
   356 	DoScanWords(9,flags,7,2);
 
   373 	DoScanWords(9,flags,7,2);
 
   357 	DoScanWords(10,flags,7,3);
 
   374 	DoScanWords(10,flags,7,3);
 
   358 	DoScanWords(11,flags,7,4);
 
   375 	DoScanWords(11,flags,7,4);
 
   359 	DoScanWords(12,flags,7,5);
 
   376 	DoScanWords(12,flags,7,5);
 
   360 	DoScanWords(13,flags,12,1);
 
   377 	DoScanWords(13,flags,12,1);
 
   361 	
   378 	
   362 	test.Next(_L("To unit end"));
 
   379 	INFO_PRINTF1(_L("To unit end"));
 
   363 	flags |= CPlainText::EScanToUnitEnd;
 
   380 	flags |= CPlainText::EScanToUnitEnd;
 
   364 	flags &=~CPlainText::EScanToUnitStart;
 
   381 	flags &=~CPlainText::EScanToUnitStart;
 
   365 	DoScanWords(9,flags,6,3);
 
   382 	DoScanWords(9,flags,6,3);
 
   366 	DoScanWords(10,flags,6,4);
 
   383 	DoScanWords(10,flags,6,4);
 
   367 	DoScanWords(11,flags,6,5);
 
   384 	DoScanWords(11,flags,6,5);
 
   368 	DoScanWords(12,flags,11,1);
 
   385 	DoScanWords(12,flags,11,1);
 
   369 	DoScanWords(13,flags,12,1);
 
   386 	DoScanWords(13,flags,12,1);
 
   370 
   387 
   371 	test.Next(_L("To unit start:join delimiters"));
 
   388 	INFO_PRINTF1(_L("To unit start:join delimiters"));
 
   372 	flags=CPlainText::EScanBackwards|CPlainText::EScanToUnitStart|CPlainText::EScanJoinDelimiters;
 
   389 	flags=CPlainText::EScanBackwards|CPlainText::EScanToUnitStart|CPlainText::EScanJoinDelimiters;
 
   373 	DoScanWords(9,flags,7,2);
 
   390 	DoScanWords(9,flags,7,2);
 
   374 	DoScanWords(10,flags,7,3);
 
   391 	DoScanWords(10,flags,7,3);
 
   375 	DoScanWords(11,flags,7,4);
 
   392 	DoScanWords(11,flags,7,4);
 
   376 	DoScanWords(12,flags,7,5);
 
   393 	DoScanWords(12,flags,7,5);
 
   377 	DoScanWords(13,flags,7,6);
 
   394 	DoScanWords(13,flags,7,6);
 
   378 
   395 
   379 	test.Next(_L("To unit end:join delimiters"));
 
   396 	INFO_PRINTF1(_L("To unit end:join delimiters"));
 
   380 	flags=CPlainText::EScanToUnitEnd|CPlainText::EScanJoinDelimiters|CPlainText::EScanBackwards;
 
   397 	flags=CPlainText::EScanToUnitEnd|CPlainText::EScanJoinDelimiters|CPlainText::EScanBackwards;
 
   381 	DoScanWords(9,flags,5,4);
 
   398 	DoScanWords(9,flags,5,4);
 
   382 	DoScanWords(10,flags,5,5);
 
   399 	DoScanWords(10,flags,5,5);
 
   383 	DoScanWords(11,flags,5,6);
 
   400 	DoScanWords(11,flags,5,6);
 
   384 	DoScanWords(12,flags,11,1);
 
   401 	DoScanWords(12,flags,11,1);
 
   385 	DoScanWords(13,flags,11,2);
 
   402 	DoScanWords(13,flags,11,2);
 
   386 	test.End();
 
   403 	
   387 	}
 
   404 	}
 
   388 
   405 
   389 
   406 
   390 template<class S,CEditableText::TDocumentStorage D>
 
   407 template<class S,CEditableText::TDocumentStorage D>
 
   391 GLDEF_C void CTestScan<S,D>::Test2cL()
 
   408 GLDEF_C void CTestScan<S,D>::Test2cL()
 
   393 //	Tests the CountParagraphs method with different cases
 
   410 //	Tests the CountParagraphs method with different cases
 
   394 //
 
   411 //
 
   395 	{
 
   412 	{
 
   396 	TBuf<64> buf;
 
   413 	TBuf<64> buf;
 
   397 	
   414 	
   398 	//test.Start(_L("0 paras"));
 
   415 	//INFO_PRINTF1(_L("0 paras"));
 
   399 	//iDocument->InsertL(0,buf.Ptr(),buf.Size());
 
   416 	//iDocument->InsertL(0,buf.Ptr(),buf.Size());
 
   400 	//DoCountParagraphs(0);
 
   417 	//DoCountParagraphs(0);
 
   401 	// This test no longer applies, since documents are created with
 
   418 	// This test no longer applies, since documents are created with
 
   402 	// an end of document character.  ie, The document can not have
 
   419 	// an end of document character.  ie, The document can not have
 
   403 	// 0 words.
 
   420 	// 0 words.
 
   404 	
   421 	
   405 	test.Start(_L("Empty text source"));
 
   422 	INFO_PRINTF1(_L("Empty text source"));
 
   406 //	buf.Append(iDelimiter);
 
   423 //	buf.Append(iDelimiter);
 
   407 //	buf.Append(iDelimiter);
 
   424 //	buf.Append(iDelimiter);
 
   408 	StoreTextL(buf);
 
   425 	StoreTextL(buf);
 
   409 	DoCountParas(1);
 
   426 	DoCountParas(1);
 
   410 	
   427 	
   411 	test.Next(_L("1 para. no delimiter"));
 
   428 	INFO_PRINTF1(_L("1 para. no delimiter"));
 
   412 	buf.Append(_L("This"));
 
   429 	buf.Append(_L("This"));
 
   413 	StoreTextL(buf);
 
   430 	StoreTextL(buf);
 
   414 	DoCountParas(1);
 
   431 	DoCountParas(1);
 
   415 
   432 
   416 	test.Next(_L("1 para. at start, no delimiter"));
 
   433 	INFO_PRINTF1(_L("1 para. at start, no delimiter"));
 
   417 	buf.Delete(0,buf.Size());
 
   434 	buf.Delete(0,buf.Size());
 
   418 	buf.Append(_L(" THIS   "));
 
   435 	buf.Append(_L(" THIS   "));
 
   419 	StoreTextL(buf);
 
   436 	StoreTextL(buf);
 
   420 	DoCountParas(1);
 
   437 	DoCountParas(1);
 
   421 
   438 
   422 	test.Next(_L("1 para, with delimiter"));
 
   439 	INFO_PRINTF1(_L("1 para, with delimiter"));
 
   423 	buf.Append(iDelimiter);
 
   440 	buf.Append(iDelimiter);
 
   424 	StoreTextL(buf);
 
   441 	StoreTextL(buf);
 
   425 	DoCountParas(2);
 
   442 	DoCountParas(2);
 
   426 
   443 
   427 	test.Next(_L("2 paras, no delimiter"));
 
   444 	INFO_PRINTF1(_L("2 paras, no delimiter"));
 
   428 	buf.Append(' ');
 
   445 	buf.Append(' ');
 
   429 	StoreTextL(buf);
 
   446 	StoreTextL(buf);
 
   430 	DoCountParas(2);
 
   447 	DoCountParas(2);
 
   431 
   448 
   432 	test.Next(_L("2 paras with delimiter"));
 
   449 	INFO_PRINTF1(_L("2 paras with delimiter"));
 
   433 	buf.Append(iDelimiter);
 
   450 	buf.Append(iDelimiter);
 
   434 	StoreTextL(buf);
 
   451 	StoreTextL(buf);
 
   435 	DoCountParas(3);
 
   452 	DoCountParas(3);
 
   436 
   453 
   437 	test.End();
 
   454 	
   438 	}
 
   455 	}
 
   439 
   456 
   440 
   457 
   441 template<class S,CEditableText::TDocumentStorage D>
 
   458 template<class S,CEditableText::TDocumentStorage D>
 
   442 GLDEF_C void CTestScan<S,D>::Test2dL()
 
   459 GLDEF_C void CTestScan<S,D>::Test2dL()
 
   453 	buf.Append(iDelimiter);
 
   470 	buf.Append(iDelimiter);
 
   454 	buf.Append(_L("TeXT"));
 
   471 	buf.Append(_L("TeXT"));
 
   455 	StoreTextL(buf);  
   472 	StoreTextL(buf);  
   456 
   473 
   457 	iCharsSkipped=iUnitCount=0;
 
   474 	iCharsSkipped=iUnitCount=0;
 
   458 	test.Start(_L("Forward scan"));
 
   475 	INFO_PRINTF1(_L("Forward scan"));
 
   459 
   476 
   460 	test.Next(_L("Stay at boundary:to unit start"));
 
   477 	INFO_PRINTF1(_L("Stay at boundary:to unit start"));
 
   461 	TUint flags=(CPlainText::EScanStayIfBoundary|CPlainText::EScanToUnitStart);
 
   478 	TUint flags=(CPlainText::EScanStayIfBoundary|CPlainText::EScanToUnitStart);
 
   462 	DoScanParas(8,flags,12,4);
 
   479 	DoScanParas(8,flags,12,4);
 
   463 	DoScanParas(7,flags,7,0);
 
   480 	DoScanParas(7,flags,7,0);
 
   464 	DoScanParas(6,flags,6,0);
 
   481 	DoScanParas(6,flags,6,0);
 
   465 	DoScanParas(5,flags,6,1);
 
   482 	DoScanParas(5,flags,6,1);
 
   466 		
   483 		
   467 	test.Next(_L("Stay at boundary:to unit end"));
 
   484 	INFO_PRINTF1(_L("Stay at boundary:to unit end"));
 
   468 	flags |= CPlainText::EScanToUnitEnd;
 
   485 	flags |= CPlainText::EScanToUnitEnd;
 
   469 	flags &=~CPlainText::EScanToUnitStart;
 
   486 	flags &=~CPlainText::EScanToUnitStart;
 
   470 	DoScanParas(8,flags,11,3);
 
   487 	DoScanParas(8,flags,11,3);
 
   471 	DoScanParas(7,flags,11,4);
 
   488 	DoScanParas(7,flags,11,4);
 
   472 	DoScanParas(6,flags,6,0);
 
   489 	DoScanParas(6,flags,6,0);
 
   473 	DoScanParas(5,flags,5,0);
 
   490 	DoScanParas(5,flags,5,0);
 
   474 
   491 
   475 	test.Next(_L("Stay at boundary:to unit start:join delimiters"));
 
   492 	INFO_PRINTF1(_L("Stay at boundary:to unit start:join delimiters"));
 
   476 	flags=(CPlainText::EScanStayIfBoundary | CPlainText::EScanToUnitStart | CPlainText::EScanJoinDelimiters);
 
   493 	flags=(CPlainText::EScanStayIfBoundary | CPlainText::EScanToUnitStart | CPlainText::EScanJoinDelimiters);
 
   477 	DoScanParas(8,flags,13,5);
 
   494 	DoScanParas(8,flags,13,5);
 
   478 	DoScanParas(7,flags,7,0);
 
   495 	DoScanParas(7,flags,7,0);
 
   479 	DoScanParas(6,flags,7,1);
 
   496 	DoScanParas(6,flags,7,1);
 
   480 	DoScanParas(5,flags,7,2);
 
   497 	DoScanParas(5,flags,7,2);
 
   481 	
   498 	
   482 	test.Next(_L("Stay at boundary:to unit end:join delimiters"));
 
   499 	INFO_PRINTF1(_L("Stay at boundary:to unit end:join delimiters"));
 
   483 	flags |= CPlainText::EScanToUnitEnd;
 
   500 	flags |= CPlainText::EScanToUnitEnd;
 
   484 	flags &=~CPlainText::EScanToUnitStart;
 
   501 	flags &=~CPlainText::EScanToUnitStart;
 
   485 	DoScanParas(8,flags,11,3);
 
   502 	DoScanParas(8,flags,11,3);
 
   486 	DoScanParas(7,flags,11,4);
 
   503 	DoScanParas(7,flags,11,4);
 
   487 	DoScanParas(6,flags,11,5);
 
   504 	DoScanParas(6,flags,11,5);
 
   488 	DoScanParas(5,flags,5,0);
 
   505 	DoScanParas(5,flags,5,0);
 
   489 
   506 
   490 	test.Next(_L("To unit start"));
 
   507 	INFO_PRINTF1(_L("To unit start"));
 
   491 	flags=CPlainText::EScanToUnitStart;
 
   508 	flags=CPlainText::EScanToUnitStart;
 
   492 	DoScanParas(8,flags,12,4);
 
   509 	DoScanParas(8,flags,12,4);
 
   493 	DoScanParas(7,flags,12,5);
 
   510 	DoScanParas(7,flags,12,5);
 
   494 	DoScanParas(6,flags,7,1);
 
   511 	DoScanParas(6,flags,7,1);
 
   495 	DoScanParas(5,flags,6,1);
 
   512 	DoScanParas(5,flags,6,1);
 
   496 	
   513 	
   497 	test.Next(_L("To unit end"));
 
   514 	INFO_PRINTF1(_L("To unit end"));
 
   498 	flags |= CPlainText::EScanToUnitEnd;
 
   515 	flags |= CPlainText::EScanToUnitEnd;
 
   499 	flags &=~CPlainText::EScanToUnitStart;
 
   516 	flags &=~CPlainText::EScanToUnitStart;
 
   500 	DoScanParas(8,flags,11,3);
 
   517 	DoScanParas(8,flags,11,3);
 
   501 	DoScanParas(7,flags,11,4);
 
   518 	DoScanParas(7,flags,11,4);
 
   502 	DoScanParas(6,flags,11,5);
 
   519 	DoScanParas(6,flags,11,5);
 
   503 	DoScanParas(5,flags,6,1);
 
   520 	DoScanParas(5,flags,6,1);
 
   504 
   521 
   505 	test.Next(_L("To unit start:join delimiters"));
 
   522 	INFO_PRINTF1(_L("To unit start:join delimiters"));
 
   506 	flags=(CPlainText::EScanToUnitStart | CPlainText::EScanJoinDelimiters);
 
   523 	flags=(CPlainText::EScanToUnitStart | CPlainText::EScanJoinDelimiters);
 
   507 	DoScanParas(8,flags,13,5);
 
   524 	DoScanParas(8,flags,13,5);
 
   508 	DoScanParas(7,flags,13,6);
 
   525 	DoScanParas(7,flags,13,6);
 
   509 	DoScanParas(6,flags,7,1);
 
   526 	DoScanParas(6,flags,7,1);
 
   510 	DoScanParas(5,flags,7,2);
 
   527 	DoScanParas(5,flags,7,2);
 
   511 
   528 
   512 	test.Next(_L("To unit end:join delimiters"));
 
   529 	INFO_PRINTF1(_L("To unit end:join delimiters"));
 
   513 	flags |= CPlainText::EScanToUnitEnd;
 
   530 	flags |= CPlainText::EScanToUnitEnd;
 
   514 	flags &=~CPlainText::EScanToUnitStart;
 
   531 	flags &=~CPlainText::EScanToUnitStart;
 
   515 	DoScanParas(8,flags,11,3);
 
   532 	DoScanParas(8,flags,11,3);
 
   516 	DoScanParas(7,flags,11,4);
 
   533 	DoScanParas(7,flags,11,4);
 
   517 	DoScanParas(6,flags,11,5);
 
   534 	DoScanParas(6,flags,11,5);
 
   518 	DoScanParas(5,flags,11,6);
 
   535 	DoScanParas(5,flags,11,6);
 
   519 	
   536 	
   520 	test.Next(_L("Backward scan"));
 
   537 	INFO_PRINTF1(_L("Backward scan"));
 
   521 	test.Next(_L("Stay at boundary:to unit start"));
 
   538 	INFO_PRINTF1(_L("Stay at boundary:to unit start"));
 
   522 	flags=(CPlainText::EScanBackwards|CPlainText::EScanStayIfBoundary|CPlainText::EScanToUnitStart);
 
   539 	flags=(CPlainText::EScanBackwards|CPlainText::EScanStayIfBoundary|CPlainText::EScanToUnitStart);
 
   523 	DoScanParas(9,flags,7,2);
 
   540 	DoScanParas(9,flags,7,2);
 
   524 	DoScanParas(10,flags,7,3);
 
   541 	DoScanParas(10,flags,7,3);
 
   525 	DoScanParas(11,flags,7,4);
 
   542 	DoScanParas(11,flags,7,4);
 
   526 	DoScanParas(12,flags,12,0);
 
   543 	DoScanParas(12,flags,12,0);
 
   530 	DoScanParas(5,flags,0,5);
 
   547 	DoScanParas(5,flags,0,5);
 
   531 	DoScanParas(4,flags,0,4);
 
   548 	DoScanParas(4,flags,0,4);
 
   532 	DoScanParas(3,flags,0,3);
 
   549 	DoScanParas(3,flags,0,3);
 
   533 	DoScanParas(2,flags,0,2);
 
   550 	DoScanParas(2,flags,0,2);
 
   534 	DoScanParas(1,flags,0,1);
 
   551 	DoScanParas(1,flags,0,1);
 
   535 	test.Next(_L("Testing at buffer boundaries."));
 
   552 	INFO_PRINTF1(_L("Testing at buffer boundaries."));
 
   536 	DoScanParas(0,flags,0,0);
 
   553 	DoScanParas(0,flags,0,0);
 
   537 	DoScanParas(16,flags,13,3);
 
   554 	DoScanParas(16,flags,13,3);
 
   538 	
   555 	
   539 
   556 
   540 	test.Next(_L("Stay at boundary:to unit end"));
 
   557 	INFO_PRINTF1(_L("Stay at boundary:to unit end"));
 
   541 	flags |= CPlainText::EScanToUnitEnd;
 
   558 	flags |= CPlainText::EScanToUnitEnd;
 
   542 	flags &=~CPlainText::EScanToUnitStart;
 
   559 	flags &=~CPlainText::EScanToUnitStart;
 
   543 	DoScanParas(9,flags,6,3);
 
   560 	DoScanParas(9,flags,6,3);
 
   544 	DoScanParas(10,flags,6,4);
 
   561 	DoScanParas(10,flags,6,4);
 
   545 	DoScanParas(11,flags,11,0);
 
   562 	DoScanParas(11,flags,11,0);
 
   546 	DoScanParas(12,flags,12,0);
 
   563 	DoScanParas(12,flags,12,0);
 
   547 	DoScanParas(13,flags,12,1);
 
   564 	DoScanParas(13,flags,12,1);
 
   548 
   565 
   549 	test.Next(_L("Stay at boundary:to unit start:join delimiters"));
 
   566 	INFO_PRINTF1(_L("Stay at boundary:to unit start:join delimiters"));
 
   550 	flags=CPlainText::EScanBackwards|CPlainText::EScanStayIfBoundary|CPlainText::EScanToUnitStart|CPlainText::EScanJoinDelimiters;
 
   567 	flags=CPlainText::EScanBackwards|CPlainText::EScanStayIfBoundary|CPlainText::EScanToUnitStart|CPlainText::EScanJoinDelimiters;
 
   551 	DoScanParas(9,flags,7,2);
 
   568 	DoScanParas(9,flags,7,2);
 
   552 	DoScanParas(10,flags,7,3);
 
   569 	DoScanParas(10,flags,7,3);
 
   553 	DoScanParas(11,flags,7,4);
 
   570 	DoScanParas(11,flags,7,4);
 
   554 	DoScanParas(12,flags,7,5);
 
   571 	DoScanParas(12,flags,7,5);
 
   555 	DoScanParas(13,flags,13,0);
 
   572 	DoScanParas(13,flags,13,0);
 
   556 
   573 
   557 	test.Next(_L("Stay at boundary:to unit end:join delimiters"));
 
   574 	INFO_PRINTF1(_L("Stay at boundary:to unit end:join delimiters"));
 
   558 	flags |= CPlainText::EScanToUnitEnd;
 
   575 	flags |= CPlainText::EScanToUnitEnd;
 
   559 	flags &=~CPlainText::EScanToUnitStart;
 
   576 	flags &=~CPlainText::EScanToUnitStart;
 
   560 	DoScanParas(9,flags,5,4);
 
   577 	DoScanParas(9,flags,5,4);
 
   561 	DoScanParas(10,flags,5,5);
 
   578 	DoScanParas(10,flags,5,5);
 
   562 	DoScanParas(11,flags,11,0);
 
   579 	DoScanParas(11,flags,11,0);
 
   563 	DoScanParas(12,flags,11,1);
 
   580 	DoScanParas(12,flags,11,1);
 
   564 	DoScanParas(13,flags,11,2);
 
   581 	DoScanParas(13,flags,11,2);
 
   565 	
   582 	
   566 	test.Next(_L("To unit start"));
 
   583 	INFO_PRINTF1(_L("To unit start"));
 
   567 	flags=CPlainText::EScanBackwards|CPlainText::EScanToUnitStart;
 
   584 	flags=CPlainText::EScanBackwards|CPlainText::EScanToUnitStart;
 
   568 	DoScanParas(9,flags,7,2);
 
   585 	DoScanParas(9,flags,7,2);
 
   569 	DoScanParas(10,flags,7,3);
 
   586 	DoScanParas(10,flags,7,3);
 
   570 	DoScanParas(11,flags,7,4);
 
   587 	DoScanParas(11,flags,7,4);
 
   571 	DoScanParas(12,flags,7,5);
 
   588 	DoScanParas(12,flags,7,5);
 
   572 	DoScanParas(13,flags,12,1);
 
   589 	DoScanParas(13,flags,12,1);
 
   573 	
   590 	
   574 	test.Next(_L("To unit end"));
 
   591 	INFO_PRINTF1(_L("To unit end"));
 
   575 	flags |= CPlainText::EScanToUnitEnd;
 
   592 	flags |= CPlainText::EScanToUnitEnd;
 
   576 	flags &=~CPlainText::EScanToUnitStart;
 
   593 	flags &=~CPlainText::EScanToUnitStart;
 
   577 	DoScanParas(9,flags,6,3);
 
   594 	DoScanParas(9,flags,6,3);
 
   578 	DoScanParas(10,flags,6,4);
 
   595 	DoScanParas(10,flags,6,4);
 
   579 	DoScanParas(11,flags,6,5);
 
   596 	DoScanParas(11,flags,6,5);
 
   580 	DoScanParas(12,flags,11,1);
 
   597 	DoScanParas(12,flags,11,1);
 
   581 	DoScanParas(13,flags,12,1);
 
   598 	DoScanParas(13,flags,12,1);
 
   582 
   599 
   583 	test.Next(_L("To unit start:join delimiters"));
 
   600 	INFO_PRINTF1(_L("To unit start:join delimiters"));
 
   584 	flags=CPlainText::EScanBackwards|CPlainText::EScanToUnitStart|CPlainText::EScanJoinDelimiters;
 
   601 	flags=CPlainText::EScanBackwards|CPlainText::EScanToUnitStart|CPlainText::EScanJoinDelimiters;
 
   585 	DoScanParas(9,flags,7,2);
 
   602 	DoScanParas(9,flags,7,2);
 
   586 	DoScanParas(10,flags,7,3);
 
   603 	DoScanParas(10,flags,7,3);
 
   587 	DoScanParas(11,flags,7,4);
 
   604 	DoScanParas(11,flags,7,4);
 
   588 	DoScanParas(12,flags,7,5);
 
   605 	DoScanParas(12,flags,7,5);
 
   589 	DoScanParas(13,flags,7,6);
 
   606 	DoScanParas(13,flags,7,6);
 
   590 
   607 
   591 	test.Next(_L("To unit end:join delimiters"));
 
   608 	INFO_PRINTF1(_L("To unit end:join delimiters"));
 
   592 	flags |= CPlainText::EScanToUnitEnd;
 
   609 	flags |= CPlainText::EScanToUnitEnd;
 
   593 	flags &=~CPlainText::EScanToUnitStart;
 
   610 	flags &=~CPlainText::EScanToUnitStart;
 
   594 	DoScanParas(9,flags,5,4);
 
   611 	DoScanParas(9,flags,5,4);
 
   595 	DoScanParas(10,flags,5,5);
 
   612 	DoScanParas(10,flags,5,5);
 
   596 	DoScanParas(11,flags,5,6);
 
   613 	DoScanParas(11,flags,5,6);
 
   597 	DoScanParas(12,flags,11,1);
 
   614 	DoScanParas(12,flags,11,1);
 
   598 	DoScanParas(13,flags,11,2);
 
   615 	DoScanParas(13,flags,11,2);
 
   599 	
   616 	
   600 	test.End();
 
   617 	
   601 	}
 
   618 	}
 
   602 
   619 
   603 
   620 
   604 template<class S,CEditableText::TDocumentStorage D>
 
   621 template<class S,CEditableText::TDocumentStorage D>
 
   605 GLDEF_C void CTestScan<S,D>::Test2L()
 
   622 GLDEF_C void CTestScan<S,D>::Test2L()
 
   606 //
 
   623 //
 
   607 // Test all the methods of the class
 
   624 // Test all the methods of the class
 
   608 //
 
   625 //
 
   609 	{
 
   626 	{
 
   610 	test.Start(_L("CountWords"));
 
   627 	INFO_PRINTF1(_L("CountWords"));
 
   611 	Test2aL();
 
   628 	Test2aL();
 
   612 
   629 
   613 	test.Next(_L("ScanWord"));
 
   630 	INFO_PRINTF1(_L("ScanWord"));
 
   614 	Test2bL();
 
   631 	Test2bL();
 
   615 
   632 
   616 	test.Next(_L("Count Paragraphs"));
 
   633 	INFO_PRINTF1(_L("Count Paragraphs"));
 
   617 	Test2cL();
 
   634 	Test2cL();
 
   618 
   635 
   619 	test.Next(_L("Scan Paragraph"));
 
   636 	INFO_PRINTF1(_L("Scan Paragraph"));
 
   620 	Test2dL();
 
   637 	Test2dL();
 
   621 
   638 
   622 	test.End();
 
   639 	
   623 	}
 
   640 	}
 
   624 
   641 
   625 
   642 CT_SCANDC::CT_SCANDC()
 
   626 GLDEF_C TInt E32Main()
 
   643     {
 
   627 //
 
   644     SetTestStepName(KTestStep_T_SCANDC);
 
   628 // Test the OLIB Varray types.
 
   645     pTestStep = this;
 
   629 //
 
   646     }
 
   630 	{
 
   647 
   631 	TheTrapCleanup=CTrapCleanup::New();
 
   648 TVerdict CT_SCANDC::doTestStepL()
 
   632 
   649     {
 
   633 	test.Title();
 
   650     SetTestStepResult(EFail);
 
   634 	test.Start(_L(" @SYMTestCaseID:SYSLIB-TTEXT-LEGACY-T_SCANDC-0001 CPlainText - Flat "));	
   651 
   635 	typedef CTestScan<TText,CEditableText::EFlatStorage> instance1;
 
   652     TheTrapCleanup=CTrapCleanup::New();
 
   636 	typedef CTestScan<TText,CEditableText::ESegmentedStorage> instance2;
 
   653 
   637 	
   654     INFO_PRINTF1(_L("SCANNING OF TEXT DOCUMENTS"));
 
   638 	instance1* aa=NULL;
 
   655     INFO_PRINTF1(_L(" @SYMTestCaseID:SYSLIB-TTEXT-LEGACY-T_SCANDC-0001 CPlainText - Flat ")); 
   639 	TRAPD(ret, aa=instance1::NewL());
 
   656     typedef CTestScan<TText,CEditableText::EFlatStorage> instance1;
 
   640     test(ret == KErrNone);
 
   657     typedef CTestScan<TText,CEditableText::ESegmentedStorage> instance2;
 
   641 
   658     
   642 	test.Start(_L("Registering all methods"));
 
   659     instance1* aa=NULL;
 
   643 
   660     TRAPD(ret1, aa=instance1::NewL());
 
   644 	TRAP(ret,aa->Test1L());
 
   661 
   645     test(ret == KErrNone);
 
   662     INFO_PRINTF1(_L("Registering all methods"));
 
   646 
   663 
   647 	test.Next(_L("Testing all methods"));
 
   664     TRAPD(ret2,aa->Test1L());
 
   648 
   665 
   649 	TRAP(ret,aa->Test2L());
 
   666     INFO_PRINTF1(_L("Testing all methods"));
 
   650     test(ret == KErrNone);
 
   667 
   651 
   668     TRAPD(ret3,aa->Test2L());
 
   652 	__UHEAP_MARK;
 
   669 
   653 	delete aa;
 
   670     __UHEAP_MARK;
 
   654 	__UHEAP_MARKEND;
 
   671     delete aa;
 
   655 
   672     __UHEAP_MARKEND;
 
   656 	test.End();
 
   673 
   657 
   674     INFO_PRINTF1(_L("CPlainText - Segmented"));
 
   658 	test.Next(_L("CPlainText - Segmented"));
 
   675 
   659 
   676     instance2* bb=NULL;
 
   660 	instance2* bb=NULL;
 
   677     TRAPD(ret4, bb=instance2::NewL());
 
   661 	TRAP(ret, bb=instance2::NewL());
 
   678 
   662     test(ret == KErrNone);
 
   679     __UHEAP_MARK;
 
   663 
   680     INFO_PRINTF1(_L("Registering all methods"));
 
   664 	__UHEAP_MARK;
 
   681     TRAPD(ret5,bb->Test1L());
 
   665 	test.Start(_L("Registering all methods"));
 
   682     INFO_PRINTF1(_L("Testing all methods"));
 
   666 	TRAP(ret,bb->Test1L());
 
   683     TRAPD(ret6,bb->Test2L());
 
   667     test(ret == KErrNone);
 
   684     delete bb;
 
   668 	test.Next(_L("Testing all methods"));
 
   685     __UHEAP_MARKEND;
 
   669 	TRAP(ret,bb->Test2L());
 
   686     
   670     test(ret == KErrNone);
 
   687     delete TheTrapCleanup;
 
   671 	delete bb;
 
   688 
   672 	__UHEAP_MARKEND;
 
   689     if (ret1 == KErrNone && ret2 == KErrNone && ret3 == KErrNone && ret4 == KErrNone && ret5 == KErrNone && ret6 == KErrNone)
 
   673 	test.End();
 
   690         {
 
   674 
   691         SetTestStepResult(EPass);
 
   675 	test.End();
 
   692         }
 
   676 	test.Close();
 
   693 
   677 	
   694     return TestStepResult();
 
   678 	delete TheTrapCleanup;
 
   695     }
 
   679 
       
   680 	return(0);
 
       
   681 	}
 
       
   682
FCL/sf/os/textandloc