|
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 ETestModuleCreateSubSession : // Create new test module subsession |
|
731 { |
|
732 __TRACE( KError,( _L( "Creating test module session" ) ) ); |
|
733 return CreateModuleSessionL( aMessage ); |
|
734 } |
|
735 |
|
736 case ETestModuleCloseSubSession: // Close module subsession |
|
737 { |
|
738 // Nothing to do. |
|
739 aMessage.Complete( KErrNone ); |
|
740 return KErrNone; |
|
741 } |
|
742 |
|
743 case ETestExecutionCreateSubSession: // Create new test execution subsession |
|
744 { |
|
745 return NewTestExecutionL( aMessage ); |
|
746 } |
|
747 |
|
748 case ETestModuleEnumerateTestCases: // Enumerate test cases |
|
749 { |
|
750 __TRACE( KError,( _L( "Enumerating test cases" ) ) ); |
|
751 return EnumerateTestCasesL( aMessage ); |
|
752 } |
|
753 |
|
754 case ETestModuleGetTestCases: // Get test cases |
|
755 { |
|
756 return GetTestCasesL( aMessage ); |
|
757 } |
|
758 |
|
759 case ETestModuleErrorNotification: // Request error notification |
|
760 { |
|
761 return HandleErrorNotificationL( aMessage ); |
|
762 } |
|
763 |
|
764 case ETestModuleCancelAsyncRequest: |
|
765 { |
|
766 return CancelAsyncRequestL( aMessage ); |
|
767 } |
|
768 |
|
769 // Subsession specific |
|
770 case ETestExecutionRunTestCase: // Run test case |
|
771 { |
|
772 __TRACE( KInit,( _L( "Running test case" ) ) ); |
|
773 CTestExecution* testCase=CaseFromHandle( aMessage.Int3(), aMessage ); |
|
774 return testCase->RunTestCase( aMessage ); |
|
775 } |
|
776 |
|
777 case ETestExecutionNotifyProgress: // Test case prints |
|
778 { |
|
779 CTestExecution* testCase=CaseFromHandle( aMessage.Int3(), aMessage ); |
|
780 return testCase->NotifyPrint( aMessage ); |
|
781 } |
|
782 |
|
783 case ETestExecutionNotifyEvent: // Event notifications |
|
784 { |
|
785 CTestExecution* testCase=CaseFromHandle( aMessage.Int3(), aMessage ); |
|
786 return testCase->NotifyEvent( aMessage ); |
|
787 } |
|
788 |
|
789 case ETestExecutionNotifyRemoteCmd: // RemoteCmd notifications |
|
790 { |
|
791 CTestExecution* testCase=CaseFromHandle( aMessage.Int3(), aMessage ); |
|
792 return testCase->NotifyRemoteCmd( aMessage ); |
|
793 } |
|
794 case ETestExecutionReadRemoteCmdInfo: // RemoteCmd reading |
|
795 { |
|
796 //CTestExecution* testCase=CaseFromHandle( aMessage.Int3() ); |
|
797 //return testCase->NotifyRemoteCmd( aMessage ); |
|
798 CTestExecution* testCase=CaseFromHandle( aMessage.Int3(), aMessage ); |
|
799 return testCase->ReadRemoteCmdInfo( aMessage ); |
|
800 } |
|
801 |
|
802 |
|
803 case ETestExecutionResume: // Resume case execution |
|
804 { |
|
805 __TRACE( KVerbose,( _L( "Resuming test execution" ) ) ); |
|
806 CTestExecution* testCase=CaseFromHandle( aMessage.Int3(), aMessage ); |
|
807 return testCase->Resume( aMessage ); |
|
808 } |
|
809 |
|
810 case ETestExecutionPause: // Pause case execution |
|
811 { |
|
812 __TRACE( KVerbose,( _L( "Pausing test execution" ) ) ); |
|
813 CTestExecution* testCase=CaseFromHandle( aMessage.Int3(), aMessage ); |
|
814 return testCase->Pause( aMessage ); |
|
815 } |
|
816 |
|
817 case ETestExecutionCloseSubSession: // Close execution subsession |
|
818 { |
|
819 CTestExecution* testCase=CaseFromHandle( aMessage.Int3(), aMessage ); |
|
820 return testCase->CloseTestExecution( aMessage ); |
|
821 } |
|
822 |
|
823 case ETestExecutionCancelAsyncRequest: // Cancel async request |
|
824 { |
|
825 CTestExecution* testCase=CaseFromHandle( aMessage.Int3(), aMessage ); |
|
826 return testCase->CancelRequestL( aMessage ); |
|
827 } |
|
828 case ETestExecutionNotifyCommand: // Command notifications |
|
829 { |
|
830 CTestExecution* testCase=CaseFromHandle( aMessage.Int3(), aMessage ); |
|
831 return testCase->NotifyCommand( aMessage ); |
|
832 } |
|
833 |
|
834 default: // Invalid request |
|
835 { |
|
836 PanicClient( EBadRequest, aMessage ); |
|
837 return KErrNotSupported; |
|
838 } |
|
839 } |
|
840 |
|
841 } |
|
842 |
|
843 |
|
844 /* |
|
845 ------------------------------------------------------------------------------- |
|
846 |
|
847 Class: CTestModule |
|
848 |
|
849 Method: EnumerateTestCases |
|
850 |
|
851 Description: Enumerates test cases and returns test case count by writing |
|
852 result to client side package. |
|
853 |
|
854 Function obtains a TestModule and calls EnumerateTestCases from it. |
|
855 Test module will be released when calling GetTestCases function. |
|
856 |
|
857 Parameters: const RMessage& aMessage :inout: Message to be handled |
|
858 |
|
859 Return Values: TInt Operation result |
|
860 |
|
861 Errors/Exceptions: None |
|
862 |
|
863 Status: Proposal |
|
864 |
|
865 ------------------------------------------------------------------------------- |
|
866 */ |
|
867 TInt CTestModule::EnumerateTestCasesL( const RMessage2& aMessage ) |
|
868 { |
|
869 |
|
870 __TRACE( KMessage,( _L( "CTestModule::EnumerateTestCasesL in" ) ) ); |
|
871 |
|
872 // Get data from message |
|
873 TFileName config; |
|
874 TRAPD( res, aMessage.ReadL( 0, config ) ); |
|
875 if(res == KErrDied) |
|
876 { |
|
877 RDebug::Print(_L("CTestModule::EnumerateTestCasesL() Reading from RMessage ended with KErrDied. Client is not alive anymore and this request will be ignored")); |
|
878 return res; |
|
879 } |
|
880 else if( res != KErrNone ) |
|
881 { |
|
882 RDebug::Print(_L("CTestModule::EnumerateTestCasesL() #1 Panic client with [%d], res=[%d]"), EBadDescriptor, res); |
|
883 PanicClient( EBadDescriptor, aMessage ); |
|
884 return res; |
|
885 } |
|
886 |
|
887 // Free old case data |
|
888 User::LeaveIfError( FreeCaseData() ); |
|
889 |
|
890 // Get test cases from the test module |
|
891 User::LeaveIfError( GetTestModule( iEnumerateModule, config ) ); |
|
892 |
|
893 // Enumerate test cases |
|
894 iEnumerateModule->EnumerateTestCases( config ); |
|
895 |
|
896 // Something fatal? |
|
897 TInt r = iEnumerateModule->OperationErrorResult(); |
|
898 if( r != KErrNone ) |
|
899 { |
|
900 // Enumeration module have crashed. |
|
901 delete iEnumerateModule; |
|
902 iEnumerateModule = NULL; |
|
903 |
|
904 return r; |
|
905 } |
|
906 |
|
907 // Error from module? |
|
908 if( iEnumerateModule->ModuleResult() != KErrNone ) |
|
909 { |
|
910 return iEnumerateModule->ModuleResult(); |
|
911 } |
|
912 |
|
913 // Write count to Ptr1() |
|
914 const RPointerArray<TTestCaseInfo>* testCases = iEnumerateModule->TestCases(); |
|
915 |
|
916 if( testCases == NULL ) |
|
917 { |
|
918 User::Leave( KErrGeneral ); |
|
919 } |
|
920 |
|
921 CTestCasesList* testCasesList = NULL; |
|
922 for ( TInt i = 0; i < iTestCaseTitlesMap.Count(); i++ ) |
|
923 { |
|
924 if ( iTestCaseTitlesMap[ i ]->GetConfigFileName() == config ) |
|
925 { |
|
926 testCasesList = iTestCaseTitlesMap[ i ]; |
|
927 break; |
|
928 } |
|
929 } |
|
930 if ( testCasesList == NULL ) |
|
931 { |
|
932 testCasesList = CTestCasesList::NewL( config ); |
|
933 CleanupStack::PushL( testCasesList ); |
|
934 iTestCaseTitlesMap.AppendL( testCasesList ); |
|
935 CleanupStack::Pop( testCasesList ); |
|
936 } |
|
937 |
|
938 // Store titles (for further use, i.e. when asked for title from the interface via CTestModuleIf->CTestThreadContainer->CTestModuleContainer) |
|
939 testCasesList->ResetAndDestroy(); |
|
940 TInt i; |
|
941 for(i = 0; i < testCases->Count(); i++) |
|
942 { |
|
943 //Handle situation when test cases are enumerated not as 0-based (testscripter, ...) |
|
944 if(i == 0 && (*testCases)[i]->iCaseNumber > 0) |
|
945 { |
|
946 testCasesList->AppendTestCaseL( KNullDesC ); |
|
947 } |
|
948 testCasesList->AppendTestCaseL( (*testCases)[i]->iTitle ); |
|
949 } |
|
950 |
|
951 TPckgBuf<TInt> countPckg( testCases->Count() ); |
|
952 TRAP( res, aMessage.WriteL( 1, countPckg ) ); |
|
953 if(res == KErrDied) |
|
954 { |
|
955 RDebug::Print(_L("CTestModule::EnumerateTestCasesL() Writing to RMessage ended with KErrDied. Client is not alive anymore and this request will be ignored")); |
|
956 return res; |
|
957 } |
|
958 else if( res != KErrNone ) |
|
959 { |
|
960 RDebug::Print(_L("CTestModule::EnumerateTestCasesL() #2 Panic client with [%d], res=[%d], config=[%S]"), EBadDescriptor, res, &config); |
|
961 PanicClient( EBadDescriptor, aMessage ); |
|
962 return res; |
|
963 } |
|
964 |
|
965 // All ok, complete message |
|
966 aMessage.Complete( KErrNone ); |
|
967 |
|
968 __TRACE( KMessage,( _L( "CTestModule::EnumerateTestCasesL out" ) ) ); |
|
969 |
|
970 return KErrNone; |
|
971 |
|
972 } |
|
973 |
|
974 |
|
975 /* |
|
976 ------------------------------------------------------------------------------- |
|
977 |
|
978 Class: CTestModule |
|
979 |
|
980 Method: GetTestCasesL |
|
981 |
|
982 Description: Get test cases. Enumerate test cases must be called before |
|
983 calling this function. |
|
984 |
|
985 Function releases the test module reserved by EnumerateTestCase(). |
|
986 |
|
987 Parameters: const RMessage& aMessage :inout: Message to be handled |
|
988 |
|
989 Return Values: TInt Operation result |
|
990 |
|
991 Errors/Exceptions: Leaves if cases have not been enumerated. |
|
992 |
|
993 Status: Proposal |
|
994 |
|
995 ------------------------------------------------------------------------------- |
|
996 */ |
|
997 TInt CTestModule::GetTestCasesL( const RMessage2& aMessage ) |
|
998 { |
|
999 |
|
1000 __TRACE( KMessage,( _L( "CTestModule::GetTestCasesL in" ) ) ); |
|
1001 |
|
1002 // Leave if cases have not been enumerated. |
|
1003 //User::LeaveIfNull(( TAny* ) iEnumerateModule->TestCases() ); |
|
1004 if( ( TAny* ) iEnumerateModule->TestCases() == NULL ) |
|
1005 { |
|
1006 User::Leave( KErrGeneral ); |
|
1007 } |
|
1008 |
|
1009 const TInt len = sizeof( TTestCaseInfo ); |
|
1010 |
|
1011 // Get cases |
|
1012 const RPointerArray<TTestCaseInfo>& cases = *iEnumerateModule->TestCases(); |
|
1013 |
|
1014 // Get number of cases |
|
1015 const TInt Kcount = cases.Count(); |
|
1016 |
|
1017 // Loop through case and copy then to client's descriptor. |
|
1018 for( TInt i = 0; i < Kcount; i++ ) |
|
1019 { |
|
1020 |
|
1021 // Construct package for source data |
|
1022 TTestCaseInfoPckg tmpPackage( *cases[i] ); |
|
1023 |
|
1024 // Write to correct location |
|
1025 aMessage.WriteL( 0, tmpPackage, i *len ); |
|
1026 |
|
1027 } |
|
1028 |
|
1029 // Free case data and the test module |
|
1030 User::LeaveIfError( FreeCaseData() ); |
|
1031 |
|
1032 // Finished |
|
1033 aMessage.Complete( KErrNone ); |
|
1034 |
|
1035 __TRACE( KMessage,( _L( "CTestModule::GetTestCasesL out" ) ) ); |
|
1036 |
|
1037 return KErrNone; |
|
1038 |
|
1039 } |
|
1040 |
|
1041 |
|
1042 /* |
|
1043 ------------------------------------------------------------------------------- |
|
1044 |
|
1045 Class: CTestModule |
|
1046 |
|
1047 Method: HandleErrorNotification |
|
1048 |
|
1049 Description: Request error notification. |
|
1050 |
|
1051 Parameters: const RMessage& aMessage :inout: Message to be handled |
|
1052 |
|
1053 Return Values: TInt Operation result |
|
1054 |
|
1055 Errors/Exceptions: None |
|
1056 |
|
1057 Status: Proposal |
|
1058 |
|
1059 ------------------------------------------------------------------------------- |
|
1060 */ |
|
1061 TInt CTestModule::HandleErrorNotificationL( const RMessage2& aMessage ) |
|
1062 { |
|
1063 |
|
1064 iErrorMessage = aMessage; |
|
1065 iErrorMessageAvailable = ETrue; |
|
1066 |
|
1067 return KErrNone; |
|
1068 |
|
1069 } |
|
1070 |
|
1071 /* |
|
1072 ------------------------------------------------------------------------------- |
|
1073 |
|
1074 Class: CTestModule |
|
1075 |
|
1076 Method: GetServerThreadId |
|
1077 |
|
1078 Description: Request server state notification. |
|
1079 |
|
1080 Parameters: const RMessage& aMessage :inout: Message to be handled |
|
1081 |
|
1082 Return Values: TInt Operation result |
|
1083 |
|
1084 Errors/Exceptions: None |
|
1085 |
|
1086 Status: Proposal |
|
1087 |
|
1088 ------------------------------------------------------------------------------- |
|
1089 */ |
|
1090 TInt CTestModule::GetServerThreadIdL( const RMessage2& aMessage ) |
|
1091 { |
|
1092 |
|
1093 TInt id( iTestServer->GetServerThreadId() ); |
|
1094 |
|
1095 TPckg<TThreadId> threadIdPckg( id ); |
|
1096 |
|
1097 TRAPD( res, aMessage.WriteL( 0, threadIdPckg ) ); |
|
1098 |
|
1099 // Finished |
|
1100 aMessage.Complete( res ); |
|
1101 |
|
1102 return KErrNone; |
|
1103 |
|
1104 } |
|
1105 |
|
1106 /* |
|
1107 ------------------------------------------------------------------------------- |
|
1108 |
|
1109 Class: CTestModule |
|
1110 |
|
1111 Method: CancelAsyncRequest |
|
1112 |
|
1113 Description: Cancels asynchronous request |
|
1114 |
|
1115 Parameters: const RMessage& aMessage :inout: Message to be handled |
|
1116 |
|
1117 Return Values: TInt Operation result |
|
1118 |
|
1119 Errors/Exceptions: None |
|
1120 |
|
1121 Status: Proposal |
|
1122 |
|
1123 ------------------------------------------------------------------------------- |
|
1124 */ |
|
1125 TInt CTestModule::CancelAsyncRequestL( const RMessage2& aMessage ) |
|
1126 { |
|
1127 |
|
1128 switch ( aMessage.Int0() ) |
|
1129 { |
|
1130 case ETestModuleErrorNotification: |
|
1131 { |
|
1132 if ( iErrorMessageAvailable ) |
|
1133 { |
|
1134 iErrorMessage.Complete ( KErrCancel ); |
|
1135 iErrorMessageAvailable = EFalse; |
|
1136 } |
|
1137 aMessage.Complete ( KErrNone ); |
|
1138 break; |
|
1139 } |
|
1140 |
|
1141 default: |
|
1142 { |
|
1143 PanicClient( EInvalidRequestCancel, aMessage ); |
|
1144 break; |
|
1145 } |
|
1146 } |
|
1147 |
|
1148 return KErrNone; |
|
1149 |
|
1150 } |
|
1151 |
|
1152 /* |
|
1153 ------------------------------------------------------------------------------- |
|
1154 |
|
1155 Class: CTestModule |
|
1156 |
|
1157 Method: ErrorPrint |
|
1158 |
|
1159 Description: Prints error |
|
1160 |
|
1161 Parameters: const TInt aPriority :in: Priority |
|
1162 TPtrC aError: in: Error |
|
1163 |
|
1164 Return Values: None |
|
1165 |
|
1166 Errors/Exceptions: None |
|
1167 |
|
1168 Status: Proposal |
|
1169 |
|
1170 ------------------------------------------------------------------------------- |
|
1171 */ |
|
1172 void CTestModule::ErrorPrint( const TInt aPriority, |
|
1173 TPtrC aError ) |
|
1174 { |
|
1175 |
|
1176 if ( iErrorMessageAvailable ) |
|
1177 { |
|
1178 TErrorNotification error; |
|
1179 TErrorNotificationPckg errorPckg ( error ); |
|
1180 |
|
1181 error.iModule = _L("TestServer"); |
|
1182 error.iPriority = aPriority; |
|
1183 error.iText = aError; |
|
1184 |
|
1185 TRAPD( r, iErrorMessage.WriteL( 0, errorPckg ) ); |
|
1186 |
|
1187 // Do not handle errors |
|
1188 iErrorMessageAvailable = EFalse; |
|
1189 iErrorMessage.Complete( r ); |
|
1190 |
|
1191 } |
|
1192 else |
|
1193 { |
|
1194 RDebug::Print (_L("Error message lost %d [%S]"), aPriority, &aError ); |
|
1195 } |
|
1196 |
|
1197 } |
|
1198 |
|
1199 /* |
|
1200 ------------------------------------------------------------------------------- |
|
1201 |
|
1202 Class: CTestModule |
|
1203 |
|
1204 Method: FreeCaseData |
|
1205 |
|
1206 Description: Frees the test case data and test module that is used in |
|
1207 enumeration. |
|
1208 |
|
1209 Parameters: None |
|
1210 |
|
1211 Return Values: TInt Error code |
|
1212 |
|
1213 Errors/Exceptions: None |
|
1214 |
|
1215 Status: Proposal |
|
1216 |
|
1217 ------------------------------------------------------------------------------- |
|
1218 */ |
|
1219 TInt CTestModule::FreeCaseData() |
|
1220 { |
|
1221 |
|
1222 __TRACE( KMessage,( _L( "CTestModule::FreeCaseData in" ) ) ); |
|
1223 |
|
1224 TInt r = KErrNone; |
|
1225 |
|
1226 if( iEnumerateModule ) |
|
1227 { |
|
1228 |
|
1229 // Deallocate testcase memory |
|
1230 iEnumerateModule->FreeEnumerationData(); |
|
1231 |
|
1232 // Free the module |
|
1233 r = FreeTestModule( iEnumerateModule ); |
|
1234 |
|
1235 iEnumerateModule = NULL; |
|
1236 |
|
1237 } |
|
1238 |
|
1239 __TRACE( KMessage,( _L( "CTestModule::FreeCaseData out" ) ) ); |
|
1240 |
|
1241 return r; |
|
1242 |
|
1243 } |
|
1244 |
|
1245 |
|
1246 /* |
|
1247 ------------------------------------------------------------------------------- |
|
1248 |
|
1249 Class: CTestModule |
|
1250 |
|
1251 Method: CreateModuleSessionL |
|
1252 |
|
1253 Description: Creates a new module session. |
|
1254 Just take the initialisation file name from message. |
|
1255 |
|
1256 Parameters: const RMessage& aMessage :inout: Message to be handled |
|
1257 |
|
1258 Return Values: TInt Operation result |
|
1259 |
|
1260 Errors/Exceptions: Leaves if memory allocation fails |
|
1261 |
|
1262 Status: Proposal |
|
1263 |
|
1264 ------------------------------------------------------------------------------- |
|
1265 */ |
|
1266 TInt CTestModule::CreateModuleSessionL( const RMessage2& aMessage ) |
|
1267 { |
|
1268 |
|
1269 __TRACE( KMessage,( _L( "CTestModule::CreateModuleSession in" ) ) ); |
|
1270 |
|
1271 // Take parameters |
|
1272 TFileName ini; |
|
1273 TRAPD( res, aMessage.ReadL( 0, ini ) ); |
|
1274 if( res != KErrNone ) |
|
1275 { |
|
1276 PanicClient( EBadDescriptor, aMessage ); |
|
1277 return res; |
|
1278 } |
|
1279 |
|
1280 // Construct heap buffer for initialization file name |
|
1281 iIniBuffer = HBufC::NewL( ini.Length() ); |
|
1282 iIni.Set ( iIniBuffer->Des() ); |
|
1283 iIni.Copy ( ini ); |
|
1284 |
|
1285 aMessage.Complete( KErrNone ); |
|
1286 |
|
1287 __TRACE( KMessage,( _L( "CTestModule::CreateModuleSession out" ) ) ); |
|
1288 |
|
1289 return KErrNone; |
|
1290 |
|
1291 } |
|
1292 |
|
1293 /* |
|
1294 ------------------------------------------------------------------------------- |
|
1295 |
|
1296 Class: CTestModule |
|
1297 |
|
1298 Method: NewTestExecutionL |
|
1299 |
|
1300 Description: Create new test execution subsession |
|
1301 |
|
1302 Parameters: const RMessage& aMessage :inout: Message to be handled |
|
1303 |
|
1304 Return Values: TInt Operation result |
|
1305 |
|
1306 Errors/Exceptions: Function leaves if object can't be created or |
|
1307 it can't be added to container. |
|
1308 Function panics client if message contains invalid |
|
1309 descriptor. |
|
1310 |
|
1311 Status: Proposal |
|
1312 |
|
1313 ------------------------------------------------------------------------------- |
|
1314 */ |
|
1315 TInt CTestModule::NewTestExecutionL( const RMessage2& aMessage ) |
|
1316 { |
|
1317 |
|
1318 __TRACE( KMessage,( _L( "CTestModule::NewTestExecutionL in" ) ) ); |
|
1319 |
|
1320 // Get data from message |
|
1321 TInt caseNumber = aMessage.Int0(); |
|
1322 TFileName config; |
|
1323 |
|
1324 TRAPD( res, aMessage.ReadL( 1, config ) ); |
|
1325 if( res != KErrNone ) |
|
1326 { |
|
1327 PanicClient( EBadDescriptor, aMessage ); |
|
1328 return res; |
|
1329 } |
|
1330 |
|
1331 // Make new object |
|
1332 CTestExecution* execution=CTestExecution::NewL( this, caseNumber, config ); |
|
1333 |
|
1334 // add object to object container to generate unique id |
|
1335 iContainer->AddL( execution ); |
|
1336 |
|
1337 // add object to object index; this returns a unique handle so we can get it again |
|
1338 TInt handle=iTestExecutionHandle->AddL( execution ); |
|
1339 |
|
1340 // write the handle to client |
|
1341 TPckg<TInt> handlePckg( handle ); |
|
1342 TRAP( res, aMessage.WriteL( 3, handlePckg ) ); |
|
1343 if( res != KErrNone ) |
|
1344 { |
|
1345 iTestExecutionHandle->Remove( handle ); |
|
1346 PanicClient( EBadDescriptor, aMessage ); |
|
1347 return res; |
|
1348 } |
|
1349 |
|
1350 // notch up another resource |
|
1351 iResourceCount++; |
|
1352 |
|
1353 // Complete message |
|
1354 aMessage.Complete( KErrNone ); |
|
1355 |
|
1356 __TRACE( KMessage,( _L( "CTestModule::NewTestExecutionL out" ) ) ); |
|
1357 |
|
1358 return KErrNone; |
|
1359 } |
|
1360 |
|
1361 /* |
|
1362 ------------------------------------------------------------------------------- |
|
1363 |
|
1364 Class: CTestModule |
|
1365 |
|
1366 Method: DeleteTestExecution |
|
1367 |
|
1368 Description: Deletes Test Execution by handle |
|
1369 |
|
1370 Parameters: const TUint aHandle :in: Handle |
|
1371 |
|
1372 Return Values: None |
|
1373 |
|
1374 Errors/Exceptions: Panics client if invalid handle |
|
1375 |
|
1376 Status: Proposal |
|
1377 |
|
1378 ------------------------------------------------------------------------------- |
|
1379 */ |
|
1380 void CTestModule::DeleteTestExecution( const TUint aHandle, const RMessage2& aMessage ) |
|
1381 { |
|
1382 |
|
1383 // Verify that handle is valid |
|
1384 CaseFromHandle( aHandle, aMessage ); |
|
1385 |
|
1386 // Remove object |
|
1387 iTestExecutionHandle->Remove( aHandle ); |
|
1388 |
|
1389 // Decrement resource count. |
|
1390 iResourceCount--; |
|
1391 |
|
1392 } |
|
1393 |
|
1394 |
|
1395 /* |
|
1396 ------------------------------------------------------------------------------- |
|
1397 |
|
1398 Class: CTestModule |
|
1399 |
|
1400 Method: CaseFromHandle |
|
1401 |
|
1402 Description: Return subsession from handle |
|
1403 |
|
1404 Parameters: const TUint aHandle :in: Handle |
|
1405 |
|
1406 Return Values: CTestExecution* Test Execution object |
|
1407 |
|
1408 Errors/Exceptions: Function panics client if invalid handle. |
|
1409 |
|
1410 Status: Approved |
|
1411 |
|
1412 ------------------------------------------------------------------------------- |
|
1413 */ |
|
1414 CTestExecution* CTestModule::CaseFromHandle( const TUint aHandle, const RMessage2& aMessage ) const |
|
1415 { |
|
1416 |
|
1417 CTestExecution* testcase =( CTestExecution* ) iTestExecutionHandle->At( aHandle ); |
|
1418 |
|
1419 if( testcase == NULL ) |
|
1420 { |
|
1421 PanicClient( EBadSubsessionHandle, aMessage ); |
|
1422 } |
|
1423 |
|
1424 return testcase; |
|
1425 |
|
1426 } |
|
1427 |
|
1428 |
|
1429 /* |
|
1430 ------------------------------------------------------------------------------- |
|
1431 |
|
1432 Class: CTestModule |
|
1433 |
|
1434 Method: GetTestModule |
|
1435 |
|
1436 Description: Gets a CTestModuleBase*. If there is a free entry |
|
1437 in the free list, then it is returned. Otherwise a new one is created. |
|
1438 |
|
1439 Parameters: CTestModuleContainer*& aContainer: out: container pointer. |
|
1440 const TDesC& aConfig: in: Test case (config) file name. |
|
1441 |
|
1442 Return Values: Symbian OS error code |
|
1443 |
|
1444 Errors/Exceptions: None |
|
1445 |
|
1446 Status: Proposal |
|
1447 |
|
1448 ------------------------------------------------------------------------------- |
|
1449 */ |
|
1450 TInt CTestModule::GetTestModule( CTestModuleContainer*& aContainer, |
|
1451 const TDesC& aConfig ) |
|
1452 { |
|
1453 TInt ret = KErrNone; |
|
1454 |
|
1455 if( iTestModuleInstances->Count() ) |
|
1456 { |
|
1457 // Return an existing one |
|
1458 aContainer =( *iTestModuleInstances )[0]; |
|
1459 iTestModuleInstances->Remove( 0 ); |
|
1460 __TRACE( KInit,( _L( "Reusing old test module container instance at 0x%x" ), (TUint32) aContainer ) ); |
|
1461 } |
|
1462 else |
|
1463 { |
|
1464 // Create a new one |
|
1465 __TRACE( KInit,( _L( "Creating new test module instance" ) ) ); |
|
1466 TRAPD( err, aContainer = CTestModuleContainer::NewL( |
|
1467 iTestServer->ModuleName(), |
|
1468 this, |
|
1469 aConfig ) ); |
|
1470 |
|
1471 // If module can't be created, then return NULL. |
|
1472 if( err ) |
|
1473 { |
|
1474 __TRACE( KError,( _L( "Can't create new test module container instance" ) ) ); |
|
1475 aContainer = NULL; |
|
1476 ret = err; |
|
1477 } |
|
1478 else |
|
1479 { |
|
1480 __TRACE( KInit,( _L( "Test module instance container created" ) ) ); |
|
1481 } |
|
1482 |
|
1483 if( aContainer ) |
|
1484 { |
|
1485 |
|
1486 // Initialise module |
|
1487 aContainer->Initialize( iTestServer->ModuleName(), iTestServer->FirstTime() ); |
|
1488 |
|
1489 if( aContainer->OperationErrorResult() != KErrNone ) |
|
1490 { |
|
1491 // Can't initialise module, delete it |
|
1492 __TRACE( KError,( CStifLogger::ERed, _L( "Operation error, can't initialize test module container instance" ) ) ); |
|
1493 ret = aContainer->OperationErrorResult(); |
|
1494 delete aContainer; |
|
1495 aContainer = NULL; |
|
1496 } |
|
1497 else if( aContainer->ModuleResult() != KErrNone ) |
|
1498 { |
|
1499 // Can't initialise module, delete it |
|
1500 __TRACE( KError,( CStifLogger::ERed, _L( "Module error, can't initialize test module container instance" ) ) ); |
|
1501 ret = aContainer->ModuleResult(); |
|
1502 delete aContainer; |
|
1503 aContainer = NULL; |
|
1504 } |
|
1505 else |
|
1506 { |
|
1507 // Module initialised properly, clear the first time flag. |
|
1508 iTestServer->ClearFirstTime(); |
|
1509 __TRACE( KInit,( _L( "Test module container initialized at 0x%x" ), (TUint32) aContainer ) ); |
|
1510 } |
|
1511 } |
|
1512 } |
|
1513 |
|
1514 return ret; |
|
1515 |
|
1516 } |
|
1517 |
|
1518 |
|
1519 /* |
|
1520 ------------------------------------------------------------------------------- |
|
1521 |
|
1522 Class: CTestModule |
|
1523 |
|
1524 Method: FreeTestModule |
|
1525 |
|
1526 Description:Frees a CTestModuleContainer. This function can be called |
|
1527 from the context of the test execution thread. |
|
1528 |
|
1529 Parameters: CTestModuleContainer* aModule :in: Module to be freed |
|
1530 |
|
1531 Return Values: TInt Error code |
|
1532 |
|
1533 Errors/Exceptions: None |
|
1534 |
|
1535 Status: Proposal |
|
1536 |
|
1537 ------------------------------------------------------------------------------- |
|
1538 */ |
|
1539 TInt CTestModule::FreeTestModule( CTestModuleContainer* aModule ) |
|
1540 { |
|
1541 |
|
1542 // Free the module |
|
1543 TInt r = iTestModuleInstances->Append( aModule ); |
|
1544 if( r != KErrNone ) |
|
1545 { |
|
1546 delete aModule; |
|
1547 aModule = NULL; |
|
1548 } |
|
1549 |
|
1550 return r; |
|
1551 |
|
1552 } |
|
1553 |
|
1554 /* |
|
1555 ------------------------------------------------------------------------------- |
|
1556 |
|
1557 Class: CTestModule |
|
1558 |
|
1559 Method: IniName |
|
1560 |
|
1561 Returns the initialisation file name |
|
1562 |
|
1563 Parameters: None |
|
1564 |
|
1565 Return Values: const TDesC& Initialisation file name |
|
1566 |
|
1567 Errors/Exceptions: None |
|
1568 |
|
1569 Status: Proposal |
|
1570 |
|
1571 ------------------------------------------------------------------------------- |
|
1572 */ |
|
1573 |
|
1574 const TDesC& CTestModule::IniName() const |
|
1575 { |
|
1576 |
|
1577 return iIni; |
|
1578 |
|
1579 } |
|
1580 |
|
1581 /* |
|
1582 ------------------------------------------------------------------------------- |
|
1583 |
|
1584 Class: CTestModule |
|
1585 |
|
1586 Method: Name |
|
1587 |
|
1588 Returns the module name |
|
1589 |
|
1590 Parameters: None |
|
1591 |
|
1592 Return Values: const TDesC& Initialisation file name |
|
1593 |
|
1594 Errors/Exceptions: None |
|
1595 |
|
1596 Status: Proposal |
|
1597 |
|
1598 ------------------------------------------------------------------------------- |
|
1599 */ |
|
1600 const TDesC& CTestModule::Name() const |
|
1601 { |
|
1602 |
|
1603 return iTestServer->ModuleName(); |
|
1604 |
|
1605 } |
|
1606 |
|
1607 /* |
|
1608 ------------------------------------------------------------------------------- |
|
1609 |
|
1610 Class: CTestModule |
|
1611 |
|
1612 Method: GetTestCaseTitleL |
|
1613 |
|
1614 Gets title of currently running test case |
|
1615 |
|
1616 Parameters: None |
|
1617 |
|
1618 Return Values: TInt aTestCaseNumber: in: index of currently running test case |
|
1619 TDes& aTestCaseTitle: out: test case title |
|
1620 |
|
1621 Errors/Exceptions: None |
|
1622 |
|
1623 Status: Proposal |
|
1624 |
|
1625 ------------------------------------------------------------------------------- |
|
1626 */ |
|
1627 void CTestModule::GetTestCaseTitleL(TInt aTestCaseNumber, const TDesC& aConfigFile,TDes& aTestCaseTitle) |
|
1628 { |
|
1629 CTestCasesList* testCasesList = NULL; |
|
1630 for ( TInt i = 0; i < iTestCaseTitlesMap.Count(); i++ ) |
|
1631 { |
|
1632 if ( iTestCaseTitlesMap[ i ]->GetConfigFileName() == aConfigFile ) |
|
1633 { |
|
1634 testCasesList = iTestCaseTitlesMap[ i ]; |
|
1635 break; |
|
1636 } |
|
1637 } |
|
1638 if ( testCasesList == NULL ) |
|
1639 { |
|
1640 User::Leave( KErrNotFound ); |
|
1641 } |
|
1642 |
|
1643 RDebug::Print(_L("Trying to get test case title from module. Index=%d, count=%d"), aTestCaseNumber, testCasesList->Count() ); |
|
1644 |
|
1645 aTestCaseTitle.Copy( testCasesList->GetTestCaseTitleL( aTestCaseNumber ) ); |
|
1646 } |
|
1647 |
|
1648 |
|
1649 /* |
|
1650 ------------------------------------------------------------------------------- |
|
1651 |
|
1652 Class: CTestModule |
|
1653 |
|
1654 Method: GetTestServer |
|
1655 |
|
1656 Gets pointer to TestServer |
|
1657 |
|
1658 Parameters: None |
|
1659 |
|
1660 Return Values: CTestServer : pointer to TestServer |
|
1661 |
|
1662 Errors/Exceptions: None |
|
1663 |
|
1664 Status: Proposal |
|
1665 |
|
1666 ------------------------------------------------------------------------------- |
|
1667 */ |
|
1668 CTestServer* CTestModule::GetTestServer() |
|
1669 { |
|
1670 return iTestServer; |
|
1671 } |
|
1672 |
|
1673 // End of File |