|
sl@0
|
1 |
// Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).
|
|
sl@0
|
2 |
// All rights reserved.
|
|
sl@0
|
3 |
// This component and the accompanying materials are made available
|
|
sl@0
|
4 |
// under the terms of "Eclipse Public License v1.0"
|
|
sl@0
|
5 |
// which accompanies this distribution, and is available
|
|
sl@0
|
6 |
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
|
|
sl@0
|
7 |
//
|
|
sl@0
|
8 |
// Initial Contributors:
|
|
sl@0
|
9 |
// Nokia Corporation - initial contribution.
|
|
sl@0
|
10 |
//
|
|
sl@0
|
11 |
// Contributors:
|
|
sl@0
|
12 |
//
|
|
sl@0
|
13 |
// Description:
|
|
sl@0
|
14 |
// Implementation of test CWSPDecodeTest
|
|
sl@0
|
15 |
//
|
|
sl@0
|
16 |
//
|
|
sl@0
|
17 |
|
|
sl@0
|
18 |
#include "cwspdecodetest.h"
|
|
sl@0
|
19 |
#include <wspdummyconstants.h>
|
|
sl@0
|
20 |
|
|
sl@0
|
21 |
|
|
sl@0
|
22 |
|
|
sl@0
|
23 |
CWSPDecodeTest* CWSPDecodeTest::NewLC(CIpuTestHarness* aTestHarness)
|
|
sl@0
|
24 |
{
|
|
sl@0
|
25 |
CWSPDecodeTest* self = new(ELeave)CWSPDecodeTest(aTestHarness);
|
|
sl@0
|
26 |
CleanupStack::PushL(self);
|
|
sl@0
|
27 |
return self;
|
|
sl@0
|
28 |
}
|
|
sl@0
|
29 |
|
|
sl@0
|
30 |
|
|
sl@0
|
31 |
CWSPDecodeTest::CWSPDecodeTest(CIpuTestHarness* aTestHarness):
|
|
sl@0
|
32 |
iTestHarness(aTestHarness)
|
|
sl@0
|
33 |
{}
|
|
sl@0
|
34 |
|
|
sl@0
|
35 |
CWSPDecodeTest::~CWSPDecodeTest()
|
|
sl@0
|
36 |
{}
|
|
sl@0
|
37 |
|
|
sl@0
|
38 |
void CWSPDecodeTest::DoTestsL()
|
|
sl@0
|
39 |
{
|
|
sl@0
|
40 |
VarTypesTestL();
|
|
sl@0
|
41 |
LengthValsTestL();
|
|
sl@0
|
42 |
StringTestL();
|
|
sl@0
|
43 |
TokensTestL();
|
|
sl@0
|
44 |
IntegersTestL();
|
|
sl@0
|
45 |
LongIntTestL();
|
|
sl@0
|
46 |
UintVarsTestL();
|
|
sl@0
|
47 |
VersionTestL();
|
|
sl@0
|
48 |
DateTestL();
|
|
sl@0
|
49 |
SegmenterTestL();
|
|
sl@0
|
50 |
}
|
|
sl@0
|
51 |
|
|
sl@0
|
52 |
|
|
sl@0
|
53 |
//* VarTypes */
|
|
sl@0
|
54 |
|
|
sl@0
|
55 |
TBool CWSPDecodeTest::VarType(TPtrC8 aBuf, TWspPrimitiveDecoder::TWspHeaderType aShouldBeType)
|
|
sl@0
|
56 |
{
|
|
sl@0
|
57 |
TWspPrimitiveDecoder dec(aBuf);
|
|
sl@0
|
58 |
TWspPrimitiveDecoder::TWspHeaderType type=dec.VarType();
|
|
sl@0
|
59 |
|
|
sl@0
|
60 |
TBool bSuccess = EFalse;
|
|
sl@0
|
61 |
if (type == aShouldBeType)
|
|
sl@0
|
62 |
bSuccess = ETrue;
|
|
sl@0
|
63 |
|
|
sl@0
|
64 |
TBuf8<25> typeStr;
|
|
sl@0
|
65 |
switch (aShouldBeType)
|
|
sl@0
|
66 |
{
|
|
sl@0
|
67 |
case TWspPrimitiveDecoder::ENotSet:
|
|
sl@0
|
68 |
typeStr.Copy(_L("ENotSet"));
|
|
sl@0
|
69 |
break;
|
|
sl@0
|
70 |
case TWspPrimitiveDecoder::ELengthVal:
|
|
sl@0
|
71 |
typeStr.Copy(_L("ELengthVal"));
|
|
sl@0
|
72 |
break;
|
|
sl@0
|
73 |
case TWspPrimitiveDecoder::EQuotedString:
|
|
sl@0
|
74 |
typeStr.Copy(_L("EQuotedString"));
|
|
sl@0
|
75 |
break;
|
|
sl@0
|
76 |
case TWspPrimitiveDecoder::EString:
|
|
sl@0
|
77 |
typeStr.Copy(_L("EString"));
|
|
sl@0
|
78 |
break;
|
|
sl@0
|
79 |
case TWspPrimitiveDecoder::E7BitVal:
|
|
sl@0
|
80 |
typeStr.Copy(_L("E7BitVal"));
|
|
sl@0
|
81 |
break;
|
|
sl@0
|
82 |
}
|
|
sl@0
|
83 |
return bSuccess;
|
|
sl@0
|
84 |
}
|
|
sl@0
|
85 |
|
|
sl@0
|
86 |
|
|
sl@0
|
87 |
void CWSPDecodeTest::VarTypesTestL()
|
|
sl@0
|
88 |
{
|
|
sl@0
|
89 |
_LIT(KTestText, "WSP Decode: VarTypes");
|
|
sl@0
|
90 |
iTestHarness->StartTestL(KTestText);
|
|
sl@0
|
91 |
TRAPD(error, TestVarTypesL());
|
|
sl@0
|
92 |
iTestHarness->EndTest(error);
|
|
sl@0
|
93 |
User::LeaveIfError(error);
|
|
sl@0
|
94 |
}
|
|
sl@0
|
95 |
|
|
sl@0
|
96 |
void CWSPDecodeTest::TestVarTypesL()
|
|
sl@0
|
97 |
{
|
|
sl@0
|
98 |
const TUint8 KToken[] = {0x81};
|
|
sl@0
|
99 |
const TUint8 KString1[] = {'a', 'b', 'c', 0x00};
|
|
sl@0
|
100 |
const TUint8 KString2[] = {0x33};
|
|
sl@0
|
101 |
const TUint8 KLen0[] = {0x00};
|
|
sl@0
|
102 |
const TUint8 KLen1[] = {0x01};
|
|
sl@0
|
103 |
const TUint8 KLen2[] = {0x1F};
|
|
sl@0
|
104 |
|
|
sl@0
|
105 |
TBuf8<255> buf;
|
|
sl@0
|
106 |
buf.Copy(KToken, sizeof(KToken));
|
|
sl@0
|
107 |
if (!VarType(buf, TWspPrimitiveDecoder::E7BitVal))
|
|
sl@0
|
108 |
User::Leave(KErrGeneral);
|
|
sl@0
|
109 |
|
|
sl@0
|
110 |
buf.Copy(KString1, sizeof(KString1));
|
|
sl@0
|
111 |
if (!VarType(buf, TWspPrimitiveDecoder::EString))
|
|
sl@0
|
112 |
User::Leave(KErrGeneral);
|
|
sl@0
|
113 |
|
|
sl@0
|
114 |
buf.Copy(KString2, sizeof(KString2));
|
|
sl@0
|
115 |
if (!VarType(buf, TWspPrimitiveDecoder::EString))
|
|
sl@0
|
116 |
User::Leave(KErrGeneral);
|
|
sl@0
|
117 |
|
|
sl@0
|
118 |
buf.Copy(KLen0, sizeof(KLen0));
|
|
sl@0
|
119 |
if (!VarType(buf, TWspPrimitiveDecoder::ELengthVal))
|
|
sl@0
|
120 |
User::Leave(KErrGeneral);
|
|
sl@0
|
121 |
|
|
sl@0
|
122 |
buf.Copy(KLen1, sizeof(KLen1));
|
|
sl@0
|
123 |
if (!VarType(buf, TWspPrimitiveDecoder::ELengthVal))
|
|
sl@0
|
124 |
User::Leave(KErrGeneral);
|
|
sl@0
|
125 |
|
|
sl@0
|
126 |
buf.Copy(KLen2, sizeof(KLen2));
|
|
sl@0
|
127 |
if (!VarType(buf, TWspPrimitiveDecoder::ELengthVal))
|
|
sl@0
|
128 |
User::Leave(KErrGeneral);
|
|
sl@0
|
129 |
}
|
|
sl@0
|
130 |
|
|
sl@0
|
131 |
|
|
sl@0
|
132 |
|
|
sl@0
|
133 |
|
|
sl@0
|
134 |
//* LenVal */
|
|
sl@0
|
135 |
|
|
sl@0
|
136 |
TBool CWSPDecodeTest::LenVal(TPtrC8 aBuf, TInt aShouldBeVal)
|
|
sl@0
|
137 |
{
|
|
sl@0
|
138 |
TBool success = EFalse;
|
|
sl@0
|
139 |
TWspPrimitiveDecoder dec(aBuf);
|
|
sl@0
|
140 |
TInt len;
|
|
sl@0
|
141 |
success = dec.LengthVal(len);
|
|
sl@0
|
142 |
if (success == KErrCorrupt)
|
|
sl@0
|
143 |
return ETrue;
|
|
sl@0
|
144 |
|
|
sl@0
|
145 |
return len == aShouldBeVal && !(success < KErrNone);
|
|
sl@0
|
146 |
}
|
|
sl@0
|
147 |
|
|
sl@0
|
148 |
|
|
sl@0
|
149 |
void CWSPDecodeTest::LengthValsTestL()
|
|
sl@0
|
150 |
{
|
|
sl@0
|
151 |
_LIT(KTestText, "WSP Decode: LengthVals");
|
|
sl@0
|
152 |
iTestHarness->StartTestL(KTestText);
|
|
sl@0
|
153 |
TRAPD(error, TestLengthValsL());
|
|
sl@0
|
154 |
iTestHarness->EndTest(error);
|
|
sl@0
|
155 |
User::LeaveIfError(error);
|
|
sl@0
|
156 |
}
|
|
sl@0
|
157 |
|
|
sl@0
|
158 |
void CWSPDecodeTest::TestLengthValsL()
|
|
sl@0
|
159 |
{
|
|
sl@0
|
160 |
const TUint8 KLen0[] = {0x00};
|
|
sl@0
|
161 |
const TUint8 KLen1[] = {0x01};
|
|
sl@0
|
162 |
const TUint8 KLen26[] = {0x1A};
|
|
sl@0
|
163 |
const TUint8 KLenUintVAR17680[] = {0x1F, 0x81,0x8A,0x10};
|
|
sl@0
|
164 |
const TUint8 KLenUintVARCorrupt[] = {0x1F, 0x81,0x8A,0x80};
|
|
sl@0
|
165 |
|
|
sl@0
|
166 |
|
|
sl@0
|
167 |
TBuf8<255> buf;
|
|
sl@0
|
168 |
buf.Copy(KLen0, sizeof(KLen0));
|
|
sl@0
|
169 |
if (!LenVal(buf, 0))
|
|
sl@0
|
170 |
User::Leave(KErrGeneral);
|
|
sl@0
|
171 |
|
|
sl@0
|
172 |
buf.Copy(KLen1, sizeof(KLen1));
|
|
sl@0
|
173 |
if (!LenVal(buf, 1))
|
|
sl@0
|
174 |
User::Leave(KErrGeneral);
|
|
sl@0
|
175 |
|
|
sl@0
|
176 |
buf.Copy(KLen26, sizeof(KLen26));
|
|
sl@0
|
177 |
if (!LenVal(buf, 0x1A))
|
|
sl@0
|
178 |
User::Leave(KErrGeneral);
|
|
sl@0
|
179 |
|
|
sl@0
|
180 |
buf.Copy(KLenUintVAR17680, sizeof(KLenUintVAR17680));
|
|
sl@0
|
181 |
if (!LenVal(buf, 17680))
|
|
sl@0
|
182 |
User::Leave(KErrGeneral);
|
|
sl@0
|
183 |
|
|
sl@0
|
184 |
buf.Copy(KLenUintVARCorrupt, sizeof(KLenUintVARCorrupt));
|
|
sl@0
|
185 |
if (!LenVal(buf, -1))
|
|
sl@0
|
186 |
User::Leave(KErrGeneral);
|
|
sl@0
|
187 |
|
|
sl@0
|
188 |
}
|
|
sl@0
|
189 |
|
|
sl@0
|
190 |
|
|
sl@0
|
191 |
|
|
sl@0
|
192 |
//* String */
|
|
sl@0
|
193 |
|
|
sl@0
|
194 |
TBool CWSPDecodeTest::String(TPtrC8 aBuf, TPtrC8 aShouldBe, TInt /*aErr*/)
|
|
sl@0
|
195 |
{
|
|
sl@0
|
196 |
TBool success = EFalse;
|
|
sl@0
|
197 |
TWspPrimitiveDecoder dec(aBuf);
|
|
sl@0
|
198 |
|
|
sl@0
|
199 |
TPtrC8 str;
|
|
sl@0
|
200 |
success = dec.String(str);
|
|
sl@0
|
201 |
if (success < KErrNone)
|
|
sl@0
|
202 |
return success;
|
|
sl@0
|
203 |
|
|
sl@0
|
204 |
|
|
sl@0
|
205 |
if (str != aShouldBe)
|
|
sl@0
|
206 |
success = EFalse;
|
|
sl@0
|
207 |
|
|
sl@0
|
208 |
// Copy to 16 bits
|
|
sl@0
|
209 |
return success;
|
|
sl@0
|
210 |
}
|
|
sl@0
|
211 |
|
|
sl@0
|
212 |
|
|
sl@0
|
213 |
|
|
sl@0
|
214 |
void CWSPDecodeTest::StringTestL()
|
|
sl@0
|
215 |
{
|
|
sl@0
|
216 |
_LIT(KTestText, "WSP Decode: String");
|
|
sl@0
|
217 |
iTestHarness->StartTestL(KTestText);
|
|
sl@0
|
218 |
TRAPD(error, TestStringL());
|
|
sl@0
|
219 |
iTestHarness->EndTest(error);
|
|
sl@0
|
220 |
User::LeaveIfError(error);
|
|
sl@0
|
221 |
}
|
|
sl@0
|
222 |
|
|
sl@0
|
223 |
|
|
sl@0
|
224 |
void CWSPDecodeTest::TestStringL()
|
|
sl@0
|
225 |
{
|
|
sl@0
|
226 |
const TUint8 KStringHello[] = {'H','e','l','l','o',0x00};
|
|
sl@0
|
227 |
const TUint8 KStringEmpty[] = {0x00};
|
|
sl@0
|
228 |
const TUint8 KStringNotAString[] = {0x1A};
|
|
sl@0
|
229 |
const TUint8 KStringCorruptNoZero[] = {'H','e','l','l','o'};
|
|
sl@0
|
230 |
const TUint8 KStringbye[] = {'b','y','e',0x00};
|
|
sl@0
|
231 |
|
|
sl@0
|
232 |
TBuf8<255> buf;
|
|
sl@0
|
233 |
|
|
sl@0
|
234 |
buf.Copy(KStringHello, sizeof(KStringHello));
|
|
sl@0
|
235 |
if (!String(buf, _L8("Hello")))
|
|
sl@0
|
236 |
User::Leave(KErrGeneral);
|
|
sl@0
|
237 |
|
|
sl@0
|
238 |
buf.Copy(KStringEmpty, sizeof(KStringEmpty));
|
|
sl@0
|
239 |
if (!String(buf, _L8(""),KErrCorrupt))
|
|
sl@0
|
240 |
User::Leave(KErrGeneral);
|
|
sl@0
|
241 |
|
|
sl@0
|
242 |
buf.Copy(KStringNotAString, sizeof(KStringNotAString));
|
|
sl@0
|
243 |
if (!String(buf, _L8(""), KErrCorrupt))
|
|
sl@0
|
244 |
User::Leave(KErrGeneral);
|
|
sl@0
|
245 |
|
|
sl@0
|
246 |
buf.Copy(KStringCorruptNoZero, sizeof(KStringCorruptNoZero));
|
|
sl@0
|
247 |
if (!String(buf, _L8(""), KErrCorrupt))
|
|
sl@0
|
248 |
User::Leave(KErrGeneral);
|
|
sl@0
|
249 |
|
|
sl@0
|
250 |
buf.Copy(KStringbye, sizeof(KStringbye));
|
|
sl@0
|
251 |
if (!String(buf, _L8("bye")))
|
|
sl@0
|
252 |
User::Leave(KErrGeneral);
|
|
sl@0
|
253 |
}
|
|
sl@0
|
254 |
|
|
sl@0
|
255 |
//* Tokens */
|
|
sl@0
|
256 |
|
|
sl@0
|
257 |
TBool CWSPDecodeTest::Token(TPtrC8 aBuf, TUint8 aShouldBe, TInt aErr)
|
|
sl@0
|
258 |
{
|
|
sl@0
|
259 |
TInt success;
|
|
sl@0
|
260 |
TWspPrimitiveDecoder dec(aBuf);
|
|
sl@0
|
261 |
|
|
sl@0
|
262 |
TUint8 val;
|
|
sl@0
|
263 |
success = dec.Val7Bit(val);
|
|
sl@0
|
264 |
if (success < KErrNone && success == aErr)
|
|
sl@0
|
265 |
return ETrue;
|
|
sl@0
|
266 |
|
|
sl@0
|
267 |
return val == aShouldBe;
|
|
sl@0
|
268 |
}
|
|
sl@0
|
269 |
|
|
sl@0
|
270 |
void CWSPDecodeTest::TokensTestL()
|
|
sl@0
|
271 |
{
|
|
sl@0
|
272 |
_LIT(KTestText, "WSP Decode: Tokens");
|
|
sl@0
|
273 |
iTestHarness->StartTestL(KTestText);
|
|
sl@0
|
274 |
TRAPD(error, TestTokensL());
|
|
sl@0
|
275 |
iTestHarness->EndTest(error);
|
|
sl@0
|
276 |
User::LeaveIfError(error);
|
|
sl@0
|
277 |
}
|
|
sl@0
|
278 |
|
|
sl@0
|
279 |
|
|
sl@0
|
280 |
void CWSPDecodeTest::TestTokensL()
|
|
sl@0
|
281 |
{
|
|
sl@0
|
282 |
const TUint8 KToken0[] = {0x80};
|
|
sl@0
|
283 |
const TUint8 KToken1[] = {0x81};
|
|
sl@0
|
284 |
const TUint8 KToken1A[] = {0x9A};
|
|
sl@0
|
285 |
const TUint8 KToken38[] = {0xB8};
|
|
sl@0
|
286 |
const TUint8 KTokenCorruptLen[] = {0x01};
|
|
sl@0
|
287 |
TBuf8<255> buf;
|
|
sl@0
|
288 |
|
|
sl@0
|
289 |
buf.Copy(KToken0, sizeof(KToken0));
|
|
sl@0
|
290 |
if (!Token(buf, 0))
|
|
sl@0
|
291 |
User::Leave(KErrGeneral);
|
|
sl@0
|
292 |
|
|
sl@0
|
293 |
buf.Copy(KToken1, sizeof(KToken1));
|
|
sl@0
|
294 |
if (!Token(buf, 1))
|
|
sl@0
|
295 |
User::Leave(KErrGeneral);
|
|
sl@0
|
296 |
|
|
sl@0
|
297 |
buf.Copy(KToken1A, sizeof(KToken1A));
|
|
sl@0
|
298 |
if (!Token(buf, 0x1A))
|
|
sl@0
|
299 |
User::Leave(KErrGeneral);
|
|
sl@0
|
300 |
|
|
sl@0
|
301 |
buf.Copy(KToken38, sizeof(KToken38));
|
|
sl@0
|
302 |
if (!Token(buf, 0x38))
|
|
sl@0
|
303 |
User::Leave(KErrGeneral);
|
|
sl@0
|
304 |
|
|
sl@0
|
305 |
buf.Copy(KTokenCorruptLen, sizeof(KTokenCorruptLen));
|
|
sl@0
|
306 |
if (!Token(buf, 1))
|
|
sl@0
|
307 |
User::Leave(KErrGeneral);
|
|
sl@0
|
308 |
}
|
|
sl@0
|
309 |
|
|
sl@0
|
310 |
|
|
sl@0
|
311 |
//* Integers */
|
|
sl@0
|
312 |
|
|
sl@0
|
313 |
TBool CWSPDecodeTest::Integer(TPtrC8 aBuf, TUint32 aShouldBe, TInt aErr)
|
|
sl@0
|
314 |
{
|
|
sl@0
|
315 |
TInt success;
|
|
sl@0
|
316 |
TWspPrimitiveDecoder dec(aBuf);
|
|
sl@0
|
317 |
TUint32 val;
|
|
sl@0
|
318 |
success = dec.Integer(val);
|
|
sl@0
|
319 |
if (success < KErrNone && success == aErr)
|
|
sl@0
|
320 |
return success;
|
|
sl@0
|
321 |
return val == aShouldBe;
|
|
sl@0
|
322 |
}
|
|
sl@0
|
323 |
|
|
sl@0
|
324 |
|
|
sl@0
|
325 |
|
|
sl@0
|
326 |
void CWSPDecodeTest::IntegersTestL()
|
|
sl@0
|
327 |
{
|
|
sl@0
|
328 |
_LIT(KTestText, "WSP Decode: Integers");
|
|
sl@0
|
329 |
iTestHarness->StartTestL(KTestText);
|
|
sl@0
|
330 |
TRAPD(error, TestIntegersL());
|
|
sl@0
|
331 |
iTestHarness->EndTest(error);
|
|
sl@0
|
332 |
User::LeaveIfError(error);
|
|
sl@0
|
333 |
}
|
|
sl@0
|
334 |
|
|
sl@0
|
335 |
|
|
sl@0
|
336 |
void CWSPDecodeTest::TestIntegersL()
|
|
sl@0
|
337 |
{
|
|
sl@0
|
338 |
const TUint8 KInt0[] = {0x80};
|
|
sl@0
|
339 |
const TUint8 KInt1[] = {0x81};
|
|
sl@0
|
340 |
const TUint8 KIntA[] = {0x8A};
|
|
sl@0
|
341 |
const TUint8 KInt38[] = {0xB8};
|
|
sl@0
|
342 |
const TUint8 KIntLong4321[] = {0x02, 0x43,0x21};
|
|
sl@0
|
343 |
const TUint8 KIntLongABCDEF[] = {0x03, 0xAB,0xCD,0xEF};
|
|
sl@0
|
344 |
const TUint8 KIntCorrupt[] = {0x01};
|
|
sl@0
|
345 |
TBuf8<255> buf;
|
|
sl@0
|
346 |
|
|
sl@0
|
347 |
buf.Copy(KInt0, sizeof(KInt0));
|
|
sl@0
|
348 |
if (!Integer(buf, 0))
|
|
sl@0
|
349 |
User::Leave(KErrGeneral);
|
|
sl@0
|
350 |
|
|
sl@0
|
351 |
buf.Copy(KInt1, sizeof(KIntA));
|
|
sl@0
|
352 |
if (!Integer(buf, 1))
|
|
sl@0
|
353 |
User::Leave(KErrGeneral);
|
|
sl@0
|
354 |
|
|
sl@0
|
355 |
buf.Copy(KIntA, sizeof(KIntA));
|
|
sl@0
|
356 |
if (!Integer(buf, 0x0A))
|
|
sl@0
|
357 |
User::Leave(KErrGeneral);
|
|
sl@0
|
358 |
|
|
sl@0
|
359 |
buf.Copy(KInt38, sizeof(KInt38));
|
|
sl@0
|
360 |
if (!Integer(buf, 0x38))
|
|
sl@0
|
361 |
User::Leave(KErrGeneral);
|
|
sl@0
|
362 |
|
|
sl@0
|
363 |
buf.Copy(KIntLong4321, sizeof(KIntLong4321));
|
|
sl@0
|
364 |
if (!Integer(buf, 0x4321))
|
|
sl@0
|
365 |
User::Leave(KErrGeneral);
|
|
sl@0
|
366 |
|
|
sl@0
|
367 |
buf.Copy(KIntLongABCDEF, sizeof(KIntLongABCDEF));
|
|
sl@0
|
368 |
if (!Integer(buf, 0xABCDEF))
|
|
sl@0
|
369 |
User::Leave(KErrGeneral);
|
|
sl@0
|
370 |
|
|
sl@0
|
371 |
buf.Copy(KIntCorrupt, sizeof(KIntCorrupt));
|
|
sl@0
|
372 |
if (!Integer(buf,0, KErrCorrupt))
|
|
sl@0
|
373 |
User::Leave(KErrGeneral);
|
|
sl@0
|
374 |
}
|
|
sl@0
|
375 |
|
|
sl@0
|
376 |
//* LongInt */
|
|
sl@0
|
377 |
|
|
sl@0
|
378 |
TBool CWSPDecodeTest::LongInt(TPtrC8 aBuf, TUint32 aShouldBe, TInt aErr)
|
|
sl@0
|
379 |
{
|
|
sl@0
|
380 |
TInt success;
|
|
sl@0
|
381 |
TWspPrimitiveDecoder dec(aBuf);
|
|
sl@0
|
382 |
|
|
sl@0
|
383 |
TUint32 val;
|
|
sl@0
|
384 |
success = dec.LongInt(val);
|
|
sl@0
|
385 |
if (success < KErrNone && success == aErr)
|
|
sl@0
|
386 |
return ETrue;
|
|
sl@0
|
387 |
return val == aShouldBe;
|
|
sl@0
|
388 |
}
|
|
sl@0
|
389 |
|
|
sl@0
|
390 |
|
|
sl@0
|
391 |
|
|
sl@0
|
392 |
void CWSPDecodeTest::LongIntTestL()
|
|
sl@0
|
393 |
{
|
|
sl@0
|
394 |
_LIT(KTestText, "WSP Decode: LongInt");
|
|
sl@0
|
395 |
iTestHarness->StartTestL(KTestText);
|
|
sl@0
|
396 |
TRAPD(error, TestLongIntL());
|
|
sl@0
|
397 |
iTestHarness->EndTest(error);
|
|
sl@0
|
398 |
User::LeaveIfError(error);
|
|
sl@0
|
399 |
}
|
|
sl@0
|
400 |
|
|
sl@0
|
401 |
|
|
sl@0
|
402 |
|
|
sl@0
|
403 |
void CWSPDecodeTest::TestLongIntL()
|
|
sl@0
|
404 |
{
|
|
sl@0
|
405 |
const TUint8 KIntLong0[] = {0x01, 0x00};
|
|
sl@0
|
406 |
const TUint8 KIntLong4321[] = {0x02, 0x43,0x21};
|
|
sl@0
|
407 |
const TUint8 KIntLongABCDEF[] = {0x03, 0xAB,0xCD,0xEF};
|
|
sl@0
|
408 |
const TUint8 KIntLongABCDEF112233[] = {0x06, 0xAB,0xCD,0xEF, 0x11,0x22,0x33};
|
|
sl@0
|
409 |
const TUint8 KIntTooLong110009ABCDEF112233[] = {0x0A, 0x11,0x00, 0x09, 0xAB,0xCD,0xEF, 0x11,0x22,0x33};
|
|
sl@0
|
410 |
const TUint8 KIntCorrupt[] = {0x01};
|
|
sl@0
|
411 |
TBuf8<255> buf;
|
|
sl@0
|
412 |
buf.Copy(KIntLong0, sizeof(KIntLong0));
|
|
sl@0
|
413 |
if (!LongInt(buf, 0))
|
|
sl@0
|
414 |
User::Leave(KErrGeneral);
|
|
sl@0
|
415 |
|
|
sl@0
|
416 |
buf.Copy(KIntLong4321, sizeof(KIntLong4321));
|
|
sl@0
|
417 |
if (!LongInt(buf, 0x4321))
|
|
sl@0
|
418 |
User::Leave(KErrGeneral);
|
|
sl@0
|
419 |
|
|
sl@0
|
420 |
buf.Copy(KIntLongABCDEF, sizeof(KIntLongABCDEF));
|
|
sl@0
|
421 |
if (!LongInt(buf, 0xABCDEF))
|
|
sl@0
|
422 |
User::Leave(KErrGeneral);
|
|
sl@0
|
423 |
|
|
sl@0
|
424 |
buf.Copy(KIntLongABCDEF112233, sizeof(KIntLongABCDEF112233));
|
|
sl@0
|
425 |
if (!LongInt(buf, 0xEF112233))
|
|
sl@0
|
426 |
User::Leave(KErrGeneral);
|
|
sl@0
|
427 |
|
|
sl@0
|
428 |
buf.Copy(KIntTooLong110009ABCDEF112233, sizeof(KIntTooLong110009ABCDEF112233));
|
|
sl@0
|
429 |
if (!LongInt(buf, 0x09ABCDEF, KErrCorrupt))
|
|
sl@0
|
430 |
User::Leave(KErrGeneral);
|
|
sl@0
|
431 |
|
|
sl@0
|
432 |
buf.Copy(KIntCorrupt, sizeof(KIntCorrupt));
|
|
sl@0
|
433 |
if (!LongInt(buf, 0, KErrCorrupt))
|
|
sl@0
|
434 |
User::Leave(KErrGeneral);
|
|
sl@0
|
435 |
}
|
|
sl@0
|
436 |
|
|
sl@0
|
437 |
|
|
sl@0
|
438 |
|
|
sl@0
|
439 |
//* UintVar */
|
|
sl@0
|
440 |
|
|
sl@0
|
441 |
TBool CWSPDecodeTest::UintVar(TPtrC8 aBuf, TUint32 aShouldBe, TInt aErr)
|
|
sl@0
|
442 |
{
|
|
sl@0
|
443 |
TInt success;
|
|
sl@0
|
444 |
TWspPrimitiveDecoder dec(aBuf);
|
|
sl@0
|
445 |
TUint32 val;
|
|
sl@0
|
446 |
success = dec.UintVar(val);
|
|
sl@0
|
447 |
if (success < KErrNone && success == aErr)
|
|
sl@0
|
448 |
return ETrue;
|
|
sl@0
|
449 |
return val == aShouldBe;
|
|
sl@0
|
450 |
}
|
|
sl@0
|
451 |
|
|
sl@0
|
452 |
|
|
sl@0
|
453 |
void CWSPDecodeTest::UintVarsTestL()
|
|
sl@0
|
454 |
{
|
|
sl@0
|
455 |
_LIT(KTestText, "WSP Decode: UintVars");
|
|
sl@0
|
456 |
iTestHarness->StartTestL(KTestText);
|
|
sl@0
|
457 |
TRAPD(error, TestUintVarsL());
|
|
sl@0
|
458 |
iTestHarness->EndTest(error);
|
|
sl@0
|
459 |
User::LeaveIfError(error);
|
|
sl@0
|
460 |
}
|
|
sl@0
|
461 |
|
|
sl@0
|
462 |
|
|
sl@0
|
463 |
void CWSPDecodeTest::TestUintVarsL()
|
|
sl@0
|
464 |
{
|
|
sl@0
|
465 |
const TUint8 KUint0[] = {0x00};
|
|
sl@0
|
466 |
const TUint8 KUint1[] = {0x01};
|
|
sl@0
|
467 |
const TUint8 KUintA[] = {0x80,0x0A};
|
|
sl@0
|
468 |
const TUint8 KUintFA[] = {0x81,0x7A};
|
|
sl@0
|
469 |
const TUint8 KLenUintVAR4510[] = {0x81, 0x8A, 0x10};
|
|
sl@0
|
470 |
const TUint8 KLenUintVARCorrupt[] = {0x8F, 0x81,0x8A,0x80,0x88};
|
|
sl@0
|
471 |
const TUint8 KIntLongACorrupt[] = {0xF3, 0xAB,0xCD,0xEF};
|
|
sl@0
|
472 |
|
|
sl@0
|
473 |
|
|
sl@0
|
474 |
TBuf8<255> buf;
|
|
sl@0
|
475 |
|
|
sl@0
|
476 |
buf.Copy(KUint0, sizeof(KUint0));
|
|
sl@0
|
477 |
if (!UintVar(buf, 0))
|
|
sl@0
|
478 |
User::Leave(KErrGeneral);
|
|
sl@0
|
479 |
|
|
sl@0
|
480 |
buf.Copy(KUint1, sizeof(KUint1));
|
|
sl@0
|
481 |
if (!UintVar(buf, 1))
|
|
sl@0
|
482 |
User::Leave(KErrGeneral);
|
|
sl@0
|
483 |
|
|
sl@0
|
484 |
buf.Copy(KUintA, sizeof(KUintA));
|
|
sl@0
|
485 |
if (!UintVar(buf, 0x0A))
|
|
sl@0
|
486 |
User::Leave(KErrGeneral);
|
|
sl@0
|
487 |
|
|
sl@0
|
488 |
buf.Copy(KUintFA, sizeof(KUintFA));
|
|
sl@0
|
489 |
if (!UintVar(buf, 0xFA))
|
|
sl@0
|
490 |
User::Leave(KErrGeneral);
|
|
sl@0
|
491 |
|
|
sl@0
|
492 |
buf.Copy(KLenUintVAR4510, sizeof(KLenUintVAR4510));
|
|
sl@0
|
493 |
if (!UintVar(buf, 0x4510))
|
|
sl@0
|
494 |
User::Leave(KErrGeneral);
|
|
sl@0
|
495 |
|
|
sl@0
|
496 |
buf.Copy(KLenUintVARCorrupt, sizeof(KLenUintVARCorrupt));
|
|
sl@0
|
497 |
if (!UintVar(buf, 0, KErrCorrupt))
|
|
sl@0
|
498 |
User::Leave(KErrGeneral);
|
|
sl@0
|
499 |
|
|
sl@0
|
500 |
buf.Copy(KIntLongACorrupt, sizeof(KIntLongACorrupt));
|
|
sl@0
|
501 |
if (!UintVar(buf, 0, KErrCorrupt))
|
|
sl@0
|
502 |
User::Leave(KErrGeneral);
|
|
sl@0
|
503 |
}
|
|
sl@0
|
504 |
|
|
sl@0
|
505 |
|
|
sl@0
|
506 |
|
|
sl@0
|
507 |
|
|
sl@0
|
508 |
//* VersionL */
|
|
sl@0
|
509 |
|
|
sl@0
|
510 |
TBool CWSPDecodeTest::VersionL(RStringPool aPool, TPtrC8 aBuf, TPtrC8 aShouldBe, TInt aErr)
|
|
sl@0
|
511 |
{
|
|
sl@0
|
512 |
TInt success;
|
|
sl@0
|
513 |
TWspPrimitiveDecoder dec(aBuf);
|
|
sl@0
|
514 |
TBool retVal = EFalse;
|
|
sl@0
|
515 |
RStringF val;
|
|
sl@0
|
516 |
success = dec.VersionL(aPool,val);
|
|
sl@0
|
517 |
CleanupClosePushL(val);
|
|
sl@0
|
518 |
if (success < KErrNone && success == aErr)
|
|
sl@0
|
519 |
retVal = ETrue;
|
|
sl@0
|
520 |
else
|
|
sl@0
|
521 |
{
|
|
sl@0
|
522 |
RStringF should = aPool.OpenFStringL(aShouldBe);
|
|
sl@0
|
523 |
retVal = val == should;
|
|
sl@0
|
524 |
should.Close();
|
|
sl@0
|
525 |
}
|
|
sl@0
|
526 |
CleanupStack::PopAndDestroy(&val);
|
|
sl@0
|
527 |
return retVal;
|
|
sl@0
|
528 |
}
|
|
sl@0
|
529 |
|
|
sl@0
|
530 |
void CWSPDecodeTest::VersionTestL()
|
|
sl@0
|
531 |
{
|
|
sl@0
|
532 |
_LIT(KTestText, "WSP Decode: Version");
|
|
sl@0
|
533 |
iTestHarness->StartTestL(KTestText);
|
|
sl@0
|
534 |
TRAPD(error, TestVersionL());
|
|
sl@0
|
535 |
iTestHarness->EndTest(error);
|
|
sl@0
|
536 |
User::LeaveIfError(error);
|
|
sl@0
|
537 |
}
|
|
sl@0
|
538 |
|
|
sl@0
|
539 |
void CWSPDecodeTest::TestVersionL()
|
|
sl@0
|
540 |
{
|
|
sl@0
|
541 |
RStringPool pool;
|
|
sl@0
|
542 |
pool.OpenL();
|
|
sl@0
|
543 |
CleanupClosePushL(pool);
|
|
sl@0
|
544 |
const TUint8 KVersion1[] = {0x9F};
|
|
sl@0
|
545 |
const TUint8 KVersion11[] = {0x91};
|
|
sl@0
|
546 |
const TUint8 KVersion610[] = {0xEA};
|
|
sl@0
|
547 |
const TUint8 KVersion73[] = {0xF3};
|
|
sl@0
|
548 |
const TUint8 KVersion00[] = {0x80};
|
|
sl@0
|
549 |
const TUint8 KVersionStr[] = {'1','.','9','9',0x00};
|
|
sl@0
|
550 |
TBuf8<255> buf;
|
|
sl@0
|
551 |
|
|
sl@0
|
552 |
buf.Copy(KVersion1, sizeof(KVersion1));
|
|
sl@0
|
553 |
if (!VersionL(pool, buf, _L8("1")))
|
|
sl@0
|
554 |
User::Leave(KErrGeneral);
|
|
sl@0
|
555 |
|
|
sl@0
|
556 |
buf.Copy(KVersion11, sizeof(KVersion11));
|
|
sl@0
|
557 |
if (!VersionL(pool, buf, _L8("1.1")))
|
|
sl@0
|
558 |
User::Leave(KErrGeneral);
|
|
sl@0
|
559 |
|
|
sl@0
|
560 |
buf.Copy(KVersion610, sizeof(KVersion610));
|
|
sl@0
|
561 |
if (!VersionL(pool, buf, _L8("6.10")))
|
|
sl@0
|
562 |
User::Leave(KErrGeneral);
|
|
sl@0
|
563 |
|
|
sl@0
|
564 |
buf.Copy(KVersion73, sizeof(KVersion73));
|
|
sl@0
|
565 |
if (!VersionL(pool, buf, _L8("7.3")))
|
|
sl@0
|
566 |
User::Leave(KErrGeneral);
|
|
sl@0
|
567 |
|
|
sl@0
|
568 |
buf.Copy(KVersion00, sizeof(KVersion00));
|
|
sl@0
|
569 |
if (!VersionL(pool, buf, _L8("0.0")))
|
|
sl@0
|
570 |
User::Leave(KErrGeneral);
|
|
sl@0
|
571 |
|
|
sl@0
|
572 |
buf.Copy(KVersionStr, sizeof(KVersionStr));
|
|
sl@0
|
573 |
if (!VersionL(pool, buf, _L8("1.99")))
|
|
sl@0
|
574 |
User::Leave(KErrGeneral);
|
|
sl@0
|
575 |
|
|
sl@0
|
576 |
CleanupStack::PopAndDestroy(&pool);
|
|
sl@0
|
577 |
}
|
|
sl@0
|
578 |
|
|
sl@0
|
579 |
|
|
sl@0
|
580 |
//* Date */
|
|
sl@0
|
581 |
|
|
sl@0
|
582 |
TBool CWSPDecodeTest::Date(TPtrC8 aBuf, TTime aShouldBe, TInt aErr)
|
|
sl@0
|
583 |
{
|
|
sl@0
|
584 |
TInt success;
|
|
sl@0
|
585 |
TWspPrimitiveDecoder dec(aBuf);
|
|
sl@0
|
586 |
TDateTime val;
|
|
sl@0
|
587 |
success = dec.Date(val);
|
|
sl@0
|
588 |
if (success < KErrNone && success == aErr)
|
|
sl@0
|
589 |
return ETrue;
|
|
sl@0
|
590 |
|
|
sl@0
|
591 |
TTime time(val);
|
|
sl@0
|
592 |
return time == aShouldBe;
|
|
sl@0
|
593 |
}
|
|
sl@0
|
594 |
|
|
sl@0
|
595 |
|
|
sl@0
|
596 |
void CWSPDecodeTest::DateTestL()
|
|
sl@0
|
597 |
{
|
|
sl@0
|
598 |
_LIT(KTestText, "WSP Decode: Date");
|
|
sl@0
|
599 |
iTestHarness->StartTestL(KTestText);
|
|
sl@0
|
600 |
TRAPD(error, TestDateL());
|
|
sl@0
|
601 |
iTestHarness->EndTest(error);
|
|
sl@0
|
602 |
User::LeaveIfError(error);
|
|
sl@0
|
603 |
}
|
|
sl@0
|
604 |
|
|
sl@0
|
605 |
|
|
sl@0
|
606 |
void CWSPDecodeTest::TestDateL()
|
|
sl@0
|
607 |
{
|
|
sl@0
|
608 |
// 1 long, value 0
|
|
sl@0
|
609 |
const TUint8 KDate0[] = {0x01, 0x00};
|
|
sl@0
|
610 |
const TUint8 KDateAprl132001[] = {0x04,0x3A,0xD6,0x41,0x80};
|
|
sl@0
|
611 |
const TUint8 KDateDec132003[] = {0x04,0x3F,0xE2,0x8D,0x84};
|
|
sl@0
|
612 |
TBuf8<255> buf;
|
|
sl@0
|
613 |
TDateTime dt(1970,EJanuary,0,0,0,0,0);
|
|
sl@0
|
614 |
TTime time1(dt);
|
|
sl@0
|
615 |
buf.Copy(KDate0, sizeof(KDate0));
|
|
sl@0
|
616 |
if (!Date(buf, time1))
|
|
sl@0
|
617 |
User::Leave(KErrGeneral);
|
|
sl@0
|
618 |
|
|
sl@0
|
619 |
TTime time2(dt);
|
|
sl@0
|
620 |
time2 += TTimeIntervalSeconds(0x3AD64180);
|
|
sl@0
|
621 |
buf.Copy(KDateAprl132001, sizeof(KDateAprl132001));
|
|
sl@0
|
622 |
if (!Date(buf, time2))
|
|
sl@0
|
623 |
User::Leave(KErrGeneral);
|
|
sl@0
|
624 |
|
|
sl@0
|
625 |
TTime time3(dt);
|
|
sl@0
|
626 |
time3 += TTimeIntervalSeconds(0x3FE28D84);
|
|
sl@0
|
627 |
buf.Copy(KDateDec132003, sizeof(KDateDec132003));
|
|
sl@0
|
628 |
if (!Date(buf, time3))
|
|
sl@0
|
629 |
User::Leave(KErrGeneral);
|
|
sl@0
|
630 |
}
|
|
sl@0
|
631 |
|
|
sl@0
|
632 |
|
|
sl@0
|
633 |
TInt CWSPDecodeTest::SegmenterCommonL(RStringPool aPool, TPtrC8 aHdr)
|
|
sl@0
|
634 |
{
|
|
sl@0
|
635 |
TInt err;
|
|
sl@0
|
636 |
TWspField fld;
|
|
sl@0
|
637 |
|
|
sl@0
|
638 |
// Pre-condition to create WSP header segment: Open the string pool
|
|
sl@0
|
639 |
// with the string table. Else program will raise a panic stringtable:4
|
|
sl@0
|
640 |
// ( EStringTableNotFound )
|
|
sl@0
|
641 |
aPool.OpenL ( WSPDummy::Table );
|
|
sl@0
|
642 |
TWspHeaderSegmenter segger(aPool, WSPDummy::Table, aHdr);
|
|
sl@0
|
643 |
|
|
sl@0
|
644 |
while ((err = segger.NextL(fld)) == KErrNone)
|
|
sl@0
|
645 |
{
|
|
sl@0
|
646 |
fld.iHdrName.Close();
|
|
sl@0
|
647 |
}
|
|
sl@0
|
648 |
return err;
|
|
sl@0
|
649 |
}
|
|
sl@0
|
650 |
|
|
sl@0
|
651 |
TBool CWSPDecodeTest::SegmenterL(RStringPool aPool, TPtrC8 aHdr)
|
|
sl@0
|
652 |
{
|
|
sl@0
|
653 |
TInt err = SegmenterCommonL(aPool,aHdr);
|
|
sl@0
|
654 |
if (err != KErrNotFound)
|
|
sl@0
|
655 |
return EFalse;
|
|
sl@0
|
656 |
return ETrue;
|
|
sl@0
|
657 |
}
|
|
sl@0
|
658 |
|
|
sl@0
|
659 |
TBool CWSPDecodeTest::SegmenterExpectCorruptL(RStringPool aPool, TPtrC8 aHdr)
|
|
sl@0
|
660 |
{
|
|
sl@0
|
661 |
TInt err = SegmenterCommonL(aPool,aHdr);
|
|
sl@0
|
662 |
if (err != KErrCorrupt)
|
|
sl@0
|
663 |
return EFalse;
|
|
sl@0
|
664 |
return ETrue;
|
|
sl@0
|
665 |
}
|
|
sl@0
|
666 |
|
|
sl@0
|
667 |
void CWSPDecodeTest::SegmenterTestL()
|
|
sl@0
|
668 |
{
|
|
sl@0
|
669 |
_LIT(KTestText, "WSP Decode: Segmenter");
|
|
sl@0
|
670 |
iTestHarness->StartTestL(KTestText);
|
|
sl@0
|
671 |
TRAPD(error, TestSegmenterL());
|
|
sl@0
|
672 |
iTestHarness->EndTest(error);
|
|
sl@0
|
673 |
User::LeaveIfError(error);
|
|
sl@0
|
674 |
}
|
|
sl@0
|
675 |
|
|
sl@0
|
676 |
|
|
sl@0
|
677 |
void CWSPDecodeTest::TestSegmenterL()
|
|
sl@0
|
678 |
{
|
|
sl@0
|
679 |
TBuf8<255> buf;
|
|
sl@0
|
680 |
RStringPool pool;
|
|
sl@0
|
681 |
pool.OpenL();
|
|
sl@0
|
682 |
CleanupClosePushL(pool);
|
|
sl@0
|
683 |
|
|
sl@0
|
684 |
// Test Headers
|
|
sl@0
|
685 |
const TUint8 KAcceptAppVndWMLC[] = {0x80, 0x94};
|
|
sl@0
|
686 |
const TUint8 KAcceptLanEngQ07[] = {0x82, 0x02, 0x99, 0x47};
|
|
sl@0
|
687 |
const TUint8 KAcceptLanENSV[] = {0x82, 0x02, 0x83, 0xF0};
|
|
sl@0
|
688 |
const TUint8 KDateThu23Apr1998134127GMT[] = {0x92, 0x04, 0x35, 0x3f, 0x45, 0x11};
|
|
sl@0
|
689 |
const TUint8 KContentRangeBytes0499[] = {0x90, 0x03, 0x00, 0x88, 0x01};
|
|
sl@0
|
690 |
const TUint8 KAcceptRangeNewRangeUnit[] = {0x84, 'n','e','w','-','r','a','n','g','e','-','u','n','i','t',0x00};
|
|
sl@0
|
691 |
const TUint8 KXNewHdrFoo[] = {'X','-','n','e','w','-','H','e','a','d','e','r',0x00,'F','o','o',0x00};
|
|
sl@0
|
692 |
const TUint8 KTwo[] = {0x80, 0x94, 0x81, 0x93};
|
|
sl@0
|
693 |
|
|
sl@0
|
694 |
const TUint8 KCorrupt1[] = {0x82};
|
|
sl@0
|
695 |
buf.Copy(KCorrupt1, sizeof(KCorrupt1));
|
|
sl@0
|
696 |
if (!SegmenterExpectCorruptL(pool, buf))
|
|
sl@0
|
697 |
User::Leave(KErrGeneral);
|
|
sl@0
|
698 |
|
|
sl@0
|
699 |
const TUint8 KCorrupt2[] = {0x82, 0x02};
|
|
sl@0
|
700 |
buf.Copy(KCorrupt2, sizeof(KCorrupt2));
|
|
sl@0
|
701 |
if (!SegmenterExpectCorruptL(pool, buf))
|
|
sl@0
|
702 |
User::Leave(KErrGeneral);
|
|
sl@0
|
703 |
|
|
sl@0
|
704 |
buf.Copy(KAcceptAppVndWMLC, sizeof(KAcceptAppVndWMLC));
|
|
sl@0
|
705 |
if (!SegmenterL(pool, buf))
|
|
sl@0
|
706 |
User::Leave(KErrGeneral);
|
|
sl@0
|
707 |
|
|
sl@0
|
708 |
buf.Copy(KAcceptLanEngQ07, sizeof(KAcceptLanEngQ07));
|
|
sl@0
|
709 |
if (!SegmenterL(pool, buf))
|
|
sl@0
|
710 |
User::Leave(KErrGeneral);
|
|
sl@0
|
711 |
|
|
sl@0
|
712 |
buf.Copy(KAcceptLanENSV, sizeof(KAcceptLanENSV));
|
|
sl@0
|
713 |
if (!SegmenterL(pool, buf))
|
|
sl@0
|
714 |
User::Leave(KErrGeneral);
|
|
sl@0
|
715 |
|
|
sl@0
|
716 |
buf.Copy(KDateThu23Apr1998134127GMT, sizeof(KDateThu23Apr1998134127GMT));
|
|
sl@0
|
717 |
if (!SegmenterL(pool, buf))
|
|
sl@0
|
718 |
User::Leave(KErrGeneral);
|
|
sl@0
|
719 |
|
|
sl@0
|
720 |
buf.Copy(KContentRangeBytes0499, sizeof(KContentRangeBytes0499));
|
|
sl@0
|
721 |
if (!SegmenterL(pool, buf))
|
|
sl@0
|
722 |
User::Leave(KErrGeneral);
|
|
sl@0
|
723 |
|
|
sl@0
|
724 |
buf.Copy(KAcceptRangeNewRangeUnit, sizeof(KAcceptRangeNewRangeUnit));
|
|
sl@0
|
725 |
if (!SegmenterL(pool, buf))
|
|
sl@0
|
726 |
User::Leave(KErrGeneral);
|
|
sl@0
|
727 |
|
|
sl@0
|
728 |
buf.Copy(KXNewHdrFoo, sizeof(KXNewHdrFoo));
|
|
sl@0
|
729 |
if (!SegmenterL(pool, buf))
|
|
sl@0
|
730 |
User::Leave(KErrGeneral);
|
|
sl@0
|
731 |
|
|
sl@0
|
732 |
buf.Copy(KTwo, sizeof(KTwo));
|
|
sl@0
|
733 |
if (!SegmenterL(pool, buf))
|
|
sl@0
|
734 |
User::Leave(KErrGeneral);
|
|
sl@0
|
735 |
|
|
sl@0
|
736 |
CleanupStack::PopAndDestroy(&pool);
|
|
sl@0
|
737 |
}
|
|
sl@0
|
738 |
|
|
sl@0
|
739 |
/*
|
|
sl@0
|
740 |
|
|
sl@0
|
741 |
void CWSPDecodeTest::XXXTestL()
|
|
sl@0
|
742 |
{
|
|
sl@0
|
743 |
_LIT(KTestText, "WSP Decode: XXX");
|
|
sl@0
|
744 |
iTestHarness->StartTestL(KTestText);
|
|
sl@0
|
745 |
TRAPD(error, TestXXXL());
|
|
sl@0
|
746 |
iTestHarness->EndTest(error);
|
|
sl@0
|
747 |
User::LeaveIfError(error);
|
|
sl@0
|
748 |
}
|
|
sl@0
|
749 |
|
|
sl@0
|
750 |
|
|
sl@0
|
751 |
*/
|