|
1 // Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // |
|
15 |
|
16 #include "TVERSIT.H" |
|
17 #include <vutil.h> |
|
18 #include <charconv.h> |
|
19 #include <e32test.h> |
|
20 #include <coreappstest/testserver.h> |
|
21 |
|
22 // Type definitions |
|
23 #define UNUSED_VAR(a) a = a |
|
24 |
|
25 // Currently no tests for multiple VCards in sequence in a stream |
|
26 |
|
27 CConsoleBase* console; |
|
28 CVersitTest* test=NULL; |
|
29 TBool automatic=EFalse; |
|
30 LOCAL_D CTestRegister* FileRegister; |
|
31 #ifdef MANUAL |
|
32 #define TheTest (*console) |
|
33 #define Next Printf |
|
34 #else |
|
35 static RTest TheTest(_L("TVersit")); |
|
36 #endif |
|
37 |
|
38 // |
|
39 // CVersitTest |
|
40 // |
|
41 |
|
42 CVersitTest::CVersitTest() |
|
43 {} |
|
44 |
|
45 CVersitTest::~CVersitTest() |
|
46 { |
|
47 delete iParser; |
|
48 delete iStore; |
|
49 } |
|
50 |
|
51 void CVersitTest::StreamInL() |
|
52 //Convert the iVersit into stream format, save it as "VersitIn" |
|
53 //and internalize it as a CVersitParser |
|
54 { |
|
55 _LIT(KVersitInFileName, "VersitIn"); |
|
56 RFs fsSession; |
|
57 User::LeaveIfError(fsSession.Connect()); |
|
58 CleanupClosePushL(fsSession); |
|
59 TFileName inFile; |
|
60 FileRegister->GetTempPath(inFile); |
|
61 inFile.Append(KVersitInFileName); |
|
62 fsSession.MkDirAll(inFile); |
|
63 FileRegister->RegisterL(inFile); |
|
64 CFileStore* store = CDirectFileStore::ReplaceLC(fsSession, inFile, EFileWrite); |
|
65 store->SetTypeL(KDirectFileStoreLayoutUid); |
|
66 RStoreWriteStream outstream; |
|
67 TStreamId id = outstream.CreateLC(*store); |
|
68 TInt length=iVersit.Length(); |
|
69 for (TInt ii=0; ii<length; ii++) |
|
70 outstream.WriteInt8L(iVersit[ii]); |
|
71 outstream.CommitL(); |
|
72 CleanupStack::PopAndDestroy(); // outstream |
|
73 store->SetRootL(id); |
|
74 store->CommitL(); |
|
75 CleanupStack::PopAndDestroy(store); |
|
76 store = CDirectFileStore::OpenLC(fsSession, inFile, EFileRead); //retrieve stream |
|
77 RStoreReadStream instream; |
|
78 instream.OpenLC(*store,store->Root()); |
|
79 iParser->InternalizeL(instream); |
|
80 CleanupStack::PopAndDestroy(3); //store + stream + fsSession |
|
81 } |
|
82 |
|
83 void CVersitTest::StreamOutL() |
|
84 // externalize the CVersitParser into stream format, save the stream as "VersitOut" |
|
85 // and output it to the console |
|
86 { |
|
87 _LIT(KVersitOutFileName, "VersitOut"); |
|
88 RFs fsSession; // Save into stream |
|
89 User::LeaveIfError(fsSession.Connect()); |
|
90 TFileName outFile; |
|
91 FileRegister->GetTempPath(outFile); |
|
92 outFile.Append(KVersitOutFileName); |
|
93 FileRegister->RegisterL(outFile); |
|
94 fsSession.MkDirAll(outFile); |
|
95 CFileStore* store = CDirectFileStore::ReplaceLC(fsSession, outFile, EFileWrite); |
|
96 store->SetTypeL(KDirectFileStoreLayoutUid); |
|
97 RStoreWriteStream outstream; |
|
98 TStreamId id = outstream.CreateLC(*store); |
|
99 iParser->ExternalizeL(outstream); |
|
100 outstream.CommitL(); |
|
101 CleanupStack::PopAndDestroy(); |
|
102 store->SetRootL(id); |
|
103 store->CommitL(); |
|
104 CleanupStack::PopAndDestroy(); |
|
105 |
|
106 store = CDirectFileStore::OpenLC(fsSession, outFile, EFileRead); //retrieve stream |
|
107 RStoreReadStream instream; |
|
108 instream.OpenLC(*store,store->Root()); |
|
109 TInt err=0; |
|
110 TChar nextChar=0; |
|
111 iVersit.Zero(); |
|
112 #ifdef UNICODE |
|
113 CCnvCharacterSetConverter* unicodeConverter=CCnvCharacterSetConverter::NewLC(); |
|
114 CArrayFix<CCnvCharacterSetConverter::SCharacterSet>* arrayOfCharacterSetsAvailable=unicodeConverter->CreateArrayOfCharacterSetsAvailableL(fsSession); |
|
115 CleanupStack::PushL(arrayOfCharacterSetsAvailable); |
|
116 unicodeConverter->PrepareToConvertToOrFromL(0x100012b6, *arrayOfCharacterSetsAvailable, fsSession); // Code Page 1252 |
|
117 unicodeConverter->SetReplacementForUnconvertibleUnicodeCharactersL(_L8("?")); |
|
118 CleanupStack::PopAndDestroy(); //arrayOfCharacterSetsAvailable |
|
119 #endif |
|
120 while (err==0) |
|
121 { |
|
122 if (nextChar!=CVersitParser::ELineFeed) |
|
123 { |
|
124 TRAP(err,nextChar=instream.ReadUint8L()); |
|
125 if (err!=KErrEof) |
|
126 User::LeaveIfError(err); |
|
127 iVersit.Append(nextChar); |
|
128 } |
|
129 else |
|
130 { |
|
131 #ifdef UNICODE |
|
132 HBufC16* output=HBufC16::NewLC(iVersit.Length()); |
|
133 TInt state; |
|
134 TPtr16 temp = output->Des(); |
|
135 TInt error = unicodeConverter->ConvertToUnicode(temp, iVersit, state); |
|
136 if (error!=KErrNone) |
|
137 User::Leave(error); |
|
138 TheTest.Printf(*output); |
|
139 CleanupStack::PopAndDestroy(); //output |
|
140 #else |
|
141 TheTest.Printf(iVersit); |
|
142 #endif |
|
143 if (!automatic) |
|
144 { |
|
145 TInt character=TheTest.Getch(); |
|
146 if (character=='q') // character q quits |
|
147 break; |
|
148 } |
|
149 nextChar=0; |
|
150 iVersit.Zero(); |
|
151 } |
|
152 } |
|
153 #ifdef UNICODE |
|
154 CleanupStack::PopAndDestroy(); //unicodeConverter |
|
155 #endif |
|
156 if (!automatic) |
|
157 { |
|
158 TheTest.Printf(_L("\n [press any key]\n")); |
|
159 TheTest.Getch(); // get and ignore character |
|
160 } |
|
161 CleanupStack::PopAndDestroy(2); //store +stream |
|
162 fsSession.Close(); |
|
163 } |
|
164 |
|
165 |
|
166 void CVersitTest::SaveFileVersitL(/*CVersitParser*/Versit::TVersitCharSet aDefaultCharSet) |
|
167 // Save iParser into VersitFile |
|
168 { |
|
169 if (!iParser) |
|
170 return; |
|
171 |
|
172 RFs fsSession; |
|
173 User::LeaveIfError(fsSession.Connect()); |
|
174 fsSession.MkDirAll(_L("C:\\logs\\t_versit\\")); |
|
175 RFile file; |
|
176 // glenn hard code to test round trip |
|
177 iParser->SetDefaultCharSet(aDefaultCharSet); |
|
178 if (file.Replace(fsSession,_L("C:\\logs\\t_versit\\VersitFile"),EFileWrite)==KErrNone) |
|
179 iParser->ExternalizeL(file); |
|
180 file.Close(); |
|
181 fsSession.Close(); |
|
182 } |
|
183 |
|
184 void CVersitTest::CheckIsValidLabelL() |
|
185 { |
|
186 TInt pos; |
|
187 if(CVersitParser::IsValidLabel(_L("abcdefghijklmnopqrstuvwxyz"), pos)) |
|
188 TheTest.Printf(_L("\n test passed\n")); |
|
189 else |
|
190 TheTest.Printf(_L("\n test failed, pos = %d\n"), pos); |
|
191 |
|
192 if(CVersitParser::IsValidLabel(_L("abcd:"), pos)) |
|
193 TheTest.Printf(_L("\n test failed, pos = %d\n"), pos); |
|
194 else |
|
195 TheTest.Printf(_L("\n test passed\n")); |
|
196 |
|
197 if(CVersitParser::IsValidLabel(_L("ab[c]d"), pos)) |
|
198 TheTest.Printf(_L("\n test failed, pos = %d\n"), pos); |
|
199 else |
|
200 TheTest.Printf(_L("\n test passed\n")); |
|
201 |
|
202 if(CVersitParser::IsValidLabel(_L("abc]d"), pos)) |
|
203 TheTest.Printf(_L("\n test failed, pos = %d\n"), pos); |
|
204 else |
|
205 TheTest.Printf(_L("\n test passed\n")); |
|
206 |
|
207 if(CVersitParser::IsValidLabel(_L(",abcd"), pos)) |
|
208 TheTest.Printf(_L("\n test failed, pos = %d\n"), pos); |
|
209 else |
|
210 TheTest.Printf(_L("\n test passed\n")); |
|
211 } |
|
212 |
|
213 // |
|
214 // CVCalTest |
|
215 // |
|
216 |
|
217 void CVCalTest::LoadFileVersitL() |
|
218 // Read VCalendar.vcs into iVersit |
|
219 { |
|
220 if (iParser == NULL) |
|
221 iParser = CParserVCal::NewL(); |
|
222 RFs fsSession; |
|
223 User::LeaveIfError(fsSession.Connect()); |
|
224 RFile file; |
|
225 if (file.Open(fsSession,_L("C:\\VCalendar.vcs"),EFileRead)==KErrNone) |
|
226 { |
|
227 TInt start=0; |
|
228 iParser->InternalizeL(file,start); |
|
229 } |
|
230 file.Close(); |
|
231 fsSession.Close(); |
|
232 } |
|
233 |
|
234 void CVCalTest::BuildVersitL() |
|
235 { |
|
236 iParser = CParserVCal::NewL(); |
|
237 iParser->SetDefaultCharSet(Versit::EISO88597CharSet); |
|
238 CParserPropertyValue* value = CParserPropertyValueHBufC::NewL(_L("TEST!!!")); |
|
239 CParserProperty* property = CParserProperty::NewL(*value, KVersitTokenDESCRIPTION, NULL); |
|
240 iParser->AddPropertyL(property); //takes ownership |
|
241 CParserVCalEntity* entity = CParserVCalEntity::NewL(); |
|
242 entity->SetEntityNameL(KVersitVarTokenVTODO); |
|
243 CParserPropertyValue* value1 = CParserPropertyValueHBufC::NewL(_L("TEST!!!")); |
|
244 CParserProperty* property1 = CParserProperty::NewL(*value1, KVersitTokenDESCRIPTION, NULL); |
|
245 entity->AddPropertyL(property1); |
|
246 iParser->AddEntityL(entity); |
|
247 CArrayPtr<CVersitParser>* entities = iParser->EntityL(KVersitVarTokenVTODO,EFalse); |
|
248 if (entities == NULL) |
|
249 User::Leave(KErrNotFound); |
|
250 CArrayPtr<CParserProperty>* properties = (*entities)[0]->PropertyL(/*KVersitVarTokenDESCRIPTION*/KVersitTokenDESCRIPTION, TUid::Uid(KVersitPropertyHBufCUid), EFalse); |
|
251 if (properties == NULL) |
|
252 User::Leave(KErrNotFound); |
|
253 delete entities; |
|
254 delete properties; |
|
255 } |
|
256 |
|
257 // |
|
258 // CVCardTest |
|
259 // |
|
260 |
|
261 void CVCardTest::LoadFileVersitL() |
|
262 // Read VCard.vcf into iVersit |
|
263 { |
|
264 if (iParser == NULL) |
|
265 iParser = CParserVCard::NewL(); |
|
266 RFs fsSession; |
|
267 User::LeaveIfError(fsSession.Connect()); |
|
268 RFile file; |
|
269 if (file.Open(fsSession,_L("C:\\VCard.vcf"),EFileRead)==KErrNone) |
|
270 { |
|
271 TInt start=0; |
|
272 iParser->InternalizeL(file,start); |
|
273 } |
|
274 file.Close(); |
|
275 fsSession.Close(); |
|
276 } |
|
277 |
|
278 void CVCardTest::BuildVersitL() |
|
279 { |
|
280 iParser = CParserVCard::NewL(); |
|
281 iParser->SetDefaultCharSet(Versit::EISO88597CharSet); |
|
282 RFs fsSession; |
|
283 User::LeaveIfError(fsSession.Connect()); |
|
284 CParserPropertyValue* value = CParserPropertyValueHBufC::NewL(_L("TEST!!!")); |
|
285 CParserProperty* property = CParserGroupedProperty::NewL(*value, KVersitTokenFN, NULL, NULL); |
|
286 iParser->AddPropertyL(property); //takes ownership |
|
287 CArrayPtr<CParserProperty>* properties = iParser->PropertyL(KVersitTokenFN, TUid::Uid(KVersitPropertyHBufCUid), EFalse); |
|
288 if (property == NULL) |
|
289 User::Leave(KErrNotFound); |
|
290 delete properties; |
|
291 fsSession.Close(); |
|
292 } |
|
293 |
|
294 // |
|
295 // Globals |
|
296 // |
|
297 |
|
298 void Help() |
|
299 { |
|
300 TheTest.Printf(_L("\n\n\nFiles must be placed in:")); |
|
301 TheTest.Printf(_L("\nC: for marm")); |
|
302 TheTest.Printf(_L("\n\\epoc32\\wins\\c for wins")); |
|
303 TheTest.Printf(_L("\n\nc:\\VersitIn file contains stream-internalized sample parse")); |
|
304 TheTest.Printf(_L("\nc:\\VersitOut file contains most recently stream-externalized parse")); |
|
305 TheTest.Printf(_L("\nc:\\VersitFile contains most recently file-externalized parse")); |
|
306 TheTest.Printf(_L("\nRename any sample file to be tested as suggested and choose options 1 and 2")); |
|
307 TheTest.Printf(_L("\nPress any key to scroll line by line through an externalized model")); |
|
308 TheTest.Printf(_L("\n'q' returns to menu")); |
|
309 TheTest.Printf(_L("\n(Press any key)\n\n")); |
|
310 TheTest.Getch(); |
|
311 } |
|
312 |
|
313 TInt Menu() |
|
314 { |
|
315 TheTest.Printf(_L("\n\n\nTest:")); |
|
316 TheTest.Printf(_L("\n\n1. Internalize c:\\vcalendar.vcs")); |
|
317 TheTest.Printf(_L("\n2. Internalize c:\\vcard.vcf")); |
|
318 TheTest.Printf(_L("\n3. Internalize full vcal test")); |
|
319 TheTest.Printf(_L("\n4. Internalize full vcard test")); |
|
320 TheTest.Printf(_L("\n5. Build up vcal dynamically")); |
|
321 TheTest.Printf(_L("\n6. Build up vcard dynamically")); |
|
322 TheTest.Printf(_L("\n7. Externalize current object")); |
|
323 TheTest.Printf(_L("\n8. Externalize object to c:\\VersitFile")); |
|
324 TheTest.Printf(_L("\n9. Externalize object to c:\\VersitFile using ISO-X charset")); |
|
325 TheTest.Printf(_L("\n0. Test IsValidlabel() method")); |
|
326 TheTest.Printf(_L("\na. Timed full vCard internalize x 100")); |
|
327 TheTest.Printf(_L("\nb. Internalize c:\\vcard.vcf (QP encoding, UTF8 charset)")); |
|
328 TheTest.Printf(_L("\nc. Internalize c:\\vcard.vcf (QP encoding, UTF7 charset)")); |
|
329 TheTest.Printf(_L("\nd. Internalize c:\\vcard.vcf (QP encoding, ISO x charsets)")); |
|
330 // |
|
331 //Change 26/01/2001 |
|
332 //#001 |
|
333 //Insert Start : Character sets for Chinese are added. |
|
334 TheTest.Printf(_L("\ne. Internalize c:\\vcard.vcf (QP encoding, GBK charsets)")); |
|
335 TheTest.Printf(_L("\nf. Internalize c:\\vcard.vcf (QP encoding, GB2312 charsets)")); |
|
336 TheTest.Printf(_L("\ng. Internalize c:\\vcard.vcf (QP encoding, Big5 charsets)")); |
|
337 TheTest.Printf(_L("\ni. Internalize c:\\vcalendar.vcs (QP encoding, GBK charsets)")); |
|
338 TheTest.Printf(_L("\nj. Internalize c:\\vcalendar.vcs (QP encoding, GB2312 charsets)")); |
|
339 TheTest.Printf(_L("\nk. Internalize c:\\vcalendar.vcs (QP encoding, Big5 charsets)")); |
|
340 TheTest.Printf(_L("\nl. Internalize c:\\vcalendar.vcs (QP encoding, UTF8 charset)")); |
|
341 TheTest.Printf(_L("\nm. Internalize c:\\vcalendar.vcs (QP encoding, UTF7 charset)")); |
|
342 TheTest.Printf(_L("\nn. Externalize object to c:\\VersitFile (QP encoding Base64, GBK charset)")); |
|
343 TheTest.Printf(_L("\no. Externalize object to c:\\VersitFile (QP encoding Base64, GB2312 charset)")); |
|
344 TheTest.Printf(_L("\np. Externalize object to c:\\VersitFile (QP encoding Base64, Big5 charset)")); |
|
345 TheTest.Printf(_L("\nr. Externalize object to c:\\VersitFile (QP UTF-8 charset)")); |
|
346 TheTest.Printf(_L("\ns. Externalize object to c:\\VersitFile (QP UTF-7 charset)")); |
|
347 TheTest.Printf(_L("\nt. Externalize object to c:\\VersitFile (SHIFT_JIS charset)")); |
|
348 TheTest.Printf(_L("\nu. Internalize object from c:\\vCard.vcf (SHIFT_JIS charset)")); |
|
349 //Insert End |
|
350 // |
|
351 TheTest.Printf(_L("\nh. Help")); |
|
352 TheTest.Printf(_L("\nq. Quit\n\n")); |
|
353 return (TheTest.Getch()); |
|
354 } |
|
355 |
|
356 TInt DoTestL(TInt aChoice) |
|
357 { |
|
358 TInt error=KErrNone; |
|
359 switch(aChoice) |
|
360 { |
|
361 case 'h': |
|
362 case 'H': |
|
363 Help(); |
|
364 break; |
|
365 case '1': |
|
366 if (test) |
|
367 CleanupStack::PopAndDestroy(test); |
|
368 |
|
369 |
|
370 TheTest.Next(_L("\nVCalendar.vcs must be in c: in order to internalize it\n")); |
|
371 test=new(ELeave)CVCalTest; |
|
372 CleanupStack::PushL(test); |
|
373 TRAP(error,test->LoadFileVersitL()); |
|
374 break; |
|
375 case '2': |
|
376 if (test) |
|
377 CleanupStack::PopAndDestroy(test); |
|
378 |
|
379 |
|
380 TheTest.Next(_L("\nVCard.vcf must be in c: in order to internalize it\n")); |
|
381 test=new(ELeave)CVCardTest; |
|
382 CleanupStack::PushL(test); |
|
383 TRAP(error,test->LoadFileVersitL()); |
|
384 break; |
|
385 case '3': |
|
386 if (test) |
|
387 CleanupStack::PopAndDestroy(test); |
|
388 |
|
389 TheTest.Next(_L("\nCreate a sample vCal in file VersitIn and internalize it\n")); |
|
390 test=new(ELeave)CVCalTest; |
|
391 CleanupStack::PushL(test); |
|
392 test->GetSampleVersitL(); |
|
393 TRAP(error,test->StreamInL()); // run tests |
|
394 break; |
|
395 case '4': |
|
396 { |
|
397 if (test) |
|
398 CleanupStack::PopAndDestroy(test); |
|
399 |
|
400 |
|
401 TheTest.Next(_L("\nCreate a sample vCard in file VersitIn and internalize it\n")); |
|
402 test = new(ELeave) CVCardTest; |
|
403 CleanupStack::PushL(test); |
|
404 test->GetSampleVersitL(); |
|
405 TRAP(error,test->StreamInL()); // run tests |
|
406 break; |
|
407 } |
|
408 case '5': |
|
409 if (test) |
|
410 CleanupStack::PopAndDestroy(test); |
|
411 |
|
412 |
|
413 TheTest.Next(_L("\nBuild up vcal dynamically\n")); |
|
414 test=new(ELeave)CVCalTest; |
|
415 CleanupStack::PushL(test); |
|
416 test->BuildVersitL(); |
|
417 break; |
|
418 case '6': |
|
419 if (test) |
|
420 CleanupStack::PopAndDestroy(test); |
|
421 |
|
422 |
|
423 TheTest.Next(_L("\nBuild up vcard dynamically\n")); |
|
424 test=new(ELeave)CVCardTest; |
|
425 CleanupStack::PushL(test); |
|
426 test->BuildVersitL(); |
|
427 |
|
428 |
|
429 TheTest.Next(_L("\nExternalize object\n")); |
|
430 if (test) |
|
431 TRAP(error,test->StreamOutL()); // run tests |
|
432 break; |
|
433 case '7': |
|
434 |
|
435 |
|
436 TheTest.Next(_L("\nExternalize object\n")); |
|
437 if (test) |
|
438 TRAP(error,test->StreamOutL()); // run tests |
|
439 break; |
|
440 case '8': |
|
441 |
|
442 |
|
443 TheTest.Next(_L("\n Externalize object to VersitFile\n")); |
|
444 if (test) |
|
445 TRAP(error,test->SaveFileVersitL()); // run tests |
|
446 break; |
|
447 case '9': |
|
448 |
|
449 |
|
450 TheTest.Next(_L("\n Externalize object to VersitFile using ISO-X charset\n")); |
|
451 if (test) |
|
452 TRAP(error,test->SaveFileVersitL(Versit::EISO88592CharSet)); // run tests |
|
453 break; |
|
454 case '0': |
|
455 if (test) |
|
456 CleanupStack::PopAndDestroy(test); |
|
457 |
|
458 |
|
459 TheTest.Next(_L("\n Test IsValidLabel()\n")); |
|
460 test=new(ELeave)CVCalTest; |
|
461 CleanupStack::PushL(test); |
|
462 test->CheckIsValidLabelL(); // run tests |
|
463 break; |
|
464 case 'a': |
|
465 case 'A': |
|
466 { |
|
467 if (test) |
|
468 CleanupStack::PopAndDestroy(test); |
|
469 |
|
470 |
|
471 TheTest.Next(_L("\n VCard test internalize x 100\n")); |
|
472 test = new(ELeave) CVCardTest; |
|
473 CleanupStack::PushL(test); |
|
474 TTime start; |
|
475 start.UniversalTime(); |
|
476 TTime finish; |
|
477 TInt i; |
|
478 for(i = 0; i < 100 && error ==KErrNone; i++) |
|
479 { |
|
480 test->GetSampleVersitL(); |
|
481 TRAP(error, test->StreamInL()); // run tests |
|
482 delete test->iParser; // delete parser after each test or it gets HUGE and we run out of memory |
|
483 test->iParser=NULL; |
|
484 } |
|
485 finish.UniversalTime(); |
|
486 TheTest.Printf(_L("\nTook %d microseconds for %i tests\n"), finish.MicroSecondsFrom(start).Int64(), i); |
|
487 break; |
|
488 } |
|
489 |
|
490 case 'b': |
|
491 case 'B': |
|
492 { |
|
493 if (test) |
|
494 CleanupStack::PopAndDestroy(test); |
|
495 |
|
496 |
|
497 TheTest.Next(_L("\n VCard.vcf internalize (QP encoding, UTF8 charset)\n")); |
|
498 test = new(ELeave) CVCardTest; |
|
499 CleanupStack::PushL(test); |
|
500 test->iParser = CParserVCard::NewL(); |
|
501 test->iParser->SetDefaultCharSet(Versit::EUTF8CharSet); |
|
502 TRAP(error,test->LoadFileVersitL()); |
|
503 break; |
|
504 } |
|
505 case 'c': |
|
506 case 'C': |
|
507 { |
|
508 if (test) |
|
509 CleanupStack::PopAndDestroy(test); |
|
510 |
|
511 |
|
512 TheTest.Next(_L("\n VCard.vcf internalize (QP encoding, UTF7 charset)\n")); |
|
513 test = new(ELeave) CVCardTest; |
|
514 CleanupStack::PushL(test); |
|
515 test->iParser = CParserVCard::NewL(); |
|
516 test->iParser->SetDefaultCharSet(Versit::EUTF7CharSet); |
|
517 TRAP(error,test->LoadFileVersitL()); |
|
518 break; |
|
519 } |
|
520 case 'd': |
|
521 case 'D': |
|
522 { |
|
523 if (test) |
|
524 CleanupStack::PopAndDestroy(test); |
|
525 |
|
526 |
|
527 TheTest.Next(_L("\n VCard.vcf internalize (QP encoding, ISO X charset)\n")); |
|
528 test = new(ELeave) CVCardTest; |
|
529 CleanupStack::PushL(test); |
|
530 test->iParser = CParserVCard::NewL(); |
|
531 test->iParser->SetDefaultEncoding(Versit::EQuotedPrintableEncoding); |
|
532 test->iParser->SetDefaultCharSet(Versit::EISO88592CharSet); |
|
533 TRAP(error,test->LoadFileVersitL()); |
|
534 if (error) |
|
535 break; |
|
536 |
|
537 test->iParser->SetDefaultCharSet(Versit::EISO88592CharSet); |
|
538 TRAP(error,test->LoadFileVersitL()); |
|
539 if (error) |
|
540 break; |
|
541 |
|
542 test->iParser->SetDefaultCharSet(Versit::EISO88594CharSet); |
|
543 TRAP(error,test->LoadFileVersitL()); |
|
544 if (error) |
|
545 break; |
|
546 |
|
547 test->iParser->SetDefaultCharSet(Versit::EISO88595CharSet); |
|
548 TRAP(error,test->LoadFileVersitL()); |
|
549 if (error) |
|
550 break; |
|
551 |
|
552 test->iParser->SetDefaultCharSet(Versit::EISO88597CharSet); |
|
553 TRAP(error,test->LoadFileVersitL()); |
|
554 if (error) |
|
555 break; |
|
556 |
|
557 test->iParser->SetDefaultCharSet(Versit::EISO88599CharSet); |
|
558 TRAP(error,test->LoadFileVersitL()); |
|
559 break; |
|
560 } |
|
561 // |
|
562 //Change 31/01/2001 |
|
563 //#002 |
|
564 //Insert Start : Character sets for Chinese are added. |
|
565 // This is to test the default character sets and encodings for decoding non-standard Versit object in vCard. |
|
566 case 'e': //GBK |
|
567 case 'E': |
|
568 { |
|
569 if (test) |
|
570 CleanupStack::PopAndDestroy(test); |
|
571 |
|
572 TheTest.Next(_L("\n VCard.vcf internalize (QP encoding, GBK charset)\n")); |
|
573 test = new(ELeave) CVCardTest; |
|
574 CleanupStack::PushL(test); |
|
575 test->iParser = CParserVCard::NewL(); |
|
576 test->iParser->SetDefaultEncoding(Versit::ENoEncoding); |
|
577 test->iParser->SetDefaultCharSet(Versit::EGBKCharSet); |
|
578 TRAP(error,test->LoadFileVersitL()); |
|
579 break; |
|
580 } |
|
581 case 'f': //GB2312 |
|
582 case 'F': |
|
583 { |
|
584 if (test) |
|
585 CleanupStack::PopAndDestroy(test); |
|
586 |
|
587 |
|
588 TheTest.Next(_L("\n VCard.vcf internalize (QP encoding, GB2312 charset)\n")); |
|
589 test = new(ELeave) CVCardTest; |
|
590 CleanupStack::PushL(test); |
|
591 test->iParser = CParserVCard::NewL(); |
|
592 test->iParser->SetDefaultEncoding(Versit::ENoEncoding); |
|
593 test->iParser->SetDefaultCharSet(Versit::EGB231280CharSet); |
|
594 TRAP(error,test->LoadFileVersitL()); |
|
595 break; |
|
596 } |
|
597 case 'g': //Big5 |
|
598 case 'G': |
|
599 { |
|
600 if (test) |
|
601 CleanupStack::PopAndDestroy(test); |
|
602 |
|
603 |
|
604 TheTest.Next(_L("\n VCard.vcf internalize (QP encoding, Big5 charset)\n")); |
|
605 test = new(ELeave) CVCardTest; |
|
606 CleanupStack::PushL(test); |
|
607 test->iParser = CParserVCard::NewL(); |
|
608 test->iParser->SetDefaultEncoding(Versit::ENoEncoding); |
|
609 test->iParser->SetDefaultCharSet(Versit::EBIG5CharSet); |
|
610 TRAP(error,test->LoadFileVersitL()); |
|
611 break; |
|
612 } |
|
613 // This is to test the default character sets and encodings for decoding non-standard Versit object in vCal. |
|
614 case 'i': //GBK |
|
615 case 'I': |
|
616 { |
|
617 if (test) |
|
618 CleanupStack::PopAndDestroy(test); |
|
619 |
|
620 |
|
621 TheTest.Next(_L("\nVCalendar.vcs internalize (QP encoding, GBK charset)\n")); |
|
622 test = new(ELeave) CVCalTest; |
|
623 CleanupStack::PushL(test); |
|
624 test->iParser = CParserVCal::NewL(); |
|
625 test->iParser->SetDefaultEncoding(Versit::ENoEncoding); |
|
626 test->iParser->SetDefaultCharSet(Versit::EGBKCharSet); |
|
627 TRAP(error,test->LoadFileVersitL()); |
|
628 break; |
|
629 } |
|
630 case 'j': //GB2312 |
|
631 case 'J': |
|
632 { |
|
633 if (test) |
|
634 CleanupStack::PopAndDestroy(test); |
|
635 |
|
636 |
|
637 TheTest.Next(_L("\n VCalendar.vcs internalize (QP encoding, GB2312 charset)\n")); |
|
638 test = new(ELeave) CVCalTest; |
|
639 CleanupStack::PushL(test); |
|
640 test->iParser = CParserVCal::NewL(); |
|
641 test->iParser->SetDefaultEncoding(Versit::ENoEncoding); |
|
642 test->iParser->SetDefaultCharSet(Versit::EGB231280CharSet); |
|
643 TRAP(error,test->LoadFileVersitL()); |
|
644 break; |
|
645 } |
|
646 case 'k': //Big5 |
|
647 case 'K': |
|
648 { |
|
649 if (test) |
|
650 CleanupStack::PopAndDestroy(test); |
|
651 |
|
652 TheTest.Next(_L("\n@VCalendar.vcs internalize (QP encoding, Big5 charset)\n")); |
|
653 test = new(ELeave) CVCalTest; |
|
654 CleanupStack::PushL(test); |
|
655 test->iParser = CParserVCal::NewL(); |
|
656 test->iParser->SetDefaultEncoding(Versit::ENoEncoding); |
|
657 test->iParser->SetDefaultCharSet(Versit::EBIG5CharSet); |
|
658 TRAP(error,test->LoadFileVersitL()); |
|
659 break; |
|
660 } |
|
661 case 'l': |
|
662 case 'L': |
|
663 { |
|
664 if (test) |
|
665 CleanupStack::PopAndDestroy(test); |
|
666 |
|
667 |
|
668 TheTest.Next(_L("\nVCalendar.vcs internalize (QP encoding, UTF8 charset)\n")); |
|
669 test = new(ELeave) CVCalTest; |
|
670 CleanupStack::PushL(test); |
|
671 test->iParser = CParserVCal::NewL(); |
|
672 test->iParser->SetDefaultEncoding(Versit::ENoEncoding); |
|
673 test->iParser->SetDefaultCharSet(Versit::EUTF8CharSet); |
|
674 TRAP(error,test->LoadFileVersitL()); |
|
675 break; |
|
676 } |
|
677 case 'm': |
|
678 case 'M': |
|
679 { |
|
680 if (test) |
|
681 CleanupStack::PopAndDestroy(test); |
|
682 |
|
683 |
|
684 TheTest.Next(_L("\nVCalendar.vcs internalize (QP encoding, UTF7 charset)\n")); |
|
685 test = new(ELeave) CVCalTest; |
|
686 CleanupStack::PushL(test); |
|
687 test->iParser = CParserVCal::NewL(); |
|
688 test->iParser->SetDefaultEncoding(Versit::ENoEncoding); |
|
689 test->iParser->SetDefaultCharSet(Versit::EUTF7CharSet); |
|
690 TRAP(error,test->LoadFileVersitL()); |
|
691 break; |
|
692 } |
|
693 // This is to test the default character sets and encodings of GBK/GB2312/Big5 for the encoding versit object. |
|
694 case 'n': //GBK |
|
695 case 'N': |
|
696 { |
|
697 |
|
698 TheTest.Next(_L("\nExternalize object to VersitFile (QP encoding Base64, GBK charset)\n")); |
|
699 if (test) |
|
700 if (test->iParser) |
|
701 { |
|
702 test->iParser->SetDefaultEncoding(Versit::EBase64Encoding); |
|
703 TRAP(error,test->SaveFileVersitL(Versit::EGBKCharSet)); // run tests |
|
704 } |
|
705 break; |
|
706 } |
|
707 case 'o': //GB2312 |
|
708 case 'O': |
|
709 { |
|
710 |
|
711 TheTest.Next(_L("\nExternalize object to VersitFile (QP encoding Base64, GB2312 charset)\n")); |
|
712 if (test) |
|
713 if (test->iParser) |
|
714 { |
|
715 test->iParser->SetDefaultEncoding(Versit::EBase64Encoding); |
|
716 TRAP(error,test->SaveFileVersitL(Versit::EGB231280CharSet)); // run tests |
|
717 } |
|
718 break; |
|
719 } |
|
720 case 'p': //Big5 |
|
721 case 'P': |
|
722 { |
|
723 |
|
724 TheTest.Next(_L("\nExternalize object to VersitFile (QP encoding Base64, Big5 charset)\n")); |
|
725 if (test) |
|
726 if (test->iParser) |
|
727 { |
|
728 test->iParser->SetDefaultEncoding(Versit::EBase64Encoding); |
|
729 TRAP(error,test->SaveFileVersitL(Versit::EBIG5CharSet)); // run tests |
|
730 } |
|
731 break; |
|
732 } |
|
733 case 'r': //UTF-8 |
|
734 case 'R': |
|
735 { |
|
736 |
|
737 TheTest.Next(_L("\nExternalize object to VersitFile (QP UTF-8 charset)\n")); |
|
738 if (test) |
|
739 if (test->iParser) |
|
740 { |
|
741 TRAP(error,test->SaveFileVersitL(Versit::EUTF8CharSet)); // run tests |
|
742 } |
|
743 break; |
|
744 } |
|
745 case 's': //UTF-7 |
|
746 case 'S': |
|
747 { |
|
748 |
|
749 TheTest.Next(_L("\nExternalize object to VersitFile (QP UTF-7 charset)\n")); |
|
750 if (test) |
|
751 if (test->iParser) |
|
752 { |
|
753 TRAP(error,test->SaveFileVersitL(Versit::EUTF7CharSet)); // run tests |
|
754 } |
|
755 break; |
|
756 } |
|
757 case 't': //SHIFT_JIS externalize |
|
758 case 'T': |
|
759 { |
|
760 |
|
761 TheTest.Next(_L("\nExternalize object to VersitFile (SHIFT_JIS charset)\n")); |
|
762 if (test) |
|
763 if (test->iParser) |
|
764 { |
|
765 TRAP(error,test->SaveFileVersitL(Versit::EShiftJISCharSet)); // run tests |
|
766 } |
|
767 break; |
|
768 } |
|
769 case 'u': //SHIFT_JIS internalize |
|
770 case 'U': |
|
771 { |
|
772 if (test) |
|
773 CleanupStack::PopAndDestroy(test); |
|
774 |
|
775 |
|
776 TheTest.Next(_L("\nvCard.vcf internalize (SHIFT_JIS charset)\n")); |
|
777 test = new(ELeave) CVCardTest; |
|
778 CleanupStack::PushL(test); |
|
779 test->iParser = CParserVCard::NewL(); |
|
780 test->iParser->SetDefaultEncoding(Versit::ENoEncoding); |
|
781 test->iParser->SetDefaultCharSet(Versit::EShiftJISCharSet); |
|
782 TRAP(error,test->LoadFileVersitL()); |
|
783 break; |
|
784 } |
|
785 case 'z': |
|
786 case 'Z': |
|
787 { |
|
788 TInt testnumber='0'; |
|
789 automatic=ETrue; |
|
790 FOREVER |
|
791 { |
|
792 if (DoTestL(testnumber)!=KErrNone) |
|
793 { |
|
794 _LIT(KContinue,"\n\nFAILED!!! Test: '%c', Press a key to continue\n"); |
|
795 TheTest.Printf(KContinue, testnumber); |
|
796 TheTest.Getch(); |
|
797 } |
|
798 switch (testnumber) |
|
799 { |
|
800 case '9': |
|
801 testnumber='a'; |
|
802 break; |
|
803 case 'u': |
|
804 automatic=EFalse; |
|
805 return KErrNone; |
|
806 case 'g': |
|
807 case 'p': |
|
808 ++testnumber; |
|
809 default: |
|
810 ++testnumber; |
|
811 } |
|
812 } |
|
813 } |
|
814 default: |
|
815 { |
|
816 TheTest.Printf(_L("\nPressing wrong key")); |
|
817 error=KErrGeneral; |
|
818 break; |
|
819 } |
|
820 }; |
|
821 #ifdef MANUAL |
|
822 if (error) |
|
823 { |
|
824 TheTest.Printf(_L("\n Failed: leave code=%d\n"), error); |
|
825 User::LeaveIfError(error); |
|
826 } |
|
827 else |
|
828 TheTest.Printf(_L("\nTest passed!")); |
|
829 #else |
|
830 TheTest(error == KErrNone); |
|
831 #endif |
|
832 return error; |
|
833 } |
|
834 |
|
835 void SetupConsoleL() // initialize and call example code under cleanup stack |
|
836 { |
|
837 console=Console::NewL(_L("VersitTest"), |
|
838 TSize(76,18)); |
|
839 CleanupStack::PushL(console); |
|
840 //TInt choice=Menu(); |
|
841 DoTestL('z'); //Perform all tests. |
|
842 TInt choice='q'; //And quit |
|
843 |
|
844 while (!(choice=='q'||choice=='Q')) |
|
845 { |
|
846 DoTestL(choice); |
|
847 console->Printf(_L("\n\nPress any key to see available options, \ne.g. either quit or performing other testings")); |
|
848 console->Getch(); |
|
849 choice=Menu(); |
|
850 } |
|
851 if (test) |
|
852 CleanupStack::PopAndDestroy(test); |
|
853 CleanupStack::PopAndDestroy(console); |
|
854 } |
|
855 |
|
856 |
|
857 void DoAllTestsL() // initialize and call all tests |
|
858 { |
|
859 FileRegister = CTestRegister::NewLC(); |
|
860 |
|
861 DoTestL('z'); //Perform all tests. |
|
862 if (test) |
|
863 { |
|
864 CleanupStack::PopAndDestroy(test); |
|
865 } |
|
866 |
|
867 CleanupStack::PopAndDestroy(FileRegister); |
|
868 } |
|
869 |
|
870 /** |
|
871 @SYMTestCaseID PIM-TVERSIT-0001 |
|
872 */ |
|
873 GLDEF_C TInt E32Main() |
|
874 { |
|
875 __UHEAP_MARK; |
|
876 CTrapCleanup* cleanup=CTrapCleanup::New(); |
|
877 #ifdef MANUAL |
|
878 TRAPD(error,SetupConsoleL()); |
|
879 #else |
|
880 TheTest.Start(_L("@SYMTestCaseID PIM-TVERSIT-0001 TVersit")); |
|
881 TRAPD(error,DoAllTestsL()); |
|
882 UNUSED_VAR(error); //Used to supress build warnings |
|
883 |
|
884 TheTest.End(); |
|
885 TheTest.Close(); |
|
886 #endif |
|
887 delete cleanup; |
|
888 __UHEAP_MARKEND; |
|
889 return (KErrNone); |
|
890 } |