|
1 // Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // Implementation of test CWSPEncodeTest. |
|
15 // |
|
16 // |
|
17 |
|
18 |
|
19 #include "cwspencodetest.h" |
|
20 #include <wspencoder.h> |
|
21 |
|
22 |
|
23 CWSPEncodeTest* CWSPEncodeTest::NewLC(CIpuTestHarness* aTestHarness) |
|
24 { |
|
25 CWSPEncodeTest* self = new(ELeave)CWSPEncodeTest(aTestHarness); |
|
26 CleanupStack::PushL(self); |
|
27 return self; |
|
28 } |
|
29 |
|
30 |
|
31 CWSPEncodeTest::CWSPEncodeTest(CIpuTestHarness* aTestHarness): |
|
32 iTestHarness(aTestHarness) |
|
33 {} |
|
34 |
|
35 CWSPEncodeTest::~CWSPEncodeTest() |
|
36 {} |
|
37 |
|
38 void CWSPEncodeTest::DoTestsL() |
|
39 { |
|
40 HeaderEncoderTestL(); |
|
41 ShortIntTestL(); |
|
42 LongIntTestL(); |
|
43 UintVarTestL(); |
|
44 StringTestL(); |
|
45 DateTestL(); |
|
46 } |
|
47 |
|
48 |
|
49 void CWSPEncodeTest::HeaderEncoderTestL() |
|
50 { |
|
51 _LIT(KTestText, "WSP Encode: Header"); |
|
52 iTestHarness->StartTestL(KTestText); |
|
53 TRAPD(error, TestHeaderEncoderL()); |
|
54 iTestHarness->EndTest(error); |
|
55 User::LeaveIfError(error); |
|
56 } |
|
57 |
|
58 void CWSPEncodeTest::TestHeaderEncoderL() |
|
59 { |
|
60 TInt err=0; |
|
61 |
|
62 CWspHeaderEncoder* primEncoder = CWspHeaderEncoder::NewLC(); |
|
63 |
|
64 primEncoder->StartHeaderL(0x27); |
|
65 primEncoder->StartValueLengthL(); |
|
66 primEncoder->AddUintVarL(0xff); |
|
67 primEncoder->AddLongIntL(999999); |
|
68 primEncoder->AddIntegerL(0x7F); |
|
69 primEncoder->EndValueLengthL(); |
|
70 HBufC8* buf = primEncoder->EndHeaderL(); |
|
71 CleanupStack::PushL(buf); |
|
72 CleanupStack::PopAndDestroy(2); //primEncoder, buf |
|
73 |
|
74 User::LeaveIfError(err); |
|
75 } |
|
76 |
|
77 |
|
78 void CWSPEncodeTest::ShortIntTestL() |
|
79 { |
|
80 _LIT(KTestText, "WSP Encode: ShortInt"); |
|
81 iTestHarness->StartTestL(KTestText); |
|
82 TInt error = TestShortInt(); |
|
83 iTestHarness->EndTest(error); |
|
84 User::LeaveIfError(error); |
|
85 } |
|
86 |
|
87 |
|
88 TInt CWSPEncodeTest::TestShortInt() |
|
89 { |
|
90 TUint8 input; |
|
91 TUint8 output; |
|
92 |
|
93 // TWspPrimitiveEncoder::ShortInt |
|
94 // Check 7 and 8 bit values. If 8bit notinh happens |
|
95 input=0; // MIN input value |
|
96 output = TWspPrimitiveEncoder::ShortInt(input); |
|
97 if (output !=128) |
|
98 return KErrGeneral; |
|
99 |
|
100 input=35; // MAX input value |
|
101 output = TWspPrimitiveEncoder::ShortInt(input); |
|
102 if (output !=163) |
|
103 return KErrGeneral; |
|
104 |
|
105 input=0x7F; // MAX input value |
|
106 output = TWspPrimitiveEncoder::ShortInt(input); |
|
107 if (output !=255) |
|
108 return KErrGeneral; |
|
109 |
|
110 input=0x80; // invalid value |
|
111 output = TWspPrimitiveEncoder::ShortInt(input); |
|
112 if (output !=0) |
|
113 return KErrGeneral; |
|
114 |
|
115 return KErrNone; |
|
116 } |
|
117 |
|
118 |
|
119 void CWSPEncodeTest::LongIntTestL() |
|
120 { |
|
121 _LIT(KTestText, "WSP Encode: LongInt"); |
|
122 iTestHarness->StartTestL(KTestText); |
|
123 TRAPD(error,TestLongIntL()); |
|
124 iTestHarness->EndTest(error); |
|
125 User::LeaveIfError(error); |
|
126 } |
|
127 |
|
128 void CWSPEncodeTest::TestLongIntL() |
|
129 { |
|
130 HBufC8* output=NULL; |
|
131 TBuf8<255> buf; |
|
132 TUint32 input; |
|
133 |
|
134 const TUint8 KZeroValueLongInt[] = {0x01, 0x00}; |
|
135 const TUint8 K127LongInt[] = {0x01, 0x7F}; |
|
136 const TUint8 K255LongInt[] = {0x01, 0xFF}; |
|
137 const TUint8 K256LongInt[] = {0x02, 0x01, 0x00}; |
|
138 const TUint8 KFFFFLongInt[] = {0x02, 0xFF, 0xFF}; |
|
139 const TUint8 K10000LongInt[] = {0x03, 0x01, 0x00, 0x00}; |
|
140 const TUint8 KFFFFFFLongInt[] = {0x03, 0xFF, 0xFF, 0xFF}; |
|
141 const TUint8 K1000000LongInt[] = {0x04, 0x01, 0x00, 0x00, 0x00}; |
|
142 const TUint8 KFFFFFFFFLongInt[] = {0x04, 0xFF, 0xFF, 0xFF, 0xFF}; |
|
143 |
|
144 input=0; |
|
145 output = TWspPrimitiveEncoder::LongIntL(input); |
|
146 CleanupStack::PushL(output); |
|
147 buf.Copy(KZeroValueLongInt, sizeof(KZeroValueLongInt)); |
|
148 if ((*output).CompareF(buf)!=0) |
|
149 User::Leave(KErrGeneral); |
|
150 CleanupStack::PopAndDestroy(output); |
|
151 |
|
152 input=127; |
|
153 output = TWspPrimitiveEncoder::LongIntL(input); |
|
154 CleanupStack::PushL(output); |
|
155 buf.Copy(K127LongInt, sizeof(K127LongInt)); |
|
156 if ((*output).CompareF(buf)!=0) |
|
157 User::Leave(KErrGeneral); |
|
158 CleanupStack::PopAndDestroy(output); |
|
159 |
|
160 input=255; |
|
161 output = TWspPrimitiveEncoder::LongIntL(input); |
|
162 CleanupStack::PushL(output); |
|
163 buf.Copy(K255LongInt, sizeof(K255LongInt)); |
|
164 if ((*output).CompareF(buf)!=0) |
|
165 User::Leave(KErrGeneral); |
|
166 CleanupStack::PopAndDestroy(output); |
|
167 |
|
168 input=256; |
|
169 output = TWspPrimitiveEncoder::LongIntL(input); |
|
170 CleanupStack::PushL(output); |
|
171 buf.Copy(K256LongInt, sizeof(K256LongInt)); |
|
172 if ((*output).CompareF(buf)!=0) |
|
173 User::Leave(KErrGeneral); |
|
174 CleanupStack::PopAndDestroy(output); |
|
175 |
|
176 input=0xFFFF; |
|
177 output = TWspPrimitiveEncoder::LongIntL(input); |
|
178 CleanupStack::PushL(output); |
|
179 buf.Copy(KFFFFLongInt, sizeof(KFFFFLongInt)); |
|
180 if ((*output).CompareF(buf)!=0) |
|
181 User::Leave(KErrGeneral); |
|
182 CleanupStack::PopAndDestroy(output); |
|
183 |
|
184 input=0x10000; |
|
185 output = TWspPrimitiveEncoder::LongIntL(input); |
|
186 CleanupStack::PushL(output); |
|
187 buf.Copy(K10000LongInt, sizeof(K10000LongInt)); |
|
188 if ((*output).CompareF(buf)!=0) |
|
189 User::Leave(KErrGeneral); |
|
190 CleanupStack::PopAndDestroy(output); |
|
191 |
|
192 input=0xFFFFFF; |
|
193 output = TWspPrimitiveEncoder::LongIntL(input); |
|
194 CleanupStack::PushL(output); |
|
195 buf.Copy(KFFFFFFLongInt, sizeof(KFFFFFFLongInt)); |
|
196 if ((*output).CompareF(buf)!=0) |
|
197 User::Leave(KErrGeneral); |
|
198 CleanupStack::PopAndDestroy(output); |
|
199 |
|
200 input=0x1000000; |
|
201 output = TWspPrimitiveEncoder::LongIntL(input); |
|
202 CleanupStack::PushL(output); |
|
203 buf.Copy(K1000000LongInt, sizeof(K1000000LongInt)); |
|
204 if ((*output).CompareF(buf)!=0) |
|
205 User::Leave(KErrGeneral); |
|
206 CleanupStack::PopAndDestroy(output); |
|
207 |
|
208 input=0xFFFFFFFF; |
|
209 output = TWspPrimitiveEncoder::LongIntL(input); |
|
210 CleanupStack::PushL(output); |
|
211 buf.Copy(KFFFFFFFFLongInt, sizeof(KFFFFFFFFLongInt)); |
|
212 if ((*output).CompareF(buf)!=0) |
|
213 User::Leave(KErrGeneral); |
|
214 CleanupStack::PopAndDestroy(output); |
|
215 } |
|
216 |
|
217 |
|
218 void CWSPEncodeTest::UintVarTestL() |
|
219 { |
|
220 _LIT(KTestText, "WSP Encode: UintVar"); |
|
221 iTestHarness->StartTestL(KTestText); |
|
222 TRAPD(error,TestUintVarL()); |
|
223 iTestHarness->EndTest(error); |
|
224 User::LeaveIfError(error); |
|
225 } |
|
226 |
|
227 void CWSPEncodeTest::TestUintVarL() |
|
228 { |
|
229 |
|
230 HBufC8* output=NULL; |
|
231 TBuf8<255> buf; |
|
232 TUint32 input; |
|
233 |
|
234 const TUint8 KMinValue[] = {0x00}; |
|
235 const TUint8 KMaxValue[] = {0x8F, 0xFF, 0xFF, 0xFF, 0x7F}; |
|
236 |
|
237 const TUint8 K7bitBoundaryLower[] = {0x7F}; |
|
238 const TUint8 K7bitBoundaryUpper[] = {0x81, 0x00}; |
|
239 |
|
240 const TUint8 K14bitBoundaryLower[] = {0xFF, 0x7F}; |
|
241 const TUint8 K14bitBoundaryUpper[] = {0x81, 0x80, 0x00}; |
|
242 |
|
243 const TUint8 K21bitBoundaryLower[] = {0xFF, 0xFF, 0x7F}; |
|
244 const TUint8 K21bitBoundaryUpper[] = {0x81, 0x80, 0x80, 0x00}; |
|
245 const TUint8 K28bitBoundaryLower[] = {0xFF, 0xFF, 0xFF, 0x7F}; |
|
246 const TUint8 K28bitBoundaryUpper[] = {0x81, 0x80, 0x80, 0x80, 0x00}; |
|
247 |
|
248 input=0; |
|
249 output = TWspPrimitiveEncoder::UintVarL(input); |
|
250 CleanupStack::PushL(output); |
|
251 buf.Copy(KMinValue, sizeof(KMinValue)); |
|
252 if ((*output).CompareF(buf)!=0) |
|
253 User::Leave(KErrGeneral); |
|
254 CleanupStack::PopAndDestroy(output); |
|
255 |
|
256 input=0xFFFFFFFF; |
|
257 output = TWspPrimitiveEncoder::UintVarL(input); |
|
258 CleanupStack::PushL(output); |
|
259 buf.Copy(KMaxValue, sizeof(KMaxValue)); |
|
260 if ((*output).CompareF(buf)!=0) |
|
261 User::Leave(KErrGeneral); |
|
262 CleanupStack::PopAndDestroy(output); |
|
263 |
|
264 input=0x7F; |
|
265 output = TWspPrimitiveEncoder::UintVarL(input); |
|
266 CleanupStack::PushL(output); |
|
267 buf.Copy(K7bitBoundaryLower, sizeof(K7bitBoundaryLower)); |
|
268 if ((*output).CompareF(buf)!=0) |
|
269 User::Leave(KErrGeneral); |
|
270 CleanupStack::PopAndDestroy(output); |
|
271 |
|
272 input=0x80; |
|
273 output = TWspPrimitiveEncoder::UintVarL(input); |
|
274 CleanupStack::PushL(output); |
|
275 buf.Copy(K7bitBoundaryUpper, sizeof(K7bitBoundaryUpper)); |
|
276 if ((*output).CompareF(buf)!=0) |
|
277 User::Leave(KErrGeneral); |
|
278 CleanupStack::PopAndDestroy(output); |
|
279 |
|
280 input=0x3FFF; |
|
281 output = TWspPrimitiveEncoder::UintVarL(input); |
|
282 CleanupStack::PushL(output); |
|
283 buf.Copy(K14bitBoundaryLower, sizeof(K14bitBoundaryLower)); |
|
284 if ((*output).CompareF(buf)!=0) |
|
285 User::Leave(KErrGeneral); |
|
286 CleanupStack::PopAndDestroy(output); |
|
287 |
|
288 input=0x4000; |
|
289 output = TWspPrimitiveEncoder::UintVarL(input); |
|
290 CleanupStack::PushL(output); |
|
291 buf.Copy(K14bitBoundaryUpper, sizeof(K14bitBoundaryUpper)); |
|
292 if ((*output).CompareF(buf)!=0) |
|
293 User::Leave(KErrGeneral); |
|
294 CleanupStack::PopAndDestroy(output); |
|
295 |
|
296 input=0x1FFFFF; |
|
297 output = TWspPrimitiveEncoder::UintVarL(input); |
|
298 CleanupStack::PushL(output); |
|
299 buf.Copy(K21bitBoundaryLower, sizeof(K21bitBoundaryLower)); |
|
300 if ((*output).CompareF(buf)!=0) |
|
301 User::Leave(KErrGeneral); |
|
302 CleanupStack::PopAndDestroy(output); |
|
303 |
|
304 input=0x200000; |
|
305 output = TWspPrimitiveEncoder::UintVarL(input); |
|
306 CleanupStack::PushL(output); |
|
307 buf.Copy(K21bitBoundaryUpper, sizeof(K21bitBoundaryUpper)); |
|
308 if ((*output).CompareF(buf)!=0) |
|
309 User::Leave(KErrGeneral); |
|
310 CleanupStack::PopAndDestroy(output); |
|
311 |
|
312 input=0xFFFFFFF; |
|
313 output = TWspPrimitiveEncoder::UintVarL(input); |
|
314 CleanupStack::PushL(output); |
|
315 buf.Copy(K28bitBoundaryLower, sizeof(K28bitBoundaryLower)); |
|
316 if ((*output).CompareF(buf)!=0) |
|
317 User::Leave(KErrGeneral); |
|
318 CleanupStack::PopAndDestroy(output); |
|
319 |
|
320 input=0x10000000; |
|
321 output = TWspPrimitiveEncoder::UintVarL(input); |
|
322 CleanupStack::PushL(output); |
|
323 buf.Copy(K28bitBoundaryUpper, sizeof(K28bitBoundaryUpper)); |
|
324 if ((*output).CompareF(buf)!=0) |
|
325 User::Leave(KErrGeneral); |
|
326 CleanupStack::PopAndDestroy(output); |
|
327 |
|
328 } |
|
329 |
|
330 |
|
331 void CWSPEncodeTest::StringTestL() |
|
332 { |
|
333 _LIT(KTestText, "WSP Encode: String"); |
|
334 iTestHarness->StartTestL(KTestText); |
|
335 TRAPD(error,TestStringL()); |
|
336 iTestHarness->EndTest(error); |
|
337 User::LeaveIfError(error); |
|
338 } |
|
339 |
|
340 void CWSPEncodeTest::TestStringL() |
|
341 { |
|
342 TBuf8<255> buf; |
|
343 |
|
344 // Test 1. A regular string |
|
345 const TUint8 KTestStringResult1[] = {'X','-','n','e','w','-','H','e','a','d','e','r','F','o','o',0x00}; |
|
346 _LIT8(KTestString1,"X-new-HeaderFoo"); |
|
347 |
|
348 // Test 2. A quoted string |
|
349 const TUint8 KTestStringResult2[] = {'\"','X','-','n','e','w','-','H','e','a','d','e','r','F','o','o',0x00}; |
|
350 _LIT8(KTestString2,"\"X-new-HeaderFoo\""); |
|
351 |
|
352 // Test 3. A string beginning with an Upper-Ascii character |
|
353 const TUint8 KTestStringResult3[] = {0x7F,0x80,'X','-','n','e','w','-','H','e','a','d','e','r','F','o','o',0x00}; |
|
354 const TUint8 KTestString3[] = {0x80,'X','-','n','e','w','-','H','e','a','d','e','r','F','o','o'}; |
|
355 |
|
356 HBufC8* output = TWspPrimitiveEncoder::TextStringL(KTestString1); |
|
357 CleanupStack::PushL(output); |
|
358 buf.Copy(KTestStringResult1, sizeof(KTestStringResult1)); |
|
359 if ((*output).CompareF(buf)!=0) |
|
360 User::Leave(KErrGeneral); |
|
361 CleanupStack::PopAndDestroy(output); |
|
362 |
|
363 |
|
364 output = TWspPrimitiveEncoder::TextStringL(KTestString2); |
|
365 CleanupStack::PushL(output); |
|
366 buf.Copy(KTestStringResult2, sizeof(KTestStringResult2)); |
|
367 if ((*output).CompareF(buf)!=0) |
|
368 User::Leave(KErrGeneral); |
|
369 CleanupStack::PopAndDestroy(output); |
|
370 |
|
371 buf.Copy(KTestString3, sizeof(KTestString3)); |
|
372 output = TWspPrimitiveEncoder::TextStringL(buf); |
|
373 CleanupStack::PushL(output); |
|
374 buf.Copy(KTestStringResult3, sizeof(KTestStringResult3)); |
|
375 if ((*output).CompareF(buf)!=0) |
|
376 User::Leave(KErrGeneral); |
|
377 CleanupStack::PopAndDestroy(output); |
|
378 } |
|
379 |
|
380 |
|
381 void CWSPEncodeTest::DateTestL() |
|
382 { |
|
383 _LIT(KTestText, "WSP Encode: Date"); |
|
384 iTestHarness->StartTestL(KTestText); |
|
385 TRAPD(error,TestDateL()); |
|
386 iTestHarness->EndTest(error); |
|
387 User::LeaveIfError(error); |
|
388 } |
|
389 |
|
390 |
|
391 void CWSPEncodeTest::TestDateL() |
|
392 { |
|
393 TBuf8<255> buf; |
|
394 |
|
395 const TUint8 KDate0[] = {0x01, 0x00}; |
|
396 |
|
397 TDateTime date(1970,EJanuary,0,0,0,0,0); |
|
398 |
|
399 HBufC8* output = TWspPrimitiveEncoder::DateL(date); |
|
400 CleanupStack::PushL(output); |
|
401 buf.Copy(KDate0, sizeof(KDate0)); |
|
402 if((*output).CompareF(buf)!=0) |
|
403 User::Leave(KErrGeneral); |
|
404 CleanupStack::PopAndDestroy(output); |
|
405 } |
|
406 |
|
407 |