|
1 // Copyright (c) 2006-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 // Extended existing test for UIKON GT0143 Typhoon Work Series 60 Changes |
|
15 // UIKON GT0143 Typhoon Work Series 60 Changes |
|
16 // REQ815.1: Add a new op-code EBitmapAnimCommandStartAnimationAndKeepLastFrame |
|
17 // Added a new class RTestBitmapAnim, which inherits from RBitmapAnim and |
|
18 // calls CommandReply with the new op-code |
|
19 // Added a new test BmpAnimTest::TestStartAnimationAndKeepLastFrameL to |
|
20 // use RTestBitmapAnim |
|
21 // |
|
22 // |
|
23 |
|
24 /** |
|
25 @file |
|
26 @test |
|
27 @internalComponent - Internal Symbian test code |
|
28 */ |
|
29 |
|
30 #include <s32mem.h> |
|
31 #include <w32std.h> |
|
32 #include <fbs.h> |
|
33 #include <tautoan.mbg> |
|
34 |
|
35 #include <bmpansrv.h> |
|
36 #include "bmpanpan.h" |
|
37 #include "TAutoAnStep.h" |
|
38 |
|
39 TInt PanicTestThread(TAny* aOption); |
|
40 |
|
41 enum TPanicOption |
|
42 { |
|
43 EFirst, |
|
44 ENegativeFrameInterval, |
|
45 EUnknownPanicOption, |
|
46 ELast |
|
47 }; |
|
48 |
|
49 _LIT(KDefaultBitmapPath,"z:\\resource\\apps\\Tautoan\\Tautoan.mbm"); |
|
50 |
|
51 const TInt KValueForSixFrames = 600;//Total time for 6 frames |
|
52 |
|
53 const TInt KNegativeFrameInterval = -100; |
|
54 |
|
55 // |
|
56 // CWsClient |
|
57 // |
|
58 |
|
59 CWsClient::CWsClient() |
|
60 { |
|
61 } |
|
62 |
|
63 void CWsClient::ConstructL() |
|
64 { |
|
65 User::LeaveIfError(iWs.Connect()); |
|
66 iGroup=RWindowGroup(iWs); |
|
67 User::LeaveIfError(iGroup.Construct(2)); |
|
68 } |
|
69 |
|
70 CWsClient::~CWsClient() |
|
71 { |
|
72 iGroup.Close(); |
|
73 iWs.Close(); |
|
74 } |
|
75 |
|
76 // |
|
77 // RTestBitmapAnim |
|
78 // |
|
79 RTestBitmapAnim::RTestBitmapAnim(RAnimDll& aAnimDll) |
|
80 :RBitmapAnim(aAnimDll) |
|
81 { |
|
82 } |
|
83 |
|
84 void RTestBitmapAnim::StartAndKeepLastFrameL() |
|
85 { |
|
86 CommandReply(EBitmapAnimCommandStartAnimationAndKeepLastFrame); |
|
87 } |
|
88 |
|
89 // |
|
90 // BmpAnimTest |
|
91 // |
|
92 |
|
93 CBitmapAnimClientData* CTAutoAnStep::CreateClientDataL() |
|
94 { |
|
95 CBitmapAnimClientData* clientData = CBitmapAnimClientData::NewL(); |
|
96 CleanupStack::PushL(clientData); |
|
97 |
|
98 CFbsBitmap* bitmap=new(ELeave) CFbsBitmap; |
|
99 CleanupStack::PushL(bitmap); |
|
100 User::LeaveIfError(bitmap->Load(KDefaultBitmapPath, EMbmTautoanTextured)); |
|
101 CFbsBitmap* mask = NULL; |
|
102 |
|
103 CBitmapFrameData* frameData = CBitmapFrameData::NewL(bitmap, mask); |
|
104 CleanupStack::Pop(); // backgroundbitmap |
|
105 |
|
106 |
|
107 clientData->SetBackgroundFrame(frameData); |
|
108 |
|
109 TPoint position(10, 10); |
|
110 TInt milliSeconds = 100; |
|
111 TInt count = 6; |
|
112 for(TInt index=0; index<count; index++) |
|
113 { |
|
114 bitmap=new(ELeave) CFbsBitmap; |
|
115 CleanupStack::PushL(bitmap); |
|
116 User::LeaveIfError(bitmap->Load(KDefaultBitmapPath, EMbmTautoanRedball)); |
|
117 mask=new(ELeave) CFbsBitmap; |
|
118 CleanupStack::PushL(mask); |
|
119 User::LeaveIfError(mask->Load(KDefaultBitmapPath, EMbmTautoanRedballm)); |
|
120 |
|
121 frameData = CBitmapFrameData::NewL(bitmap, mask, milliSeconds, position); |
|
122 frameData->SetBitmapsOwnedExternally(EFalse); |
|
123 CleanupStack::PushL(frameData); |
|
124 CleanupStack::Pop(2); // bitmap, mask |
|
125 clientData->AppendFrameL(frameData); |
|
126 CleanupStack::Pop(); |
|
127 } |
|
128 CleanupStack::Pop(); |
|
129 return clientData; |
|
130 } |
|
131 |
|
132 void CTAutoAnStep::Test1L(CTestingData* aTestingData) |
|
133 { |
|
134 __UHEAP_MARK; |
|
135 RWindow window = aTestingData->iWindow; |
|
136 RBitmapAnim animation = aTestingData->iAnimation; |
|
137 CBitmapAnimClientData* clientData = NULL; |
|
138 |
|
139 TRAPD(error, clientData = CTAutoAnStep::CreateClientDataL()); |
|
140 TEST(error == KErrNone); |
|
141 clientData->SetPlayMode(CBitmapAnimClientData::EPlay); |
|
142 clientData->SetFrameInterval(0); |
|
143 clientData->SetFlash(EFalse); |
|
144 TestWindowConstructL(animation,window,clientData); |
|
145 |
|
146 TRAP(error, clientData = CTAutoAnStep::CreateClientDataL()); |
|
147 TEST(error == KErrNone); |
|
148 clientData->ResetFrameArray(); |
|
149 TestWindowConstructL(animation,window,clientData); |
|
150 |
|
151 TRAP(error, clientData = CTAutoAnStep::CreateClientDataL()); |
|
152 TEST(error == KErrNone); |
|
153 TInt count = clientData->FrameArray().Count(); |
|
154 TInt index=0; |
|
155 for(index=0; index<count; index++) |
|
156 { |
|
157 CBitmapFrameData* frameData = clientData->FrameArray().At(index); |
|
158 frameData->SetInterval(-1); |
|
159 } |
|
160 TestWindowConstructL(animation,window,clientData); |
|
161 |
|
162 TRAP(error, clientData = CTAutoAnStep::CreateClientDataL()); |
|
163 TEST(error == KErrNone); |
|
164 count = clientData->FrameArray().Count(); |
|
165 CBitmapFrameData* frameData = NULL; |
|
166 for(index=0; index<count; index++) |
|
167 { |
|
168 frameData = clientData->FrameArray().At(index); |
|
169 frameData->SetPosition(TPoint(0, 0)); |
|
170 } |
|
171 TestWindowConstructL(animation,window,clientData); |
|
172 |
|
173 TRAP(error, clientData = CTAutoAnStep::CreateClientDataL()); |
|
174 TEST(error == KErrNone); |
|
175 clientData->SetBackgroundFrame(NULL); |
|
176 TestWindowConstructL(animation,window,clientData); |
|
177 |
|
178 //testing setbitmapOwnedExternally() |
|
179 TRAP(error, clientData = CTAutoAnStep::CreateClientDataL()); |
|
180 TEST(error == KErrNone); |
|
181 frameData->SetBitmapsOwnedExternally(EFalse); |
|
182 TBool val = frameData->BitmapsOwnedExternally(); |
|
183 TEST(val == EFalse); |
|
184 INFO_PRINTF1(_L("Test BitmapOwnedExternally Passed")); |
|
185 TestWindowConstructL(animation,window,clientData); |
|
186 |
|
187 //testing ResetFrameArray() |
|
188 TRAP(error, clientData = CTAutoAnStep::CreateClientDataL()); |
|
189 TEST(error == KErrNone); |
|
190 count = clientData->FrameArray().Count(); |
|
191 for(index=0; index<count; index++) |
|
192 { |
|
193 CBitmapFrameData* frameData = clientData->FrameArray().At(index); |
|
194 frameData->SetInterval(-1); |
|
195 } |
|
196 clientData->ResetFrameArray(); |
|
197 val = clientData->FrameArray().Count(); |
|
198 TEST(val == 0); |
|
199 TestWindowConstructL(animation,window,clientData); |
|
200 |
|
201 //TESTING SetPositionL() -greater than screen size// |
|
202 TSize area = window.Size(); |
|
203 TRAP(error, clientData = CTAutoAnStep::CreateClientDataL()); |
|
204 TEST(error == KErrNone); |
|
205 TRAP(error,animation.SetPositionL(TPoint(area.iWidth+10,area.iHeight+10))); |
|
206 TEST(error == KErrNone); |
|
207 TestWindowConstructL(animation,window,clientData); |
|
208 |
|
209 //SetPositionL() - negative value |
|
210 TRAP(error, clientData = CTAutoAnStep::CreateClientDataL()); |
|
211 TEST(error == KErrNone); |
|
212 TRAP(error, animation.SetPositionL(TPoint(-10,-10))); |
|
213 TEST(error == KErrNone); |
|
214 TestWindowConstructL(animation,window,clientData); |
|
215 |
|
216 //DurationInMilliSeconds()...6 frames...100ms each |
|
217 TRAP(error, clientData = CTAutoAnStep::CreateClientDataL()); |
|
218 TEST(error == KErrNone); |
|
219 TInt timeinmillisec = clientData->DurationInMilliSeconds(); |
|
220 TEST(timeinmillisec == KValueForSixFrames); |
|
221 TestWindowConstructL(animation,window,clientData); |
|
222 |
|
223 RFbsSession::Disconnect(); |
|
224 __UHEAP_MARKEND; |
|
225 RFbsSession::Connect(); |
|
226 } |
|
227 |
|
228 |
|
229 void CTAutoAnStep::TestWindowConstructL(RBitmapAnim& animation,RWindow& window,CBitmapAnimClientData* clientData) |
|
230 { |
|
231 TRAPD(error, animation.ConstructL(window)); |
|
232 TEST(error == KErrNone); |
|
233 TRAP(error, animation.SetBitmapAnimDataL(*clientData)); |
|
234 TEST(error == KErrNone); |
|
235 TRAP(error, animation.StartL()); |
|
236 TEST(error == KErrNone); |
|
237 User::After(1000000); |
|
238 TRAP(error, animation.StopL()); |
|
239 TEST(error == KErrNone); |
|
240 delete clientData; |
|
241 } |
|
242 |
|
243 |
|
244 void CTAutoAnStep::Test2L(CTestingData* aTestingData) |
|
245 { |
|
246 __UHEAP_MARK; |
|
247 RWindow window = aTestingData->iWindow; |
|
248 RBitmapAnim animation = aTestingData->iAnimation; |
|
249 |
|
250 CBitmapAnimClientData* clientData = NULL; |
|
251 TRAPD(error, clientData = CTAutoAnStep::CreateClientDataL()); |
|
252 TEST(error == KErrNone); |
|
253 TRAP(error, animation.ConstructL(window)); |
|
254 TEST(error == KErrNone); |
|
255 TRAP(error, animation.StartL()); |
|
256 TEST(error == KErrNone); |
|
257 User::After(1000000); |
|
258 TRAP(error, animation.StopL()); |
|
259 TEST(error == KErrNone); |
|
260 INFO_PRINTF1(_L("Executing Test2L")); |
|
261 |
|
262 TRAP(error, animation.SetBitmapAnimDataL(*clientData)); |
|
263 TEST(error == KErrNone); |
|
264 |
|
265 TRAP(error, animation.DisplayFrameL(3)); |
|
266 TEST(error == KErrNone); |
|
267 |
|
268 TRAP(error, animation.SetFrameIntervalL(200000)); |
|
269 TEST(error == KErrNone); |
|
270 |
|
271 TRAP(error, animation.SetNumberOfCyclesL(1)); |
|
272 TEST(error == KErrNone); |
|
273 |
|
274 TRAP(error, animation.SetPlayModeL(CBitmapAnimClientData::ECycle)); |
|
275 TEST(error == KErrNone); |
|
276 |
|
277 TRAP(error, animation.SetPositionL(TPoint(20,20))); |
|
278 TEST(error == KErrNone); |
|
279 |
|
280 TRAP(error, animation.SetNumberOfCyclesL(-1)); |
|
281 TEST(error == KErrNone); |
|
282 |
|
283 TRAP(error, animation.SetPlayModeL(CBitmapAnimClientData::EBounce)); |
|
284 TRAP(error, animation.SetNumberOfCyclesL(1)); |
|
285 TEST(error == KErrNone); |
|
286 |
|
287 TRAP(error,animation.DisplayFrameL(-1)); |
|
288 TEST(error == KErrOverflow); |
|
289 |
|
290 |
|
291 delete clientData; |
|
292 RFbsSession::Disconnect(); |
|
293 __UHEAP_MARKEND; |
|
294 RFbsSession::Connect(); |
|
295 |
|
296 } |
|
297 |
|
298 |
|
299 void CTAutoAnStep::CreatedAndCloseAnimationsL(CTestingData* aTestingData) |
|
300 { |
|
301 __UHEAP_MARK; |
|
302 RAnimDll animDll = aTestingData->iAnimDll; |
|
303 RWindow window = aTestingData->iWindow; |
|
304 RBitmapAnim animation = aTestingData->iAnimation; |
|
305 animation.ConstructL(window); |
|
306 |
|
307 RBitmapAnim tempAnimation(animDll); |
|
308 tempAnimation.Close(); |
|
309 RBitmapAnim tempAnimation1(animDll); |
|
310 RBitmapAnim tempAnimation2(animDll); |
|
311 tempAnimation2.ConstructL(window); |
|
312 |
|
313 RBitmapAnim tempAnimation3(animDll); |
|
314 tempAnimation3.ConstructL(window); |
|
315 |
|
316 RBitmapAnim tempAnimation4(animDll); |
|
317 tempAnimation4.ConstructL(window); |
|
318 |
|
319 RBitmapAnim tempAnimation5(animDll); |
|
320 tempAnimation5.ConstructL(window); |
|
321 |
|
322 tempAnimation2.StartL(); |
|
323 |
|
324 tempAnimation2.Close(); |
|
325 tempAnimation1.Close(); |
|
326 tempAnimation3.Close(); |
|
327 tempAnimation4.Close(); |
|
328 tempAnimation5.Close(); |
|
329 __UHEAP_MARKEND; |
|
330 } |
|
331 |
|
332 /** |
|
333 @SYMTestCaseID UIF-BMPANIM-0001 |
|
334 @SYMDEF DEF085516 |
|
335 @SYMTestCaseDesc It tests the behaviour of the API SetFrameInterval( ) for negative time. |
|
336 @SYMTestPriority High |
|
337 @SYMTestStatus Implemented |
|
338 @SYMTestActions Set time to the frames present in the clientData,through the SetFrameInterval() API of CBitmapAnimClientData. |
|
339 Pass a negative value as parameter to the API. |
|
340 @SYMTestExpectedResults It should panic in debug mode with Panic EAnimationClientPanicFrameIntervalNegative and in release mode it should not panic. |
|
341 |
|
342 */ |
|
343 |
|
344 void CTAutoAnStep::TestNegativeFrameIntervalL() |
|
345 { |
|
346 #ifdef _DEBUG//only in debug mode, the following code is used |
|
347 RThread thrd; |
|
348 TRequestStatus stat; |
|
349 TInt ret=thrd.Create(_L("ptt"),PanicTestThread,KDefaultStackSize,0x2000,0x20000,(TAny*)ENegativeFrameInterval); |
|
350 User::LeaveIfError(ret); |
|
351 thrd.SetPriority(EPriorityMuchMore); |
|
352 thrd.Logon(stat); |
|
353 User::SetJustInTime(EFalse); |
|
354 thrd.Resume(); |
|
355 User::WaitForRequest(stat); |
|
356 TEST(thrd.ExitType()==EExitPanic); |
|
357 TEST(thrd.ExitReason()==EAnimationClientPanicFrameIntervalNegative); |
|
358 INFO_PRINTF2(_L("TestNegativeFrameIntervalL panic=%d"), thrd.ExitReason()); |
|
359 thrd.Close(); |
|
360 User::SetJustInTime(ETrue); |
|
361 INFO_PRINTF1(_L("TestNegativeFrameIntervalL test case finished in udeb mode")); |
|
362 #else//only in urel mode , the following code is called |
|
363 CBitmapAnimClientData* clientData = CBitmapAnimClientData::NewL(); |
|
364 CleanupStack::PushL(clientData); |
|
365 |
|
366 CFbsBitmap* bitmap=new(ELeave) CFbsBitmap; |
|
367 CleanupStack::PushL(bitmap); |
|
368 User::LeaveIfError(bitmap->Load(KDefaultBitmapPath, EMbmTautoanTextured)); |
|
369 CFbsBitmap* mask = NULL; |
|
370 |
|
371 CBitmapFrameData* frameData = CBitmapFrameData::NewL(bitmap, mask); |
|
372 CleanupStack::Pop(); // backgroundbitmap |
|
373 |
|
374 clientData->SetBackgroundFrame(frameData); |
|
375 clientData->SetFrameInterval(KNegativeFrameInterval); |
|
376 TInt count = 3; |
|
377 for(TInt index=0; index<count; index++) |
|
378 { |
|
379 bitmap=new(ELeave) CFbsBitmap; |
|
380 CleanupStack::PushL(bitmap); |
|
381 User::LeaveIfError(bitmap->Load(KDefaultBitmapPath, EMbmTautoanRedball)); |
|
382 mask=new(ELeave) CFbsBitmap; |
|
383 CleanupStack::PushL(mask); |
|
384 User::LeaveIfError(mask->Load(KDefaultBitmapPath, EMbmTautoanRedballm)); |
|
385 |
|
386 frameData = CBitmapFrameData::NewL(bitmap, mask); |
|
387 frameData->SetBitmapsOwnedExternally(EFalse); |
|
388 CleanupStack::PushL(frameData); |
|
389 CleanupStack::Pop(2); // bitmap, mask |
|
390 clientData->AppendFrameL(frameData); |
|
391 CleanupStack::Pop(); |
|
392 } |
|
393 CleanupStack::Pop(); |
|
394 TEST(clientData->FrameIntervalInMilliSeconds() == KNegativeFrameInterval); |
|
395 delete clientData; |
|
396 INFO_PRINTF1(_L("TestNegativeFrameIntervalL test case finished in urel mode")); |
|
397 #endif |
|
398 } |
|
399 |
|
400 //The following thread should panic under debug mode |
|
401 TInt PanicTestThread(TAny* aOption) |
|
402 { |
|
403 CTrapCleanup::New(); |
|
404 RFbsSession::Connect(); |
|
405 |
|
406 const TInt option = TInt(aOption); |
|
407 switch (option) |
|
408 { |
|
409 case ENegativeFrameInterval: |
|
410 { |
|
411 CBitmapAnimClientData* clientData=NULL; |
|
412 TRAPD(ret,clientData=CBitmapAnimClientData::NewL()); |
|
413 if(ret!=KErrNone) |
|
414 User::Panic(_L(" TAutoAnStep Failed"),ret); |
|
415 clientData->SetFrameInterval(KNegativeFrameInterval); //The negative time is the reason for panic |
|
416 delete clientData; |
|
417 } |
|
418 default: |
|
419 User::Panic(_L("TAutoAnStep error"), EUnknownPanicOption); |
|
420 } |
|
421 |
|
422 return KErrNone; |
|
423 } |
|
424 |
|
425 |
|
426 |
|
427 void CTAutoAnStep::TestStartAnimationAndKeepLastFrameL(CTestingData* aTestingData) |
|
428 { |
|
429 __UHEAP_MARK; |
|
430 RWindow window = aTestingData->iWindow; |
|
431 RTestBitmapAnim animation(aTestingData->iAnimDll); |
|
432 animation.ConstructL(window); |
|
433 animation.StartAndKeepLastFrameL(); |
|
434 animation.StopL(); |
|
435 animation.Close(); |
|
436 __UHEAP_MARKEND; |
|
437 } |
|
438 |
|
439 void CTAutoAnStep::ExcuteTestCodeL() |
|
440 { |
|
441 __UHEAP_MARK; |
|
442 // Make Ws client |
|
443 INFO_PRINTF1(_L("Connecting to Windows Server")); |
|
444 CWsClient* client = new (ELeave) CWsClient; // allocate new client |
|
445 CleanupStack::PushL(client); // push, just in case |
|
446 client->ConstructL(); // construct and run |
|
447 CleanupStack::Pop(); // client |
|
448 |
|
449 // |
|
450 // Creates and deletes to bitmaps in order to allocate KDefaultBitmapPath in the cache for FBserv |
|
451 // This is necessary to check for memory leaks. |
|
452 CFbsBitmap* bitmap = new(ELeave) CFbsBitmap; |
|
453 INFO_PRINTF1(_L("Trying to Load Bitmap")); |
|
454 User::LeaveIfError(bitmap->Load(KDefaultBitmapPath, EMbmTautoanRedball)); |
|
455 CFbsBitmap* mask = new(ELeave) CFbsBitmap; |
|
456 User::LeaveIfError(mask->Load(KDefaultBitmapPath, EMbmTautoanRedballm)); |
|
457 delete bitmap; |
|
458 delete mask; |
|
459 // |
|
460 |
|
461 // Create an animation. |
|
462 RWsSession wsSession = client->WindowSession(); |
|
463 RAnimDll animDll(wsSession); |
|
464 User::LeaveIfError(animDll.Load(_L("BmpAnSrv.DLL"))); |
|
465 |
|
466 RWindow window(wsSession); |
|
467 RWindowGroup windowGroup = client->WindowGroup(); |
|
468 window.Construct(windowGroup, 123); |
|
469 |
|
470 RBitmapAnim animation(animDll); |
|
471 |
|
472 // Create the packaging object |
|
473 CTestingData testingData(animDll, animation, window); |
|
474 |
|
475 // Start tests |
|
476 |
|
477 INFO_PRINTF1(_L("Test 1: Create/Run/Stop an animation.")); |
|
478 TRAPD(err,CTAutoAnStep::Test1L(&testingData)); |
|
479 TEST(err==KErrNone); |
|
480 |
|
481 INFO_PRINTF1(_L("Test 2: Changes Attribute when running")); |
|
482 TRAP(err,CTAutoAnStep::Test2L(&testingData)); |
|
483 TEST(err==KErrNone); |
|
484 |
|
485 INFO_PRINTF1(_L("Test 3: Create/Close many animations")); |
|
486 TRAP(err,CTAutoAnStep::CreatedAndCloseAnimationsL(&testingData)); |
|
487 TEST(err==KErrNone); |
|
488 |
|
489 SetTestStepID(_L("UIF-BMPANIM-0001")); |
|
490 INFO_PRINTF1(_L("Test 4: Set Negative frameinterval")); |
|
491 TRAP(err,CTAutoAnStep::TestNegativeFrameIntervalL()); |
|
492 TEST(err==KErrNone); |
|
493 RecordTestResultL(); |
|
494 CloseTMSGraphicsStep(); |
|
495 |
|
496 // Series60 Specific Test |
|
497 INFO_PRINTF1(_L("Test 5: Start Animation and Keep Last Frame")); |
|
498 TRAP(err,CTAutoAnStep::TestStartAnimationAndKeepLastFrameL(&testingData)); |
|
499 TEST(err==KErrNone); |
|
500 |
|
501 animation.Close(); |
|
502 animDll.Close(); |
|
503 delete client; |
|
504 __UHEAP_MARKEND; |
|
505 } |
|
506 |
|
507 CTAutoAnStep::~CTAutoAnStep() |
|
508 /** |
|
509 Destructor |
|
510 */ |
|
511 { |
|
512 } |
|
513 |
|
514 CTAutoAnStep::CTAutoAnStep() |
|
515 /** |
|
516 Constructor |
|
517 */ |
|
518 { |
|
519 // Call base class method to set up the human readable name for logging |
|
520 SetTestStepName(KTAutoAnStep); |
|
521 } |
|
522 |
|
523 |
|
524 TVerdict CTAutoAnStep::doTestStepL() |
|
525 { |
|
526 INFO_PRINTF1(_L("Test Started")); |
|
527 |
|
528 __UHEAP_MARK; |
|
529 TRAPD(error, ExcuteTestCodeL()); // more initialization, then excute test |
|
530 __ASSERT_ALWAYS(!error, User::Panic(_L("TAUTOAN"), error)); |
|
531 __UHEAP_MARKEND; |
|
532 |
|
533 INFO_PRINTF1(_L("Test Finished")); |
|
534 |
|
535 return TestStepResult(); |
|
536 } |
|
537 |