9 * Initial Contributors: |
9 * Initial Contributors: |
10 * Nokia Corporation - initial contribution. |
10 * Nokia Corporation - initial contribution. |
11 * |
11 * |
12 * Contributors: |
12 * Contributors: |
13 * |
13 * |
14 * Description: |
14 * Description: Unit test code for RStarterSession class |
15 * |
15 * |
16 */ |
16 */ |
17 |
17 |
18 |
18 |
19 // CLASS HEADER |
19 // CLASS HEADER |
20 #include "MT_RStarterSession.h" |
20 #include "MT_RStarterSession.h" |
21 |
21 |
22 // EXTERNAL INCLUDES |
22 // EXTERNAL INCLUDES |
23 #include <EUnitMacros.h> |
23 #include <stifparser.h> |
24 #include <EUnitDecorators.h> |
24 #include <stiftestinterface.h> |
25 |
25 |
26 |
26 |
27 // INTERNAL INCLUDES |
27 // INTERNAL INCLUDES |
28 #include <starterclient.h> |
28 #include <starterclient.h> |
29 #include <starter.hrh> |
29 #include <starter.hrh> |
30 |
30 |
|
31 // --------------------------------------------------------- |
|
32 // MT_RStarterSession::LibEntryL |
|
33 // Returns: Poiter to MT_RStarterSession class |
|
34 // --------------------------------------------------------- |
|
35 EXPORT_C MT_RStarterSession* LibEntryL( CTestModuleIf& aTestModuleIf ) |
|
36 { |
|
37 RDebug::Printf("MT_RStarterSession* LibEntryL"); |
|
38 MT_RStarterSession* libEntry( MT_RStarterSession::NewL( aTestModuleIf ) ); |
|
39 return libEntry; |
|
40 } |
|
41 |
31 // CONSTRUCTION |
42 // CONSTRUCTION |
32 MT_RStarterSession* MT_RStarterSession::NewL() |
43 MT_RStarterSession* MT_RStarterSession::NewL(CTestModuleIf& aTestModuleIf) |
33 { |
44 { |
34 MT_RStarterSession* self = MT_RStarterSession::NewLC(); |
45 RDebug::Printf("MT_RStarterSession* NewL"); |
35 CleanupStack::Pop(); |
46 MT_RStarterSession* self = new ( ELeave ) MT_RStarterSession( aTestModuleIf ); |
36 |
|
37 return self; |
|
38 } |
|
39 |
|
40 MT_RStarterSession* MT_RStarterSession::NewLC() |
|
41 { |
|
42 MT_RStarterSession* self = new( ELeave ) MT_RStarterSession(); |
|
43 CleanupStack::PushL( self ); |
|
44 |
|
45 self->ConstructL(); |
|
46 |
|
47 return self; |
47 return self; |
48 } |
48 } |
49 |
49 |
50 // Destructor (virtual by CBase) |
50 // Destructor (virtual by CBase) |
51 MT_RStarterSession::~MT_RStarterSession() |
51 MT_RStarterSession::~MT_RStarterSession() |
52 { |
52 { |
53 Teardown(); |
53 Teardown(); |
54 } |
54 } |
55 |
55 |
56 // Default constructor |
56 // Default constructor |
57 MT_RStarterSession::MT_RStarterSession() |
57 MT_RStarterSession::MT_RStarterSession(CTestModuleIf& /*aTestModuleIf*/) |
58 { |
58 { |
59 } |
59 } |
60 |
60 |
61 // Second phase construct |
61 // ----------------------------------------------------------------------------- |
62 void MT_RStarterSession::ConstructL() |
62 // MT_SysLangUtil::Case |
63 { |
63 // Returns a test case by number. |
64 // The ConstructL from the base class CEUnitTestSuiteClass must be called. |
64 // |
65 // It generates the test case table. |
65 // This function contains an array of all available test cases |
66 CEUnitTestSuiteClass::ConstructL(); |
66 // i.e pair of case name and test function. If case specified by parameter |
|
67 // aCaseNumber is found from array, then that item is returned. |
|
68 // |
|
69 // The reason for this rather complicated function is to specify all the |
|
70 // test cases only in one place. It is not necessary to understand how |
|
71 // function pointers to class member functions works when adding new test |
|
72 // cases. See function body for instructions how to add new test case. |
|
73 // ----------------------------------------------------------------------------- |
|
74 // |
|
75 const TCaseInfo MT_RStarterSession::Case( const TInt aCaseNumber ) const |
|
76 { |
|
77 |
|
78 /** |
|
79 * To add new test cases, implement new test case function and add new |
|
80 * line to KCases array specify the name of the case and the function |
|
81 * doing the test case |
|
82 * In practice, do following |
|
83 * 1) Make copy of existing test case function and change its name |
|
84 * and functionality. Note that the function must be added to |
|
85 * CenRepNotifyHandlerTest.cpp file and to CenRepNotifyHandlerTest.h |
|
86 * header file. |
|
87 * 2) Add entry to following KCases array either by using FUNCENTRY or |
|
88 * ENTRY macro. |
|
89 * ENTRY macro takes two parameters: test case name and test case |
|
90 * function name. |
|
91 * FUNCENTRY macro takes only test case function name as a parameter and uses |
|
92 * that as a test case name and test case function name. |
|
93 */ |
|
94 RDebug::Printf("MT_RStarterSession* case"); |
|
95 static TCaseInfoInternal const KCases[] = |
|
96 { |
|
97 // To add new test cases, add new items to this array |
|
98 ENTRY( "1 [RStarterSession] Test ConectL", &MT_RStarterSession::T_RStarterSession_Connect ), |
|
99 ENTRY( "2 [RStarterSession] Test SetState to Normal", &MT_RStarterSession::T_RStarterSession_SetStateToNormal), |
|
100 ENTRY( "3 [RStarterSession] Test SetStateti Alarm", &MT_RStarterSession::T_RStarterSession_SetStateToAlarm), |
|
101 ENTRY( "4 [RStarterSession] Test SetState to Charging", &MT_RStarterSession::T_RStarterSession_SetStateToCharging), |
|
102 ENTRY( "5 [RStarterSession] Test SetState to OffLine", &MT_RStarterSession::T_RStarterSession_SetStateToOffLine), |
|
103 ENTRY( "6 [RStarterSession] Test SetState to BTSap", &MT_RStarterSession::T_RStarterSession_SetStateToBTSap), |
|
104 ENTRY( "7 [RStarterSession] Test ResetNetwork", &MT_RStarterSession::T_RStarterSession_ResetNetwork), |
|
105 ENTRY( "8 [RStarterSession] Test IsRTCTimeValid", &MT_RStarterSession::T_RStarterSession_IsRTCTimeValid), |
|
106 ENTRY( "9 [RStarterSession] Test ActivateRfForEmergencyCall", &MT_RStarterSession::T_RStarterSession_ActivateRfForEmergencyCall ), |
|
107 ENTRY( "10 [RStarterSession] Test DeactivateRfAfterEmergencyCall", &MT_RStarterSession::T_RStarterSession_DeactivateRfAfterEmergencyCall), |
|
108 ENTRY( "11 [RStarterSession] Test EndSplashScreen", &MT_RStarterSession::T_RStarterSession_EndSplashScreen), |
|
109 ENTRY( "12 [RStarterSession] Test Reset", &MT_RStarterSession::T_RStarterSession_Reset), |
|
110 ENTRY( "13 [RStarterSession] Test Shutdown", &MT_RStarterSession:: T_RStarterSession_Shutdown) |
|
111 }; |
|
112 |
|
113 // Verify that case number is valid |
|
114 if( (TUint) aCaseNumber >= sizeof( KCases ) / sizeof( TCaseInfoInternal ) ) |
|
115 { |
|
116 // Invalid case, construct empty object |
|
117 TCaseInfo null( (const TText*) L"" ); |
|
118 null.iMethod = NULL; |
|
119 return null; |
|
120 } |
|
121 |
|
122 // Construct TCaseInfo object and return it |
|
123 TCaseInfo tmp ( KCases[aCaseNumber].iCaseName ); |
|
124 tmp.iMethod = KCases[aCaseNumber].iMethod; |
|
125 tmp.iIsOOMTest = KCases[ aCaseNumber ].iIsOOMTest; |
|
126 tmp.iFirstMemoryAllocation = KCases[ aCaseNumber ].iFirstMemoryAllocation; |
|
127 tmp.iLastMemoryAllocation = KCases[ aCaseNumber ].iLastMemoryAllocation; |
|
128 |
|
129 return tmp; |
|
130 } |
|
131 |
|
132 // ----------------------------------------------------------------------------- |
|
133 // MT_SysLangUtil::GetTestCasesL |
|
134 // GetTestCases is used to inquire test cases from the Test Module. Test |
|
135 // cases are stored to array of test cases. The Test Framework will be |
|
136 // the owner of the data in the RPointerArray after GetTestCases return |
|
137 // and it does the memory deallocation. |
|
138 // ----------------------------------------------------------------------------- |
|
139 // |
|
140 TInt MT_RStarterSession::GetTestCasesL( const TFileName& /*aConfig*/, |
|
141 RPointerArray<TTestCaseInfo>& aTestCases ) |
|
142 { |
|
143 RDebug::Printf("MT_RStarterSession* gettestcase"); |
|
144 // Loop through all test cases and create new |
|
145 // TTestCaseInfo items and append items to aTestCase array |
|
146 for( TInt i = 0; Case(i).iMethod != NULL; i++ ) |
|
147 { |
|
148 |
|
149 // Allocate new TTestCaseInfo from heap for a testcase definition. |
|
150 TTestCaseInfo* newCase = new( ELeave ) TTestCaseInfo; |
|
151 |
|
152 // PushL TTestCaseInfo to CleanupStack. |
|
153 CleanupStack::PushL( newCase ); |
|
154 |
|
155 // Set number for the testcase. |
|
156 // When the testcase is run, this comes as a parameter to RunTestCaseL. |
|
157 newCase->iCaseNumber = i; |
|
158 |
|
159 // Set title for the test case. This is shown in UI to user. |
|
160 newCase->iTitle.Copy( Case(i).iCaseName ); |
|
161 |
|
162 // Append TTestCaseInfo to the testcase array. After appended |
|
163 // successfully the TTestCaseInfo object is owned (and freed) |
|
164 // by the TestServer. |
|
165 User::LeaveIfError(aTestCases.Append ( newCase ) ); |
|
166 |
|
167 // Pop TTestCaseInfo from the CleanupStack. |
|
168 CleanupStack::Pop( newCase ); |
|
169 } |
|
170 return KErrNone; |
|
171 } |
|
172 |
|
173 // ----------------------------------------------------------------------------- |
|
174 // MT_SysLangUtil::RunTestCaseL |
|
175 // RunTestCaseL is used to run an individual test case specified |
|
176 // by aTestCase. Test cases that can be run may be requested from |
|
177 // Test Module by GetTestCases method before calling RunTestCase. |
|
178 // ----------------------------------------------------------------------------- |
|
179 // |
|
180 TInt MT_RStarterSession::RunTestCaseL( const TInt aCaseNumber, |
|
181 const TFileName& /*aConfig*/, |
|
182 TTestResult& aResult ) |
|
183 { |
|
184 |
|
185 // Return value |
|
186 TInt execStatus = KErrNone; |
|
187 |
|
188 // Get the pointer to test case function |
|
189 TCaseInfo tmp = Case ( aCaseNumber ); |
|
190 |
|
191 // Check that case number was valid |
|
192 if ( tmp.iMethod != NULL ) |
|
193 { |
|
194 // Valid case was found, call it via function pointer |
|
195 iMethod = tmp.iMethod; |
|
196 execStatus = ( this->*iMethod )( aResult ); |
|
197 } |
|
198 else |
|
199 { |
|
200 // Valid case was not found, return error. |
|
201 execStatus = KErrNotFound; |
|
202 } |
|
203 |
|
204 // Return case execution status (not the result of the case execution) |
|
205 return execStatus; |
67 } |
206 } |
68 |
207 |
69 // METHODS |
208 // METHODS |
70 |
|
71 |
|
72 void MT_RStarterSession::SetupEmptyL( ) |
|
73 { |
|
74 } |
|
75 |
209 |
76 void MT_RStarterSession::SetupL( ) |
210 void MT_RStarterSession::SetupL( ) |
77 { |
211 { |
78 iRStarterSession.Connect(); |
212 TInt err = iRStarterSession.Connect(); |
|
213 RDebug::Print(_L("MT_RStarterSession* SetupL Connected to RStarterSession with % error"),err); |
79 } |
214 } |
80 |
215 |
81 void MT_RStarterSession::Teardown( ) |
216 void MT_RStarterSession::Teardown( ) |
82 { |
217 { |
83 iRStarterSession.Close(); |
218 iRStarterSession.Close(); |
84 } |
219 } |
85 |
220 |
86 void MT_RStarterSession::TeardownEmpty( ) |
221 TInt MT_RStarterSession::T_RStarterSession_Connect( TTestResult& aResult ) |
87 { |
|
88 } |
|
89 |
|
90 void MT_RStarterSession::T_RStarterSession_ConnectL( ) |
|
91 { |
222 { |
92 RStarterSession session; |
223 RStarterSession session; |
93 TInt err = session.Connect(); |
224 TInt err = session.Connect(); |
94 |
225 |
95 EUNIT_PRINT( _L("Connect() err = %d"), err ); |
226 if ( err != KErrNone ) |
96 EUNIT_ASSERT_DESC( err == KErrNone, "Incorrect return value"); |
227 { |
97 |
228 _LIT( KDescription, "Incorrect return value in T_RStarterSession_Connect" ); |
|
229 aResult.SetResult( err, KDescription ); |
|
230 return err; |
|
231 } |
98 session.Close(); |
232 session.Close(); |
99 } |
233 return err; |
100 |
234 } |
101 void MT_RStarterSession::T_RStarterSession_SetStateL( ) |
235 |
102 { |
236 TInt MT_RStarterSession::T_RStarterSession_SetStateToNormal( TTestResult& aResult ) |
103 // Perhaps test also other values... |
237 { |
|
238 SetupL(); |
|
239 // State transition from Normal to normal |
104 TInt err = iRStarterSession.SetState( RStarterSession::ENormal ); |
240 TInt err = iRStarterSession.SetState( RStarterSession::ENormal ); |
105 EUNIT_PRINT( _L("SetState() err = %d"), err ); |
241 |
106 EUNIT_ASSERT_DESC( err == KErrNone, "Incorrect return value"); |
242 if ( (err != KErrArgument) && (err != KErrGeneral) && (err != KErrNone)) |
107 } |
243 { |
108 |
244 _LIT( KDescription, "Incorrect return value in T_RStarterSession_SetStateToNormal " ); |
109 void MT_RStarterSession::T_RStarterSession_ResetL( ) |
245 aResult.SetResult( err, KDescription ); |
110 { |
246 return err; |
111 // Perhaps test also other values... |
247 } |
|
248 Teardown(); |
|
249 return KErrNone; |
|
250 } |
|
251 |
|
252 TInt MT_RStarterSession::T_RStarterSession_SetStateToAlarm( TTestResult& aResult ) |
|
253 { |
|
254 SetupL(); |
|
255 // State transition from normal to Alarm |
|
256 TInt err = iRStarterSession.SetState( RStarterSession::EAlarm ); |
|
257 |
|
258 if ( err != KErrNotSupported ) |
|
259 { |
|
260 _LIT( KDescription, "Incorrect return value T_RStarterSession_SetStateToAlarm" ); |
|
261 aResult.SetResult( err, KDescription ); |
|
262 return err; |
|
263 } |
|
264 Teardown(); |
|
265 return KErrNone; |
|
266 } |
|
267 |
|
268 TInt MT_RStarterSession::T_RStarterSession_SetStateToCharging( TTestResult& aResult ) |
|
269 { |
|
270 SetupL(); |
|
271 // State transition from normal to ECharging |
|
272 TInt err = iRStarterSession.SetState( RStarterSession::ECharging ); |
|
273 |
|
274 if ( err != KErrNotSupported ) |
|
275 { |
|
276 _LIT( KDescription, "Incorrect return value in T_RStarterSession_SetStateEToCharging " ); |
|
277 aResult.SetResult( err, KDescription ); |
|
278 return err; |
|
279 } |
|
280 Teardown(); |
|
281 return KErrNone; |
|
282 } |
|
283 |
|
284 TInt MT_RStarterSession::T_RStarterSession_SetStateToOffLine( TTestResult& aResult ) |
|
285 { |
|
286 SetupL(); |
|
287 // State transition from normal to EOffline |
|
288 TInt err = iRStarterSession.SetState( RStarterSession::EOffline ); |
|
289 |
|
290 if ( err != KErrNone ) |
|
291 { |
|
292 _LIT( KDescription, "Incorrect return value in T_RStarterSession_SetStateTOOffLine " ); |
|
293 aResult.SetResult( err, KDescription ); |
|
294 return err; |
|
295 } |
|
296 Teardown(); |
|
297 return err; |
|
298 } |
|
299 |
|
300 TInt MT_RStarterSession::T_RStarterSession_SetStateToBTSap( TTestResult& aResult ) |
|
301 { |
|
302 SetupL(); |
|
303 // State transition from ENormal to EBTSap |
|
304 TInt err = iRStarterSession.SetState( RStarterSession::EBTSap ); |
|
305 |
|
306 if ( err != KErrNone ) |
|
307 { |
|
308 _LIT( KDescription, "Incorrect return value in T_RStarterSession_SetStateToBTSap " ); |
|
309 aResult.SetResult( err, KDescription ); |
|
310 return err; |
|
311 } |
|
312 Teardown(); |
|
313 return err; |
|
314 } |
|
315 |
|
316 TInt MT_RStarterSession::T_RStarterSession_Reset( TTestResult& aResult ) |
|
317 { |
|
318 SetupL(); |
|
319 // Other values will be tested in BAT testing (Manual testing)... |
112 iRStarterSession.Reset( (RStarterSession::TResetReason)-1 ); |
320 iRStarterSession.Reset( (RStarterSession::TResetReason)-1 ); |
113 } |
321 // Make request and ignore return value |
114 |
322 _LIT( KDescription, "T_RStarterSession_Reset - Calling Reset()" ); |
115 void MT_RStarterSession::T_RStarterSession_ShutdownL( ) |
323 aResult.SetResult( KErrNone, KDescription ); |
116 { |
324 Teardown(); |
117 EUNIT_PRINT( _L("Calling Shutdown()") ); |
325 return KErrNone; |
|
326 } |
|
327 |
|
328 TInt MT_RStarterSession::T_RStarterSession_Shutdown(TTestResult& aResult ) |
|
329 { |
|
330 SetupL(); |
118 iRStarterSession.Shutdown( ); |
331 iRStarterSession.Shutdown( ); |
119 } |
332 _LIT( KDescription, "T_RStarterSession_Shutdown - Calling Shutdown()" ); |
120 |
333 aResult.SetResult( KErrNone, KDescription ); |
121 void MT_RStarterSession::T_RStarterSession_ResetNetworkL( ) |
334 Teardown(); |
122 { |
335 return KErrNone; |
123 TInt err = iRStarterSession.ResetNetwork( ); |
336 } |
124 EUNIT_PRINT( _L("ResetNetwork() err = %d"), err ); |
337 |
125 |
338 TInt MT_RStarterSession::T_RStarterSession_ResetNetwork(TTestResult& aResult ) |
126 EUNIT_ASSERT_DESC( err == KErrNone, "Incorrect return value"); |
339 { |
127 } |
340 SetupL(); |
128 |
341 TInt err = iRStarterSession.ResetNetwork( ); |
129 void MT_RStarterSession::T_RStarterSession_IsRTCTimeValidL( ) |
342 if ( err != KErrNone ) |
130 { |
343 { |
|
344 _LIT( KDescription, "T_RStarterSession_ResetNetwork - Incorrect return value in " ); |
|
345 aResult.SetResult( err, KDescription ); |
|
346 return err; |
|
347 } |
|
348 Teardown(); |
|
349 return err; |
|
350 } |
|
351 |
|
352 TInt MT_RStarterSession::T_RStarterSession_IsRTCTimeValid(TTestResult& aResult ) |
|
353 { |
|
354 SetupL(); |
131 TBool valid = iRStarterSession.IsRTCTimeValid(); |
355 TBool valid = iRStarterSession.IsRTCTimeValid(); |
132 EUNIT_PRINT( _L("IsRTCTimeValid() returned = %d"), valid ); |
356 if ( !valid ) |
133 } |
357 { |
134 |
358 _LIT( KDescription, "Incorrect return value in T_RStarterSession_IsRTCTimeValid " ); |
135 void MT_RStarterSession::T_RStarterSession_ActivateRfForEmergencyCallL( ) |
359 aResult.SetResult( valid, KDescription ); |
136 { |
360 return valid; |
|
361 } |
|
362 Teardown(); |
|
363 return KErrNone; |
|
364 } |
|
365 |
|
366 TInt MT_RStarterSession::T_RStarterSession_ActivateRfForEmergencyCall(TTestResult& aResult ) |
|
367 { |
|
368 SetupL(); |
137 TInt err = iRStarterSession.ActivateRfForEmergencyCall( ); |
369 TInt err = iRStarterSession.ActivateRfForEmergencyCall( ); |
138 EUNIT_PRINT( _L("ActivateRfForEmergencyCall() err = %d"), err ); |
370 |
139 // Do not check the return value since in some cases it is normal that |
371 if (( err != KErrNone) && (err != KErrGeneral)) |
140 // KErrGeneral(-2) is returned |
372 { |
141 //EUNIT_ASSERT_DESC( err == KErrNone, "Incorrect return value" ); |
373 _LIT( KDescription, "Incorrect return value in T_RStarterSession_ActivateRfForEmergencyCall" ); |
142 } |
374 aResult.SetResult( err, KDescription ); |
143 |
375 return err; |
144 void MT_RStarterSession::T_RStarterSession_DeactivateRfAfterEmergencyCallL( ) |
376 } |
145 { |
377 Teardown(); |
|
378 return err; |
|
379 } |
|
380 |
|
381 TInt MT_RStarterSession::T_RStarterSession_DeactivateRfAfterEmergencyCall( TTestResult& aResult ) |
|
382 { |
|
383 SetupL(); |
146 TInt err = iRStarterSession.DeactivateRfAfterEmergencyCall( ); |
384 TInt err = iRStarterSession.DeactivateRfAfterEmergencyCall( ); |
147 EUNIT_PRINT( _L("DeactivateRfAfterEmergencyCall() err = %d"), err ); |
385 |
148 EUNIT_ASSERT_DESC( err == KErrNone, "Incorrect return value" ); |
386 if (( err != KErrNone) && (err != KErrGeneral)) |
149 |
387 { |
|
388 _LIT( KDescription, "Incorrect return value in T_RStarterSession_DeactivateRfAfterEmergencyCall" ); |
|
389 aResult.SetResult( err, KDescription ); |
|
390 return err; |
|
391 } |
150 // Activate RF again |
392 // Activate RF again |
151 err = iRStarterSession.ActivateRfForEmergencyCall( ); |
393 err = iRStarterSession.ActivateRfForEmergencyCall( ); |
152 EUNIT_PRINT( _L("ActivateRfForEmergencyCall() err = %d"), err ); |
394 Teardown(); |
153 // Do not check the return value since in some cases it is normal that |
395 return err; |
154 // KErrGeneral(-2) is returned |
396 } |
155 //EUNIT_ASSERT_DESC( err == KErrNone, "Incorrect return value" ); |
397 |
156 } |
398 TInt MT_RStarterSession::T_RStarterSession_EndSplashScreen( TTestResult& aResult ) |
157 |
399 { |
158 void MT_RStarterSession::T_RStarterSession_EndSplashScreenL( ) |
400 SetupL(); |
159 { |
|
160 TInt err = iRStarterSession.EndSplashScreen( ); |
401 TInt err = iRStarterSession.EndSplashScreen( ); |
161 EUNIT_PRINT( _L("EndSplashScreen() err = %d"), err ); |
402 if ( err != KErrNone ) |
162 EUNIT_ASSERT_DESC( err == KErrNone, "Incorrect return value" ); |
403 { |
163 } |
404 _LIT( KDescription, "Incorrect return value in T_RStarterSession_EndSplashScreen" ); |
164 |
405 aResult.SetResult( err, KDescription ); |
165 // TEST TABLE |
406 return err; |
166 EUNIT_BEGIN_TEST_TABLE( |
407 } |
167 MT_RStarterSession, |
408 Teardown(); |
168 "Add test suite description here.", |
409 return err; |
169 "UNIT" ) |
410 } |
170 |
411 |
171 EUNIT_TEST( |
412 //END OF FILE |
172 "Connect - test0", |
|
173 "RStarterSession", |
|
174 "Connect - test0", |
|
175 "FUNCTIONALITY", |
|
176 SetupEmptyL, T_RStarterSession_ConnectL, TeardownEmpty) |
|
177 |
|
178 EUNIT_TEST( |
|
179 "SetState - test1", |
|
180 "RStarterSession", |
|
181 "SetState - test1", |
|
182 "FUNCTIONALITY", |
|
183 SetupL, T_RStarterSession_SetStateL, Teardown) |
|
184 |
|
185 EUNIT_TEST( |
|
186 "Reset - test2", |
|
187 "RStarterSession", |
|
188 "Reset - test2", |
|
189 "FUNCTIONALITY", |
|
190 SetupL, T_RStarterSession_ResetL, Teardown) |
|
191 |
|
192 EUNIT_TEST( |
|
193 "ResetNetwork - test4", |
|
194 "RStarterSession", |
|
195 "ResetNetwork - test4", |
|
196 "FUNCTIONALITY", |
|
197 SetupL, T_RStarterSession_ResetNetworkL, Teardown) |
|
198 |
|
199 EUNIT_TEST( |
|
200 "IsRTCTimeValid - test5", |
|
201 "RStarterSession", |
|
202 "IsRTCTimeValid - test5", |
|
203 "FUNCTIONALITY", |
|
204 SetupL, T_RStarterSession_IsRTCTimeValidL, Teardown) |
|
205 |
|
206 EUNIT_TEST( |
|
207 "ActivateRfForEmergencyCall - test6", |
|
208 "RStarterSession", |
|
209 "ActivateRfForEmergencyCall - test6", |
|
210 "FUNCTIONALITY", |
|
211 SetupL, T_RStarterSession_ActivateRfForEmergencyCallL, Teardown) |
|
212 |
|
213 EUNIT_TEST( |
|
214 "DeactivateRfAfterEmergencyCall - test7", |
|
215 "RStarterSession", |
|
216 "DeactivateRfAfterEmergencyCall - test7", |
|
217 "FUNCTIONALITY", |
|
218 SetupL, T_RStarterSession_DeactivateRfAfterEmergencyCallL, Teardown) |
|
219 |
|
220 EUNIT_TEST( |
|
221 "EndSplashScreen - test8", |
|
222 "RStarterSession", |
|
223 "EndSplashScreen - test8", |
|
224 "FUNCTIONALITY", |
|
225 SetupL, T_RStarterSession_EndSplashScreenL, Teardown) |
|
226 |
|
227 /* |
|
228 EUNIT_TEST( |
|
229 "Shutdown - test3", |
|
230 "RStarterSession", |
|
231 "Shutdown - test3", |
|
232 "FUNCTIONALITY", |
|
233 SetupL, T_RStarterSession_ShutdownL, Teardown)*/ |
|
234 |
|
235 EUNIT_END_TEST_TABLE |
|
236 |
|
237 // END OF FILE |
|