|
1 // Copyright (c) 2004-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 #include <cntdb.h> |
|
19 #include "T_Sec_AsyncOpen.h" |
|
20 #include <coreappstest/testserver.h> |
|
21 |
|
22 // |
|
23 // Constants. |
|
24 // |
|
25 _LIT(KTestName,"T_Sec_AsyncOpen"); |
|
26 _LIT(KDbFileName,"c:T_Sec_AsyncOpen.cdb"); |
|
27 |
|
28 #ifndef __SYMBIAN_CNTMODEL_USE_SQLITE__ |
|
29 //That file is a contact model database from a Calypso device |
|
30 _LIT(KDatabaseV4, "Z:\\Core-Apps\\App-Engines\\CntModel\\Databases\\FormatV4.cdb"); |
|
31 _LIT(KDbOldVersionFilePath,"C:\\private\\10003A73\\OLDVERSION.CDB"); |
|
32 #else |
|
33 //Just use a SQlite file - this still tests async and sync openings of the file |
|
34 _LIT(KDatabaseV4, "Z:\\Core-Apps\\App-Engines\\CntModel\\Databases\\SQLite__Contacts.cdb"); |
|
35 _LIT(KDbOldVersionFilePath,"C:\\private\\10003A73\\SQLite__OLDVERSION.CDB"); |
|
36 #endif //__SYMBIAN_CNTMODEL_USE_SQLITE__ |
|
37 |
|
38 _LIT(KDbOldVersionFileName,"C:OldVersion.cdb"); |
|
39 |
|
40 _LIT(KDbDamaged,"c:Damaged.cdb"); |
|
41 _LIT(KDefaultDb,"c:Contacts.cdb"); |
|
42 _LIT(KDbFileNameNotExist,"c:NotHere.cdb"); |
|
43 |
|
44 _LIT(KThreadOpenAsync,"OpenAsync"); |
|
45 _LIT(KThreadOpenSync,"OpenSync"); |
|
46 const TInt KNumWaitLoops = 3; |
|
47 |
|
48 |
|
49 LOCAL_D RTest test(KTestName); |
|
50 |
|
51 // |
|
52 // CTestConductor. |
|
53 // |
|
54 |
|
55 CTestConductor* CTestConductor::NewL() |
|
56 { |
|
57 CTestConductor* self = new(ELeave) CTestConductor(); |
|
58 CleanupStack::PushL(self); |
|
59 self->ConstructL(); |
|
60 CleanupStack::Pop(); |
|
61 return self; |
|
62 } |
|
63 |
|
64 CTestConductor::~CTestConductor() |
|
65 { |
|
66 //state deleted during tests |
|
67 } |
|
68 |
|
69 CTestConductor::CTestConductor() : CActive(EPriorityStandard),iCurrentTestNumber(-1),iWaitCounter(0) |
|
70 { |
|
71 CActiveScheduler::Add(this); |
|
72 } |
|
73 |
|
74 void CTestConductor::ConstructL() |
|
75 { |
|
76 // Create the db files used in the tests |
|
77 iDb = CContactDatabase::ReplaceL(KDbDamaged); |
|
78 CleanupStack::PushL(iDb); |
|
79 iDb->DamageDatabaseL(0x666); |
|
80 CleanupStack::PopAndDestroy(iDb); |
|
81 |
|
82 iDb = CContactDatabase::ReplaceL(KDbFileName); |
|
83 delete iDb; |
|
84 |
|
85 iDb = CContactDatabase::ReplaceL(KDefaultDb); |
|
86 delete iDb; |
|
87 |
|
88 CopyCdbFileL(KDatabaseV4,KDbOldVersionFilePath); |
|
89 |
|
90 iDb = NULL; |
|
91 |
|
92 iTestError = KErrNone; |
|
93 |
|
94 NextTest(); |
|
95 CActiveScheduler::Start(); |
|
96 |
|
97 User::LeaveIfError(iTestError); |
|
98 } |
|
99 |
|
100 void CTestConductor::NextTest() |
|
101 { |
|
102 ++iCurrentTestNumber; |
|
103 TRequestStatus *pS = &iStatus; |
|
104 User::RequestComplete(pS,KErrNone); |
|
105 SetActive(); |
|
106 } |
|
107 |
|
108 |
|
109 void CTestConductor::RunL() |
|
110 { |
|
111 User::After(1000); |
|
112 switch (iCurrentTestNumber) |
|
113 { |
|
114 // Test One - Async Open of a Named Database |
|
115 case EAsyncOpenNamed: |
|
116 test.Next(_L("=== Async Open of Named Db")); |
|
117 |
|
118 SetActive(); |
|
119 iContactOpenOperation = CContactDatabase::Open(KDbFileName,iStatus); |
|
120 ++iCurrentTestNumber; |
|
121 |
|
122 break; |
|
123 |
|
124 // Check Test One Results |
|
125 case EAsyncOpenedNamed: |
|
126 test(iStatus.Int() == KErrNone); |
|
127 test.Printf(_L("=== Opened Async\n")); |
|
128 iDb = iContactOpenOperation->TakeDatabase(); |
|
129 |
|
130 test(iDb != NULL); |
|
131 delete iContactOpenOperation; |
|
132 delete iDb; |
|
133 |
|
134 NextTest(); |
|
135 break; |
|
136 |
|
137 // Test Two - Async Open of the Default Database |
|
138 case EAsyncOpenDefault: |
|
139 test.Next(_L("=== Async Open Default")); |
|
140 |
|
141 SetActive(); |
|
142 iContactOpenOperation = CContactDatabase::Open(iStatus); |
|
143 ++iCurrentTestNumber; |
|
144 |
|
145 break; |
|
146 |
|
147 // Check Test Two Results |
|
148 case EAsyncOpenedDefault: |
|
149 test(iStatus.Int() == KErrNone); |
|
150 test.Printf(_L("=== Opened Async Default \n")); |
|
151 iDb = iContactOpenOperation->TakeDatabase(); |
|
152 test(iDb != NULL); |
|
153 delete iContactOpenOperation; |
|
154 delete iDb; |
|
155 |
|
156 NextTest(); |
|
157 break; |
|
158 |
|
159 // Test Three - Attempted Async Open of a Non-Existent File |
|
160 case EAsyncOpenNonExistent: |
|
161 test.Next(_L("=== Attempted Open of Non-Existent File")); |
|
162 |
|
163 SetActive(); |
|
164 iContactOpenOperation = CContactDatabase::Open(KDbFileNameNotExist,iStatus); |
|
165 ++iCurrentTestNumber; |
|
166 |
|
167 break; |
|
168 |
|
169 // Check Test Three Results |
|
170 case EAsyncOpenedNonExistent: |
|
171 test.Printf(_L("=== Opened Non Existent Response\n")); |
|
172 test(iStatus.Int() == KErrNotFound); |
|
173 |
|
174 delete iContactOpenOperation; |
|
175 NextTest(); |
|
176 break; |
|
177 |
|
178 // Test Four - Cancel the Async Open |
|
179 case EAsyncCancelOpenDefault: |
|
180 test.Next(_L("=== Cancel Async Open")); |
|
181 |
|
182 |
|
183 SetActive(); |
|
184 iContactOpenOperation = CContactDatabase::Open(iStatus); |
|
185 ++iCurrentTestNumber; |
|
186 |
|
187 // Cancel the request |
|
188 delete iContactOpenOperation; |
|
189 |
|
190 break; |
|
191 |
|
192 // Check Test Four Results |
|
193 case EAsyncCanceledOpenedDefault: |
|
194 test.Printf(_L("=== Cancelled Async Open\n")); |
|
195 test(iStatus.Int() == KErrCancel); |
|
196 NextTest(); |
|
197 break; |
|
198 |
|
199 // Test Five - Async Open of a damaged Database |
|
200 case EAsyncOpenDamaged: |
|
201 test.Next(_L("Open a damaged database")); |
|
202 |
|
203 |
|
204 SetActive(); |
|
205 iContactOpenOperation = CContactDatabase::Open(KDbDamaged,iStatus); |
|
206 ++iCurrentTestNumber; |
|
207 |
|
208 break; |
|
209 |
|
210 // Check Test Five Results |
|
211 case EAsyncOpenedDamaged: |
|
212 test(iStatus.Int() == KErrNone); |
|
213 test.Printf(_L("=== Opened Damaged Db \n")); |
|
214 iDb = iContactOpenOperation->TakeDatabase(); |
|
215 test(iDb != NULL); |
|
216 delete iContactOpenOperation; |
|
217 delete iDb; |
|
218 |
|
219 NextTest(); |
|
220 |
|
221 break; |
|
222 |
|
223 // Test Six - Async Open of a Previous version of the Database |
|
224 case EAsyncOpenPreviousVersion: |
|
225 test.Next(_L("Open an old version database")); |
|
226 |
|
227 |
|
228 SetActive(); |
|
229 iContactOpenOperation = CContactDatabase::Open(KDbOldVersionFileName,iStatus); |
|
230 ++iCurrentTestNumber; |
|
231 |
|
232 break; |
|
233 |
|
234 // Check Test Six Results |
|
235 case EAsyncOpenedPreviousVersion: |
|
236 test(iStatus.Int() == KErrNone); |
|
237 test.Printf(_L("=== Opened Previoius Version Db \n")); |
|
238 |
|
239 iDb = iContactOpenOperation->TakeDatabase(); |
|
240 test(iDb != NULL); |
|
241 delete iContactOpenOperation; |
|
242 delete iDb; |
|
243 |
|
244 NextTest(); |
|
245 break; |
|
246 |
|
247 // Test Seven - Async Open of a Previous version of the Database, and an Async |
|
248 // call open of the same database in a different thread. |
|
249 case EOpenAsyncAndAsync: |
|
250 test.Next(_L("Open Async Then Sync")); |
|
251 |
|
252 |
|
253 // Copy Version 4 Db |
|
254 CopyCdbFileL(KDatabaseV4,KDbOldVersionFilePath); |
|
255 |
|
256 // Open Async |
|
257 SetActive(); |
|
258 iContactOpenOperation = CContactDatabase::Open(KDbOldVersionFileName,iStatus); |
|
259 ++iCurrentTestNumber; |
|
260 |
|
261 // Lauch Thread to Open Db Asynchronously |
|
262 CDbOpenLauncher::Create(KThreadOpenAsync, KThreadOpenAsync); |
|
263 break; |
|
264 |
|
265 // Check Test Seven Results |
|
266 case EOpenedAsyncAndAsync: |
|
267 test(iStatus.Int() == KErrNone); |
|
268 test.Printf(_L("=== Opened After Async Open Db \n")); |
|
269 |
|
270 iDb = iContactOpenOperation->TakeDatabase(); |
|
271 test(iDb != NULL); |
|
272 delete iContactOpenOperation; |
|
273 delete iDb; |
|
274 |
|
275 NextTest(); |
|
276 break; |
|
277 |
|
278 |
|
279 // Iterate through these states (allowing other thread to open asynchronously) |
|
280 case EWaitState: |
|
281 test.Printf(_L("=== Waiting in first thread \n")); |
|
282 iCurrentTestNumber = EWaitedState; |
|
283 SetActive(); |
|
284 iContactOpenOperation = CContactDatabase::Open(KDbOldVersionFileName,iStatus); |
|
285 |
|
286 break; |
|
287 |
|
288 case EWaitedState: |
|
289 |
|
290 test(iStatus.Int() == KErrNone); |
|
291 test.Printf(_L("=== Opened After Wait Db \n")); |
|
292 |
|
293 iDb = iContactOpenOperation->TakeDatabase(); |
|
294 test(iDb != NULL); |
|
295 delete iContactOpenOperation; |
|
296 delete iDb; |
|
297 |
|
298 if (iWaitCounter < KNumWaitLoops) |
|
299 { |
|
300 iCurrentTestNumber = EWaitState - 1; |
|
301 iWaitCounter++; |
|
302 } |
|
303 else |
|
304 { |
|
305 // move onto next test |
|
306 iCurrentTestNumber = EWaitedState; |
|
307 } |
|
308 |
|
309 NextTest(); |
|
310 |
|
311 break; |
|
312 |
|
313 // Test Eight - Async Open of a Previous version of the Database, and a Sync |
|
314 // open of the same database in a different thread. |
|
315 case EOpenAsyncAndSync: |
|
316 test.Next(_L("Open Async Then Sync")); |
|
317 |
|
318 |
|
319 // Copy Version 4 Db |
|
320 CopyCdbFileL(KDatabaseV4,KDbOldVersionFilePath); |
|
321 |
|
322 // Open Async |
|
323 SetActive(); |
|
324 iContactOpenOperation = CContactDatabase::Open(KDbOldVersionFileName,iStatus); |
|
325 ++iCurrentTestNumber; |
|
326 |
|
327 // Lauch Thread to Open Db Synchronously |
|
328 CDbOpenLauncher::Create(KThreadOpenSync, KThreadOpenSync); |
|
329 break; |
|
330 |
|
331 // Check Test Eight Results |
|
332 case EOpenedAsyncAndSync: |
|
333 test(iStatus.Int() == KErrNone); |
|
334 test.Printf(_L("=== Opened After Sync Open Db \n")); |
|
335 |
|
336 iDb = iContactOpenOperation->TakeDatabase(); |
|
337 test(iDb != NULL); |
|
338 delete iContactOpenOperation; |
|
339 delete iDb; |
|
340 |
|
341 NextTest(); |
|
342 break; |
|
343 |
|
344 // End of Tests |
|
345 case ENumTests: |
|
346 { |
|
347 test.Printf(_L("=== Main Tests Complete\n")); |
|
348 RThread thread; |
|
349 test(thread.RequestCount()==0); |
|
350 |
|
351 // tidy up files |
|
352 CContactDatabase::DeleteDatabaseL(KDbDamaged); |
|
353 CContactDatabase::DeleteDatabaseL(KDefaultDb); |
|
354 CContactDatabase::DeleteDatabaseL(KDbOldVersionFileName); |
|
355 |
|
356 |
|
357 CContactDatabase::DeleteDatabaseL(KDbFileName); |
|
358 |
|
359 CActiveScheduler::Stop(); |
|
360 } |
|
361 break; |
|
362 |
|
363 |
|
364 default: |
|
365 ASSERT(EFalse); |
|
366 break; |
|
367 } |
|
368 } |
|
369 |
|
370 |
|
371 void CTestConductor::DoCancel() |
|
372 { |
|
373 } |
|
374 |
|
375 |
|
376 TInt CTestConductor::RunError(TInt aError) |
|
377 { |
|
378 // (only a few steps call leaving methods but we have case statements for each) |
|
379 // propagate aError back to caller |
|
380 iTestError = aError; |
|
381 |
|
382 |
|
383 switch (iCurrentTestNumber) |
|
384 { |
|
385 case EAsyncOpenNamed: test.Printf(_L("Failed at test step AsyncOpenNamed (%i), with error %i"), iCurrentTestNumber, aError); break; |
|
386 case EAsyncOpenedNamed: test.Printf(_L("Failed at test step AsyncOpenedNamed (%i), with error %i"), iCurrentTestNumber, aError); break; |
|
387 case EAsyncOpenDefault: test.Printf(_L("Failed at test step AsyncOpenDefault (%i), with error %i"), iCurrentTestNumber, aError); break; |
|
388 case EAsyncOpenedDefault: test.Printf(_L("Failed at test step AsyncOpenedDefault (%i), with error %i"), iCurrentTestNumber, aError); break; |
|
389 case EAsyncOpenNonExistent: test.Printf(_L("Failed at test step AsyncOpenNonExistent (%i), with error %i"), iCurrentTestNumber, aError); break; |
|
390 case EAsyncOpenedNonExistent: test.Printf(_L("Failed at test step AsyncOpenedNonExistent (%i), with error %i"), iCurrentTestNumber, aError); break; |
|
391 case EAsyncCancelOpenDefault: test.Printf(_L("Failed at test step AsyncCancelOpenDefault (%i), with error %i"), iCurrentTestNumber, aError); break; |
|
392 case EAsyncCanceledOpenedDefault: test.Printf(_L("Failed at test step AsyncCanceledOpenedDefault (%i), with error %i"), iCurrentTestNumber, aError); break; |
|
393 case EAsyncOpenDamaged: test.Printf(_L("Failed at test step AsyncOpenDamaged (%i), with error %i"), iCurrentTestNumber, aError); break; |
|
394 case EAsyncOpenedDamaged: test.Printf(_L("Failed at test step AsyncOpenedDamaged (%i), with error %i"), iCurrentTestNumber, aError); break; |
|
395 case EAsyncOpenPreviousVersion: test.Printf(_L("Failed at test step AsyncOpenPreviousVersion (%i), with error %i"), iCurrentTestNumber, aError); break; |
|
396 case EAsyncOpenedPreviousVersion: test.Printf(_L("Failed at test step AsyncOpenedPreviousVersion (%i), with error %i"), iCurrentTestNumber, aError); break; |
|
397 case EOpenAsyncAndAsync: test.Printf(_L("Failed at test step OpenAsyncAndAsync (%i), with error %i"), iCurrentTestNumber, aError); break; |
|
398 case EOpenedAsyncAndAsync: test.Printf(_L("Failed at test step OpenedAsyncAndAsync (%i), with error %i"), iCurrentTestNumber, aError); break; |
|
399 case EWaitState: test.Printf(_L("Failed at test step WaitState (%i), with error %i"), iCurrentTestNumber, aError); break; |
|
400 case EWaitedState: test.Printf(_L("Failed at test step WaitedState (%i), with error %i"), iCurrentTestNumber, aError); break; |
|
401 case EOpenAsyncAndSync: test.Printf(_L("Failed at test step OpenAsyncAndSync (%i), with error %i"), iCurrentTestNumber, aError); break; |
|
402 case EOpenedAsyncAndSync: test.Printf(_L("Failed at test step OpenedAsyncAndSync (%i), with error %i"), iCurrentTestNumber, aError); break; |
|
403 |
|
404 case ENumTests: test.Printf(_L("Failed at test step NumTests (%i), with error %i"), iCurrentTestNumber, aError); break; |
|
405 |
|
406 default: test.Printf(_L("Failed at test step %i, with error %i"), iCurrentTestNumber, aError); break; |
|
407 } |
|
408 |
|
409 CActiveScheduler::Stop(); |
|
410 return KErrNone; |
|
411 } |
|
412 |
|
413 |
|
414 void CTestConductor::CopyCdbFileL(const TDesC& aFileName, const TDesC& aToFileName) |
|
415 { |
|
416 RPIMTestServer serv; |
|
417 User::LeaveIfError(serv.Connect()); |
|
418 serv.CopyFileL(aFileName, aToFileName); |
|
419 serv.Close(); |
|
420 } |
|
421 |
|
422 |
|
423 // |
|
424 // Separate Thread to Open Database |
|
425 // |
|
426 CDbOpenLauncher::CViewer* CDbOpenLauncher::CViewer::NewL(const TDesC& aViewName) |
|
427 { |
|
428 CViewer* self = new(ELeave) CViewer; |
|
429 CleanupStack::PushL(self); |
|
430 self->ConstructL(aViewName); |
|
431 CleanupStack::Pop(self); |
|
432 return(self); |
|
433 } |
|
434 |
|
435 CDbOpenLauncher::CViewer::~CViewer() |
|
436 { |
|
437 delete iDatabase; |
|
438 } |
|
439 |
|
440 void CDbOpenLauncher::CViewer::ConstructL(const TDesC& aViewName) |
|
441 { |
|
442 if(aViewName.Compare(KThreadOpenAsync) == 0) |
|
443 { |
|
444 // Create Async Open |
|
445 tester=CTester::NewL(); |
|
446 } |
|
447 else if (aViewName.Compare(KThreadOpenSync) == 0) |
|
448 { |
|
449 //Open the database Synchronously |
|
450 iDatabase = CContactDatabase::OpenL(KDbOldVersionFileName); |
|
451 test(iDatabase != NULL); |
|
452 delete iDatabase; |
|
453 } |
|
454 } |
|
455 |
|
456 void CDbOpenLauncher::DoMainL(const TDesC& aName) |
|
457 { |
|
458 CActiveScheduler* scheduler = new(ELeave) CActiveScheduler; |
|
459 CActiveScheduler::Install(scheduler); |
|
460 CViewer* view = CViewer::NewL(aName); |
|
461 CleanupStack::PushL(view); |
|
462 |
|
463 CActiveScheduler::Start(); |
|
464 |
|
465 CleanupStack::PopAndDestroy(view); |
|
466 } |
|
467 |
|
468 // This is the only thing one needs to call in order to set the view in motion. |
|
469 void CDbOpenLauncher::Create(const TDesC& aName, const TDesC& aViewName) |
|
470 { |
|
471 RThread thread; |
|
472 thread.Create( aName, CDbOpenLauncher::LaunchThread, KDefaultStackSize, 0x2000, 0x20000, (void*) &aViewName, EOwnerThread ); |
|
473 thread.Resume(); |
|
474 thread.SetPriority(EPriorityNormal); |
|
475 thread.Close(); |
|
476 } |
|
477 |
|
478 |
|
479 TInt CDbOpenLauncher::LaunchThread(TAny* aAny) |
|
480 { |
|
481 __UHEAP_MARK; |
|
482 |
|
483 CTrapCleanup* cleanUpStack=CTrapCleanup::New(); |
|
484 if (!cleanUpStack) |
|
485 { |
|
486 return KErrNoMemory; |
|
487 } |
|
488 |
|
489 TRAPD(r,DoMainL(*((TDesC*) aAny))); |
|
490 |
|
491 delete CActiveScheduler::Current(); |
|
492 delete cleanUpStack; |
|
493 |
|
494 __UHEAP_MARKEND; |
|
495 return r; |
|
496 } |
|
497 |
|
498 |
|
499 // |
|
500 // CTester Active Object to test Async Open in thread whilst async open is going on in other thread |
|
501 // |
|
502 CTester* CTester::NewL() |
|
503 { |
|
504 CTester* self = new(ELeave) CTester(); |
|
505 CleanupStack::PushL(self); |
|
506 self->ConstructL(); |
|
507 CleanupStack::Pop(); |
|
508 return self; |
|
509 } |
|
510 |
|
511 void CTester::DoCancel() |
|
512 { |
|
513 } |
|
514 |
|
515 CTester::~CTester() |
|
516 { |
|
517 //state deleted during tests |
|
518 } |
|
519 |
|
520 CTester::CTester() : CActive(EPriorityIdle),iCurrentTestNumber(0) |
|
521 { |
|
522 CActiveScheduler::Add(this); |
|
523 } |
|
524 |
|
525 void CTester::ConstructL() |
|
526 { |
|
527 NextTest(); |
|
528 CActiveScheduler::Start(); |
|
529 } |
|
530 |
|
531 void CTester::NextTest() |
|
532 { |
|
533 TRequestStatus *pS = &iStatus; |
|
534 User::RequestComplete(pS,KErrNone); |
|
535 SetActive(); |
|
536 } |
|
537 |
|
538 void CTester::RunL() |
|
539 { |
|
540 if (iCurrentTestNumber == EAsyncOpenNamed) |
|
541 { |
|
542 SetActive(); |
|
543 iContactOpenOperation = CContactDatabase::Open(KDbFileName,iStatus); |
|
544 ++iCurrentTestNumber; |
|
545 } |
|
546 else if(iCurrentTestNumber == EAsyncOpenedNamed) |
|
547 { |
|
548 test(iStatus.Int() == KErrNone); |
|
549 iDb = iContactOpenOperation->TakeDatabase(); |
|
550 |
|
551 test(iDb != NULL); |
|
552 delete iContactOpenOperation; |
|
553 delete iDb; |
|
554 CActiveScheduler::Stop(); |
|
555 } |
|
556 |
|
557 |
|
558 } |
|
559 |
|
560 // |
|
561 // Main. |
|
562 // |
|
563 |
|
564 /** |
|
565 |
|
566 @SYMTestCaseID PIM-T-SEC-ASYNCOPEN-0001 |
|
567 |
|
568 */ |
|
569 |
|
570 GLDEF_C TInt E32Main() |
|
571 { |
|
572 __UHEAP_MARK; |
|
573 test.Start(_L("@SYMTESTCaseID:PIM-T-SEC-ASYNCOPEN-0001 Async Open Testing")); |
|
574 |
|
575 CActiveScheduler* scheduler=new CActiveScheduler; |
|
576 if (scheduler) |
|
577 { |
|
578 CActiveScheduler::Install(scheduler); |
|
579 CTrapCleanup* cleanup=CTrapCleanup::New(); |
|
580 if (cleanup) |
|
581 { |
|
582 CTestConductor* tester=NULL; |
|
583 TRAPD(err,tester=CTestConductor::NewL()); |
|
584 test(err == KErrNone); |
|
585 delete tester; |
|
586 delete cleanup; |
|
587 } |
|
588 delete scheduler; |
|
589 } |
|
590 test.End(); |
|
591 test.Close(); |
|
592 __UHEAP_MARKEND; |
|
593 return KErrNone; |
|
594 } |
|
595 |
|
596 |
|
597 |
|
598 |
|
599 |
|
600 |