|
1 // Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // |
|
15 |
|
16 #include <e32std.h> |
|
17 #include <e32test.h> |
|
18 |
|
19 #include <versit.h> |
|
20 #include <vcal.h> |
|
21 #include <vcard.h> |
|
22 |
|
23 #include <coreappstest/testserver.h> |
|
24 |
|
25 _LIT(KTestName,"Versit OOM Tests"); |
|
26 |
|
27 LOCAL_D RFs fs; |
|
28 |
|
29 LOCAL_D RTest test(KTestName); |
|
30 |
|
31 _LIT8(KVCalendarAllMandatoryProperties, |
|
32 "BEGIN:VCALENDAR\r\n" |
|
33 "VERSION:1.0\r\n" |
|
34 "BEGIN:VEVENT\r\n" |
|
35 "CATEGORIES:APPOINTMENT;MEETING\r\n" |
|
36 "SUMMARY:Meeting with SyncML team\r\n" |
|
37 "DESCRIPTION:Check mandatory vCalendar compliance\r\n" |
|
38 "DTSTART:20010316T170000Z\r\n" |
|
39 "DTEND:20010316T180000Z\r\n" |
|
40 "STATUS:NEEDS ACTION\r\n" |
|
41 "X-EPOCAGENDAENTRYTYPE:APPOINTMENT\r\n" |
|
42 //"AALARM:\r\n" |
|
43 "AALARM:20010607T084500\r\n" |
|
44 "AALARM;TYPE=X-EPOCSOUND:20000110T084500Z;;0;Chimes\r\n" |
|
45 "END:VEVENT\r\n" |
|
46 "BEGIN:VTODO\r\n" |
|
47 "DESCRIPTION:To-do item\r\n" |
|
48 "PRIORITY:1\r\n" |
|
49 "DUE:20010316T000000Z\r\n" |
|
50 "COMPLETED:20010314T000000Z\r\n" |
|
51 //"RRULE:\r\n" Standard leave |
|
52 "RRULE:D1 #0\r\n" |
|
53 "RRULE:MD1 10+ #0\r\n" |
|
54 "RRULE:MP1 2+ MO #0\r\n" |
|
55 "RRULE:MP12 2+ MO #0\r\n" |
|
56 "RRULE:W1 MO #0\r\n" |
|
57 "RRULE:YM1 1 #0\r\n" |
|
58 "RRULE:W2 SU TU TH SA 19991130T000000\r\n" |
|
59 "RRULE:M1 19990821T000000\r\n" //invalid format from 9110 |
|
60 "CLASS:PUBLIC\r\n" |
|
61 //"PRIORITY:\r\n" KErrNotFound |
|
62 "PRIORITY:9\r\n" |
|
63 "DCREATED:20000113T000000Z\r\n" |
|
64 "LAST-MODIFIED:20000113T122400Z\r\n" |
|
65 "UID:28\r\n" |
|
66 "PRODID:-//Microsoft Corporation//Outlook 9.0 MIMEDIR//EN\r\n" |
|
67 "TRANSP:1\r\n" |
|
68 "END:VTODO\r\n" |
|
69 "END:VCALENDAR\r\n"); |
|
70 |
|
71 _LIT8(KVCardAllMandatoryProperties, |
|
72 "BEGIN:VCARD\r\n" |
|
73 "VERSION:2.1\r\n" |
|
74 "REV:20010608T125751Z\r\n" |
|
75 "TEL;CAR:\r\n" |
|
76 "TEL;HOME;VOICE:\r\n" |
|
77 "TEL;WORK;VOICE:\r\n" |
|
78 "N:Contact;Starfish;;\r\n" |
|
79 "NOTE:\r\n" |
|
80 "TEL;PAGER:\r\n" |
|
81 //"BDAY:\r\n" standard leave |
|
82 "ADR;WORK:;;;;;;\r\n" |
|
83 "ADR;HOME:;;;;;;\r\n" |
|
84 "URL:\r\n" |
|
85 "TEL;CELL:\r\n" |
|
86 "TEL;FAX;HOME:\r\n" |
|
87 "ORG:\r\n" |
|
88 "EMAIL;INTERNET:\r\n" |
|
89 "TEL;FAX;WORK:\r\n" |
|
90 "END:VCARD\r\n"); |
|
91 |
|
92 _LIT(KVCalImportFileName,"c:\\oomvcal.vcs"); |
|
93 _LIT(KVCalExportFileName,"c:\\oomvcal2.vcs"); |
|
94 _LIT(KVCardImportFileName,"c:\\oomvcard.vcf"); |
|
95 _LIT(KVCardExportFileName,"c:\\oomvcard2.vcf"); |
|
96 |
|
97 /** Defines an interface for Versit OOM tests */ |
|
98 class MVersitOOMTest |
|
99 { |
|
100 public: |
|
101 virtual void DoTestL() = 0; |
|
102 }; |
|
103 |
|
104 /** versit alarm creation OOM test */ |
|
105 class CVersitAlarmCreateTest: public CBase, public MVersitOOMTest |
|
106 { |
|
107 public: |
|
108 static CVersitAlarmCreateTest* NewLC(); |
|
109 ~CVersitAlarmCreateTest(); |
|
110 public: //From MVersitOOMTest |
|
111 void DoTestL(); |
|
112 private: |
|
113 CVersitAlarmCreateTest(); |
|
114 }; |
|
115 |
|
116 /** vCalendar import OOM test */ |
|
117 class CVersitVCalImportTest : public CBase, public MVersitOOMTest |
|
118 { |
|
119 public: |
|
120 static CVersitVCalImportTest* NewLC(); |
|
121 ~CVersitVCalImportTest(); |
|
122 public: //From MVersitOOMTest |
|
123 void DoTestL(); |
|
124 private: |
|
125 void CheckingImportResultL(CParserVCal& aVCalParser); |
|
126 CVersitVCalImportTest(); |
|
127 }; |
|
128 |
|
129 |
|
130 /** vCalendar export OOM test */ |
|
131 class CVersitVCalExportTest : public CBase, public MVersitOOMTest |
|
132 { |
|
133 public: |
|
134 static CVersitVCalExportTest* NewLC(); |
|
135 ~CVersitVCalExportTest(); |
|
136 public: //From MVersitOOMTest |
|
137 void DoTestL(); |
|
138 private: |
|
139 CVersitVCalExportTest(); |
|
140 }; |
|
141 |
|
142 |
|
143 /** vCard import OOM test */ |
|
144 class CVersitVCardImportTest : public CBase, public MVersitOOMTest |
|
145 { |
|
146 public: |
|
147 static CVersitVCardImportTest* NewLC(); |
|
148 ~CVersitVCardImportTest(); |
|
149 public: //From MVersitOOMTest |
|
150 void DoTestL(); |
|
151 private: |
|
152 CVersitVCardImportTest(); |
|
153 }; |
|
154 |
|
155 /** vCard export OOM test */ |
|
156 class CVersitVCardExportTest : public CBase, public MVersitOOMTest |
|
157 { |
|
158 public: |
|
159 static CVersitVCardExportTest* NewLC(); |
|
160 ~CVersitVCardExportTest(); |
|
161 public: //From MVersitOOMTest |
|
162 void DoTestL(); |
|
163 private: |
|
164 CVersitVCardExportTest(); |
|
165 }; |
|
166 |
|
167 // Cleanup callback for versit entities. |
|
168 GLREF_C void ResetAndDestroyArrayOfEntities(TAny* aObject) |
|
169 { |
|
170 CArrayPtr<CVersitParser>* array=REINTERPRET_CAST(CArrayPtr<CVersitParser>*,aObject); |
|
171 if (array) |
|
172 array->ResetAndDestroy(); |
|
173 delete array; |
|
174 } |
|
175 |
|
176 CVersitAlarmCreateTest* CVersitAlarmCreateTest::NewLC() |
|
177 { |
|
178 CVersitAlarmCreateTest* self = new(ELeave) CVersitAlarmCreateTest; |
|
179 CleanupStack::PushL(self); |
|
180 return self; |
|
181 } |
|
182 |
|
183 void CVersitAlarmCreateTest::DoTestL() |
|
184 { |
|
185 TDateTime date(2001,ENovember,1,0,15,0,0); |
|
186 TVersitDateTime* runtime = new(ELeave) TVersitDateTime(date, TVersitDateTime::EIsMachineLocal); |
|
187 CleanupStack::PushL(runtime); |
|
188 CVersitAlarm* alarm = CVersitAlarm::NewL(runtime,0,0,_L("Fanfare"),KNullDesC); |
|
189 CleanupStack::Pop(runtime); |
|
190 delete alarm; |
|
191 } |
|
192 |
|
193 CVersitAlarmCreateTest::~CVersitAlarmCreateTest() |
|
194 { |
|
195 } |
|
196 |
|
197 CVersitAlarmCreateTest::CVersitAlarmCreateTest() |
|
198 { |
|
199 } |
|
200 |
|
201 CVersitVCalImportTest* CVersitVCalImportTest::NewLC() |
|
202 { |
|
203 CVersitVCalImportTest* self = new(ELeave) CVersitVCalImportTest; |
|
204 CleanupStack::PushL(self); |
|
205 return self; |
|
206 } |
|
207 |
|
208 void CVersitVCalImportTest::DoTestL() |
|
209 { |
|
210 CParserVCal* parser = CParserVCal::NewL(); |
|
211 CleanupStack::PushL(parser); |
|
212 RFile infile; |
|
213 User::LeaveIfError(infile.Open(fs,KVCalImportFileName,EFileRead)); |
|
214 CleanupClosePushL(infile); |
|
215 RFileReadStream readStream(infile); |
|
216 CleanupClosePushL(readStream); |
|
217 parser->InternalizeL(readStream); |
|
218 CheckingImportResultL(*parser); |
|
219 CleanupStack::PopAndDestroy(3); |
|
220 } |
|
221 |
|
222 void CVersitVCalImportTest::CheckingImportResultL(CParserVCal& aVCalParser) |
|
223 { |
|
224 //Test get entities and properties without taking ownership |
|
225 CArrayPtr<CVersitParser>* entities = aVCalParser.EntityL(KVersitVarTokenVTODO,EFalse); |
|
226 test(entities != NULL); |
|
227 CleanupStack::PushL(entities); |
|
228 CArrayPtr<CParserProperty>* properties = (*entities)[0]->PropertyL(KVersitTokenRRULE, TUid::Uid(KVCalPropertyRecurrenceUid), EFalse); |
|
229 test(properties != NULL); |
|
230 delete properties; |
|
231 CleanupStack::PopAndDestroy(entities); |
|
232 |
|
233 //Test get entities and properties with taking ownership |
|
234 entities = aVCalParser.EntityL(KVersitVarTokenVEVENT,ETrue); |
|
235 test(entities != NULL); |
|
236 CleanupStack::PushL(TCleanupItem(ResetAndDestroyArrayOfEntities, entities)); |
|
237 properties = (*entities)[0]->PropertyL(KVersitTokenCATEGORIES, TUid::Uid(KVersitPropertyCDesCArrayUid), ETrue); |
|
238 test(properties != NULL); |
|
239 properties->ResetAndDestroy(); |
|
240 delete properties; |
|
241 CleanupStack::PopAndDestroy(entities); |
|
242 } |
|
243 |
|
244 CVersitVCalImportTest::CVersitVCalImportTest() |
|
245 { |
|
246 } |
|
247 |
|
248 CVersitVCalImportTest::~CVersitVCalImportTest() |
|
249 { |
|
250 } |
|
251 |
|
252 CVersitVCalExportTest* CVersitVCalExportTest::NewLC() |
|
253 { |
|
254 CVersitVCalExportTest* self = new(ELeave) CVersitVCalExportTest; |
|
255 CleanupStack::PushL(self); |
|
256 return self; |
|
257 } |
|
258 |
|
259 CVersitVCalExportTest::~CVersitVCalExportTest() |
|
260 { |
|
261 } |
|
262 |
|
263 void CVersitVCalExportTest::DoTestL() |
|
264 { |
|
265 CParserVCal* parser = CParserVCal::NewL(); |
|
266 CleanupStack::PushL(parser); |
|
267 CParserVCalEntity* entity = CParserVCalEntity::NewL(); |
|
268 CleanupStack::PushL(entity); |
|
269 entity->SetEntityNameL(KVersitVarTokenVEVENT); |
|
270 |
|
271 TInt KUidValue=0; |
|
272 CParserPropertyValueInt* intValue= new(ELeave) CParserPropertyValueInt(KUidValue); |
|
273 CleanupStack::PushL(intValue); |
|
274 CParserProperty* UIDprop = CParserProperty::NewL(*intValue, KVersitTokenUID, NULL); |
|
275 CleanupStack::Pop(intValue); |
|
276 entity->AddPropertyL(UIDprop); |
|
277 |
|
278 _LIT(KVCalDescription,"Small devices come in many shapes and sizes"); |
|
279 CParserPropertyValueHBufC* hbufValue = CParserPropertyValueHBufC::NewL(KVCalDescription); |
|
280 CleanupStack::PushL(hbufValue); |
|
281 CParserProperty* DESCRIPTIONprop = CParserProperty::NewL(*hbufValue, KVersitTokenDESCRIPTION, NULL); |
|
282 CleanupStack::Pop(hbufValue); |
|
283 entity->AddPropertyL(DESCRIPTIONprop); |
|
284 |
|
285 CleanupStack::Pop(entity); |
|
286 parser->AddEntityL(entity); |
|
287 |
|
288 RFile outfile; |
|
289 User::LeaveIfError(outfile.Replace(fs,KVCardExportFileName,EFileWrite)); |
|
290 CleanupClosePushL(outfile); |
|
291 RFileWriteStream writeStream(outfile); |
|
292 CleanupClosePushL(writeStream); |
|
293 parser->ExternalizeL(writeStream); |
|
294 CleanupStack::PopAndDestroy(3); |
|
295 } |
|
296 |
|
297 CVersitVCalExportTest::CVersitVCalExportTest() |
|
298 { |
|
299 } |
|
300 |
|
301 CVersitVCardImportTest* CVersitVCardImportTest::NewLC() |
|
302 { |
|
303 CVersitVCardImportTest* self = new(ELeave) CVersitVCardImportTest; |
|
304 CleanupStack::PushL(self); |
|
305 return self; |
|
306 } |
|
307 |
|
308 void CVersitVCardImportTest::DoTestL() |
|
309 { |
|
310 CParserVCard* parser = CParserVCard::NewL(); |
|
311 CleanupStack::PushL(parser); |
|
312 RFile infile; |
|
313 User::LeaveIfError(infile.Open(fs,KVCardImportFileName,EFileRead)); |
|
314 CleanupClosePushL(infile); |
|
315 RFileReadStream readStream(infile); |
|
316 CleanupClosePushL(readStream); |
|
317 parser->InternalizeL(readStream); |
|
318 CleanupStack::PopAndDestroy(3); |
|
319 } |
|
320 |
|
321 CVersitVCardImportTest::CVersitVCardImportTest() |
|
322 { |
|
323 } |
|
324 |
|
325 CVersitVCardImportTest::~CVersitVCardImportTest() |
|
326 { |
|
327 } |
|
328 |
|
329 CVersitVCardExportTest* CVersitVCardExportTest::NewLC() |
|
330 { |
|
331 CVersitVCardExportTest* self = new(ELeave) CVersitVCardExportTest; |
|
332 CleanupStack::PushL(self); |
|
333 return self; |
|
334 } |
|
335 |
|
336 CVersitVCardExportTest::~CVersitVCardExportTest() |
|
337 { |
|
338 } |
|
339 |
|
340 void CVersitVCardExportTest::DoTestL() |
|
341 { |
|
342 CParserVCard* parser = CParserVCard::NewL(); |
|
343 CleanupStack::PushL(parser); |
|
344 |
|
345 TTime lastModified; |
|
346 lastModified.UniversalTime(); |
|
347 TVersitDateTime* dateTime=new(ELeave)TVersitDateTime(lastModified.DateTime(),TVersitDateTime::EIsMachineLocal); |
|
348 CleanupStack::PushL(dateTime); |
|
349 CParserPropertyValueDateTime* valueDateTime=new(ELeave) CParserPropertyValueDateTime(dateTime); |
|
350 CleanupStack::Pop(dateTime); |
|
351 CleanupStack::PushL(valueDateTime); |
|
352 CParserGroupedProperty* property=CParserGroupedProperty::NewL(*valueDateTime,KVersitTokenREV,NULL,NULL); |
|
353 CleanupStack::Pop(valueDateTime); |
|
354 parser->AddPropertyL(property); |
|
355 |
|
356 RFile outfile; |
|
357 User::LeaveIfError(outfile.Replace(fs,KVCalExportFileName,EFileWrite)); |
|
358 CleanupClosePushL(outfile); |
|
359 RFileWriteStream writeStream(outfile); |
|
360 CleanupClosePushL(writeStream); |
|
361 parser->ExternalizeL(writeStream); |
|
362 CleanupStack::PopAndDestroy(3); |
|
363 } |
|
364 |
|
365 CVersitVCardExportTest::CVersitVCardExportTest() |
|
366 { |
|
367 } |
|
368 |
|
369 void runOOMTestL(MVersitOOMTest& aTest) |
|
370 { |
|
371 TInt ret=KErrNoMemory; |
|
372 TInt failAt=0; |
|
373 while (ret!=KErrNone) |
|
374 { |
|
375 failAt++; |
|
376 TBuf<200>indicator; |
|
377 indicator.Format(_L("Memory fail at \t%d\x0d\x0a"),failAt); |
|
378 if(failAt%100==0) |
|
379 test.Printf(indicator); |
|
380 __UHEAP_SETFAIL(RHeap::EDeterministic,failAt); |
|
381 __UHEAP_MARK; |
|
382 TRAP(ret, aTest.DoTestL()); |
|
383 __UHEAP_MARKEND; |
|
384 __UHEAP_RESET; |
|
385 if (ret!=KErrNoMemory&&ret!=KErrNone) |
|
386 { |
|
387 test.Printf(_L("Non standard error: %d\n"),ret); |
|
388 test.Getch(); |
|
389 } |
|
390 test(ret==KErrNoMemory||ret==KErrNone); |
|
391 } |
|
392 } |
|
393 |
|
394 LOCAL_C void ExpandCleanupStackL() |
|
395 { |
|
396 // reserve some space on the cleanup stack: |
|
397 {for (TInt ii=0;ii<1000;++ii) |
|
398 CleanupStack::PushL(&ii);} |
|
399 CleanupStack::Pop(1000); |
|
400 } |
|
401 void createTestFilesL() |
|
402 { |
|
403 RFile file; |
|
404 TInt err=file.Replace(fs,KVCalImportFileName, EFileWrite+EFileShareAny+EFileStreamText); |
|
405 User::LeaveIfError(err); |
|
406 file.Write(KVCalendarAllMandatoryProperties); |
|
407 file.Close(); |
|
408 |
|
409 err=file.Replace(fs,KVCardImportFileName, EFileWrite+EFileShareAny+EFileStreamText); |
|
410 User::LeaveIfError(err); |
|
411 file.Write(KVCardAllMandatoryProperties); |
|
412 file.Close(); |
|
413 } |
|
414 |
|
415 /** |
|
416 @SYMTestCaseID PIM-TOOM-0001 |
|
417 */ |
|
418 void runOOMTestsL() |
|
419 { |
|
420 User::LeaveIfError(fs.Connect()); |
|
421 CleanupClosePushL(fs); |
|
422 |
|
423 CTestRegister* TempFiles = CTestRegister::NewLC(); |
|
424 TempFiles->RegisterL(KVCalImportFileName); |
|
425 TempFiles->RegisterL(KVCalExportFileName); |
|
426 TempFiles->RegisterL(KVCardImportFileName); |
|
427 TempFiles->RegisterL(KVCardExportFileName); |
|
428 |
|
429 test.Start(_L("@SYMTestCaseID PIM-TOOM-0001 Test One")); |
|
430 createTestFilesL(); |
|
431 ExpandCleanupStackL(); |
|
432 |
|
433 _LIT(KTestvCalImport,"vCal Import Test\n"); |
|
434 test.Printf(KTestvCalImport); |
|
435 CVersitVCalImportTest* oomtest1 = CVersitVCalImportTest::NewLC(); |
|
436 runOOMTestL(*oomtest1); |
|
437 CleanupStack::PopAndDestroy(oomtest1); |
|
438 |
|
439 _LIT(KTestvCardImport,"vCard Import Test\n"); |
|
440 test.Printf(KTestvCardImport); |
|
441 CVersitVCardImportTest* oomtest2 = CVersitVCardImportTest::NewLC(); |
|
442 runOOMTestL(*oomtest2); |
|
443 CleanupStack::PopAndDestroy(oomtest2); |
|
444 |
|
445 _LIT(KTestvCalExport,"vCal Export Test\n"); |
|
446 test.Printf(KTestvCalExport); |
|
447 CVersitVCalExportTest* oomtest3 = CVersitVCalExportTest::NewLC(); |
|
448 runOOMTestL(*oomtest3); |
|
449 CleanupStack::PopAndDestroy(oomtest3); |
|
450 |
|
451 _LIT(KTestvCardExport,"vCard Export Test\n"); |
|
452 test.Printf(KTestvCardExport); |
|
453 CVersitVCardExportTest* oomtest4 = CVersitVCardExportTest::NewLC(); |
|
454 runOOMTestL(*oomtest4); |
|
455 CleanupStack::PopAndDestroy(oomtest4); |
|
456 |
|
457 _LIT(KTestVersitAlarm,"Versit Alarm OOM Test\n"); |
|
458 test.Printf(KTestVersitAlarm); |
|
459 CVersitAlarmCreateTest* oomtest5 = CVersitAlarmCreateTest::NewLC(); |
|
460 runOOMTestL(*oomtest5); |
|
461 CleanupStack::PopAndDestroy(oomtest5); |
|
462 |
|
463 test.End(); |
|
464 test.Close(); |
|
465 CleanupStack::PopAndDestroy(2); // TempFiles, fs |
|
466 } |
|
467 |
|
468 GLDEF_C TInt E32Main() |
|
469 { |
|
470 |
|
471 TTime startTime; |
|
472 startTime.UniversalTime(); |
|
473 |
|
474 __UHEAP_MARK; |
|
475 |
|
476 CTrapCleanup* theCleanup=CTrapCleanup::New(); |
|
477 TRAPD(ret,runOOMTestsL()); |
|
478 test(ret==KErrNone); |
|
479 delete theCleanup; |
|
480 |
|
481 __UHEAP_MARKEND; |
|
482 |
|
483 TTime finishTime; |
|
484 finishTime.UniversalTime(); |
|
485 TReal elapsed = (TReal)finishTime.MicroSecondsFrom(startTime).Int64(); |
|
486 test.Printf(_L("Elapsed time: %.4f\n"), elapsed/1000000); |
|
487 |
|
488 return(KErrNone); |
|
489 } |
|
490 |