1 /* |
|
2 * Copyright (c) 2010 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: |
|
15 * |
|
16 */ |
|
17 |
|
18 // [INCLUDE FILES] - do not remove |
|
19 #include <e32svr.h> |
|
20 #include <StifParser.h> |
|
21 #include <Stiftestinterface.h> |
|
22 #include "UsbWatcherTest.h" |
|
23 #include "testdebug.h" |
|
24 |
|
25 // EXTERNAL DATA STRUCTURES |
|
26 |
|
27 // EXTERNAL FUNCTION PROTOTYPES |
|
28 |
|
29 // CONSTANTS |
|
30 |
|
31 // MACROS |
|
32 |
|
33 // LOCAL CONSTANTS AND MACROS |
|
34 |
|
35 // MODULE DATA STRUCTURES |
|
36 |
|
37 // LOCAL FUNCTION PROTOTYPES |
|
38 |
|
39 // FORWARD DECLARATIONS |
|
40 |
|
41 // ============================= LOCAL FUNCTIONS =============================== |
|
42 |
|
43 // ----------------------------------------------------------------------------- |
|
44 // ----------------------------------------------------------------------------- |
|
45 |
|
46 // ============================ MEMBER FUNCTIONS =============================== |
|
47 |
|
48 // ----------------------------------------------------------------------------- |
|
49 // CUsbWatcherTest::TestConstructL |
|
50 // Construct here all test resources for test methods. |
|
51 // Called from ConstructL. |
|
52 // ----------------------------------------------------------------------------- |
|
53 |
|
54 void CUsbWatcherTest::TestConstructL() |
|
55 { |
|
56 TRACE_FUNC_ENTRY |
|
57 |
|
58 iStubber = CStubber::NewL(); |
|
59 |
|
60 iWatcher = new ( ELeave ) RUsbWatcher(); |
|
61 iCenRep = CRepository::NewL( KCRUidUsbWatcher ); |
|
62 STIF_LOG( "Usb man initialization" ); |
|
63 iUsbMan = new ( ELeave ) RUsb(); |
|
64 User::LeaveIfError( iUsbMan -> Connect() ); |
|
65 User::LeaveIfError( BackupPersonalitySetting() ); |
|
66 |
|
67 TRACE_FUNC_EXIT |
|
68 } |
|
69 |
|
70 // ----------------------------------------------------------------------------- |
|
71 // CUsbWatcherTest::TestDelete |
|
72 // Delete here all resources allocated and opened from test methods. |
|
73 // Called from destructor. |
|
74 // ----------------------------------------------------------------------------- |
|
75 |
|
76 void CUsbWatcherTest::TestDelete() |
|
77 { |
|
78 TRACE_FUNC_ENTRY |
|
79 |
|
80 if ( RestorePersonalitySetting() != KErrNone ) |
|
81 STIF_LOG( "Warning: personality restore failed" ); |
|
82 |
|
83 delete iWatcher; |
|
84 iWatcher = NULL; |
|
85 |
|
86 delete iCenRep; |
|
87 iCenRep = NULL; |
|
88 |
|
89 iUsbMan -> Close(); |
|
90 delete iUsbMan; |
|
91 iUsbMan = NULL; |
|
92 |
|
93 delete iStubber; |
|
94 iStubber = NULL; |
|
95 |
|
96 TRACE_FUNC_EXIT |
|
97 } |
|
98 |
|
99 // ----------------------------------------------------------------------------- |
|
100 // CUsbWatcherTest::TestBlocksInfoL |
|
101 // Add new test block parameter entries below |
|
102 // ----------------------------------------------------------------------------- |
|
103 |
|
104 void CUsbWatcherTest::TestBlocksInfoL() |
|
105 { |
|
106 |
|
107 TESTENTRY( "ExampleTestL", CUsbWatcherTest::ExampleTestL ) |
|
108 { |
|
109 TESTPARAM( eGetString, eTestOption1 ) |
|
110 TESTPARAM( eGetString, eTestOption2 ) |
|
111 TESTPARAM( eGetInt, eTestIntOption1 ) |
|
112 TESTPARAM( eGetChar, eTestCharOption1 ) |
|
113 } |
|
114 |
|
115 TESTENTRY( "InitializationTest", CUsbWatcherTest::InitializationTestL ) |
|
116 { |
|
117 TESTPARAM( eGetString, eTestOption1 ) |
|
118 } |
|
119 |
|
120 TESTENTRY( "PersonalityManagementTest", CUsbWatcherTest::PersonalityManagementTestL ) |
|
121 { |
|
122 TESTPARAM( eGetString, eTestOption1 ) |
|
123 TESTPARAM( eGetString, eTestOption2 ) |
|
124 } |
|
125 |
|
126 TESTENTRY( "PersonalitySwitchTest", CUsbWatcherTest::PersonalitySwitchTestL ) |
|
127 { |
|
128 TESTPARAM( eGetString, eTestOption1 ) |
|
129 } |
|
130 |
|
131 TESTENTRY( "BranchTest", CUsbWatcherTest::BranchTestL ) |
|
132 { |
|
133 TESTPARAM( eGetString, eTestOption1 ) |
|
134 } |
|
135 } |
|
136 |
|
137 // Add test block methods implementation here |
|
138 // ----------------------------------------------------------------------------- |
|
139 // CUsbWatcherTest::ExampleTestL |
|
140 // ----------------------------------------------------------------------------- |
|
141 |
|
142 void CUsbWatcherTest::ExampleTestL( TUsbWatcherTestBlockParams& aParams, TUsbWatcherTestResult& aTestResult ) |
|
143 { |
|
144 TRACE_FUNC_ENTRY |
|
145 |
|
146 //iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) ); |
|
147 |
|
148 if ( !aParams.iTestOption1.Compare( _L( "API" ) ) ) |
|
149 { |
|
150 TRACE_INFO( "Api test option: %S", &aParams.iTestOption1 ) |
|
151 TRACE_INFO( "Api test sub-option: %S", &aParams.iTestOption2 ) |
|
152 TRACE_INFO( "Api test int option: %d", aParams.iTestIntOption1 ) |
|
153 TRACE_INFO( "Api test char option: %c", TText( aParams.iTestCharOption1 ) ) |
|
154 } |
|
155 else if ( !aParams.iTestOption1.Compare( _L( "MODULE" ) ) ) |
|
156 { |
|
157 TRACE_INFO( "Module test option: %S", &aParams.iTestOption1 ) |
|
158 TRACE_INFO( "Module test sub-option: %S", &aParams.iTestOption2 ) |
|
159 TRACE_INFO( "Module test int option: %d", aParams.iTestIntOption1 ) |
|
160 TRACE_INFO( "Module test char option: %c", TText( aParams.iTestCharOption1 ) ) |
|
161 } |
|
162 else if ( !aParams.iTestOption1.Compare( _L( "BRANCH" ) ) ) |
|
163 { |
|
164 TRACE_INFO( "Branch test option: %S", &aParams.iTestOption1 ) |
|
165 TRACE_INFO( "Branch test sub-option: %S", &aParams.iTestOption2 ) |
|
166 TRACE_INFO( "Branch test int option: %d", aParams.iTestIntOption1 ) |
|
167 TRACE_INFO( "Branch test char option: %c", TText( aParams.iTestCharOption1 ) ) |
|
168 } |
|
169 else |
|
170 { |
|
171 TRACE( "Invalid test parameter" ) |
|
172 TRACE_FUNC_EXIT |
|
173 User::Leave( KErrNotFound ); |
|
174 } |
|
175 |
|
176 aTestResult = ETestCasePassed; |
|
177 TRACE_FUNC_EXIT |
|
178 } |
|
179 |
|
180 |
|
181 // Add other member functions implementation here |
|
182 |
|
183 // ----------------------------------------------------------------------------- |
|
184 // CUSBWatcherApiTest::InitializationTest |
|
185 // ----------------------------------------------------------------------------- |
|
186 |
|
187 void CUsbWatcherTest::InitializationTestL( TUsbWatcherTestBlockParams& aParams, |
|
188 TUsbWatcherTestResult& aTestResult ) |
|
189 { |
|
190 TInt res; |
|
191 TPtrC testOptionName( aParams.iTestOption1 ); |
|
192 |
|
193 if ( !testOptionName.Compare( _L( "VERSION" ) ) ) |
|
194 { |
|
195 TRACE( "Test option: VERSION" ); |
|
196 TVersion returnedVersion; |
|
197 TVersion expectedVersion( KUsbWatcherSrvMajorVersionNumber, |
|
198 KUsbWatcherSrvMinorVersionNumber, |
|
199 KUsbWatcherSrvBuildVersionNumber ); |
|
200 TRACE( " >Version" ); |
|
201 returnedVersion = iWatcher -> Version(); |
|
202 TRACE( " <Version" ); |
|
203 if( expectedVersion.iMajor != returnedVersion.iMajor ) |
|
204 User::Leave(KErrNotFound); |
|
205 if( expectedVersion.iMinor != returnedVersion.iMinor ) |
|
206 User::Leave(KErrNotFound); |
|
207 if( expectedVersion.iBuild != returnedVersion.iBuild ) |
|
208 User::Leave(KErrNotFound); |
|
209 } |
|
210 else if ( !testOptionName.Compare( _L( "SINGLE_CONN" ) ) ) |
|
211 { |
|
212 TRACE( "Test option: SINGLE_CONN" ); |
|
213 TRACE( ">Connect" ); |
|
214 res = iWatcher -> Connect(); |
|
215 TRACE( " <Connect" ); |
|
216 TRACE_INFO( "USB watcher connection value: %d, expected: %d", res, KErrNone ); |
|
217 User::LeaveIfError( res ); |
|
218 } |
|
219 else |
|
220 { |
|
221 TRACE( "Test option: not supported" ); |
|
222 User::Leave( KErrNotFound ); |
|
223 } |
|
224 |
|
225 aTestResult = ETestCasePassed; |
|
226 } |
|
227 |
|
228 // ----------------------------------------------------------------------------- |
|
229 // CUSBWatcherApiTest::PersonalityManagementTest |
|
230 // ----------------------------------------------------------------------------- |
|
231 |
|
232 void CUsbWatcherTest::PersonalityManagementTestL( TUsbWatcherTestBlockParams& aParams, |
|
233 TUsbWatcherTestResult& aTestResult ) |
|
234 { |
|
235 TInt res; |
|
236 TInt newPersonalityId; |
|
237 TPtrC testOptionName( aParams.iTestOption2 ); |
|
238 TPtrC usbPersonalityName( aParams.iTestOption1 ); |
|
239 TInt currentPersonalityId; |
|
240 |
|
241 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetPersonalityProperty, 0, 0, _L8( "stub" ) ) ); |
|
242 |
|
243 res = iUsbMan -> GetCurrentPersonalityId( currentPersonalityId ); |
|
244 if ( res != KErrNone ) |
|
245 { |
|
246 TRACE_INFO( "GetCurrentPersonalityId failed with value: %d", res ); |
|
247 User::Leave(res); |
|
248 } |
|
249 |
|
250 res = GetPersonalityIdFromString( usbPersonalityName, newPersonalityId ); |
|
251 if ( res != KErrNone ) |
|
252 { |
|
253 TRACE_INFO( "GetPersonalityIdFromString failed with value: %d", res ); |
|
254 User::Leave(res); |
|
255 } |
|
256 |
|
257 TRACE( " >Connect" ); |
|
258 res = iWatcher -> Connect(); |
|
259 TRACE( " <Connect" ); |
|
260 TRACE_INFO( "USB watcher connection value: %d, expected: %d", res, KErrNone ); |
|
261 User::LeaveIfError( res ); |
|
262 |
|
263 if ( !testOptionName.Compare( _L( "SET_PERSONALITY" ) ) && newPersonalityId == KUsbPersonalityIdPCSuiteMTP ) |
|
264 { |
|
265 TRequestStatus status; |
|
266 TInt setPersonalityId; |
|
267 |
|
268 if ( currentPersonalityId != newPersonalityId ) |
|
269 { |
|
270 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetDeviceState, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) ); |
|
271 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EDeviceStateNotification, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) ); |
|
272 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStopAsync, 0, 0, _L8( "stub" ) ) ); |
|
273 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) ); |
|
274 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EDeviceStateNotification, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) ); |
|
275 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EDeviceStateNotification, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) ); |
|
276 } |
|
277 |
|
278 res = iUsbMan -> GetCurrentPersonalityId( currentPersonalityId ); |
|
279 |
|
280 TRACE( " >SetPersonality" ); |
|
281 iWatcher -> SetPersonality( status, KUsbPersonalityIdMS, EFalse, EFalse ); |
|
282 User::WaitForRequest( status ); |
|
283 TRACE( " <SetPersonality" ); |
|
284 TRACE_INFO( "Set initial test personality value: %d", status.Int() ); |
|
285 res = iCenRep -> Get( KUsbWatcherPersonality, setPersonalityId ); |
|
286 TRACE_INFO( "Set initial test personality value: %d, personality ID: %d", status.Int(), setPersonalityId ); |
|
287 User::LeaveIfError( status.Int() ); |
|
288 if( KUsbPersonalityIdMS != setPersonalityId ) |
|
289 User::Leave(KErrNotFound); |
|
290 } |
|
291 else |
|
292 { |
|
293 TRequestStatus status; |
|
294 TInt setPersonalityId; |
|
295 |
|
296 if ( currentPersonalityId != newPersonalityId ) |
|
297 { |
|
298 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetDeviceState, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) ); |
|
299 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EDeviceStateNotification, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) ); |
|
300 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStopAsync, 0, 0, _L8( "stub" ) ) ); |
|
301 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) ); |
|
302 } |
|
303 |
|
304 TRACE( " >SetPersonality" ); |
|
305 iWatcher -> SetPersonality( status, KUsbPersonalityIdPCSuiteMTP, EFalse, EFalse ); |
|
306 User::WaitForRequest( status ); |
|
307 TRACE( " <SetPersonality" ); |
|
308 res = iCenRep -> Get( KUsbWatcherPersonality, setPersonalityId ); |
|
309 TRACE_INFO( "Set initial test personality value: %d, personality ID: %d", status.Int(), setPersonalityId ); |
|
310 User::LeaveIfError( status.Int() ); |
|
311 if( KUsbPersonalityIdPCSuiteMTP != setPersonalityId ) |
|
312 User::Leave(KErrNotFound); |
|
313 } |
|
314 |
|
315 if ( !testOptionName.Compare( _L( "SET_PERSONALITY" ) ) ) |
|
316 { |
|
317 TRACE( "Test option: SET_PERSONALITY" ); |
|
318 aTestResult = SetPersonalityTest( newPersonalityId, ETrue ); |
|
319 } |
|
320 else if ( !testOptionName.Compare( _L( "CANCEL_SET_PERSONALITY" ) ) ) |
|
321 { |
|
322 TRACE( "Test option: CANCEL_SET_PERSONALITY" ); |
|
323 aTestResult = CancelSetPersonalityTest( newPersonalityId, ETrue ); |
|
324 } |
|
325 else if ( !testOptionName.Compare( _L( "SET_PREVIOUS_PERSONALITY" ) ) ) |
|
326 { |
|
327 TRACE( "Test option: SET_PREVIOUS_PERSONALITY" ); |
|
328 aTestResult = SetPreviousPersonalityTest( newPersonalityId, ETrue ); |
|
329 } |
|
330 else if ( !testOptionName.Compare( _L( "SET_PREVIOUS_PERSONALITY_ON_DISC" ) ) ) |
|
331 { |
|
332 TRACE( "Test option: SET_PREVIOUS_PERSONALITY_ON_DISC" ); |
|
333 aTestResult = SetPreviousPersonalityOnDiscTest( newPersonalityId, ETrue ); |
|
334 } |
|
335 else if ( !testOptionName.Compare( _L( "SET_PREVIOUS_PERSONALITY_SYNC" ) ) ) |
|
336 { |
|
337 TRACE( "Test option: SET_PREVIOUS_PERSONALITY_SYNC" ); |
|
338 aTestResult = SetPreviousPersonalitySyncTest( newPersonalityId, ETrue ); |
|
339 } |
|
340 else if ( !testOptionName.Compare( _L( "CANCEL_SET_PREVIOUS_PERSONALITY" ) ) ) |
|
341 { |
|
342 TRACE( "Test option: CANCEL_SET_PREVIOUS_PERSONALITY" ); |
|
343 aTestResult = CancelSetPreviousPersonalityTest( newPersonalityId, ETrue ); |
|
344 } |
|
345 else if ( !testOptionName.Compare( _L( "SET_PERSONALITY_DISC" ) ) ) |
|
346 { |
|
347 TRACE( "Test option: SET_PERSONALITY_DISC" ); |
|
348 aTestResult = SetPersonalityTest( newPersonalityId, EFalse ); |
|
349 } |
|
350 else if ( !testOptionName.Compare( _L( "CANCEL_SET_PERSONALITY_DISC" ) ) ) |
|
351 { |
|
352 TRACE( "Test option: CANCEL_SET_PERSONALITY_DISC" ); |
|
353 aTestResult = CancelSetPersonalityTest( newPersonalityId, EFalse ); |
|
354 } |
|
355 else if ( !testOptionName.Compare( _L( "SET_PREVIOUS_PERSONALITY_DISC" ) ) ) |
|
356 { |
|
357 TRACE( "Test option: SET_PREVIOUS_PERSONALITY_DISC" ); |
|
358 aTestResult = SetPreviousPersonalityTest( newPersonalityId, EFalse ); |
|
359 } |
|
360 else if ( !testOptionName.Compare( _L( "SET_PREVIOUS_PERSONALITY_ON_DISC_DISC" ) ) ) |
|
361 { |
|
362 TRACE( "Test option: SET_PREVIOUS_PERSONALITY_ON_DISC_DISC" ); |
|
363 aTestResult = SetPreviousPersonalityOnDiscTest( newPersonalityId, EFalse ); |
|
364 } |
|
365 else if ( !testOptionName.Compare( _L( "SET_PREVIOUS_PERSONALITY_SYNC_DISC" ) ) ) |
|
366 { |
|
367 TRACE( "Test option: SET_PREVIOUS_PERSONALITY_SYNC_DISC" ); |
|
368 aTestResult = SetPreviousPersonalitySyncTest( newPersonalityId, EFalse ); |
|
369 } |
|
370 else if ( !testOptionName.Compare( _L( "CANCEL_SET_PREVIOUS_PERSONALITY_DISC" ) ) ) |
|
371 { |
|
372 TRACE( "Test option: CANCEL_SET_PREVIOUS_PERSONALITY_DISC" ); |
|
373 aTestResult = CancelSetPreviousPersonalityTest( newPersonalityId, EFalse ); |
|
374 } |
|
375 else if ( !testOptionName.Compare( _L( "SET_UNKNOWN_PERSONALITY" ) ) ) |
|
376 { |
|
377 TRACE( "Test option: SET_UNKNOWN_PERSONALITY" ); |
|
378 aTestResult = SetUnknownPersonalityTest(); |
|
379 } |
|
380 else if ( !testOptionName.Compare( _L( "INTERRUPT_PERSONALITY_SET" ) ) ) |
|
381 { |
|
382 TRACE( "Test option: INTERRUPT_PERSONALITY_SET" ); |
|
383 aTestResult = InterruptPersonalitySetTest( newPersonalityId ); |
|
384 } |
|
385 else |
|
386 { |
|
387 TRACE( "Test option: not supported" ); |
|
388 User::Leave(KErrNotFound); |
|
389 } |
|
390 } |
|
391 |
|
392 TUsbWatcherTestResult CUsbWatcherTest::SetPersonalityTest( TInt aNewPersonalityId, TBool aCableConnected ) |
|
393 { |
|
394 TRequestStatus stat; |
|
395 TInt currentPersonalityId; |
|
396 TInt res; |
|
397 |
|
398 TRACE( "Checking test results:" ); |
|
399 |
|
400 if ( aCableConnected ) |
|
401 { |
|
402 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetDeviceState, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) ); |
|
403 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStopAsync, 0, 0, _L8( "stub" ) ) ); |
|
404 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) ); |
|
405 } |
|
406 |
|
407 TRACE( " >SetPersonality" ); |
|
408 iWatcher -> SetPersonality( stat, aNewPersonalityId, EFalse, EFalse ); |
|
409 User::WaitForRequest( stat ); |
|
410 TRACE( " <SetPersonality" ); |
|
411 TRACE_INFO("Set personality request status: %d, expected %d", stat.Int(), KErrNone ); |
|
412 |
|
413 res = iCenRep -> Get( KUsbWatcherPersonality, currentPersonalityId ); |
|
414 TRACE_INFO("GetCurrentPersonalityId value: %d, expected %d", res, KErrNone ); |
|
415 TRACE_INFO("Current personality ID: %d, expected: %d", currentPersonalityId, aNewPersonalityId ); |
|
416 |
|
417 if ( stat.Int() != KErrNone || res != KErrNone || currentPersonalityId != aNewPersonalityId ) |
|
418 return ETestCaseFailed; |
|
419 |
|
420 return ETestCasePassed; |
|
421 } |
|
422 |
|
423 TUsbWatcherTestResult CUsbWatcherTest::CancelSetPersonalityTest( TInt aNewPersonalityId, TBool aCableConnected ) |
|
424 { |
|
425 TRequestStatus stat; |
|
426 TInt previousPersonalityId; |
|
427 TInt currentPersonalityId; |
|
428 TInt res; |
|
429 |
|
430 res = iCenRep -> Get( KUsbWatcherPersonality, previousPersonalityId ); |
|
431 TRACE_INFO("GetCurrentPersonalityId value: %d, expected %d", res, KErrNone ); |
|
432 TRACE_INFO("Original personality ID: %d", previousPersonalityId ); |
|
433 if ( res != KErrNone ) |
|
434 return ETestCaseFailed; |
|
435 |
|
436 TRACE( "Checking test results:" ); |
|
437 |
|
438 if ( aCableConnected ) |
|
439 { |
|
440 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetDeviceState, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) ); |
|
441 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetDeviceState, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) ); |
|
442 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EDeviceStateNotification, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) ); |
|
443 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EDeviceStateNotification, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) ); |
|
444 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStopAsync, 0, 0, _L8( "stub" ) ) ); |
|
445 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) ); |
|
446 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetPersonalityProperty, 0, 0, _L8( "stub" ) ) ); |
|
447 } |
|
448 |
|
449 |
|
450 TRACE( " >SetPersonality" ); |
|
451 iWatcher -> SetPersonality( stat, aNewPersonalityId, EFalse, EFalse ); |
|
452 TRACE( " >CancelSetPersonality" ); |
|
453 iWatcher -> CancelSetPersonality(); |
|
454 User::WaitForRequest( stat ); |
|
455 TRACE( " <CancelSetPersonality" ); |
|
456 TRACE_INFO("Cancel set personality request status: %d", stat.Int() ); |
|
457 |
|
458 res = iCenRep -> Get( KUsbWatcherPersonality, currentPersonalityId ); |
|
459 TRACE_INFO("GetCurrentPersonalityId value: %d, expected %d", res, KErrNone ); |
|
460 TRACE_INFO("Current personality ID: %d", currentPersonalityId ); |
|
461 |
|
462 if ( aCableConnected ) |
|
463 { |
|
464 if ( stat.Int() != KErrCancel || res != KErrNone || currentPersonalityId != previousPersonalityId ) |
|
465 return ETestCaseFailed; |
|
466 } |
|
467 else |
|
468 { |
|
469 if ( stat.Int() != KErrNone || res != KErrNone || currentPersonalityId != aNewPersonalityId ) |
|
470 return ETestCaseFailed; |
|
471 } |
|
472 |
|
473 return ETestCasePassed; |
|
474 } |
|
475 |
|
476 TUsbWatcherTestResult CUsbWatcherTest::SetPreviousPersonalityTest( TInt aNewPersonalityId, TBool aCableConnected ) |
|
477 { |
|
478 TRequestStatus stat; |
|
479 TInt previousPersonalityId; |
|
480 TInt currentPersonalityId; |
|
481 TInt res; |
|
482 |
|
483 res = iCenRep -> Get( KUsbWatcherPersonality, previousPersonalityId ); |
|
484 TRACE_INFO("GetCurrentPersonalityId value: %d, expected %d", res, KErrNone ); |
|
485 TRACE_INFO("Original personality ID: %d", previousPersonalityId ); |
|
486 if ( res != KErrNone ) |
|
487 return ETestCaseFailed; |
|
488 |
|
489 TRACE( " >SetPersonality" ); |
|
490 |
|
491 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetDeviceState, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) ); |
|
492 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EDeviceStateNotification, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) ); |
|
493 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStopAsync, 0, 0, _L8( "stub" ) ) ); |
|
494 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) ); |
|
495 |
|
496 iWatcher -> SetPersonality( stat, aNewPersonalityId, EFalse, EFalse ); |
|
497 User::WaitForRequest( stat ); |
|
498 TRACE( " <SetPersonality" ); |
|
499 TRACE_INFO("Set personality request status: %d, expected %d", stat.Int(), KErrNone ); |
|
500 |
|
501 res = iCenRep -> Get( KUsbWatcherPersonality, currentPersonalityId ); |
|
502 TRACE_INFO("GetCurrentPersonalityId value: %d, expected %d", res, KErrNone ); |
|
503 TRACE_INFO("Current personality ID: %d, expected: %d", currentPersonalityId, aNewPersonalityId ); |
|
504 |
|
505 if ( stat.Int() != KErrNone || res != KErrNone || currentPersonalityId != aNewPersonalityId ) |
|
506 return ETestCaseFailed; |
|
507 |
|
508 TRACE( "Checking test results:" ); |
|
509 |
|
510 if ( aCableConnected ) |
|
511 { |
|
512 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetDeviceState, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) ); |
|
513 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EDeviceStateNotification, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) ); |
|
514 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStopAsync, 0, 0, _L8( "stub" ) ) ); |
|
515 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) ); |
|
516 } |
|
517 |
|
518 TRACE( " >SetPreviousPersonality" ); |
|
519 iWatcher -> SetPreviousPersonality( stat ); |
|
520 User::WaitForRequest( stat ); |
|
521 TRACE( " <SetPreviousPersonality" ); |
|
522 TRACE_INFO("Set previous personality request status: %d, expected %d", stat.Int(), KErrNone ); |
|
523 |
|
524 res = iCenRep -> Get( KUsbWatcherPersonality, currentPersonalityId ); |
|
525 TRACE_INFO("GetCurrentPersonalityId value: %d, expected %d", res, KErrNone ); |
|
526 TRACE_INFO("Current personality ID: %d, expected: %d", currentPersonalityId, previousPersonalityId ); |
|
527 |
|
528 if ( stat.Int() != KErrNone || res != KErrNone || currentPersonalityId != previousPersonalityId ) |
|
529 return ETestCaseFailed; |
|
530 |
|
531 return ETestCasePassed; |
|
532 } |
|
533 |
|
534 TUsbWatcherTestResult CUsbWatcherTest::SetPreviousPersonalityOnDiscTest( TInt aNewPersonalityId, TBool aCableConnected ) |
|
535 { |
|
536 TRequestStatus stat; |
|
537 TInt previousPersonalityId; |
|
538 TInt currentPersonalityId; |
|
539 TInt res; |
|
540 |
|
541 res = iCenRep -> Get( KUsbWatcherPersonality, previousPersonalityId ); |
|
542 TRACE_INFO("GetCurrentPersonalityId value: %d, expected %d", res, KErrNone ); |
|
543 TRACE_INFO("Original personality ID: %d", previousPersonalityId ); |
|
544 if ( res != KErrNone ) |
|
545 return ETestCaseFailed; |
|
546 |
|
547 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetDeviceState, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) ); |
|
548 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EDeviceStateNotification, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) ); |
|
549 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStopAsync, 0, 0, _L8( "stub" ) ) ); |
|
550 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) ); |
|
551 |
|
552 TRACE( " >SetPersonality" ); |
|
553 iWatcher -> SetPersonality( stat, aNewPersonalityId, EFalse, EFalse ); |
|
554 User::WaitForRequest( stat ); |
|
555 TRACE( " <SetPersonality" ); |
|
556 TRACE_INFO("Set personality request status: %d, expected %d", stat.Int(), KErrNone ); |
|
557 |
|
558 if ( aCableConnected ) |
|
559 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetDeviceState, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) ); |
|
560 |
|
561 TRACE( " >SetPreviousPersonalityOnDisconnect" ); |
|
562 iWatcher -> SetPreviousPersonalityOnDisconnect(); |
|
563 TRACE( " <SetPreviousPersonalityOnDisconnect" ); |
|
564 |
|
565 // disconnect cable here |
|
566 |
|
567 TRACE( "Checking test results:" ); |
|
568 |
|
569 res = iCenRep -> Get( KUsbWatcherPersonality, currentPersonalityId ); |
|
570 TRACE_INFO("GetCurrentPersonalityId value: %d, expected %d", res, KErrNone ); |
|
571 TRACE_INFO("Current personality ID: %d, expected: %d", currentPersonalityId, aNewPersonalityId ); |
|
572 |
|
573 if ( stat.Int() != KErrNone || res != KErrNone || currentPersonalityId != aNewPersonalityId ) |
|
574 return ETestCaseFailed; |
|
575 |
|
576 return ETestCasePassed; |
|
577 } |
|
578 |
|
579 TUsbWatcherTestResult CUsbWatcherTest::SetPreviousPersonalitySyncTest( TInt aNewPersonalityId, TBool aCableConnected ) |
|
580 { |
|
581 TRequestStatus stat; |
|
582 TInt previousPersonalityId; |
|
583 TInt currentPersonalityId; |
|
584 TInt res; |
|
585 |
|
586 res = iCenRep -> Get( KUsbWatcherPersonality, previousPersonalityId ); |
|
587 TRACE_INFO("GetCurrentPersonalityId value: %d, expected %d", res, KErrNone ); |
|
588 TRACE_INFO("Original personality ID: %d", previousPersonalityId ); |
|
589 if ( res != KErrNone ) |
|
590 return ETestCaseFailed; |
|
591 |
|
592 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetDeviceState, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) ); |
|
593 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStopAsync, 0, 0, _L8( "stub" ) ) ); |
|
594 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) ); |
|
595 |
|
596 TRACE( " >SetPersonality" ); |
|
597 iWatcher -> SetPersonality( stat, aNewPersonalityId, EFalse, EFalse ); |
|
598 User::WaitForRequest( stat ); |
|
599 TRACE( " <SetPersonality" ); |
|
600 TRACE_INFO("Set personality request status: %d, expected %d", stat.Int(), KErrNone ); |
|
601 |
|
602 res = iCenRep -> Get( KUsbWatcherPersonality, currentPersonalityId ); |
|
603 TRACE_INFO("GetCurrentPersonalityId value: %d, expected %d", res, KErrNone ); |
|
604 TRACE_INFO("Current personality ID: %d, expected: %d", currentPersonalityId, aNewPersonalityId ); |
|
605 |
|
606 if ( stat.Int() != KErrNone || res != KErrNone || currentPersonalityId != aNewPersonalityId ) |
|
607 return ETestCaseFailed; |
|
608 |
|
609 TRACE( "Checking test results:" ); |
|
610 |
|
611 if ( aCableConnected ) |
|
612 { |
|
613 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetDeviceState, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) ); |
|
614 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStopAsync, 0, 0, _L8( "stub" ) ) ); |
|
615 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) ); |
|
616 } |
|
617 |
|
618 TRACE( " >SetPreviousPersonality" ); |
|
619 iWatcher -> SetPreviousPersonality(); |
|
620 TRACE( " <SetPreviousPersonality" ); |
|
621 TRACE("Set previous personality sync invoked" ); |
|
622 |
|
623 User::After( 10*1000*1000 ); |
|
624 |
|
625 res = iCenRep -> Get( KUsbWatcherPersonality, currentPersonalityId ); |
|
626 TRACE_INFO("GetCurrentPersonalityId value: %d, expected %d", res, KErrNone ); |
|
627 TRACE_INFO("Current personality ID: %d, expected: %d", currentPersonalityId, previousPersonalityId ); |
|
628 |
|
629 if ( res != KErrNone || currentPersonalityId != previousPersonalityId ) |
|
630 return ETestCaseFailed; |
|
631 |
|
632 return ETestCasePassed; |
|
633 } |
|
634 |
|
635 TUsbWatcherTestResult CUsbWatcherTest::CancelSetPreviousPersonalityTest( TInt aNewPersonalityId, TBool aCableConnected ) |
|
636 { |
|
637 TRequestStatus stat; |
|
638 TInt previousPersonalityId; |
|
639 TInt currentPersonalityId; |
|
640 TInt res; |
|
641 |
|
642 res = iCenRep -> Get( KUsbWatcherPersonality, previousPersonalityId ); |
|
643 TRACE_INFO("GetCurrentPersonalityId value: %d, expected %d", res, KErrNone ); |
|
644 TRACE_INFO("Original personality ID: %d", previousPersonalityId ); |
|
645 if ( res != KErrNone ) |
|
646 return ETestCaseFailed; |
|
647 |
|
648 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetDeviceState, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) ); |
|
649 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStopAsync, 0, 0, _L8( "stub" ) ) ); |
|
650 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) ); |
|
651 |
|
652 TRACE( " >SetPersonality" ); |
|
653 iWatcher -> SetPersonality( stat, aNewPersonalityId, EFalse, EFalse ); |
|
654 User::WaitForRequest( stat ); |
|
655 TRACE( " <SetPersonality" ); |
|
656 TRACE_INFO("Set personality request status: %d, expected %d", stat.Int(), KErrNone ); |
|
657 |
|
658 res = iCenRep -> Get( KUsbWatcherPersonality, currentPersonalityId ); |
|
659 TRACE_INFO("GetCurrentPersonalityId value: %d, expected %d", res, KErrNone ); |
|
660 TRACE_INFO("Current personality ID: %d, expected: %d", currentPersonalityId, aNewPersonalityId ); |
|
661 |
|
662 if ( stat.Int() != KErrNone || res != KErrNone || currentPersonalityId != aNewPersonalityId ) |
|
663 return ETestCaseFailed; |
|
664 |
|
665 TRACE( "Checking test results:" ); |
|
666 |
|
667 if ( aCableConnected ) |
|
668 { |
|
669 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetDeviceState, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) ); |
|
670 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetDeviceState, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) ); |
|
671 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStopAsync, 0, 0, _L8( "stub" ) ) ); |
|
672 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) ); |
|
673 } |
|
674 |
|
675 TRACE( " >SetPreviousPersonality" ); |
|
676 iWatcher -> SetPreviousPersonality( stat ); |
|
677 TRACE( " >CancelSetPreviousPersonality" ); |
|
678 iWatcher -> CancelSetPreviousPersonality(); |
|
679 User::WaitForRequest( stat ); |
|
680 TRACE( " <CancelSetPreviousPersonality" ); |
|
681 TRACE_INFO("Cancel set previous personality request status: %d", stat.Int() ); |
|
682 |
|
683 res = iCenRep -> Get( KUsbWatcherPersonality, currentPersonalityId ); |
|
684 TRACE_INFO("GetCurrentPersonalityId value: %d, expected %d", res, KErrNone ); |
|
685 TRACE_INFO("Current personality ID: %d", currentPersonalityId ); |
|
686 |
|
687 if ( aCableConnected ) |
|
688 { |
|
689 if ( stat.Int() != KErrCancel || res != KErrNone || currentPersonalityId != aNewPersonalityId ) |
|
690 return ETestCaseFailed; |
|
691 } |
|
692 else |
|
693 { |
|
694 if ( stat.Int() != KErrNone || res != KErrNone || currentPersonalityId != previousPersonalityId ) |
|
695 return ETestCaseFailed; |
|
696 } |
|
697 |
|
698 |
|
699 return ETestCasePassed; |
|
700 } |
|
701 |
|
702 TUsbWatcherTestResult CUsbWatcherTest::SetUnknownPersonalityTest() |
|
703 { |
|
704 TRequestStatus stat; |
|
705 TInt unknownPersonalityId = 0xFFFF; |
|
706 |
|
707 TRACE( "Checking test results:" ); |
|
708 |
|
709 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetDeviceState, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) ); |
|
710 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStopAsync, 0, 0, _L8( "stub" ) ) ); |
|
711 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) ); |
|
712 |
|
713 TRACE( " >SetPersonality" ); |
|
714 iWatcher -> SetPersonality( stat, unknownPersonalityId, EFalse, EFalse ); |
|
715 User::WaitForRequest( stat ); |
|
716 TRACE( " <SetPersonality" ); |
|
717 TRACE_INFO("Set personality request status: %d, expected %d", stat.Int(), KErrNotFound ); |
|
718 |
|
719 if ( stat.Int() != KErrNotFound ) |
|
720 return ETestCaseFailed; |
|
721 |
|
722 return ETestCasePassed; |
|
723 } |
|
724 |
|
725 TUsbWatcherTestResult CUsbWatcherTest::InterruptPersonalitySetTest( TInt aNewPersonalityId ) |
|
726 { |
|
727 TRequestStatus stat; |
|
728 TRequestStatus secondStat; |
|
729 TInt previousPersonalityId; |
|
730 TInt currentPersonalityId; |
|
731 TInt res; |
|
732 |
|
733 res = iCenRep -> Get( KUsbWatcherPersonality, previousPersonalityId ); |
|
734 TRACE_INFO("GetCurrentPersonalityId value: %d, expected %d", res, KErrNone ); |
|
735 TRACE_INFO("Original personality ID: %d", previousPersonalityId ); |
|
736 if ( res != KErrNone ) |
|
737 return ETestCaseFailed; |
|
738 |
|
739 TRACE( "Checking test results:" ); |
|
740 |
|
741 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetDeviceState, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) ); |
|
742 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStopAsync, 0, 0, _L8( "stub" ) ) ); |
|
743 |
|
744 TRACE( " >SetPersonality" ); |
|
745 iWatcher -> SetPersonality( stat, aNewPersonalityId, EFalse, EFalse ); |
|
746 TRACE( " >SetPersonality" ); |
|
747 iWatcher -> SetPersonality( secondStat, previousPersonalityId, EFalse, EFalse ); |
|
748 User::WaitForRequest( stat ); |
|
749 TRACE( " <SetPersonality" ); |
|
750 User::WaitForRequest( secondStat ); |
|
751 TRACE( " <SetPersonality" ); |
|
752 |
|
753 TRACE_INFO("Set personality request status: %d, expected %d", stat.Int(), KErrNone ); |
|
754 TRACE_INFO("Interrupt set personality request status: %d, expected %d", secondStat.Int(), KErrNone ); |
|
755 |
|
756 res = iCenRep -> Get( KUsbWatcherPersonality, currentPersonalityId ); |
|
757 TRACE_INFO("GetCurrentPersonalityId value: %d, expected %d", res, KErrNone ); |
|
758 TRACE_INFO("Current personality ID: %d, expected: %d", currentPersonalityId, previousPersonalityId ); |
|
759 |
|
760 if ( stat.Int() != KErrNone || secondStat.Int() != KErrNone || res != KErrNone || currentPersonalityId != previousPersonalityId ) |
|
761 return ETestCaseFailed; |
|
762 |
|
763 return ETestCasePassed; |
|
764 } |
|
765 |
|
766 TInt CUsbWatcherTest::GetPersonalityIdFromString( TPtrC& aUsbPersonalityName, TInt& aUsbPersonalityId ) |
|
767 { |
|
768 if ( !aUsbPersonalityName.Compare( _L( "PCSUITE" ) ) ) |
|
769 { |
|
770 TRACE( "Test personality ID setting: PCSUITE" ); |
|
771 aUsbPersonalityId = KUsbPersonalityIdPCSuiteMTP; |
|
772 } |
|
773 else if ( !aUsbPersonalityName.Compare( _L( "MS" ) ) ) |
|
774 { |
|
775 TRACE( "Test personality ID setting: MS" ); |
|
776 aUsbPersonalityId = KUsbPersonalityIdMS; |
|
777 } |
|
778 else if ( !aUsbPersonalityName.Compare( _L( "PTP" ) ) ) |
|
779 { |
|
780 TRACE( "Test personality ID setting: PTP" ); |
|
781 aUsbPersonalityId = KUsbPersonalityIdPTP; |
|
782 } |
|
783 else if ( !aUsbPersonalityName.Compare( _L( "MTP" ) ) ) |
|
784 { |
|
785 TRACE( "Test personality ID setting: MTP" ); |
|
786 aUsbPersonalityId = KUsbPersonalityIdMTP; |
|
787 } |
|
788 else if ( !aUsbPersonalityName.Compare( _L( "Modem" ) ) ) |
|
789 { |
|
790 TRACE( "Test personality ID setting: Modem" ); |
|
791 aUsbPersonalityId = KUsbPersonalityIdModemInst; |
|
792 } |
|
793 else |
|
794 { |
|
795 TRACE( "Test personality ID setting: not supported" ); |
|
796 return KErrNotFound; |
|
797 } |
|
798 |
|
799 return KErrNone; |
|
800 } |
|
801 |
|
802 // ----------------------------------------------------------------------------- |
|
803 // CUSBWatcherTest::PersonalitySwitchTest |
|
804 // ----------------------------------------------------------------------------- |
|
805 |
|
806 void CUsbWatcherTest::PersonalitySwitchTestL( TUsbWatcherTestBlockParams& aParams, |
|
807 TUsbWatcherTestResult& aTestResult ) |
|
808 { |
|
809 TInt res; |
|
810 TRequestStatus stat; |
|
811 TPtrC testOptionName( aParams.iTestOption1 ); |
|
812 TInt currentPersonalityId; |
|
813 |
|
814 res = iUsbMan -> GetCurrentPersonalityId( currentPersonalityId ); |
|
815 if ( res != KErrNone ) |
|
816 { |
|
817 TRACE_INFO( "GetCurrentPersonalityId failed with value: %d" , res ); |
|
818 User::Leave( res ); |
|
819 } |
|
820 |
|
821 TRACE( " >Connect" ); |
|
822 res = iWatcher -> Connect(); |
|
823 TRACE( " <Connect" ); |
|
824 TRACE_INFO( "USB watcher connection value: %d, expected: %d" , res, KErrNone ); |
|
825 User::LeaveIfError( res ); |
|
826 |
|
827 if ( currentPersonalityId != KUsbPersonalityIdPCSuiteMTP ) |
|
828 { |
|
829 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetDeviceState, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) ); |
|
830 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStopAsync, 0, 0, _L8( "stub" ) ) ); |
|
831 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) ); |
|
832 } |
|
833 |
|
834 TRACE( " >SetPersonality" ); |
|
835 iWatcher -> SetPersonality( stat, KUsbPersonalityIdPCSuiteMTP, EFalse, EFalse ); |
|
836 User::WaitForRequest( stat ); |
|
837 TRACE( " <SetPersonality" ); |
|
838 |
|
839 TRACE_INFO( "Set initial test personality value: %d" , stat.Int() ); |
|
840 User::LeaveIfError( stat.Int() ); |
|
841 |
|
842 if ( !testOptionName.Compare( _L( "FAST_SWITCH" ) ) ) |
|
843 { |
|
844 TRACE( "Test option: FAST_SWITCH" ); |
|
845 aTestResult = FastPersonalitySwitchTest(); |
|
846 } |
|
847 else if ( !testOptionName.Compare( _L( "DELAYED_SWITCH" ) ) ) |
|
848 { |
|
849 TRACE( "Test option: DELAYED_SWITCH" ); |
|
850 aTestResult = DelayedPersonalitySwitchTest(); |
|
851 } |
|
852 else |
|
853 { |
|
854 TRACE( "Test option: not supported" ); |
|
855 User::Leave(KErrNotFound); |
|
856 } |
|
857 |
|
858 } |
|
859 |
|
860 TUsbWatcherTestResult CUsbWatcherTest::FastPersonalitySwitchTest() |
|
861 { |
|
862 TInt res; |
|
863 TInt testLoopCounter = 3; |
|
864 TInt numberOfPersonalities = 4; |
|
865 TInt currentPersonalityId; |
|
866 TInt setPersonalityId; |
|
867 TRequestStatus stat; |
|
868 |
|
869 TRACE( "Checking test results:" ); |
|
870 |
|
871 for ( int i = 0; i< testLoopCounter; i++ ) |
|
872 { |
|
873 currentPersonalityId = KUsbPersonalityIdMS; |
|
874 for ( int j = 0; j< numberOfPersonalities; j++ ) |
|
875 { |
|
876 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetDeviceState, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) ); |
|
877 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStopAsync, 0, 0, _L8( "stub" ) ) ); |
|
878 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) ); |
|
879 |
|
880 TRACE( " >SetPersonality" ); |
|
881 iWatcher -> SetPersonality( stat, currentPersonalityId, EFalse, EFalse ); |
|
882 User::WaitForRequest( stat ); |
|
883 TRACE( " <SetPersonality" ); |
|
884 |
|
885 res = iCenRep -> Get( KUsbWatcherPersonality, setPersonalityId ); |
|
886 TRACE_INFO("Set personality request status: %d, expected %d", stat.Int(), KErrNone ); |
|
887 TRACE_INFO("GetCurrentPersonalityId value: %d, expected %d", res, KErrNone ); |
|
888 TRACE_INFO("Current personality ID: %d, expected: %d", currentPersonalityId, setPersonalityId ); |
|
889 if ( stat.Int() != KErrNone || res != KErrNone || currentPersonalityId != setPersonalityId ) |
|
890 return ETestCaseFailed; |
|
891 currentPersonalityId++; |
|
892 } |
|
893 } |
|
894 return ETestCasePassed; |
|
895 } |
|
896 |
|
897 TUsbWatcherTestResult CUsbWatcherTest::DelayedPersonalitySwitchTest() |
|
898 { |
|
899 TInt res; |
|
900 TInt numberOfPersonalities = 4; |
|
901 TInt currentPersonalityId; |
|
902 TInt setPersonalityId; |
|
903 TRequestStatus stat; |
|
904 |
|
905 TRACE( "Checking test results:" ); |
|
906 currentPersonalityId = KUsbPersonalityIdMS; |
|
907 |
|
908 for ( int j = 0; j< numberOfPersonalities; j++ ) |
|
909 { |
|
910 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetDeviceState, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) ); |
|
911 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStopAsync, 0, 0, _L8( "stub" ) ) ); |
|
912 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) ); |
|
913 |
|
914 TRACE( " >SetPersonality" ); |
|
915 iWatcher -> SetPersonality( stat, currentPersonalityId, EFalse, EFalse ); |
|
916 User::WaitForRequest( stat ); |
|
917 TRACE( " <SetPersonality" ); |
|
918 |
|
919 res = iCenRep -> Get( KUsbWatcherPersonality, setPersonalityId ); |
|
920 TRACE_INFO("Set personality request status: %d, expected %d", stat.Int(), KErrNone ); |
|
921 TRACE_INFO("GetCurrentPersonalityId value: %d, expected %d", res, KErrNone ); |
|
922 TRACE_INFO("Current personality ID: %d, expected: %d", currentPersonalityId, setPersonalityId ); |
|
923 if ( stat.Int() != KErrNone || res != KErrNone || currentPersonalityId != setPersonalityId ) |
|
924 return ETestCaseFailed; |
|
925 currentPersonalityId++; |
|
926 User::After( 7000*1000 ); |
|
927 } |
|
928 return ETestCasePassed; |
|
929 } |
|
930 |
|
931 // ----------------------------------------------------------------------------- |
|
932 // CUSBWatcherTest::BranchTest |
|
933 // ----------------------------------------------------------------------------- |
|
934 |
|
935 void CUsbWatcherTest::BranchTestL( TUsbWatcherTestBlockParams& aParams, |
|
936 TUsbWatcherTestResult& aTestResult ) |
|
937 { |
|
938 TInt res; |
|
939 TRequestStatus stat; |
|
940 TPtrC testOptionName( aParams.iTestOption1 ); |
|
941 TInt currentPersonalityId; |
|
942 |
|
943 res = iUsbMan -> GetCurrentPersonalityId( currentPersonalityId ); |
|
944 if ( res != KErrNone ) |
|
945 { |
|
946 TRACE_INFO( "GetCurrentPersonalityId failed with value: %d", res ); |
|
947 User::Leave( res ); |
|
948 } |
|
949 |
|
950 TRACE( " >Connect" ); |
|
951 res = iWatcher -> Connect(); |
|
952 TRACE( " <Connect" ); |
|
953 TRACE_INFO( "USB watcher connection value: %d, expected: %d", res, KErrNone ); |
|
954 User::LeaveIfError( res ); |
|
955 |
|
956 if ( currentPersonalityId != KUsbPersonalityIdPCSuiteMTP ) |
|
957 { |
|
958 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetDeviceState, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) ); |
|
959 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStopAsync, 0, 0, _L8( "stub" ) ) ); |
|
960 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) ); |
|
961 } |
|
962 |
|
963 TRACE( "Initial SetPersonality" ); |
|
964 |
|
965 TRACE( " >SetPersonality" ); |
|
966 iWatcher -> SetPersonality( stat, KUsbPersonalityIdPCSuiteMTP, EFalse, EFalse ); |
|
967 User::WaitForRequest( stat ); |
|
968 TRACE( " <SetPersonality" ); |
|
969 |
|
970 TRACE_INFO( "Set initial test personality value: %d", stat.Int() ); |
|
971 User::LeaveIfError( stat.Int() ); |
|
972 |
|
973 if ( !testOptionName.Compare( _L( "SAME_PERSONALITY_SET" ) ) ) |
|
974 { |
|
975 TRACE( "Test option: SAME_PERSONALITY_SET" ); |
|
976 aTestResult = SetSamePersonalityTest(); |
|
977 } |
|
978 else if ( !testOptionName.Compare( _L( "NON_BLOCKING" ) ) ) |
|
979 { |
|
980 TRACE( "Test option: NON_BLOCKING" ); |
|
981 aTestResult = SetPersonalityBlockingOn(); |
|
982 } |
|
983 else if ( !testOptionName.Compare( _L( "FORCE_SWITCH" ) ) ) |
|
984 { |
|
985 TRACE( "Test option: FORCE_SWITCH" ); |
|
986 aTestResult = SetPersonalityAskOnConnectionOff(); |
|
987 } |
|
988 else |
|
989 { |
|
990 TRACE( "Test option: not supported" ); |
|
991 User::Leave( KErrNotFound ); |
|
992 } |
|
993 } |
|
994 |
|
995 TUsbWatcherTestResult CUsbWatcherTest::SetSamePersonalityTest() |
|
996 { |
|
997 TRequestStatus stat; |
|
998 TInt currentPersonalityId; |
|
999 TInt res; |
|
1000 |
|
1001 TRACE( "Checking test results:" ); |
|
1002 |
|
1003 TRACE( " >SetPersonality" ); |
|
1004 iWatcher -> SetPersonality( stat, KUsbPersonalityIdPCSuiteMTP, EFalse, EFalse ); |
|
1005 User::WaitForRequest( stat ); |
|
1006 TRACE( " <SetPersonality" ); |
|
1007 TRACE_INFO("Set personality request status: %d, expected %d", stat.Int(), KErrNone ); |
|
1008 |
|
1009 res = iCenRep -> Get( KUsbWatcherPersonality, currentPersonalityId ); |
|
1010 TRACE_INFO("GetCurrentPersonalityId value: %d, expected %d", res, KErrNone ); |
|
1011 TRACE_INFO("Current personality ID: %d, expected: %d", currentPersonalityId, KUsbPersonalityIdPCSuiteMTP ); |
|
1012 |
|
1013 if ( stat.Int() != KErrNone || res != KErrNone || currentPersonalityId != KUsbPersonalityIdPCSuiteMTP ) |
|
1014 return ETestCaseFailed; |
|
1015 |
|
1016 return ETestCasePassed; |
|
1017 } |
|
1018 |
|
1019 TUsbWatcherTestResult CUsbWatcherTest::SetPersonalityBlockingOn() |
|
1020 { |
|
1021 TRequestStatus stat; |
|
1022 TInt currentPersonalityId; |
|
1023 TInt res; |
|
1024 |
|
1025 TRACE( "Checking test results:" ); |
|
1026 |
|
1027 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetDeviceState, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) ); |
|
1028 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStopAsync, 0, 0, _L8( "stub" ) ) ); |
|
1029 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) ); |
|
1030 |
|
1031 TRACE( " >SetPersonality" ); |
|
1032 iWatcher -> SetPersonality( stat, KUsbPersonalityIdMS, EFalse, ETrue ); |
|
1033 User::WaitForRequest( stat ); |
|
1034 TRACE( " <SetPersonality" ); |
|
1035 TRACE_INFO("Set personality request status: %d, expected %d", stat.Int(), KErrNone ); |
|
1036 |
|
1037 res = iCenRep -> Get( KUsbWatcherPersonality, currentPersonalityId ); |
|
1038 TRACE_INFO("GetCurrentPersonalityId value: %d, expected %d", res, KErrNone ); |
|
1039 TRACE_INFO("Current personality ID: %d, expected: %d", currentPersonalityId, KUsbPersonalityIdMS ); |
|
1040 |
|
1041 if ( stat.Int() != KErrNone || res != KErrNone || currentPersonalityId != KUsbPersonalityIdMS ) |
|
1042 return ETestCaseFailed; |
|
1043 |
|
1044 return ETestCasePassed; |
|
1045 } |
|
1046 |
|
1047 TUsbWatcherTestResult CUsbWatcherTest::SetPersonalityAskOnConnectionOff() |
|
1048 { |
|
1049 TRequestStatus stat; |
|
1050 TInt currentPersonalityId; |
|
1051 TInt res; |
|
1052 |
|
1053 TRACE( "Checking test results:" ); |
|
1054 |
|
1055 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetDeviceState, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) ); |
|
1056 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStopAsync, 0, 0, _L8( "stub" ) ) ); |
|
1057 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) ); |
|
1058 |
|
1059 TRACE( " >SetPersonality" ); |
|
1060 iWatcher -> SetPersonality( stat, KUsbPersonalityIdMS, ETrue, EFalse ); |
|
1061 User::WaitForRequest( stat ); |
|
1062 TRACE( " <SetPersonality" ); |
|
1063 TRACE_INFO("Set personality request status: %d, expected %d", stat.Int(), KErrNone ); |
|
1064 |
|
1065 res = iCenRep -> Get( KUsbWatcherPersonality, currentPersonalityId ); |
|
1066 TRACE_INFO("GetCurrentPersonalityId value: %d, expected %d", res, KErrNone ); |
|
1067 TRACE_INFO("Current personality ID: %d, expected: %d", currentPersonalityId, KUsbPersonalityIdMS ); |
|
1068 |
|
1069 if ( stat.Int() != KErrNone || res != KErrNone || currentPersonalityId != KUsbPersonalityIdMS ) |
|
1070 return ETestCaseFailed; |
|
1071 |
|
1072 return ETestCasePassed; |
|
1073 } |
|
1074 |
|
1075 // ----------------------------------------------------------------------------- |
|
1076 // CUSBWatcherTest:: Other functions |
|
1077 // ----------------------------------------------------------------------------- |
|
1078 |
|
1079 TInt CUsbWatcherTest::BackupPersonalitySetting() |
|
1080 { |
|
1081 TRACE( "><Backup personality setting" ) |
|
1082 return iUsbMan -> GetCurrentPersonalityId( iPersonalityIdBackup ); |
|
1083 } |
|
1084 |
|
1085 TInt CUsbWatcherTest::RestorePersonalitySetting() |
|
1086 { |
|
1087 TRequestStatus stat; |
|
1088 TInt currentPersonalityId; |
|
1089 |
|
1090 TRACE( ">Restore personality setting" ) |
|
1091 TRACE( " >Close" ); |
|
1092 iWatcher -> Close(); |
|
1093 TRACE( " <Close" ); |
|
1094 |
|
1095 iUsbMan -> GetCurrentPersonalityId( currentPersonalityId ); |
|
1096 if ( currentPersonalityId != iPersonalityIdBackup ) |
|
1097 { |
|
1098 TRACE( " >Connect" ); |
|
1099 iWatcher -> Connect(); |
|
1100 TRACE( " <Connect" ); |
|
1101 |
|
1102 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, EGetDeviceState, 0, 0, _L8( "EUsbDeviceStateConfigured" ) ) ); |
|
1103 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStopAsync, 0, 0, _L8( "stub" ) ) ); |
|
1104 iStubber -> EnqueBehavior( TApiBehavior( KUsbManStubAgentDll, ETryStartAsync, 0, 0, _L8( "stub" ) ) ); |
|
1105 |
|
1106 TRACE( " >SetPersonality" ); |
|
1107 iWatcher -> SetPersonality( stat, iPersonalityIdBackup, EFalse, EFalse ); |
|
1108 User::WaitForRequest( stat ); |
|
1109 TRACE( " <SetPersonality" ); |
|
1110 |
|
1111 TRACE( " >Close" ); |
|
1112 iWatcher -> Close(); |
|
1113 TRACE( " <Close" ); |
|
1114 } |
|
1115 |
|
1116 TRACE( "<Restore personality setting" ) |
|
1117 return stat.Int(); |
|
1118 } |
|
1119 |
|
1120 |
|
1121 |
|
1122 |
|
1123 // ========================== OTHER EXPORTED FUNCTIONS ========================= |
|
1124 // None |
|
1125 |
|
1126 // [End of File] - Do not remove |
|