|
1 /* |
|
2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: This file contains the header file of the CTestEngine. |
|
15 * |
|
16 */ |
|
17 |
|
18 #ifndef TEST_ENGINE_H |
|
19 #define TEST_ENGINE_H |
|
20 |
|
21 // INCLUDES |
|
22 #include <e32std.h> |
|
23 #include <e32base.h> |
|
24 #include <StifLogger.h> |
|
25 #include <StifParser.h> |
|
26 #include <stifinternal/TestServerClient.h> |
|
27 #include <TestEngineClient.h> |
|
28 #include "TestEngineCommon.h" |
|
29 #include "TestEngineEvent.h" |
|
30 #include "STIFTestFrameworkSettings.h" |
|
31 #include "SettingServerClient.h" |
|
32 #include "STIFMeasurement.h" |
|
33 #include "TestModuleInfo.h" |
|
34 |
|
35 // CONSTANTS |
|
36 // Heap sizes needed for creating server thread. |
|
37 const TUint KTestEngineMinHeapSize = 0x10000; |
|
38 const TUint KTestEngineMaxHeapSize = 0x100000; |
|
39 |
|
40 // MACROS |
|
41 // None |
|
42 |
|
43 |
|
44 class CRebootParams |
|
45 :public CBase |
|
46 { |
|
47 public: // Constructors and destructor |
|
48 |
|
49 /** |
|
50 * NewL is two-phased constructor. |
|
51 */ |
|
52 static CRebootParams* NewL(); |
|
53 |
|
54 /** |
|
55 * Destructor of CTestEngineServer. |
|
56 */ |
|
57 ~CRebootParams(); |
|
58 |
|
59 // Setters |
|
60 void SetTestModuleNameL( const TDesC& aName ); |
|
61 void SetTestCaseFileNameL( const TDesC& aName ); |
|
62 void SetTestCaseTitleL( const TDesC& aName ); |
|
63 void SetTestCaseStateL( const TDesC& aName ); |
|
64 |
|
65 |
|
66 private: // New functions |
|
67 |
|
68 /** |
|
69 * C++ default constructor. |
|
70 */ |
|
71 CRebootParams(); |
|
72 |
|
73 /** |
|
74 * By default Symbian OS constructor is private. |
|
75 */ |
|
76 void ConstructL(); |
|
77 |
|
78 public: // Data |
|
79 TInt iCaseNumber; |
|
80 TInt iStateCode; |
|
81 |
|
82 TPtrC iTestModule; |
|
83 TPtrC iTestCaseFile; |
|
84 TPtrC iTestCaseTitle; |
|
85 TPtrC iStateName; |
|
86 |
|
87 private: // Data |
|
88 HBufC* iTestModuleBuf; |
|
89 HBufC* iTestCaseFileBuf; |
|
90 HBufC* iTestCaseTitleBuf; |
|
91 HBufC* iStateNameBuf; |
|
92 |
|
93 }; |
|
94 |
|
95 // FUNCTION PROTOTYPES |
|
96 // None |
|
97 |
|
98 // DESCRIPTION |
|
99 // Class used to store version information of test module. |
|
100 // iTestModuleName field keeps name of test module dll |
|
101 // iVersion keeps version of test module dll |
|
102 |
|
103 struct TTestModuleVersionInfo |
|
104 { |
|
105 TFileName iTestModuleName; |
|
106 TInt iMajor; |
|
107 TInt iMinor; |
|
108 TInt iBuild; |
|
109 }; |
|
110 |
|
111 // DESCRIPTION |
|
112 // CTestEngine is a session class. |
|
113 // Session for the CTestEngineServer server, to a single client-side session |
|
114 // a session may own any number of CCounter objects |
|
115 |
|
116 class CTestCase; |
|
117 class CTestEventController; |
|
118 class CTestModuleController; |
|
119 class CTestEngineServer; |
|
120 class CTestReport; |
|
121 |
|
122 class CTestEngine |
|
123 : public CSession2 |
|
124 { |
|
125 public: // Enumerations |
|
126 |
|
127 private: // Enumerations |
|
128 |
|
129 public: // Constructors and destructor |
|
130 |
|
131 /** |
|
132 * NewL is two-phased constructor. |
|
133 */ |
|
134 static CTestEngine* NewL( CTestEngineServer* aServer ); |
|
135 |
|
136 /** |
|
137 * Destructor. |
|
138 */ |
|
139 ~CTestEngine(); |
|
140 |
|
141 /** |
|
142 * Leave with notify |
|
143 */ |
|
144 void LeaveWithNotifyL( TInt aCode, const TDesC& aText ); |
|
145 |
|
146 /** |
|
147 * If error leave with notify |
|
148 */ |
|
149 void LeaveIfErrorWithNotify( TInt aCode, const TDesC& aText ); |
|
150 |
|
151 /** |
|
152 * Leave with notify |
|
153 */ |
|
154 void LeaveWithNotifyL( TInt aCode ); |
|
155 |
|
156 /** |
|
157 * If error leave with notify |
|
158 */ |
|
159 void LeaveIfErrorWithNotify( TInt aCode ); |
|
160 |
|
161 /** |
|
162 * Close the session to CTestEngineServer. |
|
163 */ |
|
164 void CloseSession(); |
|
165 |
|
166 public: // New functions |
|
167 |
|
168 /** |
|
169 * PanicClient panics the user of CTestEngine ( RTestEngine user ) |
|
170 */ |
|
171 void PanicClient( TTestEnginePanic aPanic, const RMessage2& aMessage ) const; |
|
172 |
|
173 /** |
|
174 * NumResources is used to provide reserver resources to client. |
|
175 */ |
|
176 void NumResources( const RMessage2& aMessage ); |
|
177 |
|
178 /** |
|
179 * Return the number of resources owned by the session. |
|
180 * Required by CSession if derived class implements resource |
|
181 * mark-start and mark-end protocol. |
|
182 */ |
|
183 TInt CountResources(); |
|
184 |
|
185 /** |
|
186 * Callback to inform that enumeration of test cases is completed |
|
187 */ |
|
188 void EnumerationCompleted( TInt aCount, TInt aError = KErrNone ); |
|
189 |
|
190 |
|
191 /** |
|
192 * Callback to check state event status. |
|
193 */ |
|
194 TBool IsStateEventAndSet( const TName& aEventName ); |
|
195 |
|
196 /** |
|
197 * Callback to control events. |
|
198 */ |
|
199 CTestEventController* CtlEventL( const TEventIf& aEvent, |
|
200 TRequestStatus& aStatus ); |
|
201 |
|
202 /** |
|
203 * Return the pointer to CStifLogger owned by CTestEngineServer |
|
204 */ |
|
205 CStifLogger* Logger(); |
|
206 |
|
207 /** |
|
208 * Return testcases. |
|
209 */ |
|
210 RPointerArray<CTestCase>& TestCaseArray(){ return iTestCaseArray; } |
|
211 |
|
212 /** |
|
213 * Return client events. |
|
214 */ |
|
215 RPointerArray<TEventMsg>& ClientEvents(){ return iClientEvents; } |
|
216 |
|
217 /** |
|
218 * ErrorPrint print errors. This version is used to print engine own |
|
219 * errors. |
|
220 */ |
|
221 void ErrorPrint( const TInt aPriority, |
|
222 TPtrC aError ); |
|
223 |
|
224 /** |
|
225 * ErrorPrint print errors. This version is used to forward errors. |
|
226 */ |
|
227 void ErrorPrint( TErrorNotificationPckg aError ); |
|
228 |
|
229 /** |
|
230 * Write the Reboot related information to file. |
|
231 */ |
|
232 TInt WriteRebootParams( TTestInfo& aTestInfo, |
|
233 TInt& aCode, TDesC& aName ); |
|
234 |
|
235 /** |
|
236 * Read the Reboot related information from the file. |
|
237 */ |
|
238 TInt ReadRebootParams( TTestInfo& aTestInfo, |
|
239 TDes& aStateDes, |
|
240 TInt& aState ); |
|
241 |
|
242 /** |
|
243 * Pause all test case(s) which are/is running. |
|
244 */ |
|
245 void PauseAllTestCases(); |
|
246 |
|
247 /** |
|
248 * Flush ATS logger buffers. |
|
249 */ |
|
250 void FlushAtsLogger(); |
|
251 |
|
252 /** |
|
253 * Get device reset module's DLL name. |
|
254 */ |
|
255 TPtrC GetDeviceResetDllName(); |
|
256 |
|
257 /** |
|
258 * Get measurements related information. Returns is measurement disable. |
|
259 */ |
|
260 TInt StifMeasurement(); |
|
261 |
|
262 /** |
|
263 * For Recovering from serious testmodulecrash situations (KErrserverTerminated (-15)) |
|
264 * Clones TestModuleController |
|
265 */ |
|
266 void TestModuleCrash( CTestModuleController* aTestModuleController ); |
|
267 |
|
268 /** |
|
269 * Executes command received from test case. |
|
270 * It was created to allow test case to kill itself. |
|
271 */ |
|
272 void ExecuteCommandL(TCommand aCommand, TDesC8& aParamsPckg); |
|
273 |
|
274 /** |
|
275 * Returns new index for test module controller. |
|
276 * This number is appended to module controller name. |
|
277 * This method is used when option to run every test case in separate |
|
278 * process is set to on. |
|
279 */ |
|
280 TInt GetIndexForNewTestModuleController(void); |
|
281 |
|
282 /** |
|
283 * Return free module controller specified by given parameter. |
|
284 * If it can't be found, new one will be created. |
|
285 */ |
|
286 CTestModuleController* GetFreeOrCreateModuleControllerL(TTestInfo& aTestInfo, |
|
287 CTestModuleController** aRealModuleController); |
|
288 TBool UITesting(); |
|
289 |
|
290 TBool SeparateProcesses(); |
|
291 |
|
292 public: // Functions from base classes |
|
293 |
|
294 /** |
|
295 * ServiceL handles the messages to CTestEngineServer |
|
296 */ |
|
297 virtual void ServiceL( const RMessage2& aMessage ); |
|
298 |
|
299 protected: // New functions |
|
300 |
|
301 protected: // Functions from base classes |
|
302 |
|
303 private: // New functions |
|
304 |
|
305 /** |
|
306 * C++ default constructor. |
|
307 */ |
|
308 CTestEngine(); |
|
309 |
|
310 /** |
|
311 * By default Symbian OS constructor is private. |
|
312 */ |
|
313 void ConstructL( CTestEngineServer* aServer ); |
|
314 |
|
315 /** |
|
316 * DispatchMessageL handles the messages to CTestEngineServer |
|
317 */ |
|
318 void DispatchMessageL( const RMessage2& aMessage ); |
|
319 |
|
320 /** |
|
321 * Get module controller by name |
|
322 */ |
|
323 CTestModuleController* ModuleControllerByName( |
|
324 const TName& aModuleName ); |
|
325 |
|
326 void SetTestEngineDefaultSettings(); |
|
327 |
|
328 /** |
|
329 * Initialize the Test Engine. |
|
330 */ |
|
331 void LoadConfigurationL( const RMessage2& aMessage ); |
|
332 /** |
|
333 * Update Log Configuration. |
|
334 */ |
|
335 void UpdateLogConfigurationL( const RMessage2& aMessage ); |
|
336 /** |
|
337 * Update Engine Configuration . |
|
338 */ |
|
339 void UpdateEngineConfigurationL( const RMessage2& aMessage ); |
|
340 |
|
341 /** |
|
342 * Parse Test Engine defaults from STIF initialization |
|
343 * file. |
|
344 */ |
|
345 void ReadEngineDefaultsL( CStifParser* aParser, |
|
346 CSTIFTestFrameworkSettings* aSettings ); |
|
347 /** |
|
348 * Parse Test Engine defaults from command line. |
|
349 * |
|
350 */ |
|
351 void ReadEngineFromCommandLineL(const TDesC& aCommand); |
|
352 |
|
353 /** |
|
354 * Parse Test modules and module information from STIFTestFramework |
|
355 * initialization file. |
|
356 */ |
|
357 void ReadTestModulesL( CStifParser* aParser ); |
|
358 |
|
359 /** |
|
360 * |
|
361 */ |
|
362 void TestModuleConfigFileL( CTestModuleController* aModule, |
|
363 CStifSectionParser* aSectionParser, |
|
364 TDesC& aTag ); |
|
365 |
|
366 /** |
|
367 * Sets attributes to Test Framework |
|
368 */ |
|
369 void SetAttributeL( const RMessage2& aMessage ); |
|
370 |
|
371 /** |
|
372 * Adds new Test Module |
|
373 */ |
|
374 void AddTestModuleL( const RMessage2& aMessage ); |
|
375 |
|
376 /** |
|
377 * Removes Test Module |
|
378 */ |
|
379 TInt RemoveTestModuleL( const RMessage2& aMessage ); |
|
380 |
|
381 /** |
|
382 * Close Test Engine |
|
383 */ |
|
384 void CloseTestEngineL(); |
|
385 |
|
386 /** |
|
387 * Adds new config file to Test Module |
|
388 */ |
|
389 void AddConfigFileL( const RMessage2& aMessage ); |
|
390 |
|
391 /** |
|
392 * Removes config file from test module |
|
393 */ |
|
394 void RemoveConfigFileL( const RMessage2& aMessage ); |
|
395 |
|
396 /** |
|
397 * Enumerates test cases |
|
398 */ |
|
399 void EnumerateTestCasesL( const RMessage2& aMessage ); |
|
400 |
|
401 /** |
|
402 * Get test cases |
|
403 */ |
|
404 void GetTestCasesL( const RMessage2& aMessage ); |
|
405 |
|
406 /** |
|
407 * Cancel outstanding asynchronous request |
|
408 */ |
|
409 void CancelAsyncRequest( const RMessage2& aMessage ); |
|
410 |
|
411 /** |
|
412 * Event system control. |
|
413 */ |
|
414 void EventControlL( const RMessage2& aMessage ); |
|
415 |
|
416 /** |
|
417 * Update state event list. |
|
418 */ |
|
419 void UpdateEventL( const TEventIf& aEvent ); |
|
420 |
|
421 /** |
|
422 * Handles error notifications |
|
423 */ |
|
424 void HandleErrorNotificationL( const RMessage2& iMessage ); |
|
425 |
|
426 /** |
|
427 * Get Logger's overwrite parameters |
|
428 */ |
|
429 void LoggerSettings( const RMessage2& iMessage ); |
|
430 |
|
431 /** |
|
432 * Close logger settings |
|
433 */ |
|
434 void CloseLoggerSettings(); |
|
435 |
|
436 /** |
|
437 * Process error queue. |
|
438 */ |
|
439 void ProcessErrorQueue(); |
|
440 |
|
441 /** |
|
442 * Resolve the correct CTestCase object |
|
443 */ |
|
444 CTestCase* TestCaseByHandle( TUint aHandle, const RMessage2& aMessage ); |
|
445 |
|
446 /** |
|
447 * Create CTestCase subsession. |
|
448 */ |
|
449 void NewTestCaseL( const RMessage2& aMessage ); |
|
450 |
|
451 /** |
|
452 * Destroy the created CTestCase subsession. |
|
453 * Cannot fail - can panic client. |
|
454 */ |
|
455 void DeleteTestCase( TUint aHandle ); |
|
456 |
|
457 /** |
|
458 * Parse the Reboot related information from the file. |
|
459 */ |
|
460 TInt ParseRebootParamsL(); |
|
461 |
|
462 /** |
|
463 * Set measurements related information, enable measurement. |
|
464 */ |
|
465 TInt EnableStifMeasurement( const TDesC& aInfoType ); |
|
466 |
|
467 /** |
|
468 * Set measurements related information, disable measurement. |
|
469 */ |
|
470 TInt DisableStifMeasurement( const TDesC& aInfoType ); |
|
471 |
|
472 /** |
|
473 * Parse and search for module info and fill list of modules. |
|
474 */ |
|
475 void ParseTestModulesL(CStifParser* aParser, CTestModuleList* aModuleList, const TDesC& aSectionStart, const TDesC& aSectionEnd); |
|
476 |
|
477 /** |
|
478 * Add test case info to test report. |
|
479 */ |
|
480 TInt AddTestCaseToTestReport(const RMessage2& aMessage); |
|
481 |
|
482 |
|
483 /** |
|
484 * CreateTestReport |
|
485 */ |
|
486 CTestReport* RetrieveTestReport(); |
|
487 |
|
488 public: // Data |
|
489 |
|
490 protected: // Data |
|
491 |
|
492 private: // Data |
|
493 |
|
494 // Test module array |
|
495 RPointerArray<CTestModuleController> iModules; |
|
496 |
|
497 // Object container for this session |
|
498 CObjectCon* iContainer; |
|
499 |
|
500 // Object index which stores objects (CTestCase instances) |
|
501 // for this session |
|
502 CObjectIx* iTestCases; |
|
503 |
|
504 // Array of CTestCase instances |
|
505 RPointerArray<CTestCase> iTestCaseArray; |
|
506 |
|
507 // Pointer to owning server |
|
508 CTestEngineServer* iTestEngineServer; |
|
509 |
|
510 // Device reset module's DLL name(Reboot) |
|
511 HBufC* iDeviceResetDllName; |
|
512 |
|
513 // Total number of resources allocated |
|
514 TInt iResourceCount; |
|
515 |
|
516 // Test Engine's initialization file |
|
517 HBufC* iIniFile; |
|
518 |
|
519 // Test Report |
|
520 CTestReport* iTestReport; |
|
521 // Test Report Mode |
|
522 TUint iReportMode; |
|
523 // Test Report Output Type |
|
524 TUint iReportOutput; |
|
525 |
|
526 // Test report settings |
|
527 CTestReportSettings* iTestReportSettings; |
|
528 |
|
529 // RMessage for ongoing operation |
|
530 RMessage2 iEnumerationMessage; |
|
531 |
|
532 // Test case count used in EnumerateTestCases |
|
533 TInt iCaseCount; |
|
534 // Error code used in EnumerateTestCases |
|
535 TInt iEnumError; |
|
536 |
|
537 // Tell if message can be completed |
|
538 TBool iComplete; |
|
539 |
|
540 // Error code for complete of message |
|
541 TInt iReturn; |
|
542 |
|
543 // State event Array |
|
544 RPointerArray<HBufC> iStateEvents; |
|
545 |
|
546 // Client event Array |
|
547 RPointerArray<TEventMsg> iClientEvents; |
|
548 |
|
549 // Number of enumerated test modules currently |
|
550 TInt iEnumerateModuleCount; |
|
551 |
|
552 // RMessage for error notifications |
|
553 TBool iErrorMessageAvailable; |
|
554 RMessage2 iErrorMessage; |
|
555 RArray<TErrorNotification> iErrorQueue; |
|
556 |
|
557 // Reboot path definition |
|
558 HBufC* iRebootPath; |
|
559 // Reboot file name definition |
|
560 HBufC* iRebootFilename; |
|
561 // Reboot default path definition |
|
562 TPtrC iRebootDefaultPath; |
|
563 // Reboot default file name definition |
|
564 TPtrC iRebootDefaultFilename; |
|
565 |
|
566 // Handle to Setting server. |
|
567 RSettingServer iSettingServer; |
|
568 |
|
569 CRebootParams* iRebootParams; |
|
570 TBool iIsTestReportGenerated; |
|
571 |
|
572 // For indication is measurement disable |
|
573 TInt iDisableMeasurement; |
|
574 |
|
575 // Default timeout value. 0 - no timeout value |
|
576 TInt64 iDefaultTimeout; |
|
577 |
|
578 // Counter for created TestModuleControllers |
|
579 TInt iIndexTestModuleControllers; |
|
580 |
|
581 // Is this UI testing? |
|
582 // If yes, then Test Engine works in a specific way. |
|
583 // It creates new process for every test scripter's test case |
|
584 // and deletes it after test case has finished. |
|
585 TBool iUITestingSupport; |
|
586 |
|
587 // Should every test case be executed in separate process? |
|
588 // This option is similar to iUITestingSupport, however |
|
589 // it does not delete the process after test case is finished. |
|
590 TBool iSeparateProcesses; |
|
591 |
|
592 //RPointerArray of versions of test modules |
|
593 RPointerArray<TTestModuleVersionInfo> iTestModulesVersionInfo; |
|
594 |
|
595 public: // Friend classes |
|
596 |
|
597 protected: // Friend classes |
|
598 |
|
599 private: // Friend classes |
|
600 |
|
601 }; |
|
602 |
|
603 // DESCRIPTION |
|
604 // CTestCase represents a subsession object in the CTestEngineServer. |
|
605 // A session may own any number of CTestCase objects |
|
606 |
|
607 class CTestProgressNotifier; |
|
608 class CTestCaseController; |
|
609 class CTestEventNotifier; |
|
610 class CTestRemoteCmdNotifier; |
|
611 class CTestCommandNotifier; |
|
612 class CTestCase |
|
613 : public CObject |
|
614 { |
|
615 public: // Enumerations |
|
616 |
|
617 private: // Enumerations |
|
618 |
|
619 public: // Constructors and destructor |
|
620 |
|
621 /** |
|
622 * NewL is two-phased constructor. |
|
623 */ |
|
624 static CTestCase* NewL( CTestEngine* aEngine, |
|
625 CTestModuleController* aModuleController, |
|
626 CTestReport* aTestReport, |
|
627 TTestInfo& aTestInfo, |
|
628 CTestModuleController* aRealModuleController); |
|
629 |
|
630 /** |
|
631 * Destructor of CTestCase. |
|
632 */ |
|
633 ~CTestCase(); |
|
634 |
|
635 /** |
|
636 * Close Test Case. |
|
637 */ |
|
638 void CloseTestCase(); |
|
639 |
|
640 public: // New functions |
|
641 |
|
642 /** |
|
643 * Run test case. |
|
644 */ |
|
645 void RunTestCaseL( const RMessage2& aMessage ); |
|
646 |
|
647 /** |
|
648 * Suspend the test case execution. |
|
649 */ |
|
650 TInt Pause(); |
|
651 |
|
652 /** |
|
653 * Resume the suspended test case execution. |
|
654 */ |
|
655 TInt Resume(); |
|
656 |
|
657 /** |
|
658 * Notify progress from Test Module. |
|
659 */ |
|
660 void NotifyProgressL( const RMessage2& aMessage ); |
|
661 |
|
662 /** |
|
663 * Notify remote commands from Test Module. |
|
664 */ |
|
665 void NotifyRemoteTypeL( const RMessage2& aMessage ); |
|
666 |
|
667 /** |
|
668 * Notify remote commands from Test Module. |
|
669 */ |
|
670 void NotifyRemoteMsgL( const RMessage2& aMessage ); |
|
671 |
|
672 /** |
|
673 * Cancel outstanding asynchronous request. |
|
674 */ |
|
675 void CancelAsyncRequest( const RMessage2& aMessage ); |
|
676 |
|
677 /** |
|
678 * Return the name of Test Module. |
|
679 */ |
|
680 const TDesC& ModuleName(); |
|
681 |
|
682 /** |
|
683 * For event control. |
|
684 */ |
|
685 void CtlEvent( const TEventIf& aEvent, TRequestStatus& aStatus ); |
|
686 |
|
687 /** |
|
688 * Check if CtlEvent should be called |
|
689 */ |
|
690 TBool CheckCtlEvent( const TEventIf& aEvent ); |
|
691 |
|
692 /** |
|
693 * Executes command received from test case. |
|
694 */ |
|
695 void ExecuteCommandL(TCommand aCommand, TDesC8& aParamsPckg); |
|
696 |
|
697 /** |
|
698 * Return module controller and real module controller. |
|
699 */ |
|
700 CTestModuleController* GetModuleControllers(CTestModuleController** aRealModuleController); |
|
701 |
|
702 /** |
|
703 * Set new module controller for test case (only in case when original controller crashed). |
|
704 */ |
|
705 void ResetModuleController(CTestModuleController* aModuleController); |
|
706 |
|
707 /** |
|
708 * Set new real module controller for test case (only in case when original controller crashed). |
|
709 */ |
|
710 void ResetRealModuleController(CTestModuleController* aRealModuleController); |
|
711 |
|
712 public: // Functions from base classes |
|
713 |
|
714 protected: // New functions |
|
715 |
|
716 protected: // Functions from base classes |
|
717 |
|
718 private: // New functions |
|
719 |
|
720 /** |
|
721 * C++ default constructor. |
|
722 */ |
|
723 CTestCase( CTestEngine* aEngine, |
|
724 CTestModuleController* aModuleController, |
|
725 TTestInfo& aTestInfo, |
|
726 CTestModuleController* aRealModuleController); |
|
727 |
|
728 /** |
|
729 * By default Symbian OS constructor is private. |
|
730 */ |
|
731 void ConstructL( CTestReport* aTestReport, TTestInfo& aTestInfo ); |
|
732 |
|
733 /** |
|
734 * Return the pointer to CStifLogger owned by CTestEngineServer |
|
735 */ |
|
736 CStifLogger* Logger(); |
|
737 |
|
738 public: // Data |
|
739 |
|
740 protected: // Data |
|
741 |
|
742 // Session owning us |
|
743 CTestEngine* iTestEngine; |
|
744 |
|
745 private: // Data |
|
746 |
|
747 // Test Module |
|
748 CTestModuleController* iTestModule; |
|
749 |
|
750 // Test case controller |
|
751 CTestCaseController* iTestCaseController; |
|
752 |
|
753 // Notifier for print |
|
754 CTestProgressNotifier* iTestCasePrint; |
|
755 |
|
756 // Notifier for event |
|
757 CTestEventNotifier* iTestCaseEvent; |
|
758 |
|
759 // Notifier for remote commands |
|
760 CTestRemoteCmdNotifier* iTestCaseRemoteCmd; |
|
761 |
|
762 // Handle to RTestServer |
|
763 RTestServer iTestServer; |
|
764 |
|
765 // Handle to RTestExecution |
|
766 RTestExecution iTestExecution; |
|
767 |
|
768 // Notifier for commands |
|
769 CTestCommandNotifier* iTestCaseCommand; |
|
770 |
|
771 // Real Test Module (when test module controller is testscripter) |
|
772 CTestModuleController* iRealModuleController; |
|
773 |
|
774 public: // Friend classes |
|
775 |
|
776 protected: // Friend classes |
|
777 |
|
778 private: // Friend classes |
|
779 |
|
780 }; |
|
781 |
|
782 #endif // TEST_ENGINE_H |
|
783 |
|
784 // End of File |