Symaptic: os/ossrv/genericservices/httputils/Test/t_uriparser/CDelimitedQueryTest.cpp@bde4ae8d615e

     1 // Copyright (c) 2001-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 //

    16 #include "CDelimitedQueryTest.h"

    18 #include <e32base.h>

    19 #include <delimitedquery16.h>

    20 #include <delimitedquery8.h>

    22 #include "TDelimitedDataCommon.h"

    23 #include "DelimitedQueryTests.h"

    25 // Constants

    26 //

    27 _LIT(KTitle16Bit, "%S (16-Bit)");

    28 _LIT(KTitle8Bit, "%S (8-Bit)");

    30 CDelimitedQueryTest* CDelimitedQueryTest::NewLC(CIpuTestHarness* aTestHarness)

    31 	{

    32 	CDelimitedQueryTest* self = new (ELeave) CDelimitedQueryTest(aTestHarness);

    33 	CleanupStack::PushL(self);

    34 	self->ConstructL();

    35 	return self;

    36 	}

    38 CDelimitedQueryTest* CDelimitedQueryTest::NewL(CIpuTestHarness* aTestHarness)

    39 	{

    40 	CDelimitedQueryTest* self = CDelimitedQueryTest::NewLC(aTestHarness);

    41 	CleanupStack::Pop(self);

    42 	return self;

    43 	}

    45 CDelimitedQueryTest::CDelimitedQueryTest(CIpuTestHarness* aTestHarness)

    46 : iTestHarness(aTestHarness)

    47 	{

    48 	}

    50 void CDelimitedQueryTest::ConstructL()

    51 	{

    52 	}

    54 CDelimitedQueryTest::~CDelimitedQueryTest()

    55 	{

    56 	}

    58 void CDelimitedQueryTest::DoTestsL()

    59 	{

    60 //

    61 //

    62 // Delimited Query Tests

    63 //

    64 //

    66 	TestDelimitedQueryExtractionL(KQueryParse0, &KQueryParse0Seg0(), &KQueryParse0Seg1(), &KQueryParse0Seg2(),

    67 							   &KQueryParse0Seg3(), NULL);

    68 	TestDelimitedQueryExtractionL(KQueryParse1, &KQueryParse1Seg0(), &KQueryParse1Seg1(), NULL);

    69 	TestDelimitedQueryExtractionL(KQueryParse2, &KQueryParse2Seg0(), &KQueryParse2Seg1(), &KQueryParse2Seg2(),

    70 							   &KQueryParse2Seg3(), &KQueryParse2Seg4(), &KQueryParse2Seg5(), NULL);

    72 	TestDelimitedQueryReverseExtractionL(KQueryParse0, &KQueryParse0Seg3(), &KQueryParse0Seg2(),

    73 							   &KQueryParse0Seg1(), &KQueryParse0Seg0(), NULL);

    74 	TestDelimitedQueryReverseExtractionL(KQueryParse1, &KQueryParse1Seg1(), &KQueryParse1Seg0(), NULL);

    75 	TestDelimitedQueryReverseExtractionL(KQueryParse2, &KQueryParse2Seg5(), &KQueryParse2Seg4(),

    76 							   &KQueryParse2Seg3(), &KQueryParse2Seg2(), &KQueryParse2Seg1(), &KQueryParse2Seg0(), NULL);

    78 	TestDelimitedQueryDelimiterPresenceL(KQuery_DelimPresence0, KQuery_FrontDelim0, KQuery_BackDelim0);

    79 	TestDelimitedQueryDelimiterPresenceL(KQuery_DelimPresence1, KQuery_FrontDelim1, KQuery_BackDelim1);

    80 	TestDelimitedQueryDelimiterPresenceL(KQuery_DelimPresence2, KQuery_FrontDelim2, KQuery_BackDelim2);

    81 	TestDelimitedQueryDelimiterPresenceL(KQuery_DelimPresence3, KQuery_FrontDelim3, KQuery_BackDelim3);

    83 	TestDelimitedQueryRemainderL(KQuery_Rem_Forwards0_0, &KQuery_Rem_Forwards0_0(), &KQuery_Rem_Forwards0_1(),

    84 								&KQuery_Rem_Forwards0_2(), &KQuery_Rem_Forwards0_3(), NULL);

    86 	TestDelimitedQueryRemainderReverseL(KQuery_Rem_Backwards0_0, &KQuery_Rem_Backwards0_0(), &KQuery_Rem_Backwards0_1(),

    87 								&KQuery_Rem_Backwards0_2(), &KQuery_Rem_Backwards0_3(), NULL);

    89 	TestDelimitedQueryDesL(KQuery_Des0);

    91 	TestDelimitedQueryPushFrontL(KQuery_PushPopFront0_0, &KQuery_Push0_a(), &KQuery_PushPopFront0_1(),

    92 								&KQuery_Push0_b(), &KQuery_PushPopFront0_2(),

    93 								&KQuery_Push0_c(), &KQuery_PushPopFront0_3(),

    94 								&KQuery_Push0_d(), &KQuery_PushPopFront0_4(),

    95 								&KQuery_Push0_e(), &KQuery_PushPopFront0_5(), NULL, NULL);

    97 	TestDelimitedQueryPushBackL(KQuery_PushPopBack0_0, &KQuery_Push0_a(), &KQuery_PushPopBack0_1(),

    98 								&KQuery_Push0_b(), &KQuery_PushPopBack0_2(),

    99 								&KQuery_Push0_c(), &KQuery_PushPopBack0_3(),

   100 								&KQuery_Push0_d(), &KQuery_PushPopBack0_4(),

   101 								&KQuery_Push0_e(), &KQuery_PushPopBack0_5(), NULL, NULL);

   103 	TestDelimitedQueryPopFrontL(KQuery_PushPopFront0_5, &KQuery_PushPopFront0_4(), &KQuery_PushPopFront0_3(),

   104 								&KQuery_PushPopFront0_2(), &KQuery_PushPopFront0_1(), &KQuery_PushPopFront0_0(), NULL);

   106 	TestDelimitedQueryPopBackL(KQuery_PushPopBack0_5, &KQuery_PushPopBack0_4(), &KQuery_PushPopBack0_3(),

   107 								&KQuery_PushPopBack0_2(), &KQuery_PushPopBack0_1(), &KQuery_PushPopBack0_0(), NULL);

   109 	TestDelimitedQueryAddAndTrimFrontAndBackDelimiterL(KQuery_AddTrimDelim0);

   111 	TestDelimitedQueryInsertAndParseL(KQueryInsertForwardsPos0, KQuery_InsertForwards0_0,

   112 									&KQuery_Insert0_a(), &KQuery_InsertForwards0_1(),

   113 									&KQuery_Insert0_b(), &KQuery_InsertForwards0_2(),

   114 									&KQuery_Insert0_c(), &KQuery_InsertForwards0_3(),

   115 									&KQuery_Insert0_d(), &KQuery_InsertForwards0_4(),

   116 									&KQuery_Insert0_e(), &KQuery_InsertForwards0_5(), NULL, NULL);

   118 	TestDelimitedQueryRemoveAndParseL(KQueryRemoveForwardsPos0, KQuery_RemoveForwards0_0,

   119 									&KQuery_RemoveForwards0_1(), &KQuery_RemoveForwards0_2(),

   120 									&KQuery_RemoveForwards0_3(), &KQuery_RemoveForwards0_4(),

   121 									&KQuery_RemoveForwards0_5(), NULL);

   123 	TestDelimitedQueryInsertAndParseReverseL(KQueryInsertBackwardsPos0, KQuery_InsertBackwards0_0,

   124 											&KQuery_Insert0_a(), &KQuery_InsertBackwards0_1(),

   125 											&KQuery_Insert0_b(), &KQuery_InsertBackwards0_2(),

   126 											&KQuery_Insert0_c(), &KQuery_InsertBackwards0_3(),

   127 											&KQuery_Insert0_d(), &KQuery_InsertBackwards0_4(),

   128 											&KQuery_Insert0_e(), &KQuery_InsertBackwards0_5(), NULL, NULL);

   130 	TestDelimitedQueryRemoveAndParseReverseL(KQueryRemoveBackwardsPos0, KQuery_RemoveBackwards0_0,

   131 											&KQuery_RemoveBackwards0_1(), &KQuery_RemoveBackwards0_2(),

   132 											&KQuery_RemoveBackwards0_3(), &KQuery_RemoveBackwards0_4(),

   133 											&KQuery_RemoveBackwards0_5(), NULL);

   135 	TestDelimitedQueryInsertEscapeAndParseL(KQueryInsertEscapeForwardsPos0, KQuery_InsertEscapeForwards0_0,

   136 									&KQuery_InsertEscape0_a(), &KQuery_InsertEscapeForwards0_1(),

   137 									&KQuery_InsertEscape0_b(), &KQuery_InsertEscapeForwards0_2(),

   138 									&KQuery_InsertEscape0_c(), &KQuery_InsertEscapeForwards0_3(),

   139 									&KQuery_InsertEscape0_d(), &KQuery_InsertEscapeForwards0_4(),

   140 									&KQuery_InsertEscape0_e(), &KQuery_InsertEscapeForwards0_5(), NULL, NULL);

   142 	TestDelimitedQueryInsertEscapeAndParseReverseL(KQueryInsertEscapeBackwardsPos0, KQuery_InsertEscapeBackwards0_0,

   143 											&KQuery_InsertEscape0_a(), &KQuery_InsertEscapeBackwards0_1(),

   144 											&KQuery_InsertEscape0_b(), &KQuery_InsertEscapeBackwards0_2(),

   145 											&KQuery_InsertEscape0_c(), &KQuery_InsertEscapeBackwards0_3(),

   146 											&KQuery_InsertEscape0_d(), &KQuery_InsertEscapeBackwards0_4(),

   147 											&KQuery_InsertEscape0_e(), &KQuery_InsertEscapeBackwards0_5(), NULL, NULL);

   149 	TestDelimitedQueryPushAndEscapeFrontL(KQuery_PushEscapeFront0_0, &KQuery_PushEscape0_a(), &KQuery_PushEscapeFront0_1(),

   150 										&KQuery_PushEscape0_b(), &KQuery_PushEscapeFront0_2(),

   151 										&KQuery_PushEscape0_c(), &KQuery_PushEscapeFront0_3(),

   152 										&KQuery_PushEscape0_d(), &KQuery_PushEscapeFront0_4(),

   153 										&KQuery_PushEscape0_e(), &KQuery_PushEscapeFront0_5(), NULL, NULL);

   155 	TestDelimitedQueryPushAndEscapeBackL(KQuery_PushEscapeBack0_0, &KQuery_PushEscape0_a(), &KQuery_PushEscapeBack0_1(),

   156 										&KQuery_PushEscape0_b(), &KQuery_PushEscapeBack0_2(),

   157 										&KQuery_PushEscape0_c(), &KQuery_PushEscapeBack0_3(),

   158 										&KQuery_PushEscape0_d(), &KQuery_PushEscapeBack0_4(),

   159 										&KQuery_PushEscape0_e(), &KQuery_PushEscapeBack0_5(), NULL, NULL);

   160 	}

   162 //

   163 //

   164 //	Delimited Query tests

   165 //

   166 //

   168 void CDelimitedQueryTest::TestDelimitedQueryExtractionL(TRefByValue<const TDesC> aQuery, ...) const

   169 	{

   170 	VA_LIST list1; VA_START(list1, aQuery);

   171 	VA_LIST list2; VA_START(list2, aQuery);

   172 	const TDesC& path = aQuery;

   174 	TestDelimitedDataExtractionL(_L("Test TDelimitedQueryParser Parse : GetNext, Dec, Inc, Peek and Eos"), iTestHarness, path, list1, list2);

   175 	VA_END(list1); VA_END(list2);

   176 	}

   178 void CDelimitedQueryTest::TestDelimitedQueryReverseExtractionL(TRefByValue<const TDesC> aQuery, ...) const

   179 	{

   180 	VA_LIST list1; VA_START(list1, aQuery);

   181 	VA_LIST list2; VA_START(list2, aQuery);

   182 	const TDesC& path = aQuery;

   184 	TestDelimitedDataReverseExtractionL(_L("Test TDelimitedQueryParser ParseReverse : GetNext, Dec, Inc, Peek and Eos"), iTestHarness, path, list1, list2);

   185 	VA_END(list1); VA_END(list2);

   186 	}

   188 void CDelimitedQueryTest::TestDelimitedQueryDelimiterPresenceL(const TDesC& aQuery, TBool aFrontDelim, TBool aBackDelim) const

   189 	{

   190 	TestDelimitedDataDelimiterPresenceL(_L("Test TDelimitedQueryParser Delimiter Presence"), iTestHarness, aQuery, aFrontDelim, aBackDelim);

   191 	}

   193 void CDelimitedQueryTest::TestDelimitedQueryRemainderL(TRefByValue<const TDesC> aQuery, ...) const

   194 	{

   195 	VA_LIST list1; VA_START(list1, aQuery);

   196 	VA_LIST list2; VA_START(list2, aQuery);

   197 	const TDesC& path = aQuery;

   199 	TestDelimitedDataRemainderL(_L("Test TDelimitedQueryParser Remainder, Parse"), iTestHarness, path, list1, list2);

   200 	VA_END(list1); VA_END(list2);

   201 	}

   203 void CDelimitedQueryTest::TestDelimitedQueryRemainderReverseL(TRefByValue<const TDesC> aQuery, ...) const

   204 	{

   205 	VA_LIST list1; VA_START(list1, aQuery);

   206 	VA_LIST list2; VA_START(list2, aQuery);

   207 	const TDesC& path = aQuery;

   209 	TestDelimitedDataRemainderReverseL(_L("Test TDelimitedQueryParser Remainder, ParseReverse"), iTestHarness, path, list1, list2);

   210 	VA_END(list1); VA_END(list2);

   211 	}

   213 void CDelimitedQueryTest::TestDelimitedQueryDesL(const TDesC& aQuery) const

   214 	{

   215 	TestDelimitedDataDesL(_L("Test TDelimitedQueryParser Des"), iTestHarness, aQuery);

   216 	}

   218 void CDelimitedQueryTest::TestDelimitedQueryPushFrontL(TRefByValue<const TDesC> aQuery, ...) const

   219 	{

   220 	VA_LIST list1; VA_START(list1, aQuery);

   221 	VA_LIST list2; VA_START(list2, aQuery);

   222 	const TDesC& path = aQuery;

   224 	TestDelimitedDataPushFrontL(_L("Test CDelimitedQuery PushFront"), iTestHarness, path, list1, list2);

   225 	VA_END(list1);

   226 	VA_END(list2);

   227 	}

   229 void CDelimitedQueryTest::TestDelimitedQueryPushBackL(TRefByValue<const TDesC> aQuery, ...) const

   230 	{

   231 	VA_LIST list1; VA_START(list1, aQuery);

   232 	VA_LIST list2; VA_START(list2, aQuery);

   233 	const TDesC& path = aQuery;

   235 	TestDelimitedDataPushBackL(_L("Test CDelimitedQuery PushBack"), iTestHarness, path, list1, list2);

   236 	VA_END(list1); VA_END(list2);

   237 	}

   239 void CDelimitedQueryTest::TestDelimitedQueryPopFrontL(TRefByValue<const TDesC> aQuery, ...) const

   240 	{

   241 	VA_LIST list1; VA_START(list1, aQuery);

   242 	VA_LIST list2; VA_START(list2, aQuery);

   243 	const TDesC& path = aQuery;

   245 	TestDelimitedDataPopFrontL(_L("Test CDelimitedQuery PopFront"), iTestHarness, path, list1, list2);

   246 	VA_END(list1); VA_END(list2);

   247 	}

   249 void CDelimitedQueryTest::TestDelimitedQueryPopBackL(TRefByValue<const TDesC> aQuery, ...) const

   250 	{

   251 	VA_LIST list1; VA_START(list1, aQuery);

   252 	VA_LIST list2; VA_START(list2, aQuery);

   253 	const TDesC& path = aQuery;

   255 	TestDelimitedDataPopBackL(_L("Test CDelimitedQuery PopBack"), iTestHarness, path, list1, list2);

   256 	VA_END(list1); VA_END(list2);

   257 	}

   259 void CDelimitedQueryTest::TestDelimitedQueryAddAndTrimFrontAndBackDelimiterL(const TDesC& aQuery) const

   260 	{

   261 	TestDelimitedDataAddAndTrimFrontAndBackDelimiterL(_L("Test CDelimitedQuery Add and Trim Front and Back delimiter"), iTestHarness, aQuery);

   262 	}

   264 void CDelimitedQueryTest::TestDelimitedQueryInsertAndParseL(TInt aStartPos, TRefByValue<const TDesC> aQuery, ...) const

   265 	{

   266 	VA_LIST list1; VA_START(list1, aQuery);

   267 	VA_LIST list2; VA_START(list2, aQuery);

   268 	const TDesC& path = aQuery;

   270 	TestDelimitedDataInsertAndParseL(_L("Test CDelimitedQuery InsertCurrent, Parse"), iTestHarness, path, list1, list2, aStartPos);

   271 	VA_END(list1); VA_END(list2);

   272 	}

   274 void CDelimitedQueryTest::TestDelimitedQueryRemoveAndParseL(TInt aStartPos, TRefByValue<const TDesC> aQuery, ...) const

   275 	{

   276 	VA_LIST list1; VA_START(list1, aQuery);

   277 	VA_LIST list2; VA_START(list2, aQuery);

   278 	const TDesC& path = aQuery;

   280 	TestDelimitedDataRemoveAndParseL(_L("Test CDelimitedQuery RemoveCurrent, Parse"), iTestHarness, path, list1, list2, aStartPos);

   281 	VA_END(list1); VA_END(list2);

   282 	}

   284 void CDelimitedQueryTest::TestDelimitedQueryInsertAndParseReverseL(TInt aStartPos, TRefByValue<const TDesC> aQuery, ...) const

   285 	{

   286 	VA_LIST list1; VA_START(list1, aQuery);

   287 	VA_LIST list2; VA_START(list2, aQuery);

   288 	const TDesC& path = aQuery;

   290 	TestDelimitedDataInsertAndParseReverseL(_L("Test CDelimitedQuery InsertCurrent, ParseReverse"), iTestHarness, path, list1, list2, aStartPos);

   291 	VA_END(list1); VA_END(list2);

   292 	}

   294 void CDelimitedQueryTest::TestDelimitedQueryRemoveAndParseReverseL(TInt aStartPos, TRefByValue<const TDesC> aQuery, ...) const

   295 	{

   296 	VA_LIST list1; VA_START(list1, aQuery);

   297 	VA_LIST list2; VA_START(list2, aQuery);

   298 	const TDesC& path = aQuery;

   300 	TestDelimitedDataRemoveAndParseReverseL(_L("Test CDelimitedQuery RemoveCurrent, ParseReverse"), iTestHarness, path, list1, list2, aStartPos);

   301 	VA_END(list1); VA_END(list2);

   302 	}

   304 void CDelimitedQueryTest::TestDelimitedQueryInsertEscapeAndParseL(TInt aStartPos, TRefByValue<const TDesC> aQuery, ...) const

   305 	{

   306 	VA_LIST list1; VA_START(list1, aQuery);

   307 	VA_LIST list2; VA_START(list2, aQuery);

   308 	const TDesC& path = aQuery;

   310 	TestDelimitedDataInsertEscapeAndParseL(_L("Test CDelimitedQuery InsertAndEscapeCurrent, Parse"), iTestHarness, path, list1, list2, aStartPos);

   311 	VA_END(list1); VA_END(list2);

   312 	}

   314 void CDelimitedQueryTest::TestDelimitedQueryInsertEscapeAndParseReverseL(TInt aStartPos, TRefByValue<const TDesC> aQuery, ...) const

   315 	{

   316 	VA_LIST list1; VA_START(list1, aQuery);

   317 	VA_LIST list2; VA_START(list2, aQuery);

   318 	const TDesC& path = aQuery;

   320 	TestDelimitedDataInsertEscapeAndParseReverseL(_L("Test CDelimitedQuery InsertAndEscapeCurrent, ParseReverse"), iTestHarness, path, list1, list2, aStartPos);

   321 	VA_END(list1); VA_END(list2);

   322 	}

   324 void CDelimitedQueryTest::TestDelimitedQueryPushAndEscapeFrontL(TRefByValue<const TDesC> aQuery, ...) const

   325 	{

   326 	VA_LIST list1; VA_START(list1, aQuery);

   327 	VA_LIST list2; VA_START(list2, aQuery);

   328 	const TDesC& path = aQuery;

   330 	TestDelimitedDataPushAndEscapeFrontL(_L("Test CDelimitedQuery PushAndEscapeFront"), iTestHarness, path, list1, list2);

   331 	VA_END(list1); VA_END(list2);

   332 	}

   334 void CDelimitedQueryTest::TestDelimitedQueryPushAndEscapeBackL(TRefByValue<const TDesC> aQuery, ...) const

   335 	{

   336 	VA_LIST list1; VA_START(list1, aQuery);

   337 	VA_LIST list2; VA_START(list2, aQuery);

   338 	const TDesC& path = aQuery;

   340 	TestDelimitedDataPushAndEscapeBackL(_L("Test CDelimitedQuery PushAndEscapeBack"), iTestHarness, path, list1, list2);

   341 	VA_END(list1); VA_END(list2);

   342 	}

   343 //

   344 //

   345 //	Implementation of LOCAL functions - test funcions

   346 //

   347 //

   349 void TestDelimitedDataExtractionL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness,

   350 										  const TDesC& aData, VA_LIST& aList1, VA_LIST& aList2)	{

   351 	// Create title

   352 	HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());

   353 	title16Bit->Des().Format(KTitle16Bit, &aTestTitle);

   354 	aTestHarness->StartTestL(*title16Bit);

   356 	// Create TDelimitedQueryParser object and do parsing

   357 	TDelimitedQueryParser16 parser16Bit;

   358 	parser16Bit.Parse(aData);

   360 	TInt error = DoDelimitedDataParsingL<HBufC16, TPtrC16>(parser16Bit, aList1);

   362 	CleanupStack::PopAndDestroy(title16Bit);	// title16Bit

   363 	aTestHarness->EndTest(error);

   365 	// Make 8-bit copy

   366 	HBufC8* dataBuf = HBufC8::NewLC(aData.Length());

   367 	TPtr8 data8Bit = dataBuf->Des();

   368 	data8Bit.Copy(aData);

   370 	HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());

   371 	title8Bit->Des().Format(KTitle8Bit, &aTestTitle);

   372 	aTestHarness->StartTestL(*title8Bit);

   374 	// Create TDelimitedQueryParser object and do parsing

   375 	TDelimitedQueryParser8 parser8Bit;

   376 	parser8Bit.Parse(data8Bit);

   378 	error = DoDelimitedDataParsingL<HBufC8, TPtrC8>(parser8Bit, aList2);

   380 	aTestHarness->EndTest(error);

   381 	CleanupStack::PopAndDestroy(2, dataBuf);	// dataBuf, title8Bit

   382 	}

   384 void TestDelimitedDataReverseExtractionL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness,

   385 												 const TDesC& aData, VA_LIST& aList1, VA_LIST& aList2)

   386 	{

   387 	// Create title

   388 	HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());

   389 	title16Bit->Des().Format(KTitle16Bit, &aTestTitle);

   390 	aTestHarness->StartTestL(*title16Bit);

   392 	// Create TDelimitedQueryParser object and do parsing

   393 	TDelimitedQueryParser16 parser16Bit;

   394 	parser16Bit.ParseReverse(aData);

   396 	TInt error = DoDelimitedDataParsingL<HBufC16, TPtrC16>(parser16Bit, aList1);

   398 	CleanupStack::PopAndDestroy(title16Bit);	// title16Bit

   399 	aTestHarness->EndTest(error);

   401 	// Make 8-bit copy

   402 	HBufC8* dataBuf = HBufC8::NewLC(aData.Length());

   403 	TPtr8 data8Bit = dataBuf->Des();

   404 	data8Bit.Copy(aData);

   406 	// Create title

   407 	HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());

   408 	title8Bit->Des().Format(KTitle8Bit, &aTestTitle);

   409 	aTestHarness->StartTestL(*title8Bit);

   411 	// Create TDelimitedQueryParser object and do parsing

   412 	TDelimitedQueryParser8 parser8Bit;

   413 	parser8Bit.ParseReverse(data8Bit);

   415 	error = DoDelimitedDataParsingL<HBufC8, TPtrC8>(parser8Bit, aList2);

   417 	aTestHarness->EndTest(error);

   418 	CleanupStack::PopAndDestroy(2, dataBuf);	// dataBuf, title8Bit

   419 	}

   421 void TestDelimitedDataDelimiterPresenceL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness,

   422 												 const TDesC& aData, TBool aFrontDelim, TBool aBackDelim)

   423 	{

   424 	// Create title

   425 	HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());

   426 	title16Bit->Des().Format(KTitle16Bit, &aTestTitle);

   427 	aTestHarness->StartTestL(*title16Bit);

   429 	// Create TDelimitedQueryParser object

   430 	TDelimitedQueryParser16 parser16Bit;

   431 	parser16Bit.Parse(aData);

   432 	TInt error = DoDelimiterPresenceTest(parser16Bit, aFrontDelim, aBackDelim);

   434 	CleanupStack::PopAndDestroy(title16Bit);	// title16Bit

   435 	aTestHarness->EndTest(error);

   437 	// Make 8-bit copy

   438 	HBufC8* dataBuf = HBufC8::NewLC(aData.Length());

   439 	TPtr8 data8Bit = dataBuf->Des();

   440 	data8Bit.Copy(aData);

   442 	// Create title

   443 	HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());

   444 	title8Bit->Des().Format(KTitle8Bit, &aTestTitle);

   445 	aTestHarness->StartTestL(*title8Bit);

   447 	// Create TDelimitedQueryParser object

   448 	TDelimitedQueryParser8 parser8Bit;

   449 	parser8Bit.Parse(data8Bit);

   450 	error = DoDelimiterPresenceTest(parser8Bit, aFrontDelim, aBackDelim);

   452 	aTestHarness->EndTest(error);

   453 	CleanupStack::PopAndDestroy(2, dataBuf);	// dataBuf, title8Bit

   454 	}

   456 void TestDelimitedDataRemainderL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness,

   457 										 const TDesC& aData, VA_LIST& aList1, VA_LIST& aList2)

   458 	{

   459 	// Create title

   460 	HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());

   461 	title16Bit->Des().Format(KTitle16Bit, &aTestTitle);

   462 	aTestHarness->StartTestL(*title16Bit);

   464 	// Create TDelimiteddataParser object and do parsing

   465 	TDelimitedQueryParser16 parser16Bit;

   466 	parser16Bit.Parse(aData);

   468 	TInt error = DoDelimitedDataRemainderTestL<HBufC16, TPtrC16>(parser16Bit, aList1);

   470 	CleanupStack::PopAndDestroy(title16Bit);	// title16Bit

   471 	aTestHarness->EndTest(error);

   473 	// Make 8-bit copy

   474 	HBufC8* dataBuf = HBufC8::NewLC(aData.Length());

   475 	TPtr8 data8Bit = dataBuf->Des();

   476 	data8Bit.Copy(aData);

   478 	// Create title

   479 	HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());

   480 	title8Bit->Des().Format(KTitle8Bit, &aTestTitle);

   481 	aTestHarness->StartTestL(*title8Bit);

   483 	// Create TDelimiteddataParser object and do parsing

   484 	TDelimitedQueryParser8 parser8Bit;

   485 	parser8Bit.Parse(data8Bit);

   487 	error = DoDelimitedDataRemainderTestL<HBufC8, TPtrC8>(parser8Bit, aList2);

   489 	aTestHarness->EndTest(error);

   490 	CleanupStack::PopAndDestroy(2, dataBuf);	// dataBuf, title8Bit

   491 	}

   493 void TestDelimitedDataRemainderReverseL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness,

   494 												const TDesC& aData, VA_LIST& aList1, VA_LIST& aList2)

   495 	{

   496 	// Create title

   497 	HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());

   498 	title16Bit->Des().Format(KTitle16Bit, &aTestTitle);

   499 	aTestHarness->StartTestL(*title16Bit);

   501 	// Create TDelimitedQueryParser object and do parsing

   502 	TDelimitedQueryParser16 parser16Bit;

   503 	parser16Bit.ParseReverse(aData);

   505 	TInt error = DoDelimitedDataRemainderTestL<HBufC16, TPtrC16>(parser16Bit, aList1);

   507 	CleanupStack::PopAndDestroy(title16Bit);	// title16Bit

   508 	aTestHarness->EndTest(error);

   510 	// Make 8-bit copy

   511 	HBufC8* dataBuf = HBufC8::NewLC(aData.Length());

   512 	TPtr8 data8Bit = dataBuf->Des();

   513 	data8Bit.Copy(aData);

   515 	// Create title

   516 	HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());

   517 	title8Bit->Des().Format(KTitle8Bit, &aTestTitle);

   518 	aTestHarness->StartTestL(*title8Bit);

   520 	// Create TDelimitedQueryParser object and do parsing

   521 	TDelimitedQueryParser8 parser8Bit;

   522 	parser8Bit.ParseReverse(data8Bit);

   524 	error = DoDelimitedDataRemainderTestL<HBufC8, TPtrC8>(parser8Bit, aList2);

   526 	aTestHarness->EndTest(error);

   527 	CleanupStack::PopAndDestroy(2, dataBuf);	// dataBuf, title8Bit

   528 	}

   530 void TestDelimitedDataDesL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness, const TDesC& aData)

   531 	{

   532 	// Create title

   533 	HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());

   534 	title16Bit->Des().Format(KTitle16Bit, &aTestTitle);

   535 	aTestHarness->StartTestL(*title16Bit);

   537 	// Create TDelimitedQueryParser object and do parsing

   538 	TDelimitedQueryParser16 parser16Bit;

   539 	parser16Bit.Parse(aData);

   541 	TInt error = DoDelimitedDataDes(parser16Bit, aData);

   543 	CleanupStack::PopAndDestroy(title16Bit);	// title16Bit

   544 	aTestHarness->EndTest(error);

   546 	// Make 8-bit copy

   547 	HBufC8* dataBuf = HBufC8::NewLC(aData.Length());

   548 	TPtr8 data8Bit = dataBuf->Des();

   549 	data8Bit.Copy(aData);

   551 	// Create title

   552 	HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());

   553 	title8Bit->Des().Format(KTitle8Bit, &aTestTitle);

   554 	aTestHarness->StartTestL(*title8Bit);

   556 	// Create TDelimitedQueryParser object and do parsing

   557 	TDelimitedQueryParser8 parser8Bit;

   558 	parser8Bit.Parse(data8Bit);

   560 	error = DoDelimitedDataDes(parser8Bit, data8Bit);

   562 	aTestHarness->EndTest(error);

   563 	CleanupStack::PopAndDestroy(2, dataBuf);	// dataBuf, title8Bit

   564 	}

   566 void TestDelimitedDataPushFrontL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness,

   567 										 const TDesC& aData, VA_LIST& aList1, VA_LIST& aList2)

   568 	{

   569 	// Create title

   570 	HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());

   571 	title16Bit->Des().Format(KTitle16Bit, &aTestTitle);

   572 	aTestHarness->StartTestL(*title16Bit);

   574 	// Create TDelimitedQueryParser object and do parsing

   575 	CDelimitedQuery16* data16Bit = CDelimitedQuery16::NewL(aData);	// Also excersies NewLC()

   576 	CleanupStack::PushL(data16Bit);

   578 	TInt error = DoDelimitedDataPushFrontL<HBufC16>(data16Bit, aList1);

   580 	CleanupStack::PopAndDestroy(2, title16Bit);	// title16Bit, data16Bit

   581 	aTestHarness->EndTest(error);

   583 	// Make 8-bit copy

   584 	HBufC8* dataBuf = HBufC8::NewLC(aData.Length());

   585 	TPtr8 initData8Bit = dataBuf->Des();

   586 	initData8Bit.Copy(aData);

   588 	// Create title

   589 	HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());

   590 	title8Bit->Des().Format(KTitle8Bit, &aTestTitle);

   591 	aTestHarness->StartTestL(*title8Bit);

   593 	// Create TDelimitedQueryParser object and do parsing

   594 	CDelimitedQuery8* data8Bit = CDelimitedQuery8::NewL(initData8Bit);	// Also excersies NewLC()

   595 	CleanupStack::PushL(data8Bit);

   597 	error = DoDelimitedDataPushFrontL<HBufC8>(data8Bit, aList2);

   599 	aTestHarness->EndTest(error);

   600 	CleanupStack::PopAndDestroy(3, dataBuf);	// dataBuf, title8Bit, data8Bit

   601 	}

   603 void TestDelimitedDataPushAndEscapeFrontL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness,

   604 												  const TDesC& aData, VA_LIST& aList1, VA_LIST& aList2)

   605 	{

   606 	// Create title

   607 	HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());

   608 	title16Bit->Des().Format(KTitle16Bit, &aTestTitle);

   609 	aTestHarness->StartTestL(*title16Bit);

   611 	// Create TDelimitedQueryParser object and do parsing

   612 	CDelimitedQuery16* data16Bit = CDelimitedQuery16::NewL(aData);	// Also excersies NewLC()

   613 	CleanupStack::PushL(data16Bit);

   615 	TInt error = DoDelimitedDataPushAndEscapeFrontL<HBufC16>(data16Bit, aList1);

   617 	CleanupStack::PopAndDestroy(2, title16Bit);	// title16Bit, data16Bit

   618 	aTestHarness->EndTest(error);

   620 	// Make 8-bit copy

   621 	HBufC8* dataBuf = HBufC8::NewLC(aData.Length());

   622 	TPtr8 initData8Bit = dataBuf->Des();

   623 	initData8Bit.Copy(aData);

   625 	// Create title

   626 	HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());

   627 	title8Bit->Des().Format(KTitle8Bit, &aTestTitle);

   628 	aTestHarness->StartTestL(*title8Bit);

   630 	// Create TDelimitedQueryParser object and do parsing

   631 	CDelimitedQuery8* data8Bit = CDelimitedQuery8::NewL(initData8Bit);	// Also excersies NewLC()

   632 	CleanupStack::PushL(data8Bit);

   634 	error = DoDelimitedDataPushAndEscapeFrontL<HBufC8>(data8Bit, aList2);

   636 	aTestHarness->EndTest(error);

   637 	CleanupStack::PopAndDestroy(3, dataBuf);	// dataBuf, title8Bit, data8Bit

   638 	}

   640 void TestDelimitedDataPushBackL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness,

   641 										const TDesC& aData, VA_LIST& aList1, VA_LIST& aList2)

   642 	{

   643 	// Create title

   644 	HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());

   645 	title16Bit->Des().Format(KTitle16Bit, &aTestTitle);

   646 	aTestHarness->StartTestL(*title16Bit);

   648 	// Create TDelimitedQueryParser object and do parsing

   649 	CDelimitedQuery16* data16Bit = CDelimitedQuery16::NewL(aData);	// Also excersies NewLC()

   650 	CleanupStack::PushL(data16Bit);

   652 	TInt error = DoDelimitedDataPushBackL<HBufC16>(data16Bit, aList1);

   654 	CleanupStack::PopAndDestroy(2, title16Bit);	// title16Bit, data16Bit

   655 	aTestHarness->EndTest(error);

   657 	// Make 8-bit copy

   658 	HBufC8* dataBuf = HBufC8::NewLC(aData.Length());

   659 	TPtr8 initData8Bit = dataBuf->Des();

   660 	initData8Bit.Copy(aData);

   662 	// Create title

   663 	HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());

   664 	title8Bit->Des().Format(KTitle8Bit, &aTestTitle);

   665 	aTestHarness->StartTestL(*title8Bit);

   667 	// Create TDelimitedQueryParser object and do parsing

   668 	CDelimitedQuery8* data8Bit = CDelimitedQuery8::NewL(initData8Bit);	// Also excersies NewLC()

   669 	CleanupStack::PushL(data8Bit);

   671 	error = DoDelimitedDataPushBackL<HBufC8>(data8Bit, aList2);

   673 	aTestHarness->EndTest(error);

   674 	CleanupStack::PopAndDestroy(3, dataBuf);	// dataBuf, title8Bit, data8Bit

   675 	}

   677 void TestDelimitedDataPushAndEscapeBackL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness,

   678 												 const TDesC& aData, VA_LIST& aList1, VA_LIST& aList2)

   679 	{

   680 	// Create title

   681 	HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());

   682 	title16Bit->Des().Format(KTitle16Bit, &aTestTitle);

   683 	aTestHarness->StartTestL(*title16Bit);

   685 	// Create TDelimitedQueryParser object and do parsing

   686 	CDelimitedQuery16* data16Bit = CDelimitedQuery16::NewL(aData);	// Also excersies NewLC()

   687 	CleanupStack::PushL(data16Bit);

   689 	TInt error = DoDelimitedDataPushAndEscapeBackL<HBufC16>(data16Bit, aList1);

   691 	CleanupStack::PopAndDestroy(2, title16Bit);	// title16Bit, data16Bit

   692 	aTestHarness->EndTest(error);

   694 	// Make 8-bit copy

   695 	HBufC8* dataBuf = HBufC8::NewLC(aData.Length());

   696 	TPtr8 initData8Bit = dataBuf->Des();

   697 	initData8Bit.Copy(aData);

   699 	// Create title

   700 	HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());

   701 	title8Bit->Des().Format(KTitle8Bit, &aTestTitle);

   702 	aTestHarness->StartTestL(*title8Bit);

   704 	// Create TDelimitedQueryParser object and do parsing

   705 	CDelimitedQuery8* data8Bit = CDelimitedQuery8::NewL(initData8Bit);	// Also excersies NewLC()

   706 	CleanupStack::PushL(data8Bit);

   708 	error = DoDelimitedDataPushAndEscapeBackL<HBufC8>(data8Bit, aList2);

   710 	aTestHarness->EndTest(error);

   711 	CleanupStack::PopAndDestroy(3, dataBuf);	// dataBuf, title8Bit, data8Bit

   712 	}

   714 void TestDelimitedDataPopFrontL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness,

   715 										const TDesC& aData, VA_LIST& aList1, VA_LIST& aList2)

   716 	{

   717 	// Create title

   718 	HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());

   719 	title16Bit->Des().Format(KTitle16Bit, &aTestTitle);

   720 	aTestHarness->StartTestL(*title16Bit);

   722 	// Create TDelimitedQueryParser object and do parsing

   723 	CDelimitedQuery16* data16Bit = CDelimitedQuery16::NewL(aData);	// Also excersies NewLC()

   724 	CleanupStack::PushL(data16Bit);

   726 	TInt error = DoDelimitedDataPopFrontL<HBufC16>(data16Bit, aList1);

   728 	CleanupStack::PopAndDestroy(2, title16Bit);	// title16Bit, data16Bit

   729 	aTestHarness->EndTest(error);

   731 	// Make 8-bit copy

   732 	HBufC8* dataBuf = HBufC8::NewLC(aData.Length());

   733 	TPtr8 initData8Bit = dataBuf->Des();

   734 	initData8Bit.Copy(aData);

   736 	// Create title

   737 	HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());

   738 	title8Bit->Des().Format(KTitle8Bit, &aTestTitle);

   739 	aTestHarness->StartTestL(*title8Bit);

   741 	// Create TDelimitedQueryParser object and do parsing

   742 	CDelimitedQuery8* data8Bit = CDelimitedQuery8::NewL(initData8Bit);	// Also excersies NewLC()

   743 	CleanupStack::PushL(data8Bit);

   745 	error = DoDelimitedDataPopFrontL<HBufC8>(data8Bit, aList2);

   747 	aTestHarness->EndTest(error);

   748 	CleanupStack::PopAndDestroy(3, dataBuf);	// dataBuf, title8Bit, data8Bit

   749 	}

   751 void TestDelimitedDataPopBackL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness,

   752 									   const TDesC& aData, VA_LIST& aList1, VA_LIST& aList2)

   753 	{

   754 	// Create title

   755 	HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());

   756 	title16Bit->Des().Format(KTitle16Bit, &aTestTitle);

   757 	aTestHarness->StartTestL(*title16Bit);

   759 	// Create TDelimitedQueryParser object and do parsing

   760 	CDelimitedQuery16* data16Bit = CDelimitedQuery16::NewL(aData);	// Also excersies NewLC()

   761 	CleanupStack::PushL(data16Bit);

   763 	TInt error = DoDelimitedDataPopBackL<HBufC16>(data16Bit, aList1);

   765 	CleanupStack::PopAndDestroy(2, title16Bit);	// title16Bit, data16Bit

   766 	aTestHarness->EndTest(error);

   768 	// Make 8-bit copy

   769 	HBufC8* dataBuf = HBufC8::NewLC(aData.Length());

   770 	TPtr8 initData8Bit = dataBuf->Des();

   771 	initData8Bit.Copy(aData);

   773 	// Create title

   774 	HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());

   775 	title8Bit->Des().Format(KTitle8Bit, &aTestTitle);

   776 	aTestHarness->StartTestL(*title8Bit);

   778 	// Create TDelimitedQueryParser object and do parsing

   779 	CDelimitedQuery8* data8Bit = CDelimitedQuery8::NewL(initData8Bit);	// Also excersies NewLC()

   780 	CleanupStack::PushL(data8Bit);

   782 	error = DoDelimitedDataPopBackL<HBufC8>(data8Bit, aList2);

   784 	aTestHarness->EndTest(error);

   785 	CleanupStack::PopAndDestroy(3, dataBuf);	// dataBuf, title8Bit, data8Bit

   786 	}

   788 void TestDelimitedDataAddAndTrimFrontAndBackDelimiterL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness, const TDesC& aData)

   789 	{

   790 	// Create title

   791 	HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());

   792 	title16Bit->Des().Format(KTitle16Bit, &aTestTitle);

   793 	aTestHarness->StartTestL(*title16Bit);

   795 	// Create TDelimitedQueryParser object and do parsing

   796 	CDelimitedQuery16* data16Bit = CDelimitedQuery16::NewL(aData);	// Also excersies NewLC()

   797 	CleanupStack::PushL(data16Bit);

   799 	TInt error = DoDelimitedDataAddAndTrimFrontAndBackDelimiterL(data16Bit);

   801 	CleanupStack::PopAndDestroy(2, title16Bit);	// title16Bit, data16Bit

   802 	aTestHarness->EndTest(error);

   804 	// Make 8-bit copy

   805 	HBufC8* dataBuf = HBufC8::NewLC(aData.Length());

   806 	TPtr8 initData8Bit = dataBuf->Des();

   807 	initData8Bit.Copy(aData);

   809 	// Create title

   810 	HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());

   811 	title8Bit->Des().Format(KTitle8Bit, &aTestTitle);

   812 	aTestHarness->StartTestL(*title8Bit);

   814 	// Create TDelimitedQueryParser object and do parsing

   815 	CDelimitedQuery8* data8Bit = CDelimitedQuery8::NewL(initData8Bit);	// Also excersies NewLC()

   816 	CleanupStack::PushL(data8Bit);

   818 	error = DoDelimitedDataAddAndTrimFrontAndBackDelimiterL(data8Bit);

   820 	aTestHarness->EndTest(error);

   821 	CleanupStack::PopAndDestroy(3, dataBuf);	// dataBuf, title8Bit, data8Bit

   822 	}

   824 void TestDelimitedDataInsertAndParseL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness,

   825 											  const TDesC& aData, VA_LIST& aList1, VA_LIST& aList2, TInt aStartPos)

   826 	{

   827 	// Create title

   828 	HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());

   829 	title16Bit->Des().Format(KTitle16Bit, &aTestTitle);

   830 	aTestHarness->StartTestL(*title16Bit);

   832 	// Create TDelimitedQueryParser object and do parsing

   833 	CDelimitedQuery16* data16Bit = CDelimitedQuery16::NewL(aData);	// Also excersies NewLC()

   834 	CleanupStack::PushL(data16Bit);

   836 	// Do initial parse and get to position

   837 	data16Bit->Parse();

   838 	TInt error = DoDelimitedDataParseToPosition(data16Bit, aStartPos);

   839 	if( error == KErrNone )

   840 		{

   841 		error = DoDelimitedDataInsertL<HBufC16, TPtrC16>(data16Bit, aList1);

   842 		}

   843 	CleanupStack::PopAndDestroy(2, title16Bit);	// title16Bit, data16Bit

   844 	aTestHarness->EndTest(error);

   846 	// Make 8-bit copy

   847 	HBufC8* dataBuf = HBufC8::NewLC(aData.Length());

   848 	TPtr8 initData8Bit = dataBuf->Des();

   849 	initData8Bit.Copy(aData);

   851 	// Create title

   852 	HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());

   853 	title8Bit->Des().Format(KTitle8Bit, &aTestTitle);

   854 	aTestHarness->StartTestL(*title8Bit);

   856 	// Create TDelimitedQueryParser object and do parsing

   857 	CDelimitedQuery8* data8Bit = CDelimitedQuery8::NewL(initData8Bit);	// Also excersies NewLC()

   858 	CleanupStack::PushL(data8Bit);

   860 	// Do initial parse and get to position

   861 	data8Bit->Parse();

   862 	error = DoDelimitedDataParseToPosition(data8Bit, aStartPos);

   863 	if( error == KErrNone )

   864 		{

   865 		error = DoDelimitedDataInsertL<HBufC8, TPtrC8>(data8Bit, aList2);

   866 		}

   867 	aTestHarness->EndTest(error);

   868 	CleanupStack::PopAndDestroy(3, dataBuf);	// dataBuf, title8Bit, data8Bit

   869 	}

   871 void TestDelimitedDataRemoveAndParseL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness,

   872 											  const TDesC& aData, VA_LIST& aList1, VA_LIST& aList2, TInt aStartPos)

   873 	{

   874 	// Create title

   875 	HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());

   876 	title16Bit->Des().Format(KTitle16Bit, &aTestTitle);

   877 	aTestHarness->StartTestL(*title16Bit);

   879 	// Create TDelimitedQueryParser object and do parsing

   880 	CDelimitedQuery16* data16Bit = CDelimitedQuery16::NewL(aData);	// Also excersies NewLC()

   881 	CleanupStack::PushL(data16Bit);

   883 	// Do initial parse and get to position

   884 	data16Bit->Parse();

   885 	TInt error = DoDelimitedDataParseToPosition(data16Bit, aStartPos);

   886 	if( error == KErrNone )

   887 		{

   888 		error = DoDelimitedDataRemoveL<HBufC16, TPtrC16>(data16Bit, aList1);

   889 		}

   890 	CleanupStack::PopAndDestroy(2, title16Bit);	// title16Bit, data16Bit

   891 	aTestHarness->EndTest(error);

   893 	// Make 8-bit copy

   894 	HBufC8* dataBuf = HBufC8::NewLC(aData.Length());

   895 	TPtr8 initData8Bit = dataBuf->Des();

   896 	initData8Bit.Copy(aData);

   898 	// Create title

   899 	HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());

   900 	title8Bit->Des().Format(KTitle8Bit, &aTestTitle);

   901 	aTestHarness->StartTestL(*title8Bit);

   903 	// Create TDelimitedQueryParser object and do parsing

   904 	CDelimitedQuery8* data8Bit = CDelimitedQuery8::NewL(initData8Bit);	// Also excersies NewLC()

   905 	CleanupStack::PushL(data8Bit);

   907 	// Do initial parse and get to position

   908 	data8Bit->Parse();

   909 	error = DoDelimitedDataParseToPosition(data8Bit, aStartPos);

   910 	if( error == KErrNone )

   911 		{

   912 		error = DoDelimitedDataRemoveL<HBufC8, TPtrC8>(data8Bit, aList2);

   913 		}

   914 	aTestHarness->EndTest(error);

   915 	CleanupStack::PopAndDestroy(3, dataBuf);	// dataBuf, title8Bit, data8Bit

   916 	}

   918 void TestDelimitedDataInsertAndParseReverseL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness,

   919 													 const TDesC& aData, VA_LIST& aList1, VA_LIST& aList2, TInt aStartPos)

   920 	{

   921 	// Create title

   922 	HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());

   923 	title16Bit->Des().Format(KTitle16Bit, &aTestTitle);

   924 	aTestHarness->StartTestL(*title16Bit);

   926 	// Create TDelimitedQueryParser object and do parsing

   927 	CDelimitedQuery16* data16Bit = CDelimitedQuery16::NewL(aData);	// Also excersies NewLC()

   928 	CleanupStack::PushL(data16Bit);

   930 	// Do initial parse and get to position

   931 	data16Bit->ParseReverse();

   932 	TInt error = DoDelimitedDataParseToPosition(data16Bit, aStartPos);

   933 	if( error == KErrNone )

   934 		{

   935 		error = DoDelimitedDataInsertL<HBufC16, TPtrC16>(data16Bit, aList1);

   936 		}

   937 	CleanupStack::PopAndDestroy(2, title16Bit);	// title16Bit, data16Bit

   938 	aTestHarness->EndTest(error);

   940 	// Make 8-bit copy

   941 	HBufC8* dataBuf = HBufC8::NewLC(aData.Length());

   942 	TPtr8 initData8Bit = dataBuf->Des();

   943 	initData8Bit.Copy(aData);

   945 	// Create title

   946 	HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());

   947 	title8Bit->Des().Format(KTitle8Bit, &aTestTitle);

   948 	aTestHarness->StartTestL(*title8Bit);

   950 	// Create TDelimitedQueryParser object and do parsing

   951 	CDelimitedQuery8* data8Bit = CDelimitedQuery8::NewL(initData8Bit);	// Also excersies NewLC()

   952 	CleanupStack::PushL(data8Bit);

   954 	// Do initial parse and get to position

   955 	data8Bit->ParseReverse();

   956 	error = DoDelimitedDataParseToPosition(data8Bit, aStartPos);

   957 	if( error == KErrNone )

   958 		{

   959 		error = DoDelimitedDataInsertL<HBufC8, TPtrC8>(data8Bit, aList2);

   960 		}

   961 	aTestHarness->EndTest(error);

   962 	CleanupStack::PopAndDestroy(3, dataBuf);	// dataBuf, title8Bit, data8Bit

   963 	}

   965 void TestDelimitedDataRemoveAndParseReverseL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness,

   966 													 const TDesC& aData, VA_LIST& aList1, VA_LIST& aList2, TInt aStartPos)

   967 	{

   968 	// Create title

   969 	HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());

   970 	title16Bit->Des().Format(KTitle16Bit, &aTestTitle);

   971 	aTestHarness->StartTestL(*title16Bit);

   973 	// Create TDelimitedQueryParser object and do parsing

   974 	CDelimitedQuery16* data16Bit = CDelimitedQuery16::NewL(aData);	// Also excersies NewLC()

   975 	CleanupStack::PushL(data16Bit);

   977 	// Do initial parse and get to position

   978 	data16Bit->ParseReverse();

   979 	TInt error = DoDelimitedDataParseToPosition(data16Bit, aStartPos);

   980 	if( error == KErrNone )

   981 		{

   982 		error = DoDelimitedDataRemoveL<HBufC16, TPtrC16>(data16Bit, aList1);

   983 		}

   984 	CleanupStack::PopAndDestroy(2, title16Bit);	// title16Bit, data16Bit

   985 	aTestHarness->EndTest(error);

   987 	// Make 8-bit copy

   988 	HBufC8* dataBuf = HBufC8::NewLC(aData.Length());

   989 	TPtr8 initData8Bit = dataBuf->Des();

   990 	initData8Bit.Copy(aData);

   992 	// Create title

   993 	HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());

   994 	title8Bit->Des().Format(KTitle8Bit, &aTestTitle);

   995 	aTestHarness->StartTestL(*title8Bit);

   997 	// Create TDelimitedQueryParser object and do parsing

   998 	CDelimitedQuery8* data8Bit = CDelimitedQuery8::NewL(initData8Bit);	// Also excersies NewLC()

   999 	CleanupStack::PushL(data8Bit);

  1001 	// Do initial parse and get to position

  1002 	data8Bit->ParseReverse();

  1003 	error = DoDelimitedDataParseToPosition(data8Bit, aStartPos);

  1004 	if( error == KErrNone )

  1005 		{

  1006 		error = DoDelimitedDataRemoveL<HBufC8, TPtrC8>(data8Bit, aList2);

  1007 		}

  1008 	aTestHarness->EndTest(error);

  1009 	CleanupStack::PopAndDestroy(3, dataBuf);	// dataBuf, title8Bit, data8Bit

  1010 	}

  1012 void TestDelimitedDataInsertEscapeAndParseL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness,

  1013 													const TDesC& aData, VA_LIST& aList1, VA_LIST& aList2, TInt aStartPos)

  1014 	{

  1015 	// Create title

  1016 	HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());

  1017 	title16Bit->Des().Format(KTitle16Bit, &aTestTitle);

  1018 	aTestHarness->StartTestL(*title16Bit);

  1020 	// Create TDelimitedQueryParser object and do parsing

  1021 	CDelimitedQuery16* data16Bit = CDelimitedQuery16::NewL(aData);	// Also excersies NewLC()

  1022 	CleanupStack::PushL(data16Bit);

  1024 	// Do initial parse and get to position

  1025 	data16Bit->Parse();

  1026 	TInt error = DoDelimitedDataParseToPosition(data16Bit, aStartPos);

  1027 	if( error == KErrNone )

  1028 		{

  1029 		error = DoDelimitedDataInsertAndEscapeL<HBufC16, TPtrC16>(data16Bit, aList1);

  1030 		}

  1031 	CleanupStack::PopAndDestroy(2, title16Bit);	// title16Bit, data16Bit

  1032 	aTestHarness->EndTest(error);

  1034 	// Make 8-bit copy

  1035 	HBufC8* dataBuf = HBufC8::NewLC(aData.Length());

  1036 	TPtr8 initData8Bit = dataBuf->Des();

  1037 	initData8Bit.Copy(aData);

  1039 	// Create title

  1040 	HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());

  1041 	title8Bit->Des().Format(KTitle8Bit, &aTestTitle);

  1042 	aTestHarness->StartTestL(*title8Bit);

  1044 	// Create TDelimitedQueryParser object and do parsing

  1045 	CDelimitedQuery8* data8Bit = CDelimitedQuery8::NewL(initData8Bit);	// Also excersies NewLC()

  1046 	CleanupStack::PushL(data8Bit);

  1048 	// Do initial parse and get to position

  1049 	data8Bit->Parse();

  1050 	error = DoDelimitedDataParseToPosition(data8Bit, aStartPos);

  1051 	if( error == KErrNone )

  1052 		{

  1053 		error = DoDelimitedDataInsertAndEscapeL<HBufC8, TPtrC8>(data8Bit, aList2);

  1054 		}

  1055 	aTestHarness->EndTest(error);

  1056 	CleanupStack::PopAndDestroy(3, dataBuf);	// dataBuf, title8Bit, data8Bit

  1057 	}

  1059 void TestDelimitedDataInsertEscapeAndParseReverseL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness,

  1060 														   const TDesC& aData, VA_LIST& aList1, VA_LIST& aList2, TInt aStartPos)

  1061 	{

  1062 	// Create title

  1063 	HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());

  1064 	title16Bit->Des().Format(KTitle16Bit, &aTestTitle);

  1065 	aTestHarness->StartTestL(*title16Bit);

  1067 	// Create TDelimitedQueryParser object and do parsing

  1068 	CDelimitedQuery16* data16Bit = CDelimitedQuery16::NewL(aData);	// Also excersies NewLC()

  1069 	CleanupStack::PushL(data16Bit);

  1071 	// Do initial parse and get to position

  1072 	data16Bit->ParseReverse();

  1073 	TInt error = DoDelimitedDataParseToPosition(data16Bit, aStartPos);

  1074 	if( error == KErrNone )

  1075 		{

  1076 		error = DoDelimitedDataInsertAndEscapeL<HBufC16, TPtrC16>(data16Bit, aList1);

  1077 		}

  1078 	CleanupStack::PopAndDestroy(2, title16Bit);	// title16Bit, data16Bit

  1079 	aTestHarness->EndTest(error);

  1081 	// Make 8-bit copy

  1082 	HBufC8* dataBuf = HBufC8::NewLC(aData.Length());

  1083 	TPtr8 initData8Bit = dataBuf->Des();

  1084 	initData8Bit.Copy(aData);

  1086 	// Create title

  1087 	HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());

  1088 	title8Bit->Des().Format(KTitle8Bit, &aTestTitle);

  1089 	aTestHarness->StartTestL(*title8Bit);

  1091 	// Create TDelimitedQueryParser object and do parsing

  1092 	CDelimitedQuery8* data8Bit = CDelimitedQuery8::NewL(initData8Bit);	// Also excersies NewLC()

  1093 	CleanupStack::PushL(data8Bit);

  1095 	// Do initial parse and get to position

  1096 	data8Bit->ParseReverse();

  1097 	error = DoDelimitedDataParseToPosition(data8Bit, aStartPos);

  1098 	if( error == KErrNone )

  1099 		{

  1100 		error = DoDelimitedDataInsertAndEscapeL<HBufC8, TPtrC8>(data8Bit, aList2);

  1101 		}

  1102 	aTestHarness->EndTest(error);

  1103 	CleanupStack::PopAndDestroy(3, dataBuf);	// dataBuf, title8Bit, data8Bit

  1104 	}

  1106 //

  1107 //

  1108 //	Implementation of LOCAL functions - helper functions

  1109 //

  1110 //

  1112 #include "TDelimitedDataCommon.cpp"

author	sl@SLION-WIN7.fritz.box
	Fri, 15 Jun 2012 03:10:57 +0200
changeset 0	bde4ae8d615e
permissions	-rw-r--r--