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