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 //

    15 

    16 #include "CDelimitedPathTest.h"

    17 

    18 #include <e32base.h>

    19 #include <delimitedpath16.h>

    20 #include <delimitedpath8.h>

    21 

    22 #include "TDelimitedDataCommon.h"

    23 #include "DelimitedPathTests.h"

    24 

    25 // Constants

    26 //

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

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

    29 

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

    31 	{

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

    33 	CleanupStack::PushL(self);

    34 	self->ConstructL();

    35 	return self;

    36 	}

    37 

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

    39 	{

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

    41 	CleanupStack::Pop();	// self

    42 	return self;

    43 	}

    44 

    45 CDelimitedPathTest::CDelimitedPathTest(CIpuTestHarness* aTestHarness)

    46 : iTestHarness(aTestHarness)

    47 	{

    48 	}

    49 

    50 void CDelimitedPathTest::ConstructL()

    51 	{

    52 	}

    53 

    54 CDelimitedPathTest::~CDelimitedPathTest()

    55 	{

    56 	}

    57 

    58 void CDelimitedPathTest::DoTestsL()

    59 	{

    60 //

    61 //

    62 // Delimited Path Tests

    63 //

    64 //

    65 

    66 	TestDelimitedPathExtractionL(KPathParse0, &KPathParse0Seg0(), &KPathParse0Seg1(), &KPathParse0Seg2(),

    67 							   &KPathParse0Seg3(), &KPathParse0Seg4(), NULL);

    68 	TestDelimitedPathExtractionL(KPathParse1, &KPathParse1Seg0(), &KPathParse1Seg1(), NULL);

    69 	TestDelimitedPathExtractionL(KPathParse2, &KPathParse2Seg0(), &KPathParse2Seg1(), &KPathParse2Seg2(), 

    70 							   &KPathParse2Seg3(), &KPathParse2Seg4(), &KPathParse2Seg5(), &KPathParse2Seg6(), NULL);

    71 

    72 	TestDelimitedPathReverseExtractionL(KPathParse0, &KPathParse0Seg4(), &KPathParse0Seg3(), &KPathParse0Seg2(),

    73 							   &KPathParse0Seg1(), &KPathParse0Seg0(), NULL);

    74 	TestDelimitedPathReverseExtractionL(KPathParse1, &KPathParse1Seg1(), &KPathParse1Seg0(), NULL);

    75 	TestDelimitedPathReverseExtractionL(KPathParse2, &KPathParse2Seg6(), &KPathParse2Seg5(), &KPathParse2Seg4(), 

    76 							   &KPathParse2Seg3(), &KPathParse2Seg2(), &KPathParse2Seg1(), &KPathParse2Seg0(), NULL);

    77 

    78 	TestDelimitedPathDelimiterPresenceL(KPath_DelimPresence0, KPath_FrontDelim0, KPath_BackDelim0);

    79 	TestDelimitedPathDelimiterPresenceL(KPath_DelimPresence1, KPath_FrontDelim1, KPath_BackDelim1);

    80 	TestDelimitedPathDelimiterPresenceL(KPath_DelimPresence2, KPath_FrontDelim2, KPath_BackDelim2);

    81 	TestDelimitedPathDelimiterPresenceL(KPath_DelimPresence3, KPath_FrontDelim3, KPath_BackDelim3);

    82 

    83 	TestDelimitedPathRemainderL(KPath_Rem_Forwards0_0, &KPath_Rem_Forwards0_0(), &KPath_Rem_Forwards0_1(), 

    84 								&KPath_Rem_Forwards0_2(), &KPath_Rem_Forwards0_3(), &KPath_Rem_Forwards0_4(), NULL);

    85 	TestDelimitedPathRemainderL(KPath_Rem_Forwards1_0, &KPath_Rem_Forwards1_0(), &KPath_Rem_Forwards1_1(), 

    86 								&KPath_Rem_Forwards1_2(), &KPath_Rem_Forwards1_3(), NULL);

    87 	TestDelimitedPathRemainderL(KPath_Rem_Forwards2_0, &KPath_Rem_Forwards2_0(), &KPath_Rem_Forwards2_1(), 

    88 								&KPath_Rem_Forwards2_2(), &KPath_Rem_Forwards2_3(), NULL);

    89 

    90 	TestDelimitedPathRemainderReverseL(KPath_Rem_Backwards0_0, &KPath_Rem_Backwards0_0(), &KPath_Rem_Backwards0_1(), 

    91 								&KPath_Rem_Backwards0_2(), &KPath_Rem_Backwards0_3(), &KPath_Rem_Backwards0_4(), NULL);

    92 	TestDelimitedPathRemainderReverseL(KPath_Rem_Backwards1_0, &KPath_Rem_Backwards1_0(), &KPath_Rem_Backwards1_1(), 

    93 								&KPath_Rem_Backwards1_2(), &KPath_Rem_Backwards1_3(), NULL);

    94 	TestDelimitedPathRemainderReverseL(KPath_Rem_Backwards2_0, &KPath_Rem_Backwards2_0(), &KPath_Rem_Backwards2_1(), 

    95 								&KPath_Rem_Backwards2_2(), &KPath_Rem_Backwards2_3(), NULL);

    96 

    97 	TestDelimitedPathDesL(KPath_Des0);

    98 

    99 	TestDelimitedPathPushFrontL(KPath_PushPopFront0_0, &KPath_Push0_a(), &KPath_PushPopFront0_1(), 

   100 								&KPath_Push0_b(), &KPath_PushPopFront0_2(), 

   101 								&KPath_Push0_c(), &KPath_PushPopFront0_3(), 

   102 								&KPath_Push0_d(), &KPath_PushPopFront0_4(), 

   103 								&KPath_Push0_e(), &KPath_PushPopFront0_5(), NULL, NULL);

   104 

   105 	TestDelimitedPathPushBackL(KPath_PushPopBack0_0, &KPath_Push0_a(), &KPath_PushPopBack0_1(), 

   106 								&KPath_Push0_b(), &KPath_PushPopBack0_2(), 

   107 								&KPath_Push0_c(), &KPath_PushPopBack0_3(), 

   108 								&KPath_Push0_d(), &KPath_PushPopBack0_4(), 

   109 								&KPath_Push0_e(), &KPath_PushPopBack0_5(), NULL, NULL);

   110 

   111 	TestDelimitedPathPopFrontL(KPath_PushPopFront0_5, &KPath_PushPopFront0_4(), &KPath_PushPopFront0_3(), 

   112 								&KPath_PushPopFront0_2(), &KPath_PushPopFront0_1(), &KPath_PushPopFront0_0(), NULL);

   113 

   114 	TestDelimitedPathPopBackL(KPath_PushPopBack0_5, &KPath_PushPopBack0_4(), &KPath_PushPopBack0_3(), 

   115 								&KPath_PushPopBack0_2(), &KPath_PushPopBack0_1(), &KPath_PushPopBack0_0(), NULL);

   116 

   117 	TestDelimitedPathAddAndTrimFrontAndBackDelimiterL(KPath_AddTrimDelim0);

   118 

   119 	TestDelimitedPathInsertAndParseL(KPathInsertForwardsPos0, KPath_InsertForwards0_0, 

   120 									&KPath_Insert0_a(), &KPath_InsertForwards0_1(), 

   121 									&KPath_Insert0_b(), &KPath_InsertForwards0_2(), 

   122 									&KPath_Insert0_c(), &KPath_InsertForwards0_3(), 

   123 									&KPath_Insert0_d(), &KPath_InsertForwards0_4(), 

   124 									&KPath_Insert0_e(), &KPath_InsertForwards0_5(), NULL, NULL);

   125 

   126 	TestDelimitedPathRemoveAndParseL(KPathRemoveForwardsPos0, KPath_RemoveForwards0_0, 

   127 									&KPath_RemoveForwards0_1(), &KPath_RemoveForwards0_2(), 

   128 									&KPath_RemoveForwards0_3(), &KPath_RemoveForwards0_4(), 

   129 									&KPath_RemoveForwards0_5(), NULL);

   130 

   131 	TestDelimitedPathInsertAndParseReverseL(KPathInsertBackwardsPos0, KPath_InsertBackwards0_0, 

   132 											&KPath_Insert0_a(), &KPath_InsertBackwards0_1(), 

   133 											&KPath_Insert0_b(), &KPath_InsertBackwards0_2(), 

   134 											&KPath_Insert0_c(), &KPath_InsertBackwards0_3(), 

   135 											&KPath_Insert0_d(), &KPath_InsertBackwards0_4(), 

   136 											&KPath_Insert0_e(), &KPath_InsertBackwards0_5(), NULL, NULL);

   137 

   138 	TestDelimitedPathRemoveAndParseReverseL(KPathRemoveBackwardsPos0, KPath_RemoveBackwards0_0, 

   139 											&KPath_RemoveBackwards0_1(), &KPath_RemoveBackwards0_2(), 

   140 											&KPath_RemoveBackwards0_3(), &KPath_RemoveBackwards0_4(), 

   141 											&KPath_RemoveBackwards0_5(), NULL);

   142 

   143 	TestDelimitedPathInsertEscapeAndParseL(KPathInsertEscapeForwardsPos0, KPath_InsertEscapeForwards0_0, 

   144 									&KPath_InsertEscape0_a(), &KPath_InsertEscapeForwards0_1(), 

   145 									&KPath_InsertEscape0_b(), &KPath_InsertEscapeForwards0_2(), 

   146 									&KPath_InsertEscape0_c(), &KPath_InsertEscapeForwards0_3(), 

   147 									&KPath_InsertEscape0_d(), &KPath_InsertEscapeForwards0_4(), 

   148 									&KPath_InsertEscape0_e(), &KPath_InsertEscapeForwards0_5(), NULL, NULL);

   149 

   150 	TestDelimitedPathInsertEscapeAndParseReverseL(KPathInsertEscapeBackwardsPos0, KPath_InsertEscapeBackwards0_0, 

   151 											&KPath_InsertEscape0_a(), &KPath_InsertEscapeBackwards0_1(), 

   152 											&KPath_InsertEscape0_b(), &KPath_InsertEscapeBackwards0_2(), 

   153 											&KPath_InsertEscape0_c(), &KPath_InsertEscapeBackwards0_3(), 

   154 											&KPath_InsertEscape0_d(), &KPath_InsertEscapeBackwards0_4(), 

   155 											&KPath_InsertEscape0_e(), &KPath_InsertEscapeBackwards0_5(), NULL, NULL);

   156 

   157 	TestDelimitedPathPushAndEscapeFrontL(KPath_PushEscapeFront0_0, &KPath_PushEscape0_a(), &KPath_PushEscapeFront0_1(), 

   158 										&KPath_PushEscape0_b(), &KPath_PushEscapeFront0_2(), 

   159 										&KPath_PushEscape0_c(), &KPath_PushEscapeFront0_3(), 

   160 										&KPath_PushEscape0_d(), &KPath_PushEscapeFront0_4(), 

   161 										&KPath_PushEscape0_e(), &KPath_PushEscapeFront0_5(), NULL, NULL);

   162 

   163 	TestDelimitedPathPushAndEscapeBackL(KPath_PushEscapeBack0_0, &KPath_PushEscape0_a(), &KPath_PushEscapeBack0_1(), 

   164 										&KPath_PushEscape0_b(), &KPath_PushEscapeBack0_2(), 

   165 										&KPath_PushEscape0_c(), &KPath_PushEscapeBack0_3(), 

   166 										&KPath_PushEscape0_d(), &KPath_PushEscapeBack0_4(), 

   167 										&KPath_PushEscape0_e(), &KPath_PushEscapeBack0_5(), NULL, NULL);

   168 

   169 //

   170 //

   171 // Delimited PathSegment Tests

   172 //

   173 //

   174 /*

   175 	TestDelimitedPathSegmentExtractionL(KPathSegmentParse0, &KPathSegmentParse0Seg0(), &KPathSegmentParse0Seg1(), 

   176 										&KPathSegmentParse0Seg2(), NULL);

   177 	TestDelimitedPathSegmentExtractionL(KPathSegmentParse1, &KPathSegmentParse1Seg0(), &KPathSegmentParse1Seg1(), &KPathSegmentParse1Seg2(), 

   178 								&KPathSegmentParse1Seg3(), NULL);

   179 	TestDelimitedPathSegmentExtractionL(KPathSegmentParse2, &KPathSegmentParse2Seg0(), &KPathSegmentParse2Seg1(), &KPathSegmentParse2Seg2(), 

   180 							   &KPathSegmentParse2Seg3(), &KPathSegmentParse2Seg4(), &KPathSegmentParse2Seg5(), &KPathSegmentParse2Seg6(), 

   181 							   &KPathSegmentParse2Seg7(), NULL);

   182 

   183 	TestDelimitedPathSegmentReverseExtractionL(KPathSegmentParse0, &KPathSegmentParse0Seg2(),

   184 							   &KPathSegmentParse0Seg1(), &KPathSegmentParse0Seg0(), NULL);

   185 	TestDelimitedPathSegmentReverseExtractionL(KPathSegmentParse1, &KPathSegmentParse1Seg3(), &KPathSegmentParse1Seg2(), 

   186 								&KPathSegmentParse1Seg1(), &KPathSegmentParse1Seg0(), NULL);

   187 	TestDelimitedPathSegmentReverseExtractionL(KPathSegmentParse2, &KPathSegmentParse2Seg7(), &KPathSegmentParse2Seg6(), 

   188 								&KPathSegmentParse2Seg5(), &KPathSegmentParse2Seg4(), &KPathSegmentParse2Seg3(), 

   189 								&KPathSegmentParse2Seg2(), &KPathSegmentParse2Seg1(), &KPathSegmentParse2Seg0(), NULL);

   190 

   191 	TestDelimitedPathSegmentDelimiterPresenceL(KPathSegment_DelimPresence0, KPathSegment_FrontDelim0, KPathSegment_BackDelim0);

   192 	TestDelimitedPathSegmentDelimiterPresenceL(KPathSegment_DelimPresence1, KPathSegment_FrontDelim1, KPathSegment_BackDelim1);

   193 	TestDelimitedPathSegmentDelimiterPresenceL(KPathSegment_DelimPresence2, KPathSegment_FrontDelim2, KPathSegment_BackDelim2);

   194 	TestDelimitedPathSegmentDelimiterPresenceL(KPathSegment_DelimPresence3, KPathSegment_FrontDelim3, KPathSegment_BackDelim3);

   195 

   196 	TestDelimitedPathSegmentRemainderL(KPathSegment_Rem_Forwards0_0, &KPathSegment_Rem_Forwards0_0(), &KPathSegment_Rem_Forwards0_1(), 

   197 								&KPathSegment_Rem_Forwards0_2(), &KPathSegment_Rem_Forwards0_3(), NULL);

   198 

   199 	TestDelimitedPathSegmentRemainderReverseL(KPathSegment_Rem_Backwards0_0, &KPathSegment_Rem_Backwards0_0(), &KPathSegment_Rem_Backwards0_1(), 

   200 								&KPathSegment_Rem_Backwards0_2(), &KPathSegment_Rem_Backwards0_3(), NULL);

   201 

   202 	TestDelimitedPathSegmentDesL(KPathSegment_Des0);

   203 

   204 	TestDelimitedPathSegmentPushFrontL(KPathSegment_PushPopFront0_0, &KPathSegment_Push0_a(), &KPathSegment_PushPopFront0_1(), 

   205 								&KPathSegment_Push0_b(), &KPathSegment_PushPopFront0_2(), 

   206 								&KPathSegment_Push0_c(), &KPathSegment_PushPopFront0_3(), 

   207 								&KPathSegment_Push0_d(), &KPathSegment_PushPopFront0_4(), 

   208 								&KPathSegment_Push0_e(), &KPathSegment_PushPopFront0_5(), NULL, NULL);

   209 

   210 	TestDelimitedPathSegmentPushBackL(KPathSegment_PushPopBack0_0, &KPathSegment_Push0_a(), &KPathSegment_PushPopBack0_1(), 

   211 								&KPathSegment_Push0_b(), &KPathSegment_PushPopBack0_2(), 

   212 								&KPathSegment_Push0_c(), &KPathSegment_PushPopBack0_3(), 

   213 								&KPathSegment_Push0_d(), &KPathSegment_PushPopBack0_4(), 

   214 								&KPathSegment_Push0_e(), &KPathSegment_PushPopBack0_5(), NULL, NULL);

   215 

   216 	TestDelimitedPathSegmentPopFrontL(KPathSegment_PushPopFront0_5, &KPathSegment_PushPopFront0_4(), &KPathSegment_PushPopFront0_3(), 

   217 								&KPathSegment_PushPopFront0_2(), &KPathSegment_PushPopFront0_1(), &KPathSegment_PushPopFront0_0(), NULL);

   218 

   219 	TestDelimitedPathSegmentPopBackL(KPathSegment_PushPopBack0_5, &KPathSegment_PushPopBack0_4(), &KPathSegment_PushPopBack0_3(), 

   220 								&KPathSegment_PushPopBack0_2(), &KPathSegment_PushPopBack0_1(), &KPathSegment_PushPopBack0_0(), NULL);

   221 

   222 	TestDelimitedPathSegmentAddAndTrimFrontAndBackDelimiterL(KPathSegment_AddTrimDelim0);

   223 

   224 	TestDelimitedPathSegmentInsertAndParseL(KPathSegmentInsertForwardsPos0, KPathSegment_InsertForwards0_0, 

   225 									&KPathSegment_Insert0_a(), &KPathSegment_InsertForwards0_1(), 

   226 									&KPathSegment_Insert0_b(), &KPathSegment_InsertForwards0_2(), 

   227 									&KPathSegment_Insert0_c(), &KPathSegment_InsertForwards0_3(), 

   228 									&KPathSegment_Insert0_d(), &KPathSegment_InsertForwards0_4(), 

   229 									&KPathSegment_Insert0_e(), &KPathSegment_InsertForwards0_5(), NULL, NULL);

   230 

   231 	TestDelimitedPathSegmentRemoveAndParseL(KPathSegmentRemoveForwardsPos0, KPathSegment_RemoveForwards0_0, 

   232 									&KPathSegment_RemoveForwards0_1(), &KPathSegment_RemoveForwards0_2(), 

   233 									&KPathSegment_RemoveForwards0_3(), &KPathSegment_RemoveForwards0_4(), 

   234 									&KPathSegment_RemoveForwards0_5(), NULL);

   235 

   236 	TestDelimitedPathSegmentInsertAndParseReverseL(KPathSegmentInsertBackwardsPos0, KPathSegment_InsertBackwards0_0, 

   237 											&KPathSegment_Insert0_a(), &KPathSegment_InsertBackwards0_1(), 

   238 											&KPathSegment_Insert0_b(), &KPathSegment_InsertBackwards0_2(), 

   239 											&KPathSegment_Insert0_c(), &KPathSegment_InsertBackwards0_3(), 

   240 											&KPathSegment_Insert0_d(), &KPathSegment_InsertBackwards0_4(), 

   241 											&KPathSegment_Insert0_e(), &KPathSegment_InsertBackwards0_5(), NULL, NULL);

   242 

   243 	TestDelimitedPathSegmentRemoveAndParseReverseL(KPathSegmentRemoveBackwardsPos0, KPathSegment_RemoveBackwards0_0, 

   244 											&KPathSegment_RemoveBackwards0_1(), &KPathSegment_RemoveBackwards0_2(), 

   245 											&KPathSegment_RemoveBackwards0_3(), &KPathSegment_RemoveBackwards0_4(), 

   246 											&KPathSegment_RemoveBackwards0_5(), NULL);

   247 

   248 	TestDelimitedPathSegmentInsertEscapeAndParseL(KPathSegmentInsertEscapeForwardsPos0, KPathSegment_InsertEscapeForwards0_0, 

   249 									&KPathSegment_InsertEscape0_a(), &KPathSegment_InsertEscapeForwards0_1(), 

   250 									&KPathSegment_InsertEscape0_b(), &KPathSegment_InsertEscapeForwards0_2(), 

   251 									&KPathSegment_InsertEscape0_c(), &KPathSegment_InsertEscapeForwards0_3(), 

   252 									&KPathSegment_InsertEscape0_d(), &KPathSegment_InsertEscapeForwards0_4(), 

   253 									&KPathSegment_InsertEscape0_e(), &KPathSegment_InsertEscapeForwards0_5(), NULL, NULL);

   254 

   255 	TestDelimitedPathSegmentInsertEscapeAndParseReverseL(KPathSegmentInsertEscapeBackwardsPos0, KPathSegment_InsertEscapeBackwards0_0, 

   256 											&KPathSegment_InsertEscape0_a(), &KPathSegment_InsertEscapeBackwards0_1(), 

   257 											&KPathSegment_InsertEscape0_b(), &KPathSegment_InsertEscapeBackwards0_2(), 

   258 											&KPathSegment_InsertEscape0_c(), &KPathSegment_InsertEscapeBackwards0_3(), 

   259 											&KPathSegment_InsertEscape0_d(), &KPathSegment_InsertEscapeBackwards0_4(), 

   260 											&KPathSegment_InsertEscape0_e(), &KPathSegment_InsertEscapeBackwards0_5(), NULL, NULL);

   261 

   262 	TestDelimitedPathSegmentPushAndEscapeFrontL(KPathSegment_PushEscapeFront0_0, &KPathSegment_PushEscape0_a(), &KPathSegment_PushEscapeFront0_1(), 

   263 										&KPathSegment_PushEscape0_b(), &KPathSegment_PushEscapeFront0_2(), 

   264 										&KPathSegment_PushEscape0_c(), &KPathSegment_PushEscapeFront0_3(), 

   265 										&KPathSegment_PushEscape0_d(), &KPathSegment_PushEscapeFront0_4(), 

   266 										&KPathSegment_PushEscape0_e(), &KPathSegment_PushEscapeFront0_5(), NULL, NULL);

   267 

   268 	TestDelimitedPathSegmentPushAndEscapeBackL(KPathSegment_PushEscapeBack0_0, &KPathSegment_PushEscape0_a(), &KPathSegment_PushEscapeBack0_1(), 

   269 										&KPathSegment_PushEscape0_b(), &KPathSegment_PushEscapeBack0_2(), 

   270 										&KPathSegment_PushEscape0_c(), &KPathSegment_PushEscapeBack0_3(), 

   271 										&KPathSegment_PushEscape0_d(), &KPathSegment_PushEscapeBack0_4(), 

   272 										&KPathSegment_PushEscape0_e(), &KPathSegment_PushEscapeBack0_5(), NULL, NULL);

   273 

   274 //

   275 //

   276 // Delimited Query Tests

   277 //

   278 //

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

   280 							   &KQueryParse0Seg3(), NULL);

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

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

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

   284 

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

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

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

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

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

   290 

   291 	TestDelimitedQueryDelimiterPresenceL(KQuery_DelimPresence0, KQuery_FrontDelim0, KQuery_BackDelim0);

   292 	TestDelimitedQueryDelimiterPresenceL(KQuery_DelimPresence1, KQuery_FrontDelim1, KQuery_BackDelim1);

   293 	TestDelimitedQueryDelimiterPresenceL(KQuery_DelimPresence2, KQuery_FrontDelim2, KQuery_BackDelim2);

   294 	TestDelimitedQueryDelimiterPresenceL(KQuery_DelimPresence3, KQuery_FrontDelim3, KQuery_BackDelim3);

   295 

   296 	TestDelimitedQueryRemainderL(KQuery_Rem_Forwards0_0, &KQuery_Rem_Forwards0_0(), &KQuery_Rem_Forwards0_1(), 

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

   298 

   299 	TestDelimitedQueryRemainderReverseL(KQuery_Rem_Backwards0_0, &KQuery_Rem_Backwards0_0(), &KQuery_Rem_Backwards0_1(), 

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

   301 

   302 	TestDelimitedQueryDesL(KQuery_Des0);

   303 

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

   305 								&KQuery_Push0_b(), &KQuery_PushPopFront0_2(), 

   306 								&KQuery_Push0_c(), &KQuery_PushPopFront0_3(), 

   307 								&KQuery_Push0_d(), &KQuery_PushPopFront0_4(), 

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

   309 

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

   311 								&KQuery_Push0_b(), &KQuery_PushPopBack0_2(), 

   312 								&KQuery_Push0_c(), &KQuery_PushPopBack0_3(), 

   313 								&KQuery_Push0_d(), &KQuery_PushPopBack0_4(), 

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

   315 

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

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

   318 

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

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

   321 

   322 	TestDelimitedQueryAddAndTrimFrontAndBackDelimiterL(KQuery_AddTrimDelim0);

   323 

   324 	TestDelimitedQueryInsertAndParseL(KQueryInsertForwardsPos0, KQuery_InsertForwards0_0, 

   325 									&KQuery_Insert0_a(), &KQuery_InsertForwards0_1(), 

   326 									&KQuery_Insert0_b(), &KQuery_InsertForwards0_2(), 

   327 									&KQuery_Insert0_c(), &KQuery_InsertForwards0_3(), 

   328 									&KQuery_Insert0_d(), &KQuery_InsertForwards0_4(), 

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

   330 

   331 	TestDelimitedQueryRemoveAndParseL(KQueryRemoveForwardsPos0, KQuery_RemoveForwards0_0, 

   332 									&KQuery_RemoveForwards0_1(), &KQuery_RemoveForwards0_2(), 

   333 									&KQuery_RemoveForwards0_3(), &KQuery_RemoveForwards0_4(), 

   334 									&KQuery_RemoveForwards0_5(), NULL);

   335 

   336 	TestDelimitedQueryInsertAndParseReverseL(KQueryInsertBackwardsPos0, KQuery_InsertBackwards0_0, 

   337 											&KQuery_Insert0_a(), &KQuery_InsertBackwards0_1(), 

   338 											&KQuery_Insert0_b(), &KQuery_InsertBackwards0_2(), 

   339 											&KQuery_Insert0_c(), &KQuery_InsertBackwards0_3(), 

   340 											&KQuery_Insert0_d(), &KQuery_InsertBackwards0_4(), 

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

   342 

   343 	TestDelimitedQueryRemoveAndParseReverseL(KQueryRemoveBackwardsPos0, KQuery_RemoveBackwards0_0, 

   344 											&KQuery_RemoveBackwards0_1(), &KQuery_RemoveBackwards0_2(), 

   345 											&KQuery_RemoveBackwards0_3(), &KQuery_RemoveBackwards0_4(), 

   346 											&KQuery_RemoveBackwards0_5(), NULL);

   347 

   348 	TestDelimitedQueryInsertEscapeAndParseL(KQueryInsertEscapeForwardsPos0, KQuery_InsertEscapeForwards0_0, 

   349 									&KQuery_InsertEscape0_a(), &KQuery_InsertEscapeForwards0_1(), 

   350 									&KQuery_InsertEscape0_b(), &KQuery_InsertEscapeForwards0_2(), 

   351 									&KQuery_InsertEscape0_c(), &KQuery_InsertEscapeForwards0_3(), 

   352 									&KQuery_InsertEscape0_d(), &KQuery_InsertEscapeForwards0_4(), 

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

   354 

   355 	TestDelimitedQueryInsertEscapeAndParseReverseL(KQueryInsertEscapeBackwardsPos0, KQuery_InsertEscapeBackwards0_0, 

   356 											&KQuery_InsertEscape0_a(), &KQuery_InsertEscapeBackwards0_1(), 

   357 											&KQuery_InsertEscape0_b(), &KQuery_InsertEscapeBackwards0_2(), 

   358 											&KQuery_InsertEscape0_c(), &KQuery_InsertEscapeBackwards0_3(), 

   359 											&KQuery_InsertEscape0_d(), &KQuery_InsertEscapeBackwards0_4(), 

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

   361 

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

   363 										&KQuery_PushEscape0_b(), &KQuery_PushEscapeFront0_2(), 

   364 										&KQuery_PushEscape0_c(), &KQuery_PushEscapeFront0_3(), 

   365 										&KQuery_PushEscape0_d(), &KQuery_PushEscapeFront0_4(), 

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

   367 

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

   369 										&KQuery_PushEscape0_b(), &KQuery_PushEscapeBack0_2(), 

   370 										&KQuery_PushEscape0_c(), &KQuery_PushEscapeBack0_3(), 

   371 										&KQuery_PushEscape0_d(), &KQuery_PushEscapeBack0_4(), 

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

   373 */	}

   374 

   375 //

   376 //

   377 //	Delimited Path tests

   378 //

   379 //

   380 

   381 void CDelimitedPathTest::TestDelimitedPathExtractionL(TRefByValue<const TDesC> aPath, ...) const

   382 	{

   383 	VA_LIST list1; VA_START(list1, aPath);

   384 	VA_LIST list2; VA_START(list2, aPath);

   385 	const TDesC& path = aPath;

   386 

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

   388 	VA_END(list1); VA_END(list2);

   389 	}

   390 

   391 void CDelimitedPathTest::TestDelimitedPathReverseExtractionL(TRefByValue<const TDesC> aPath, ...) const

   392 	{

   393 	VA_LIST list1; VA_START(list1, aPath);

   394 	VA_LIST list2; VA_START(list2, aPath);

   395 	const TDesC& path = aPath;

   396 

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

   398 	VA_END(list1); VA_END(list2);

   399 	}

   400 

   401 void CDelimitedPathTest::TestDelimitedPathDelimiterPresenceL(const TDesC& aPath, TBool aFrontDelim, TBool aBackDelim) const

   402 	{

   403 	TestDelimitedDataDelimiterPresenceL(_L("Test TDelimitedPathParser Delimiter Presence"), iTestHarness, aPath, aFrontDelim, aBackDelim);

   404 	}

   405 

   406 void CDelimitedPathTest::TestDelimitedPathRemainderL(TRefByValue<const TDesC> aPath, ...) const

   407 	{

   408 	VA_LIST list1; VA_START(list1, aPath);

   409 	VA_LIST list2; VA_START(list2, aPath);

   410 	const TDesC& path = aPath;

   411 

   412 	TestDelimitedDataRemainderL(_L("Test TDelimitedPathParser Remainder, Parse"), iTestHarness, path, list1, list2);

   413 	VA_END(list1); VA_END(list2);

   414 	}

   415 

   416 void CDelimitedPathTest::TestDelimitedPathRemainderReverseL(TRefByValue<const TDesC> aPath, ...) const

   417 	{

   418 	VA_LIST list1; VA_START(list1, aPath);

   419 	VA_LIST list2; VA_START(list2, aPath);

   420 	const TDesC& path = aPath;

   421 

   422 	TestDelimitedDataRemainderReverseL(_L("Test TDelimitedPathParser Remainder, ParseReverse"), iTestHarness, path, list1, list2);

   423 	VA_END(list1); VA_END(list2);

   424 	}

   425 

   426 void CDelimitedPathTest::TestDelimitedPathDesL(const TDesC& aPath) const

   427 	{

   428 	TestDelimitedDataDesL(_L("Test TDelimitedPathParser Des"), iTestHarness, aPath);

   429 	}

   430 

   431 void CDelimitedPathTest::TestDelimitedPathPushFrontL(TRefByValue<const TDesC> aPath, ...) const

   432 	{

   433 	VA_LIST list1; VA_START(list1, aPath);

   434 	VA_LIST list2; VA_START(list2, aPath);

   435 	const TDesC& path = aPath;

   436 

   437 	TestDelimitedDataPushFrontL(_L("Test CDelimitedPath PushFront"), iTestHarness, path, list1, list2);

   438 	VA_END(list1);

   439 	VA_END(list2);

   440 	}

   441 

   442 void CDelimitedPathTest::TestDelimitedPathPushBackL(TRefByValue<const TDesC> aPath, ...) const

   443 	{

   444 	VA_LIST list1; VA_START(list1, aPath);

   445 	VA_LIST list2; VA_START(list2, aPath);

   446 	const TDesC& path = aPath;

   447 

   448 	TestDelimitedDataPushBackL(_L("Test CDelimitedPath PushBack"), iTestHarness, path, list1, list2);

   449 	VA_END(list1); VA_END(list2);

   450 	}

   451 

   452 void CDelimitedPathTest::TestDelimitedPathPopFrontL(TRefByValue<const TDesC> aPath, ...) const

   453 	{

   454 	VA_LIST list1; VA_START(list1, aPath);

   455 	VA_LIST list2; VA_START(list2, aPath);

   456 	const TDesC& path = aPath;

   457 

   458 	TestDelimitedDataPopFrontL(_L("Test CDelimitedPath PopFront"), iTestHarness, path, list1, list2);

   459 	VA_END(list1); VA_END(list2);

   460 	}

   461 

   462 void CDelimitedPathTest::TestDelimitedPathPopBackL(TRefByValue<const TDesC> aPath, ...) const

   463 	{

   464 	VA_LIST list1; VA_START(list1, aPath);

   465 	VA_LIST list2; VA_START(list2, aPath);

   466 	const TDesC& path = aPath;

   467 

   468 	TestDelimitedDataPopBackL(_L("Test CDelimitedPath PopBack"), iTestHarness, path, list1, list2);

   469 	VA_END(list1); VA_END(list2);

   470 	}

   471 

   472 void CDelimitedPathTest::TestDelimitedPathAddAndTrimFrontAndBackDelimiterL(const TDesC& aPath) const

   473 	{

   474 	TestDelimitedDataAddAndTrimFrontAndBackDelimiterL(_L("Test CDelimitedPath Add and Trim Front and Back delimiter"), iTestHarness, aPath);

   475 	}

   476 

   477 void CDelimitedPathTest::TestDelimitedPathInsertAndParseL(TInt aStartPos, TRefByValue<const TDesC> aPath, ...) const

   478 	{

   479 	VA_LIST list1; VA_START(list1, aPath);

   480 	VA_LIST list2; VA_START(list2, aPath);

   481 	const TDesC& path = aPath;

   482 

   483 	TestDelimitedDataInsertAndParseL(_L("Test CDelimitedPath InsertCurrent, Parse"), iTestHarness, path, list1, list2, aStartPos);

   484 	VA_END(list1); VA_END(list2);

   485 	}

   486 

   487 void CDelimitedPathTest::TestDelimitedPathRemoveAndParseL(TInt aStartPos, TRefByValue<const TDesC> aPath, ...) const

   488 	{

   489 	VA_LIST list1; VA_START(list1, aPath);

   490 	VA_LIST list2; VA_START(list2, aPath);

   491 	const TDesC& path = aPath;

   492 

   493 	TestDelimitedDataRemoveAndParseL(_L("Test CDelimitedPath RemoveCurrent, Parse"), iTestHarness, path, list1, list2, aStartPos);

   494 	VA_END(list1); VA_END(list2);

   495 	}

   496 

   497 void CDelimitedPathTest::TestDelimitedPathInsertAndParseReverseL(TInt aStartPos, TRefByValue<const TDesC> aPath, ...) const

   498 	{

   499 	VA_LIST list1; VA_START(list1, aPath);

   500 	VA_LIST list2; VA_START(list2, aPath);

   501 	const TDesC& path = aPath;

   502 

   503 	TestDelimitedDataInsertAndParseReverseL(_L("Test CDelimitedPath InsertCurrent, ParseReverse"), iTestHarness, path, list1, list2, aStartPos);

   504 	VA_END(list1); VA_END(list2);

   505 	}

   506 

   507 void CDelimitedPathTest::TestDelimitedPathRemoveAndParseReverseL(TInt aStartPos, TRefByValue<const TDesC> aPath, ...) const

   508 	{

   509 	VA_LIST list1; VA_START(list1, aPath);

   510 	VA_LIST list2; VA_START(list2, aPath);

   511 	const TDesC& path = aPath;

   512 

   513 	TestDelimitedDataRemoveAndParseReverseL(_L("Test CDelimitedPath RemoveCurrent, ParseReverse"), iTestHarness, path, list1, list2, aStartPos);

   514 	VA_END(list1); VA_END(list2);

   515 	}

   516 

   517 void CDelimitedPathTest::TestDelimitedPathInsertEscapeAndParseL(TInt aStartPos, TRefByValue<const TDesC> aPath, ...) const

   518 	{

   519 	VA_LIST list1; VA_START(list1, aPath);

   520 	VA_LIST list2; VA_START(list2, aPath);

   521 	const TDesC& path = aPath;

   522 

   523 	TestDelimitedDataInsertEscapeAndParseL(_L("Test CDelimitedPath InsertAndEscapeCurrent, Parse"), iTestHarness, path, list1, list2, aStartPos);

   524 	VA_END(list1); VA_END(list2);

   525 	}

   526 

   527 void CDelimitedPathTest::TestDelimitedPathInsertEscapeAndParseReverseL(TInt aStartPos, TRefByValue<const TDesC> aPath, ...) const

   528 	{

   529 	VA_LIST list1; VA_START(list1, aPath);

   530 	VA_LIST list2; VA_START(list2, aPath);

   531 	const TDesC& path = aPath;

   532 

   533 	TestDelimitedDataInsertEscapeAndParseReverseL(_L("Test CDelimitedPath InsertAndEscapeCurrent, ParseReverse"), iTestHarness, path, list1, list2, aStartPos);

   534 	VA_END(list1); VA_END(list2);

   535 	}

   536 

   537 void CDelimitedPathTest::TestDelimitedPathPushAndEscapeFrontL(TRefByValue<const TDesC> aPath, ...) const

   538 	{

   539 	VA_LIST list1; VA_START(list1, aPath);

   540 	VA_LIST list2; VA_START(list2, aPath);

   541 	const TDesC& path = aPath;

   542 

   543 	TestDelimitedDataPushAndEscapeFrontL(_L("Test CDelimitedPath PushAndEscapeFront"), iTestHarness, path, list1, list2);

   544 	VA_END(list1); VA_END(list2);

   545 	}

   546 

   547 void CDelimitedPathTest::TestDelimitedPathPushAndEscapeBackL(TRefByValue<const TDesC> aPath, ...) const

   548 	{

   549 	VA_LIST list1; VA_START(list1, aPath);

   550 	VA_LIST list2; VA_START(list2, aPath);

   551 	const TDesC& path = aPath;

   552 

   553 	TestDelimitedDataPushAndEscapeBackL(_L("Test CDelimitedPath PushAndEscapeBack"), iTestHarness, path, list1, list2);

   554 	VA_END(list1); VA_END(list2);

   555 	}

   556 /*

   557 //

   558 //

   559 //	Delimited PathSegment tests

   560 //

   561 //

   562 

   563 void CDelimitedPathTest::TestDelimitedPathSegmentExtractionL(TRefByValue<const TDesC> aPathSegment, ...) const

   564 	{

   565 	VA_LIST list1; VA_START(list1, aPathSegment);

   566 	VA_LIST list2; VA_START(list2, aPathSegment);

   567 	const TDesC& pathSegment = aPathSegment;

   568 

   569 	TestDelimitedDataExtractionL(TDelimitedPathSegmentParser16(), TDelimitedPathSegmentParser8(),

   570 		_L("Test TDelimitedPathSegmentParser Parse : GetNext, Dec, Inc, Peek and Eos"), iTestHarness, pathSegment, list1, list2);

   571 	VA_END(list1); VA_END(list2);

   572 	}

   573 

   574 void CDelimitedPathTest::TestDelimitedPathSegmentReverseExtractionL(TRefByValue<const TDesC> aPathSegment, ...) const

   575 	{

   576 	VA_LIST list1; VA_START(list1, aPathSegment);

   577 	VA_LIST list2; VA_START(list2, aPathSegment);

   578 	const TDesC& pathSegment = aPathSegment;

   579 

   580 	TestDelimitedDataReverseExtractionL<TDelimitedPathSegmentParser16, TDelimitedPathSegmentParser8>(

   581 		_L("Test TDelimitedPathSegmentParser ParseReverse : GetNext, Dec, Inc, Peek and Eos"), iTestHarness, pathSegment, list1, list2);

   582 	VA_END(list1); VA_END(list2);

   583 	}

   584 

   585 void CDelimitedPathTest::TestDelimitedPathSegmentDelimiterPresenceL(const TDesC& aPathSegment, TBool aFrontDelim, TBool aBackDelim) const

   586 	{

   587 	TestDelimitedDataDelimiterPresenceL<TDelimitedPathSegmentParser16, TDelimitedPathSegmentParser8>(

   588 		_L("Test TDelimitedPathSegmentParser Delimiter Presence"), iTestHarness, aPathSegment, aFrontDelim, aBackDelim);

   589 	}

   590 

   591 void CDelimitedPathTest::TestDelimitedPathSegmentRemainderL(TRefByValue<const TDesC> aPathSegment, ...) const

   592 	{

   593 	VA_LIST list1; VA_START(list1, aPathSegment);

   594 	VA_LIST list2; VA_START(list2, aPathSegment);

   595 	const TDesC& pathSegment = aPathSegment;

   596 

   597 	TestDelimitedDataRemainderL<TDelimitedPathSegmentParser16, TDelimitedPathSegmentParser8>(

   598 		_L("Test TDelimitedPathSegmentParser Remainder, Parse"), iTestHarness, pathSegment, list1, list2);

   599 	VA_END(list1); VA_END(list2);

   600 	}

   601 

   602 void CDelimitedPathTest::TestDelimitedPathSegmentRemainderReverseL(TRefByValue<const TDesC> aPathSegment, ...) const

   603 	{

   604 	VA_LIST list1; VA_START(list1, aPathSegment);

   605 	VA_LIST list2; VA_START(list2, aPathSegment);

   606 	const TDesC& pathSegment = aPathSegment;

   607 

   608 	TestDelimitedDataRemainderReverseL<TDelimitedPathSegmentParser16, TDelimitedPathSegmentParser8>(

   609 		_L("Test TDelimitedPathSegmentParser Remainder, ParseReverse"), iTestHarness, pathSegment, list1, list2);

   610 	VA_END(list1); VA_END(list2);

   611 	}

   612 

   613 void CDelimitedPathTest::TestDelimitedPathSegmentDesL(const TDesC& aPathSegment) const

   614 	{

   615 	TestDelimitedDataDesL<TDelimitedPathSegmentParser16, TDelimitedPathSegmentParser8>(_L("Test TDelimitedPathSegment Des"), iTestHarness, aPathSegment);

   616 	}

   617 

   618 void CDelimitedPathTest::TestDelimitedPathSegmentPushFrontL(TRefByValue<const TDesC> aPathSegment, ...) const

   619 	{

   620 	VA_LIST list1; VA_START(list1, aPathSegment);

   621 	VA_LIST list2; VA_START(list2, aPathSegment);

   622 	const TDesC& pathSegment = aPathSegment;

   623 

   624 	CDelimitedPath16* path16Bit = NULL; CDelimitedPath8* path8Bit = NULL;

   625 	TestDelimitedDataPushFrontL(path16Bit, path8Bit,

   626 		_L("Test TDelimitedPathSegmentParser PushFront"), iTestHarness, pathSegment, list1, list2);

   627 	VA_END(list1);

   628 	VA_END(list2);

   629 	}

   630 

   631 void CDelimitedPathTest::TestDelimitedPathSegmentPushBackL(TRefByValue<const TDesC> aPathSegment, ...) const

   632 	{

   633 	VA_LIST list1; VA_START(list1, aPathSegment);

   634 	VA_LIST list2; VA_START(list2, aPathSegment);

   635 	const TDesC& pathSegment = aPathSegment;

   636 

   637 	TestDelimitedDataPushBackL<CDelimitedPathSegment16, CDelimitedPathSegment8>(

   638 		_L("Test TDelimitedPathSegmentParser PushBack"), iTestHarness, pathSegment, list1, list2);

   639 	VA_END(list1); VA_END(list2);

   640 	}

   641 

   642 void CDelimitedPathTest::TestDelimitedPathSegmentPopFrontL(TRefByValue<const TDesC> aPathSegment, ...) const

   643 	{

   644 	VA_LIST list1; VA_START(list1, aPathSegment);

   645 	VA_LIST list2; VA_START(list2, aPathSegment);

   646 	const TDesC& pathSegment = aPathSegment;

   647 

   648 	TestDelimitedDataPopFrontL<CDelimitedPathSegment16, CDelimitedPathSegment8>(

   649 		_L("Test TDelimitedPathSegmentParser PopFront"), iTestHarness, pathSegment, list1, list2);

   650 	VA_END(list1); VA_END(list2);

   651 	}

   652 

   653 void CDelimitedPathTest::TestDelimitedPathSegmentPopBackL(TRefByValue<const TDesC> aPathSegment, ...) const

   654 	{

   655 	VA_LIST list1; VA_START(list1, aPathSegment);

   656 	VA_LIST list2; VA_START(list2, aPathSegment);

   657 	const TDesC& pathSegment = aPathSegment;

   658 

   659 	TestDelimitedDataPopBackL<CDelimitedPathSegment16, CDelimitedPathSegment8>(

   660 		_L("Test TDelimitedPathSegmentParser PopBack"), iTestHarness, pathSegment, list1, list2);

   661 	VA_END(list1); VA_END(list2);

   662 	}

   663 

   664 void CDelimitedPathTest::TestDelimitedPathSegmentAddAndTrimFrontAndBackDelimiterL(const TDesC& aPathSegment) const

   665 	{

   666 	TestDelimitedDataAddAndTrimFrontAndBackDelimiterL<CDelimitedPathSegment16, CDelimitedPathSegment8>(

   667 		_L("Test TDelimitedPathSegmentParser Add and Trim Front and Back delimiter"), iTestHarness, aPathSegment);

   668 	}

   669 

   670 void CDelimitedPathTest::TestDelimitedPathSegmentInsertAndParseL(TInt aStartPos, TRefByValue<const TDesC> aPathSegment, ...) const

   671 	{

   672 	VA_LIST list1; VA_START(list1, aPathSegment);

   673 	VA_LIST list2; VA_START(list2, aPathSegment);

   674 	const TDesC& pathSegment = aPathSegment;

   675 

   676 	TestDelimitedDataInsertAndParseL<CDelimitedPathSegment16, CDelimitedPathSegment8>(

   677 		_L("Test TDelimitedPathSegmentParser InsertCurrent, Parse"), iTestHarness, pathSegment, list1, list2, aStartPos);

   678 	VA_END(list1); VA_END(list2);

   679 	}

   680 

   681 void CDelimitedPathTest::TestDelimitedPathSegmentRemoveAndParseL(TInt aStartPos, TRefByValue<const TDesC> aPathSegment, ...) const

   682 	{

   683 	VA_LIST list1; VA_START(list1, aPathSegment);

   684 	VA_LIST list2; VA_START(list2, aPathSegment);

   685 	const TDesC& pathSegment = aPathSegment;

   686 

   687 	TestDelimitedDataRemoveAndParseL<CDelimitedPathSegment16, CDelimitedPathSegment8>(

   688 		_L("Test TDelimitedPathSegmentParser RemoveCurrent, Parse"), iTestHarness, pathSegment, list1, list2, aStartPos);

   689 	VA_END(list1); VA_END(list2);

   690 	}

   691 

   692 void CDelimitedPathTest::TestDelimitedPathSegmentInsertAndParseReverseL(TInt aStartPos, TRefByValue<const TDesC> aPathSegment, ...) const

   693 	{

   694 	VA_LIST list1; VA_START(list1, aPathSegment);

   695 	VA_LIST list2; VA_START(list2, aPathSegment);

   696 	const TDesC& pathSegment = aPathSegment;

   697 

   698 	TestDelimitedDataInsertAndParseReverseL<CDelimitedPathSegment16, CDelimitedPathSegment8>(

   699 		_L("Test TDelimitedPathSegmentParser InsertCurrent, ParseReverse"), iTestHarness, pathSegment, list1, list2, aStartPos);

   700 	VA_END(list1); VA_END(list2);

   701 	}

   702 

   703 void CDelimitedPathTest::TestDelimitedPathSegmentRemoveAndParseReverseL(TInt aStartPos, TRefByValue<const TDesC> aPathSegment, ...) const

   704 	{

   705 	VA_LIST list1; VA_START(list1, aPathSegment);

   706 	VA_LIST list2; VA_START(list2, aPathSegment);

   707 	const TDesC& pathSegment = aPathSegment;

   708 

   709 	TestDelimitedDataRemoveAndParseReverseL<CDelimitedPathSegment16, CDelimitedPathSegment8>(

   710 		_L("Test TDelimitedPathSegmentParser RemoveCurrent, ParseReverse"), iTestHarness, pathSegment, list1, list2, aStartPos);

   711 	VA_END(list1); VA_END(list2);

   712 	}

   713 

   714 void CDelimitedPathTest::TestDelimitedPathSegmentInsertEscapeAndParseL(TInt aStartPos, TRefByValue<const TDesC> aPathSegment, ...) const

   715 	{

   716 	VA_LIST list1; VA_START(list1, aPathSegment);

   717 	VA_LIST list2; VA_START(list2, aPathSegment);

   718 	const TDesC& pathSegment = aPathSegment;

   719 

   720 	TestDelimitedDataInsertEscapeAndParseL<CDelimitedPathSegment16, CDelimitedPathSegment8>(

   721 		_L("Test TDelimitedPathSegmentParser InsertAndEscapeCurrent, Parse"), iTestHarness, pathSegment, list1, list2, aStartPos);

   722 	VA_END(list1); VA_END(list2);

   723 	}

   724 

   725 void CDelimitedPathTest::TestDelimitedPathSegmentInsertEscapeAndParseReverseL(TInt aStartPos, TRefByValue<const TDesC> aPathSegment, ...) const

   726 	{

   727 	VA_LIST list1; VA_START(list1, aPathSegment);

   728 	VA_LIST list2; VA_START(list2, aPathSegment);

   729 	const TDesC& pathSegment = aPathSegment;

   730 

   731 	TestDelimitedDataInsertEscapeAndParseReverseL<CDelimitedPathSegment16, CDelimitedPathSegment8>(

   732 		_L("Test TDelimitedPathSegmentParser InsertAndEscapeCurrent, ParseReverse"), iTestHarness, pathSegment, list1, list2, aStartPos);

   733 	VA_END(list1); VA_END(list2);

   734 	}

   735 

   736 void CDelimitedPathTest::TestDelimitedPathSegmentPushAndEscapeFrontL(TRefByValue<const TDesC> aPathSegment, ...) const

   737 	{

   738 	VA_LIST list1; VA_START(list1, aPathSegment);

   739 	VA_LIST list2; VA_START(list2, aPathSegment);

   740 	const TDesC& pathSegment = aPathSegment;

   741 

   742 	TestDelimitedDataPushAndEscapeFrontL<CDelimitedPathSegment16, CDelimitedPathSegment8>(

   743 		_L("Test TDelimitedPathSegmentParser PushAndEscapeFront"), iTestHarness, pathSegment, list1, list2);

   744 	VA_END(list1); VA_END(list2);

   745 	}

   746 

   747 void CDelimitedPathTest::TestDelimitedPathSegmentPushAndEscapeBackL(TRefByValue<const TDesC> aPathSegment, ...) const

   748 	{

   749 	VA_LIST list1; VA_START(list1, aPathSegment);

   750 	VA_LIST list2; VA_START(list2, aPathSegment);

   751 	const TDesC& pathSegment = aPathSegment;

   752 

   753 	TestDelimitedDataPushAndEscapeBackL<CDelimitedPathSegment16, CDelimitedPathSegment8>(

   754 		_L("Test TDelimitedPathSegmentParser PushAndEscapeBack"), iTestHarness, pathSegment, list1, list2);

   755 	VA_END(list1); VA_END(list2);

   756 	}

   757 

   758 //

   759 //

   760 //	Delimited Query tests

   761 //

   762 //

   763 void CDelimitedPathTest::TestDelimitedQueryExtractionL(TRefByValue<const TDesC> aQuery, ...) const

   764 	{

   765 	VA_LIST list1; VA_START(list1, aQuery);

   766 	VA_LIST list2; VA_START(list2, aQuery);

   767 	const TDesC& query = aQuery;

   768 

   769 	TestDelimitedDataExtractionL<TDelimitedQueryParser16, TDelimitedQueryParser8>(

   770 		_L("Test TDelimitedQueryParser Parse : GetNext, Dec, Inc, Peek and Eos"), iTestHarness, query, list1, list2);

   771 	VA_END(list1); VA_END(list2);

   772 	}

   773 

   774 void CDelimitedPathTest::TestDelimitedQueryReverseExtractionL(TRefByValue<const TDesC> aQuery, ...) const

   775 	{

   776 	VA_LIST list1; VA_START(list1, aQuery);

   777 	VA_LIST list2; VA_START(list2, aQuery);

   778 	const TDesC& query = aQuery;

   779 

   780 	TestDelimitedDataReverseExtractionL<TDelimitedQueryParser16, TDelimitedQueryParser8>(

   781 		_L("Test TDelimitedQueryParser ParseReverse : GetNext, Dec, Inc, Peek and Eos"), iTestHarness, query, list1, list2);

   782 	VA_END(list1); VA_END(list2);

   783 	}

   784 

   785 void CDelimitedPathTest::TestDelimitedQueryDelimiterPresenceL(const TDesC& aQuery, TBool aFrontDelim, TBool aBackDelim) const

   786 	{

   787 	TestDelimitedDataDelimiterPresenceL<TDelimitedQueryParser16, TDelimitedQueryParser8>(

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

   789 	}

   790 

   791 void CDelimitedPathTest::TestDelimitedQueryRemainderL(TRefByValue<const TDesC> aQuery, ...) const

   792 	{

   793 	VA_LIST list1; VA_START(list1, aQuery);

   794 	VA_LIST list2; VA_START(list2, aQuery);

   795 	const TDesC& query = aQuery;

   796 

   797 	TestDelimitedDataRemainderL<TDelimitedQueryParser16, TDelimitedQueryParser8>(

   798 		_L("Test TDelimitedQueryParser Remainder, Parse"), iTestHarness, query, list1, list2);

   799 	VA_END(list1); VA_END(list2);

   800 	}

   801 

   802 void CDelimitedPathTest::TestDelimitedQueryRemainderReverseL(TRefByValue<const TDesC> aQuery, ...) const

   803 	{

   804 	VA_LIST list1; VA_START(list1, aQuery);

   805 	VA_LIST list2; VA_START(list2, aQuery);

   806 	const TDesC& query = aQuery;

   807 

   808 	TestDelimitedDataRemainderReverseL<TDelimitedQueryParser16, TDelimitedQueryParser8>(

   809 		_L("Test TDelimitedQueryParser Remainder, ParseReverse"), iTestHarness, query, list1, list2);

   810 	VA_END(list1); VA_END(list2);

   811 	}

   812 

   813 void CDelimitedPathTest::TestDelimitedQueryDesL(const TDesC& aQuery) const

   814 	{

   815 	TestDelimitedDataDesL<TDelimitedQueryParser16, TDelimitedQueryParser8>(_L("Test TDelimitedQuery Des"), iTestHarness, aQuery);

   816 	}

   817 

   818 void CDelimitedPathTest::TestDelimitedQueryPushFrontL(TRefByValue<const TDesC> aQuery, ...) const

   819 	{

   820 	VA_LIST list1; VA_START(list1, aQuery);

   821 	VA_LIST list2; VA_START(list2, aQuery);

   822 	const TDesC& query = aQuery;

   823 

   824 	TestDelimitedDataPushFrontL<CDelimitedQuery16, CDelimitedQuery8>(

   825 		_L("Test TDelimitedQueryParser PushFront"), iTestHarness, query, list1, list2);

   826 	VA_END(list1);

   827 	VA_END(list2);

   828 	}

   829 

   830 void CDelimitedPathTest::TestDelimitedQueryPushBackL(TRefByValue<const TDesC> aQuery, ...) const

   831 	{

   832 	VA_LIST list1; VA_START(list1, aQuery);

   833 	VA_LIST list2; VA_START(list2, aQuery);

   834 	const TDesC& query = aQuery;

   835 

   836 	TestDelimitedDataPushBackL<CDelimitedQuery16, CDelimitedQuery8>(

   837 		_L("Test TDelimitedQueryParser PushBack"), iTestHarness, query, list1, list2);

   838 	VA_END(list1); VA_END(list2);

   839 	}

   840 

   841 void CDelimitedPathTest::TestDelimitedQueryPopFrontL(TRefByValue<const TDesC> aQuery, ...) const

   842 	{

   843 	VA_LIST list1; VA_START(list1, aQuery);

   844 	VA_LIST list2; VA_START(list2, aQuery);

   845 	const TDesC& query = aQuery;

   846 

   847 	TestDelimitedDataPopFrontL<CDelimitedQuery16, CDelimitedQuery8>(

   848 		_L("Test TDelimitedQueryParser PopFront"), iTestHarness, query, list1, list2);

   849 	VA_END(list1); VA_END(list2);

   850 	}

   851 

   852 void CDelimitedPathTest::TestDelimitedQueryPopBackL(TRefByValue<const TDesC> aQuery, ...) const

   853 	{

   854 	VA_LIST list1; VA_START(list1, aQuery);

   855 	VA_LIST list2; VA_START(list2, aQuery);

   856 	const TDesC& query = aQuery;

   857 

   858 	TestDelimitedDataPopBackL<CDelimitedQuery16, CDelimitedQuery8>(

   859 		_L("Test TDelimitedQueryParser PopBack"), iTestHarness, query, list1, list2);

   860 	VA_END(list1); VA_END(list2);

   861 	}

   862 

   863 void CDelimitedPathTest::TestDelimitedQueryAddAndTrimFrontAndBackDelimiterL(const TDesC& aQuery) const

   864 	{

   865 	TestDelimitedDataAddAndTrimFrontAndBackDelimiterL<CDelimitedQuery16, CDelimitedQuery8>(

   866 		_L("Test TDelimitedQueryParser Add and Trim Front and Back delimiter"), iTestHarness, aQuery);

   867 	}

   868 

   869 void CDelimitedPathTest::TestDelimitedQueryInsertAndParseL(TInt aStartPos, TRefByValue<const TDesC> aQuery, ...) const

   870 	{

   871 	VA_LIST list1; VA_START(list1, aQuery);

   872 	VA_LIST list2; VA_START(list2, aQuery);

   873 	const TDesC& query = aQuery;

   874 

   875 	TestDelimitedDataInsertAndParseL<CDelimitedQuery16, CDelimitedQuery8>(

   876 		_L("Test TDelimitedQueryParser InsertCurrent, Parse"), iTestHarness, query, list1, list2, aStartPos);

   877 	VA_END(list1); VA_END(list2);

   878 	}

   879 

   880 void CDelimitedPathTest::TestDelimitedQueryRemoveAndParseL(TInt aStartPos, TRefByValue<const TDesC> aQuery, ...) const

   881 	{

   882 	VA_LIST list1; VA_START(list1, aQuery);

   883 	VA_LIST list2; VA_START(list2, aQuery);

   884 	const TDesC& query = aQuery;

   885 

   886 	TestDelimitedDataRemoveAndParseL<CDelimitedQuery16, CDelimitedQuery8>(

   887 		_L("Test TDelimitedQueryParser RemoveCurrent, Parse"), iTestHarness, query, list1, list2, aStartPos);

   888 	VA_END(list1); VA_END(list2);

   889 	}

   890 

   891 void CDelimitedPathTest::TestDelimitedQueryInsertAndParseReverseL(TInt aStartPos, TRefByValue<const TDesC> aQuery, ...) const

   892 	{

   893 	VA_LIST list1; VA_START(list1, aQuery);

   894 	VA_LIST list2; VA_START(list2, aQuery);

   895 	const TDesC& query = aQuery;

   896 

   897 	TestDelimitedDataInsertAndParseReverseL<CDelimitedQuery16, CDelimitedQuery8>(

   898 		_L("Test TDelimitedQueryParser InsertCurrent, ParseReverse"), iTestHarness, query, list1, list2, aStartPos);

   899 	VA_END(list1); VA_END(list2);

   900 	}

   901 

   902 void CDelimitedPathTest::TestDelimitedQueryRemoveAndParseReverseL(TInt aStartPos, TRefByValue<const TDesC> aQuery, ...) const

   903 	{

   904 	VA_LIST list1; VA_START(list1, aQuery);

   905 	VA_LIST list2; VA_START(list2, aQuery);

   906 	const TDesC& query = aQuery;

   907 

   908 	TestDelimitedDataRemoveAndParseReverseL<CDelimitedQuery16, CDelimitedQuery8>(

   909 		_L("Test TDelimitedQueryParser RemoveCurrent, ParseReverse"), iTestHarness, query, list1, list2, aStartPos);

   910 	VA_END(list1); VA_END(list2);

   911 	}

   912 

   913 void CDelimitedPathTest::TestDelimitedQueryInsertEscapeAndParseL(TInt aStartPos, TRefByValue<const TDesC> aQuery, ...) const

   914 	{

   915 	VA_LIST list1; VA_START(list1, aQuery);

   916 	VA_LIST list2; VA_START(list2, aQuery);

   917 	const TDesC& query = aQuery;

   918 

   919 	TestDelimitedDataInsertEscapeAndParseL<CDelimitedQuery16, CDelimitedQuery8>(

   920 		_L("Test TDelimitedQueryParser InsertAndEscapeCurrent, Parse"), iTestHarness, query, list1, list2, aStartPos);

   921 	VA_END(list1); VA_END(list2);

   922 	}

   923 

   924 void CDelimitedPathTest::TestDelimitedQueryInsertEscapeAndParseReverseL(TInt aStartPos, TRefByValue<const TDesC> aQuery, ...) const

   925 	{

   926 	VA_LIST list1; VA_START(list1, aQuery);

   927 	VA_LIST list2; VA_START(list2, aQuery);

   928 	const TDesC& query = aQuery;

   929 

   930 	TestDelimitedDataInsertEscapeAndParseReverseL<CDelimitedQuery16, CDelimitedQuery8>(

   931 		_L("Test TDelimitedQueryParser InsertAndEscapeCurrent, ParseReverse"), iTestHarness, query, list1, list2, aStartPos);

   932 	VA_END(list1); VA_END(list2);

   933 	}

   934 

   935 void CDelimitedPathTest::TestDelimitedQueryPushAndEscapeFrontL(TRefByValue<const TDesC> aQuery, ...) const

   936 	{

   937 	VA_LIST list1; VA_START(list1, aQuery);

   938 	VA_LIST list2; VA_START(list2, aQuery);

   939 	const TDesC& query = aQuery;

   940 

   941 	TestDelimitedDataPushAndEscapeFrontL<CDelimitedQuery16, CDelimitedQuery8>(

   942 		_L("Test TDelimitedQueryParser PushAndEscapeFront"), iTestHarness, query, list1, list2);

   943 	VA_END(list1); VA_END(list2);

   944 	}

   945 

   946 void CDelimitedPathTest::TestDelimitedQueryPushAndEscapeBackL(TRefByValue<const TDesC> aQuery, ...) const

   947 	{

   948 	VA_LIST list1; VA_START(list1, aQuery);

   949 	VA_LIST list2; VA_START(list2, aQuery);

   950 	const TDesC& query = aQuery;

   951 

   952 	TestDelimitedDataPushAndEscapeBackL<CDelimitedQuery16, CDelimitedQuery8>(

   953 		_L("Test TDelimitedQueryParser PushAndEscapeBack"), iTestHarness, query, list1, list2);

   954 	VA_END(list1); VA_END(list2);

   955 	}

   956 */

   957 //

   958 //

   959 //	Implementation of LOCAL functions - test funcions

   960 //

   961 //

   962 

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

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

   965 	// Create title

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

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

   968 	aTestHarness->StartTestL(*title16Bit);

   969 

   970 	// Create TDelimitedPathParser object and do parsing

   971 	TDelimitedPathParser16 parser16Bit;

   972 	parser16Bit.Parse(aData);

   973 

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

   975 

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

   977 	aTestHarness->EndTest(error);

   978 

   979 	// Make 8-bit copy

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

   981 	TPtr8 data8Bit = dataBuf->Des();

   982 	data8Bit.Copy(aData);

   983 

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

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

   986 	aTestHarness->StartTestL(*title8Bit);

   987 

   988 	// Create TDelimitedPathParser object and do parsing

   989 	TDelimitedPathParser8 parser8Bit;

   990 	parser8Bit.Parse(data8Bit);

   991 

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

   993 

   994 	aTestHarness->EndTest(error);

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

   996 	}

   997 

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

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

  1000 	{

  1001 	// Create title

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

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

  1004 	aTestHarness->StartTestL(*title16Bit);

  1005 

  1006 	// Create TDelimitedPathParser object and do parsing

  1007 	TDelimitedPathParser16 parser16Bit;

  1008 	parser16Bit.ParseReverse(aData);

  1009 

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

  1011 

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

  1013 	aTestHarness->EndTest(error);

  1014 

  1015 	// Make 8-bit copy

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

  1017 	TPtr8 data8Bit = dataBuf->Des();

  1018 	data8Bit.Copy(aData);

  1019 

  1020 	// Create title

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

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

  1023 	aTestHarness->StartTestL(*title8Bit);

  1024 

  1025 	// Create TDelimitedPathParser object and do parsing

  1026 	TDelimitedPathParser8 parser8Bit;

  1027 	parser8Bit.ParseReverse(data8Bit);

  1028 

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

  1030 

  1031 	aTestHarness->EndTest(error);

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

  1033 	}

  1034 

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

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

  1037 	{

  1038 	// Create title

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

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

  1041 	aTestHarness->StartTestL(*title16Bit);

  1042 

  1043 	// Create TDelimitedPathParser object 

  1044 	TDelimitedPathParser16 parser16Bit;

  1045 	parser16Bit.Parse(aData);

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

  1047 

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

  1049 	aTestHarness->EndTest(error);

  1050 

  1051 	// Make 8-bit copy

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

  1053 	TPtr8 data8Bit = dataBuf->Des();

  1054 	data8Bit.Copy(aData);

  1055 

  1056 	// Create title

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

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

  1059 	aTestHarness->StartTestL(*title8Bit);

  1060 

  1061 	// Create TDelimitedPathParser object 

  1062 	TDelimitedPathParser8 parser8Bit;

  1063 	parser8Bit.Parse(data8Bit);

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

  1065 

  1066 	aTestHarness->EndTest(error);

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

  1068 	}

  1069 

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

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

  1072 	{

  1073 	// Create title

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

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

  1076 	aTestHarness->StartTestL(*title16Bit);

  1077 

  1078 	// Create TDelimiteddataParser object and do parsing

  1079 	TDelimitedPathParser16 parser16Bit;

  1080 	parser16Bit.Parse(aData);

  1081 

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

  1083 

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

  1085 	aTestHarness->EndTest(error);

  1086 

  1087 	// Make 8-bit copy

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

  1089 	TPtr8 data8Bit = dataBuf->Des();

  1090 	data8Bit.Copy(aData);

  1091 

  1092 	// Create title

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

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

  1095 	aTestHarness->StartTestL(*title8Bit);

  1096 

  1097 	// Create TDelimiteddataParser object and do parsing

  1098 	TDelimitedPathParser8 parser8Bit;

  1099 	parser8Bit.Parse(data8Bit);

  1100 

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

  1102 

  1103 	aTestHarness->EndTest(error);

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

  1105 	}

  1106 

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

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

  1109 	{

  1110 	// Create title

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

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

  1113 	aTestHarness->StartTestL(*title16Bit);

  1114 

  1115 	// Create TDelimitedPathParser object and do parsing

  1116 	TDelimitedPathParser16 parser16Bit;

  1117 	parser16Bit.ParseReverse(aData);

  1118 

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

  1120 

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

  1122 	aTestHarness->EndTest(error);

  1123 

  1124 	// Make 8-bit copy

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

  1126 	TPtr8 data8Bit = dataBuf->Des();

  1127 	data8Bit.Copy(aData);

  1128 

  1129 	// Create title

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

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

  1132 	aTestHarness->StartTestL(*title8Bit);

  1133 

  1134 	// Create TDelimitedPathParser object and do parsing