1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/ossrv/genericservices/httputils/Test/t_uriparser/CDelimitedPathTest.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1726 @@
1.4 +// Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +//
1.18 +
1.19 +#include "CDelimitedPathTest.h"
1.20 +
1.21 +#include <e32base.h>
1.22 +#include <delimitedpath16.h>
1.23 +#include <delimitedpath8.h>
1.24 +
1.25 +#include "TDelimitedDataCommon.h"
1.26 +#include "DelimitedPathTests.h"
1.27 +
1.28 +// Constants
1.29 +//
1.30 +_LIT(KTitle16Bit, "%S (16-Bit)");
1.31 +_LIT(KTitle8Bit, "%S (8-Bit)");
1.32 +
1.33 +CDelimitedPathTest* CDelimitedPathTest::NewLC(CIpuTestHarness* aTestHarness)
1.34 + {
1.35 + CDelimitedPathTest* self = new (ELeave) CDelimitedPathTest(aTestHarness);
1.36 + CleanupStack::PushL(self);
1.37 + self->ConstructL();
1.38 + return self;
1.39 + }
1.40 +
1.41 +CDelimitedPathTest* CDelimitedPathTest::NewL(CIpuTestHarness* aTestHarness)
1.42 + {
1.43 + CDelimitedPathTest* self = CDelimitedPathTest::NewLC(aTestHarness);
1.44 + CleanupStack::Pop(); // self
1.45 + return self;
1.46 + }
1.47 +
1.48 +CDelimitedPathTest::CDelimitedPathTest(CIpuTestHarness* aTestHarness)
1.49 +: iTestHarness(aTestHarness)
1.50 + {
1.51 + }
1.52 +
1.53 +void CDelimitedPathTest::ConstructL()
1.54 + {
1.55 + }
1.56 +
1.57 +CDelimitedPathTest::~CDelimitedPathTest()
1.58 + {
1.59 + }
1.60 +
1.61 +void CDelimitedPathTest::DoTestsL()
1.62 + {
1.63 +//
1.64 +//
1.65 +// Delimited Path Tests
1.66 +//
1.67 +//
1.68 +
1.69 + TestDelimitedPathExtractionL(KPathParse0, &KPathParse0Seg0(), &KPathParse0Seg1(), &KPathParse0Seg2(),
1.70 + &KPathParse0Seg3(), &KPathParse0Seg4(), NULL);
1.71 + TestDelimitedPathExtractionL(KPathParse1, &KPathParse1Seg0(), &KPathParse1Seg1(), NULL);
1.72 + TestDelimitedPathExtractionL(KPathParse2, &KPathParse2Seg0(), &KPathParse2Seg1(), &KPathParse2Seg2(),
1.73 + &KPathParse2Seg3(), &KPathParse2Seg4(), &KPathParse2Seg5(), &KPathParse2Seg6(), NULL);
1.74 +
1.75 + TestDelimitedPathReverseExtractionL(KPathParse0, &KPathParse0Seg4(), &KPathParse0Seg3(), &KPathParse0Seg2(),
1.76 + &KPathParse0Seg1(), &KPathParse0Seg0(), NULL);
1.77 + TestDelimitedPathReverseExtractionL(KPathParse1, &KPathParse1Seg1(), &KPathParse1Seg0(), NULL);
1.78 + TestDelimitedPathReverseExtractionL(KPathParse2, &KPathParse2Seg6(), &KPathParse2Seg5(), &KPathParse2Seg4(),
1.79 + &KPathParse2Seg3(), &KPathParse2Seg2(), &KPathParse2Seg1(), &KPathParse2Seg0(), NULL);
1.80 +
1.81 + TestDelimitedPathDelimiterPresenceL(KPath_DelimPresence0, KPath_FrontDelim0, KPath_BackDelim0);
1.82 + TestDelimitedPathDelimiterPresenceL(KPath_DelimPresence1, KPath_FrontDelim1, KPath_BackDelim1);
1.83 + TestDelimitedPathDelimiterPresenceL(KPath_DelimPresence2, KPath_FrontDelim2, KPath_BackDelim2);
1.84 + TestDelimitedPathDelimiterPresenceL(KPath_DelimPresence3, KPath_FrontDelim3, KPath_BackDelim3);
1.85 +
1.86 + TestDelimitedPathRemainderL(KPath_Rem_Forwards0_0, &KPath_Rem_Forwards0_0(), &KPath_Rem_Forwards0_1(),
1.87 + &KPath_Rem_Forwards0_2(), &KPath_Rem_Forwards0_3(), &KPath_Rem_Forwards0_4(), NULL);
1.88 + TestDelimitedPathRemainderL(KPath_Rem_Forwards1_0, &KPath_Rem_Forwards1_0(), &KPath_Rem_Forwards1_1(),
1.89 + &KPath_Rem_Forwards1_2(), &KPath_Rem_Forwards1_3(), NULL);
1.90 + TestDelimitedPathRemainderL(KPath_Rem_Forwards2_0, &KPath_Rem_Forwards2_0(), &KPath_Rem_Forwards2_1(),
1.91 + &KPath_Rem_Forwards2_2(), &KPath_Rem_Forwards2_3(), NULL);
1.92 +
1.93 + TestDelimitedPathRemainderReverseL(KPath_Rem_Backwards0_0, &KPath_Rem_Backwards0_0(), &KPath_Rem_Backwards0_1(),
1.94 + &KPath_Rem_Backwards0_2(), &KPath_Rem_Backwards0_3(), &KPath_Rem_Backwards0_4(), NULL);
1.95 + TestDelimitedPathRemainderReverseL(KPath_Rem_Backwards1_0, &KPath_Rem_Backwards1_0(), &KPath_Rem_Backwards1_1(),
1.96 + &KPath_Rem_Backwards1_2(), &KPath_Rem_Backwards1_3(), NULL);
1.97 + TestDelimitedPathRemainderReverseL(KPath_Rem_Backwards2_0, &KPath_Rem_Backwards2_0(), &KPath_Rem_Backwards2_1(),
1.98 + &KPath_Rem_Backwards2_2(), &KPath_Rem_Backwards2_3(), NULL);
1.99 +
1.100 + TestDelimitedPathDesL(KPath_Des0);
1.101 +
1.102 + TestDelimitedPathPushFrontL(KPath_PushPopFront0_0, &KPath_Push0_a(), &KPath_PushPopFront0_1(),
1.103 + &KPath_Push0_b(), &KPath_PushPopFront0_2(),
1.104 + &KPath_Push0_c(), &KPath_PushPopFront0_3(),
1.105 + &KPath_Push0_d(), &KPath_PushPopFront0_4(),
1.106 + &KPath_Push0_e(), &KPath_PushPopFront0_5(), NULL, NULL);
1.107 +
1.108 + TestDelimitedPathPushBackL(KPath_PushPopBack0_0, &KPath_Push0_a(), &KPath_PushPopBack0_1(),
1.109 + &KPath_Push0_b(), &KPath_PushPopBack0_2(),
1.110 + &KPath_Push0_c(), &KPath_PushPopBack0_3(),
1.111 + &KPath_Push0_d(), &KPath_PushPopBack0_4(),
1.112 + &KPath_Push0_e(), &KPath_PushPopBack0_5(), NULL, NULL);
1.113 +
1.114 + TestDelimitedPathPopFrontL(KPath_PushPopFront0_5, &KPath_PushPopFront0_4(), &KPath_PushPopFront0_3(),
1.115 + &KPath_PushPopFront0_2(), &KPath_PushPopFront0_1(), &KPath_PushPopFront0_0(), NULL);
1.116 +
1.117 + TestDelimitedPathPopBackL(KPath_PushPopBack0_5, &KPath_PushPopBack0_4(), &KPath_PushPopBack0_3(),
1.118 + &KPath_PushPopBack0_2(), &KPath_PushPopBack0_1(), &KPath_PushPopBack0_0(), NULL);
1.119 +
1.120 + TestDelimitedPathAddAndTrimFrontAndBackDelimiterL(KPath_AddTrimDelim0);
1.121 +
1.122 + TestDelimitedPathInsertAndParseL(KPathInsertForwardsPos0, KPath_InsertForwards0_0,
1.123 + &KPath_Insert0_a(), &KPath_InsertForwards0_1(),
1.124 + &KPath_Insert0_b(), &KPath_InsertForwards0_2(),
1.125 + &KPath_Insert0_c(), &KPath_InsertForwards0_3(),
1.126 + &KPath_Insert0_d(), &KPath_InsertForwards0_4(),
1.127 + &KPath_Insert0_e(), &KPath_InsertForwards0_5(), NULL, NULL);
1.128 +
1.129 + TestDelimitedPathRemoveAndParseL(KPathRemoveForwardsPos0, KPath_RemoveForwards0_0,
1.130 + &KPath_RemoveForwards0_1(), &KPath_RemoveForwards0_2(),
1.131 + &KPath_RemoveForwards0_3(), &KPath_RemoveForwards0_4(),
1.132 + &KPath_RemoveForwards0_5(), NULL);
1.133 +
1.134 + TestDelimitedPathInsertAndParseReverseL(KPathInsertBackwardsPos0, KPath_InsertBackwards0_0,
1.135 + &KPath_Insert0_a(), &KPath_InsertBackwards0_1(),
1.136 + &KPath_Insert0_b(), &KPath_InsertBackwards0_2(),
1.137 + &KPath_Insert0_c(), &KPath_InsertBackwards0_3(),
1.138 + &KPath_Insert0_d(), &KPath_InsertBackwards0_4(),
1.139 + &KPath_Insert0_e(), &KPath_InsertBackwards0_5(), NULL, NULL);
1.140 +
1.141 + TestDelimitedPathRemoveAndParseReverseL(KPathRemoveBackwardsPos0, KPath_RemoveBackwards0_0,
1.142 + &KPath_RemoveBackwards0_1(), &KPath_RemoveBackwards0_2(),
1.143 + &KPath_RemoveBackwards0_3(), &KPath_RemoveBackwards0_4(),
1.144 + &KPath_RemoveBackwards0_5(), NULL);
1.145 +
1.146 + TestDelimitedPathInsertEscapeAndParseL(KPathInsertEscapeForwardsPos0, KPath_InsertEscapeForwards0_0,
1.147 + &KPath_InsertEscape0_a(), &KPath_InsertEscapeForwards0_1(),
1.148 + &KPath_InsertEscape0_b(), &KPath_InsertEscapeForwards0_2(),
1.149 + &KPath_InsertEscape0_c(), &KPath_InsertEscapeForwards0_3(),
1.150 + &KPath_InsertEscape0_d(), &KPath_InsertEscapeForwards0_4(),
1.151 + &KPath_InsertEscape0_e(), &KPath_InsertEscapeForwards0_5(), NULL, NULL);
1.152 +
1.153 + TestDelimitedPathInsertEscapeAndParseReverseL(KPathInsertEscapeBackwardsPos0, KPath_InsertEscapeBackwards0_0,
1.154 + &KPath_InsertEscape0_a(), &KPath_InsertEscapeBackwards0_1(),
1.155 + &KPath_InsertEscape0_b(), &KPath_InsertEscapeBackwards0_2(),
1.156 + &KPath_InsertEscape0_c(), &KPath_InsertEscapeBackwards0_3(),
1.157 + &KPath_InsertEscape0_d(), &KPath_InsertEscapeBackwards0_4(),
1.158 + &KPath_InsertEscape0_e(), &KPath_InsertEscapeBackwards0_5(), NULL, NULL);
1.159 +
1.160 + TestDelimitedPathPushAndEscapeFrontL(KPath_PushEscapeFront0_0, &KPath_PushEscape0_a(), &KPath_PushEscapeFront0_1(),
1.161 + &KPath_PushEscape0_b(), &KPath_PushEscapeFront0_2(),
1.162 + &KPath_PushEscape0_c(), &KPath_PushEscapeFront0_3(),
1.163 + &KPath_PushEscape0_d(), &KPath_PushEscapeFront0_4(),
1.164 + &KPath_PushEscape0_e(), &KPath_PushEscapeFront0_5(), NULL, NULL);
1.165 +
1.166 + TestDelimitedPathPushAndEscapeBackL(KPath_PushEscapeBack0_0, &KPath_PushEscape0_a(), &KPath_PushEscapeBack0_1(),
1.167 + &KPath_PushEscape0_b(), &KPath_PushEscapeBack0_2(),
1.168 + &KPath_PushEscape0_c(), &KPath_PushEscapeBack0_3(),
1.169 + &KPath_PushEscape0_d(), &KPath_PushEscapeBack0_4(),
1.170 + &KPath_PushEscape0_e(), &KPath_PushEscapeBack0_5(), NULL, NULL);
1.171 +
1.172 +//
1.173 +//
1.174 +// Delimited PathSegment Tests
1.175 +//
1.176 +//
1.177 +/*
1.178 + TestDelimitedPathSegmentExtractionL(KPathSegmentParse0, &KPathSegmentParse0Seg0(), &KPathSegmentParse0Seg1(),
1.179 + &KPathSegmentParse0Seg2(), NULL);
1.180 + TestDelimitedPathSegmentExtractionL(KPathSegmentParse1, &KPathSegmentParse1Seg0(), &KPathSegmentParse1Seg1(), &KPathSegmentParse1Seg2(),
1.181 + &KPathSegmentParse1Seg3(), NULL);
1.182 + TestDelimitedPathSegmentExtractionL(KPathSegmentParse2, &KPathSegmentParse2Seg0(), &KPathSegmentParse2Seg1(), &KPathSegmentParse2Seg2(),
1.183 + &KPathSegmentParse2Seg3(), &KPathSegmentParse2Seg4(), &KPathSegmentParse2Seg5(), &KPathSegmentParse2Seg6(),
1.184 + &KPathSegmentParse2Seg7(), NULL);
1.185 +
1.186 + TestDelimitedPathSegmentReverseExtractionL(KPathSegmentParse0, &KPathSegmentParse0Seg2(),
1.187 + &KPathSegmentParse0Seg1(), &KPathSegmentParse0Seg0(), NULL);
1.188 + TestDelimitedPathSegmentReverseExtractionL(KPathSegmentParse1, &KPathSegmentParse1Seg3(), &KPathSegmentParse1Seg2(),
1.189 + &KPathSegmentParse1Seg1(), &KPathSegmentParse1Seg0(), NULL);
1.190 + TestDelimitedPathSegmentReverseExtractionL(KPathSegmentParse2, &KPathSegmentParse2Seg7(), &KPathSegmentParse2Seg6(),
1.191 + &KPathSegmentParse2Seg5(), &KPathSegmentParse2Seg4(), &KPathSegmentParse2Seg3(),
1.192 + &KPathSegmentParse2Seg2(), &KPathSegmentParse2Seg1(), &KPathSegmentParse2Seg0(), NULL);
1.193 +
1.194 + TestDelimitedPathSegmentDelimiterPresenceL(KPathSegment_DelimPresence0, KPathSegment_FrontDelim0, KPathSegment_BackDelim0);
1.195 + TestDelimitedPathSegmentDelimiterPresenceL(KPathSegment_DelimPresence1, KPathSegment_FrontDelim1, KPathSegment_BackDelim1);
1.196 + TestDelimitedPathSegmentDelimiterPresenceL(KPathSegment_DelimPresence2, KPathSegment_FrontDelim2, KPathSegment_BackDelim2);
1.197 + TestDelimitedPathSegmentDelimiterPresenceL(KPathSegment_DelimPresence3, KPathSegment_FrontDelim3, KPathSegment_BackDelim3);
1.198 +
1.199 + TestDelimitedPathSegmentRemainderL(KPathSegment_Rem_Forwards0_0, &KPathSegment_Rem_Forwards0_0(), &KPathSegment_Rem_Forwards0_1(),
1.200 + &KPathSegment_Rem_Forwards0_2(), &KPathSegment_Rem_Forwards0_3(), NULL);
1.201 +
1.202 + TestDelimitedPathSegmentRemainderReverseL(KPathSegment_Rem_Backwards0_0, &KPathSegment_Rem_Backwards0_0(), &KPathSegment_Rem_Backwards0_1(),
1.203 + &KPathSegment_Rem_Backwards0_2(), &KPathSegment_Rem_Backwards0_3(), NULL);
1.204 +
1.205 + TestDelimitedPathSegmentDesL(KPathSegment_Des0);
1.206 +
1.207 + TestDelimitedPathSegmentPushFrontL(KPathSegment_PushPopFront0_0, &KPathSegment_Push0_a(), &KPathSegment_PushPopFront0_1(),
1.208 + &KPathSegment_Push0_b(), &KPathSegment_PushPopFront0_2(),
1.209 + &KPathSegment_Push0_c(), &KPathSegment_PushPopFront0_3(),
1.210 + &KPathSegment_Push0_d(), &KPathSegment_PushPopFront0_4(),
1.211 + &KPathSegment_Push0_e(), &KPathSegment_PushPopFront0_5(), NULL, NULL);
1.212 +
1.213 + TestDelimitedPathSegmentPushBackL(KPathSegment_PushPopBack0_0, &KPathSegment_Push0_a(), &KPathSegment_PushPopBack0_1(),
1.214 + &KPathSegment_Push0_b(), &KPathSegment_PushPopBack0_2(),
1.215 + &KPathSegment_Push0_c(), &KPathSegment_PushPopBack0_3(),
1.216 + &KPathSegment_Push0_d(), &KPathSegment_PushPopBack0_4(),
1.217 + &KPathSegment_Push0_e(), &KPathSegment_PushPopBack0_5(), NULL, NULL);
1.218 +
1.219 + TestDelimitedPathSegmentPopFrontL(KPathSegment_PushPopFront0_5, &KPathSegment_PushPopFront0_4(), &KPathSegment_PushPopFront0_3(),
1.220 + &KPathSegment_PushPopFront0_2(), &KPathSegment_PushPopFront0_1(), &KPathSegment_PushPopFront0_0(), NULL);
1.221 +
1.222 + TestDelimitedPathSegmentPopBackL(KPathSegment_PushPopBack0_5, &KPathSegment_PushPopBack0_4(), &KPathSegment_PushPopBack0_3(),
1.223 + &KPathSegment_PushPopBack0_2(), &KPathSegment_PushPopBack0_1(), &KPathSegment_PushPopBack0_0(), NULL);
1.224 +
1.225 + TestDelimitedPathSegmentAddAndTrimFrontAndBackDelimiterL(KPathSegment_AddTrimDelim0);
1.226 +
1.227 + TestDelimitedPathSegmentInsertAndParseL(KPathSegmentInsertForwardsPos0, KPathSegment_InsertForwards0_0,
1.228 + &KPathSegment_Insert0_a(), &KPathSegment_InsertForwards0_1(),
1.229 + &KPathSegment_Insert0_b(), &KPathSegment_InsertForwards0_2(),
1.230 + &KPathSegment_Insert0_c(), &KPathSegment_InsertForwards0_3(),
1.231 + &KPathSegment_Insert0_d(), &KPathSegment_InsertForwards0_4(),
1.232 + &KPathSegment_Insert0_e(), &KPathSegment_InsertForwards0_5(), NULL, NULL);
1.233 +
1.234 + TestDelimitedPathSegmentRemoveAndParseL(KPathSegmentRemoveForwardsPos0, KPathSegment_RemoveForwards0_0,
1.235 + &KPathSegment_RemoveForwards0_1(), &KPathSegment_RemoveForwards0_2(),
1.236 + &KPathSegment_RemoveForwards0_3(), &KPathSegment_RemoveForwards0_4(),
1.237 + &KPathSegment_RemoveForwards0_5(), NULL);
1.238 +
1.239 + TestDelimitedPathSegmentInsertAndParseReverseL(KPathSegmentInsertBackwardsPos0, KPathSegment_InsertBackwards0_0,
1.240 + &KPathSegment_Insert0_a(), &KPathSegment_InsertBackwards0_1(),
1.241 + &KPathSegment_Insert0_b(), &KPathSegment_InsertBackwards0_2(),
1.242 + &KPathSegment_Insert0_c(), &KPathSegment_InsertBackwards0_3(),
1.243 + &KPathSegment_Insert0_d(), &KPathSegment_InsertBackwards0_4(),
1.244 + &KPathSegment_Insert0_e(), &KPathSegment_InsertBackwards0_5(), NULL, NULL);
1.245 +
1.246 + TestDelimitedPathSegmentRemoveAndParseReverseL(KPathSegmentRemoveBackwardsPos0, KPathSegment_RemoveBackwards0_0,
1.247 + &KPathSegment_RemoveBackwards0_1(), &KPathSegment_RemoveBackwards0_2(),
1.248 + &KPathSegment_RemoveBackwards0_3(), &KPathSegment_RemoveBackwards0_4(),
1.249 + &KPathSegment_RemoveBackwards0_5(), NULL);
1.250 +
1.251 + TestDelimitedPathSegmentInsertEscapeAndParseL(KPathSegmentInsertEscapeForwardsPos0, KPathSegment_InsertEscapeForwards0_0,
1.252 + &KPathSegment_InsertEscape0_a(), &KPathSegment_InsertEscapeForwards0_1(),
1.253 + &KPathSegment_InsertEscape0_b(), &KPathSegment_InsertEscapeForwards0_2(),
1.254 + &KPathSegment_InsertEscape0_c(), &KPathSegment_InsertEscapeForwards0_3(),
1.255 + &KPathSegment_InsertEscape0_d(), &KPathSegment_InsertEscapeForwards0_4(),
1.256 + &KPathSegment_InsertEscape0_e(), &KPathSegment_InsertEscapeForwards0_5(), NULL, NULL);
1.257 +
1.258 + TestDelimitedPathSegmentInsertEscapeAndParseReverseL(KPathSegmentInsertEscapeBackwardsPos0, KPathSegment_InsertEscapeBackwards0_0,
1.259 + &KPathSegment_InsertEscape0_a(), &KPathSegment_InsertEscapeBackwards0_1(),
1.260 + &KPathSegment_InsertEscape0_b(), &KPathSegment_InsertEscapeBackwards0_2(),
1.261 + &KPathSegment_InsertEscape0_c(), &KPathSegment_InsertEscapeBackwards0_3(),
1.262 + &KPathSegment_InsertEscape0_d(), &KPathSegment_InsertEscapeBackwards0_4(),
1.263 + &KPathSegment_InsertEscape0_e(), &KPathSegment_InsertEscapeBackwards0_5(), NULL, NULL);
1.264 +
1.265 + TestDelimitedPathSegmentPushAndEscapeFrontL(KPathSegment_PushEscapeFront0_0, &KPathSegment_PushEscape0_a(), &KPathSegment_PushEscapeFront0_1(),
1.266 + &KPathSegment_PushEscape0_b(), &KPathSegment_PushEscapeFront0_2(),
1.267 + &KPathSegment_PushEscape0_c(), &KPathSegment_PushEscapeFront0_3(),
1.268 + &KPathSegment_PushEscape0_d(), &KPathSegment_PushEscapeFront0_4(),
1.269 + &KPathSegment_PushEscape0_e(), &KPathSegment_PushEscapeFront0_5(), NULL, NULL);
1.270 +
1.271 + TestDelimitedPathSegmentPushAndEscapeBackL(KPathSegment_PushEscapeBack0_0, &KPathSegment_PushEscape0_a(), &KPathSegment_PushEscapeBack0_1(),
1.272 + &KPathSegment_PushEscape0_b(), &KPathSegment_PushEscapeBack0_2(),
1.273 + &KPathSegment_PushEscape0_c(), &KPathSegment_PushEscapeBack0_3(),
1.274 + &KPathSegment_PushEscape0_d(), &KPathSegment_PushEscapeBack0_4(),
1.275 + &KPathSegment_PushEscape0_e(), &KPathSegment_PushEscapeBack0_5(), NULL, NULL);
1.276 +
1.277 +//
1.278 +//
1.279 +// Delimited Query Tests
1.280 +//
1.281 +//
1.282 + TestDelimitedQueryExtractionL(KQueryParse0, &KQueryParse0Seg0(), &KQueryParse0Seg1(), &KQueryParse0Seg2(),
1.283 + &KQueryParse0Seg3(), NULL);
1.284 + TestDelimitedQueryExtractionL(KQueryParse1, &KQueryParse1Seg0(), &KQueryParse1Seg1(), NULL);
1.285 + TestDelimitedQueryExtractionL(KQueryParse2, &KQueryParse2Seg0(), &KQueryParse2Seg1(), &KQueryParse2Seg2(),
1.286 + &KQueryParse2Seg3(), &KQueryParse2Seg4(), &KQueryParse2Seg5(), NULL);
1.287 +
1.288 + TestDelimitedQueryReverseExtractionL(KQueryParse0, &KQueryParse0Seg3(), &KQueryParse0Seg2(),
1.289 + &KQueryParse0Seg1(), &KQueryParse0Seg0(), NULL);
1.290 + TestDelimitedQueryReverseExtractionL(KQueryParse1, &KQueryParse1Seg1(), &KQueryParse1Seg0(), NULL);
1.291 + TestDelimitedQueryReverseExtractionL(KQueryParse2, &KQueryParse2Seg5(), &KQueryParse2Seg4(),
1.292 + &KQueryParse2Seg3(), &KQueryParse2Seg2(), &KQueryParse2Seg1(), &KQueryParse2Seg0(), NULL);
1.293 +
1.294 + TestDelimitedQueryDelimiterPresenceL(KQuery_DelimPresence0, KQuery_FrontDelim0, KQuery_BackDelim0);
1.295 + TestDelimitedQueryDelimiterPresenceL(KQuery_DelimPresence1, KQuery_FrontDelim1, KQuery_BackDelim1);
1.296 + TestDelimitedQueryDelimiterPresenceL(KQuery_DelimPresence2, KQuery_FrontDelim2, KQuery_BackDelim2);
1.297 + TestDelimitedQueryDelimiterPresenceL(KQuery_DelimPresence3, KQuery_FrontDelim3, KQuery_BackDelim3);
1.298 +
1.299 + TestDelimitedQueryRemainderL(KQuery_Rem_Forwards0_0, &KQuery_Rem_Forwards0_0(), &KQuery_Rem_Forwards0_1(),
1.300 + &KQuery_Rem_Forwards0_2(), &KQuery_Rem_Forwards0_3(), NULL);
1.301 +
1.302 + TestDelimitedQueryRemainderReverseL(KQuery_Rem_Backwards0_0, &KQuery_Rem_Backwards0_0(), &KQuery_Rem_Backwards0_1(),
1.303 + &KQuery_Rem_Backwards0_2(), &KQuery_Rem_Backwards0_3(), NULL);
1.304 +
1.305 + TestDelimitedQueryDesL(KQuery_Des0);
1.306 +
1.307 + TestDelimitedQueryPushFrontL(KQuery_PushPopFront0_0, &KQuery_Push0_a(), &KQuery_PushPopFront0_1(),
1.308 + &KQuery_Push0_b(), &KQuery_PushPopFront0_2(),
1.309 + &KQuery_Push0_c(), &KQuery_PushPopFront0_3(),
1.310 + &KQuery_Push0_d(), &KQuery_PushPopFront0_4(),
1.311 + &KQuery_Push0_e(), &KQuery_PushPopFront0_5(), NULL, NULL);
1.312 +
1.313 + TestDelimitedQueryPushBackL(KQuery_PushPopBack0_0, &KQuery_Push0_a(), &KQuery_PushPopBack0_1(),
1.314 + &KQuery_Push0_b(), &KQuery_PushPopBack0_2(),
1.315 + &KQuery_Push0_c(), &KQuery_PushPopBack0_3(),
1.316 + &KQuery_Push0_d(), &KQuery_PushPopBack0_4(),
1.317 + &KQuery_Push0_e(), &KQuery_PushPopBack0_5(), NULL, NULL);
1.318 +
1.319 + TestDelimitedQueryPopFrontL(KQuery_PushPopFront0_5, &KQuery_PushPopFront0_4(), &KQuery_PushPopFront0_3(),
1.320 + &KQuery_PushPopFront0_2(), &KQuery_PushPopFront0_1(), &KQuery_PushPopFront0_0(), NULL);
1.321 +
1.322 + TestDelimitedQueryPopBackL(KQuery_PushPopBack0_5, &KQuery_PushPopBack0_4(), &KQuery_PushPopBack0_3(),
1.323 + &KQuery_PushPopBack0_2(), &KQuery_PushPopBack0_1(), &KQuery_PushPopBack0_0(), NULL);
1.324 +
1.325 + TestDelimitedQueryAddAndTrimFrontAndBackDelimiterL(KQuery_AddTrimDelim0);
1.326 +
1.327 + TestDelimitedQueryInsertAndParseL(KQueryInsertForwardsPos0, KQuery_InsertForwards0_0,
1.328 + &KQuery_Insert0_a(), &KQuery_InsertForwards0_1(),
1.329 + &KQuery_Insert0_b(), &KQuery_InsertForwards0_2(),
1.330 + &KQuery_Insert0_c(), &KQuery_InsertForwards0_3(),
1.331 + &KQuery_Insert0_d(), &KQuery_InsertForwards0_4(),
1.332 + &KQuery_Insert0_e(), &KQuery_InsertForwards0_5(), NULL, NULL);
1.333 +
1.334 + TestDelimitedQueryRemoveAndParseL(KQueryRemoveForwardsPos0, KQuery_RemoveForwards0_0,
1.335 + &KQuery_RemoveForwards0_1(), &KQuery_RemoveForwards0_2(),
1.336 + &KQuery_RemoveForwards0_3(), &KQuery_RemoveForwards0_4(),
1.337 + &KQuery_RemoveForwards0_5(), NULL);
1.338 +
1.339 + TestDelimitedQueryInsertAndParseReverseL(KQueryInsertBackwardsPos0, KQuery_InsertBackwards0_0,
1.340 + &KQuery_Insert0_a(), &KQuery_InsertBackwards0_1(),
1.341 + &KQuery_Insert0_b(), &KQuery_InsertBackwards0_2(),
1.342 + &KQuery_Insert0_c(), &KQuery_InsertBackwards0_3(),
1.343 + &KQuery_Insert0_d(), &KQuery_InsertBackwards0_4(),
1.344 + &KQuery_Insert0_e(), &KQuery_InsertBackwards0_5(), NULL, NULL);
1.345 +
1.346 + TestDelimitedQueryRemoveAndParseReverseL(KQueryRemoveBackwardsPos0, KQuery_RemoveBackwards0_0,
1.347 + &KQuery_RemoveBackwards0_1(), &KQuery_RemoveBackwards0_2(),
1.348 + &KQuery_RemoveBackwards0_3(), &KQuery_RemoveBackwards0_4(),
1.349 + &KQuery_RemoveBackwards0_5(), NULL);
1.350 +
1.351 + TestDelimitedQueryInsertEscapeAndParseL(KQueryInsertEscapeForwardsPos0, KQuery_InsertEscapeForwards0_0,
1.352 + &KQuery_InsertEscape0_a(), &KQuery_InsertEscapeForwards0_1(),
1.353 + &KQuery_InsertEscape0_b(), &KQuery_InsertEscapeForwards0_2(),
1.354 + &KQuery_InsertEscape0_c(), &KQuery_InsertEscapeForwards0_3(),
1.355 + &KQuery_InsertEscape0_d(), &KQuery_InsertEscapeForwards0_4(),
1.356 + &KQuery_InsertEscape0_e(), &KQuery_InsertEscapeForwards0_5(), NULL, NULL);
1.357 +
1.358 + TestDelimitedQueryInsertEscapeAndParseReverseL(KQueryInsertEscapeBackwardsPos0, KQuery_InsertEscapeBackwards0_0,
1.359 + &KQuery_InsertEscape0_a(), &KQuery_InsertEscapeBackwards0_1(),
1.360 + &KQuery_InsertEscape0_b(), &KQuery_InsertEscapeBackwards0_2(),
1.361 + &KQuery_InsertEscape0_c(), &KQuery_InsertEscapeBackwards0_3(),
1.362 + &KQuery_InsertEscape0_d(), &KQuery_InsertEscapeBackwards0_4(),
1.363 + &KQuery_InsertEscape0_e(), &KQuery_InsertEscapeBackwards0_5(), NULL, NULL);
1.364 +
1.365 + TestDelimitedQueryPushAndEscapeFrontL(KQuery_PushEscapeFront0_0, &KQuery_PushEscape0_a(), &KQuery_PushEscapeFront0_1(),
1.366 + &KQuery_PushEscape0_b(), &KQuery_PushEscapeFront0_2(),
1.367 + &KQuery_PushEscape0_c(), &KQuery_PushEscapeFront0_3(),
1.368 + &KQuery_PushEscape0_d(), &KQuery_PushEscapeFront0_4(),
1.369 + &KQuery_PushEscape0_e(), &KQuery_PushEscapeFront0_5(), NULL, NULL);
1.370 +
1.371 + TestDelimitedQueryPushAndEscapeBackL(KQuery_PushEscapeBack0_0, &KQuery_PushEscape0_a(), &KQuery_PushEscapeBack0_1(),
1.372 + &KQuery_PushEscape0_b(), &KQuery_PushEscapeBack0_2(),
1.373 + &KQuery_PushEscape0_c(), &KQuery_PushEscapeBack0_3(),
1.374 + &KQuery_PushEscape0_d(), &KQuery_PushEscapeBack0_4(),
1.375 + &KQuery_PushEscape0_e(), &KQuery_PushEscapeBack0_5(), NULL, NULL);
1.376 +*/ }
1.377 +
1.378 +//
1.379 +//
1.380 +// Delimited Path tests
1.381 +//
1.382 +//
1.383 +
1.384 +void CDelimitedPathTest::TestDelimitedPathExtractionL(TRefByValue<const TDesC> aPath, ...) const
1.385 + {
1.386 + VA_LIST list1; VA_START(list1, aPath);
1.387 + VA_LIST list2; VA_START(list2, aPath);
1.388 + const TDesC& path = aPath;
1.389 +
1.390 + TestDelimitedDataExtractionL(_L("Test TDelimitedPathParser Parse : GetNext, Dec, Inc, Peek and Eos"), iTestHarness, path, list1, list2);
1.391 + VA_END(list1); VA_END(list2);
1.392 + }
1.393 +
1.394 +void CDelimitedPathTest::TestDelimitedPathReverseExtractionL(TRefByValue<const TDesC> aPath, ...) const
1.395 + {
1.396 + VA_LIST list1; VA_START(list1, aPath);
1.397 + VA_LIST list2; VA_START(list2, aPath);
1.398 + const TDesC& path = aPath;
1.399 +
1.400 + TestDelimitedDataReverseExtractionL(_L("Test TDelimitedPathParser ParseReverse : GetNext, Dec, Inc, Peek and Eos"), iTestHarness, path, list1, list2);
1.401 + VA_END(list1); VA_END(list2);
1.402 + }
1.403 +
1.404 +void CDelimitedPathTest::TestDelimitedPathDelimiterPresenceL(const TDesC& aPath, TBool aFrontDelim, TBool aBackDelim) const
1.405 + {
1.406 + TestDelimitedDataDelimiterPresenceL(_L("Test TDelimitedPathParser Delimiter Presence"), iTestHarness, aPath, aFrontDelim, aBackDelim);
1.407 + }
1.408 +
1.409 +void CDelimitedPathTest::TestDelimitedPathRemainderL(TRefByValue<const TDesC> aPath, ...) const
1.410 + {
1.411 + VA_LIST list1; VA_START(list1, aPath);
1.412 + VA_LIST list2; VA_START(list2, aPath);
1.413 + const TDesC& path = aPath;
1.414 +
1.415 + TestDelimitedDataRemainderL(_L("Test TDelimitedPathParser Remainder, Parse"), iTestHarness, path, list1, list2);
1.416 + VA_END(list1); VA_END(list2);
1.417 + }
1.418 +
1.419 +void CDelimitedPathTest::TestDelimitedPathRemainderReverseL(TRefByValue<const TDesC> aPath, ...) const
1.420 + {
1.421 + VA_LIST list1; VA_START(list1, aPath);
1.422 + VA_LIST list2; VA_START(list2, aPath);
1.423 + const TDesC& path = aPath;
1.424 +
1.425 + TestDelimitedDataRemainderReverseL(_L("Test TDelimitedPathParser Remainder, ParseReverse"), iTestHarness, path, list1, list2);
1.426 + VA_END(list1); VA_END(list2);
1.427 + }
1.428 +
1.429 +void CDelimitedPathTest::TestDelimitedPathDesL(const TDesC& aPath) const
1.430 + {
1.431 + TestDelimitedDataDesL(_L("Test TDelimitedPathParser Des"), iTestHarness, aPath);
1.432 + }
1.433 +
1.434 +void CDelimitedPathTest::TestDelimitedPathPushFrontL(TRefByValue<const TDesC> aPath, ...) const
1.435 + {
1.436 + VA_LIST list1; VA_START(list1, aPath);
1.437 + VA_LIST list2; VA_START(list2, aPath);
1.438 + const TDesC& path = aPath;
1.439 +
1.440 + TestDelimitedDataPushFrontL(_L("Test CDelimitedPath PushFront"), iTestHarness, path, list1, list2);
1.441 + VA_END(list1);
1.442 + VA_END(list2);
1.443 + }
1.444 +
1.445 +void CDelimitedPathTest::TestDelimitedPathPushBackL(TRefByValue<const TDesC> aPath, ...) const
1.446 + {
1.447 + VA_LIST list1; VA_START(list1, aPath);
1.448 + VA_LIST list2; VA_START(list2, aPath);
1.449 + const TDesC& path = aPath;
1.450 +
1.451 + TestDelimitedDataPushBackL(_L("Test CDelimitedPath PushBack"), iTestHarness, path, list1, list2);
1.452 + VA_END(list1); VA_END(list2);
1.453 + }
1.454 +
1.455 +void CDelimitedPathTest::TestDelimitedPathPopFrontL(TRefByValue<const TDesC> aPath, ...) const
1.456 + {
1.457 + VA_LIST list1; VA_START(list1, aPath);
1.458 + VA_LIST list2; VA_START(list2, aPath);
1.459 + const TDesC& path = aPath;
1.460 +
1.461 + TestDelimitedDataPopFrontL(_L("Test CDelimitedPath PopFront"), iTestHarness, path, list1, list2);
1.462 + VA_END(list1); VA_END(list2);
1.463 + }
1.464 +
1.465 +void CDelimitedPathTest::TestDelimitedPathPopBackL(TRefByValue<const TDesC> aPath, ...) const
1.466 + {
1.467 + VA_LIST list1; VA_START(list1, aPath);
1.468 + VA_LIST list2; VA_START(list2, aPath);
1.469 + const TDesC& path = aPath;
1.470 +
1.471 + TestDelimitedDataPopBackL(_L("Test CDelimitedPath PopBack"), iTestHarness, path, list1, list2);
1.472 + VA_END(list1); VA_END(list2);
1.473 + }
1.474 +
1.475 +void CDelimitedPathTest::TestDelimitedPathAddAndTrimFrontAndBackDelimiterL(const TDesC& aPath) const
1.476 + {
1.477 + TestDelimitedDataAddAndTrimFrontAndBackDelimiterL(_L("Test CDelimitedPath Add and Trim Front and Back delimiter"), iTestHarness, aPath);
1.478 + }
1.479 +
1.480 +void CDelimitedPathTest::TestDelimitedPathInsertAndParseL(TInt aStartPos, TRefByValue<const TDesC> aPath, ...) const
1.481 + {
1.482 + VA_LIST list1; VA_START(list1, aPath);
1.483 + VA_LIST list2; VA_START(list2, aPath);
1.484 + const TDesC& path = aPath;
1.485 +
1.486 + TestDelimitedDataInsertAndParseL(_L("Test CDelimitedPath InsertCurrent, Parse"), iTestHarness, path, list1, list2, aStartPos);
1.487 + VA_END(list1); VA_END(list2);
1.488 + }
1.489 +
1.490 +void CDelimitedPathTest::TestDelimitedPathRemoveAndParseL(TInt aStartPos, TRefByValue<const TDesC> aPath, ...) const
1.491 + {
1.492 + VA_LIST list1; VA_START(list1, aPath);
1.493 + VA_LIST list2; VA_START(list2, aPath);
1.494 + const TDesC& path = aPath;
1.495 +
1.496 + TestDelimitedDataRemoveAndParseL(_L("Test CDelimitedPath RemoveCurrent, Parse"), iTestHarness, path, list1, list2, aStartPos);
1.497 + VA_END(list1); VA_END(list2);
1.498 + }
1.499 +
1.500 +void CDelimitedPathTest::TestDelimitedPathInsertAndParseReverseL(TInt aStartPos, TRefByValue<const TDesC> aPath, ...) const
1.501 + {
1.502 + VA_LIST list1; VA_START(list1, aPath);
1.503 + VA_LIST list2; VA_START(list2, aPath);
1.504 + const TDesC& path = aPath;
1.505 +
1.506 + TestDelimitedDataInsertAndParseReverseL(_L("Test CDelimitedPath InsertCurrent, ParseReverse"), iTestHarness, path, list1, list2, aStartPos);
1.507 + VA_END(list1); VA_END(list2);
1.508 + }
1.509 +
1.510 +void CDelimitedPathTest::TestDelimitedPathRemoveAndParseReverseL(TInt aStartPos, TRefByValue<const TDesC> aPath, ...) const
1.511 + {
1.512 + VA_LIST list1; VA_START(list1, aPath);
1.513 + VA_LIST list2; VA_START(list2, aPath);
1.514 + const TDesC& path = aPath;
1.515 +
1.516 + TestDelimitedDataRemoveAndParseReverseL(_L("Test CDelimitedPath RemoveCurrent, ParseReverse"), iTestHarness, path, list1, list2, aStartPos);
1.517 + VA_END(list1); VA_END(list2);
1.518 + }
1.519 +
1.520 +void CDelimitedPathTest::TestDelimitedPathInsertEscapeAndParseL(TInt aStartPos, TRefByValue<const TDesC> aPath, ...) const
1.521 + {
1.522 + VA_LIST list1; VA_START(list1, aPath);
1.523 + VA_LIST list2; VA_START(list2, aPath);
1.524 + const TDesC& path = aPath;
1.525 +
1.526 + TestDelimitedDataInsertEscapeAndParseL(_L("Test CDelimitedPath InsertAndEscapeCurrent, Parse"), iTestHarness, path, list1, list2, aStartPos);
1.527 + VA_END(list1); VA_END(list2);
1.528 + }
1.529 +
1.530 +void CDelimitedPathTest::TestDelimitedPathInsertEscapeAndParseReverseL(TInt aStartPos, TRefByValue<const TDesC> aPath, ...) const
1.531 + {
1.532 + VA_LIST list1; VA_START(list1, aPath);
1.533 + VA_LIST list2; VA_START(list2, aPath);
1.534 + const TDesC& path = aPath;
1.535 +
1.536 + TestDelimitedDataInsertEscapeAndParseReverseL(_L("Test CDelimitedPath InsertAndEscapeCurrent, ParseReverse"), iTestHarness, path, list1, list2, aStartPos);
1.537 + VA_END(list1); VA_END(list2);
1.538 + }
1.539 +
1.540 +void CDelimitedPathTest::TestDelimitedPathPushAndEscapeFrontL(TRefByValue<const TDesC> aPath, ...) const
1.541 + {
1.542 + VA_LIST list1; VA_START(list1, aPath);
1.543 + VA_LIST list2; VA_START(list2, aPath);
1.544 + const TDesC& path = aPath;
1.545 +
1.546 + TestDelimitedDataPushAndEscapeFrontL(_L("Test CDelimitedPath PushAndEscapeFront"), iTestHarness, path, list1, list2);
1.547 + VA_END(list1); VA_END(list2);
1.548 + }
1.549 +
1.550 +void CDelimitedPathTest::TestDelimitedPathPushAndEscapeBackL(TRefByValue<const TDesC> aPath, ...) const
1.551 + {
1.552 + VA_LIST list1; VA_START(list1, aPath);
1.553 + VA_LIST list2; VA_START(list2, aPath);
1.554 + const TDesC& path = aPath;
1.555 +
1.556 + TestDelimitedDataPushAndEscapeBackL(_L("Test CDelimitedPath PushAndEscapeBack"), iTestHarness, path, list1, list2);
1.557 + VA_END(list1); VA_END(list2);
1.558 + }
1.559 +/*
1.560 +//
1.561 +//
1.562 +// Delimited PathSegment tests
1.563 +//
1.564 +//
1.565 +
1.566 +void CDelimitedPathTest::TestDelimitedPathSegmentExtractionL(TRefByValue<const TDesC> aPathSegment, ...) const
1.567 + {
1.568 + VA_LIST list1; VA_START(list1, aPathSegment);
1.569 + VA_LIST list2; VA_START(list2, aPathSegment);
1.570 + const TDesC& pathSegment = aPathSegment;
1.571 +
1.572 + TestDelimitedDataExtractionL(TDelimitedPathSegmentParser16(), TDelimitedPathSegmentParser8(),
1.573 + _L("Test TDelimitedPathSegmentParser Parse : GetNext, Dec, Inc, Peek and Eos"), iTestHarness, pathSegment, list1, list2);
1.574 + VA_END(list1); VA_END(list2);
1.575 + }
1.576 +
1.577 +void CDelimitedPathTest::TestDelimitedPathSegmentReverseExtractionL(TRefByValue<const TDesC> aPathSegment, ...) const
1.578 + {
1.579 + VA_LIST list1; VA_START(list1, aPathSegment);
1.580 + VA_LIST list2; VA_START(list2, aPathSegment);
1.581 + const TDesC& pathSegment = aPathSegment;
1.582 +
1.583 + TestDelimitedDataReverseExtractionL<TDelimitedPathSegmentParser16, TDelimitedPathSegmentParser8>(
1.584 + _L("Test TDelimitedPathSegmentParser ParseReverse : GetNext, Dec, Inc, Peek and Eos"), iTestHarness, pathSegment, list1, list2);
1.585 + VA_END(list1); VA_END(list2);
1.586 + }
1.587 +
1.588 +void CDelimitedPathTest::TestDelimitedPathSegmentDelimiterPresenceL(const TDesC& aPathSegment, TBool aFrontDelim, TBool aBackDelim) const
1.589 + {
1.590 + TestDelimitedDataDelimiterPresenceL<TDelimitedPathSegmentParser16, TDelimitedPathSegmentParser8>(
1.591 + _L("Test TDelimitedPathSegmentParser Delimiter Presence"), iTestHarness, aPathSegment, aFrontDelim, aBackDelim);
1.592 + }
1.593 +
1.594 +void CDelimitedPathTest::TestDelimitedPathSegmentRemainderL(TRefByValue<const TDesC> aPathSegment, ...) const
1.595 + {
1.596 + VA_LIST list1; VA_START(list1, aPathSegment);
1.597 + VA_LIST list2; VA_START(list2, aPathSegment);
1.598 + const TDesC& pathSegment = aPathSegment;
1.599 +
1.600 + TestDelimitedDataRemainderL<TDelimitedPathSegmentParser16, TDelimitedPathSegmentParser8>(
1.601 + _L("Test TDelimitedPathSegmentParser Remainder, Parse"), iTestHarness, pathSegment, list1, list2);
1.602 + VA_END(list1); VA_END(list2);
1.603 + }
1.604 +
1.605 +void CDelimitedPathTest::TestDelimitedPathSegmentRemainderReverseL(TRefByValue<const TDesC> aPathSegment, ...) const
1.606 + {
1.607 + VA_LIST list1; VA_START(list1, aPathSegment);
1.608 + VA_LIST list2; VA_START(list2, aPathSegment);
1.609 + const TDesC& pathSegment = aPathSegment;
1.610 +
1.611 + TestDelimitedDataRemainderReverseL<TDelimitedPathSegmentParser16, TDelimitedPathSegmentParser8>(
1.612 + _L("Test TDelimitedPathSegmentParser Remainder, ParseReverse"), iTestHarness, pathSegment, list1, list2);
1.613 + VA_END(list1); VA_END(list2);
1.614 + }
1.615 +
1.616 +void CDelimitedPathTest::TestDelimitedPathSegmentDesL(const TDesC& aPathSegment) const
1.617 + {
1.618 + TestDelimitedDataDesL<TDelimitedPathSegmentParser16, TDelimitedPathSegmentParser8>(_L("Test TDelimitedPathSegment Des"), iTestHarness, aPathSegment);
1.619 + }
1.620 +
1.621 +void CDelimitedPathTest::TestDelimitedPathSegmentPushFrontL(TRefByValue<const TDesC> aPathSegment, ...) const
1.622 + {
1.623 + VA_LIST list1; VA_START(list1, aPathSegment);
1.624 + VA_LIST list2; VA_START(list2, aPathSegment);
1.625 + const TDesC& pathSegment = aPathSegment;
1.626 +
1.627 + CDelimitedPath16* path16Bit = NULL; CDelimitedPath8* path8Bit = NULL;
1.628 + TestDelimitedDataPushFrontL(path16Bit, path8Bit,
1.629 + _L("Test TDelimitedPathSegmentParser PushFront"), iTestHarness, pathSegment, list1, list2);
1.630 + VA_END(list1);
1.631 + VA_END(list2);
1.632 + }
1.633 +
1.634 +void CDelimitedPathTest::TestDelimitedPathSegmentPushBackL(TRefByValue<const TDesC> aPathSegment, ...) const
1.635 + {
1.636 + VA_LIST list1; VA_START(list1, aPathSegment);
1.637 + VA_LIST list2; VA_START(list2, aPathSegment);
1.638 + const TDesC& pathSegment = aPathSegment;
1.639 +
1.640 + TestDelimitedDataPushBackL<CDelimitedPathSegment16, CDelimitedPathSegment8>(
1.641 + _L("Test TDelimitedPathSegmentParser PushBack"), iTestHarness, pathSegment, list1, list2);
1.642 + VA_END(list1); VA_END(list2);
1.643 + }
1.644 +
1.645 +void CDelimitedPathTest::TestDelimitedPathSegmentPopFrontL(TRefByValue<const TDesC> aPathSegment, ...) const
1.646 + {
1.647 + VA_LIST list1; VA_START(list1, aPathSegment);
1.648 + VA_LIST list2; VA_START(list2, aPathSegment);
1.649 + const TDesC& pathSegment = aPathSegment;
1.650 +
1.651 + TestDelimitedDataPopFrontL<CDelimitedPathSegment16, CDelimitedPathSegment8>(
1.652 + _L("Test TDelimitedPathSegmentParser PopFront"), iTestHarness, pathSegment, list1, list2);
1.653 + VA_END(list1); VA_END(list2);
1.654 + }
1.655 +
1.656 +void CDelimitedPathTest::TestDelimitedPathSegmentPopBackL(TRefByValue<const TDesC> aPathSegment, ...) const
1.657 + {
1.658 + VA_LIST list1; VA_START(list1, aPathSegment);
1.659 + VA_LIST list2; VA_START(list2, aPathSegment);
1.660 + const TDesC& pathSegment = aPathSegment;
1.661 +
1.662 + TestDelimitedDataPopBackL<CDelimitedPathSegment16, CDelimitedPathSegment8>(
1.663 + _L("Test TDelimitedPathSegmentParser PopBack"), iTestHarness, pathSegment, list1, list2);
1.664 + VA_END(list1); VA_END(list2);
1.665 + }
1.666 +
1.667 +void CDelimitedPathTest::TestDelimitedPathSegmentAddAndTrimFrontAndBackDelimiterL(const TDesC& aPathSegment) const
1.668 + {
1.669 + TestDelimitedDataAddAndTrimFrontAndBackDelimiterL<CDelimitedPathSegment16, CDelimitedPathSegment8>(
1.670 + _L("Test TDelimitedPathSegmentParser Add and Trim Front and Back delimiter"), iTestHarness, aPathSegment);
1.671 + }
1.672 +
1.673 +void CDelimitedPathTest::TestDelimitedPathSegmentInsertAndParseL(TInt aStartPos, TRefByValue<const TDesC> aPathSegment, ...) const
1.674 + {
1.675 + VA_LIST list1; VA_START(list1, aPathSegment);
1.676 + VA_LIST list2; VA_START(list2, aPathSegment);
1.677 + const TDesC& pathSegment = aPathSegment;
1.678 +
1.679 + TestDelimitedDataInsertAndParseL<CDelimitedPathSegment16, CDelimitedPathSegment8>(
1.680 + _L("Test TDelimitedPathSegmentParser InsertCurrent, Parse"), iTestHarness, pathSegment, list1, list2, aStartPos);
1.681 + VA_END(list1); VA_END(list2);
1.682 + }
1.683 +
1.684 +void CDelimitedPathTest::TestDelimitedPathSegmentRemoveAndParseL(TInt aStartPos, TRefByValue<const TDesC> aPathSegment, ...) const
1.685 + {
1.686 + VA_LIST list1; VA_START(list1, aPathSegment);
1.687 + VA_LIST list2; VA_START(list2, aPathSegment);
1.688 + const TDesC& pathSegment = aPathSegment;
1.689 +
1.690 + TestDelimitedDataRemoveAndParseL<CDelimitedPathSegment16, CDelimitedPathSegment8>(
1.691 + _L("Test TDelimitedPathSegmentParser RemoveCurrent, Parse"), iTestHarness, pathSegment, list1, list2, aStartPos);
1.692 + VA_END(list1); VA_END(list2);
1.693 + }
1.694 +
1.695 +void CDelimitedPathTest::TestDelimitedPathSegmentInsertAndParseReverseL(TInt aStartPos, TRefByValue<const TDesC> aPathSegment, ...) const
1.696 + {
1.697 + VA_LIST list1; VA_START(list1, aPathSegment);
1.698 + VA_LIST list2; VA_START(list2, aPathSegment);
1.699 + const TDesC& pathSegment = aPathSegment;
1.700 +
1.701 + TestDelimitedDataInsertAndParseReverseL<CDelimitedPathSegment16, CDelimitedPathSegment8>(
1.702 + _L("Test TDelimitedPathSegmentParser InsertCurrent, ParseReverse"), iTestHarness, pathSegment, list1, list2, aStartPos);
1.703 + VA_END(list1); VA_END(list2);
1.704 + }
1.705 +
1.706 +void CDelimitedPathTest::TestDelimitedPathSegmentRemoveAndParseReverseL(TInt aStartPos, TRefByValue<const TDesC> aPathSegment, ...) const
1.707 + {
1.708 + VA_LIST list1; VA_START(list1, aPathSegment);
1.709 + VA_LIST list2; VA_START(list2, aPathSegment);
1.710 + const TDesC& pathSegment = aPathSegment;
1.711 +
1.712 + TestDelimitedDataRemoveAndParseReverseL<CDelimitedPathSegment16, CDelimitedPathSegment8>(
1.713 + _L("Test TDelimitedPathSegmentParser RemoveCurrent, ParseReverse"), iTestHarness, pathSegment, list1, list2, aStartPos);
1.714 + VA_END(list1); VA_END(list2);
1.715 + }
1.716 +
1.717 +void CDelimitedPathTest::TestDelimitedPathSegmentInsertEscapeAndParseL(TInt aStartPos, TRefByValue<const TDesC> aPathSegment, ...) const
1.718 + {
1.719 + VA_LIST list1; VA_START(list1, aPathSegment);
1.720 + VA_LIST list2; VA_START(list2, aPathSegment);
1.721 + const TDesC& pathSegment = aPathSegment;
1.722 +
1.723 + TestDelimitedDataInsertEscapeAndParseL<CDelimitedPathSegment16, CDelimitedPathSegment8>(
1.724 + _L("Test TDelimitedPathSegmentParser InsertAndEscapeCurrent, Parse"), iTestHarness, pathSegment, list1, list2, aStartPos);
1.725 + VA_END(list1); VA_END(list2);
1.726 + }
1.727 +
1.728 +void CDelimitedPathTest::TestDelimitedPathSegmentInsertEscapeAndParseReverseL(TInt aStartPos, TRefByValue<const TDesC> aPathSegment, ...) const
1.729 + {
1.730 + VA_LIST list1; VA_START(list1, aPathSegment);
1.731 + VA_LIST list2; VA_START(list2, aPathSegment);
1.732 + const TDesC& pathSegment = aPathSegment;
1.733 +
1.734 + TestDelimitedDataInsertEscapeAndParseReverseL<CDelimitedPathSegment16, CDelimitedPathSegment8>(
1.735 + _L("Test TDelimitedPathSegmentParser InsertAndEscapeCurrent, ParseReverse"), iTestHarness, pathSegment, list1, list2, aStartPos);
1.736 + VA_END(list1); VA_END(list2);
1.737 + }
1.738 +
1.739 +void CDelimitedPathTest::TestDelimitedPathSegmentPushAndEscapeFrontL(TRefByValue<const TDesC> aPathSegment, ...) const
1.740 + {
1.741 + VA_LIST list1; VA_START(list1, aPathSegment);
1.742 + VA_LIST list2; VA_START(list2, aPathSegment);
1.743 + const TDesC& pathSegment = aPathSegment;
1.744 +
1.745 + TestDelimitedDataPushAndEscapeFrontL<CDelimitedPathSegment16, CDelimitedPathSegment8>(
1.746 + _L("Test TDelimitedPathSegmentParser PushAndEscapeFront"), iTestHarness, pathSegment, list1, list2);
1.747 + VA_END(list1); VA_END(list2);
1.748 + }
1.749 +
1.750 +void CDelimitedPathTest::TestDelimitedPathSegmentPushAndEscapeBackL(TRefByValue<const TDesC> aPathSegment, ...) const
1.751 + {
1.752 + VA_LIST list1; VA_START(list1, aPathSegment);
1.753 + VA_LIST list2; VA_START(list2, aPathSegment);
1.754 + const TDesC& pathSegment = aPathSegment;
1.755 +
1.756 + TestDelimitedDataPushAndEscapeBackL<CDelimitedPathSegment16, CDelimitedPathSegment8>(
1.757 + _L("Test TDelimitedPathSegmentParser PushAndEscapeBack"), iTestHarness, pathSegment, list1, list2);
1.758 + VA_END(list1); VA_END(list2);
1.759 + }
1.760 +
1.761 +//
1.762 +//
1.763 +// Delimited Query tests
1.764 +//
1.765 +//
1.766 +void CDelimitedPathTest::TestDelimitedQueryExtractionL(TRefByValue<const TDesC> aQuery, ...) const
1.767 + {
1.768 + VA_LIST list1; VA_START(list1, aQuery);
1.769 + VA_LIST list2; VA_START(list2, aQuery);
1.770 + const TDesC& query = aQuery;
1.771 +
1.772 + TestDelimitedDataExtractionL<TDelimitedQueryParser16, TDelimitedQueryParser8>(
1.773 + _L("Test TDelimitedQueryParser Parse : GetNext, Dec, Inc, Peek and Eos"), iTestHarness, query, list1, list2);
1.774 + VA_END(list1); VA_END(list2);
1.775 + }
1.776 +
1.777 +void CDelimitedPathTest::TestDelimitedQueryReverseExtractionL(TRefByValue<const TDesC> aQuery, ...) const
1.778 + {
1.779 + VA_LIST list1; VA_START(list1, aQuery);
1.780 + VA_LIST list2; VA_START(list2, aQuery);
1.781 + const TDesC& query = aQuery;
1.782 +
1.783 + TestDelimitedDataReverseExtractionL<TDelimitedQueryParser16, TDelimitedQueryParser8>(
1.784 + _L("Test TDelimitedQueryParser ParseReverse : GetNext, Dec, Inc, Peek and Eos"), iTestHarness, query, list1, list2);
1.785 + VA_END(list1); VA_END(list2);
1.786 + }
1.787 +
1.788 +void CDelimitedPathTest::TestDelimitedQueryDelimiterPresenceL(const TDesC& aQuery, TBool aFrontDelim, TBool aBackDelim) const
1.789 + {
1.790 + TestDelimitedDataDelimiterPresenceL<TDelimitedQueryParser16, TDelimitedQueryParser8>(
1.791 + _L("Test TDelimitedQueryParser Delimiter Presence"), iTestHarness, aQuery, aFrontDelim, aBackDelim);
1.792 + }
1.793 +
1.794 +void CDelimitedPathTest::TestDelimitedQueryRemainderL(TRefByValue<const TDesC> aQuery, ...) const
1.795 + {
1.796 + VA_LIST list1; VA_START(list1, aQuery);
1.797 + VA_LIST list2; VA_START(list2, aQuery);
1.798 + const TDesC& query = aQuery;
1.799 +
1.800 + TestDelimitedDataRemainderL<TDelimitedQueryParser16, TDelimitedQueryParser8>(
1.801 + _L("Test TDelimitedQueryParser Remainder, Parse"), iTestHarness, query, list1, list2);
1.802 + VA_END(list1); VA_END(list2);
1.803 + }
1.804 +
1.805 +void CDelimitedPathTest::TestDelimitedQueryRemainderReverseL(TRefByValue<const TDesC> aQuery, ...) const
1.806 + {
1.807 + VA_LIST list1; VA_START(list1, aQuery);
1.808 + VA_LIST list2; VA_START(list2, aQuery);
1.809 + const TDesC& query = aQuery;
1.810 +
1.811 + TestDelimitedDataRemainderReverseL<TDelimitedQueryParser16, TDelimitedQueryParser8>(
1.812 + _L("Test TDelimitedQueryParser Remainder, ParseReverse"), iTestHarness, query, list1, list2);
1.813 + VA_END(list1); VA_END(list2);
1.814 + }
1.815 +
1.816 +void CDelimitedPathTest::TestDelimitedQueryDesL(const TDesC& aQuery) const
1.817 + {
1.818 + TestDelimitedDataDesL<TDelimitedQueryParser16, TDelimitedQueryParser8>(_L("Test TDelimitedQuery Des"), iTestHarness, aQuery);
1.819 + }
1.820 +
1.821 +void CDelimitedPathTest::TestDelimitedQueryPushFrontL(TRefByValue<const TDesC> aQuery, ...) const
1.822 + {
1.823 + VA_LIST list1; VA_START(list1, aQuery);
1.824 + VA_LIST list2; VA_START(list2, aQuery);
1.825 + const TDesC& query = aQuery;
1.826 +
1.827 + TestDelimitedDataPushFrontL<CDelimitedQuery16, CDelimitedQuery8>(
1.828 + _L("Test TDelimitedQueryParser PushFront"), iTestHarness, query, list1, list2);
1.829 + VA_END(list1);
1.830 + VA_END(list2);
1.831 + }
1.832 +
1.833 +void CDelimitedPathTest::TestDelimitedQueryPushBackL(TRefByValue<const TDesC> aQuery, ...) const
1.834 + {
1.835 + VA_LIST list1; VA_START(list1, aQuery);
1.836 + VA_LIST list2; VA_START(list2, aQuery);
1.837 + const TDesC& query = aQuery;
1.838 +
1.839 + TestDelimitedDataPushBackL<CDelimitedQuery16, CDelimitedQuery8>(
1.840 + _L("Test TDelimitedQueryParser PushBack"), iTestHarness, query, list1, list2);
1.841 + VA_END(list1); VA_END(list2);
1.842 + }
1.843 +
1.844 +void CDelimitedPathTest::TestDelimitedQueryPopFrontL(TRefByValue<const TDesC> aQuery, ...) const
1.845 + {
1.846 + VA_LIST list1; VA_START(list1, aQuery);
1.847 + VA_LIST list2; VA_START(list2, aQuery);
1.848 + const TDesC& query = aQuery;
1.849 +
1.850 + TestDelimitedDataPopFrontL<CDelimitedQuery16, CDelimitedQuery8>(
1.851 + _L("Test TDelimitedQueryParser PopFront"), iTestHarness, query, list1, list2);
1.852 + VA_END(list1); VA_END(list2);
1.853 + }
1.854 +
1.855 +void CDelimitedPathTest::TestDelimitedQueryPopBackL(TRefByValue<const TDesC> aQuery, ...) const
1.856 + {
1.857 + VA_LIST list1; VA_START(list1, aQuery);
1.858 + VA_LIST list2; VA_START(list2, aQuery);
1.859 + const TDesC& query = aQuery;
1.860 +
1.861 + TestDelimitedDataPopBackL<CDelimitedQuery16, CDelimitedQuery8>(
1.862 + _L("Test TDelimitedQueryParser PopBack"), iTestHarness, query, list1, list2);
1.863 + VA_END(list1); VA_END(list2);
1.864 + }
1.865 +
1.866 +void CDelimitedPathTest::TestDelimitedQueryAddAndTrimFrontAndBackDelimiterL(const TDesC& aQuery) const
1.867 + {
1.868 + TestDelimitedDataAddAndTrimFrontAndBackDelimiterL<CDelimitedQuery16, CDelimitedQuery8>(
1.869 + _L("Test TDelimitedQueryParser Add and Trim Front and Back delimiter"), iTestHarness, aQuery);
1.870 + }
1.871 +
1.872 +void CDelimitedPathTest::TestDelimitedQueryInsertAndParseL(TInt aStartPos, TRefByValue<const TDesC> aQuery, ...) const
1.873 + {
1.874 + VA_LIST list1; VA_START(list1, aQuery);
1.875 + VA_LIST list2; VA_START(list2, aQuery);
1.876 + const TDesC& query = aQuery;
1.877 +
1.878 + TestDelimitedDataInsertAndParseL<CDelimitedQuery16, CDelimitedQuery8>(
1.879 + _L("Test TDelimitedQueryParser InsertCurrent, Parse"), iTestHarness, query, list1, list2, aStartPos);
1.880 + VA_END(list1); VA_END(list2);
1.881 + }
1.882 +
1.883 +void CDelimitedPathTest::TestDelimitedQueryRemoveAndParseL(TInt aStartPos, TRefByValue<const TDesC> aQuery, ...) const
1.884 + {
1.885 + VA_LIST list1; VA_START(list1, aQuery);
1.886 + VA_LIST list2; VA_START(list2, aQuery);
1.887 + const TDesC& query = aQuery;
1.888 +
1.889 + TestDelimitedDataRemoveAndParseL<CDelimitedQuery16, CDelimitedQuery8>(
1.890 + _L("Test TDelimitedQueryParser RemoveCurrent, Parse"), iTestHarness, query, list1, list2, aStartPos);
1.891 + VA_END(list1); VA_END(list2);
1.892 + }
1.893 +
1.894 +void CDelimitedPathTest::TestDelimitedQueryInsertAndParseReverseL(TInt aStartPos, TRefByValue<const TDesC> aQuery, ...) const
1.895 + {
1.896 + VA_LIST list1; VA_START(list1, aQuery);
1.897 + VA_LIST list2; VA_START(list2, aQuery);
1.898 + const TDesC& query = aQuery;
1.899 +
1.900 + TestDelimitedDataInsertAndParseReverseL<CDelimitedQuery16, CDelimitedQuery8>(
1.901 + _L("Test TDelimitedQueryParser InsertCurrent, ParseReverse"), iTestHarness, query, list1, list2, aStartPos);
1.902 + VA_END(list1); VA_END(list2);
1.903 + }
1.904 +
1.905 +void CDelimitedPathTest::TestDelimitedQueryRemoveAndParseReverseL(TInt aStartPos, TRefByValue<const TDesC> aQuery, ...) const
1.906 + {
1.907 + VA_LIST list1; VA_START(list1, aQuery);
1.908 + VA_LIST list2; VA_START(list2, aQuery);
1.909 + const TDesC& query = aQuery;
1.910 +
1.911 + TestDelimitedDataRemoveAndParseReverseL<CDelimitedQuery16, CDelimitedQuery8>(
1.912 + _L("Test TDelimitedQueryParser RemoveCurrent, ParseReverse"), iTestHarness, query, list1, list2, aStartPos);
1.913 + VA_END(list1); VA_END(list2);
1.914 + }
1.915 +
1.916 +void CDelimitedPathTest::TestDelimitedQueryInsertEscapeAndParseL(TInt aStartPos, TRefByValue<const TDesC> aQuery, ...) const
1.917 + {
1.918 + VA_LIST list1; VA_START(list1, aQuery);
1.919 + VA_LIST list2; VA_START(list2, aQuery);
1.920 + const TDesC& query = aQuery;
1.921 +
1.922 + TestDelimitedDataInsertEscapeAndParseL<CDelimitedQuery16, CDelimitedQuery8>(
1.923 + _L("Test TDelimitedQueryParser InsertAndEscapeCurrent, Parse"), iTestHarness, query, list1, list2, aStartPos);
1.924 + VA_END(list1); VA_END(list2);
1.925 + }
1.926 +
1.927 +void CDelimitedPathTest::TestDelimitedQueryInsertEscapeAndParseReverseL(TInt aStartPos, TRefByValue<const TDesC> aQuery, ...) const
1.928 + {
1.929 + VA_LIST list1; VA_START(list1, aQuery);
1.930 + VA_LIST list2; VA_START(list2, aQuery);
1.931 + const TDesC& query = aQuery;
1.932 +
1.933 + TestDelimitedDataInsertEscapeAndParseReverseL<CDelimitedQuery16, CDelimitedQuery8>(
1.934 + _L("Test TDelimitedQueryParser InsertAndEscapeCurrent, ParseReverse"), iTestHarness, query, list1, list2, aStartPos);
1.935 + VA_END(list1); VA_END(list2);
1.936 + }
1.937 +
1.938 +void CDelimitedPathTest::TestDelimitedQueryPushAndEscapeFrontL(TRefByValue<const TDesC> aQuery, ...) const
1.939 + {
1.940 + VA_LIST list1; VA_START(list1, aQuery);
1.941 + VA_LIST list2; VA_START(list2, aQuery);
1.942 + const TDesC& query = aQuery;
1.943 +
1.944 + TestDelimitedDataPushAndEscapeFrontL<CDelimitedQuery16, CDelimitedQuery8>(
1.945 + _L("Test TDelimitedQueryParser PushAndEscapeFront"), iTestHarness, query, list1, list2);
1.946 + VA_END(list1); VA_END(list2);
1.947 + }
1.948 +
1.949 +void CDelimitedPathTest::TestDelimitedQueryPushAndEscapeBackL(TRefByValue<const TDesC> aQuery, ...) const
1.950 + {
1.951 + VA_LIST list1; VA_START(list1, aQuery);
1.952 + VA_LIST list2; VA_START(list2, aQuery);
1.953 + const TDesC& query = aQuery;
1.954 +
1.955 + TestDelimitedDataPushAndEscapeBackL<CDelimitedQuery16, CDelimitedQuery8>(
1.956 + _L("Test TDelimitedQueryParser PushAndEscapeBack"), iTestHarness, query, list1, list2);
1.957 + VA_END(list1); VA_END(list2);
1.958 + }
1.959 +*/
1.960 +//
1.961 +//
1.962 +// Implementation of LOCAL functions - test funcions
1.963 +//
1.964 +//
1.965 +
1.966 +void TestDelimitedDataExtractionL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness,
1.967 + const TDesC& aData, VA_LIST& aList1, VA_LIST& aList2) {
1.968 + // Create title
1.969 + HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());
1.970 + title16Bit->Des().Format(KTitle16Bit, &aTestTitle);
1.971 + aTestHarness->StartTestL(*title16Bit);
1.972 +
1.973 + // Create TDelimitedPathParser object and do parsing
1.974 + TDelimitedPathParser16 parser16Bit;
1.975 + parser16Bit.Parse(aData);
1.976 +
1.977 + TInt error = DoDelimitedDataParsingL<HBufC16, TPtrC16>(parser16Bit, aList1);
1.978 +
1.979 + CleanupStack::PopAndDestroy(title16Bit); // title16Bit
1.980 + aTestHarness->EndTest(error);
1.981 +
1.982 + // Make 8-bit copy
1.983 + HBufC8* dataBuf = HBufC8::NewLC(aData.Length());
1.984 + TPtr8 data8Bit = dataBuf->Des();
1.985 + data8Bit.Copy(aData);
1.986 +
1.987 + HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());
1.988 + title8Bit->Des().Format(KTitle8Bit, &aTestTitle);
1.989 + aTestHarness->StartTestL(*title8Bit);
1.990 +
1.991 + // Create TDelimitedPathParser object and do parsing
1.992 + TDelimitedPathParser8 parser8Bit;
1.993 + parser8Bit.Parse(data8Bit);
1.994 +
1.995 + error = DoDelimitedDataParsingL<HBufC8, TPtrC8>(parser8Bit, aList2);
1.996 +
1.997 + aTestHarness->EndTest(error);
1.998 + CleanupStack::PopAndDestroy(2, dataBuf); // dataBuf, title8Bit
1.999 + }
1.1000 +
1.1001 +void TestDelimitedDataReverseExtractionL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness,
1.1002 + const TDesC& aData, VA_LIST& aList1, VA_LIST& aList2)
1.1003 + {
1.1004 + // Create title
1.1005 + HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());
1.1006 + title16Bit->Des().Format(KTitle16Bit, &aTestTitle);
1.1007 + aTestHarness->StartTestL(*title16Bit);
1.1008 +
1.1009 + // Create TDelimitedPathParser object and do parsing
1.1010 + TDelimitedPathParser16 parser16Bit;
1.1011 + parser16Bit.ParseReverse(aData);
1.1012 +
1.1013 + TInt error = DoDelimitedDataParsingL<HBufC16, TPtrC16>(parser16Bit, aList1);
1.1014 +
1.1015 + CleanupStack::PopAndDestroy(title16Bit); // title16Bit
1.1016 + aTestHarness->EndTest(error);
1.1017 +
1.1018 + // Make 8-bit copy
1.1019 + HBufC8* dataBuf = HBufC8::NewLC(aData.Length());
1.1020 + TPtr8 data8Bit = dataBuf->Des();
1.1021 + data8Bit.Copy(aData);
1.1022 +
1.1023 + // Create title
1.1024 + HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());
1.1025 + title8Bit->Des().Format(KTitle8Bit, &aTestTitle);
1.1026 + aTestHarness->StartTestL(*title8Bit);
1.1027 +
1.1028 + // Create TDelimitedPathParser object and do parsing
1.1029 + TDelimitedPathParser8 parser8Bit;
1.1030 + parser8Bit.ParseReverse(data8Bit);
1.1031 +
1.1032 + error = DoDelimitedDataParsingL<HBufC8, TPtrC8>(parser8Bit, aList2);
1.1033 +
1.1034 + aTestHarness->EndTest(error);
1.1035 + CleanupStack::PopAndDestroy(2, dataBuf); // dataBuf, title8Bit
1.1036 + }
1.1037 +
1.1038 +void TestDelimitedDataDelimiterPresenceL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness,
1.1039 + const TDesC& aData, TBool aFrontDelim, TBool aBackDelim)
1.1040 + {
1.1041 + // Create title
1.1042 + HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());
1.1043 + title16Bit->Des().Format(KTitle16Bit, &aTestTitle);
1.1044 + aTestHarness->StartTestL(*title16Bit);
1.1045 +
1.1046 + // Create TDelimitedPathParser object
1.1047 + TDelimitedPathParser16 parser16Bit;
1.1048 + parser16Bit.Parse(aData);
1.1049 + TInt error = DoDelimiterPresenceTest(parser16Bit, aFrontDelim, aBackDelim);
1.1050 +
1.1051 + CleanupStack::PopAndDestroy(title16Bit); // title16Bit
1.1052 + aTestHarness->EndTest(error);
1.1053 +
1.1054 + // Make 8-bit copy
1.1055 + HBufC8* dataBuf = HBufC8::NewLC(aData.Length());
1.1056 + TPtr8 data8Bit = dataBuf->Des();
1.1057 + data8Bit.Copy(aData);
1.1058 +
1.1059 + // Create title
1.1060 + HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());
1.1061 + title8Bit->Des().Format(KTitle8Bit, &aTestTitle);
1.1062 + aTestHarness->StartTestL(*title8Bit);
1.1063 +
1.1064 + // Create TDelimitedPathParser object
1.1065 + TDelimitedPathParser8 parser8Bit;
1.1066 + parser8Bit.Parse(data8Bit);
1.1067 + error = DoDelimiterPresenceTest(parser8Bit, aFrontDelim, aBackDelim);
1.1068 +
1.1069 + aTestHarness->EndTest(error);
1.1070 + CleanupStack::PopAndDestroy(2, dataBuf); // dataBuf, title8Bit
1.1071 + }
1.1072 +
1.1073 +void TestDelimitedDataRemainderL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness,
1.1074 + const TDesC& aData, VA_LIST& aList1, VA_LIST& aList2)
1.1075 + {
1.1076 + // Create title
1.1077 + HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());
1.1078 + title16Bit->Des().Format(KTitle16Bit, &aTestTitle);
1.1079 + aTestHarness->StartTestL(*title16Bit);
1.1080 +
1.1081 + // Create TDelimiteddataParser object and do parsing
1.1082 + TDelimitedPathParser16 parser16Bit;
1.1083 + parser16Bit.Parse(aData);
1.1084 +
1.1085 + TInt error = DoDelimitedDataRemainderTestL<HBufC16, TPtrC16>(parser16Bit, aList1);
1.1086 +
1.1087 + CleanupStack::PopAndDestroy(title16Bit); // title16Bit
1.1088 + aTestHarness->EndTest(error);
1.1089 +
1.1090 + // Make 8-bit copy
1.1091 + HBufC8* dataBuf = HBufC8::NewLC(aData.Length());
1.1092 + TPtr8 data8Bit = dataBuf->Des();
1.1093 + data8Bit.Copy(aData);
1.1094 +
1.1095 + // Create title
1.1096 + HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());
1.1097 + title8Bit->Des().Format(KTitle8Bit, &aTestTitle);
1.1098 + aTestHarness->StartTestL(*title8Bit);
1.1099 +
1.1100 + // Create TDelimiteddataParser object and do parsing
1.1101 + TDelimitedPathParser8 parser8Bit;
1.1102 + parser8Bit.Parse(data8Bit);
1.1103 +
1.1104 + error = DoDelimitedDataRemainderTestL<HBufC8, TPtrC8>(parser8Bit, aList2);
1.1105 +
1.1106 + aTestHarness->EndTest(error);
1.1107 + CleanupStack::PopAndDestroy(2, dataBuf); // dataBuf, title8Bit
1.1108 + }
1.1109 +
1.1110 +void TestDelimitedDataRemainderReverseL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness,
1.1111 + const TDesC& aData, VA_LIST& aList1, VA_LIST& aList2)
1.1112 + {
1.1113 + // Create title
1.1114 + HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());
1.1115 + title16Bit->Des().Format(KTitle16Bit, &aTestTitle);
1.1116 + aTestHarness->StartTestL(*title16Bit);
1.1117 +
1.1118 + // Create TDelimitedPathParser object and do parsing
1.1119 + TDelimitedPathParser16 parser16Bit;
1.1120 + parser16Bit.ParseReverse(aData);
1.1121 +
1.1122 + TInt error = DoDelimitedDataRemainderTestL<HBufC16, TPtrC16>(parser16Bit, aList1);
1.1123 +
1.1124 + CleanupStack::PopAndDestroy(title16Bit); // title16Bit
1.1125 + aTestHarness->EndTest(error);
1.1126 +
1.1127 + // Make 8-bit copy
1.1128 + HBufC8* dataBuf = HBufC8::NewLC(aData.Length());
1.1129 + TPtr8 data8Bit = dataBuf->Des();
1.1130 + data8Bit.Copy(aData);
1.1131 +
1.1132 + // Create title
1.1133 + HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());
1.1134 + title8Bit->Des().Format(KTitle8Bit, &aTestTitle);
1.1135 + aTestHarness->StartTestL(*title8Bit);
1.1136 +
1.1137 + // Create TDelimitedPathParser object and do parsing
1.1138 + TDelimitedPathParser8 parser8Bit;
1.1139 + parser8Bit.ParseReverse(data8Bit);
1.1140 +
1.1141 + error = DoDelimitedDataRemainderTestL<HBufC8, TPtrC8>(parser8Bit, aList2);
1.1142 +
1.1143 + aTestHarness->EndTest(error);
1.1144 + CleanupStack::PopAndDestroy(2, dataBuf); // dataBuf, title8Bit
1.1145 + }
1.1146 +
1.1147 +void TestDelimitedDataDesL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness, const TDesC& aData)
1.1148 + {
1.1149 + // Create title
1.1150 + HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());
1.1151 + title16Bit->Des().Format(KTitle16Bit, &aTestTitle);
1.1152 + aTestHarness->StartTestL(*title16Bit);
1.1153 +
1.1154 + // Create TDelimitedPathParser object and do parsing
1.1155 + TDelimitedPathParser16 parser16Bit;
1.1156 + parser16Bit.Parse(aData);
1.1157 +
1.1158 + TInt error = DoDelimitedDataDes(parser16Bit, aData);
1.1159 +
1.1160 + CleanupStack::PopAndDestroy(title16Bit); // title16Bit
1.1161 + aTestHarness->EndTest(error);
1.1162 +
1.1163 + // Make 8-bit copy
1.1164 + HBufC8* dataBuf = HBufC8::NewLC(aData.Length());
1.1165 + TPtr8 data8Bit = dataBuf->Des();
1.1166 + data8Bit.Copy(aData);
1.1167 +
1.1168 + // Create title
1.1169 + HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());
1.1170 + title8Bit->Des().Format(KTitle8Bit, &aTestTitle);
1.1171 + aTestHarness->StartTestL(*title8Bit);
1.1172 +
1.1173 + // Create TDelimitedPathParser object and do parsing
1.1174 + TDelimitedPathParser8 parser8Bit;
1.1175 + parser8Bit.Parse(data8Bit);
1.1176 +
1.1177 + error = DoDelimitedDataDes(parser8Bit, data8Bit);
1.1178 +
1.1179 + aTestHarness->EndTest(error);
1.1180 + CleanupStack::PopAndDestroy(2, dataBuf); // dataBuf, title8Bit
1.1181 + }
1.1182 +
1.1183 +void TestDelimitedDataPushFrontL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness,
1.1184 + const TDesC& aData, VA_LIST& aList1, VA_LIST& aList2)
1.1185 + {
1.1186 + // Create title
1.1187 + HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());
1.1188 + title16Bit->Des().Format(KTitle16Bit, &aTestTitle);
1.1189 + aTestHarness->StartTestL(*title16Bit);
1.1190 +
1.1191 + // Create TDelimitedPathParser object and do parsing
1.1192 + CDelimitedPath16* data16Bit = CDelimitedPath16::NewL(aData); // Also excersies NewLC()
1.1193 + CleanupStack::PushL(data16Bit);
1.1194 +
1.1195 + TInt error = DoDelimitedDataPushFrontL<HBufC16>(data16Bit, aList1);
1.1196 +
1.1197 + CleanupStack::PopAndDestroy(2, title16Bit); // title16Bit, data16Bit
1.1198 + aTestHarness->EndTest(error);
1.1199 +
1.1200 + // Make 8-bit copy
1.1201 + HBufC8* dataBuf = HBufC8::NewLC(aData.Length());
1.1202 + TPtr8 initData8Bit = dataBuf->Des();
1.1203 + initData8Bit.Copy(aData);
1.1204 +
1.1205 + // Create title
1.1206 + HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());
1.1207 + title8Bit->Des().Format(KTitle8Bit, &aTestTitle);
1.1208 + aTestHarness->StartTestL(*title8Bit);
1.1209 +
1.1210 + // Create TDelimitedPathParser object and do parsing
1.1211 + CDelimitedPath8* data8Bit = CDelimitedPath8::NewL(initData8Bit); // Also excersies NewLC()
1.1212 + CleanupStack::PushL(data8Bit);
1.1213 +
1.1214 + error = DoDelimitedDataPushFrontL<HBufC8>(data8Bit, aList2);
1.1215 +
1.1216 + aTestHarness->EndTest(error);
1.1217 + CleanupStack::PopAndDestroy(3, dataBuf); // dataBuf, title8Bit, data8Bit
1.1218 + }
1.1219 +
1.1220 +void TestDelimitedDataPushAndEscapeFrontL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness,
1.1221 + const TDesC& aData, VA_LIST& aList1, VA_LIST& aList2)
1.1222 + {
1.1223 + // Create title
1.1224 + HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());
1.1225 + title16Bit->Des().Format(KTitle16Bit, &aTestTitle);
1.1226 + aTestHarness->StartTestL(*title16Bit);
1.1227 +
1.1228 + // Create TDelimitedPathParser object and do parsing
1.1229 + CDelimitedPath16* data16Bit = CDelimitedPath16::NewL(aData); // Also excersies NewLC()
1.1230 + CleanupStack::PushL(data16Bit);
1.1231 +
1.1232 + TInt error = DoDelimitedDataPushAndEscapeFrontL<HBufC16>(data16Bit, aList1);
1.1233 +
1.1234 + CleanupStack::PopAndDestroy(2, title16Bit); // title16Bit, data16Bit
1.1235 + aTestHarness->EndTest(error);
1.1236 +
1.1237 + // Make 8-bit copy
1.1238 + HBufC8* dataBuf = HBufC8::NewLC(aData.Length());
1.1239 + TPtr8 initData8Bit = dataBuf->Des();
1.1240 + initData8Bit.Copy(aData);
1.1241 +
1.1242 + // Create title
1.1243 + HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());
1.1244 + title8Bit->Des().Format(KTitle8Bit, &aTestTitle);
1.1245 + aTestHarness->StartTestL(*title8Bit);
1.1246 +
1.1247 + // Create TDelimitedPathParser object and do parsing
1.1248 + CDelimitedPath8* data8Bit = CDelimitedPath8::NewL(initData8Bit); // Also excersies NewLC()
1.1249 + CleanupStack::PushL(data8Bit);
1.1250 +
1.1251 + error = DoDelimitedDataPushAndEscapeFrontL<HBufC8>(data8Bit, aList2);
1.1252 +
1.1253 + aTestHarness->EndTest(error);
1.1254 + CleanupStack::PopAndDestroy(3, dataBuf); // dataBuf, title8Bit, data8Bit
1.1255 + }
1.1256 +
1.1257 +void TestDelimitedDataPushBackL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness,
1.1258 + const TDesC& aData, VA_LIST& aList1, VA_LIST& aList2)
1.1259 + {
1.1260 + // Create title
1.1261 + HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());
1.1262 + title16Bit->Des().Format(KTitle16Bit, &aTestTitle);
1.1263 + aTestHarness->StartTestL(*title16Bit);
1.1264 +
1.1265 + // Create TDelimitedPathParser object and do parsing
1.1266 + CDelimitedPath16* data16Bit = CDelimitedPath16::NewL(aData); // Also excersies NewLC()
1.1267 + CleanupStack::PushL(data16Bit);
1.1268 +
1.1269 + TInt error = DoDelimitedDataPushBackL<HBufC16>(data16Bit, aList1);
1.1270 +
1.1271 + CleanupStack::PopAndDestroy(2, title16Bit); // title16Bit, data16Bit
1.1272 + aTestHarness->EndTest(error);
1.1273 +
1.1274 + // Make 8-bit copy
1.1275 + HBufC8* dataBuf = HBufC8::NewLC(aData.Length());
1.1276 + TPtr8 initData8Bit = dataBuf->Des();
1.1277 + initData8Bit.Copy(aData);
1.1278 +
1.1279 + // Create title
1.1280 + HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());
1.1281 + title8Bit->Des().Format(KTitle8Bit, &aTestTitle);
1.1282 + aTestHarness->StartTestL(*title8Bit);
1.1283 +
1.1284 + // Create TDelimitedPathParser object and do parsing
1.1285 + CDelimitedPath8* data8Bit = CDelimitedPath8::NewL(initData8Bit); // Also excersies NewLC()
1.1286 + CleanupStack::PushL(data8Bit);
1.1287 +
1.1288 + error = DoDelimitedDataPushBackL<HBufC8>(data8Bit, aList2);
1.1289 +
1.1290 + aTestHarness->EndTest(error);
1.1291 + CleanupStack::PopAndDestroy(3, dataBuf); // dataBuf, title8Bit, data8Bit
1.1292 + }
1.1293 +
1.1294 +void TestDelimitedDataPushAndEscapeBackL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness,
1.1295 + const TDesC& aData, VA_LIST& aList1, VA_LIST& aList2)
1.1296 + {
1.1297 + // Create title
1.1298 + HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());
1.1299 + title16Bit->Des().Format(KTitle16Bit, &aTestTitle);
1.1300 + aTestHarness->StartTestL(*title16Bit);
1.1301 +
1.1302 + // Create TDelimitedPathParser object and do parsing
1.1303 + CDelimitedPath16* data16Bit = CDelimitedPath16::NewL(aData); // Also excersies NewLC()
1.1304 + CleanupStack::PushL(data16Bit);
1.1305 +
1.1306 + TInt error = DoDelimitedDataPushAndEscapeBackL<HBufC16>(data16Bit, aList1);
1.1307 +
1.1308 + CleanupStack::PopAndDestroy(2, title16Bit); // title16Bit, data16Bit
1.1309 + aTestHarness->EndTest(error);
1.1310 +
1.1311 + // Make 8-bit copy
1.1312 + HBufC8* dataBuf = HBufC8::NewLC(aData.Length());
1.1313 + TPtr8 initData8Bit = dataBuf->Des();
1.1314 + initData8Bit.Copy(aData);
1.1315 +
1.1316 + // Create title
1.1317 + HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());
1.1318 + title8Bit->Des().Format(KTitle8Bit, &aTestTitle);
1.1319 + aTestHarness->StartTestL(*title8Bit);
1.1320 +
1.1321 + // Create TDelimitedPathParser object and do parsing
1.1322 + CDelimitedPath8* data8Bit = CDelimitedPath8::NewL(initData8Bit); // Also excersies NewLC()
1.1323 + CleanupStack::PushL(data8Bit);
1.1324 +
1.1325 + error = DoDelimitedDataPushAndEscapeBackL<HBufC8>(data8Bit, aList2);
1.1326 +
1.1327 + aTestHarness->EndTest(error);
1.1328 + CleanupStack::PopAndDestroy(3, dataBuf); // dataBuf, title8Bit, data8Bit
1.1329 + }
1.1330 +
1.1331 +void TestDelimitedDataPopFrontL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness,
1.1332 + const TDesC& aData, VA_LIST& aList1, VA_LIST& aList2)
1.1333 + {
1.1334 + // Create title
1.1335 + HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());
1.1336 + title16Bit->Des().Format(KTitle16Bit, &aTestTitle);
1.1337 + aTestHarness->StartTestL(*title16Bit);
1.1338 +
1.1339 + // Create TDelimitedPathParser object and do parsing
1.1340 + CDelimitedPath16* data16Bit = CDelimitedPath16::NewL(aData); // Also excersies NewLC()
1.1341 + CleanupStack::PushL(data16Bit);
1.1342 +
1.1343 + TInt error = DoDelimitedDataPopFrontL<HBufC16>(data16Bit, aList1);
1.1344 +
1.1345 + CleanupStack::PopAndDestroy(2, title16Bit); // title16Bit, data16Bit
1.1346 + aTestHarness->EndTest(error);
1.1347 +
1.1348 + // Make 8-bit copy
1.1349 + HBufC8* dataBuf = HBufC8::NewLC(aData.Length());
1.1350 + TPtr8 initData8Bit = dataBuf->Des();
1.1351 + initData8Bit.Copy(aData);
1.1352 +
1.1353 + // Create title
1.1354 + HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());
1.1355 + title8Bit->Des().Format(KTitle8Bit, &aTestTitle);
1.1356 + aTestHarness->StartTestL(*title8Bit);
1.1357 +
1.1358 + // Create TDelimitedPathParser object and do parsing
1.1359 + CDelimitedPath8* data8Bit = CDelimitedPath8::NewL(initData8Bit); // Also excersies NewLC()
1.1360 + CleanupStack::PushL(data8Bit);
1.1361 +
1.1362 + error = DoDelimitedDataPopFrontL<HBufC8>(data8Bit, aList2);
1.1363 +
1.1364 + aTestHarness->EndTest(error);
1.1365 + CleanupStack::PopAndDestroy(3, dataBuf); // dataBuf, title8Bit, data8Bit
1.1366 + }
1.1367 +
1.1368 +void TestDelimitedDataPopBackL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness,
1.1369 + const TDesC& aData, VA_LIST& aList1, VA_LIST& aList2)
1.1370 + {
1.1371 + // Create title
1.1372 + HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());
1.1373 + title16Bit->Des().Format(KTitle16Bit, &aTestTitle);
1.1374 + aTestHarness->StartTestL(*title16Bit);
1.1375 +
1.1376 + // Create TDelimitedPathParser object and do parsing
1.1377 + CDelimitedPath16* data16Bit = CDelimitedPath16::NewL(aData); // Also excersies NewLC()
1.1378 + CleanupStack::PushL(data16Bit);
1.1379 +
1.1380 + TInt error = DoDelimitedDataPopBackL<HBufC16>(data16Bit, aList1);
1.1381 +
1.1382 + CleanupStack::PopAndDestroy(2, title16Bit); // title16Bit, data16Bit
1.1383 + aTestHarness->EndTest(error);
1.1384 +
1.1385 + // Make 8-bit copy
1.1386 + HBufC8* dataBuf = HBufC8::NewLC(aData.Length());
1.1387 + TPtr8 initData8Bit = dataBuf->Des();
1.1388 + initData8Bit.Copy(aData);
1.1389 +
1.1390 + // Create title
1.1391 + HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());
1.1392 + title8Bit->Des().Format(KTitle8Bit, &aTestTitle);
1.1393 + aTestHarness->StartTestL(*title8Bit);
1.1394 +
1.1395 + // Create TDelimitedPathParser object and do parsing
1.1396 + CDelimitedPath8* data8Bit = CDelimitedPath8::NewL(initData8Bit); // Also excersies NewLC()
1.1397 + CleanupStack::PushL(data8Bit);
1.1398 +
1.1399 + error = DoDelimitedDataPopBackL<HBufC8>(data8Bit, aList2);
1.1400 +
1.1401 + aTestHarness->EndTest(error);
1.1402 + CleanupStack::PopAndDestroy(3, dataBuf); // dataBuf, title8Bit, data8Bit
1.1403 + }
1.1404 +
1.1405 +void TestDelimitedDataAddAndTrimFrontAndBackDelimiterL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness, const TDesC& aData)
1.1406 + {
1.1407 + // Create title
1.1408 + HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());
1.1409 + title16Bit->Des().Format(KTitle16Bit, &aTestTitle);
1.1410 + aTestHarness->StartTestL(*title16Bit);
1.1411 +
1.1412 + // Create TDelimitedPathParser object and do parsing
1.1413 + CDelimitedPath16* data16Bit = CDelimitedPath16::NewL(aData); // Also excersies NewLC()
1.1414 + CleanupStack::PushL(data16Bit);
1.1415 +
1.1416 + TInt error = DoDelimitedDataAddAndTrimFrontAndBackDelimiterL(data16Bit);
1.1417 +
1.1418 + CleanupStack::PopAndDestroy(2, title16Bit); // title16Bit, data16Bit
1.1419 + aTestHarness->EndTest(error);
1.1420 +
1.1421 + // Make 8-bit copy
1.1422 + HBufC8* dataBuf = HBufC8::NewLC(aData.Length());
1.1423 + TPtr8 initData8Bit = dataBuf->Des();
1.1424 + initData8Bit.Copy(aData);
1.1425 +
1.1426 + // Create title
1.1427 + HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());
1.1428 + title8Bit->Des().Format(KTitle8Bit, &aTestTitle);
1.1429 + aTestHarness->StartTestL(*title8Bit);
1.1430 +
1.1431 + // Create TDelimitedPathParser object and do parsing
1.1432 + CDelimitedPath8* data8Bit = CDelimitedPath8::NewL(initData8Bit); // Also excersies NewLC()
1.1433 + CleanupStack::PushL(data8Bit);
1.1434 +
1.1435 + error = DoDelimitedDataAddAndTrimFrontAndBackDelimiterL(data8Bit);
1.1436 +
1.1437 + aTestHarness->EndTest(error);
1.1438 + CleanupStack::PopAndDestroy(3, dataBuf); // dataBuf, title8Bit, data8Bit
1.1439 + }
1.1440 +
1.1441 +void TestDelimitedDataInsertAndParseL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness,
1.1442 + const TDesC& aData, VA_LIST& aList1, VA_LIST& aList2, TInt aStartPos)
1.1443 + {
1.1444 + // Create title
1.1445 + HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());
1.1446 + title16Bit->Des().Format(KTitle16Bit, &aTestTitle);
1.1447 + aTestHarness->StartTestL(*title16Bit);
1.1448 +
1.1449 + // Create TDelimitedPathParser object and do parsing
1.1450 + CDelimitedPath16* data16Bit = CDelimitedPath16::NewL(aData); // Also excersies NewLC()
1.1451 + CleanupStack::PushL(data16Bit);
1.1452 +
1.1453 + // Do initial parse and get to position
1.1454 + data16Bit->Parse();
1.1455 + TInt error = DoDelimitedDataParseToPosition(data16Bit, aStartPos);
1.1456 + if( error == KErrNone )
1.1457 + {
1.1458 + error = DoDelimitedDataInsertL<HBufC16, TPtrC16>(data16Bit, aList1);
1.1459 + }
1.1460 + CleanupStack::PopAndDestroy(2, title16Bit); // title16Bit, data16Bit
1.1461 + aTestHarness->EndTest(error);
1.1462 +
1.1463 + // Make 8-bit copy
1.1464 + HBufC8* dataBuf = HBufC8::NewLC(aData.Length());
1.1465 + TPtr8 initData8Bit = dataBuf->Des();
1.1466 + initData8Bit.Copy(aData);
1.1467 +
1.1468 + // Create title
1.1469 + HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());
1.1470 + title8Bit->Des().Format(KTitle8Bit, &aTestTitle);
1.1471 + aTestHarness->StartTestL(*title8Bit);
1.1472 +
1.1473 + // Create TDelimitedPathParser object and do parsing
1.1474 + CDelimitedPath8* data8Bit = CDelimitedPath8::NewL(initData8Bit); // Also excersies NewLC()
1.1475 + CleanupStack::PushL(data8Bit);
1.1476 +
1.1477 + // Do initial parse and get to position
1.1478 + data8Bit->Parse();
1.1479 + error = DoDelimitedDataParseToPosition(data8Bit, aStartPos);
1.1480 + if( error == KErrNone )
1.1481 + {
1.1482 + error = DoDelimitedDataInsertL<HBufC8, TPtrC8>(data8Bit, aList2);
1.1483 + }
1.1484 + aTestHarness->EndTest(error);
1.1485 + CleanupStack::PopAndDestroy(3, dataBuf); // dataBuf, title8Bit, data8Bit
1.1486 + }
1.1487 +
1.1488 +void TestDelimitedDataRemoveAndParseL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness,
1.1489 + const TDesC& aData, VA_LIST& aList1, VA_LIST& aList2, TInt aStartPos)
1.1490 + {
1.1491 + // Create title
1.1492 + HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());
1.1493 + title16Bit->Des().Format(KTitle16Bit, &aTestTitle);
1.1494 + aTestHarness->StartTestL(*title16Bit);
1.1495 +
1.1496 + // Create TDelimitedPathParser object and do parsing
1.1497 + CDelimitedPath16* data16Bit = CDelimitedPath16::NewL(aData); // Also excersies NewLC()
1.1498 + CleanupStack::PushL(data16Bit);
1.1499 +
1.1500 + // Do initial parse and get to position
1.1501 + data16Bit->Parse();
1.1502 + TInt error = DoDelimitedDataParseToPosition(data16Bit, aStartPos);
1.1503 + if( error == KErrNone )
1.1504 + {
1.1505 + error = DoDelimitedDataRemoveL<HBufC16, TPtrC16>(data16Bit, aList1);
1.1506 + }
1.1507 + CleanupStack::PopAndDestroy(2, title16Bit); // title16Bit, data16Bit
1.1508 + aTestHarness->EndTest(error);
1.1509 +
1.1510 + // Make 8-bit copy
1.1511 + HBufC8* dataBuf = HBufC8::NewLC(aData.Length());
1.1512 + TPtr8 initData8Bit = dataBuf->Des();
1.1513 + initData8Bit.Copy(aData);
1.1514 +
1.1515 + // Create title
1.1516 + HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());
1.1517 + title8Bit->Des().Format(KTitle8Bit, &aTestTitle);
1.1518 + aTestHarness->StartTestL(*title8Bit);
1.1519 +
1.1520 + // Create TDelimitedPathParser object and do parsing
1.1521 + CDelimitedPath8* data8Bit = CDelimitedPath8::NewL(initData8Bit); // Also excersies NewLC()
1.1522 + CleanupStack::PushL(data8Bit);
1.1523 +
1.1524 + // Do initial parse and get to position
1.1525 + data8Bit->Parse();
1.1526 + error = DoDelimitedDataParseToPosition(data8Bit, aStartPos);
1.1527 + if( error == KErrNone )
1.1528 + {
1.1529 + error = DoDelimitedDataRemoveL<HBufC8, TPtrC8>(data8Bit, aList2);
1.1530 + }
1.1531 + aTestHarness->EndTest(error);
1.1532 + CleanupStack::PopAndDestroy(3, dataBuf); // dataBuf, title8Bit, data8Bit
1.1533 + }
1.1534 +
1.1535 +void TestDelimitedDataInsertAndParseReverseL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness,
1.1536 + const TDesC& aData, VA_LIST& aList1, VA_LIST& aList2, TInt aStartPos)
1.1537 + {
1.1538 + // Create title
1.1539 + HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());
1.1540 + title16Bit->Des().Format(KTitle16Bit, &aTestTitle);
1.1541 + aTestHarness->StartTestL(*title16Bit);
1.1542 +
1.1543 + // Create TDelimitedPathParser object and do parsing
1.1544 + CDelimitedPath16* data16Bit = CDelimitedPath16::NewL(aData); // Also excersies NewLC()
1.1545 + CleanupStack::PushL(data16Bit);
1.1546 +
1.1547 + // Do initial parse and get to position
1.1548 + data16Bit->ParseReverse();
1.1549 + TInt error = DoDelimitedDataParseToPosition(data16Bit, aStartPos);
1.1550 + if( error == KErrNone )
1.1551 + {
1.1552 + error = DoDelimitedDataInsertL<HBufC16, TPtrC16>(data16Bit, aList1);
1.1553 + }
1.1554 + CleanupStack::PopAndDestroy(2, title16Bit); // title16Bit, data16Bit
1.1555 + aTestHarness->EndTest(error);
1.1556 +
1.1557 + // Make 8-bit copy
1.1558 + HBufC8* dataBuf = HBufC8::NewLC(aData.Length());
1.1559 + TPtr8 initData8Bit = dataBuf->Des();
1.1560 + initData8Bit.Copy(aData);
1.1561 +
1.1562 + // Create title
1.1563 + HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());
1.1564 + title8Bit->Des().Format(KTitle8Bit, &aTestTitle);
1.1565 + aTestHarness->StartTestL(*title8Bit);
1.1566 +
1.1567 + // Create TDelimitedPathParser object and do parsing
1.1568 + CDelimitedPath8* data8Bit = CDelimitedPath8::NewL(initData8Bit); // Also excersies NewLC()
1.1569 + CleanupStack::PushL(data8Bit);
1.1570 +
1.1571 + // Do initial parse and get to position
1.1572 + data8Bit->ParseReverse();
1.1573 + error = DoDelimitedDataParseToPosition(data8Bit, aStartPos);
1.1574 + if( error == KErrNone )
1.1575 + {
1.1576 + error = DoDelimitedDataInsertL<HBufC8, TPtrC8>(data8Bit, aList2);
1.1577 + }
1.1578 + aTestHarness->EndTest(error);
1.1579 + CleanupStack::PopAndDestroy(3, dataBuf); // dataBuf, title8Bit, data8Bit
1.1580 + }
1.1581 +
1.1582 +void TestDelimitedDataRemoveAndParseReverseL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness,
1.1583 + const TDesC& aData, VA_LIST& aList1, VA_LIST& aList2, TInt aStartPos)
1.1584 + {
1.1585 + // Create title
1.1586 + HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());
1.1587 + title16Bit->Des().Format(KTitle16Bit, &aTestTitle);
1.1588 + aTestHarness->StartTestL(*title16Bit);
1.1589 +
1.1590 + // Create TDelimitedPathParser object and do parsing
1.1591 + CDelimitedPath16* data16Bit = CDelimitedPath16::NewL(aData); // Also excersies NewLC()
1.1592 + CleanupStack::PushL(data16Bit);
1.1593 +
1.1594 + // Do initial parse and get to position
1.1595 + data16Bit->ParseReverse();
1.1596 + TInt error = DoDelimitedDataParseToPosition(data16Bit, aStartPos);
1.1597 + if( error == KErrNone )
1.1598 + {
1.1599 + error = DoDelimitedDataRemoveL<HBufC16, TPtrC16>(data16Bit, aList1);
1.1600 + }
1.1601 + CleanupStack::PopAndDestroy(2, title16Bit); // title16Bit, data16Bit
1.1602 + aTestHarness->EndTest(error);
1.1603 +
1.1604 + // Make 8-bit copy
1.1605 + HBufC8* dataBuf = HBufC8::NewLC(aData.Length());
1.1606 + TPtr8 initData8Bit = dataBuf->Des();
1.1607 + initData8Bit.Copy(aData);
1.1608 +
1.1609 + // Create title
1.1610 + HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());
1.1611 + title8Bit->Des().Format(KTitle8Bit, &aTestTitle);
1.1612 + aTestHarness->StartTestL(*title8Bit);
1.1613 +
1.1614 + // Create TDelimitedPathParser object and do parsing
1.1615 + CDelimitedPath8* data8Bit = CDelimitedPath8::NewL(initData8Bit); // Also excersies NewLC()
1.1616 + CleanupStack::PushL(data8Bit);
1.1617 +
1.1618 + // Do initial parse and get to position
1.1619 + data8Bit->ParseReverse();
1.1620 + error = DoDelimitedDataParseToPosition(data8Bit, aStartPos);
1.1621 + if( error == KErrNone )
1.1622 + {
1.1623 + error = DoDelimitedDataRemoveL<HBufC8, TPtrC8>(data8Bit, aList2);
1.1624 + }
1.1625 + aTestHarness->EndTest(error);
1.1626 + CleanupStack::PopAndDestroy(3, dataBuf); // dataBuf, title8Bit, data8Bit
1.1627 + }
1.1628 +
1.1629 +void TestDelimitedDataInsertEscapeAndParseL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness,
1.1630 + const TDesC& aData, VA_LIST& aList1, VA_LIST& aList2, TInt aStartPos)
1.1631 + {
1.1632 + // Create title
1.1633 + HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());
1.1634 + title16Bit->Des().Format(KTitle16Bit, &aTestTitle);
1.1635 + aTestHarness->StartTestL(*title16Bit);
1.1636 +
1.1637 + // Create TDelimitedPathParser object and do parsing
1.1638 + CDelimitedPath16* data16Bit = CDelimitedPath16::NewL(aData); // Also excersies NewLC()
1.1639 + CleanupStack::PushL(data16Bit);
1.1640 +
1.1641 + // Do initial parse and get to position
1.1642 + data16Bit->Parse();
1.1643 + TInt error = DoDelimitedDataParseToPosition(data16Bit, aStartPos);
1.1644 + if( error == KErrNone )
1.1645 + {
1.1646 + error = DoDelimitedDataInsertAndEscapeL<HBufC16, TPtrC16>(data16Bit, aList1);
1.1647 + }
1.1648 + CleanupStack::PopAndDestroy(2, title16Bit); // title16Bit, data16Bit
1.1649 + aTestHarness->EndTest(error);
1.1650 +
1.1651 + // Make 8-bit copy
1.1652 + HBufC8* dataBuf = HBufC8::NewLC(aData.Length());
1.1653 + TPtr8 initData8Bit = dataBuf->Des();
1.1654 + initData8Bit.Copy(aData);
1.1655 +
1.1656 + // Create title
1.1657 + HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());
1.1658 + title8Bit->Des().Format(KTitle8Bit, &aTestTitle);
1.1659 + aTestHarness->StartTestL(*title8Bit);
1.1660 +
1.1661 + // Create TDelimitedPathParser object and do parsing
1.1662 + CDelimitedPath8* data8Bit = CDelimitedPath8::NewL(initData8Bit); // Also excersies NewLC()
1.1663 + CleanupStack::PushL(data8Bit);
1.1664 +
1.1665 + // Do initial parse and get to position
1.1666 + data8Bit->Parse();
1.1667 + error = DoDelimitedDataParseToPosition(data8Bit, aStartPos);
1.1668 + if( error == KErrNone )
1.1669 + {
1.1670 + error = DoDelimitedDataInsertAndEscapeL<HBufC8, TPtrC8>(data8Bit, aList2);
1.1671 + }
1.1672 + aTestHarness->EndTest(error);
1.1673 + CleanupStack::PopAndDestroy(3, dataBuf); // dataBuf, title8Bit, data8Bit
1.1674 + }
1.1675 +
1.1676 +void TestDelimitedDataInsertEscapeAndParseReverseL(const TDesC& aTestTitle, CIpuTestHarness* aTestHarness,
1.1677 + const TDesC& aData, VA_LIST& aList1, VA_LIST& aList2, TInt aStartPos)
1.1678 + {
1.1679 + // Create title
1.1680 + HBufC* title16Bit = HBufC::NewLC(aTestTitle.Length() + KTitle16Bit().Length());
1.1681 + title16Bit->Des().Format(KTitle16Bit, &aTestTitle);
1.1682 + aTestHarness->StartTestL(*title16Bit);
1.1683 +
1.1684 + // Create TDelimitedPathParser object and do parsing
1.1685 + CDelimitedPath16* data16Bit = CDelimitedPath16::NewL(aData); // Also excersies NewLC()
1.1686 + CleanupStack::PushL(data16Bit);
1.1687 +
1.1688 + // Do initial parse and get to position
1.1689 + data16Bit->ParseReverse();
1.1690 + TInt error = DoDelimitedDataParseToPosition(data16Bit, aStartPos);
1.1691 + if( error == KErrNone )
1.1692 + {
1.1693 + error = DoDelimitedDataInsertAndEscapeL<HBufC16, TPtrC16>(data16Bit, aList1);
1.1694 + }
1.1695 + CleanupStack::PopAndDestroy(2, title16Bit); // title16Bit, data16Bit
1.1696 + aTestHarness->EndTest(error);
1.1697 +
1.1698 + // Make 8-bit copy
1.1699 + HBufC8* dataBuf = HBufC8::NewLC(aData.Length());
1.1700 + TPtr8 initData8Bit = dataBuf->Des();
1.1701 + initData8Bit.Copy(aData);
1.1702 +
1.1703 + // Create title
1.1704 + HBufC* title8Bit = HBufC::NewLC(aTestTitle.Length() + KTitle8Bit().Length());
1.1705 + title8Bit->Des().Format(KTitle8Bit, &aTestTitle);
1.1706 + aTestHarness->StartTestL(*title8Bit);
1.1707 +
1.1708 + // Create TDelimitedPathParser object and do parsing
1.1709 + CDelimitedPath8* data8Bit = CDelimitedPath8::NewL(initData8Bit); // Also excersies NewLC()
1.1710 + CleanupStack::PushL(data8Bit);
1.1711 +
1.1712 + // Do initial parse and get to position
1.1713 + data8Bit->ParseReverse();
1.1714 + error = DoDelimitedDataParseToPosition(data8Bit, aStartPos);
1.1715 + if( error == KErrNone )
1.1716 + {
1.1717 + error = DoDelimitedDataInsertAndEscapeL<HBufC8, TPtrC8>(data8Bit, aList2);
1.1718 + }
1.1719 + aTestHarness->EndTest(error);
1.1720 + CleanupStack::PopAndDestroy(3, dataBuf); // dataBuf, title8Bit, data8Bit
1.1721 + }
1.1722 +
1.1723 +//
1.1724 +//
1.1725 +// Implementation of LOCAL functions - helper functions
1.1726 +//
1.1727 +//
1.1728 +
1.1729 +#include "TDelimitedDataCommon.cpp"