|
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 module contains implementation of CTestServer |
|
15 * class member functions. |
|
16 * |
|
17 */ |
|
18 |
|
19 // INCLUDE FILES |
|
20 #include <e32std.h> |
|
21 #include <e32svr.h> |
|
22 #include "TestEngineClient.h" |
|
23 #include <StifTestModule.h> |
|
24 #include <stifinternal/TestServerClient.h> |
|
25 #include "TestServer.h" |
|
26 #include "TestServerCommon.h" |
|
27 #include "TestServerModuleIf.h" |
|
28 |
|
29 // EXTERNAL DATA STRUCTURES |
|
30 |
|
31 // EXTERNAL FUNCTION PROTOTYPES |
|
32 |
|
33 // CONSTANTS |
|
34 |
|
35 // MACROS |
|
36 |
|
37 // LOCAL CONSTANTS AND MACROS |
|
38 |
|
39 // MODULE DATA STRUCTURES |
|
40 // Struct to pass parameters to server thread |
|
41 struct TThreadStartTestServerSession |
|
42 { |
|
43 RThread iServerThread; // The server thread |
|
44 RSemaphore iStarted; // Startup syncronisation semaphore |
|
45 TInt iStartupResult;// Start-up result |
|
46 }; |
|
47 |
|
48 // LOCAL FUNCTION PROTOTYPES |
|
49 |
|
50 // FORWARD DECLARATIONS |
|
51 |
|
52 // ==================== LOCAL FUNCTIONS ======================================= |
|
53 |
|
54 // None |
|
55 |
|
56 // ================= MEMBER FUNCTIONS ========================================= |
|
57 |
|
58 /* |
|
59 ------------------------------------------------------------------------------- |
|
60 |
|
61 Class: CTestCasesList |
|
62 |
|
63 Method: NewL |
|
64 |
|
65 Description: Create new test cases list |
|
66 |
|
67 Parameters: const TDesC& aConfigFileName :in: Config file name |
|
68 |
|
69 Return Values: CTestCasesList* Pointer to new test cases list |
|
70 |
|
71 Errors/Exceptions: Leaves if memory allocation fails or ConstructL leaves. |
|
72 |
|
73 Status: Approved |
|
74 |
|
75 ------------------------------------------------------------------------------- |
|
76 */ |
|
77 CTestCasesList* CTestCasesList::NewL( const TDesC& aConfigFileName ) |
|
78 { |
|
79 CTestCasesList* self = new(ELeave)CTestCasesList; |
|
80 CleanupStack::PushL( self ); |
|
81 self->ConstructL( aConfigFileName ); |
|
82 CleanupStack::Pop( self ); |
|
83 return self; |
|
84 } |
|
85 |
|
86 /* |
|
87 ------------------------------------------------------------------------------- |
|
88 |
|
89 Class: CTestCasesList |
|
90 |
|
91 Method: ~CTestCasesList |
|
92 |
|
93 Description: Destructor |
|
94 |
|
95 Parameters: |
|
96 |
|
97 Return Values: |
|
98 |
|
99 Errors/Exceptions: |
|
100 |
|
101 Status: Approved |
|
102 |
|
103 ------------------------------------------------------------------------------- |
|
104 */ |
|
105 CTestCasesList::~CTestCasesList() |
|
106 { |
|
107 delete iConfigFileName; |
|
108 iConfigFileName = NULL; |
|
109 iTestCases.ResetAndDestroy(); |
|
110 iTestCases.Close(); |
|
111 } |
|
112 |
|
113 /* |
|
114 ------------------------------------------------------------------------------- |
|
115 |
|
116 Class: CTestCasesList |
|
117 |
|
118 Method: AppendTestCaseL |
|
119 |
|
120 Description: Appends test case. |
|
121 |
|
122 Parameters: const TDesC& aTestCaseTitle in: Test case title |
|
123 |
|
124 Return Values: |
|
125 |
|
126 Errors/Exceptions: Leaves if memory allocation fails |
|
127 |
|
128 Status: Approved |
|
129 |
|
130 ------------------------------------------------------------------------------- |
|
131 */ |
|
132 void CTestCasesList::AppendTestCaseL( const TDesC& aTestCaseTitle ) |
|
133 { |
|
134 HBufC* testCaseTitle = aTestCaseTitle.AllocL(); |
|
135 CleanupStack::PushL( testCaseTitle ); |
|
136 iTestCases.AppendL( testCaseTitle ); |
|
137 CleanupStack::Pop( testCaseTitle ); |
|
138 } |
|
139 |
|
140 /* |
|
141 ------------------------------------------------------------------------------- |
|
142 |
|
143 Class: CTestCasesList |
|
144 |
|
145 Method: GetTestCaseTitleL |
|
146 |
|
147 Description: Returns specified test case title |
|
148 |
|
149 Parameters: TInt aIndex: in: Requested test case index. |
|
150 |
|
151 Return Values: Test case title. |
|
152 |
|
153 Errors/Exceptions: Leaves if test case index is invalid |
|
154 |
|
155 Status: Approved |
|
156 |
|
157 ------------------------------------------------------------------------------- |
|
158 */ |
|
159 const TDesC& CTestCasesList::GetTestCaseTitleL( TInt aIndex ) const |
|
160 { |
|
161 if ( ( aIndex < 0 ) || ( aIndex >= iTestCases.Count() ) ) |
|
162 { |
|
163 User::Leave( KErrNotFound ); |
|
164 } |
|
165 return *iTestCases[ aIndex ]; |
|
166 } |
|
167 |
|
168 /* |
|
169 ------------------------------------------------------------------------------- |
|
170 |
|
171 Class: CTestCasesList |
|
172 |
|
173 Method: GetConfigFileName |
|
174 |
|
175 Description: Returns config file name |
|
176 |
|
177 Parameters: |
|
178 |
|
179 Return Values: Config file name. |
|
180 |
|
181 Errors/Exceptions: |
|
182 |
|
183 Status: Approved |
|
184 |
|
185 ------------------------------------------------------------------------------- |
|
186 */ |
|
187 const TDesC& CTestCasesList::GetConfigFileName() const |
|
188 { |
|
189 return *iConfigFileName; |
|
190 } |
|
191 |
|
192 /* |
|
193 ------------------------------------------------------------------------------- |
|
194 |
|
195 Class: CTestCasesList |
|
196 |
|
197 Method: Count |
|
198 |
|
199 Description: Returns count of test cases. |
|
200 |
|
201 Parameters: |
|
202 |
|
203 Return Values: Test cases count. |
|
204 |
|
205 Errors/Exceptions: |
|
206 |
|
207 Status: Approved |
|
208 |
|
209 ------------------------------------------------------------------------------- |
|
210 */ |
|
211 TInt CTestCasesList::Count() const |
|
212 { |
|
213 return iTestCases.Count(); |
|
214 } |
|
215 |
|
216 /* |
|
217 ------------------------------------------------------------------------------- |
|
218 |
|
219 Class: CTestCasesList |
|
220 |
|
221 Method: ResetAndDestroy |
|
222 |
|
223 Description: Resets list of test cases. |
|
224 |
|
225 Parameters: |
|
226 |
|
227 Return Values: |
|
228 |
|
229 Errors/Exceptions: |
|
230 |
|
231 Status: Approved |
|
232 |
|
233 ------------------------------------------------------------------------------- |
|
234 */ |
|
235 void CTestCasesList::ResetAndDestroy() |
|
236 { |
|
237 iTestCases.ResetAndDestroy(); |
|
238 } |
|
239 |
|
240 /* |
|
241 ------------------------------------------------------------------------------- |
|
242 |
|
243 Class: CTestCasesList |
|
244 |
|
245 Method: ~CTestCasesList |
|
246 |
|
247 Description: Destructor |
|
248 |
|
249 Parameters: |
|
250 |
|
251 Return Values: |
|
252 |
|
253 Errors/Exceptions: |
|
254 |
|
255 Status: Approved |
|
256 |
|
257 ------------------------------------------------------------------------------- |
|
258 */ |
|
259 CTestCasesList::CTestCasesList() |
|
260 { |
|
261 } |
|
262 |
|
263 /* |
|
264 ------------------------------------------------------------------------------- |
|
265 |
|
266 Class: CTestCasesList |
|
267 |
|
268 Method: ~CTestCasesList |
|
269 |
|
270 Description: Destructor |
|
271 |
|
272 Parameters: |
|
273 |
|
274 Return Values: |
|
275 |
|
276 Errors/Exceptions: |
|
277 |
|
278 Status: Approved |
|
279 |
|
280 ------------------------------------------------------------------------------- |
|
281 */ |
|
282 void CTestCasesList::ConstructL( const TDesC& aConfigFileName ) |
|
283 { |
|
284 iConfigFileName = aConfigFileName.AllocL(); |
|
285 } |
|
286 |
|
287 /* |
|
288 ------------------------------------------------------------------------------- |
|
289 |
|
290 Class: CTestModule |
|
291 |
|
292 Method: NewL |
|
293 |
|
294 Description: Create new Test Module |
|
295 |
|
296 Parameters: RThread& aClient :in: Handle to client |
|
297 CTestServer* aServer :in: Pointer to server |
|
298 |
|
299 Return Values: CTestModule* Pointer to new test module |
|
300 |
|
301 Errors/Exceptions: Leaves if memory allocation fails or ConstructL leaves. |
|
302 |
|
303 Status: Approved |
|
304 |
|
305 ------------------------------------------------------------------------------- |
|
306 */ |
|
307 CTestModule* CTestModule::NewL( CTestServer* aServer ) |
|
308 { |
|
309 |
|
310 CTestModule* self=new( ELeave ) CTestModule(); |
|
311 CleanupStack::PushL( self ); |
|
312 self->ConstructL( aServer ); |
|
313 CleanupStack::Pop(); |
|
314 return self; |
|
315 } |
|
316 |
|
317 /* |
|
318 ------------------------------------------------------------------------------- |
|
319 |
|
320 Class: CTestModule |
|
321 |
|
322 Method: CTestModule |
|
323 |
|
324 Description: Constructor. |
|
325 Initialise base class. |
|
326 |
|
327 Parameters: RThread& aClient :in: Handle to client |
|
328 |
|
329 Return Values: None |
|
330 |
|
331 Errors/Exceptions: None |
|
332 |
|
333 Status: Approved |
|
334 |
|
335 ------------------------------------------------------------------------------- |
|
336 */ |
|
337 CTestModule::CTestModule() : |
|
338 CSession2(), |
|
339 iIni(0, 0) |
|
340 { |
|
341 } |
|
342 |
|
343 /* |
|
344 ------------------------------------------------------------------------------- |
|
345 |
|
346 Class: CTestModule |
|
347 |
|
348 Method: ~CTestModule |
|
349 |
|
350 Description: Destructor. |
|
351 Deallocate memory and close handles. |
|
352 |
|
353 Parameters: None |
|
354 |
|
355 Return Values: None |
|
356 |
|
357 Errors/Exceptions: None. |
|
358 |
|
359 Status: Proposal |
|
360 |
|
361 ------------------------------------------------------------------------------- |
|
362 */ |
|
363 CTestModule::~CTestModule() |
|
364 { |
|
365 |
|
366 __TRACE( KVerbose, ( _L( "Closing test module" ) ) ); |
|
367 |
|
368 // Free test case related data. No error checking here, because if freeing |
|
369 // fails, then nothing can be done in destructor. |
|
370 FreeCaseData(); |
|
371 |
|
372 // Delete all test module instances. |
|
373 // Cleanup all RTestExecution has been opened by client but not properly |
|
374 // closed for example if timeout occurs and client died. This almost do |
|
375 // same than CloseSession() in "if( iTestExecutionHandle )" branch. |
|
376 if( iTestExecutionHandle ) |
|
377 { |
|
378 TInt handle = 0; |
|
379 CObject* theObj = NULL; |
|
380 TInt count = iTestExecutionHandle->Count(); |
|
381 |
|
382 for( TInt i = 0 ; i < count; i++ ) |
|
383 { |
|
384 // Get pointer to CTestExecution |
|
385 theObj=iTestExecutionHandle->operator[]( i ); |
|
386 if( theObj ) |
|
387 { |
|
388 handle=iTestExecutionHandle->At( theObj ); |
|
389 |
|
390 CTestExecution* testcase = (CTestExecution*) theObj; |
|
391 // Cancels test(s) execution(timeout, exit, etc) |
|
392 // For example TestCombiner is timeouted => TestCombiner's |
|
393 // TestServer+TestModule(s) should cancel also. |
|
394 testcase->CancelTestExecution(); |
|
395 // CTestExecution will panic if test case is ongoing!!! This |
|
396 // should be stopped, client should handless this. |
|
397 iTestExecutionHandle->Remove( handle ); |
|
398 } |
|
399 } |
|
400 |
|
401 delete iTestExecutionHandle; |
|
402 iTestExecutionHandle = NULL; |
|
403 |
|
404 } |
|
405 |
|
406 // Delete all FREE Test Module instances. |
|
407 if( iTestModuleInstances ) |
|
408 { |
|
409 iTestModuleInstances->ResetAndDestroy(); |
|
410 delete iTestModuleInstances; |
|
411 iTestModuleInstances = NULL; |
|
412 } |
|
413 |
|
414 // Delete ini file heap buffer |
|
415 delete iIniBuffer; |
|
416 iIniBuffer = NULL; |
|
417 |
|
418 // Delete array of test case titles |
|
419 iTestCaseTitlesMap.ResetAndDestroy(); |
|
420 iTestCaseTitlesMap.Close(); |
|
421 } |
|
422 |
|
423 /* |
|
424 ------------------------------------------------------------------------------- |
|
425 |
|
426 Class: CTestModule |
|
427 |
|
428 Method: ConstructL |
|
429 |
|
430 Description: Second level constructor. |
|
431 |
|
432 Parameters: CTestServer* aServer :in: Server |
|
433 |
|
434 Return Values: None |
|
435 |
|
436 Errors/Exceptions: Leaves if: |
|
437 base class CreateL leaves |
|
438 Object index creation fails |
|
439 Object container creation fails |
|
440 Pointer array construction fails |
|
441 |
|
442 Status: Approved |
|
443 |
|
444 ------------------------------------------------------------------------------- |
|
445 */ |
|
446 void CTestModule::ConstructL( CTestServer* aServer ) |
|
447 { |
|
448 |
|
449 __TRACE( KVerbose, ( _L( "CTestModule::ConstructL - constructing server session" ) ) ); |
|
450 |
|
451 // second-phase construct base class |
|
452 //CSession2::CreateL( /* *aServer */ ); |
|
453 iTestServer = aServer; |
|
454 |
|
455 // create new object index |
|
456 iTestExecutionHandle = CObjectIx::NewL(); |
|
457 |
|
458 // Initialize the object container using the object |
|
459 // container index in the server. |
|
460 iContainer = iTestServer->NewContainerL(); |
|
461 |
|
462 iTestModuleInstances = new( ELeave ) RPointerArray<CTestModuleContainer>; |
|
463 |
|
464 __TRACE( KError, ( _L( "CTestModule::ConstructL - constructing server session done" ) ) ); |
|
465 |
|
466 } |
|
467 |
|
468 |
|
469 /* |
|
470 ------------------------------------------------------------------------------- |
|
471 |
|
472 Class: CTestModule |
|
473 |
|
474 Method: CountResources |
|
475 |
|
476 Description: Resource counting |
|
477 |
|
478 Parameters: None |
|
479 |
|
480 Return Values: TInt Resource count |
|
481 |
|
482 Errors/Exceptions: None |
|
483 |
|
484 Status: Approved |
|
485 |
|
486 ------------------------------------------------------------------------------- |
|
487 */ |
|
488 TInt CTestModule::CountResources() |
|
489 { |
|
490 |
|
491 return iResourceCount; |
|
492 |
|
493 } |
|
494 |
|
495 |
|
496 /* |
|
497 ------------------------------------------------------------------------------- |
|
498 |
|
499 Class: CTestModule |
|
500 |
|
501 Method: NumResources |
|
502 |
|
503 Description: Get resources, writes to Message() |
|
504 |
|
505 Parameters: None |
|
506 |
|
507 Return Values: None |
|
508 |
|
509 Errors/Exceptions: Panic client if result can't be written to descriptor. |
|
510 |
|
511 Status: Approved |
|
512 |
|
513 ------------------------------------------------------------------------------- |
|
514 */ |
|
515 void CTestModule::NumResources( const RMessage2& aMessage ) |
|
516 { |
|
517 |
|
518 TPckgBuf<TInt> countPckg( iResourceCount ); |
|
519 |
|
520 TRAPD( r, aMessage.WriteL( 0, countPckg ) ); |
|
521 if( r !=KErrNone ) |
|
522 { |
|
523 PanicClient( EBadDescriptor, aMessage ); |
|
524 } |
|
525 |
|
526 } |
|
527 |
|
528 /* |
|
529 ------------------------------------------------------------------------------- |
|
530 |
|
531 Class: CTestModule |
|
532 |
|
533 Method: PanicClient |
|
534 |
|
535 Description: Panic clients. |
|
536 |
|
537 Parameters: TInt aPanic :in: Panic code |
|
538 |
|
539 Return Values: None |
|
540 |
|
541 Errors/Exceptions: None |
|
542 |
|
543 Status: Approved |
|
544 |
|
545 ------------------------------------------------------------------------------- |
|
546 */ |
|
547 void CTestModule::PanicClient( const TInt aPanic, const RMessage2& aMessage ) const |
|
548 { |
|
549 |
|
550 __TRACE( KError,( _L( "CTestModule::PanicClient code = %d" ), aPanic ) ); |
|
551 |
|
552 _LIT( KTxtTestModule,"CTestModule" ); |
|
553 |
|
554 aMessage.Panic( KTxtTestModule, aPanic ); |
|
555 } |
|
556 |
|
557 |
|
558 /* |
|
559 ------------------------------------------------------------------------------- |
|
560 |
|
561 Class: CTestModule |
|
562 |
|
563 Method: CloseSession |
|
564 |
|
565 Description: Close session |
|
566 |
|
567 Parameters: None |
|
568 |
|
569 Return Values: TInt: Symbian error code. |
|
570 |
|
571 Errors/Exceptions: None |
|
572 |
|
573 Status: Approved |
|
574 |
|
575 ------------------------------------------------------------------------------- |
|
576 */ |
|
577 TInt CTestModule::CloseSession( const RMessage2& aMessage ) |
|
578 { |
|
579 |
|
580 __TRACE( KMessage,( _L( "CTestModule::CloseSession in" ) ) ); |
|
581 |
|
582 // Delete all unclosed subsession handle before closing session. |
|
583 // Remove iTestExecutionHandle contents. iTestExecutionHandle countains |
|
584 // CTestExecution that handles test case have been created. |
|
585 if( iTestExecutionHandle ) |
|
586 { |
|
587 TInt handle = 0; |
|
588 CObject* theObj = NULL; |
|
589 TInt count = iTestExecutionHandle->Count(); |
|
590 for ( TInt i = count - 1; i >= 0; i-- ) |
|
591 { |
|
592 theObj=iTestExecutionHandle->operator[]( i ); |
|
593 if( theObj ) |
|
594 { |
|
595 handle=iTestExecutionHandle->At( theObj ); |
|
596 // CTestExecution will panic if test case is ongoing!!! This |
|
597 // should be stopped, client should handle this. |
|
598 iTestExecutionHandle->Remove( handle ); |
|
599 } |
|
600 } |
|
601 |
|
602 delete iTestExecutionHandle; |
|
603 iTestExecutionHandle = NULL; |
|
604 } |
|
605 |
|
606 // Deletion must be done here, because the "CloseSession" message is |
|
607 // completed before execution continues from CActiveScheduler::Start |
|
608 // location, and the main thread can continue execution |
|
609 // and therefore shutdown itself and all threads in that process. |
|
610 |
|
611 // Delete the object container |
|
612 iTestServer->DeleteContainer( iContainer ); |
|
613 |
|
614 // Free test case related data |
|
615 TInt r = FreeCaseData(); |
|
616 |
|
617 // Delete all FREE Test Module instances |
|
618 iTestModuleInstances->ResetAndDestroy(); |
|
619 delete iTestModuleInstances; |
|
620 iTestModuleInstances = NULL; |
|
621 |
|
622 // Inform server that session is closed |
|
623 iTestServer->SessionClosed(); |
|
624 |
|
625 // Check for avoiding multiple complete, see CTestModule::ServiceL() |
|
626 if( r != KErrNone ) |
|
627 { |
|
628 // In error cases do not complete, just return |
|
629 __TRACE( KMessage,( _L( "CTestModule::CloseSession out (1)" ) ) ); |
|
630 return r; |
|
631 } |
|
632 |
|
633 aMessage.Complete( KErrNone ); |
|
634 |
|
635 // After active scheduler shutdown is done, execution continues from |
|
636 // CTestServer::ThreadFunction() |
|
637 |
|
638 __TRACE( KMessage,( _L( "CTestModule::CloseSession out (2)" ) ) ); |
|
639 return r; |
|
640 } |
|
641 |
|
642 |
|
643 /* |
|
644 ------------------------------------------------------------------------------- |
|
645 |
|
646 Class: CTestModule |
|
647 |
|
648 Method: ServiceL |
|
649 |
|
650 Description: Trap harness for dispatcher |
|
651 |
|
652 Parameters: const RMessage& aMessage :inout: Message |
|
653 |
|
654 Return Values: None |
|
655 |
|
656 Errors/Exceptions: None |
|
657 |
|
658 Status: Proposal |
|
659 |
|
660 ------------------------------------------------------------------------------- |
|
661 */ |
|
662 void CTestModule::ServiceL( const RMessage2& aMessage ) |
|
663 { |
|
664 |
|
665 // NOTE! HW testing slows down dramatically if adds commants here |
|
666 |
|
667 //__TRACE( KMessage,( _L( "CTestModule::ServiceL in" ) ) ); |
|
668 |
|
669 TInt r = KErrNone; |
|
670 TRAPD( ret, r = DispatchMessageL( aMessage ) ); |
|
671 |
|
672 if ( ret != KErrNone ) |
|
673 { |
|
674 // Complete message on leaving cases with leave code. |
|
675 __TRACE( KError, ( CStifLogger::ERed, _L( "CTestModule::DispatchMessageL leaved" ) ) ); |
|
676 aMessage.Complete( ret ); |
|
677 } |
|
678 |
|
679 // Complete message with error code originating from message handling |
|
680 // function. |
|
681 if ( r != KErrNone ) |
|
682 { |
|
683 __TRACE( KError, ( CStifLogger::ERed, _L( "CTestModule::DispatchMessageL returned error" ) ) ); |
|
684 aMessage.Complete( r ); |
|
685 } |
|
686 |
|
687 // __TRACE( KMessage,( _L( "CTestModule::ServiceL out" ) ) ); |
|
688 |
|
689 } |
|
690 |
|
691 |
|
692 /* |
|
693 ------------------------------------------------------------------------------- |
|
694 |
|
695 Class: CTestModule |
|
696 |
|
697 Method: DispatchMessageL |
|
698 |
|
699 Description: Dispatch message, calls corresponding function to do it. |
|
700 |
|
701 Parameters: const RMessage& aMessage :inout: Message to be handled |
|
702 |
|
703 Return Values: TInt Error code |
|
704 |
|
705 Errors/Exceptions: Leaves if operation handling function leaves |
|
706 |
|
707 Status: Proposal |
|
708 |
|
709 ------------------------------------------------------------------------------- |
|
710 */ |
|
711 TInt CTestModule::DispatchMessageL( const RMessage2& aMessage ) |
|
712 { |
|
713 |
|
714 __TRACE( KMessage,( _L( "CTestModule::DispatchMessageL %d" ), |
|
715 aMessage.Function() ) ); |
|
716 switch( aMessage.Function() ) |
|
717 { |
|
718 // Session specific |
|
719 case ETestServerCloseSession: // Close whole session |
|
720 { |
|
721 __TRACE( KError ,( _L( "Closing test module session" ) ) ); |
|
722 return CloseSession( aMessage ); |
|
723 } |
|
724 case ETestServerGetServerThreadId: // Get Server ThreadId |
|
725 { |
|
726 __TRACE( KError ,( _L( "Return server thread id" ) ) ); |
|
727 return GetServerThreadIdL( aMessage ); |
|
728 } |
|
729 |
|
730 case ETestServerPassEngineSessionSettings: |
|
731 { |
|
732 __TRACE( KError ,( _L( "Passing test engine session settings to testserver session" ) ) ); |
|
733 return PassEngineSessionSettings( aMessage ); |
|
734 } |
|
735 |
|
736 case ETestModuleCreateSubSession : // Create new test module subsession |
|
737 { |
|
738 __TRACE( KError,( _L( "Creating test module session" ) ) ); |
|
739 return CreateModuleSessionL( aMessage ); |
|
740 } |
|
741 |
|
742 case ETestModuleCloseSubSession: // Close module subsession |
|
743 { |
|
744 // Nothing to do. |
|
745 aMessage.Complete( KErrNone ); |
|
746 return KErrNone; |
|
747 } |
|
748 |
|
749 case ETestExecutionCreateSubSession: // Create new test execution subsession |
|
750 { |
|
751 return NewTestExecutionL( aMessage ); |
|
752 } |
|
753 |
|
754 case ETestModuleEnumerateTestCases: // Enumerate test cases |
|
755 { |
|
756 __TRACE( KError,( _L( "Enumerating test cases" ) ) ); |
|
757 return EnumerateTestCasesL( aMessage ); |
|
758 } |
|
759 |
|
760 case ETestModuleGetTestCases: // Get test cases |
|
761 { |
|
762 return GetTestCasesL( aMessage ); |
|
763 } |
|
764 |
|
765 case ETestModuleErrorNotification: // Request error notification |
|
766 { |
|
767 return HandleErrorNotificationL( aMessage ); |
|
768 } |
|
769 |
|
770 case ETestModuleCancelAsyncRequest: |
|
771 { |
|
772 return CancelAsyncRequestL( aMessage ); |
|
773 } |
|
774 |
|
775 // Subsession specific |
|
776 case ETestExecutionRunTestCase: // Run test case |
|
777 { |
|
778 __TRACE( KInit,( _L( "Running test case" ) ) ); |
|
779 CTestExecution* testCase=CaseFromHandle( aMessage.Int3(), aMessage ); |
|
780 return testCase->RunTestCase( aMessage ); |
|
781 } |
|
782 |
|
783 case ETestExecutionNotifyProgress: // Test case prints |
|
784 { |
|
785 CTestExecution* testCase=CaseFromHandle( aMessage.Int3(), aMessage ); |
|
786 return testCase->NotifyPrint( aMessage ); |
|
787 } |
|
788 |
|
789 case ETestExecutionNotifyEvent: // Event notifications |
|
790 { |
|
791 CTestExecution* testCase=CaseFromHandle( aMessage.Int3(), aMessage ); |
|
792 return testCase->NotifyEvent( aMessage ); |
|
793 } |
|
794 |
|
795 case ETestExecutionNotifyRemoteCmd: // RemoteCmd notifications |
|
796 { |
|
797 CTestExecution* testCase=CaseFromHandle( aMessage.Int3(), aMessage ); |
|
798 return testCase->NotifyRemoteCmd( aMessage ); |
|
799 } |
|
800 case ETestExecutionReadRemoteCmdInfo: // RemoteCmd reading |
|
801 { |
|
802 //CTestExecution* testCase=CaseFromHandle( aMessage.Int3() ); |
|
803 //return testCase->NotifyRemoteCmd( aMessage ); |
|
804 CTestExecution* testCase=CaseFromHandle( aMessage.Int3(), aMessage ); |
|
805 return testCase->ReadRemoteCmdInfo( aMessage ); |
|
806 } |
|
807 |
|
808 |
|
809 case ETestExecutionResume: // Resume case execution |
|
810 { |
|
811 __TRACE( KVerbose,( _L( "Resuming test execution" ) ) ); |
|
812 CTestExecution* testCase=CaseFromHandle( aMessage.Int3(), aMessage ); |
|
813 return testCase->Resume( aMessage ); |
|
814 } |
|
815 |
|
816 case ETestExecutionPause: // Pause case execution |
|
817 { |
|
818 __TRACE( KVerbose,( _L( "Pausing test execution" ) ) ); |
|
819 CTestExecution* testCase=CaseFromHandle( aMessage.Int3(), aMessage ); |
|
820 return testCase->Pause( aMessage ); |
|
821 } |
|
822 |
|
823 case ETestExecutionCloseSubSession: // Close execution subsession |
|
824 { |
|
825 CTestExecution* testCase=CaseFromHandle( aMessage.Int3(), aMessage ); |
|
826 return testCase->CloseTestExecution( aMessage ); |
|
827 } |
|
828 |
|
829 case ETestExecutionCancelAsyncRequest: // Cancel async request |
|
830 { |
|
831 CTestExecution* testCase=CaseFromHandle( aMessage.Int3(), aMessage ); |
|
832 return testCase->CancelRequestL( aMessage ); |
|
833 } |
|
834 case ETestExecutionNotifyCommand: // Command notifications |
|
835 { |
|
836 CTestExecution* testCase=CaseFromHandle( aMessage.Int3(), aMessage ); |
|
837 return testCase->NotifyCommand( aMessage ); |
|
838 } |
|
839 |
|
840 default: // Invalid request |
|
841 { |
|
842 PanicClient( EBadRequest, aMessage ); |
|
843 return KErrNotSupported; |
|
844 } |
|
845 } |
|
846 |
|
847 } |
|
848 |
|
849 |
|
850 /* |
|
851 ------------------------------------------------------------------------------- |
|
852 |
|
853 Class: CTestModule |
|
854 |
|
855 Method: EnumerateTestCases |
|
856 |
|
857 Description: Enumerates test cases and returns test case count by writing |
|
858 result to client side package. |
|
859 |
|
860 Function obtains a TestModule and calls EnumerateTestCases from it. |
|
861 Test module will be released when calling GetTestCases function. |
|
862 |
|
863 Parameters: const RMessage& aMessage :inout: Message to be handled |
|
864 |
|
865 Return Values: TInt Operation result |
|
866 |
|
867 Errors/Exceptions: None |
|
868 |
|
869 Status: Proposal |
|
870 |
|
871 ------------------------------------------------------------------------------- |
|
872 */ |
|
873 TInt CTestModule::EnumerateTestCasesL( const RMessage2& aMessage ) |
|
874 { |
|
875 |
|
876 __TRACE( KMessage,( _L( "CTestModule::EnumerateTestCasesL in" ) ) ); |
|
877 |
|
878 // Get data from message |
|
879 TFileName config; |
|
880 TRAPD( res, aMessage.ReadL( 0, config ) ); |
|
881 if(res == KErrDied) |
|
882 { |
|
883 RDebug::Print(_L("CTestModule::EnumerateTestCasesL() Reading from RMessage ended with KErrDied. Client is not alive anymore and this request will be ignored")); |
|
884 return res; |
|
885 } |
|
886 else if( res != KErrNone ) |
|
887 { |
|
888 RDebug::Print(_L("CTestModule::EnumerateTestCasesL() #1 Panic client with [%d], res=[%d]"), EBadDescriptor, res); |
|
889 PanicClient( EBadDescriptor, aMessage ); |
|
890 return res; |
|
891 } |
|
892 |
|
893 // Free old case data |
|
894 User::LeaveIfError( FreeCaseData() ); |
|
895 |
|
896 // Get test cases from the test module |
|
897 User::LeaveIfError( GetTestModule( iEnumerateModule, config ) ); |
|
898 |
|
899 // Enumerate test cases |
|
900 iEnumerateModule->EnumerateTestCases( config ); |
|
901 |
|
902 // Something fatal? |
|
903 TInt r = iEnumerateModule->OperationErrorResult(); |
|
904 if( r != KErrNone ) |
|
905 { |
|
906 // Enumeration module have crashed. |
|
907 delete iEnumerateModule; |
|
908 iEnumerateModule = NULL; |
|
909 |
|
910 return r; |
|
911 } |
|
912 |
|
913 // Error from module? |
|
914 if( iEnumerateModule->ModuleResult() != KErrNone ) |
|
915 { |
|
916 return iEnumerateModule->ModuleResult(); |
|
917 } |
|
918 |
|
919 // Write count to Ptr1() |
|
920 const RPointerArray<TTestCaseInfo>* testCases = iEnumerateModule->TestCases(); |
|
921 |
|
922 if( testCases == NULL ) |
|
923 { |
|
924 User::Leave( KErrGeneral ); |
|
925 } |
|
926 |
|
927 CTestCasesList* testCasesList = NULL; |
|
928 for ( TInt i = 0; i < iTestCaseTitlesMap.Count(); i++ ) |
|
929 { |
|
930 if ( iTestCaseTitlesMap[ i ]->GetConfigFileName() == config ) |
|
931 { |
|
932 testCasesList = iTestCaseTitlesMap[ i ]; |
|
933 break; |
|
934 } |
|
935 } |
|
936 if ( testCasesList == NULL ) |
|
937 { |
|
938 testCasesList = CTestCasesList::NewL( config ); |
|
939 CleanupStack::PushL( testCasesList ); |
|
940 iTestCaseTitlesMap.AppendL( testCasesList ); |
|
941 CleanupStack::Pop( testCasesList ); |
|
942 } |
|
943 |
|
944 // Store titles (for further use, i.e. when asked for title from the interface via CTestModuleIf->CTestThreadContainer->CTestModuleContainer) |
|
945 testCasesList->ResetAndDestroy(); |
|
946 TInt i; |
|
947 for(i = 0; i < testCases->Count(); i++) |
|
948 { |
|
949 //Handle situation when test cases are enumerated not as 0-based (testscripter, ...) |
|
950 if(i == 0 && (*testCases)[i]->iCaseNumber > 0) |
|
951 { |
|
952 testCasesList->AppendTestCaseL( KNullDesC ); |
|
953 } |
|
954 testCasesList->AppendTestCaseL( (*testCases)[i]->iTitle ); |
|
955 } |
|
956 |
|
957 TPckgBuf<TInt> countPckg( testCases->Count() ); |
|
958 TRAP( res, aMessage.WriteL( 1, countPckg ) ); |
|
959 if(res == KErrDied) |
|
960 { |
|
961 RDebug::Print(_L("CTestModule::EnumerateTestCasesL() Writing to RMessage ended with KErrDied. Client is not alive anymore and this request will be ignored")); |
|
962 return res; |
|
963 } |
|
964 else if( res != KErrNone ) |
|
965 { |
|
966 RDebug::Print(_L("CTestModule::EnumerateTestCasesL() #2 Panic client with [%d], res=[%d], config=[%S]"), EBadDescriptor, res, &config); |
|
967 PanicClient( EBadDescriptor, aMessage ); |
|
968 return res; |
|
969 } |
|
970 |
|
971 // All ok, complete message |
|
972 aMessage.Complete( KErrNone ); |
|
973 |
|
974 __TRACE( KMessage,( _L( "CTestModule::EnumerateTestCasesL out" ) ) ); |
|
975 |
|
976 return KErrNone; |
|
977 |
|
978 } |
|
979 |
|
980 |
|
981 /* |
|
982 ------------------------------------------------------------------------------- |
|
983 |
|
984 Class: CTestModule |
|
985 |
|
986 Method: GetTestCasesL |
|
987 |
|
988 Description: Get test cases. Enumerate test cases must be called before |
|
989 calling this function. |
|
990 |
|
991 Function releases the test module reserved by EnumerateTestCase(). |
|
992 |
|
993 Parameters: const RMessage& aMessage :inout: Message to be handled |
|
994 |
|
995 Return Values: TInt Operation result |
|
996 |
|
997 Errors/Exceptions: Leaves if cases have not been enumerated. |
|
998 |
|
999 Status: Proposal |
|
1000 |
|
1001 ------------------------------------------------------------------------------- |
|
1002 */ |
|
1003 TInt CTestModule::GetTestCasesL( const RMessage2& aMessage ) |
|
1004 { |
|
1005 |
|
1006 __TRACE( KMessage,( _L( "CTestModule::GetTestCasesL in" ) ) ); |
|
1007 |
|
1008 // Leave if cases have not been enumerated. |
|
1009 //User::LeaveIfNull(( TAny* ) iEnumerateModule->TestCases() ); |
|
1010 if( ( TAny* ) iEnumerateModule->TestCases() == NULL ) |
|
1011 { |
|
1012 User::Leave( KErrGeneral ); |
|
1013 } |
|
1014 |
|
1015 const TInt len = sizeof( TTestCaseInfo ); |
|
1016 |
|
1017 // Get cases |
|
1018 const RPointerArray<TTestCaseInfo>& cases = *iEnumerateModule->TestCases(); |
|
1019 |
|
1020 // Get number of cases |
|
1021 const TInt Kcount = cases.Count(); |
|
1022 |
|
1023 // Loop through case and copy then to client's descriptor. |
|
1024 for( TInt i = 0; i < Kcount; i++ ) |
|
1025 { |
|
1026 |
|
1027 // Construct package for source data |
|
1028 TTestCaseInfoPckg tmpPackage( *cases[i] ); |
|
1029 |
|
1030 // Write to correct location |
|
1031 aMessage.WriteL( 0, tmpPackage, i *len ); |
|
1032 |
|
1033 } |
|
1034 |
|
1035 // Free case data and the test module |
|
1036 User::LeaveIfError( FreeCaseData() ); |
|
1037 |
|
1038 // Finished |
|
1039 aMessage.Complete( KErrNone ); |
|
1040 |
|
1041 __TRACE( KMessage,( _L( "CTestModule::GetTestCasesL out" ) ) ); |
|
1042 |
|
1043 return KErrNone; |
|
1044 |
|
1045 } |
|
1046 |
|
1047 |
|
1048 /* |
|
1049 ------------------------------------------------------------------------------- |
|
1050 |
|
1051 Class: CTestModule |
|
1052 |
|
1053 Method: HandleErrorNotification |
|
1054 |
|
1055 Description: Request error notification. |
|
1056 |
|
1057 Parameters: const RMessage& aMessage :inout: Message to be handled |
|
1058 |
|
1059 Return Values: TInt Operation result |
|
1060 |
|
1061 Errors/Exceptions: None |
|
1062 |
|
1063 Status: Proposal |
|
1064 |
|
1065 ------------------------------------------------------------------------------- |
|
1066 */ |
|
1067 TInt CTestModule::HandleErrorNotificationL( const RMessage2& aMessage ) |
|
1068 { |
|
1069 |
|
1070 iErrorMessage = aMessage; |
|
1071 iErrorMessageAvailable = ETrue; |
|
1072 |
|
1073 return KErrNone; |
|
1074 |
|
1075 } |
|
1076 |
|
1077 /* |
|
1078 ------------------------------------------------------------------------------- |
|
1079 |
|
1080 Class: CTestModule |
|
1081 |
|
1082 Method: GetServerThreadId |
|
1083 |
|
1084 Description: Request server state notification. |
|
1085 |
|
1086 Parameters: const RMessage& aMessage :inout: Message to be handled |
|
1087 |
|
1088 Return Values: TInt Operation result |
|
1089 |
|
1090 Errors/Exceptions: None |
|
1091 |
|
1092 Status: Proposal |
|
1093 |
|
1094 ------------------------------------------------------------------------------- |
|
1095 */ |
|
1096 TInt CTestModule::GetServerThreadIdL( const RMessage2& aMessage ) |
|
1097 { |
|
1098 |
|
1099 TInt id( iTestServer->GetServerThreadId() ); |
|
1100 |
|
1101 TPckg<TThreadId> threadIdPckg( id ); |
|
1102 |
|
1103 TRAPD( res, aMessage.WriteL( 0, threadIdPckg ) ); |
|
1104 |
|
1105 // Finished |
|
1106 aMessage.Complete( res ); |
|
1107 |
|
1108 return KErrNone; |
|
1109 |
|
1110 } |
|
1111 |
|
1112 TInt CTestModule::PassEngineSessionSettings( const RMessage2& aMessage ) |
|
1113 { |
|
1114 TPckgBuf<TEngineSettings> engineSettings; |
|
1115 |
|
1116 TRAPD( ret, aMessage.ReadL( 0, engineSettings, 0 ) ); |
|
1117 |
|
1118 iUiTesting = engineSettings().iUITestingSupport; |
|
1119 iSeperateProcesses = engineSettings().iSeparateProcesses; |
|
1120 |
|
1121 aMessage.Complete( ret ); |
|
1122 |
|
1123 return KErrNone; |
|
1124 } |
|
1125 |
|
1126 |
|
1127 /* |
|
1128 ------------------------------------------------------------------------------- |
|
1129 |
|
1130 Class: CTestModule |
|
1131 |
|
1132 Method: CancelAsyncRequest |
|
1133 |
|
1134 Description: Cancels asynchronous request |
|
1135 |
|
1136 Parameters: const RMessage& aMessage :inout: Message to be handled |
|
1137 |
|
1138 Return Values: TInt Operation result |
|
1139 |
|
1140 Errors/Exceptions: None |
|
1141 |
|
1142 Status: Proposal |
|
1143 |
|
1144 ------------------------------------------------------------------------------- |
|
1145 */ |
|
1146 TInt CTestModule::CancelAsyncRequestL( const RMessage2& aMessage ) |
|
1147 { |
|
1148 |
|
1149 switch ( aMessage.Int0() ) |
|
1150 { |
|
1151 case ETestModuleErrorNotification: |
|
1152 { |
|
1153 if ( iErrorMessageAvailable ) |
|
1154 { |
|
1155 iErrorMessage.Complete ( KErrCancel ); |
|
1156 iErrorMessageAvailable = EFalse; |
|
1157 } |
|
1158 aMessage.Complete ( KErrNone ); |
|
1159 break; |
|
1160 } |
|
1161 |
|
1162 default: |
|
1163 { |
|
1164 PanicClient( EInvalidRequestCancel, aMessage ); |
|
1165 break; |
|
1166 } |
|
1167 } |
|
1168 |
|
1169 return KErrNone; |
|
1170 |
|
1171 } |
|
1172 |
|
1173 /* |
|
1174 ------------------------------------------------------------------------------- |
|
1175 |
|
1176 Class: CTestModule |
|
1177 |
|
1178 Method: ErrorPrint |
|
1179 |
|
1180 Description: Prints error |
|
1181 |
|
1182 Parameters: const TInt aPriority :in: Priority |
|
1183 TPtrC aError: in: Error |
|
1184 |
|
1185 Return Values: None |
|
1186 |
|
1187 Errors/Exceptions: None |
|
1188 |
|
1189 Status: Proposal |
|
1190 |
|
1191 ------------------------------------------------------------------------------- |
|
1192 */ |
|
1193 void CTestModule::ErrorPrint( const TInt aPriority, |
|
1194 TPtrC aError ) |
|
1195 { |
|
1196 |
|
1197 if ( iErrorMessageAvailable ) |
|
1198 { |
|
1199 TErrorNotification error; |
|
1200 TErrorNotificationPckg errorPckg ( error ); |
|
1201 |
|
1202 error.iModule = _L("TestServer"); |
|
1203 error.iPriority = aPriority; |
|
1204 error.iText = aError; |
|
1205 |
|
1206 TRAPD( r, iErrorMessage.WriteL( 0, errorPckg ) ); |
|
1207 |
|
1208 // Do not handle errors |
|
1209 iErrorMessageAvailable = EFalse; |
|
1210 iErrorMessage.Complete( r ); |
|
1211 |
|
1212 } |
|
1213 else |
|
1214 { |
|
1215 RDebug::Print (_L("Error message lost %d [%S]"), aPriority, &aError ); |
|
1216 } |
|
1217 |
|
1218 } |
|
1219 |
|
1220 /* |
|
1221 ------------------------------------------------------------------------------- |
|
1222 |
|
1223 Class: CTestModule |
|
1224 |
|
1225 Method: FreeCaseData |
|
1226 |
|
1227 Description: Frees the test case data and test module that is used in |
|
1228 enumeration. |
|
1229 |
|
1230 Parameters: None |
|
1231 |
|
1232 Return Values: TInt Error code |
|
1233 |
|
1234 Errors/Exceptions: None |
|
1235 |
|
1236 Status: Proposal |
|
1237 |
|
1238 ------------------------------------------------------------------------------- |
|
1239 */ |
|
1240 TInt CTestModule::FreeCaseData() |
|
1241 { |
|
1242 |
|
1243 __TRACE( KMessage,( _L( "CTestModule::FreeCaseData in" ) ) ); |
|
1244 |
|
1245 TInt r = KErrNone; |
|
1246 |
|
1247 if( iEnumerateModule ) |
|
1248 { |
|
1249 |
|
1250 // Deallocate testcase memory |
|
1251 iEnumerateModule->FreeEnumerationData(); |
|
1252 |
|
1253 // Free the module |
|
1254 r = FreeTestModule( iEnumerateModule ); |
|
1255 |
|
1256 iEnumerateModule = NULL; |
|
1257 |
|
1258 } |
|
1259 |
|
1260 __TRACE( KMessage,( _L( "CTestModule::FreeCaseData out" ) ) ); |
|
1261 |
|
1262 return r; |
|
1263 |
|
1264 } |
|
1265 |
|
1266 |
|
1267 /* |
|
1268 ------------------------------------------------------------------------------- |
|
1269 |
|
1270 Class: CTestModule |
|
1271 |
|
1272 Method: CreateModuleSessionL |
|
1273 |
|
1274 Description: Creates a new module session. |
|
1275 Just take the initialisation file name from message. |
|
1276 |
|
1277 Parameters: const RMessage& aMessage :inout: Message to be handled |
|
1278 |
|
1279 Return Values: TInt Operation result |
|
1280 |
|
1281 Errors/Exceptions: Leaves if memory allocation fails |
|
1282 |
|
1283 Status: Proposal |
|
1284 |
|
1285 ------------------------------------------------------------------------------- |
|
1286 */ |
|
1287 TInt CTestModule::CreateModuleSessionL( const RMessage2& aMessage ) |
|
1288 { |
|
1289 |
|
1290 __TRACE( KMessage,( _L( "CTestModule::CreateModuleSession in" ) ) ); |
|
1291 |
|
1292 // Take parameters |
|
1293 TFileName ini; |
|
1294 TRAPD( res, aMessage.ReadL( 0, ini ) ); |
|
1295 if( res != KErrNone ) |
|
1296 { |
|
1297 PanicClient( EBadDescriptor, aMessage ); |
|
1298 return res; |
|
1299 } |
|
1300 |
|
1301 // Construct heap buffer for initialization file name |
|
1302 iIniBuffer = HBufC::NewL( ini.Length() ); |
|
1303 iIni.Set ( iIniBuffer->Des() ); |
|
1304 iIni.Copy ( ini ); |
|
1305 |
|
1306 aMessage.Complete( KErrNone ); |
|
1307 |
|
1308 __TRACE( KMessage,( _L( "CTestModule::CreateModuleSession out" ) ) ); |
|
1309 |
|
1310 return KErrNone; |
|
1311 |
|
1312 } |
|
1313 |
|
1314 /* |
|
1315 ------------------------------------------------------------------------------- |
|
1316 |
|
1317 Class: CTestModule |
|
1318 |
|
1319 Method: NewTestExecutionL |
|
1320 |
|
1321 Description: Create new test execution subsession |
|
1322 |
|
1323 Parameters: const RMessage& aMessage :inout: Message to be handled |
|
1324 |
|
1325 Return Values: TInt Operation result |
|
1326 |
|
1327 Errors/Exceptions: Function leaves if object can't be created or |
|
1328 it can't be added to container. |
|
1329 Function panics client if message contains invalid |
|
1330 descriptor. |
|
1331 |
|
1332 Status: Proposal |
|
1333 |
|
1334 ------------------------------------------------------------------------------- |
|
1335 */ |
|
1336 TInt CTestModule::NewTestExecutionL( const RMessage2& aMessage ) |
|
1337 { |
|
1338 |
|
1339 __TRACE( KMessage,( _L( "CTestModule::NewTestExecutionL in" ) ) ); |
|
1340 |
|
1341 // Get data from message |
|
1342 TInt caseNumber = aMessage.Int0(); |
|
1343 TFileName config; |
|
1344 |
|
1345 TRAPD( res, aMessage.ReadL( 1, config ) ); |
|
1346 if( res != KErrNone ) |
|
1347 { |
|
1348 PanicClient( EBadDescriptor, aMessage ); |
|
1349 return res; |
|
1350 } |
|
1351 |
|
1352 // Make new object |
|
1353 CTestExecution* execution=CTestExecution::NewL( this, caseNumber, config ); |
|
1354 |
|
1355 // add object to object container to generate unique id |
|
1356 iContainer->AddL( execution ); |
|
1357 |
|
1358 // add object to object index; this returns a unique handle so we can get it again |
|
1359 TInt handle=iTestExecutionHandle->AddL( execution ); |
|
1360 |
|
1361 // write the handle to client |
|
1362 TPckg<TInt> handlePckg( handle ); |
|
1363 TRAP( res, aMessage.WriteL( 3, handlePckg ) ); |
|
1364 if( res != KErrNone ) |
|
1365 { |
|
1366 iTestExecutionHandle->Remove( handle ); |
|
1367 PanicClient( EBadDescriptor, aMessage ); |
|
1368 return res; |
|
1369 } |
|
1370 |
|
1371 // notch up another resource |
|
1372 iResourceCount++; |
|
1373 |
|
1374 // Complete message |
|
1375 aMessage.Complete( KErrNone ); |
|
1376 |
|
1377 __TRACE( KMessage,( _L( "CTestModule::NewTestExecutionL out" ) ) ); |
|
1378 |
|
1379 return KErrNone; |
|
1380 } |
|
1381 |
|
1382 /* |
|
1383 ------------------------------------------------------------------------------- |
|
1384 |
|
1385 Class: CTestModule |
|
1386 |
|
1387 Method: DeleteTestExecution |
|
1388 |
|
1389 Description: Deletes Test Execution by handle |
|
1390 |
|
1391 Parameters: const TUint aHandle :in: Handle |
|
1392 |
|
1393 Return Values: None |
|
1394 |
|
1395 Errors/Exceptions: Panics client if invalid handle |
|
1396 |
|
1397 Status: Proposal |
|
1398 |
|
1399 ------------------------------------------------------------------------------- |
|
1400 */ |
|
1401 void CTestModule::DeleteTestExecution( const TUint aHandle, const RMessage2& aMessage ) |
|
1402 { |
|
1403 |
|
1404 // Verify that handle is valid |
|
1405 CaseFromHandle( aHandle, aMessage ); |
|
1406 |
|
1407 // Remove object |
|
1408 iTestExecutionHandle->Remove( aHandle ); |
|
1409 |
|
1410 // Decrement resource count. |
|
1411 iResourceCount--; |
|
1412 |
|
1413 } |
|
1414 |
|
1415 |
|
1416 /* |
|
1417 ------------------------------------------------------------------------------- |
|
1418 |
|
1419 Class: CTestModule |
|
1420 |
|
1421 Method: CaseFromHandle |
|
1422 |
|
1423 Description: Return subsession from handle |
|
1424 |
|
1425 Parameters: const TUint aHandle :in: Handle |
|
1426 |
|
1427 Return Values: CTestExecution* Test Execution object |
|
1428 |
|
1429 Errors/Exceptions: Function panics client if invalid handle. |
|
1430 |
|
1431 Status: Approved |
|
1432 |
|
1433 ------------------------------------------------------------------------------- |
|
1434 */ |
|
1435 CTestExecution* CTestModule::CaseFromHandle( const TUint aHandle, const RMessage2& aMessage ) const |
|
1436 { |
|
1437 |
|
1438 CTestExecution* testcase =( CTestExecution* ) iTestExecutionHandle->At( aHandle ); |
|
1439 |
|
1440 if( testcase == NULL ) |
|
1441 { |
|
1442 PanicClient( EBadSubsessionHandle, aMessage ); |
|
1443 } |
|
1444 |
|
1445 return testcase; |
|
1446 |
|
1447 } |
|
1448 |
|
1449 |
|
1450 /* |
|
1451 ------------------------------------------------------------------------------- |
|
1452 |
|
1453 Class: CTestModule |
|
1454 |
|
1455 Method: GetTestModule |
|
1456 |
|
1457 Description: Gets a CTestModuleBase*. If there is a free entry |
|
1458 in the free list, then it is returned. Otherwise a new one is created. |
|
1459 |
|
1460 Parameters: CTestModuleContainer*& aContainer: out: container pointer. |
|
1461 const TDesC& aConfig: in: Test case (config) file name. |
|
1462 |
|
1463 Return Values: Symbian OS error code |
|
1464 |
|
1465 Errors/Exceptions: None |
|
1466 |
|
1467 Status: Proposal |
|
1468 |
|
1469 ------------------------------------------------------------------------------- |
|
1470 */ |
|
1471 TInt CTestModule::GetTestModule( CTestModuleContainer*& aContainer, |
|
1472 const TDesC& aConfig ) |
|
1473 { |
|
1474 TInt ret = KErrNone; |
|
1475 |
|
1476 if( iTestModuleInstances->Count() ) |
|
1477 { |
|
1478 // Return an existing one |
|
1479 aContainer =( *iTestModuleInstances )[0]; |
|
1480 iTestModuleInstances->Remove( 0 ); |
|
1481 __TRACE( KInit,( _L( "Reusing old test module container instance at 0x%x" ), (TUint32) aContainer ) ); |
|
1482 } |
|
1483 else |
|
1484 { |
|
1485 // Create a new one |
|
1486 __TRACE( KInit,( _L( "Creating new test module instance" ) ) ); |
|
1487 TRAPD( err, aContainer = CTestModuleContainer::NewL( |
|
1488 iTestServer->ModuleName(), |
|
1489 this, |
|
1490 aConfig ) ); |
|
1491 |
|
1492 // If module can't be created, then return NULL. |
|
1493 if( err ) |
|
1494 { |
|
1495 __TRACE( KError,( _L( "Can't create new test module container instance" ) ) ); |
|
1496 aContainer = NULL; |
|
1497 ret = err; |
|
1498 } |
|
1499 else |
|
1500 { |
|
1501 __TRACE( KInit,( _L( "Test module instance container created" ) ) ); |
|
1502 } |
|
1503 |
|
1504 if( aContainer ) |
|
1505 { |
|
1506 |
|
1507 // Initialise module |
|
1508 aContainer->Initialize( iTestServer->ModuleName(), iTestServer->FirstTime() ); |
|
1509 |
|
1510 if( aContainer->OperationErrorResult() != KErrNone ) |
|
1511 { |
|
1512 // Can't initialise module, delete it |
|
1513 __TRACE( KError,( CStifLogger::ERed, _L( "Operation error, can't initialize test module container instance" ) ) ); |
|
1514 ret = aContainer->OperationErrorResult(); |
|
1515 delete aContainer; |
|
1516 aContainer = NULL; |
|
1517 } |
|
1518 else if( aContainer->ModuleResult() != KErrNone ) |
|
1519 { |
|
1520 // Can't initialise module, delete it |
|
1521 __TRACE( KError,( CStifLogger::ERed, _L( "Module error, can't initialize test module container instance" ) ) ); |
|
1522 ret = aContainer->ModuleResult(); |
|
1523 delete aContainer; |
|
1524 aContainer = NULL; |
|
1525 } |
|
1526 else |
|
1527 { |
|
1528 // Module initialised properly, clear the first time flag. |
|
1529 iTestServer->ClearFirstTime(); |
|
1530 __TRACE( KInit,( _L( "Test module container initialized at 0x%x" ), (TUint32) aContainer ) ); |
|
1531 } |
|
1532 } |
|
1533 } |
|
1534 |
|
1535 return ret; |
|
1536 |
|
1537 } |
|
1538 |
|
1539 |
|
1540 /* |
|
1541 ------------------------------------------------------------------------------- |
|
1542 |
|
1543 Class: CTestModule |
|
1544 |
|
1545 Method: FreeTestModule |
|
1546 |
|
1547 Description:Frees a CTestModuleContainer. This function can be called |
|
1548 from the context of the test execution thread. |
|
1549 |
|
1550 Parameters: CTestModuleContainer* aModule :in: Module to be freed |
|
1551 |
|
1552 Return Values: TInt Error code |
|
1553 |
|
1554 Errors/Exceptions: None |
|
1555 |
|
1556 Status: Proposal |
|
1557 |
|
1558 ------------------------------------------------------------------------------- |
|
1559 */ |
|
1560 TInt CTestModule::FreeTestModule( CTestModuleContainer* aModule ) |
|
1561 { |
|
1562 |
|
1563 // Free the module |
|
1564 TInt r = iTestModuleInstances->Append( aModule ); |
|
1565 if( r != KErrNone ) |
|
1566 { |
|
1567 delete aModule; |
|
1568 aModule = NULL; |
|
1569 } |
|
1570 |
|
1571 return r; |
|
1572 |
|
1573 } |
|
1574 |
|
1575 /* |
|
1576 ------------------------------------------------------------------------------- |
|
1577 |
|
1578 Class: CTestModule |
|
1579 |
|
1580 Method: IniName |
|
1581 |
|
1582 Returns the initialisation file name |
|
1583 |
|
1584 Parameters: None |
|
1585 |
|
1586 Return Values: const TDesC& Initialisation file name |
|
1587 |
|
1588 Errors/Exceptions: None |
|
1589 |
|
1590 Status: Proposal |
|
1591 |
|
1592 ------------------------------------------------------------------------------- |
|
1593 */ |
|
1594 |
|
1595 const TDesC& CTestModule::IniName() const |
|
1596 { |
|
1597 |
|
1598 return iIni; |
|
1599 |
|
1600 } |
|
1601 |
|
1602 /* |
|
1603 ------------------------------------------------------------------------------- |
|
1604 |
|
1605 Class: CTestModule |
|
1606 |
|
1607 Method: Name |
|
1608 |
|
1609 Returns the module name |
|
1610 |
|
1611 Parameters: None |
|
1612 |
|
1613 Return Values: const TDesC& Initialisation file name |
|
1614 |
|
1615 Errors/Exceptions: None |
|
1616 |
|
1617 Status: Proposal |
|
1618 |
|
1619 ------------------------------------------------------------------------------- |
|
1620 */ |
|
1621 const TDesC& CTestModule::Name() const |
|
1622 { |
|
1623 |
|
1624 return iTestServer->ModuleName(); |
|
1625 |
|
1626 } |
|
1627 |
|
1628 /* |
|
1629 ------------------------------------------------------------------------------- |
|
1630 |
|
1631 Class: CTestModule |
|
1632 |
|
1633 Method: GetTestCaseTitleL |
|
1634 |
|
1635 Gets title of currently running test case |
|
1636 |
|
1637 Parameters: None |
|
1638 |
|
1639 Return Values: TInt aTestCaseNumber: in: index of currently running test case |
|
1640 TDes& aTestCaseTitle: out: test case title |
|
1641 |
|
1642 Errors/Exceptions: None |
|
1643 |
|
1644 Status: Proposal |
|
1645 |
|
1646 ------------------------------------------------------------------------------- |
|
1647 */ |
|
1648 void CTestModule::GetTestCaseTitleL(TInt aTestCaseNumber, const TDesC& aConfigFile,TDes& aTestCaseTitle) |
|
1649 { |
|
1650 CTestCasesList* testCasesList = NULL; |
|
1651 for ( TInt i = 0; i < iTestCaseTitlesMap.Count(); i++ ) |
|
1652 { |
|
1653 if ( iTestCaseTitlesMap[ i ]->GetConfigFileName() == aConfigFile ) |
|
1654 { |
|
1655 testCasesList = iTestCaseTitlesMap[ i ]; |
|
1656 break; |
|
1657 } |
|
1658 } |
|
1659 if ( testCasesList == NULL ) |
|
1660 { |
|
1661 User::Leave( KErrNotFound ); |
|
1662 } |
|
1663 |
|
1664 RDebug::Print(_L("Trying to get test case title from module. Index=%d, count=%d"), aTestCaseNumber, testCasesList->Count() ); |
|
1665 |
|
1666 aTestCaseTitle.Copy( testCasesList->GetTestCaseTitleL( aTestCaseNumber ) ); |
|
1667 } |
|
1668 |
|
1669 |
|
1670 /* |
|
1671 ------------------------------------------------------------------------------- |
|
1672 |
|
1673 Class: CTestModule |
|
1674 |
|
1675 Method: GetTestServer |
|
1676 |
|
1677 Gets pointer to TestServer |
|
1678 |
|
1679 Parameters: None |
|
1680 |
|
1681 Return Values: CTestServer : pointer to TestServer |
|
1682 |
|
1683 Errors/Exceptions: None |
|
1684 |
|
1685 Status: Proposal |
|
1686 |
|
1687 ------------------------------------------------------------------------------- |
|
1688 */ |
|
1689 CTestServer* CTestModule::GetTestServer() |
|
1690 { |
|
1691 return iTestServer; |
|
1692 } |
|
1693 |
|
1694 TBool CTestModule::UiTesting() |
|
1695 { |
|
1696 return iUiTesting; |
|
1697 } |
|
1698 |
|
1699 TBool CTestModule::SeperateProcesses() |
|
1700 { |
|
1701 return iSeperateProcesses; |
|
1702 } |
|
1703 |
|
1704 // End of File |